_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| 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
batch = []
end
i += 1
end
e.yield batch if batch.count > 0 # last one
end
en.lazy
end | ruby | {
"resource": ""
} |
q501 | Krikri.SearchIndex.incremental_update_from_activity | train | def incremental_update_from_activity(activity)
entities_as_json_hashes(activity).each do |h|
index_with_error_handling(activity) { add(h) }
end
end | ruby | {
"resource": ""
} |
q502 | Krikri.QASearchIndex.schema_keys | train | def schema_keys
schema_file = File.join(Rails.root, 'solr_conf', 'schema.xml')
file = File.open(schema_file)
doc = Nokogiri::XML(file)
file.close
doc.xpath('//fields/field').map { |f| f.attr('name') }
end | 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
end
else
formatted_key = format_key(keys + [key])
new_hash[formatted_key] =
new_hash[formatted_key] ? (Array(new_hash[formatted_key]) << v) : v
end
end
end
end
new_hash
end | 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|
names << dependency unless names.include?(dependency)
end
end
end | 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,
startkey: '_design',
endkey: '_design0')
total = v.total_rows
design_doc_count = v.keys.size
total - design_doc_count
end | 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(
mint_id(row['doc']['_id']),
row['doc'].to_json,
'application/json'
)
end
end | 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)
total_rows ||= v.total_rows
rows_retrieved += v.rows.size
v.rows.each do |row|
next if row['id'].start_with?('_design')
e.yield row
end
break if rows_retrieved == total_rows
view_opts[:startkey] = v.rows.last['id'] + '0'
end
end
en.lazy
end | ruby | {
"resource": ""
} |
q508 | Krikri::Harvesters.CouchdbHarvester.get_record | train | def get_record(identifier)
doc = client.get!(CGI.escape(identifier)).body.to_json
@record_class.build(mint_id(identifier), doc, 'application/json')
end | 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
has_many :received_notifications, through: :deliveries, source: :simple_notification
end
end
end | 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
else
raise 'SimpleNotifications::SenderTypeError'
end
end | 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
receivers.flatten.collect {|receiver| receivers_class(receiver)}
else
raise 'SimpleNotifications::ReceiverTypeError'
end
end
end | ruby | {
"resource": ""
} |
q512 | Krikri::Harvesters.ApiHarvester.next_options | train | def next_options(opts, record_count)
old_start = opts['params'].fetch('start', 0)
opts['params']['start'] = old_start.to_i + record_count
opts
end | 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
conditions = new_record? ? ['slug = ?',slug] : ['slug = ? AND id != ?',slug,id]
conditions[1] = "#{prim_slug}_#{i+=1}" while Page.where(conditions).first && (attempts += 1) < 20
write_attribute(:slug,conditions[1])
end | 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
memo
end
params.merge! custom_attrs
params["ownerid"] = record.owner.roleid if record.owner
end
end | 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 if port
end
@headers.each do |key, val|
if (key == 'CONTENT_LENGTH' || key == 'CONTENT_TYPE')
env[key] = val
else
env["HTTP_#{key}"] = val
end
end
return env
end | 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
end
rescue Exception=>exception
raise Sequel.convert_exception_class(exception, Sequel::DatabaseConnectionError)
end
raise(Sequel::DatabaseConnectionError, "Connection parameters not valid") unless conn
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)
Request.new(uri, headers, @default_opts.merge(opts))
end | 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)
raise ArgumentError, 'Exportable: Expecting Array type for field options'
end
fields = options[:only] - options[:except] + options[:methods]
{ fields: fields, header: options[:header] }
end | ruby | {
"resource": ""
} |
q519 | DockerCloud.NodeTypeAPI.get | train | def get(provider_name, node_type_name)
name = "#{provider_name}/#{node_type_name}/"
response = http_get(resource_url(name))
format_object(response, TYPE)
end | 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)
headers[:losantdomain] = params[:losantdomain] if params.has_key?(:losantdomain)
query_params[:_actions] = params[:_actions] if params.has_key?(:_actions)
query_params[:_links] = params[:_links] if params.has_key?(:_links)
query_params[:_embedded] = params[:_embedded] if params.has_key?(:_embedded)
path = "/applications/#{params[:applicationId]}/keys"
@client.request(
method: :get,
path: path,
query: query_params,
headers: headers,
body: body)
end | 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)
headers[:losantdomain] = params[:losantdomain] if params.has_key?(:losantdomain)
query_params[:_actions] = params[:_actions] if params.has_key?(:_actions)
query_params[:_links] = params[:_links] if params.has_key?(:_links)
query_params[:_embedded] = params[:_embedded] if params.has_key?(:_embedded)
path = "/applications/#{params[:applicationId]}/keys"
@client.request(
method: :post,
path: path,
query: query_params,
headers: headers,
body: body)
end | ruby | {
"resource": ""
} |
q522 | SpatialFeatures.Utils.class_of | train | def class_of(object)
case object
when ActiveRecord::Base
object.class
when ActiveRecord::Relation
object.klass
when String
object.constantize
else
object
end
end | 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 action are not all specified for '#{event.inspect}'"
end
if respond_to?(delegate_method)
public_send(delegate_method, message[:body])
else
raise "`#{self.class.name}` is subscribed, but doesn't implement `#{delegate_method}` for '#{event.inspect}'"
end
end | ruby | {
"resource": ""
} |
q524 | EasyRSA.Config.load! | train | def load!(path)
settings = YAML.load(ERB.new(File.new(path).read).result)
if settings.present?
from_hash(settings)
end
end | 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 + @provider_id
solr_params[:fq] ||= []
solr_params[:fq] << "provider_id:\"#{rdf_subject}\""
end
end | 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|
Geotrigger.const_get(model.capitalize).from_api data, @session
end
end | 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
end
else
key = meth_s.camelcase
if @data and @data.key? key
@data[key]
else
super meth, *args
end
end
end | ruby | {
"resource": ""
} |
q528 | Net.HTTP.request_body_from | train | def request_body_from(req, body)
req.body.nil? || req.body.size == 0 ? body : req.body
end | 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?
return value if value.is_a?(DPLA::MAP::Controlled::Language)
return nil if value.is_a?(ActiveTriples::Resource)
enrich_literal(value)
end | 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?
# if match is still a node, we didn't find anything
return node if match.node?
node.exactMatch = match
node.prefLabel = RDF::ISO_639_3[match.rdf_subject.qname[1]].label.last
node
end | 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
new_position = other.position - 1
other.higher_siblings.where(:position.gt => self.position).each { |s| s.inc(:position, -1) }
self.position = new_position
save!
end
end | 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
else
did_not_match
end
end | 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 :Command, result.str
end
result.consumed_length
else
did_not_match
end
end | 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)
report_hash
end
update(field_report: report)
end | 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)
report_hash
end
update(count_report: report)
end | 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
end
opts[:uri] = "jdbc:impala://#{e opts[:host]}:#{opts.fetch(:port, 21050).to_i}/#{e(opts[:database] || 'default')}#{auth}"
when :jdbc_postgres
opts[:adapter] = :jdbc
auth = "?user=#{user}#{"&password=#{password}" if password}" if user
opts[:uri] = "jdbc:postgresql://#{e opts[:host]}:#{opts.fetch(:port, 5432).to_i}/#{e(opts[:database])}#{auth}"
when :impala
opts[:database] ||= 'default'
opts[:port] ||= 21000
if principal
# realm doesn't seem to be used?
opts[:transport] = :sasl
opts[:sasl_params] = {
mechanism: "GSSAPI",
remote_host: host_fqdn,
remote_principal: principal
}
end
end
Sequel.connect(opts)
end
conn.extension(*extensions)
conn
end | ruby | {
"resource": ""
} |
q537 | AvroSchemaRegistry.Client.register | train | def register(subject, schema, **params)
lookup_subject_schema(subject, schema)
rescue Excon::Errors::NotFound
register_without_lookup(subject, schema, params)
end | ruby | {
"resource": ""
} |
q538 | AvroSchemaRegistry.Client.compatible? | train | def compatible?(subject, schema, version = 'latest', **params)
data = post("/compatibility/subjects/#{subject}/versions/#{version}",
expects: [200, 404],
body: { schema: schema.to_s }.merge!(params).to_json)
data.fetch('is_compatible', false) unless data.key?('error_code')
end | 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
fail ApiError.new(:code => 0,
:message => response.return_message)
else
fail ApiError.new(:code => response.code,
:response_headers => response.headers,
:response_body => response.body),
response.status_message
end
end
if opts[:return_type]
return_type = Pollster.const_get(opts[:return_type])
data = return_type.from_tsv(response.body)
else
data = nil
end
return data, response.code, response.headers
end | 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 = action_link_to(@options[:action], cell_value) if @type != :action and @options.has_key?(:action)
content_tag(:td, cell_value, @html_options)
end | 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)
content_tag(:th, sort_link_to(cell_value, sort_on), @html_options)
else
content_tag(:th, cell_value, @html_options)
end
end | 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
create_link_to(block || I18n.t(:show), object_or_array, @@options[:link_remote])
else
object_or_array.insert(0, action)
create_link_to(block || I18n.t(@ask), object_or_array, @@options[:link_remote])
end
end | 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, :method => method, :confirm => confirm, :remote => true)
end
link_to(block, url, :method => method, :confirm => confirm)
end | 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?
return ret_value
end
format_cell_value_as_type(value, attribute)
end | 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)
elsif TableBuilder.currency_columns.include?(attribute)
return number_to_currency(value)
elsif value.is_a?(TrueClass)
return TableBuilder.default_boolean.first
elsif value.is_a?(FalseClass)
return TableBuilder.default_boolean.second
end
value
end | 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|
format.html
format.csv { render text: @report.send("#{@type}_csv".to_sym).to_csv }
end
end | 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 =~ /_DB_OPT_/ }.inject({}) do |config, key|
new_key = key.downcase
config[new_key] = ENV[key]
config
end
db_config.merge(seq_config)
end | 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 match
return match
else
return match.to_i
end
end | 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
raise NetworkException.new("error sending command: #{rpacket.command_type}")
end
if @return_packets
return rpacket
else
return rpacket.string1
end
end | 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
raise NetworkException.new("error authenticating: #{rpacket.command_type}")
end
@authed = true
if @return_packets
return rpacket
else
return true
end
end | ruby | {
"resource": ""
} |
q551 | SortingTableFor.FormatLine.add_cell | train | def add_cell(object, args, type = nil, block = nil)
@cells << FormatCell.new(object, args, type, block)
end | ruby | {
"resource": ""
} |
q552 | SortingTableFor.FormatLine.content_columns | train | def content_columns
model_name(@object).constantize.content_columns.collect { |c| c.name.to_sym }.compact rescue []
end | ruby | {
"resource": ""
} |
q553 | SortingTableFor.FormatLine.model_have_column? | train | def model_have_column?(column)
model_name(@object).constantize.content_columns.each do |model_column|
return true if model_column.name == column.to_s
end
false
end | 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
ask = [ask] unless ask.is_a? Array
(ask.last.is_a? Hash and ask.last.has_key? :html) ? ask.last[:html].merge!(key => value) : ask << { :html => { key => value }}
end
end
end
ask
end | ruby | {
"resource": ""
} |
q555 | DictionaryRB.Word.dictionary_meaning | train | def dictionary_meaning
if @dictionary_meaning.nil?
@dictionary = Dictionary.new(@word)
meanings = @dictionary.meanings
if meanings.is_a? Array and not meanings.empty?
@dictionary_meanings = meanings
@dictionary_meaning = @dictionary.meaning
end
end
@dictionary_meaning
end | 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?
@urban_meanings = meanings
@urban_meaning = @urban.meaning
end
end
@urban_meaning
end | 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 at least one of limit, terminator or grammar")
grammars = AskGrammarBuilder.new(options).grammars
output_document = prompts.empty? ? nil : output_formatter.ssml_for_collection(prompts)
PromptBuilder.new(output_document, grammars, options).execute self
end | 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 = MenuBuilder.new(options, &block)
output_document = prompts.empty? ? nil : output_formatter.ssml_for_collection(prompts)
menu_builder.execute output_document, self
end | 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 #{table_alias} ON #{table_alias}.spatial_model_id = #{table_name}.id))
.joins(%Q(INNER JOIN (#{other_scope.to_sql}) AS #{other_alias} ON ST_Intersects(#{table_alias}.geom, #{other_alias}.buffered_geom)))
end | 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])
else
agg = do_basic_enrichment(agg, enrichment, chain[e])
end
end
end | 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)
memo
end
elsif obj.respond_to? :to_sym
return obj.to_sym
else
return nil
end
end | 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 ||= Meter.new(name: name, created_on: created_on)
meter.value += value
return meter.save
end | ruby | {
"resource": ""
} |
q563 | Geotrigger.Tag.post_update | train | def post_update
raise StateError.new 'device access_token prohibited' if @session.device?
post_data = @data.dup
post_data['tags'] = post_data.delete 'name'
grok_self_from post 'tag/permissions/update', post_data
self
end | 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'
when :device
post_data.delete 'deviceId'
end
post_data.delete 'tags'
post_data.delete 'lastSeen'
grok_self_from post 'device/update', post_data
self
end | 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')
results = nodes.map(&:text).map(&:strip).reject(&:empty?)
@meaning = results.first
results
end | 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 = Krikri::Mapping.new(klass, parser, *parser_args)
map.instance_eval(&block) if block_given?
Registry.register!(name, map)
end | 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" \
"#{rec.content}\n\twith message:\n"\
"#{e.message}"
next
end
end
true
end | 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 }
# }
#
# ... However there doesn't appear to be a way of constructing
# 'FILTER NOT EXISTS' with SPARQL::Client. Instead, we've managed to
# hack the following solution together.
#
# SPARQL::Client#filter is labeled @private in its YARD comment (and
# has no other documentation) but it's not private, at least for
# now.
query.filter \
'NOT EXISTS ' \
'{ ?record <http://www.w3.org/ns/prov#invalidatedAtTime> ?x }'
end
end | ruby | {
"resource": ""
} |
q569 | NanoleafRuby.Api.ct_increment | train | def ct_increment(increment = 1)
params = { ct: {} }
params[:ct][:increment] = increment
@requester.put(url: "#{@api_url}/state", params: params)
end | 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}")
newentry = Nokogiri::XML::Node.new("#{catalog.to_s.gsub(/s?_catalog/,'')}", self.report)
newentry["id"] = id
valuehash.each do |key, value|
newentry["#{key}"] = value
end
cat << newentry
end
end | 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}']")
@report.at_css("#{catalog}").at("[@id='#{id}']")["#{key}"]
else
return false
end
end | 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] ==
'krikri/providers'
params[:provider] = provider.id
params[:session_provider] = provider.id
link_to provider_name(provider), params
end | ruby | {
"resource": ""
} |
q573 | MeterCat.MetersHelper.meter_description | train | def meter_description(name)
content_tag(:p) do
concat content_tag(:b, name)
concat ' - '
concat t(name, scope: :meter_cat)
end
end | ruby | {
"resource": ""
} |
q574 | MeterCat.MetersHelper.meter_descriptions | train | def meter_descriptions(meters)
content_tag(:ul) do
meters.keys.sort.each do |name|
concat content_tag(:li, meter_description(name))
end
end
end | ruby | {
"resource": ""
} |
q575 | MeterCat.MetersHelper.meter_form | train | def meter_form(date, days, names, all_names)
render partial: 'form', locals: { date: date, days: days, names: names, all_names: all_names }
end | ruby | {
"resource": ""
} |
q576 | HelenaAdministration.ApplicationHelper.truncate_between | train | def truncate_between(str, after = 30)
str = '' if str.nil?
str.length > after ? "#{str[0..(after / 2) - 2]}...#{str[(str.length - ((after / 2) - 2))..str.length]}" : str
end | 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
h = JSON.parse r.body
raise_error h['error'] if h['error']
h
end | 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']
ge.parameters = error['parameters']
jj error
raise ge
end | 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 ...
return [nil, nil] unless coords[0] && coords[1] # ... i.e. not nil
[coords[0], coords[1]]
end | ruby | {
"resource": ""
} |
q580 | RspecSpinner.RspecSpinnerBase.example_pending | train | def example_pending(example, message, deprecated_pending_location=nil)
immediately_dump_pending(example.description, message, example.location)
mark_error_state_pending
increment
end | 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
request.headers = headers if headers
request.body = body
end
end | 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
redirect_to providers_path
end
@current_provider = Krikri::Provider.find(params[:id])
end | ruby | {
"resource": ""
} |
q583 | Distillery.Document.remove_unlikely_elements! | train | def remove_unlikely_elements!
search('*').each do |element|
idclass = "#{element['class']}#{element['id']}"
if idclass =~ UNLIKELY_IDENTIFIERS && !REMOVAL_WHITELIST.include?(element.name)
element.remove
end
end
end | 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
scores[element.parent.path] += points
scores[element.parent.parent.path] += points.to_f/2
end
augment_scores_by_link_weight!
end | ruby | {
"resource": ""
} |
q585 | Distillery.Document.distill! | train | def distill!(options = {})
remove_irrelevant_elements!
remove_unlikely_elements!
score!
clean_top_scoring_elements!(options) unless options.delete(:clean) == false
top_scoring_elements.map(&:inner_html).join("\n")
end | 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|
element.search("*").each do |node|
if cleanable?(node, keep_images)
debugger if node.to_s =~ /maximum flavor/
node.remove
end
end
end
end | ruby | {
"resource": ""
} |
q587 | HelenaAdministration.SessionsController.unique_question_codes | train | def unique_question_codes
codes = @survey.versions.map(&:question_codes).flatten.uniq
codes.map do |code|
session_fields.include?(code) ? "answer_#{code}" : code
end
end | 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)),
record_xml(rec))
rescue => e
Krikri::Logger.log(:error, e.message)
next
end
end
end
end | ruby | {
"resource": ""
} |
q589 | Krikri::Harvesters.OAIHarvester.get_record | train | def get_record(identifier, opts = {})
opts[:identifier] = identifier
opts = @opts.merge(opts)
@record_class.build(mint_id(identifier),
record_xml(client.get_record(opts).record))
end | ruby | {
"resource": ""
} |
q590 | Krikri::Harvesters.OAIHarvester.concat_enum | train | def concat_enum(enum_enum)
Enumerator.new do |yielder|
enum_enum.each do |enum|
enum.each { |i| yielder << i }
end
end
end | 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] = set unless set.nil?
begin
yield(set_opts) if block_given?
rescue OAI::Exception => e
Krikri::Logger.log :warn, "Skipping set #{set} with error: #{e}"
[]
end
end
concat_enum(set_enums).lazy
end | 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'
post_data['condition']['geo'].delete 'esrijson'
end
grok_self_from post 'trigger/update', post_data.merge(opts)
self
end | 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 doing a merge! here because the indifferent access part
# of OptionsHash seemed to not work when I tried
# sequelizer_options[:timeout] = sequelizer_options[:timeout].to_i
sequelizer_options.merge!(timeout: sequelizer_options[:timeout].to_i)
end
sequelizer_options.merge(after_connect: make_ac(sequelizer_options))
end | 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}")
end
conn.execute("SET search_path TO #{search_path}")
end
end | 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 do |ivar|
@ivars[ivar] = binding.instance_variable_get(ivar)
end
end | ruby | {
"resource": ""
} |
q596 | RunningMan.ActiveRecordBlock.setup | train | def setup(test_class)
block = self
test_class.setup { block.run(self) }
test_class.teardown { block.teardown_transaction }
end | ruby | {
"resource": ""
} |
q597 | RunningMan.ActiveRecordBlock.set_ivar | train | def set_ivar(binding, ivar, value)
if value.class.respond_to?(:find)
value = value.class.find(value.id)
end
super(binding, ivar, value)
end | ruby | {
"resource": ""
} |
q598 | Topsy.Client.experts | train | def experts(q, options={})
options = set_window_or_default(options)
result = handle_response(get("/experts.json", :query => {:q => q}.merge(options)))
Topsy::Page.new(result, Topsy::Author)
end | ruby | {
"resource": ""
} |
q599 | Topsy.Client.link_posts | train | def link_posts(url, options={})
linkposts = handle_response(get("/linkposts.json", :query => {:url => url}.merge(options)))
Topsy::Page.new(linkposts,Topsy::Linkpost)
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.