_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q18700 | TLAW.DataTable.to_h | train | def to_h
keys.map { |k| [k, map { |h| | ruby | {
"resource": ""
} |
q18701 | ElmInstall.DirectorySource.copy_to | train | def copy_to(_, directory)
# Delete the directory to make sure no pervious version remains
FileUtils.rm_rf(directory) if directory.exist?
# Create parent directory
| ruby | {
"resource": ""
} |
q18702 | ElmInstall.Identifier.identify | train | def identify(directory)
raw = json(directory)
dependencies = raw['dependencies'].to_h
dependency_sources =
raw['dependency-sources']
.to_h
.merge(@dependency_sources)
dependencies.map do |package, constraint|
constraints = Utils.transform_constraint constraint
... | ruby | {
"resource": ""
} |
q18703 | ElmInstall.Identifier.uri_type | train | def uri_type(url, branch)
uri = GitCloneUrl.parse(url)
case uri
when URI::SshGit::Generic
| ruby | {
"resource": ""
} |
q18704 | ElmInstall.Identifier.json | train | def json(directory)
path = File.join(directory, 'elm-package.json')
JSON.parse(File.read(path))
rescue JSON::ParserError
warn "Invalid JSON in file: #{path.bold}" | ruby | {
"resource": ""
} |
q18705 | ElmInstall.Utils.transform_constraint | train | def transform_constraint(elm_constraint)
elm_constraint.gsub!(/\s/, '')
CONVERTERS
.map { |regexp, prefix| [elm_constraint.match(regexp), prefix] }
.select { |(match)| match }
| ruby | {
"resource": ""
} |
q18706 | ElmInstall.Installer.results | train | def results
Solve
.it!(@graph, initial_solve_constraints)
.map do |name, version|
dep = @resolver.dependencies[name]
| ruby | {
"resource": ""
} |
q18707 | ElmInstall.Installer.initial_solve_constraints | train | def initial_solve_constraints
@identifier.initial_dependencies.flat_map do |dependency|
| ruby | {
"resource": ""
} |
q18708 | ElmInstall.Resolver.resolve_dependency | train | def resolve_dependency(dependency)
@dependencies[dependency.name] ||= dependency
dependency
.source
.versions(
dependency.constraints,
@identifier.initial_elm_version,
!@options[:skip_update],
@options[:only_update]
)
| ruby | {
"resource": ""
} |
q18709 | ElmInstall.Resolver.resolve_dependencies | train | def resolve_dependencies(main, version)
dependencies = @identifier.identify(main.source.fetch(version))
artifact = @graph.artifact main.name, version
| ruby | {
"resource": ""
} |
q18710 | ElmInstall.GitSource.fetch | train | def fetch(version)
# Get the reference from the branch
ref =
case @branch
when Branch::Just
@branch.ref
when Branch::Nothing
case version
when String
| ruby | {
"resource": ""
} |
q18711 | ElmInstall.GitSource.copy_to | train | def copy_to(version, directory)
# Delete the directory to make sure no pervious version remains if
# we are using a branch or symlink if using Dir.
FileUtils.rm_rf(directory) if directory.exist?
# Create directory if not exists
FileUtils.mkdir_p directory
# Copy hole repository
| ruby | {
"resource": ""
} |
q18712 | ElmInstall.GitSource.versions | train | def versions(constraints, elm_version, should_update, only_update)
if repository.cloned? &&
!repository.fetched &&
should_update &&
(!only_update || only_update == package_name)
# Get updates from upstream
Logger.arrow "Getting updates for: #{package_name.bold}"
... | ruby | {
"resource": ""
} |
q18713 | ElmInstall.GitSource.matching_versions | train | def matching_versions(constraints, elm_version)
repository
.versions
.select do |version|
elm_version_of(version.to_s) == elm_version &&
| ruby | {
"resource": ""
} |
q18714 | ElmInstall.Populator.log_dependency | train | def log_dependency(dependency)
log = "#{dependency.name} - "
log += dependency.source.to_log.to_s
log += | ruby | {
"resource": ""
} |
q18715 | ElmInstall.Repository.versions | train | def versions
@versions ||=
repo
.tags
.map(&:name)
.select { |tag| tag =~ /(.*\..*\..*)/ }
| ruby | {
"resource": ""
} |
q18716 | SimpleEnum.ViewHelpers.enum_option_pairs | train | def enum_option_pairs(record, enum, encode_as_value = false)
reader = enum.to_s.pluralize
record = record.class unless record.respond_to?(reader)
record.send(reader).map { |key, value|
name = | ruby | {
"resource": ""
} |
q18717 | GeneValidator.AlignmentValidation.array_to_ranges | train | def array_to_ranges(ar)
prev = ar[0]
ranges = ar.slice_before do |e|
| ruby | {
"resource": ""
} |
q18718 | GeneValidator.DuplicationValidation.find_local_alignment | train | def find_local_alignment(hit, prediction, hsp)
# indexing in blast starts from 1
hit_local = hit.raw_sequence[hsp.hit_from - 1..hsp.hit_to - 1]
query_local = prediction.raw_sequence[hsp.match_query_from -
1..hsp.match_query_to - 1]
# in case of nucl... | ruby | {
"resource": ""
} |
q18719 | GeneValidator.Cluster.print | train | def print
warn "Cluster: mean = #{mean}, density = #{density}"
lengths.sort { |a, b| a <=> b }.each do |elem|
warn | ruby | {
"resource": ""
} |
q18720 | GeneValidator.Validations.get_info_on_query_sequence | train | def get_info_on_query_sequence(seq_type = @config[:type],
index = @config[:idx])
query = GeneValidator.extract_input_fasta_sequence(index)
parse_query = query.scan(/^>([^\n]*)\n([A-Za-z\n]*)/)[0]
prediction | ruby | {
"resource": ""
} |
q18721 | GeneValidator.Validate.length_validation_scores | train | def length_validation_scores(validations, scores)
lcv = validations.select { |v| v.class == LengthClusterValidationOutput }
lrv = validations.select { |v| v.class == LengthRankValidationOutput }
if lcv.length == 1 && lrv.length == 1
score_lcv = (lcv[0].result == lcv[0].expected)
score_... | ruby | {
"resource": ""
} |
q18722 | GeneValidator.OutputFiles.turn_off_automated_sorting | train | def turn_off_automated_sorting
js_file = File.join(@dirs[:output_dir], 'html_files/js/gv.compiled.min.js')
original_content = File.read(js_file)
# removes the automatic sort on page load
updated_content = original_content.gsub(',sortList:[[0,0]]', '')
| ruby | {
"resource": ""
} |
q18723 | GeneValidator.OutputFiles.overview_html_hash | train | def overview_html_hash(evaluation, less)
data = [@overview[:scores].group_by { |a| a }.map do |k, vs|
{ 'key': k, 'value': vs.length, 'main': false }
end]
{ data: data, type: :simplebars, aux1: 10, aux2: '',
| ruby | {
"resource": ""
} |
q18724 | RailsPushNotifications.BaseApp.push_notifications | train | def push_notifications
pending = find_pending
to_send = pending.map do |notification|
notification_type.new notification.destinations, notification.data
| ruby | {
"resource": ""
} |
q18725 | ActiveRecord::Associations.HasManyForActiveModelAssociation.replace | train | def replace(other_array)
original_target = load_target.dup
other_array.each { |val| raise_on_type_mismatch!(val) }
target_ids = reflection.options[:target_ids]
owner[target_ids] = other_array.map(&:id)
old_records = original_target - other_array
old_records.each do |record|
... | ruby | {
"resource": ""
} |
q18726 | ActiveRecord::Associations.HasManyForActiveModelAssociation.concat | train | def concat(*records)
load_target
flatten_records = records.flatten
flatten_records.each { |val| raise_on_type_mismatch!(val) }
target_ids = reflection.options[:target_ids]
| ruby | {
"resource": ""
} |
q18727 | ActiveModel::Associations.OverrideMethods.association | train | def association(name) #:nodoc:
association = association_instance_get(name)
if association.nil?
reflection = self.class.reflect_on_association(name)
if reflection.options[:active_model]
| ruby | {
"resource": ""
} |
q18728 | SchemaToScaffold.Path.choose | train | def choose
validate_path
search_paths_list = search_paths
if search_paths_list.empty?
puts "\nThere is no /schema[^\/]*.rb$/ in the directory #{@path}"
exit
end
search_paths_list.each_with_index {|path,indx| puts "#{indx}. #{path}" }
begin
| ruby | {
"resource": ""
} |
q18729 | SimpleScheduler.SchedulerJob.load_config | train | def load_config
@config = YAML.safe_load(ERB.new(File.read(config_path)).result)
@queue_ahead = @config["queue_ahead"] || Task::DEFAULT_QUEUE_AHEAD_MINUTES
@queue_name = @config["queue_name"] || "default"
@time_zone | ruby | {
"resource": ""
} |
q18730 | SimpleScheduler.SchedulerJob.queue_future_jobs | train | def queue_future_jobs
tasks.each do |task|
# Schedule the new run times using the future job wrapper.
new_run_times = task.future_run_times - task.existing_run_times
new_run_times.each do |time|
| ruby | {
"resource": ""
} |
q18731 | SimpleScheduler.SchedulerJob.tasks | train | def tasks
@config.map do |task_name, options|
task_params = options.symbolize_keys
task_params[:queue_ahead] ||= @queue_ahead
task_params[:name] = task_name
| ruby | {
"resource": ""
} |
q18732 | SimpleScheduler.Task.existing_jobs | train | def existing_jobs
@existing_jobs ||= SimpleScheduler::Task.scheduled_set.select do |job|
next unless job.display_class == | ruby | {
"resource": ""
} |
q18733 | SimpleScheduler.Task.future_run_times | train | def future_run_times
future_run_times = existing_run_times.dup
last_run_time = future_run_times.last || at - frequency
last_run_time = last_run_time.in_time_zone(time_zone)
# Ensure there are at least two future jobs scheduled and that the queue ahead time is filled
while future_run_times... | ruby | {
"resource": ""
} |
q18734 | SimpleScheduler.FutureJob.perform | train | def perform(task_params, scheduled_time)
@task = Task.new(task_params)
@scheduled_time | ruby | {
"resource": ""
} |
q18735 | SimpleScheduler.FutureJob.expire_duration | train | def expire_duration
split_duration = @task.expires_after.split(".")
duration = split_duration[0].to_i
| ruby | {
"resource": ""
} |
q18736 | SimpleScheduler.FutureJob.expired? | train | def expired?
return false if @task.expires_after.blank?
| ruby | {
"resource": ""
} |
q18737 | SimpleScheduler.FutureJob.handle_expired_task | train | def handle_expired_task(exception)
exception.run_time = Time.now.in_time_zone(@task.time_zone)
exception.scheduled_time = @scheduled_time
exception.task = @task
| ruby | {
"resource": ""
} |
q18738 | SimpleScheduler.FutureJob.queue_task | train | def queue_task
if @task.job_class.instance_method(:perform).arity.zero?
@task.job_class.send(perform_method)
| ruby | {
"resource": ""
} |
q18739 | SimpleScheduler.At.parsed_time | train | def parsed_time
return @parsed_time if @parsed_time
@parsed_time = parsed_day
change_hour = next_hour
# There is no hour 24, so we need to move to the next day
if change_hour == 24
@parsed_time = 1.day.from_now(@parsed_time)
change_hour = 0
end
@parsed_time =... | ruby | {
"resource": ""
} |
q18740 | ActionSubscriber.DSL.exchange_names | train | def exchange_names(*names)
@_exchange_names ||= []
@_exchange_names += names.flatten.map(&:to_s)
| ruby | {
"resource": ""
} |
q18741 | ActionSubscriber.Subscribable.queue_name_for_method | train | def queue_name_for_method(method_name)
return queue_names[method_name] if queue_names[method_name]
queue_name = | ruby | {
"resource": ""
} |
q18742 | ActionSubscriber.Subscribable.routing_key_name_for_method | train | def routing_key_name_for_method(method_name)
return routing_key_names[method_name] if routing_key_names[method_name]
| ruby | {
"resource": ""
} |
q18743 | ECDSA.Point.double | train | def double
return self if infinity?
gamma = field.mod((3 * x * x + @group.param_a) * field.inverse(2 * y))
new_x = field.mod(gamma * gamma - 2 * x)
| ruby | {
"resource": ""
} |
q18744 | ECDSA.Point.multiply_by_scalar | train | def multiply_by_scalar(i)
raise ArgumentError, 'Scalar is not an integer.' if !i.is_a?(Integer)
raise ArgumentError, 'Scalar is negative.' if i < 0
result = group.infinity
v = self
while i > 0
| ruby | {
"resource": ""
} |
q18745 | ECDSA.PrimeField.square_roots | train | def square_roots(n)
raise ArgumentError, "Not a member of the field: #{n}." if !include?(n)
case
when prime == 2 then [n]
when (prime % 4) == 3 then square_roots_for_p_3_mod_4(n)
| ruby | {
"resource": ""
} |
q18746 | WaveFile.Writer.write_header | train | def write_header(sample_frame_count)
extensible = @format.channels > 2 ||
(@format.sample_format == :pcm && @format.bits_per_sample != 8 && @format.bits_per_sample != 16) ||
(@format.channels == 1 && @format.speaker_mapping != [:front_center]) ||
(@format.c... | ruby | {
"resource": ""
} |
q18747 | ObfuscateId.ClassMethods.obfuscate_id_default_spin | train | def obfuscate_id_default_spin
alphabet = Array("a".."z")
number = name.split("").collect do |char|
| ruby | {
"resource": ""
} |
q18748 | Praxis.ValidationHandler.handle! | train | def handle!(summary:, request:, stage:, errors: nil, exception: nil, **opts)
documentation = Docs::LinkBuilder.instance.for_request | ruby | {
"resource": ""
} |
q18749 | Praxis.Response.validate | train | def validate(action, validate_body: false)
return if response_name == :validation_error
unless (response_definition = action.responses[response_name])
raise Exceptions::Validation, "Attempting to return a response with name #{response_name} " \
| ruby | {
"resource": ""
} |
q18750 | Praxis.Config.define | train | def define(key=nil, type=Attributor::Struct, **opts, &block)
if key.nil? && type != Attributor::Struct
raise Exceptions::InvalidConfiguration.new(
"You cannot define the top level configuration with a non-Struct type. Got: #{type.inspect}"
)
end
case key
when Str... | ruby | {
"resource": ""
} |
q18751 | Praxis.MultipartPart.derive_content_type | train | def derive_content_type(handler_name)
possible_values = if self.content_type.match 'text/plain'
_, content_type_attribute = self.headers_attribute && self.headers_attribute.attributes.find { |k,v| k.to_s =~ /^content[-_]{1}type$/i }
if content_type_attribute && content_type_attribute.options.key?(... | ruby | {
"resource": ""
} |
q18752 | Praxis.ActionDefinition.precomputed_header_keys_for_rack | train | def precomputed_header_keys_for_rack
@precomputed_header_keys_for_rack ||= begin
@headers.attributes.keys.each_with_object(Hash.new) do |key,hash|
name = key.to_s
| ruby | {
"resource": ""
} |
q18753 | Praxis.ActionDefinition.derive_content_type | train | def derive_content_type(example, handler_name)
# MultipartArrays *must* use the provided content_type
if example.kind_of? Praxis::Types::MultipartArray
return MediaTypeIdentifier.load(example.content_type)
end
_, content_type_attribute = self.headers && self.headers.attributes.find { |... | ruby | {
"resource": ""
} |
q18754 | Praxis.MediaTypeIdentifier.without_parameters | train | def without_parameters
if self.parameters.empty?
self
else
MediaTypeIdentifier.load(type: | ruby | {
"resource": ""
} |
q18755 | Praxis.ResponseDefinition.validate_status! | train | def validate_status!(response)
return unless status
# Validate status code if defined in the spec
if response.status != status
raise Exceptions::Validation.new(
"Invalid response code detected. Response %s dictates | ruby | {
"resource": ""
} |
q18756 | Praxis.ResponseDefinition.validate_location! | train | def validate_location!(response)
return if location.nil? || location === response.headers['Location'] | ruby | {
"resource": ""
} |
q18757 | Praxis.ResponseDefinition.validate_content_type! | train | def validate_content_type!(response)
return unless media_type
response_content_type = response.content_type
expected_content_type = Praxis::MediaTypeIdentifier.load(media_type.identifier)
| ruby | {
"resource": ""
} |
q18758 | Praxis.ResponseDefinition.validate_body! | train | def validate_body!(response)
return unless media_type
return if media_type.kind_of? SimpleMediaType
errors = self.media_type.validate(self.media_type.load(response.body))
if errors.any?
message = | ruby | {
"resource": ""
} |
q18759 | Harmony.Page.load | train | def load(*paths)
paths.flatten.each do |path|
| ruby | {
"resource": ""
} |
q18760 | Middleman.S3SyncExtension.read_config | train | def read_config(io = nil)
unless io
root_path = ::Middleman::Application.root
config_file_path = File.join(root_path, ".s3_sync")
# skip if config file does not exist
return unless File.exists?(config_file_path)
io = File.open(config_file_path, "r")
end
| ruby | {
"resource": ""
} |
q18761 | Geo.Coord.strfcoord | train | def strfcoord(formatstr)
h = full_hash
DIRECTIVES.reduce(formatstr) do |memo, (from, to)|
memo.gsub(from) do
| ruby | {
"resource": ""
} |
q18762 | RubySpeech.GenericElement.read_attr | train | def read_attr(attr_name, to_call = nil)
val = self[attr_name]
val && | ruby | {
"resource": ""
} |
q18763 | RubySpeech.GenericElement.write_attr | train | def write_attr(attr_name, value, to_call = nil)
| ruby | {
"resource": ""
} |
q18764 | RubySpeech.GenericElement.namespace= | train | def namespace=(namespaces)
case namespaces
when Nokogiri::XML::Namespace
super namespaces
when String | ruby | {
"resource": ""
} |
q18765 | ActiveModel::Datastore.PropertyValues.default_property_value | train | def default_property_value(attr, value)
if value.is_a?(TrueClass) || value.is_a?(FalseClass)
send("#{attr.to_sym}=", value) if send(attr.to_sym).nil?
else
| ruby | {
"resource": ""
} |
q18766 | ActiveModel::Datastore.PropertyValues.format_property_value | train | def format_property_value(attr, type)
return unless send(attr.to_sym).present?
case type.to_sym
when :integer
send("#{attr.to_sym}=", send(attr.to_sym).to_i)
when :float
send("#{attr.to_sym}=", send(attr.to_sym).to_f)
| ruby | {
"resource": ""
} |
q18767 | ActiveModel::Datastore.NestedAttr.nested_models | train | def nested_models
model_entities = []
nested_attributes.each | ruby | {
"resource": ""
} |
q18768 | ActiveModel::Datastore.NestedAttr.assign_nested_attributes | train | def assign_nested_attributes(association_name, attributes, options = {})
attributes = validate_attributes(attributes)
association_name = association_name.to_sym
send("#{association_name}=", []) if send(association_name).nil?
attributes.each_value do |params|
if params['id'].blank?
... | ruby | {
"resource": ""
} |
q18769 | ActiveModel::Datastore.NestedAttr.assign_to_or_mark_for_destruction | train | def assign_to_or_mark_for_destruction(record, attributes)
record.assign_attributes(attributes.except(*UNASSIGNABLE_KEYS))
| ruby | {
"resource": ""
} |
q18770 | ActiveModel::Datastore.ClassMethods.find_entity | train | def find_entity(id_or_name, parent = nil)
key = CloudDatastore.dataset.key name, id_or_name | ruby | {
"resource": ""
} |
q18771 | ActiveModel::Datastore.ClassMethods.all | train | def all(options = {})
next_cursor = nil
query = build_query(options)
query_results = retry_on_exception { CloudDatastore.dataset.run query }
if options[:limit]
next_cursor | ruby | {
"resource": ""
} |
q18772 | ActiveModel::Datastore.ClassMethods.find_by | train | def find_by(args)
query = CloudDatastore.dataset.query name
query.ancestor(args[:ancestor]) if args[:ancestor]
query.limit(1)
| ruby | {
"resource": ""
} |
q18773 | ActiveModel::Datastore.ClassMethods.query_sort | train | def query_sort(query, options)
query.order(options[:order]) if options[:order]
| ruby | {
"resource": ""
} |
q18774 | Pxlsrt.Image.diagonalColumnRow | train | def diagonalColumnRow(d, i)
{
'column' => (d.to_i < 0 | ruby | {
"resource": ""
} |
q18775 | Pxlsrt.Image.getSobel | train | def getSobel(x, y)
if !defined?(@sobels)
@sobel_x ||= [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]
@sobel_y ||= [[-1, -2, -1], [0, 0, 0], [1, 2, 1]]
return 0 if x.zero? || (x == (@width - 1)) || y.zero? || (y == (@height - 1))
t1 = @grey[y - 1][x - 1]
t2 = @grey[y - 1][x]
t... | ruby | {
"resource": ""
} |
q18776 | Pxlsrt.Image.getSobels | train | def getSobels
unless defined?(@sobels)
l = []
(0...(@width * @height)).each do |xy|
s = getSobel(xy % @width, (xy / | ruby | {
"resource": ""
} |
q18777 | Middleware.Runner.build_call_chain | train | def build_call_chain(stack)
# We need to instantiate the middleware stack in reverse
# order so that each middleware can have a reference to
# the next middleware it has to call. The final middleware
# is always the empty middleware, which does nothing but return.
stack.reverse.inject(EMPT... | ruby | {
"resource": ""
} |
q18778 | Middleware.Builder.insert_before_each | train | def insert_before_each(middleware, *args, &block)
self.stack = stack.reduce([]) do |carry, item|
| ruby | {
"resource": ""
} |
q18779 | Middleware.Builder.delete | train | def delete(index)
index = self.index(index) unless index.is_a?(Integer)
| ruby | {
"resource": ""
} |
q18780 | Pxpay.Notification.to_hash | train | def to_hash
doc = ::Nokogiri::XML( self.response )
hash = {}
doc.at_css("Response").element_children.each do |attribute|
| ruby | {
"resource": ""
} |
q18781 | CloudFoundry.Client.valid_target_url? | train | def valid_target_url?
return false unless cloud_info = cloud_info()
return false unless cloud_info[:name]
| ruby | {
"resource": ""
} |
q18782 | Jikan.Search.result | train | def result
case @type
when :anime
iter { |i| Jikan::AnimeResult.new(i) }
when :manga
iter { |i| Jikan::MangaResult.new(i) }
when :character
| ruby | {
"resource": ""
} |
q18783 | OctocatalogDiff.PuppetDB.parse_url | train | def parse_url(url)
uri = URI(url)
if URI.split(url)[3].nil?
uri.port = uri.scheme == 'https' ? DEFAULT_HTTPS_PORT : DEFAULT_HTTP_PORT
end
raise ArgumentError, "URL #{url} has invalid scheme" unless uri.scheme =~ /^https?$/
parsed_url = { ssl: uri.scheme == 'https', host: uri.host,... | ruby | {
"resource": ""
} |
q18784 | OctocatalogDiff.Catalog.resources | train | def resources
build
raise OctocatalogDiff::Errors::CatalogError, 'Catalog does not appear to have been built' if !valid? && error_message.nil?
raise OctocatalogDiff::Errors::CatalogError, error_message unless valid?
return @catalog['data']['resources'] | ruby | {
"resource": ""
} |
q18785 | OctocatalogDiff.Facts.facts | train | def facts(node = @node, timestamp = false)
raise "Expected @facts to be a hash but it is a #{@facts.class}" unless @facts.is_a?(Hash)
raise "Expected @facts['values'] to be a hash but it is a #{@facts['values'].class}" unless @facts['values'].is_a?(Hash)
f = @facts.dup
f['name'] = node unless no... | ruby | {
"resource": ""
} |
q18786 | OctocatalogDiff.Facts.without | train | def without(remove)
r = remove.is_a?(Array) ? remove : [remove]
obj = dup
r.each { |fact| | ruby | {
"resource": ""
} |
q18787 | OctocatalogDiff.Facts.facts_to_yaml | train | def facts_to_yaml(node = @node)
# Add the header that Puppet needs to treat this as facts. Save the results
# as a string in the option.
f = facts(node)
| ruby | {
"resource": ""
} |
q18788 | JasperRails.JasperReportsRenderer.parameter_value_of | train | def parameter_value_of(param)
_String = Rjb::import 'java.lang.String'
# Using Rjb::import('java.util.HashMap').new, it returns an instance of
# Rjb::Rjb_JavaProxy, so the Rjb_JavaProxy parent is the Rjb module | ruby | {
"resource": ""
} |
q18789 | Delayed.RecurringJob.schedule! | train | def schedule! options = {}
options = options.dup
if run_every = options.delete(:run_every)
options[:run_interval] = serialize_duration(run_every)
end
@schedule_options = options.reverse_merge(@schedule_options || {}).reverse_merge(
run_at: self.class.run_at,
timezone: s... | ruby | {
"resource": ""
} |
q18790 | Yelp.Client.create_methods_from_instance | train | def create_methods_from_instance(instance)
instance.public_methods(false).each do |method_name|
| ruby | {
"resource": ""
} |
q18791 | Yelp.Client.add_method | train | def add_method(instance, method_name)
define_singleton_method(method_name) do |*args|
| ruby | {
"resource": ""
} |
q18792 | Yelp.Configuration.auth_keys | train | def auth_keys
AUTH_KEYS.inject({}) do |keys_hash, key|
| ruby | {
"resource": ""
} |
q18793 | Pod.Lockfile.write_to_disk | train | def write_to_disk(path)
# code here mimics the original method but with link filtering
filename = File.basename(path)
| ruby | {
"resource": ""
} |
q18794 | Pod.Lockfile.to_link_hash | train | def to_link_hash
# retrieve the lock contents with links
after_hash = to_hash
unless File.exists?(PODFILE_LOCK)
return after_hash
end
# retrieve the lock content before the links
before_hash = YAML.load(File.read(PODFILE_LOCK))
# retrieve installed links
links... | ruby | {
"resource": ""
} |
q18795 | Pod.Lockfile.merge_dependencies | train | def merge_dependencies(links, before, after)
links.each do |link|
before_index = find_dependency_index before, link
after_index = find_dependency_index after, link
unless before_index.nil? || | ruby | {
"resource": ""
} |
q18796 | Pod.Lockfile.merge_hashes | train | def merge_hashes(links, before, after)
if before.nil?
return after
end
links.each do |link|
if before.has_key?(link)
| ruby | {
"resource": ""
} |
q18797 | Chaskiq.SesSenderJob.perform | train | def perform(campaign, subscription)
subscriber = subscription.subscriber
return if subscriber.blank?
mailer = campaign.prepare_mail_to(subscription)
response = mailer.deliver
| ruby | {
"resource": ""
} |
q18798 | Chaskiq.Campaign.clean_inline_css | train | def clean_inline_css(url)
premailer = Premailer.new(url, :adapter => :nokogiri, :escape_url_attributes => false)
| ruby | {
"resource": ""
} |
q18799 | Chaskiq.MailSenderJob.perform | train | def perform(campaign)
campaign.apply_premailer
campaign.list.subscriptions.availables.each | ruby | {
"resource": ""
} |
Subsets and Splits
SQL Console for CoIR-Retrieval/CodeSearchNet-ccr-ruby-queries-corpus
Retrieves a large number of entries in the 'ruby' language, providing basic information but limited analytical value.