_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 30
4.3k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q500 | Krikri.SearchIndex.bulk_update_batches | train | def bulk_update_batches(aggregations)
en = Enumerator.new do |e|
i = 1
batch = []
aggregations.each do |agg|
batch << agg
if i % @bulk_update_size == 0
e.yield batch
| ruby | {
"resource": ""
} |
q501 | Krikri.SearchIndex.incremental_update_from_activity | train | def incremental_update_from_activity(activity)
entities_as_json_hashes(activity).each do |h|
| ruby | {
"resource": ""
} |
q502 | Krikri.QASearchIndex.schema_keys | train | def schema_keys
schema_file = File.join(Rails.root, 'solr_conf', 'schema.xml')
file = | ruby | {
"resource": ""
} |
q503 | Krikri.QASearchIndex.flat_hash | train | def flat_hash(hash, keys = [])
new_hash = {}
hash.each do |key, val|
new_hash[format_key(keys + [key])] = val unless
val.is_a?(Array) || val.is_a?(Hash)
new_hash.merge!(flat_hash(val, keys + [key])) if val.is_a? Hash
if val.is_a? Array
val.each do |v|
if v.is_a? Hash
new_hash.merge!(flat_hash(v, keys + [key])) do |key, f, s|
Array(f) << s
| ruby | {
"resource": ""
} |
q504 | MeterCat.Calculator.dependencies | train | def dependencies(names)
names.each do |name|
calculation = fetch(name, nil)
next unless calculation
calculation.dependencies.each do |dependency|
| ruby | {
"resource": ""
} |
q505 | Krikri::Harvesters.CouchdbHarvester.count | train | def count(opts = {})
view = opts[:view] || @opts[:view]
# The count that we want is the total documents in the database minus
# CouchDB design documents. Asking for the design documents will give us
# the total count in addition to letting us determine the number of
# design documents.
v = client.view(view,
include_docs: false,
stream: false, | ruby | {
"resource": ""
} |
q506 | Krikri::Harvesters.CouchdbHarvester.records | train | def records(opts = {})
view = opts[:view] || @opts[:view]
limit = opts[:limit] || @opts[:limit]
record_rows(view, limit).map do |row|
@record_class.build(
| ruby | {
"resource": ""
} |
q507 | Krikri::Harvesters.CouchdbHarvester.record_rows | train | def record_rows(view, limit)
en = Enumerator.new do |e|
view_opts = {include_docs: true, stream: false, limit: limit}
rows_retrieved = 0
total_rows = nil
loop do
v = client.view(view, view_opts)
| ruby | {
"resource": ""
} |
q508 | Krikri::Harvesters.CouchdbHarvester.get_record | train | def get_record(identifier)
doc = client.get!(CGI.escape(identifier)).body.to_json
| ruby | {
"resource": ""
} |
q509 | SimpleNotifications.Base.open_receiver_class | train | def open_receiver_class
# Define association for receiver model
[receivers_class(@@options[:receivers])].flatten.each do |base|
base.class_eval do
has_many :deliveries, class_name: 'SimpleNotifications::Delivery', as: :receiver
| ruby | {
"resource": ""
} |
q510 | SimpleNotifications.Base.sender_class | train | def sender_class(sender)
if sender.kind_of? Symbol
reflections[sender.to_s].klass
elsif sender.kind_of? ActiveRecord::Base
sender.class
| ruby | {
"resource": ""
} |
q511 | SimpleNotifications.Base.receivers_class | train | def receivers_class(receivers)
if receivers.kind_of? Symbol
reflections[receivers.to_s].klass
else
if receivers.kind_of? ActiveRecord::Base
receivers.class
elsif receivers.kind_of? ActiveRecord::Relation
receivers.klass
elsif receivers.kind_of? Array
| ruby | {
"resource": ""
} |
q512 | Krikri::Harvesters.ApiHarvester.next_options | train | def next_options(opts, record_count)
old_start = opts['params'].fetch('start', | ruby | {
"resource": ""
} |
q513 | Tandem.Page.do_before_validation | train | def do_before_validation
prim_slug, i = slug, 0
prim_slug, i = $1, $2.to_i if slug =~ /^(.*)_([0-9]+)$/
return unless prim_slug.present?
attempts = 0 | ruby | {
"resource": ""
} |
q514 | Conjur::Policy::Executor.CreateRecord.create_parameters | train | def create_parameters
{
record.id_attribute => record.id
}.tap do |params|
custom_attrs = attribute_names.inject({}) do |memo, attr|
value = record.send(attr)
memo[attr.to_s] = value if value
| ruby | {
"resource": ""
} |
q515 | Http.NativeParser.fill_rack_env | train | def fill_rack_env(env = {})
env["rack.input"] = @body || StringIO.new
env["REQUEST_METHOD"] = @method
env["SCRIPT_NAME"] = ""
env["REQUEST_URI"] = @path
env["PATH_INFO"], query = @path.split("?", 2)
env["QUERY_STRING"] = query || ""
if (@headers["HOST"] && !env["SERVER_NAME"])
env["SERVER_NAME"], port = @headers["HOST"].split(":", 2)
env["SERVER_PORT"] = port | ruby | {
"resource": ""
} |
q516 | Sequel.ConnectionPool.make_new | train | def make_new(server)
begin
conn = @db.connect(server)
if ac = @after_connect
case ac.arity
when 3
ac.call(conn, server, @db)
when 2
ac.call(conn, server)
else
ac.call(conn)
end | ruby | {
"resource": ""
} |
q517 | Krikri.AsyncUriGetter.add_request | train | def add_request(uri: nil, headers: {}, opts: {})
fail ArgumentError, "uri must be a URI; got: #{uri}" unless uri.is_a?(URI)
| ruby | {
"resource": ""
} |
q518 | Exportable.Utils.get_export_options | train | def get_export_options(model, options)
default_options = { only: model.attribute_names.map(&:to_sym),
except: [],
methods: [],
header: true }
options = default_options.merge(options)
unless options[:only].is_a?(Array) && options[:except].is_a?(Array) && options[:methods].is_a?(Array)
| ruby | {
"resource": ""
} |
q519 | DockerCloud.NodeTypeAPI.get | train | def get(provider_name, node_type_name)
name = "#{provider_name}/#{node_type_name}/" | ruby | {
"resource": ""
} |
q520 | LosantRest.ApplicationKeys.get | train | def get(params = {})
params = Utils.symbolize_hash_keys(params)
query_params = { _actions: false, _links: true, _embedded: true }
headers = {}
body = nil
raise ArgumentError.new("applicationId is required") unless params.has_key?(:applicationId)
query_params[:sortField] = params[:sortField] if params.has_key?(:sortField)
query_params[:sortDirection] = params[:sortDirection] if params.has_key?(:sortDirection)
query_params[:page] = params[:page] if params.has_key?(:page)
query_params[:perPage] = params[:perPage] if params.has_key?(:perPage)
query_params[:filterField] = params[:filterField] if params.has_key?(:filterField)
query_params[:filter] = params[:filter] if params.has_key?(:filter)
| ruby | {
"resource": ""
} |
q521 | LosantRest.ApplicationKeys.post | train | def post(params = {})
params = Utils.symbolize_hash_keys(params)
query_params = { _actions: false, _links: true, _embedded: true }
headers = {}
body = nil
raise ArgumentError.new("applicationId is required") unless params.has_key?(:applicationId)
raise ArgumentError.new("applicationKey is required") unless params.has_key?(:applicationKey)
body = params[:applicationKey] if params.has_key?(:applicationKey) | ruby | {
"resource": ""
} |
q522 | SpatialFeatures.Utils.class_of | train | def class_of(object)
case object
when ActiveRecord::Base
object.class
when ActiveRecord::Relation
object.klass
| ruby | {
"resource": ""
} |
q523 | Announce.Subscriber.delegate_event | train | def delegate_event(event)
@message = event.deep_symbolize_keys
@subject = message[:subject]
@action = message[:action]
if [message, subject, action].any? { |a| a.nil? }
raise "Message, subject, and | ruby | {
"resource": ""
} |
q524 | EasyRSA.Config.load! | train | def load!(path)
settings = YAML.load(ERB.new(File.new(path).read).result) | ruby | {
"resource": ""
} |
q525 | Krikri.RecordsController.records_by_provider | train | def records_by_provider(solr_params, user_params)
if @provider_id.present?
rdf_subject = Krikri::Provider.base_uri | ruby | {
"resource": ""
} |
q526 | Geotrigger.Model.post_list | train | def post_list models, params = {}, default_params = {}
model = models.sub /s$/, ''
params = default_params.merge params
post(model + '/list', params)[models].map do |data|
| ruby | {
"resource": ""
} |
q527 | Geotrigger.Model.method_missing | train | def method_missing meth, *args
meth_s = meth.to_s
if meth_s =~ /=$/ and args.length == 1
key = meth_s.sub(/=$/,'').camelcase
if @data and @data.key? key
@data[key] = args[0]
else
super meth, *args | ruby | {
"resource": ""
} |
q528 | Net.HTTP.request_body_from | train | def request_body_from(req, body)
req.body.nil? || req.body.size | ruby | {
"resource": ""
} |
q529 | Krikri::Enrichments.LanguageToLexvo.enrich_value | train | def enrich_value(value)
return enrich_node(value) if value.is_a?(ActiveTriples::Resource) &&
value.node?
| ruby | {
"resource": ""
} |
q530 | Krikri::Enrichments.LanguageToLexvo.enrich_literal | train | def enrich_literal(label)
node = DPLA::MAP::Controlled::Language.new()
node.providedLabel = label
match = match_iso(label.to_s)
match = match_label(label.to_s) if match.node? | ruby | {
"resource": ""
} |
q531 | Mongoid.Orderable.move_above | train | def move_above(other)
if position > other.position
new_position = other.position
other.lower_siblings.where(:position.lt => self.position).each { |s| s.inc(:position, 1) }
other.inc(:position, 1)
self.position = new_position
save!
else
| ruby | {
"resource": ""
} |
q532 | Yap::Shell.Parser::Lexer.whitespace_token | train | def whitespace_token
if md=WHITESPACE.match(@chunk)
input = md.to_a[0]
input.length
| ruby | {
"resource": ""
} |
q533 | Yap::Shell.Parser::Lexer.string_token | train | def string_token
if %w(' ").include?(@chunk[0])
result = process_string @chunk[0..-1], @chunk[0]
if @looking_for_args
token :Argument, result.str, attrs: { quoted_by: @chunk[0] }
else
token | ruby | {
"resource": ""
} |
q534 | Krikri.QAReport.generate_field_report! | train | def generate_field_report!
report = field_queries.inject({}) do |report_hash, (k, v)|
report_hash[k] = solutions_to_hash(v.execute)
| ruby | {
"resource": ""
} |
q535 | Krikri.QAReport.generate_count_report! | train | def generate_count_report!
report = count_queries.inject({}) do |report_hash, (k, v)|
report_hash[k] = solutions_to_counts(v.execute)
| ruby | {
"resource": ""
} |
q536 | Sequelizer.ConnectionMaker.connection | train | def connection
opts = options.to_hash
extensions = options.extensions
conn = if url = (opts.delete(:uri) || opts.delete(:url))
Sequel.connect(url, opts)
else
# Kerberos related options
realm = opts[:realm]
host_fqdn = opts[:host_fqdn] || opts[:host]
principal = opts[:principal]
adapter = opts[:adapter]
if adapter =~ /\Ajdbc_/
user = opts[:user]
password = opts[:password]
end
case opts[:adapter] && opts[:adapter].to_sym
when :jdbc_hive2
opts[:adapter] = :jdbc
auth = if realm
";principal=#{e principal}/#{e host_fqdn}@#{e realm}"
elsif user
";user=#{e user};password=#{e password}"
else
';auth=noSasl'
end
opts[:uri] = "jdbc:hive2://#{e opts[:host]}:#{opts.fetch(:port, 21050).to_i}/#{e(opts[:database] || 'default')}#{auth}"
when :jdbc_impala
opts[:adapter] = :jdbc
auth = if realm
";AuthMech=1;KrbServiceName=#{e principal};KrbAuthType=2;KrbHostFQDN=#{e host_fqdn};KrbRealm=#{e realm}"
elsif user
if password
";AuthMech=3;UID=#{e user};PWD=#{e password}"
else
";AuthMech=2;UID=#{e user}"
end
| ruby | {
"resource": ""
} |
q537 | AvroSchemaRegistry.Client.register | train | def register(subject, schema, **params)
lookup_subject_schema(subject, schema)
rescue Excon::Errors::NotFound
| ruby | {
"resource": ""
} |
q538 | AvroSchemaRegistry.Client.compatible? | train | def compatible?(subject, schema, version = 'latest', **params)
data = post("/compatibility/subjects/#{subject}/versions/#{version}",
expects: [200, 404],
| ruby | {
"resource": ""
} |
q539 | Pollster.ApiClient.call_api_tsv | train | def call_api_tsv(http_method, path, opts = {})
request = build_request(http_method, path, opts)
response = request.run
if @config.debugging
@config.logger.debug "HTTP response body ~BEGIN~\n#{response.body}\n~END~\n"
end
unless response.success?
if response.timed_out?
fail ApiError.new('Connection timed out')
elsif response.code == 0
# Errors from libcurl will be made visible here
| ruby | {
"resource": ""
} |
q540 | SortingTableFor.FormatCell.render_cell_tbody | train | def render_cell_tbody
if @type == :action
cell_value = action_link_to(@ask)
elsif @ask
cell_value = (@ask.is_a?(Symbol)) ? format_cell_value(@object[@ask], @ask) : format_cell_value(@ask)
else
cell_value = @block
end
cell_value = | ruby | {
"resource": ""
} |
q541 | SortingTableFor.FormatCell.render_cell_thead | train | def render_cell_thead
if @ask
cell_value = (@ask.is_a?(Symbol)) ? I18n.t(@ask, {}, :header) : @ask
else
cell_value = @block
end
if @can_sort
sort_on = @options[:sort_as] || @ask
@html_options.merge!(:class => "#{@html_options[:class]} #{sorting_html_class(sort_on)}".strip)
| ruby | {
"resource": ""
} |
q542 | SortingTableFor.FormatCell.action_link_to | train | def action_link_to(action, block = nil)
object_or_array = @@object_or_array.clone
object_or_array.push @object
return case action.to_sym
when :delete
create_link_to(block || I18n.t(:delete), object_or_array, @@options[:link_remote], :delete, I18n.t(:confirm_delete))
when :show
| ruby | {
"resource": ""
} |
q543 | SortingTableFor.FormatCell.create_link_to | train | def create_link_to(block, url, remote, method = nil, confirm = nil)
if remote
return link_to(block, url, | ruby | {
"resource": ""
} |
q544 | SortingTableFor.FormatCell.format_cell_value | train | def format_cell_value(value, attribute = nil)
unless (ret_value = format_cell_value_as_ask(value)).nil?
| ruby | {
"resource": ""
} |
q545 | SortingTableFor.FormatCell.format_cell_value_as_type | train | def format_cell_value_as_type(value, attribute)
if value.is_a?(Time) or value.is_a?(Date)
return ::I18n.l(value, :format => @options[:format] || TableBuilder.i18n_default_format_date)
| ruby | {
"resource": ""
} |
q546 | Krikri.QaReportsController.show | train | def show
@report = Krikri::QAReport.find(params[:id])
@type = params[:type] == 'count' ? :count : :field
respond_to do |format|
| ruby | {
"resource": ""
} |
q547 | Sequelizer.EnvConfig.options | train | def options
Dotenv.load
seq_config = ENV.keys.select { |key| key =~ /^SEQUELIZER_/ }.inject({}) do |config, key|
new_key = key.gsub(/^SEQUELIZER_/, '').downcase
config[new_key] = ENV[key]
config
end
db_config = ENV.keys.select { |key| key =~ | ruby | {
"resource": ""
} |
q548 | RCON.Query.cvar | train | def cvar(cvar_name)
response = command(cvar_name)
match = /^.+?\s(?:is|=)\s"([^"]+)".*$/.match response
match = match[1]
if /\D/.match | ruby | {
"resource": ""
} |
q549 | RCON.Source.command | train | def command(command)
if ! @authed
raise NetworkException.new("You must authenticate the connection successfully before sending commands.")
end
@packet = Packet::Source.new
@packet.command(command)
@socket.print @packet.to_s
rpacket = build_response_packet
if rpacket.command_type != Packet::Source::RESPONSE_NORM
| ruby | {
"resource": ""
} |
q550 | RCON.Source.auth | train | def auth(password)
establish_connection
@packet = Packet::Source.new
@packet.auth(password)
@socket.print @packet.to_s
# on auth, one junk packet is sent
rpacket = nil
2.times { rpacket = build_response_packet }
if rpacket.command_type != Packet::Source::RESPONSE_AUTH
| ruby | {
"resource": ""
} |
q551 | SortingTableFor.FormatLine.add_cell | train | def add_cell(object, args, type = nil, block = nil)
@cells << | ruby | {
"resource": ""
} |
q552 | SortingTableFor.FormatLine.content_columns | train | def content_columns
model_name(@object).constantize.content_columns.collect { |c| | ruby | {
"resource": ""
} |
q553 | SortingTableFor.FormatLine.model_have_column? | train | def model_have_column?(column)
model_name(@object).constantize.content_columns.each do |model_column|
| ruby | {
"resource": ""
} |
q554 | SortingTableFor.FormatLine.format_options_to_cell | train | def format_options_to_cell(ask, options = @column_options)
options.each do |key, value|
if only_cell_option?(key)
if ask.is_a? Hash
ask.merge!(key => value)
else
| ruby | {
"resource": ""
} |
q555 | DictionaryRB.Word.dictionary_meaning | train | def dictionary_meaning
if @dictionary_meaning.nil?
@dictionary = Dictionary.new(@word)
meanings = @dictionary.meanings
| ruby | {
"resource": ""
} |
q556 | DictionaryRB.Word.urban_meaning | train | def urban_meaning
if @urban_meaning.nil?
@urban = Urban.new(@word)
meanings = @urban.meanings
if meanings.is_a?(Array) and not meanings.empty?
| ruby | {
"resource": ""
} |
q557 | AdhearsionASR.ControllerMethods.ask | train | def ask(*args)
options = args.last.kind_of?(Hash) ? args.pop : {}
prompts = args.flatten.compact
if block_given?
logger.warn "You passed a block to #ask, but this functionality is not available in adhearsion-asr. If you're looking for the block validator functionality, you should avoid using it in favour of grammars, and it is deprecated in Adhearsion Core."
end
options[:grammar] || options[:grammar_url] || options[:limit] || options[:terminator] || raise(ArgumentError, "You must specify | ruby | {
"resource": ""
} |
q558 | AdhearsionASR.ControllerMethods.menu | train | def menu(*args, &block)
raise ArgumentError, "You must specify a block to build the menu" unless block
options = args.last.kind_of?(Hash) ? args.pop : {}
prompts = args.flatten.compact
menu_builder = | ruby | {
"resource": ""
} |
q559 | SpatialFeatures.ClassMethods.spatial_join | train | def spatial_join(other, buffer = 0, table_alias = 'features', other_alias = 'other_features', geom = 'geom_lowres')
scope = features_scope(self).select("#{geom} AS geom").select(:spatial_model_id)
other_scope = features_scope(other)
other_scope = other_scope.select("ST_Union(#{geom}) AS geom").select("ST_Buffer(ST_Union(#{geom}), #{buffer.to_i}) AS buffered_geom")
return joins(%Q(INNER JOIN (#{scope.to_sql}) AS | ruby | {
"resource": ""
} |
q560 | Krikri.Enricher.chain_enrichments! | train | def chain_enrichments!(agg)
chain.keys.each do |e|
enrichment = enrichment_cache(e)
if enrichment.is_a? Audumbla::FieldEnrichment
agg = do_field_enrichment(agg, enrichment, chain[e])
| ruby | {
"resource": ""
} |
q561 | Krikri.Enricher.deep_sym | train | def deep_sym(obj)
if obj.is_a? Hash
return obj.inject({}) do |memo, (k, v)|
memo[k.to_sym] = deep_sym(v)
memo
end
elsif obj.is_a? Array
return obj.inject([]) do |memo, el|
memo << deep_sym(el)
| ruby | {
"resource": ""
} |
q562 | MeterCat.Meter.add | train | def add
meter = nil
Meter.uncached { meter = Meter.find_by_name_and_created_on(name, created_on) }
meter | ruby | {
"resource": ""
} |
q563 | Geotrigger.Tag.post_update | train | def post_update
raise StateError.new 'device access_token prohibited' if @session.device?
post_data | ruby | {
"resource": ""
} |
q564 | Geotrigger.Device.post_update | train | def post_update
post_data = @data.dup
case @session.type
when :application
post_data['deviceIds'] = post_data.delete 'deviceId'
| ruby | {
"resource": ""
} |
q565 | DictionaryRB.Urban.meanings | train | def meanings
url = PREFIX + CGI::escape(@word)
@doc ||= Nokogiri::HTML(open(url))
#nodes = @doc.css('div#outer.container div.row.three_columns div.span6 div#content div.box div.inner div.meaning')
nodes = @doc.css('.meaning')
| ruby | {
"resource": ""
} |
q566 | Krikri.Mapper.define | train | def define(name, opts = {}, &block)
klass = opts.fetch(:class, DPLA::MAP::Aggregation)
parser = opts.fetch(:parser, Krikri::XmlParser)
parser_args = opts.fetch(:parser_args, nil)
map = | ruby | {
"resource": ""
} |
q567 | Krikri.Harvester.run | train | def run(activity_uri = nil)
records.each do |rec|
next if rec.nil?
begin
process_record(rec, activity_uri)
rescue => e
Krikri::Logger.log :error, "Error harvesting record:\n" \
| ruby | {
"resource": ""
} |
q568 | Krikri.ProvenanceQueryClient.find_by_activity | train | def find_by_activity(activity_uri, include_invalidated = false)
raise ArgumentError, 'activity_uri must be an RDF::URI' unless
activity_uri.respond_to? :to_term
query = SPARQL_CLIENT.select(:record)
.where([:record,
[RDF::PROV.wasGeneratedBy, '|', RDF::DPLA.wasRevisedBy],
activity_uri.to_term])
if include_invalidated
query
else
# We need to say "and if RDF::PROV.invalidatedAtTime is not set."
#
# The SPARQL query should be:
#
# PREFIX prov: <http://www.w3.org/ns/prov#>
# SELECT * WHERE {
# ?subject prov:wasGeneratedBy <http://xampl.org/ldp/activity/n> .
# FILTER NOT EXISTS { ?subject prov:invalidatedAtTime ?x }
| ruby | {
"resource": ""
} |
q569 | NanoleafRuby.Api.ct_increment | train | def ct_increment(increment = 1)
params = { ct: {} }
params[:ct][:increment] | ruby | {
"resource": ""
} |
q570 | OpenTox.QMRFReport.change_catalog | train | def change_catalog catalog, id, valuehash
catalog_exists? catalog
if @report.at_css("#{catalog}").at("[@id='#{id}']")
valuehash.each do |key, value|
@report.at_css("#{catalog}").at("[@id='#{id}']")["#{key}"]= value
end
else
cat = @report.at_css("#{catalog}")
| ruby | {
"resource": ""
} |
q571 | OpenTox.QMRFReport.get_catalog_value | train | def get_catalog_value catalog, id, key
catalog_exists? catalog
if @report.at_css("#{catalog}").at("[@id='#{id}']") | ruby | {
"resource": ""
} |
q572 | Krikri.ApplicationHelper.link_to_current_page_by_provider | train | def link_to_current_page_by_provider(provider)
provider = Krikri::Provider.find(provider) if provider.is_a? String
return link_to_provider_page(provider) if params[:controller] ==
| ruby | {
"resource": ""
} |
q573 | MeterCat.MetersHelper.meter_description | train | def meter_description(name)
content_tag(:p) do
concat content_tag(:b, name)
concat ' - '
| ruby | {
"resource": ""
} |
q574 | MeterCat.MetersHelper.meter_descriptions | train | def meter_descriptions(meters)
content_tag(:ul) do
meters.keys.sort.each do |name|
| ruby | {
"resource": ""
} |
q575 | MeterCat.MetersHelper.meter_form | train | def meter_form(date, days, names, all_names)
render partial: 'form', locals: { date: | ruby | {
"resource": ""
} |
q576 | HelenaAdministration.ApplicationHelper.truncate_between | train | def truncate_between(str, after = 30)
str = '' if str.nil?
str.length | ruby | {
"resource": ""
} |
q577 | Geotrigger.Session.post | train | def post path, params = {}, other_headers = {}
r = @hc.post BASE_URL % path, params.to_json, headers(other_headers)
raise GeotriggerError.new r.body unless r.status == 200
| ruby | {
"resource": ""
} |
q578 | Geotrigger.Session.raise_error | train | def raise_error error
ge = GeotriggerError.new error['message']
ge.code = error['code']
ge.headers = error['headers']
ge.message = error['message']
| ruby | {
"resource": ""
} |
q579 | Krikri::Enrichments.SplitCoordinates.coord_values | train | def coord_values(s)
coords = s.split(/ *, */)
return [nil, nil] if coords.size != 2
coords.map! { |c| c.to_f.to_s == c ? c : nil } # must be decimal ...
| ruby | {
"resource": ""
} |
q580 | RspecSpinner.RspecSpinnerBase.example_pending | train | def example_pending(example, message, deprecated_pending_location=nil)
immediately_dump_pending(example.description, | ruby | {
"resource": ""
} |
q581 | Krikri::LDP.Resource.make_request | train | def make_request(method, body = nil, headers = {})
validate_subject
ldp_connection.send(method) do |request|
request.url rdf_subject
| ruby | {
"resource": ""
} |
q582 | Krikri.ProvidersController.show | train | def show
if params[:set_session]
session[:current_provider] = params[:id]
redirect_to :back, provider: params[:id]
elsif params[:clear_session]
session.delete :current_provider | ruby | {
"resource": ""
} |
q583 | Distillery.Document.remove_unlikely_elements! | train | def remove_unlikely_elements!
search('*').each do |element|
idclass = "#{element['class']}#{element['id']}"
| ruby | {
"resource": ""
} |
q584 | Distillery.Document.score! | train | def score!
mark_scorable_elements!
scorable_elements.each do |element|
points = 1
points += element.text.split(',').length
points += [element.text.length / 100, 3].min
scores[element.path] = points
| ruby | {
"resource": ""
} |
q585 | Distillery.Document.distill! | train | def distill!(options = {})
remove_irrelevant_elements!
remove_unlikely_elements!
score!
clean_top_scoring_elements!(options) unless | ruby | {
"resource": ""
} |
q586 | Distillery.Document.clean_top_scoring_elements! | train | def clean_top_scoring_elements!(options = {})
keep_images = !!options[:images]
top_scoring_elements.each do |element|
| ruby | {
"resource": ""
} |
q587 | HelenaAdministration.SessionsController.unique_question_codes | train | def unique_question_codes
codes = @survey.versions.map(&:question_codes).flatten.uniq
| ruby | {
"resource": ""
} |
q588 | Krikri::Harvesters.OAIHarvester.records | train | def records(opts = {})
opts = @opts.merge(opts)
request_with_sets(opts) do |set_opts|
client.list_records(set_opts).full.lazy.flat_map do |rec|
begin
@record_class.build(mint_id(get_identifier(rec)),
| ruby | {
"resource": ""
} |
q589 | Krikri::Harvesters.OAIHarvester.get_record | train | def get_record(identifier, opts = {})
opts[:identifier] = identifier
opts = @opts.merge(opts)
| ruby | {
"resource": ""
} |
q590 | Krikri::Harvesters.OAIHarvester.concat_enum | train | def concat_enum(enum_enum)
Enumerator.new do |yielder|
| ruby | {
"resource": ""
} |
q591 | Krikri::Harvesters.OAIHarvester.request_with_sets | train | def request_with_sets(opts, &block)
sets = Array(opts.delete(:set))
if opts[:skip_set]
sets = self.sets(&:spec) if sets.empty?
skips = Array(opts.delete(:skip_set))
sets.reject! { |s| skips.include? s }
end
sets = [nil] if sets.empty?
set_enums = sets.lazy.map do |set|
set_opts = opts.dup
set_opts[:set] | ruby | {
"resource": ""
} |
q592 | Geotrigger.Trigger.post_update | train | def post_update opts = {}
post_data = @data.dup
post_data['triggerIds'] = post_data.delete 'triggerId'
post_data.delete 'tags'
if circle?
post_data['condition']['geo'].delete 'geojson'
| ruby | {
"resource": ""
} |
q593 | Sequelizer.Options.fix_options | train | def fix_options(passed_options)
return passed_options unless passed_options.nil? || passed_options.is_a?(Hash)
sequelizer_options = db_config.merge(OptionsHash.new(passed_options || {}).to_hash)
if sequelizer_options[:adapter] =~ /^postgres/
sequelizer_options[:adapter] = 'postgres'
paths = %w(search_path schema_search_path schema).map { |key| sequelizer_options.delete(key) }.compact
unless paths.empty?
sequelizer_options[:search_path] = paths.first
sequelizer_options[:after_connect] = after_connect(paths.first)
end
end
if sequelizer_options[:timeout]
# I'm | ruby | {
"resource": ""
} |
q594 | Sequelizer.Options.after_connect | train | def after_connect(search_path)
Proc.new do |conn|
search_path.split(',').map(&:strip).each do |schema|
conn.execute("CREATE SCHEMA IF NOT EXISTS #{schema}")
| ruby | {
"resource": ""
} |
q595 | RunningMan.Block.run_once | train | def run_once(binding)
@ivars.clear
before = binding.instance_variables
binding.instance_eval(&@block)
(binding.instance_variables - before).each | ruby | {
"resource": ""
} |
q596 | RunningMan.ActiveRecordBlock.setup | train | def setup(test_class)
block = self
test_class.setup { block.run(self) }
| ruby | {
"resource": ""
} |
q597 | RunningMan.ActiveRecordBlock.set_ivar | train | def set_ivar(binding, ivar, value)
if value.class.respond_to?(:find)
value | ruby | {
"resource": ""
} |
q598 | Topsy.Client.experts | train | def experts(q, options={})
options = set_window_or_default(options)
result = handle_response(get("/experts.json", :query => | ruby | {
"resource": ""
} |
q599 | Topsy.Client.link_posts | train | def link_posts(url, options={})
linkposts = handle_response(get("/linkposts.json", :query => {:url => | ruby | {
"resource": ""
} |