_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": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.