_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q2000 | RTP.Record.delete_children | train | def delete_children(attribute)
self.send(attribute).each { |c| c.parent = nil }
self.send(attribute).clear
end | ruby | {
"resource": ""
} |
q2001 | RTP.Record.set_attributes | train | def set_attributes(values)
import_indices([values.length - 1, @max_elements - 1].min).each_with_index do |indices, i|
param = nil
if indices
param = values.values_at(*indices)
param = param[0] if param.length == 1
end
self.send("#{@attributes[i]}=", param)
... | ruby | {
"resource": ""
} |
q2002 | RTP.Record.discard_unsupported_attributes | train | def discard_unsupported_attributes(values, options={})
case self
when SiteSetup
options[:version].to_f >= 2.6 ? values : values[0..-4]
when Field
options[:version].to_f >= 2.64 ? values : values[0..-4]
when ExtendedField
options[:version].to_f >= 2.4 ? values : values[0..... | ruby | {
"resource": ""
} |
q2003 | Cfer.Config.include_config | train | def include_config(*files)
include_base = File.dirname(@config_file) if @config_file
files.each do |file|
path = File.join(include_base, file) if include_base
include_file(path || file)
end
end | ruby | {
"resource": ""
} |
q2004 | RTP.Plan.write | train | def write(file, options={})
f = open_file(file)
f.write(to_s(options))
f.close
end | ruby | {
"resource": ""
} |
q2005 | Cfer::Cfn.Client.tail | train | def tail(options = {})
q = []
event_id_highwater = nil
counter = 0
number = options[:number] || 0
for_each_event name do |fetched_event|
q.unshift fetched_event if counter < number
counter = counter + 1
end
while q.size > 0
event = q.shift
yield... | ruby | {
"resource": ""
} |
q2006 | Cfer.Block.build_from_block | train | def build_from_block(*args, &block)
pre_block
Docile.dsl_eval(self, *args, &block) if block
post_block
self
end | ruby | {
"resource": ""
} |
q2007 | RTP.Plan.add_angle | train | def add_angle(item, angle_tag, direction_tag, angle, direction, current_angle)
if !self.send(current_angle) || angle != self.send(current_angle)
self.send("#{current_angle}=", angle)
DICOM::Element.new(angle_tag, angle, :parent => item)
DICOM::Element.new(direction_tag, (direction.empty? ?... | ruby | {
"resource": ""
} |
q2008 | RTP.Plan.add_couch_position | train | def add_couch_position(item, tag, value, current)
if !self.send(current) || value != self.send(current)
self.send("#{current}=", value)
DICOM::Element.new(tag, (value.empty? ? '' : value.to_f * 10), :parent => item)
end
end | ruby | {
"resource": ""
} |
q2009 | RTP.Plan.add_doserate | train | def add_doserate(value, item)
if !@current_doserate || value != @current_doserate
@current_doserate = value
DICOM::Element.new('300A,0115', value, :parent => item)
end
end | ruby | {
"resource": ""
} |
q2010 | RTP.Plan.create_control_point | train | def create_control_point(cp, sequence, options={})
cp_item = DICOM::Item.new(:parent => sequence)
# Some CP attributes will always be written (CP index, BLD positions & Cumulative meterset weight).
# The other attributes are only written if they are different from the previous control point.
# C... | ruby | {
"resource": ""
} |
q2011 | RTP.Plan.create_beam_limiting_devices | train | def create_beam_limiting_devices(beam_item, field)
bl_seq = DICOM::Sequence.new('300A,00B6', :parent => beam_item)
# The ASYMX item ('backup jaws') doesn't exist on all models:
if ['SYM', 'ASY'].include?(field.field_x_mode.upcase)
bl_item_x = DICOM::Item.new(:parent => bl_seq)
DICOM::E... | ruby | {
"resource": ""
} |
q2012 | RTP.Plan.create_asym_item | train | def create_asym_item(cp, dcm_parent, axis, options={})
val1 = cp.send("dcm_collimator_#{axis.to_s}1", options[:scale])
val2 = cp.send("dcm_collimator_#{axis.to_s}2", options[:scale])
item = DICOM::Item.new(:parent => dcm_parent)
# RT Beam Limiting Device Type:
DICOM::Element.new('300A,00B8... | ruby | {
"resource": ""
} |
q2013 | RTP.Plan.create_dose_reference | train | def create_dose_reference(dcm, description)
dr_seq = DICOM::Sequence.new('300A,0010', :parent => dcm)
dr_item = DICOM::Item.new(:parent => dr_seq)
# Dose Reference Number:
DICOM::Element.new('300A,0012', '1', :parent => dr_item)
# Dose Reference Structure Type:
DICOM::Element.new('30... | ruby | {
"resource": ""
} |
q2014 | RTP.Plan.create_referenced_dose_reference | train | def create_referenced_dose_reference(cp_item)
# Referenced Dose Reference Sequence:
rd_seq = DICOM::Sequence.new('300C,0050', :parent => cp_item)
rd_item = DICOM::Item.new(:parent => rd_seq)
# Cumulative Dose Reference Coeffecient:
DICOM::Element.new('300A,010C', '', :parent => rd_item)
... | ruby | {
"resource": ""
} |
q2015 | YamlRecord.Base.save | train | def save
run_callbacks(:before_save)
run_callbacks(:before_create) unless self.is_created
existing_items = self.class.all
if self.new_record?
existing_items << self
else # update existing record
updated_item = existing_items.find { |item| item.id == self.id }
retur... | ruby | {
"resource": ""
} |
q2016 | YamlRecord.Base.destroy | train | def destroy
run_callbacks(:before_destroy)
new_data = self.class.all.reject { |item| item.persisted_attributes == self.persisted_attributes }.map { |item| item.persisted_attributes }
self.class.write_contents(new_data)
self.is_destroyed = true
run_callbacks(:after_destroy)
true
r... | ruby | {
"resource": ""
} |
q2017 | Cfer::Core.Resource.tag | train | def tag(k, v, **options)
self[:Properties][:Tags] ||= []
self[:Properties][:Tags].delete_if { |kv| kv["Key"] == k }
self[:Properties][:Tags].unshift({"Key" => k, "Value" => v}.merge(options))
end | ruby | {
"resource": ""
} |
q2018 | Cfer::Core.Stack.parameter | train | def parameter(name, options = {})
param = {}
options.each do |key, v|
next if v === nil
k = key.to_s.camelize.to_sym
param[k] =
case k
when :AllowedPattern
if v.class == Regexp
v.source
end
when :Default
... | ruby | {
"resource": ""
} |
q2019 | Cfer::Core.Stack.resource | train | def resource(name, type, options = {}, &block)
Preconditions.check_argument(/[[:alnum:]]+/ =~ name, "Resource name must be alphanumeric")
clazz = Cfer::Core::Resource.resource_class(type)
rc = clazz.new(name, type, self, options, &block)
self[:Resources][name] = rc
rc.handle
end | ruby | {
"resource": ""
} |
q2020 | Cfer::Core.Stack.include_template | train | def include_template(*files)
include_base = options[:include_base] || File.dirname(caller.first.split(/:\d/,2).first)
files.each do |file|
path = File.join(include_base, file)
include_file(path)
end
end | ruby | {
"resource": ""
} |
q2021 | Cfer::Core.Stack.lookup_outputs | train | def lookup_outputs(stack)
client = @options[:client] || raise(Cfer::Util::CferError, "Can not fetch stack outputs without a client")
client.fetch_outputs(stack)
end | ruby | {
"resource": ""
} |
q2022 | RackFakeS3.SortedObjectList.list | train | def list(options)
marker = options[:marker]
prefix = options[:prefix]
max_keys = options[:max_keys] || 1000
delimiter = options[:delimiter]
ms = S3MatchSet.new
marker_found = true
pseudo = nil
if marker
marker_found = false
if !@object_map[marker]
... | ruby | {
"resource": ""
} |
q2023 | Gusteau.Config.build_node | train | def build_node(node_name, env_hash, node_hash)
node_config = {
'server' => node_hash.slice('host', 'port', 'user', 'password', 'platform', 'vagrant'),
'attributes' => (node_hash['attributes'] || {}).deep_merge(env_hash['attributes'] || {}),
'run_list' => node_hash['run_list'] || en... | ruby | {
"resource": ""
} |
q2024 | RackFakeS3.Servlet.normalize_request | train | def normalize_request(rack_req)
host = rack_req.host
s_req = Request.new
s_req.path = path_for_rack_request(rack_req)
s_req.is_path_style = true
s_req.rack_request = rack_req
if !@root_hostnames.include?(host)
s_req.bucket = host.split(".")[0]
s_req.is_path_style = ... | ruby | {
"resource": ""
} |
q2025 | Metior.Report.generate | train | def generate(target_dir, with_assets = true)
target_dir = File.expand_path target_dir
copy_assets target_dir if with_assets
render.each do |view_name, output|
file_name = File.join target_dir, view_name.to_s.downcase + '.html'
begin
output_file = File.open file_name, 'wb'
... | ruby | {
"resource": ""
} |
q2026 | Metior.Report.copy_assets | train | def copy_assets(target_dir)
FileUtils.mkdir_p target_dir
self.class.assets.map do |asset|
asset_path = self.class.find asset
asset_dir = File.join target_dir, File.dirname(asset)
FileUtils.mkdir_p asset_dir unless File.exists? asset_dir
FileUtils.cp_r asset_path, asset_dir
... | ruby | {
"resource": ""
} |
q2027 | Metior.Repository.actor | train | def actor(actor)
id = self.class::Actor.id_for(actor)
@actors[id] ||= self.class::Actor.new(self, actor)
end | ruby | {
"resource": ""
} |
q2028 | Metior.Repository.commits | train | def commits(range = current_branch)
range = parse_range range
commits = cached_commits range
if commits.empty?
base_commit, raw_commits = load_commits(range)
commits = build_commits raw_commits
unless base_commit.nil?
base_commit = self.class::Commit.new(self, base_c... | ruby | {
"resource": ""
} |
q2029 | Metior.Repository.file_stats | train | def file_stats(range = current_branch)
support! :file_stats
stats = {}
commits(range).each_value do |commit|
commit.added_files.each do |file|
stats[file] = { :modifications => 0 } unless stats.key? file
stats[file][:added_date] = commit.authored_date
stats[file]... | ruby | {
"resource": ""
} |
q2030 | Metior.Repository.build_commits | train | def build_commits(raw_commits)
child_commit_id = nil
raw_commits.map do |commit|
commit = self.class::Commit.new(self, commit)
commit.add_child child_commit_id unless child_commit_id.nil?
child_commit_id = commit.id
@commits[commit.id] = commit
commit
end
en... | ruby | {
"resource": ""
} |
q2031 | Metior.Repository.cached_commits | train | def cached_commits(range)
commits = []
direction = nil
if @commits.key? range.last
current_commits = [@commits[range.last]]
direction = :parents
elsif @commits.key? range.first
current_commits = [@commits[range.first]]
direction = :children
end
unles... | ruby | {
"resource": ""
} |
q2032 | Metior.Repository.parse_range | train | def parse_range(range)
unless range.is_a? Range
range = range.to_s.split '..'
range = ((range.size == 1) ? '' : range.first)..range.last
end
range = id_for_ref(range.first)..range.last if range.first != ''
range.first..id_for_ref(range.last)
end | ruby | {
"resource": ""
} |
q2033 | Metior::Adapter.ClassMethods.register_for | train | def register_for(vcs)
vcs = Metior.find_vcs vcs
vcs.register_adapter id, self
class_variable_set :@@vcs, vcs
end | ruby | {
"resource": ""
} |
q2034 | BentoSearch.OpenurlCreator.ensure_no_tags | train | def ensure_no_tags(str)
return str unless str.html_safe?
str = str.to_str # get it out of HTMLSafeBuffer, which messes things up
str = strip_tags(str)
str = HTMLEntities.new.decode(str)
return str
end | ruby | {
"resource": ""
} |
q2035 | Route53.DNSRecord.update | train | def update(name,type,ttl,values,comment=nil, zone_apex = nil)
prev = self.clone
@name = name unless name.nil?
@type = type unless type.nil?
@ttl = ttl unless ttl.nil?
@values = values unless values.nil?
@zone_apex = zone_apex unless zone_apex.nil?
@zone.perform_actions([
... | ruby | {
"resource": ""
} |
q2036 | Route53.DNSRecord.update_dirty | train | def update_dirty(name,type,ttl,values,zone_apex = nil)
prev = self.clone
@name = name unless name.nil?
@type = type unless type.nil?
@ttl = ttl unless ttl.nil?
@values = values unless values.nil?
@zone_apex = zone_apex unless zone_apex.nil?
return [{:action => "DELETE", :record... | ruby | {
"resource": ""
} |
q2037 | Metior.ActorCollection.most_significant | train | def most_significant(count = 3)
support! :line_stats
authors = ActorCollection.new
sort_by { |author| -author.modifications }.each do |author|
authors << author
break if authors.size == count
end
authors
end | ruby | {
"resource": ""
} |
q2038 | Metior.ActorCollection.top | train | def top(count = 3)
authors = ActorCollection.new
sort_by { |author| -author.authored_commits.size }.each do |author|
authors << author
break if authors.size == count
end
authors
end | ruby | {
"resource": ""
} |
q2039 | Metior.ActorCollection.load_commits | train | def load_commits(commit_type, actor_id = nil)
commits = CommitCollection.new
if actor_id.nil?
each { |actor| commits.merge! actor.send(commit_type) }
elsif key? actor_id
commits = self[actor_id].send commit_type
end
commits
end | ruby | {
"resource": ""
} |
q2040 | Metior::Adapter::Octokit.Repository.load_commits | train | def load_commits(range)
base_commit = nil
commits = []
last_commit = nil
loop do
new_commits = ::Octokit.commits(@path, nil, :last_sha => last_commit, :per_page => 100, :top => range.last)
break if new_commits.empty?
base_commit_index = new_commits.find_index do |commit|... | ruby | {
"resource": ""
} |
q2041 | Autosign.Validator.validate | train | def validate(challenge_password, certname, raw_csr)
@log.debug "running validate"
fail unless challenge_password.is_a?(String)
fail unless certname.is_a?(String)
case perform_validation(challenge_password, certname, raw_csr)
when true
@log.debug "validated successfully"
@l... | ruby | {
"resource": ""
} |
q2042 | Autosign.Validator.settings | train | def settings
@log.debug "merging settings"
setting_sources = [get_override_settings, load_config, default_settings]
merged_settings = setting_sources.inject({}) { |merged, hash| merged.deep_merge(hash) }
@log.debug "using merged settings: " + merged_settings.to_s
@log.debug "validating mer... | ruby | {
"resource": ""
} |
q2043 | Autosign.Validator.load_config | train | def load_config
@log.debug "loading validator-specific configuration"
config = Autosign::Config.new
if config.settings.to_hash[self.name].nil?
@log.warn "Unable to load validator-specific configuration"
@log.warn "Cannot load configuration section named '#{self.name}'"
return ... | ruby | {
"resource": ""
} |
q2044 | BentoSearch.SearchEngine.fill_in_search_metadata_for | train | def fill_in_search_metadata_for(results, normalized_arguments = {})
results.search_args = normalized_arguments
results.start = normalized_arguments[:start] || 0
results.per_page = normalized_arguments[:per_page]
results.engine_id = configuration.id
results.display_co... | ruby | {
"resource": ""
} |
q2045 | AllscriptsUnityClient.JSONUnityRequest.to_hash | train | def to_hash
action = @parameters[:action]
userid = @parameters[:userid]
appname = @parameters[:appname] || @appname
patientid = @parameters[:patientid]
token = @parameters[:token] || @security_token
parameter1 = process_date(@parameters[:parameter1]) || ''
parameter2 = process_... | ruby | {
"resource": ""
} |
q2046 | AllscriptsUnityClient.Client.get_encounter_list | train | def get_encounter_list(
userid,
patientid,
encounter_type = nil,
when_param = nil,
nostradamus = 0,
show_past_flag = true,
billing_provider_user_name = nil,
show_all = false)
magic_parameters = {
action: 'GetEncounterList',
userid: us... | ruby | {
"resource": ""
} |
q2047 | AllscriptsUnityClient.Client.get_task_list | train | def get_task_list(userid = nil, since = nil, delegated = nil, task_types = nil, task_statuses = nil)
magic_parameters = {
action: 'GetTaskList',
userid: userid,
parameter1: since,
parameter2: task_types,
parameter3: task_statuses,
parameter4: delegated
}
... | ruby | {
"resource": ""
} |
q2048 | Route53.Zone.perform_actions | train | def perform_actions(change_list,comment=nil)
xml_str = gen_change_xml(change_list,comment)
@conn.request(@conn.base_url + @host_url+"/rrset","POST",xml_str)
end | ruby | {
"resource": ""
} |
q2049 | Route53.CLI.process_options | train | def process_options
@options.verbose = false if @options.quiet
@options.file = (user_home+"/.route53") if @options.file.nil?
#setup file
if @options.setup
setup
end
load_config
@config['access_key'] = @options.access unless @options.access.nil?
@... | ruby | {
"resource": ""
} |
q2050 | Route53.CLI.process_arguments | train | def process_arguments
if @options.new_zone
new_zone
elsif @options.delete_zone
delete_zone
elsif @options.create_record
create_record
elsif @options.remove_record
remove_record
elsif @options.change_record
change_record
el... | ruby | {
"resource": ""
} |
q2051 | Mongoid.CachedJson.as_json_partial | train | def as_json_partial(options = {})
options ||= {}
if options[:properties] && !all_json_properties.member?(options[:properties])
fail ArgumentError.new("Unknown properties option: #{options[:properties]}")
end
# partial, unmaterialized JSON
keys, partial_json = self.class.materialize... | ruby | {
"resource": ""
} |
q2052 | Mongoid.CachedJson.as_json_cached | train | def as_json_cached(options = {})
keys, json = as_json_partial(options)
Mongoid::CachedJson.materialize_json_references_with_read_multi(keys, json)
end | ruby | {
"resource": ""
} |
q2053 | Mongoid.CachedJson.expire_cached_json | train | def expire_cached_json
all_json_properties.each do |properties|
[true, false].each do |is_top_level_json|
all_json_versions.each do |version|
Mongoid::CachedJson.config.cache.delete(self.class.cached_json_key({
... | ruby | {
"resource": ""
} |
q2054 | Autosign.Journal.setup | train | def setup
@log.debug "using journalfile: " + self.settings['journalfile']
journalfile = self.settings['journalfile']
store = YAML::Store.new(journalfile, true)
store.ultra_safe = true
return store
end | ruby | {
"resource": ""
} |
q2055 | Autosign.Journal.validate_uuid | train | def validate_uuid(uuid)
unless uuid.is_a?(String)
@log.error "UUID is not a string"
return false
end
unless !!/^\S{8}-\S{4}-4\S{3}-[89abAB]\S{3}-\S{12}$/.match(uuid.to_s)
@log.error "UUID is not a valid V4 UUID"
return false
end
return true
end | ruby | {
"resource": ""
} |
q2056 | Metior.CommitCollection.<< | train | def <<(commit)
return self if key? commit.id
if @additions.nil? && empty? && commit.line_stats?
@additions = commit.additions
@deletions = commit.deletions
elsif !@additions.nil?
@additions += commit.additions
@deletions += commit.deletions
end
super
e... | ruby | {
"resource": ""
} |
q2057 | Metior.CommitCollection.activity | train | def activity
activity = {}
return activity if empty?
commit_count = values.size
active_days = {}
each do |commit|
date = commit.committed_date.utc
day = Time.utc(date.year, date.month, date.day).send :to_date
if active_days.key? day
active_days[day] += ... | ruby | {
"resource": ""
} |
q2058 | Metior.CommitCollection.authors | train | def authors(commit_id = nil)
authors = ActorCollection.new
if commit_id.nil?
each { |commit| authors << commit.author }
elsif key? commit_id
authors << self[commit_id].author
end
authors
end | ruby | {
"resource": ""
} |
q2059 | Metior.CommitCollection.before | train | def before(date)
date = Time.parse date if date.is_a? String
commits = CommitCollection.new
each do |commit|
commits << commit if commit.committed_date < date
end
commits
end | ruby | {
"resource": ""
} |
q2060 | Metior.CommitCollection.by | train | def by(*author_ids)
author_ids = author_ids.flatten.map do |author_id|
author_id.is_a?(Actor) ? author_id.id : author_id
end
commits = CommitCollection.new
each do |commit|
commits << commit if author_ids.include? commit.author.id
end
commits
end | ruby | {
"resource": ""
} |
q2061 | Metior.CommitCollection.changing | train | def changing(*files)
support! :file_stats
commits = CommitCollection.new
each do |commit|
commit_files = commit.added_files + commit.deleted_files + commit.modified_files
commits << commit unless (commit_files & files).empty?
end
commits
end | ruby | {
"resource": ""
} |
q2062 | Metior.CommitCollection.committers | train | def committers(commit_id = nil)
committers = ActorCollection.new
if commit_id.nil?
each { |commit| committers << commit.committer }
elsif key? commit_id
committers << self[commit_id].committer
end
committers
end | ruby | {
"resource": ""
} |
q2063 | Metior.CommitCollection.line_history | train | def line_history
support! :line_stats
history = { :additions => [], :deletions => [] }
values.reverse.each do |commit|
history[:additions] << commit.additions
history[:deletions] << -commit.deletions
end
history
end | ruby | {
"resource": ""
} |
q2064 | Metior.CommitCollection.most_significant | train | def most_significant(count = 10)
support! :line_stats
commits = CommitCollection.new
sort_by { |commit| -commit.modifications }.each do |commit|
commits << commit
break if commits.size == count
end
commits
end | ruby | {
"resource": ""
} |
q2065 | Metior.CommitCollection.with_impact | train | def with_impact(line_count)
support! :line_stats
commits = CommitCollection.new
each do |commit|
commits << commit if commit.modifications >= line_count
end
commits
end | ruby | {
"resource": ""
} |
q2066 | Metior.CommitCollection.load_line_stats | train | def load_line_stats
@additions = 0
@deletions = 0
return if empty?
line_stats = nil
if @range.nil?
ids = values.reject { |c| c.line_stats? }.map { |c| c.id }
line_stats = first.repo.load_line_stats ids unless ids.empty?
else
line_stats = first.repo.load_line... | ruby | {
"resource": ""
} |
q2067 | Metior::Report.View.render | train | def render(*args)
begin
features = self.class.send :class_variable_get, :@@required_features
super if features.all? { |feature| repository.supports? feature }
rescue Metior::UnsupportedError
end
end | ruby | {
"resource": ""
} |
q2068 | BentoSearch.SearchController.search | train | def search
engine = BentoSearch.get_engine(params[:engine_id])
# put it in an iVar mainly for testing purposes.
@engine = engine
unless engine.configuration.allow_routable_results == true
raise AccessDenied.new("engine needs to be registered with :allow_routable_results => true")
... | ruby | {
"resource": ""
} |
q2069 | Metior::Adapter::Grit.Repository.current_branch | train | def current_branch
branch = @grit_repo.head
return branch.name unless branch.nil?
commit = @grit_repo.commit('HEAD')
commit.id unless commit.nil?
end | ruby | {
"resource": ""
} |
q2070 | Metior::Adapter::Grit.Repository.load_line_stats | train | def load_line_stats(ids)
if ids.is_a? Range
if ids.first == ''
range = ids.last
else
range = '%s..%s' % [ids.first, ids.last]
end
options = { :numstat => true, :timeout => false }
output = @grit_repo.git.native :log, options, range
commit_stats ... | ruby | {
"resource": ""
} |
q2071 | Metior::Adapter::Grit.Repository.load_branches | train | def load_branches
Hash[@grit_repo.branches.map { |b| [b.name, b.commit.id] }]
end | ruby | {
"resource": ""
} |
q2072 | Metior::Adapter::Grit.Repository.load_commits | train | def load_commits(range)
if range.first == ''
base_commit = nil
range = range.last
else
base_commit = @grit_repo.commit(range.first)
range = '%s..%s' % [range.first, range.last]
end
options = { :pretty => 'raw', :timeout => false }
output = @grit_repo.git.na... | ruby | {
"resource": ""
} |
q2073 | Metior::Adapter::Grit.Repository.load_name_and_description | train | def load_name_and_description
description = @grit_repo.description
if description.start_with? 'Unnamed repository'
@name = ''
@description = ''
else
description = description.lines.to_a
@name = description.shift.strip
@description = description.jo... | ruby | {
"resource": ""
} |
q2074 | Metior::Adapter::Grit.Repository.load_tags | train | def load_tags
Hash[@grit_repo.tags.map { |b| [b.name, b.commit.id] }]
end | ruby | {
"resource": ""
} |
q2075 | Nestive.LayoutHelper.area | train | def area(name, content=nil, &block)
content = capture(&block) if block_given?
append name, content
render_area name
end | ruby | {
"resource": ""
} |
q2076 | Nestive.LayoutHelper.render_area | train | def render_area(name)
[].tap do |output|
@_area_for.fetch(name, []).reverse_each do |method_name, content|
output.public_send method_name, content
end
end.join.html_safe
end | ruby | {
"resource": ""
} |
q2077 | BentoSearch.GoogleBooksEngine.hash_to_item | train | def hash_to_item(item_response)
v_info = item_response["volumeInfo"] || {}
item = ResultItem.new
item.unique_id = item_response["id"]
item.title = format_title(v_info)
item.publisher = v_info["publisher"]
# previewLink gives you your search results highli... | ruby | {
"resource": ""
} |
q2078 | BentoSearch.GoogleBooksEngine.args_to_search_url | train | def args_to_search_url(arguments)
query = if arguments[:query].kind_of? Hash
#multi-field
arguments[:query].collect {|field, query_value| fielded_query(query_value, field)}.join(" ")
elsif arguments[:search_field]
fielded_query(arguments[:query], arguments[:search_field])
else
... | ruby | {
"resource": ""
} |
q2079 | BentoSearch.StandardDecorator.render_authors_list | train | def render_authors_list
parts = []
first_three = self.authors.slice(0,3)
first_three.each_with_index do |author, index|
parts << _h.content_tag("span", :class => "author") do
self.author_display(author)
end
if (index + 1) < first_three.length
parts << "; "... | ruby | {
"resource": ""
} |
q2080 | BentoSearch.StandardDecorator.render_citation_details | train | def render_citation_details
# \u00A0 is unicode non-breaking space to keep labels and values from
# getting separated.
result_elements = []
result_elements.push("#{I18n.t('bento_search.volume')}\u00A0#{volume}") if volume.present?
result_elements.push("#{I18n.t('bento_search.issue')}\u00... | ruby | {
"resource": ""
} |
q2081 | BentoSearch.StandardDecorator.render_summary | train | def render_summary
summary = nil
max_chars = (self.display_configuration.try {|h| h["summary_max_chars"]}) || 280
if self.snippets.length > 0 && !(self.display_configuration.try {|h| h["prefer_abstract_as_summary"]} && self.abstract)
summary = self.snippets.first
self.snippets.slice... | ruby | {
"resource": ""
} |
q2082 | Autosign.Config.configfile | train | def configfile
@log.debug "Finding config file"
@config_file_paths.each { |file|
@log.debug "Checking if file '#{file}' exists"
if File.file?(file)
@log.debug "Reading config file from: " + file
config_file = File.read(file)
parsed_config_file = YAML.load(config... | ruby | {
"resource": ""
} |
q2083 | Autosign.Config.validate_config_file | train | def validate_config_file(configfile = location)
@log.debug "validating config file"
unless File.file?(configfile)
@log.error "configuration file not found at: #{configfile}"
raise Autosign::Exceptions::NotFound
end
# check if file is world-readable
if File.world_readable?(... | ruby | {
"resource": ""
} |
q2084 | BentoSearch.RISCreator.format_author_name | train | def format_author_name(author)
if author.last.present? && author.first.present?
str = "#{author.last}, #{author.first}"
if author.middle.present?
middle = author.middle
middle += "." if middle.length == 1
str += " #{middle}"
end
return str
elsif ... | ruby | {
"resource": ""
} |
q2085 | SendWithUs.Api.send_email | train | def send_email(email_id, to, options = {})
if email_id.nil?
raise SendWithUs::ApiNilEmailId, 'email_id cannot be nil'
end
payload = {
email_id: email_id,
recipient: to
}
if options[:data] && options[:data].any?
payload[:email_data] = options[:data]
e... | ruby | {
"resource": ""
} |
q2086 | ActiveAdmin.Duplicatable.enable_resource_duplication_via_form | train | def enable_resource_duplication_via_form
action_item(*compatible_action_item_parameters) do
if controller.action_methods.include?('new') && authorized?(ActiveAdmin::Auth::CREATE, active_admin_config.resource_class)
link_to(I18n.t(:duplicate_model, default: "Duplicate %{model}", scope: [:active_a... | ruby | {
"resource": ""
} |
q2087 | ActiveAdmin.Duplicatable.enable_resource_duplication_via_save | train | def enable_resource_duplication_via_save
action_item(*compatible_action_item_parameters) do
if controller.action_methods.include?('new') && authorized?(ActiveAdmin::Auth::CREATE, active_admin_config.resource_class)
link_to(I18n.t(:duplicate_model, default: "Duplicate %{model}", scope: [:active_a... | ruby | {
"resource": ""
} |
q2088 | ActiveAdmin.Duplicatable.enable_resource_duplication_via_custom_method | train | def enable_resource_duplication_via_custom_method(method)
action_item(*compatible_action_item_parameters) do
if controller.action_methods.include?('new') && authorized?(ActiveAdmin::Auth::CREATE, active_admin_config.resource_class)
link_to(I18n.t(:duplicate_model, default: "Duplicate %{model}", ... | ruby | {
"resource": ""
} |
q2089 | GnuplotRB.ErrorHandling.check_errors | train | def check_errors(raw: false)
return if @err_array.empty?
command = ''
rest = ''
@semaphore.synchronize do
command = @err_array.first
rest = @err_array[1..-1].join('; ')
@err_array.clear
end
message = if raw
"#{command};#{rest}}"
else
"Err... | ruby | {
"resource": ""
} |
q2090 | GnuplotRB.ErrorHandling.handle_stderr | train | def handle_stderr(stream)
@err_array = []
# synchronize access to @err_array
@semaphore = Mutex.new
Thread.new do
until (line = stream.gets).nil?
line.strip!
@semaphore.synchronize { @err_array << line if line.size > 3 }
end
end
end | ruby | {
"resource": ""
} |
q2091 | GnuplotRB.OptionHandling.option | train | def option(key, *value)
if value.empty?
value = options[key]
value = value[0] if value && value.size == 1
value
else
options(key => value)
end
end | ruby | {
"resource": ""
} |
q2092 | Blurrily.Client.put | train | def put(needle, ref, weight = 0)
check_valid_needle(needle)
check_valid_ref(ref)
raise(ArgumentError, "WEIGHT value must be in #{WEIGHT_RANGE}") unless WEIGHT_RANGE.include?(weight)
cmd = ["PUT", @db_name, needle, ref, weight]
send_cmd_and_get_results(cmd)
return
end | ruby | {
"resource": ""
} |
q2093 | SfnParameters.Utils.lock_content | train | def lock_content(content)
content = content.to_smash
content.merge!(:sfn_lock_enabled => true)
safe = SfnParameters::Safe.build(
config.fetch(:sfn_parameters, :safe, Smash.new)
)
safe.lock(dump_json(content))
end | ruby | {
"resource": ""
} |
q2094 | SfnParameters.Utils.unlock_content | train | def unlock_content(content)
content = content.to_smash
if content[:sfn_parameters_lock]
safe = SfnParameters::Safe.build(
config.fetch(:sfn_parameters, :safe, Smash.new)
)
load_json(safe.unlock(content)).to_smash.merge(:sfn_lock_enabled => true)
else
content
... | ruby | {
"resource": ""
} |
q2095 | Clockwork.API.balance | train | def balance
xml = Clockwork::XML::Balance.build( self )
response = Clockwork::HTTP.post( Clockwork::API::BALANCE_URL, xml, @use_ssl )
balance = Clockwork::XML::Balance.parse( response )
end | ruby | {
"resource": ""
} |
q2096 | GnuplotRB.Multiplot.mix_options | train | def mix_options(options)
all_options = @options.merge(options)
specific_options, plot_options = all_options.partition { |key, _value| specific_option?(key) }
yield(plot_options, default_options.merge(specific_options))
end | ruby | {
"resource": ""
} |
q2097 | RRSchedule.Schedule.generate | train | def generate(params={})
raise "You need to specify at least 1 team" if @teams.nil? || @teams.empty?
raise "You need to specify at least 1 rule" if @rules.nil? || @rules.empty?
arrange_flights
init_stats
@gamedays = []; @rounds = []
@flights.each_with_index do |teams,flight_id|
... | ruby | {
"resource": ""
} |
q2098 | RRSchedule.Schedule.to_s | train | def to_s
res = ""
res << "#{self.gamedays.size.to_s} gamedays\n"
self.gamedays.each do |gd|
res << gd.date.strftime("%Y-%m-%d") + "\n"
res << "==========\n"
gd.games.sort{|g1,g2| g1.gt == g2.gt ? g1.ps <=> g2.ps : g1.gt <=> g2.gt}.each do |g|
res << "#{g.ta.to_s} VS #... | ruby | {
"resource": ""
} |
q2099 | RRSchedule.Schedule.next_game_date | train | def next_game_date(dt,wday)
dt += 1 until wday == dt.wday && !self.exclude_dates.include?(dt)
dt
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.