_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21200 | Rfd.Commands.ctrl_a | train | def ctrl_a
mark = marked_items.size != (items.size - 2) # exclude . and ..
items.each {|i| i.toggle_mark unless i.marked? == mark}
draw_items
draw_marked_items
move_cursor current_row
end | ruby | {
"resource": ""
} |
q21201 | Rfd.Commands.enter | train | def enter
if current_item.name == '.' # do nothing
elsif current_item.name == '..'
cd '..'
elsif in_zip?
v
elsif current_item.directory? || current_item.zip?
cd current_item
else
v
end
end | ruby | {
"resource": ""
} |
q21202 | Rfd.Commands.del | train | def del
if current_dir.path != '/'
dir_was = times == 1 ? current_dir.name : File.basename(current_dir.join(['..'] * (times - 1)))
cd File.expand_path(current_dir.join(['..'] * times))
find dir_was
end
end | ruby | {
"resource": ""
} |
q21203 | Riot.Message.method_missing | train | def method_missing(meth, *phrases, &block)
push(meth.to_s.gsub('_', ' '))
_inspect(phrases)
end | ruby | {
"resource": ""
} |
q21204 | Riot.Reporter.report | train | def report(description, response)
code, result = *response
case code
when :pass then
@passes += 1
pass(description, result)
when :fail then
@failures += 1
message, line, file = *response[1..-1]
fail(description, message, line, file)
when :error, :set... | ruby | {
"resource": ""
} |
q21205 | UTF8Cleaner.URIString.encoded_char_array | train | def encoded_char_array
char_array = []
index = 0
while (index < data.length) do
char = data[index]
if char == '%'
# Skip the next two characters, which are the encoded byte
# indicates by this %. (We'll change this later for multibyte characters.)
skip_n... | ruby | {
"resource": ""
} |
q21206 | UTF8Cleaner.URIString.utf8_char_length_in_bytes | train | def utf8_char_length_in_bytes(first_byte)
if first_byte.hex < 'C0'.hex
1
elsif first_byte.hex < 'DF'.hex
2
elsif first_byte.hex < 'EF'.hex
3
else
4
end
end | ruby | {
"resource": ""
} |
q21207 | Stax.Ecs.ecs_services_with_ids | train | def ecs_services_with_ids(*ids)
if ids.empty?
ecs_services
else
ecs_services.select do |s|
ids.include?(s.logical_resource_id)
end
end
end | ruby | {
"resource": ""
} |
q21208 | Maestrano::Connector::Rails.AllSynchronizationsJob.perform | train | def perform(name = nil, count = nil)
Maestrano::Connector::Rails::Organization
.where.not(oauth_provider: nil, encrypted_oauth_token: nil)
.where(sync_enabled: true)
.select(:id)
.find_each do |organization|
Maestrano::Connector::Rails::SynchronizationJob.set(wait: rand(360... | ruby | {
"resource": ""
} |
q21209 | FeedNormalizer.ElementCleaner.clean! | train | def clean!
self.class::SIMPLE_ELEMENTS.each do |element|
val = self.send(element)
send("#{element}=", (val.is_a?(Array) ?
val.collect{|v| HtmlCleaner.flatten(v.to_s)} : HtmlCleaner.flatten(val.to_s)))
end
self.class::HTML_ELEMENTS.each do |element|
send("#{element}=... | ruby | {
"resource": ""
} |
q21210 | Stax.Ssm.ssm_parameter_tmpfile | train | def ssm_parameter_tmpfile(name)
Tempfile.new(stack_name).tap do |file|
file.write(ssm_parameter_get(name))
File.chmod(0400, file.path)
file.close
end
end | ruby | {
"resource": ""
} |
q21211 | Stax.Ssm.ssm_run_shellscript | train | def ssm_run_shellscript(*cmd)
Aws::Ssm.run(
document_name: 'AWS-RunShellScript',
targets: [{key: 'tag:aws:cloudformation:stack-name', values: [stack_name]}],
parameters: {commands: cmd}
)&.command_id.tap(&method(:puts))
end | ruby | {
"resource": ""
} |
q21212 | SnipSnip.Reporter.report | train | def report(controller)
return if results.empty?
action_display = "#{controller.controller_name}##{controller.action_name}"
SnipSnip.logger.info(action_display)
results.sort_by(&:report).each do |result|
SnipSnip.logger.info(" #{result.report}")
end
ensure
Registry.clea... | ruby | {
"resource": ""
} |
q21213 | Maestrano::Connector::Rails::Concerns::ConnecHelper.ClassMethods.fold_references | train | def fold_references(mapped_external_entity, references, organization)
references = format_references(references)
mapped_external_entity = mapped_external_entity.with_indifferent_access
# Use both record_references and id_references + the id
(references.values.flatten + ['id']).each do |referenc... | ruby | {
"resource": ""
} |
q21214 | Maestrano::Connector::Rails::Concerns::ConnecHelper.ClassMethods.id_hash | train | def id_hash(id, organization)
{
id: id,
provider: organization.oauth_provider,
realm: organization.oauth_uid
}
end | ruby | {
"resource": ""
} |
q21215 | Maestrano::Connector::Rails::Concerns::ConnecHelper.ClassMethods.fold_references_helper | train | def fold_references_helper(entity, array_of_refs, organization)
ref = array_of_refs.shift
field = entity[ref]
return if field.blank?
# Follow embedment path, remplace if it's not an array or a hash
case field
when Array
field.each do |f|
fold_references_helper(f, a... | ruby | {
"resource": ""
} |
q21216 | Maestrano::Connector::Rails::Concerns::ConnecHelper.ClassMethods.unfold_references_helper | train | def unfold_references_helper(entity, array_of_refs, organization)
ref = array_of_refs.shift
field = entity[ref]
# Unfold the id
if array_of_refs.empty? && field
return entity.delete(ref) if field.is_a?(String) # ~retro-compatibility to ease transition aroud Connec! idmaps rework. Should... | ruby | {
"resource": ""
} |
q21217 | Maestrano::Connector::Rails::Concerns::ConnecHelper.ClassMethods.filter_connec_entity_for_id_refs | train | def filter_connec_entity_for_id_refs(connec_entity, id_references)
return {} if id_references.empty?
entity = connec_entity.dup.with_indifferent_access
tree = build_id_references_tree(id_references)
filter_connec_entity_for_id_refs_helper(entity, tree)
# TODO, improve performance by ret... | ruby | {
"resource": ""
} |
q21218 | Maestrano::Connector::Rails::Concerns::ConnecHelper.ClassMethods.filter_connec_entity_for_id_refs_helper | train | def filter_connec_entity_for_id_refs_helper(entity_hash, tree)
return if tree.empty?
entity_hash.slice!(*tree.keys)
tree.each do |key, children|
case entity_hash[key]
when Array
entity_hash[key].each do |hash|
filter_connec_entity_for_id_refs_helper(hash, childr... | ruby | {
"resource": ""
} |
q21219 | Maestrano::Connector::Rails::Concerns::ConnecHelper.ClassMethods.merge_id_hashes | train | def merge_id_hashes(dist, src, id_references)
dist = dist.with_indifferent_access
src = src.with_indifferent_access
id_references.each do |id_reference|
array_of_refs = id_reference.split('/')
merge_id_hashes_helper(dist, array_of_refs, src)
end
dist
end | ruby | {
"resource": ""
} |
q21220 | Maestrano::Connector::Rails::Concerns::ConnecHelper.ClassMethods.merge_id_hashes_helper | train | def merge_id_hashes_helper(hash, array_of_refs, src, path = [])
ref = array_of_refs.shift
field = hash[ref]
if array_of_refs.empty? && field
value = value_from_hash(src, path + [ref])
if value.is_a?(Array)
hash[ref] = (field + value).uniq
else
hash.delete(r... | ruby | {
"resource": ""
} |
q21221 | Stax.Ecs.taskdef_to_hash | train | def taskdef_to_hash(taskdef)
args = %i[family cpu memory requires_compatibilities task_role_arn execution_role_arn network_mode container_definitions volumes placement_constraints]
taskdef.to_hash.slice(*args)
end | ruby | {
"resource": ""
} |
q21222 | Stax.Ecs.ecs_deploy | train | def ecs_deploy(id, &block)
service = Aws::Ecs.services(ecs_cluster_name, [resource(id)]).first
taskdef = get_taskdef(service)
## convert to a hash and modify in block
hash = taskdef_to_hash(taskdef)
yield(hash) if block_given?
taskdef = register_taskdef(hash)
update_service(s... | ruby | {
"resource": ""
} |
q21223 | Rpub.Compressor.store_file | train | def store_file(filename, content)
zip.put_next_entry filename, nil, nil, Zip::Entry::STORED, Zlib::NO_COMPRESSION
zip.write content.to_s
end | ruby | {
"resource": ""
} |
q21224 | Rpub.Compressor.compress_file | train | def compress_file(filename, content)
zip.put_next_entry filename, nil, nil, Zip::Entry::DEFLATED, Zlib::BEST_COMPRESSION
zip.write content.to_s
end | ruby | {
"resource": ""
} |
q21225 | PostgreSQLCursor.Cursor.pluck | train | def pluck(*cols)
options = cols.last.is_a?(Hash) ? cols.pop : {}
@options.merge!(options)
@options[:symbolize_keys] = true
self.iterate_type(options[:class]) if options[:class]
cols = cols.map {|c| c.to_sym }
result = []
self.each() do |row|
row = row.symbolize_key... | ruby | {
"resource": ""
} |
q21226 | Reckon.App.weighted_account_match | train | def weighted_account_match( row )
query_tokens = tokenize(row[:description])
search_vector = []
account_vectors = {}
query_tokens.each do |token|
idf = Math.log((accounts.keys.length + 1) / ((tokens[token] || {}).keys.length.to_f + 1))
tf = 1.0 / query_tokens.length.to_f
... | ruby | {
"resource": ""
} |
q21227 | Danger.DangerTextlint.lint | train | def lint
return if target_files.empty?
bin = textlint_path
result_json = run_textlint(bin, target_files)
errors = parse(result_json)
send_comment(errors)
end | ruby | {
"resource": ""
} |
q21228 | Capistrano.Karafka.set_defaults | train | def set_defaults
set_if_empty :karafka_role, :karafka
set_if_empty :karafka_processes, 1
set_if_empty :karafka_consumer_groups, []
set_if_empty :karafka_default_hooks, -> { true }
set_if_empty :karafka_env, -> { fetch(:karafka_env, fetch(:environment)) }
set_if_empty :karafka_pid, ->... | ruby | {
"resource": ""
} |
q21229 | Weary.Resource.meets_requirements? | train | def meets_requirements?(params)
requirements.reject {|k| params.keys.map(&:to_s).include? k.to_s }.empty?
end | ruby | {
"resource": ""
} |
q21230 | Weary.Resource.request | train | def request(params={})
normalize_parameters params
raise UnmetRequirementsError, "Required parameters: #{requirements}" \
unless meets_requirements? params
credentials = pull_credentials params
pairs = pull_url_pairs params
request = construct_request expand_url(pairs), params, cre... | ruby | {
"resource": ""
} |
q21231 | PGN.MoveCalculator.compute_origin | train | def compute_origin
return nil if move.castle
possibilities = case move.piece
when /[brq]/i then direction_origins
when /[kn]/i then move_origins
when /p/i then pawn_origins
end
if possibilities.length > 1
possibilities = disambiguate(possibilities)
end
... | ruby | {
"resource": ""
} |
q21232 | PGN.MoveCalculator.direction_origins | train | def direction_origins
directions = DIRECTIONS[move.piece.downcase]
possibilities = []
directions.each do |dir|
piece, square = first_piece(destination_coords, dir)
possibilities << square if piece == self.move.piece
end
possibilities
end | ruby | {
"resource": ""
} |
q21233 | PGN.MoveCalculator.move_origins | train | def move_origins(moves = nil)
moves ||= MOVES[move.piece.downcase]
possibilities = []
file, rank = destination_coords
moves.each do |i, j|
f = file + i
r = rank + j
if valid_square?(f, r) && self.board.at(f, r) == move.piece
possibilities << [f,... | ruby | {
"resource": ""
} |
q21234 | PGN.MoveCalculator.pawn_origins | train | def pawn_origins
_, rank = destination_coords
double_rank = (rank == 3 && self.move.white?) || (rank == 4 && self.move.black?)
pawn_moves = PAWN_MOVES[self.move.piece]
moves = self.move.capture ? pawn_moves[:capture] : pawn_moves[:normal]
moves += pawn_moves[:double] if double_rank
... | ruby | {
"resource": ""
} |
q21235 | PGN.MoveCalculator.disambiguate_san | train | def disambiguate_san(possibilities)
move.disambiguation ?
possibilities.select {|p| self.board.position_for(p).match(move.disambiguation) } :
possibilities
end | ruby | {
"resource": ""
} |
q21236 | PGN.MoveCalculator.disambiguate_pawns | train | def disambiguate_pawns(possibilities)
self.move.piece.match(/p/i) && !self.move.capture ?
possibilities.reject {|p| self.board.position_for(p).match(/2|7/) } :
possibilities
end | ruby | {
"resource": ""
} |
q21237 | PGN.MoveCalculator.disambiguate_discovered_check | train | def disambiguate_discovered_check(possibilities)
DIRECTIONS.each do |attacking_piece, directions|
attacking_piece = attacking_piece.upcase if self.move.black?
directions.each do |dir|
piece, square = first_piece(king_position, dir)
next unless piece == self.move.piece && possi... | ruby | {
"resource": ""
} |
q21238 | PGN.MoveCalculator.en_passant_capture | train | def en_passant_capture
return nil if self.move.castle
if !self.board.at(self.move.destination) && self.move.capture
self.move.destination[0] + self.origin[1]
end
end | ruby | {
"resource": ""
} |
q21239 | Weary.Request.call | train | def call(environment)
app = adapter.new
middlewares = @middlewares || []
stack = Rack::Builder.new do
middlewares.each do |middleware|
klass, *args = middleware
use klass, *args[0...-1].flatten, &args.last
end
run app
end
stack.call rack_env_defa... | ruby | {
"resource": ""
} |
q21240 | Weary.Request.perform | train | def perform
future do
status, headers, body = call(rack_env_defaults)
response = Weary::Response.new body, status, headers
yield response if block_given?
response
end
end | ruby | {
"resource": ""
} |
q21241 | Weary.Request.query_params_from_hash | train | def query_params_from_hash(value, prefix = nil)
case value
when Array
value.map { |v| query_params_from_hash(v, "#{prefix}%5B%5D") }.join("&")
when Hash
value.map { |k, v|
query_params_from_hash(v, prefix ? "#{prefix}%5B#{Rack::Utils.escape_path(k)}%5D" : Rack::Utils.escape_p... | ruby | {
"resource": ""
} |
q21242 | SAPOCI.Document.to_html | train | def to_html(options = {})
html = []
self.items.each do |item|
html << item.to_html(options)
end
html.join
end | ruby | {
"resource": ""
} |
q21243 | TicketEvolution.AffiliateCommissions.find_by_office_order | train | def find_by_office_order(office_id, order_link_id, params=nil)
request(:GET, "/#{office_id}/orders/#{order_link_id}", params) do |response|
singular_class.new(response.body.merge({
:status_code => response.response_code,
:server_message => response.server_message,
:connection... | ruby | {
"resource": ""
} |
q21244 | PGN.Game.play | train | def play
index = 0
hist = Array.new(3, "")
loop do
puts "\e[H\e[2J"
puts self.positions[index].inspect
hist[0..2] = (hist[1..2] << STDIN.getch)
case hist.join
when LEFT
index -= 1 if index > 0
when RIGHT
index += 1 if index < self.m... | ruby | {
"resource": ""
} |
q21245 | GrabzIt.Client.url_to_animation | train | def url_to_animation(url, options = nil)
if options == nil
options = AnimationOptions.new()
end
@request = Request.new(@protocol + WebServicesBaseURLGet + "takeanimation.ashx", false, options, url)
return nil
end | ruby | {
"resource": ""
} |
q21246 | GrabzIt.Client.url_to_image | train | def url_to_image(url, options = nil)
if options == nil
options = ImageOptions.new()
end
@request = Request.new(@protocol + WebServicesBaseURLGet + TakePicture, false, options, url)
return nil
end | ruby | {
"resource": ""
} |
q21247 | GrabzIt.Client.html_to_image | train | def html_to_image(html, options = nil)
if options == nil
options = ImageOptions.new()
end
@request = Request.new(@protocol + WebServicesBaseURLPost + TakePicture, true, options, html)
return nil
end | ruby | {
"resource": ""
} |
q21248 | GrabzIt.Client.url_to_table | train | def url_to_table(url, options = nil)
if options == nil
options = TableOptions.new()
end
@request = Request.new(@protocol + WebServicesBaseURLGet + TakeTable, false, options, url)
return nil
end | ruby | {
"resource": ""
} |
q21249 | GrabzIt.Client.html_to_table | train | def html_to_table(html, options = nil)
if options == nil
options = TableOptions.new()
end
@request = Request.new(@protocol + WebServicesBaseURLPost + TakeTable, true, options, html)
return nil
end | ruby | {
"resource": ""
} |
q21250 | GrabzIt.Client.url_to_pdf | train | def url_to_pdf(url, options = nil)
if options == nil
options = PDFOptions.new()
end
@request = Request.new(@protocol + WebServicesBaseURLGet + TakePDF, false, options, url)
return nil
end | ruby | {
"resource": ""
} |
q21251 | GrabzIt.Client.html_to_pdf | train | def html_to_pdf(html, options = nil)
if options == nil
options = PDFOptions.new()
end
@request = Request.new(@protocol + WebServicesBaseURLPost + TakePDF, true, options, html)
return nil
end | ruby | {
"resource": ""
} |
q21252 | GrabzIt.Client.url_to_docx | train | def url_to_docx(url, options = nil)
if options == nil
options = DOCXOptions.new()
end
@request = Request.new(@protocol + WebServicesBaseURLGet + TakeDOCX, false, options, url)
return nil
end | ruby | {
"resource": ""
} |
q21253 | GrabzIt.Client.html_to_docx | train | def html_to_docx(html, options = nil)
if options == nil
options = DOCXOptions.new()
end
@request = Request.new(@protocol + WebServicesBaseURLPost + TakeDOCX, true, options, html)
return nil
end | ruby | {
"resource": ""
} |
q21254 | GrabzIt.Client.save | train | def save(callBackURL = nil)
if @request == nil
raise GrabzItException.new("No parameters have been set.", GrabzItException::PARAMETER_MISSING_PARAMETERS)
end
sig = encode(@request.options()._getSignatureString(GrabzIt::Utility.nil_check(@applicationSecret), callBackURL, @request.getTargetUrl()))
... | ruby | {
"resource": ""
} |
q21255 | GrabzIt.Client.save_to | train | def save_to(saveToFile = nil)
id = save()
if id == nil || id == ""
return false
end
#Wait for it to be possibly ready
sleep((@request.options().startDelay() / 1000) + 3)
#Wait for it to be ready.
while true do
status = get_status(id)
if !status.cached && !status.processing
... | ruby | {
"resource": ""
} |
q21256 | GrabzIt.Client.get_status | train | def get_status(id)
if id == nil || id == ""
return nil
end
result = get(@protocol + WebServicesBaseURLGet + "getstatus.ashx?id=" + GrabzIt::Utility.nil_check(id))
doc = REXML::Document.new(result)
processing = doc.root.elements["Processing"].text()
cached = doc.root.elements["Cached"]... | ruby | {
"resource": ""
} |
q21257 | GrabzIt.Client.get_result | train | def get_result(id)
if id == nil || id == ""
return nil
end
return get(@protocol + WebServicesBaseURLGet + "getfile.ashx?id=" + GrabzIt::Utility.nil_check(id))
end | ruby | {
"resource": ""
} |
q21258 | GrabzIt.Client.get_cookies | train | def get_cookies(domain)
sig = encode(GrabzIt::Utility.nil_check(@applicationSecret)+"|"+GrabzIt::Utility.nil_check(domain))
qs = "key="
qs.concat(CGI.escape(GrabzIt::Utility.nil_check(@applicationKey)))
qs.concat("&domain=")
qs.concat(CGI.escape(GrabzIt::Utility.nil_check(domain)))
qs.... | ruby | {
"resource": ""
} |
q21259 | GrabzIt.Client.set_cookie | train | def set_cookie(name, domain, value = "", path = "/", httponly = false, expires = "")
sig = encode(GrabzIt::Utility.nil_check(@applicationSecret)+"|"+GrabzIt::Utility.nil_check(name)+"|"+GrabzIt::Utility.nil_check(domain)+
"|"+GrabzIt::Utility.nil_check(value)+"|"+GrabzIt::Utility.nil_check(path)+"|"+GrabzIt::Util... | ruby | {
"resource": ""
} |
q21260 | GrabzIt.Client.delete_cookie | train | def delete_cookie(name, domain)
sig = encode(GrabzIt::Utility.nil_check(@applicationSecret)+"|"+GrabzIt::Utility.nil_check(name)+
"|"+GrabzIt::Utility.nil_check(domain)+"|1")
qs = "key="
qs.concat(CGI.escape(GrabzIt::Utility.nil_check(@applicationKey)))
qs.concat("&domain=")
qs.concat(CGI.escape(Grab... | ruby | {
"resource": ""
} |
q21261 | GrabzIt.Client.add_watermark | train | def add_watermark(identifier, path, xpos, ypos)
if !File.file?(path)
raise "File: " + path + " does not exist"
end
sig = encode(GrabzIt::Utility.nil_check(@applicationSecret)+"|"+GrabzIt::Utility.nil_check(identifier)+"|"+GrabzIt::Utility.nil_int_check(xpos)+
"|"+GrabzIt::Utility.nil_int_check(ypos))
... | ruby | {
"resource": ""
} |
q21262 | GrabzIt.Client.delete_watermark | train | def delete_watermark(identifier)
sig = encode(GrabzIt::Utility.nil_check(@applicationSecret)+"|"+GrabzIt::Utility.nil_check(identifier))
qs = "key="
qs.concat(CGI.escape(GrabzIt::Utility.nil_check(@applicationKey)))
qs.concat("&identifier=")
qs.concat(CGI.escape(GrabzIt::Utility.nil_check(identifier)))
... | ruby | {
"resource": ""
} |
q21263 | GrabzIt.Client.set_local_proxy | train | def set_local_proxy(value)
if value
uri = URI.parse(value)
@proxy = Proxy.new(uri.host, uri.port, uri.user, uri.password)
else
@proxy = Proxy.new()
end
end | ruby | {
"resource": ""
} |
q21264 | GrabzIt.Client.decrypt_file | train | def decrypt_file(path, key)
data = read_file(path)
decryptedFile = File.new(path, "wb")
decryptedFile.write(decrypt(data, key))
decryptedFile.close
end | ruby | {
"resource": ""
} |
q21265 | GrabzIt.Client.decrypt | train | def decrypt(data, key)
if data == nil
return nil
end
iv = data[0..15]
payload = data[16..-1]
cipher = OpenSSL::Cipher::Cipher.new("aes-256-cbc")
cipher.padding = 0
cipher.key = Base64.strict_decode64(key);
cipher.iv = iv
decrypted = cipher.update(payload);
decrypted << cipher.final();
... | ruby | {
"resource": ""
} |
q21266 | ApiHammer.HaltMethods.halt_error | train | def halt_error(status, errors, options = {})
errors_as_json = errors.respond_to?(:as_json) ? errors.as_json : errors
unless errors_as_json.is_a?(Hash)
raise ArgumentError, "errors be an object representable in JSON as a Hash; got errors = #{errors.inspect}"
end
unless errors_as_json.keys... | ruby | {
"resource": ""
} |
q21267 | ApiHammer.Sinatra.format_response | train | def format_response(status, body_object, headers={})
if status == 204
body = ''
else
body = case response_media_type
when 'application/json'
JSON.pretty_generate(body_object)
when 'application/x-www-form-urlencoded'
URI.encode_www_form(body_object)
... | ruby | {
"resource": ""
} |
q21268 | ApiHammer.Sinatra.request_body | train | def request_body
# rewind in case anything in the past has left this un-rewound
request.body.rewind
request.body.read.tap do
# rewind in case anything in the future expects this to have been left rewound
request.body.rewind
end
end | ruby | {
"resource": ""
} |
q21269 | ApiHammer.Sinatra.parsed_body | train | def parsed_body
request_media_type = request.media_type
unless request_media_type =~ /\S/
fallback = true
request_media_type = supported_media_types.first
end
case request_media_type
when 'application/json'
begin
return JSON.parse(request_body)
res... | ruby | {
"resource": ""
} |
q21270 | ApiHammer.Sinatra.check_params_and_object_consistent | train | def check_params_and_object_consistent(path_params, object)
errors = {}
path_params.each do |(k, v)|
if object.key?(k) && object[k] != v
errors[k] = [I18n.t('app.errors.inconsistent_uri_and_entity',
:key => k,
:uri_value => v,
:entity_value => object[k],... | ruby | {
"resource": ""
} |
q21271 | ApiHammer.Body.object | train | def object
instance_variable_defined?(:@object) ? @object : @object = begin
if media_type == 'application/json'
JSON.parse(body) rescue nil
elsif media_type == 'application/x-www-form-urlencoded'
CGI.parse(body).map { |k, vs| {k => vs.last} }.inject({}, &:update)
end
... | ruby | {
"resource": ""
} |
q21272 | ApiHammer.Body.jsonifiable | train | def jsonifiable
@jsonifiable ||= Body.new(catch(:jsonifiable) do
original_body = self.body
unless original_body.is_a?(String)
begin
# if the response body is not a string, but JSON doesn't complain
# about dumping whatever it is, go ahead and use it
J... | ruby | {
"resource": ""
} |
q21273 | ApiHammer.FaradayCurlVOutputter.alter_body_by_content_type | train | def alter_body_by_content_type(body, content_type)
return body unless body.is_a?(String)
content_type_attrs = ApiHammer::ContentTypeAttrs.new(content_type)
if @options[:text].nil? ? content_type_attrs.text? : @options[:text]
if pretty?
case content_type_attrs.media_type
whe... | ruby | {
"resource": ""
} |
q21274 | ActiveList.Generator.select_data_code | train | def select_data_code(options = {})
paginate = (options.key?(:paginate) ? options[:paginate] : @table.paginate?)
# Check order
unless @table.options.keys.include?(:order)
columns = @table.table_columns
@table.options[:order] = (columns.any? ? columns.first.name.to_sym : { id: :desc })
... | ruby | {
"resource": ""
} |
q21275 | ActiveList.Generator.includes_reflections | train | def includes_reflections
hash = []
@table.columns.each do |column|
hash << column.reflection.name if column.respond_to?(:reflection)
end
hash
end | ruby | {
"resource": ""
} |
q21276 | ActiveList.Generator.conditions_code | train | def conditions_code
conditions = @table.options[:conditions]
code = ''
case conditions
when Array
case conditions[0]
when String # SQL
code << '[' + conditions.first.inspect
code << conditions[1..-1].collect { |p| ', ' + sanitize_condition(p) }.join if conditi... | ruby | {
"resource": ""
} |
q21277 | RConfig.Utils.default_load_paths | train | def default_load_paths
paths = []
# Check for Rails config path
paths << "#{::Rails.root}/config" if rails?
# Check for defined constants
paths << CONFIG_ROOT if defined?(CONFIG_ROOT) && Dir.exists?(CONFIG_ROOT)
paths << CONFIG_PATH if defined?(CONFIG_PATH) && Dir.exists?(CONFIG_PA... | ruby | {
"resource": ""
} |
q21278 | RConfig.Utils.read | train | def read(file, name, ext)
contents = File.read(file) # Read the contents from the file.
contents = ERB.new(contents).result # Evaluate any ruby code using ERB.
parse(contents, name, ext) # Parse the contents based on the file type
end | ruby | {
"resource": ""
} |
q21279 | RConfig.Utils.parse | train | def parse(contents, name, ext)
hash = case ext
when *YML_FILE_TYPES
YAML::load(contents)
when *XML_FILE_TYPES
parse_xml(contents, name)
when *CNF_FILE_TYPES
RConfig::PropertiesFile.parse(contents)
else
raise ConfigError, "Unknown File type: #... | ruby | {
"resource": ""
} |
q21280 | RConfig.Utils.parse_xml | train | def parse_xml(contents, name)
hash = Hash.from_xml(contents)
hash = hash[name] if hash.size == 1 && hash.key?(name) # xml document could have root tag matching the file name.
RConfig::PropertiesFile.parse_references(hash)
end | ruby | {
"resource": ""
} |
q21281 | RConfig.Utils.merge_hashes | train | def merge_hashes(hashes)
hashes.inject({}) { |n, h| n.weave(h, true) }
end | ruby | {
"resource": ""
} |
q21282 | RConfig.Utils.make_indifferent | train | def make_indifferent(hash)
case hash
when Hash
unless hash.frozen?
hash.each do |k, v|
hash[k] = make_indifferent(v)
end
hash = RConfig::Config.new.merge!(hash).freeze
end
logger.debug "make_indefferent: x = #{hash.inspect}:#{... | ruby | {
"resource": ""
} |
q21283 | RConfig.Utils.flush_cache | train | def flush_cache(name=nil)
if name
name = name.to_s
self.cache_hash[name] &&= nil
else
logger.warn "RConfig: Flushing config data cache."
self.suffixes = {}
self.cache = {}
self.cache_files = {}
self.cache_hash = {}
sel... | ruby | {
"resource": ""
} |
q21284 | RConfig.Cascade.overlay= | train | def overlay=(value)
reload(false) if self.overlay != value
self.overlay = value && value.dup.freeze
end | ruby | {
"resource": ""
} |
q21285 | RConfig.Cascade.suffixes_for | train | def suffixes_for(name)
name = name.to_s
self.suffixes[name] ||= begin
ol = overlay
name_x = name.dup
if name_x.sub!(/_([A-Z]+)$/, '')
ol = $1
end
name_x.freeze
result = if ol
ol_ = ol.upcase
ol = ol.downcase
x = []
... | ruby | {
"resource": ""
} |
q21286 | RConfig.CoreMethods.load_config_files | train | def load_config_files(name, force=false)
name = name.to_s
# Return last config file hash list loaded,
# if reload is disabled and files have already been loaded.
return self.cache_config_files[name] if self.reload_disabled? && self.cache_config_files[name]
logger.info "Loading config fil... | ruby | {
"resource": ""
} |
q21287 | RConfig.CoreMethods.config_changed? | train | def config_changed?(name)
logger.debug "config_changed?(#{name.inspect})"
name = name.to_s
!(self.cache_files[name] === get_config_files(name))
end | ruby | {
"resource": ""
} |
q21288 | RConfig.CoreMethods.get_config_data | train | def get_config_data(name)
logger.debug "get_config_data(#{name.inspect})"
name = name.to_s
unless result = self.cache_hash[name]
result = self.cache_hash[name] =
make_indifferent(
merge_hashes(
load_config_files(name)
)
... | ruby | {
"resource": ""
} |
q21289 | RConfig.CoreMethods.check_for_changes | train | def check_for_changes(name=nil)
changed = []
if name == nil
self.cache_hash.keys.dup.each do |name|
if reload_on_change(name)
changed << name
end
end
else
name = name.to_s
if reload_on_change(name)
changed << name
end
... | ruby | {
"resource": ""
} |
q21290 | RConfig.CoreMethods.reload_on_change | train | def reload_on_change(name)
logger.debug "reload_on_change(#{name.inspect}), reload_disabled=#{self.reload_disabled?}"
if changed = config_changed?(name) && reload?
if self.cache_hash[name]
flush_cache(name) # flush cached config values.
fire_on_load(name) # force on_load trigger... | ruby | {
"resource": ""
} |
q21291 | RConfig.CoreMethods.with_file | train | def with_file(name, *args)
logger.debug "with_file(#{name.inspect}, #{args.inspect})"
result = args.inject(config_for(name)) { |v, i|
logger.debug "v = #{v.inspect}, i = #{i.inspect}"
case v
when Hash
v[i.to_s]
when Array
i.is_a?(Integer) ? v[i] : ... | ruby | {
"resource": ""
} |
q21292 | RConfig.CoreMethods.config_for | train | def config_for(name)
name = name.to_s
check_for_changes(name) if auto_check?(name)
data = get_config_data(name)
logger.debug "config_for(#{name.inspect}) => #{data.inspect}"
data
end | ruby | {
"resource": ""
} |
q21293 | RConfig.CoreMethods.method_missing | train | def method_missing(method, * args)
value = with_file(method, * args)
logger.debug "#{self}.method_missing(#{method.inspect}, #{args.inspect}) => #{value.inspect}"
value
end | ruby | {
"resource": ""
} |
q21294 | SimplerTiles.VectorLayer.query | train | def query(sql, &blk)
layer = SimplerTiles::Query.new(sql, &blk)
add_query layer
end | ruby | {
"resource": ""
} |
q21295 | SimplerTiles.Map.layer | train | def layer(source, &blk)
layer = SimplerTiles::VectorLayer.new(source, &blk)
add_vector_layer layer
end | ruby | {
"resource": ""
} |
q21296 | SimplerTiles.Map.raster_layer | train | def raster_layer(source, &blk)
layer = SimplerTiles::RasterLayer.new(source, &blk)
add_raster_layer layer
end | ruby | {
"resource": ""
} |
q21297 | SimplerTiles.Map.ar_layer | train | def ar_layer(&blk)
if !defined?(ActiveRecord)
raise "ActiveRecord not available"
end
config = ActiveRecord::Base.connection.instance_variable_get("@config")
params = {
:dbname => config[:database],
:user => config[:username],
:host => config[:host],
... | ruby | {
"resource": ""
} |
q21298 | SimplerTiles.Map.to_png | train | def to_png
data = ""
to_png_stream Proc.new { |chunk| data += chunk }
yield data if block_given?
data
end | ruby | {
"resource": ""
} |
q21299 | SimplerTiles.Query.styles | train | def styles(styles)
styles.each do |k,v|
style = SimplerTiles::Style.new k, v
add_style style
end
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.