_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q14600 | ActivityNotification.ViewHelpers.subscribe_subscription_url_for | train | def subscribe_subscription_url_for(subscription, params = {})
options = params.dup
options.delete(:devise_default_routes) ?
send("subscribe_#{routing_scope(options)}subscription_url", subscription, options) :
send("subscribe_#{routing_scope(options)}#{subscription.target.to_resource_name}_subscription_url", subscription.target, subscription, options)
end | ruby | {
"resource": ""
} |
q14601 | ActivityNotification.ViewHelpers.unsubscribe_subscription_url_for | train | def unsubscribe_subscription_url_for(subscription, params = {})
options = params.dup
options.delete(:devise_default_routes) ?
send("unsubscribe_#{routing_scope(options)}subscription_url", subscription, options) :
send("unsubscribe_#{routing_scope(options)}#{subscription.target.to_resource_name}_subscription_url", subscription.target, subscription, options)
end | ruby | {
"resource": ""
} |
q14602 | ActivityNotification.ViewHelpers.subscribe_to_email_subscription_url_for | train | def subscribe_to_email_subscription_url_for(subscription, params = {})
options = params.dup
options.delete(:devise_default_routes) ?
send("subscribe_to_email_#{routing_scope(options)}subscription_url", subscription, options) :
send("subscribe_to_email_#{routing_scope(options)}#{subscription.target.to_resource_name}_subscription_url", subscription.target, subscription, options)
end | ruby | {
"resource": ""
} |
q14603 | ActivityNotification.ViewHelpers.unsubscribe_to_email_subscription_url_for | train | def unsubscribe_to_email_subscription_url_for(subscription, params = {})
options = params.dup
options.delete(:devise_default_routes) ?
send("unsubscribe_to_email_#{routing_scope(options)}subscription_url", subscription, options) :
send("unsubscribe_to_email_#{routing_scope(options)}#{subscription.target.to_resource_name}_subscription_url", subscription.target, subscription, options)
end | ruby | {
"resource": ""
} |
q14604 | ActivityNotification.ViewHelpers.subscribe_to_optional_target_subscription_url_for | train | def subscribe_to_optional_target_subscription_url_for(subscription, params = {})
options = params.dup
options.delete(:devise_default_routes) ?
send("subscribe_to_optional_target_#{routing_scope(options)}subscription_url", subscription, options) :
send("subscribe_to_optional_target_#{routing_scope(options)}#{subscription.target.to_resource_name}_subscription_url", subscription.target, subscription, options)
end | ruby | {
"resource": ""
} |
q14605 | ActivityNotification.ViewHelpers.unsubscribe_to_optional_target_subscription_url_for | train | def unsubscribe_to_optional_target_subscription_url_for(subscription, params = {})
options = params.dup
options.delete(:devise_default_routes) ?
send("unsubscribe_to_optional_target_#{routing_scope(options)}subscription_url", subscription, options) :
send("unsubscribe_to_optional_target_#{routing_scope(options)}#{subscription.target.to_resource_name}_subscription_url", subscription.target, subscription, options)
end | ruby | {
"resource": ""
} |
q14606 | ActivityNotification.CommonController.target_view_path | train | def target_view_path
target_type = @target.to_resources_name
view_path = [controller_path, target_type].join('/')
lookup_context.exists?(action_name, view_path) ?
view_path :
[controller_path, DEFAULT_VIEW_DIRECTORY].join('/')
end | ruby | {
"resource": ""
} |
q14607 | ActivityNotification.CommonController.return_back_or_ajax | train | def return_back_or_ajax
set_index_options
respond_to do |format|
if request.xhr?
load_index if params[:reload].to_s.to_boolean(true)
format.js
else
compatibly_redirect_back(@index_options) and return
end
end
end | ruby | {
"resource": ""
} |
q14608 | ActivityNotification.CommonController.compatibly_redirect_back | train | def compatibly_redirect_back(request_params = {})
# :only-rails5+:
if Rails::VERSION::MAJOR >= 5
redirect_back fallback_location: { action: :index }, **request_params
# :only-rails5+:
# :except-rails5+:
elsif request.referer
redirect_to :back, **request_params
else
redirect_to action: :index, **request_params
end
# :except-rails5+:
true
end | ruby | {
"resource": ""
} |
q14609 | ActionDispatch::Routing.Mapper.notify_to | train | def notify_to(*resources)
options = create_options(:notifications, resources.extract_options!, [:new, :create, :edit, :update])
resources.each do |target|
options[:defaults] = { target_type: target.to_s }.merge(options[:devise_defaults])
resources_options = options.select { |key, _| [:with_devise, :devise_default_routes, :with_subscription, :subscription_option, :model, :devise_defaults].exclude? key }
if options[:with_devise].present? && options[:devise_default_routes].present?
create_notification_routes options, resources_options
else
self.resources target, only: :none do
create_notification_routes options, resources_options
end
end
if options[:with_subscription].present? && target.to_s.to_model_class.subscription_enabled?
subscribed_by target, options[:subscription_option]
end
end
self
end | ruby | {
"resource": ""
} |
q14610 | ActionDispatch::Routing.Mapper.subscribed_by | train | def subscribed_by(*resources)
options = create_options(:subscriptions, resources.extract_options!, [:new, :edit, :update])
resources.each do |target|
options[:defaults] = { target_type: target.to_s }.merge(options[:devise_defaults])
resources_options = options.select { |key, _| [:with_devise, :devise_default_routes, :model, :devise_defaults].exclude? key }
if options[:with_devise].present? && options[:devise_default_routes].present?
create_subscription_routes options, resources_options
else
self.resources target, only: :none do
create_subscription_routes options, resources_options
end
end
end
self
end | ruby | {
"resource": ""
} |
q14611 | ActivityNotification.Renderable.text | train | def text(params = {})
k = key.split('.')
k.unshift('notification') if k.first != 'notification'
if params.has_key?(:target)
k.insert(1, params[:target])
else
k.insert(1, target.to_resource_name)
end
k.push('text')
k = k.join('.')
attrs = (parameters.symbolize_keys.merge(params) || {}).merge(
group_member_count: group_member_count,
group_notification_count: group_notification_count,
group_member_notifier_count: group_member_notifier_count,
group_notifier_count: group_notifier_count
)
# Generate the :default fallback key without using pluralization key :count
default = I18n.t(k, attrs)
I18n.t(k, attrs.merge(count: group_notification_count, default: default))
end | ruby | {
"resource": ""
} |
q14612 | ActivityNotification.Renderable.render | train | def render(context, params = {})
params[:i18n] and return context.render plain: self.text(params)
partial = partial_path(*params.values_at(:partial, :partial_root, :target))
layout = layout_path(*params.values_at(:layout, :layout_root))
locals = prepare_locals(params)
begin
context.render params.merge(partial: partial, layout: layout, locals: locals)
rescue ActionView::MissingTemplate => e
if params[:fallback] == :text
context.render plain: self.text(params)
elsif params[:fallback].present?
partial = partial_path(*params.values_at(:fallback, :partial_root, :target))
context.render params.merge(partial: partial, layout: layout, locals: locals)
else
raise e
end
end
end | ruby | {
"resource": ""
} |
q14613 | ActivityNotification.Renderable.partial_path | train | def partial_path(path = nil, root = nil, target = nil)
controller = ActivityNotification.get_controller if ActivityNotification.respond_to?(:get_controller)
root ||= "activity_notification/notifications/#{target}" if target.present?
root ||= controller.target_view_path if controller.present? && controller.respond_to?(:target_view_path)
root ||= 'activity_notification/notifications/default'
template_key = notifiable.respond_to?(:overriding_notification_template_key) &&
notifiable.overriding_notification_template_key(@target, key).present? ?
notifiable.overriding_notification_template_key(@target, key) :
key
path ||= template_key.tr('.', '/')
select_path(path, root)
end | ruby | {
"resource": ""
} |
q14614 | ActivityNotification.Common.resolve_value | train | def resolve_value(thing, *args)
case thing
when Symbol
symbol_method = method(thing)
if symbol_method.arity > 0
symbol_method.call(*args)
else
symbol_method.call
end
when Proc
if thing.arity > 1
thing.call(self, *args)
elsif thing.arity > 0
thing.call(self)
else
thing.call
end
when Hash
thing.dup.tap do |hash|
hash.each do |key, value|
hash[key] = resolve_value(value, *args)
end
end
else
thing
end
end | ruby | {
"resource": ""
} |
q14615 | ActivityNotification.NotificationsController.index | train | def index
set_index_options
load_index if params[:reload].to_s.to_boolean(true)
respond_to do |format|
format.html # index.html.erb
format.json { render json: @notifications.to_json(include: [:target, :notifiable, :group]) }
end
end | ruby | {
"resource": ""
} |
q14616 | ActivityNotification.NotificationsController.open | train | def open
with_members = !(params[:with_group_members].to_s.to_boolean(false) || params[:without_grouping].to_s.to_boolean(false))
@notification.open!(with_members: with_members)
params[:move].to_s.to_boolean(false) ?
move :
return_back_or_ajax
end | ruby | {
"resource": ""
} |
q14617 | ActivityNotification.NotificationsController.set_index_options | train | def set_index_options
limit = params[:limit].to_i > 0 ? params[:limit].to_i : nil
reverse = params[:reverse].present? ?
params[:reverse].to_s.to_boolean(false) : nil
with_group_members = params[:with_group_members].present? || params[:without_grouping].present? ?
params[:with_group_members].to_s.to_boolean(false) || params[:without_grouping].to_s.to_boolean(false) : nil
@index_options = params.permit(:filter, :filtered_by_type, :filtered_by_group_type, :filtered_by_group_id, :filtered_by_key, :routing_scope, :devise_default_routes)
.to_h.symbolize_keys
.merge(limit: limit, reverse: reverse, with_group_members: with_group_members)
end | ruby | {
"resource": ""
} |
q14618 | ActivityNotification.Target.authenticated_with_devise? | train | def authenticated_with_devise?(current_resource)
devise_resource = resolve_value(_notification_devise_resource)
unless current_resource.blank? or current_resource.is_a? devise_resource.class
raise TypeError,
"Different type of current resource #{current_resource.class} "\
"with devise resource #{devise_resource.class} has been passed to #{self.class}##{__method__}. "\
"You have to override #{self.class}##{__method__} method or set devise_resource in acts_as_target."
end
current_resource.present? && current_resource == devise_resource
end | ruby | {
"resource": ""
} |
q14619 | ActivityNotification.Target.send_batch_notification_email | train | def send_batch_notification_email(notifications, options = {})
return if notifications.blank?
if notifications.map{ |n| n.target }.uniq == [self]
Notification.send_batch_notification_email(self, notifications, options)
end
end | ruby | {
"resource": ""
} |
q14620 | ActivityNotification.Target.subscribes_to_notification? | train | def subscribes_to_notification?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
!subscription_allowed?(key) || _subscribes_to_notification?(key, subscribe_as_default)
end | ruby | {
"resource": ""
} |
q14621 | ActivityNotification.Target.subscribes_to_notification_email? | train | def subscribes_to_notification_email?(key, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
!subscription_allowed?(key) || _subscribes_to_notification_email?(key, subscribe_as_default)
end | ruby | {
"resource": ""
} |
q14622 | ActivityNotification.Target.subscribes_to_optional_target? | train | def subscribes_to_optional_target?(key, optional_target_name, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
!subscription_allowed?(key) || _subscribes_to_optional_target?(key, optional_target_name, subscribe_as_default)
end | ruby | {
"resource": ""
} |
q14623 | ActivityNotification.Target._opened_notification_index | train | def _opened_notification_index(options = {})
limit = options[:limit] || ActivityNotification.config.opened_index_limit
reverse = options[:reverse] || false
with_group_members = options[:with_group_members] || false
notifications.opened_index(limit, reverse, with_group_members).filtered_by_options(options)
end | ruby | {
"resource": ""
} |
q14624 | ActivityNotification.SubscriptionApi.subscribe | train | def subscribe(options = {})
subscribed_at = options[:subscribed_at] || Time.current
with_email_subscription = options.has_key?(:with_email_subscription) ? options[:with_email_subscription] : true
with_optional_targets = options.has_key?(:with_optional_targets) ? options[:with_optional_targets] : true
new_attributes = { subscribing: true, subscribed_at: subscribed_at, optional_targets: optional_targets }
new_attributes = new_attributes.merge(subscribing_to_email: true, subscribed_to_email_at: subscribed_at) if with_email_subscription
if with_optional_targets
optional_target_names.each do |optional_target_name|
new_attributes[:optional_targets] = new_attributes[:optional_targets].merge(
Subscription.to_optional_target_key(optional_target_name) => true,
Subscription.to_optional_target_subscribed_at_key(optional_target_name) => subscribed_at)
end
end
update(new_attributes)
end | ruby | {
"resource": ""
} |
q14625 | ActivityNotification.SubscriptionApi.unsubscribe | train | def unsubscribe(options = {})
unsubscribed_at = options[:unsubscribed_at] || Time.current
new_attributes = { subscribing: false, unsubscribed_at: unsubscribed_at,
subscribing_to_email: false, unsubscribed_to_email_at: unsubscribed_at,
optional_targets: optional_targets }
optional_target_names.each do |optional_target_name|
new_attributes[:optional_targets] = new_attributes[:optional_targets].merge(
Subscription.to_optional_target_key(optional_target_name) => false,
Subscription.to_optional_target_unsubscribed_at_key(optional_target_name) => subscribed_at)
end
update(new_attributes)
end | ruby | {
"resource": ""
} |
q14626 | ActivityNotification.SubscriptionApi.subscribe_to_email | train | def subscribe_to_email(options = {})
subscribed_to_email_at = options[:subscribed_to_email_at] || Time.current
update(subscribing_to_email: true, subscribed_to_email_at: subscribed_to_email_at)
end | ruby | {
"resource": ""
} |
q14627 | ActivityNotification.SubscriptionApi.unsubscribe_to_email | train | def unsubscribe_to_email(options = {})
unsubscribed_to_email_at = options[:unsubscribed_to_email_at] || Time.current
update(subscribing_to_email: false, unsubscribed_to_email_at: unsubscribed_to_email_at)
end | ruby | {
"resource": ""
} |
q14628 | ActivityNotification.SubscriptionApi.subscribing_to_optional_target? | train | def subscribing_to_optional_target?(optional_target_name, subscribe_as_default = ActivityNotification.config.subscribe_as_default)
optional_target_key = Subscription.to_optional_target_key(optional_target_name)
subscribe_as_default ?
!optional_targets.has_key?(optional_target_key) || optional_targets[optional_target_key] :
optional_targets.has_key?(optional_target_key) && optional_targets[optional_target_key]
end | ruby | {
"resource": ""
} |
q14629 | ActivityNotification.SubscriptionApi.subscribe_to_optional_target | train | def subscribe_to_optional_target(optional_target_name, options = {})
subscribed_at = options[:subscribed_at] || Time.current
update(optional_targets: optional_targets.merge(
Subscription.to_optional_target_key(optional_target_name) => true,
Subscription.to_optional_target_subscribed_at_key(optional_target_name) => subscribed_at)
)
end | ruby | {
"resource": ""
} |
q14630 | ActivityNotification.SubscriptionApi.unsubscribe_to_optional_target | train | def unsubscribe_to_optional_target(optional_target_name, options = {})
unsubscribed_at = options[:unsubscribed_at] || Time.current
update(optional_targets: optional_targets.merge(
Subscription.to_optional_target_key(optional_target_name) => false,
Subscription.to_optional_target_unsubscribed_at_key(optional_target_name) => unsubscribed_at)
)
end | ruby | {
"resource": ""
} |
q14631 | ActivityNotification.SubscriptionApi.optional_target_names | train | def optional_target_names
optional_targets.keys.select { |key| key.to_s.start_with?("subscribing_to_") }.map { |key| key.slice(15..-1) }
end | ruby | {
"resource": ""
} |
q14632 | ActivityNotification.Notifiable.notification_targets | train | def notification_targets(target_type, options = {})
target_typed_method_name = "notification_#{cast_to_resources_name(target_type)}"
resolved_parameter = resolve_parameter(
target_typed_method_name,
_notification_targets[cast_to_resources_sym(target_type)],
nil,
options)
unless resolved_parameter
raise NotImplementedError, "You have to implement #{self.class}##{target_typed_method_name} "\
"or set :targets in acts_as_notifiable"
end
resolved_parameter
end | ruby | {
"resource": ""
} |
q14633 | ActivityNotification.Notifiable.notification_email_allowed? | train | def notification_email_allowed?(target, key = nil)
resolve_parameter(
"notification_email_allowed_for_#{cast_to_resources_name(target.class)}?",
_notification_email_allowed[cast_to_resources_sym(target.class)],
ActivityNotification.config.email_enabled,
target, key)
end | ruby | {
"resource": ""
} |
q14634 | ActivityNotification.Notifiable.notifiable_path | train | def notifiable_path(target_type, key = nil)
resolved_parameter = resolve_parameter(
"notifiable_path_for_#{cast_to_resources_name(target_type)}",
_notifiable_path[cast_to_resources_sym(target_type)],
nil,
key)
unless resolved_parameter
begin
resolved_parameter = defined?(super) ? super : polymorphic_path(self)
rescue NoMethodError, ActionController::UrlGenerationError
raise NotImplementedError, "You have to implement #{self.class}##{__method__}, "\
"set :notifiable_path in acts_as_notifiable or "\
"set polymorphic_path routing for #{self.class}"
end
end
resolved_parameter
end | ruby | {
"resource": ""
} |
q14635 | ActivityNotification.Notifiable.printable_notifiable_name | train | def printable_notifiable_name(target, key = nil)
resolve_parameter(
"printable_notifiable_name_for_#{cast_to_resources_name(target.class)}?",
_printable_notifiable_name[cast_to_resources_sym(target.class)],
printable_name,
target, key)
end | ruby | {
"resource": ""
} |
q14636 | ActivityNotification.Notifiable.optional_target_names | train | def optional_target_names(target_type, key = nil)
optional_targets(target_type, key).map { |optional_target| optional_target.to_optional_target_name }
end | ruby | {
"resource": ""
} |
q14637 | ActivityNotification.Notifiable.generated_notifications_as_notifiable_for | train | def generated_notifications_as_notifiable_for(target_type = nil)
target_type.nil? ?
generated_notifications_as_notifiable.all :
generated_notifications_as_notifiable.filtered_by_target_type(target_type.to_s.to_model_name)
end | ruby | {
"resource": ""
} |
q14638 | ActivityNotification.Notifiable.destroy_generated_notifications_with_dependency | train | def destroy_generated_notifications_with_dependency(dependent = :delete_all, target_type = nil, remove_from_group = false)
remove_generated_notifications_from_group(target_type) if remove_from_group
generated_notifications = generated_notifications_as_notifiable_for(target_type)
case dependent
when :restrict_with_exception
ActivityNotification::Notification.raise_delete_restriction_error("generated_notifications_as_notifiable_for_#{target_type.to_s.pluralize.underscore}") unless generated_notifications.empty?
when :restrict_with_error
unless generated_notifications.empty?
record = self.class.human_attribute_name("generated_notifications_as_notifiable_for_#{target_type.to_s.pluralize.underscore}").downcase
self.errors.add(:base, :'restrict_dependent_destroy.has_many', record: record)
# :only-rails5+:
if Rails::VERSION::MAJOR >= 5
throw(:abort)
# :only-rails5+:
# :except-rails5+:
else
false
end
# :except-rails5+:
end
when :destroy
generated_notifications.each { |n| n.destroy }
when :delete_all
generated_notifications.delete_all
end
end | ruby | {
"resource": ""
} |
q14639 | ActivityNotification.SubscriptionsController.index | train | def index
set_index_options
load_index if params[:reload].to_s.to_boolean(true)
respond_to do |format|
format.html # index.html.erb
format.json { render json: { subscriptions: @subscriptions, unconfigured_notification_keys: @notification_keys } }
end
end | ruby | {
"resource": ""
} |
q14640 | ActivityNotification.SubscriptionsController.subscribe | train | def subscribe
@subscription.subscribe(with_email_subscription: params[:with_email_subscription].to_s.to_boolean(true),
with_optional_targets: params[:with_optional_targets].to_s.to_boolean(true))
return_back_or_ajax
end | ruby | {
"resource": ""
} |
q14641 | ActivityNotification.SubscriptionsController.set_index_options | train | def set_index_options
limit = params[:limit].to_i > 0 ? params[:limit].to_i : nil
reverse = params[:reverse].present? ?
params[:reverse].to_s.to_boolean(false) : nil
@index_options = params.permit(:filter, :filtered_by_key, :routing_scope, :devise_default_routes)
.to_h.symbolize_keys.merge(limit: limit, reverse: reverse)
end | ruby | {
"resource": ""
} |
q14642 | ActivityNotification.SubscriptionsController.load_index | train | def load_index
case @index_options[:filter]
when :configured, 'configured'
@subscriptions = @target.subscription_index(@index_options.merge(with_target: true))
@notification_keys = nil
when :unconfigured, 'unconfigured'
@subscriptions = nil
@notification_keys = @target.notification_keys(@index_options.merge(filter: :unconfigured))
else
@subscriptions = @target.subscription_index(@index_options.merge(with_target: true))
@notification_keys = @target.notification_keys(@index_options.merge(filter: :unconfigured))
end
end | ruby | {
"resource": ""
} |
q14643 | ActivityNotification.Subscriber.find_or_create_subscription | train | def find_or_create_subscription(key, subscription_params = {})
subscription = find_subscription(key)
subscription || create_subscription(subscription_params.merge(key: key))
end | ruby | {
"resource": ""
} |
q14644 | ActivityNotification.Subscriber.create_subscription | train | def create_subscription(subscription_params = {})
created_at = Time.current
if subscription_params[:subscribing] == false && subscription_params[:subscribing_to_email].nil?
subscription_params[:subscribing_to_email] = subscription_params[:subscribing]
end
subscription = subscriptions.new(subscription_params)
subscription.subscribing? ?
subscription.assign_attributes(subscribing: true, subscribed_at: created_at) :
subscription.assign_attributes(subscribing: false, unsubscribed_at: created_at)
subscription.subscribing_to_email? ?
subscription.assign_attributes(subscribing_to_email: true, subscribed_to_email_at: created_at) :
subscription.assign_attributes(subscribing_to_email: false, unsubscribed_to_email_at: created_at)
subscription.optional_targets = (subscription.optional_targets || {}).with_indifferent_access
optional_targets = {}.with_indifferent_access
subscription.optional_target_names.each do |optional_target_name|
optional_targets = subscription.subscribing_to_optional_target?(optional_target_name) ?
optional_targets.merge(
Subscription.to_optional_target_key(optional_target_name) => true,
Subscription.to_optional_target_subscribed_at_key(optional_target_name) => created_at
) :
optional_targets.merge(
Subscription.to_optional_target_key(optional_target_name) => false,
Subscription.to_optional_target_unsubscribed_at_key(optional_target_name) => created_at
)
end
subscription.assign_attributes(optional_targets: optional_targets)
subscription.save ? subscription : nil
end | ruby | {
"resource": ""
} |
q14645 | ActivityNotification.Subscriber.subscription_index | train | def subscription_index(options = {})
target_index = subscriptions.filtered_by_options(options)
target_index = options[:reverse] ? target_index.earliest_order : target_index.latest_order
target_index = target_index.with_target if options[:with_target]
options[:limit].present? ? target_index.limit(options[:limit]).to_a : target_index.to_a
end | ruby | {
"resource": ""
} |
q14646 | ActivityNotification.Subscriber.notification_keys | train | def notification_keys(options = {})
subscription_keys = subscriptions.uniq_keys
target_notifications = notifications.filtered_by_options(options.select { |k, _| [:filtered_by_key, :custom_filter].include?(k) })
target_notifications = options[:reverse] ? target_notifications.earliest_order : target_notifications.latest_order
target_notifications = options[:limit].present? ? target_notifications.limit(options[:limit] + subscription_keys.size) : target_notifications
notification_keys = target_notifications.uniq_keys
notification_keys =
case options[:filter]
when :configured, 'configured'
notification_keys & subscription_keys
when :unconfigured, 'unconfigured'
notification_keys - subscription_keys
else
notification_keys
end
options[:limit].present? ? notification_keys.take(options[:limit]) : notification_keys
end | ruby | {
"resource": ""
} |
q14647 | ActivityNotification.Subscriber.evaluate_subscription | train | def evaluate_subscription(record, field, default, *args)
default ? record.blank? || record.send(field, *args) : record.present? && record.send(field, *args)
end | ruby | {
"resource": ""
} |
q14648 | Puppet::ResourceApi.ResourceShim.to_hierayaml | train | def to_hierayaml
attributes = Hash[filtered_keys.map { |k| [k.to_s, values[k]] }]
YAML.dump('type' => { title => attributes }).split("\n").drop(2).join("\n") + "\n"
end | ruby | {
"resource": ""
} |
q14649 | Puppet::ResourceApi.ResourceShim.filtered_keys | train | def filtered_keys
values.keys.reject { |k| k == :title || !attr_def[k] || (attr_def[k][:behaviour] == :namevar && @namevars.size == 1) }
end | ruby | {
"resource": ""
} |
q14650 | Puppet::ResourceApi.TypeDefinition.feature? | train | def feature?(feature)
supported = (definition[:features] && definition[:features].include?(feature))
if supported
Puppet.debug("#{definition[:name]} supports `#{feature}`")
else
Puppet.debug("#{definition[:name]} does not support `#{feature}`")
end
supported
end | ruby | {
"resource": ""
} |
q14651 | Puppet::ResourceApi.BaseTypeDefinition.check_schema | train | def check_schema(resource, message_prefix = nil)
namevars.each do |namevar|
if resource[namevar].nil?
raise Puppet::ResourceError, "`#{name}.get` did not return a value for the `#{namevar}` namevar attribute"
end
end
message_prefix = 'Provider returned data that does not match the Type Schema' if message_prefix.nil?
message = "#{message_prefix} for `#{name}[#{resource[namevars.first]}]`"
rejected_keys = check_schema_keys(resource)
bad_values = check_schema_values(resource)
unless rejected_keys.empty?
message += "\n Unknown attribute:\n"
rejected_keys.each { |key, _value| message += " * #{key}\n" }
end
unless bad_values.empty?
message += "\n Value type mismatch:\n"
bad_values.each { |key, value| message += " * #{key}: #{value}\n" }
end
return if rejected_keys.empty? && bad_values.empty?
notify_schema_errors(message)
end | ruby | {
"resource": ""
} |
q14652 | Puppet::ResourceApi.BaseTypeDefinition.check_schema_keys | train | def check_schema_keys(resource)
rejected = []
resource.reject { |key| rejected << key if key != :title && attributes.key?(key) == false }
rejected
end | ruby | {
"resource": ""
} |
q14653 | Puppet::ResourceApi.BaseTypeDefinition.check_schema_values | train | def check_schema_values(resource)
bad_vals = {}
resource.each do |key, value|
next unless attributes[key]
type = @data_type_cache[attributes[key][:type]]
is_sensitive = (attributes[key].key?(:sensitive) && (attributes[key][:sensitive] == true))
error_message = Puppet::ResourceApi::DataTypeHandling.try_validate(
type,
value,
'',
)
if is_sensitive
bad_vals[key] = '<< redacted value >> ' + error_message unless error_message.nil?
else
bad_vals[key] = value unless error_message.nil?
end
end
bad_vals
end | ruby | {
"resource": ""
} |
q14654 | FaradayMiddleware.ResponseMiddleware.parse | train | def parse(body)
if self.class.parser
begin
self.class.parser.call(body, @parser_options)
rescue StandardError, SyntaxError => err
raise err if err.is_a? SyntaxError and err.class.name != 'Psych::SyntaxError'
raise Faraday::Error::ParsingError, err
end
else
body
end
end | ruby | {
"resource": ""
} |
q14655 | FaradayMiddleware.RackCompatible.prepare_env | train | def prepare_env(faraday_env)
env = headers_to_rack(faraday_env)
url = faraday_env[:url]
env['rack.url_scheme'] = url.scheme
env['PATH_INFO'] = url.path
env['SERVER_PORT'] = url.respond_to?(:inferred_port) ? url.inferred_port : url.port
env['QUERY_STRING'] = url.query
env['REQUEST_METHOD'] = faraday_env[:method].to_s.upcase
env['rack.errors'] ||= StringIO.new
env['faraday'] = faraday_env
env
end | ruby | {
"resource": ""
} |
q14656 | FaradayMiddleware.RackCompatible.restore_env | train | def restore_env(rack_env)
env = rack_env.fetch('faraday')
headers = env[:request_headers]
headers.clear
rack_env.each do |name, value|
next unless String === name && String === value
if NonPrefixedHeaders.include? name or name.index('HTTP_') == 0
name = name.sub(/^HTTP_/, '').downcase.tr('_', '-')
headers[name] = value
end
end
env[:method] = rack_env['REQUEST_METHOD'].downcase.to_sym
env[:rack_errors] = rack_env['rack.errors']
env
end | ruby | {
"resource": ""
} |
q14657 | CommandT.MatchWindow.match_with_syntax_highlight | train | def match_with_syntax_highlight(match)
highlight_chars = @prompt.abbrev.downcase.scan(/./mu)
if @encoding &&
match.respond_to?(:force_encoding) &&
match.encoding != @encoding
match = match.force_encoding(@encoding)
end
match.scan(/./mu).inject([]) do |output, char|
if char.downcase == highlight_chars.first
highlight_chars.shift
output.concat [MH_START, char, MH_END]
else
output << char
end
end.join
end | ruby | {
"resource": ""
} |
q14658 | CommandT.MatchWindow.print_match | train | def print_match(idx)
return unless VIM::Window.select(@window)
unlock
@@buffer[line(idx)] = match_text_for_idx idx
lock
end | ruby | {
"resource": ""
} |
q14659 | CommandT.MatchWindow.print_matches | train | def print_matches
match_count = @matches.length
if match_count == 0
print_error 'NO MATCHES'
else
return unless VIM::Window.select(@window)
unlock
clear
@window_width = @window.width # update cached value
desired_lines = [match_count, @min_height].max
desired_lines = [max_lines, desired_lines].min
@window.height = desired_lines
matches = []
(0...@window.height).each do |idx|
text = match_text_for_idx(idx)
@reverse_list ? matches.unshift(text) : matches.push(text)
end
matches.each_with_index do |match, idx|
if @@buffer.count > idx
@@buffer[idx + 1] = match
else
@@buffer.append(idx, match)
end
end
lock
end
end | ruby | {
"resource": ""
} |
q14660 | CommandT.Controller.quickfix | train | def quickfix
hide
matches = @matches.map do |match|
"{ 'filename': '#{VIM::escape_for_single_quotes match}' }"
end.join(', ')
::VIM::command 'call setqflist([' + matches + '])'
::VIM::command 'cope'
end | ruby | {
"resource": ""
} |
q14661 | CommandT.Prompt.backspace! | train | def backspace!
if @col > 0
left, cursor, right = abbrev_segments
@abbrev = left.chop! + cursor + right
@col -= 1
redraw
end
end | ruby | {
"resource": ""
} |
q14662 | EmailAddress.Local.format | train | def format(form=@config[:local_format]||:conventional)
if @config[:local_format].is_a?(Proc)
@config[:local_format].call(self)
elsif form == :conventional
self.conventional
elsif form == :canonical
self.canonical
elsif form == :relaxed
self.relax
elsif form == :standard
self.standard
end
end | ruby | {
"resource": ""
} |
q14663 | EmailAddress.Local.standard | train | def standard
form = self.mailbox
form += @config[:tag_separator] + self.tag if self.tag
form += "(" + self.comment + ")" if self.comment
form.gsub!(/([\\\"])/, '\\\1') # Escape \ and "
if form =~ /[ \"\(\),:<>@\[\\\]]/ # Space and "(),:;<>@[\]
form = %Q("#{form}")
end
form
end | ruby | {
"resource": ""
} |
q14664 | EmailAddress.Local.conventional? | train | def conventional?
self.syntax = :invalid
self.local =~ CONVENTIONAL_MAILBOX_REGEX or return false
self.valid_size? or return false
self.valid_encoding? or return false
self.syntax = :conventional
true
end | ruby | {
"resource": ""
} |
q14665 | EmailAddress.Local.relaxed? | train | def relaxed?
self.syntax = :invalid
self.valid_size? or return false
self.valid_encoding? or return false
if self.local =~ RELAXED_MAILBOX_REGEX
self.syntax = :relaxed
true
else
false
end
end | ruby | {
"resource": ""
} |
q14666 | EmailAddress.Local.standard? | train | def standard?
self.syntax = :invalid
self.valid_size? or return false
self.valid_encoding? or return false
if self.local =~ STANDARD_LOCAL_REGEX
self.syntax = :standard
true
else
false
end
end | ruby | {
"resource": ""
} |
q14667 | EmailAddress.Local.matches? | train | def matches?(*rules)
rules.flatten.each do |r|
if r =~ /(.+)@\z/
return r if File.fnmatch?($1, self.local)
end
end
false
end | ruby | {
"resource": ""
} |
q14668 | EmailAddress.Address.canonical | train | def canonical
c = self.local.canonical
c += "@" + self.host.canonical if self.host.canonical && self.host.canonical > " "
c
end | ruby | {
"resource": ""
} |
q14669 | EmailAddress.Exchanger.provider | train | def provider
return @provider if defined? @provider
EmailAddress::Config.providers.each do |provider, config|
if config[:exchanger_match] && self.matches?(config[:exchanger_match])
return @provider = provider
end
end
@provider = :default
end | ruby | {
"resource": ""
} |
q14670 | EmailAddress.Exchanger.domains | train | def domains
@_domains ||= mxers.map {|m| EmailAddress::Host.new(m.first).domain_name }.sort.uniq
end | ruby | {
"resource": ""
} |
q14671 | ZipkinTracer.HostnameResolver.unique_hosts | train | def unique_hosts(spans)
hosts = []
each_endpoint(spans) do |endpoint|
hosts.push(endpoint)
end
hosts.uniq
end | ruby | {
"resource": ""
} |
q14672 | DeliveryBoy.Instance.producer_options | train | def producer_options
{
required_acks: config.required_acks,
ack_timeout: config.ack_timeout,
max_retries: config.max_retries,
retry_backoff: config.retry_backoff,
max_buffer_size: config.max_buffer_size,
max_buffer_bytesize: config.max_buffer_bytesize,
compression_codec: (config.compression_codec.to_sym if config.compression_codec),
compression_threshold: config.compression_threshold,
}
end | ruby | {
"resource": ""
} |
q14673 | SidekiqScheduler.Schedule.get_schedule | train | def get_schedule(name = nil)
if name.nil?
get_all_schedules
else
encoded_schedule = SidekiqScheduler::RedisManager.get_job_schedule(name)
encoded_schedule.nil? ? nil : JSON.parse(encoded_schedule)
end
end | ruby | {
"resource": ""
} |
q14674 | SidekiqScheduler.Schedule.get_all_schedules | train | def get_all_schedules
schedules = {}
if SidekiqScheduler::RedisManager.schedule_exist?
SidekiqScheduler::RedisManager.get_all_schedules.tap do |h|
h.each do |name, config|
schedules[name] = JSON.parse(config)
end
end
end
schedules
end | ruby | {
"resource": ""
} |
q14675 | SidekiqScheduler.Schedule.set_schedule | train | def set_schedule(name, config)
existing_config = get_schedule(name)
unless existing_config && existing_config == config
SidekiqScheduler::RedisManager.set_job_schedule(name, config)
SidekiqScheduler::RedisManager.add_schedule_change(name)
end
config
end | ruby | {
"resource": ""
} |
q14676 | SidekiqScheduler.Schedule.remove_schedule | train | def remove_schedule(name)
SidekiqScheduler::RedisManager.remove_job_schedule(name)
SidekiqScheduler::RedisManager.add_schedule_change(name)
end | ruby | {
"resource": ""
} |
q14677 | SidekiqScheduler.Scheduler.load_schedule! | train | def load_schedule!
if enabled
Sidekiq.logger.info 'Loading Schedule'
# Load schedule from redis for the first time if dynamic
if dynamic
Sidekiq.reload_schedule!
@current_changed_score = Time.now.to_f
rufus_scheduler.every(dynamic_every) do
update_schedule
end
end
Sidekiq.logger.info 'Schedule empty! Set Sidekiq.schedule' if Sidekiq.schedule.empty?
@scheduled_jobs = {}
queues = sidekiq_queues
Sidekiq.schedule.each do |name, config|
if !listened_queues_only || enabled_queue?(config['queue'].to_s, queues)
load_schedule_job(name, config)
else
Sidekiq.logger.info { "Ignoring #{name}, job's queue is not enabled." }
end
end
Sidekiq.logger.info 'Schedules Loaded'
else
Sidekiq.logger.info 'SidekiqScheduler is disabled'
end
end | ruby | {
"resource": ""
} |
q14678 | SidekiqScheduler.Scheduler.idempotent_job_enqueue | train | def idempotent_job_enqueue(job_name, time, config)
registered = SidekiqScheduler::RedisManager.register_job_instance(job_name, time)
if registered
Sidekiq.logger.info "queueing #{config['class']} (#{job_name})"
handle_errors { enqueue_job(config, time) }
SidekiqScheduler::RedisManager.remove_elder_job_instances(job_name)
else
Sidekiq.logger.debug { "Ignoring #{job_name} job as it has been already enqueued" }
end
end | ruby | {
"resource": ""
} |
q14679 | SidekiqScheduler.Scheduler.enqueue_job | train | def enqueue_job(job_config, time = Time.now)
config = prepare_arguments(job_config.dup)
if config.delete('include_metadata')
config['args'] = arguments_with_metadata(config['args'], scheduled_at: time.to_f)
end
if active_job_enqueue?(config['class'])
SidekiqScheduler::Utils.enqueue_with_active_job(config)
else
SidekiqScheduler::Utils.enqueue_with_sidekiq(config)
end
end | ruby | {
"resource": ""
} |
q14680 | SidekiqScheduler.Scheduler.schedule_state | train | def schedule_state(name)
state = SidekiqScheduler::RedisManager.get_job_state(name)
state ? JSON.parse(state) : {}
end | ruby | {
"resource": ""
} |
q14681 | SidekiqScheduler.Scheduler.arguments_with_metadata | train | def arguments_with_metadata(args, metadata)
if args.is_a? Array
[*args, metadata]
else
[args, metadata]
end
end | ruby | {
"resource": ""
} |
q14682 | SidekiqScheduler.Scheduler.active_job_enqueue? | train | def active_job_enqueue?(klass)
klass.is_a?(Class) && defined?(ActiveJob::Enqueuing) &&
klass.included_modules.include?(ActiveJob::Enqueuing)
end | ruby | {
"resource": ""
} |
q14683 | SidekiqScheduler.Scheduler.prepare_arguments | train | def prepare_arguments(config)
config['class'] = SidekiqScheduler::Utils.try_to_constantize(config['class'])
if config['args'].is_a?(Hash)
config['args'].symbolize_keys! if config['args'].respond_to?(:symbolize_keys!)
else
config['args'] = Array(config['args'])
end
config
end | ruby | {
"resource": ""
} |
q14684 | SidekiqScheduler.JobPresenter.next_time | train | def next_time
execution_time = SidekiqScheduler::RedisManager.get_job_next_time(name)
relative_time(Time.parse(execution_time)) if execution_time
end | ruby | {
"resource": ""
} |
q14685 | SidekiqScheduler.JobPresenter.last_time | train | def last_time
execution_time = SidekiqScheduler::RedisManager.get_job_last_time(name)
relative_time(Time.parse(execution_time)) if execution_time
end | ruby | {
"resource": ""
} |
q14686 | Stitches.Deprecation.deprecated | train | def deprecated(gone_on:,&block)
response.set_header("Sunset",Date.parse(gone_on).in_time_zone("GMT").midnight.strftime("%a, %e %b %Y %H:%M:%S %Z"))
Rails.logger.info("DEPRECATED ENDPOINT #{request.method} to #{request.fullpath} requested by #{current_user.id}")
block.()
end | ruby | {
"resource": ""
} |
q14687 | Terminal.Table.align_column | train | def align_column n, alignment
r = rows
column(n).each_with_index do |col, i|
cell = r[i][n]
next unless cell
cell.alignment = alignment unless cell.alignment?
end
end | ruby | {
"resource": ""
} |
q14688 | Terminal.Table.add_row | train | def add_row array
row = array == :separator ? Separator.new(self) : Row.new(self, array)
@rows << row
require_column_widths_recalc unless row.is_a?(Separator)
end | ruby | {
"resource": ""
} |
q14689 | Terminal.Table.column | train | def column n, method = :value, array = rows
array.map { |row|
# for each cells in a row, find the column with index
# just greater than the required one, and go back one.
index = col = 0
row.cells.each do |cell|
break if index > n
index += cell.colspan
col += 1
end
cell = row[col - 1]
cell && method ? cell.__send__(method) : cell
}.compact
end | ruby | {
"resource": ""
} |
q14690 | Terminal.Table.headings= | train | def headings= arrays
arrays = [arrays] unless arrays.first.is_a?(Array)
@headings = arrays.map do |array|
row = Row.new(self, array)
require_column_widths_recalc
row
end
end | ruby | {
"resource": ""
} |
q14691 | Terminal.Table.render | train | def render
separator = Separator.new(self)
buffer = style.border_top ? [separator] : []
unless @title.nil?
buffer << Row.new(self, [title_cell_options])
buffer << separator
end
@headings.each do |row|
unless row.cells.empty?
buffer << row
buffer << separator
end
end
if style.all_separators
buffer += @rows.product([separator]).flatten
else
buffer += @rows
buffer << separator if style.border_bottom
end
buffer.map { |r| style.margin_left + r.render.rstrip }.join("\n")
end | ruby | {
"resource": ""
} |
q14692 | RailsBestPractices.Analyzer.analyze | train | def analyze
Core::Runner.base_path = @path
Core::Runner.config_path = @options['config']
@runner = Core::Runner.new
analyze_source_codes
analyze_vcs
end | ruby | {
"resource": ""
} |
q14693 | RailsBestPractices.Analyzer.process | train | def process(process)
parse_files.each do |file|
begin
puts file if @options['debug']
@runner.send(process, file, File.read(file))
rescue StandardError
if @options['debug']
warning = "#{file} looks like it's not a valid Ruby file. Skipping..."
plain_output(warning, 'red')
end
end
@bar.increment if display_bar?
end
@runner.send("after_#{process}")
end | ruby | {
"resource": ""
} |
q14694 | RailsBestPractices.Analyzer.parse_files | train | def parse_files
@parse_files ||= begin
files = expand_dirs_to_files(@path)
files = file_sort(files)
if @options['only'].present?
files = file_accept(files, @options['only'])
end
# By default, tmp, vender, spec, test, features are ignored.
%w[vendor spec test features tmp].each do |dir|
files = file_ignore(files, File.join(@path, dir)) unless @options[dir]
end
# Exclude files based on exclude regexes if the option is set.
@options['exclude'].each do |pattern|
files = file_ignore(files, pattern)
end
%w[Capfile Gemfile Gemfile.lock].each do |file|
files.unshift File.join(@path, file)
end
files.compact
end
end | ruby | {
"resource": ""
} |
q14695 | RailsBestPractices.Analyzer.expand_dirs_to_files | train | def expand_dirs_to_files(*dirs)
extensions = %w[rb erb rake rhtml haml slim builder rxml rabl]
dirs.flatten.map do |entry|
next unless File.exist? entry
if File.directory? entry
Dir[File.join(entry, '**', "*.{#{extensions.join(',')}}")]
else
entry
end
end.flatten
end | ruby | {
"resource": ""
} |
q14696 | RailsBestPractices.Analyzer.file_sort | train | def file_sort(files)
models = files.find_all { |file| file =~ Core::Check::MODEL_FILES }
mailers = files.find_all { |file| file =~ Core::Check::MAILER_FILES }
helpers = files.find_all { |file| file =~ Core::Check::HELPER_FILES }
others = files.find_all { |file| file !~ Core::Check::MAILER_FILES && file !~ Core::Check::MODEL_FILES && file !~ Core::Check::HELPER_FILES }
models + mailers + helpers + others
end | ruby | {
"resource": ""
} |
q14697 | RailsBestPractices.Analyzer.file_accept | train | def file_accept(files, patterns)
files.select { |file| patterns.any? { |pattern| file =~ pattern } }
end | ruby | {
"resource": ""
} |
q14698 | RailsBestPractices.Analyzer.output_json_errors | train | def output_json_errors
errors_as_hashes = errors.map do |err|
{
filename: err.filename,
line_number: err.line_number,
message: err.message
}
end
File.open(@options['output-file'], 'w+') do |file|
file.write JSON.dump(errors_as_hashes)
end
end | ruby | {
"resource": ""
} |
q14699 | RailsBestPractices.Analyzer.plain_output | train | def plain_output(message, color)
if @options['without-color']
puts message
else
puts Colorize.send(color, message)
end
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.