_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | 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}
| ruby | {
"resource": ""
} |
q21201 | Rfd.Commands.enter | train | def enter
if current_item.name == '.' # do nothing
elsif current_item.name == '..'
cd '..'
elsif in_zip?
v | 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)))
| ruby | {
"resource": ""
} |
q21203 | Riot.Message.method_missing | train | def method_missing(meth, *phrases, &block)
| 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, | 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
| 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|
| 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|
| 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 | ruby | {
"resource": ""
} |
q21210 | Stax.Ssm.ssm_parameter_tmpfile | train | def ssm_parameter_tmpfile(name)
Tempfile.new(stack_name).tap do |file|
| 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]}],
| 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|
| 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
| ruby | {
"resource": ""
} |
q21214 | Maestrano::Connector::Rails::Concerns::ConnecHelper.ClassMethods.id_hash | train | def id_hash(id, organization)
{
id: id,
provider: organization.oauth_provider,
| 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
| 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, | 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, | 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|
| 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 | 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)
| ruby | {
"resource": ""
} |
q21223 | Rpub.Compressor.store_file | train | def store_file(filename, content)
zip.put_next_entry filename, | ruby | {
"resource": ""
} |
q21224 | Rpub.Compressor.compress_file | train | def compress_file(filename, content)
zip.put_next_entry filename, | 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 | 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)
| 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 | ruby | {
"resource": ""
} |
q21229 | Weary.Resource.meets_requirements? | train | def meets_requirements?(params)
requirements.reject | 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 | 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
| 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)
| 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 + | 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 | ruby | {
"resource": ""
} |
q21235 | PGN.MoveCalculator.disambiguate_san | train | def disambiguate_san(possibilities)
move.disambiguation ?
possibilities.select | ruby | {
"resource": ""
} |
q21236 | PGN.MoveCalculator.disambiguate_pawns | train | def disambiguate_pawns(possibilities)
self.move.piece.match(/p/i) && !self.move.capture ?
| 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
| ruby | {
"resource": ""
} |
q21239 | Weary.Request.call | train | def call(environment)
app = adapter.new
middlewares = @middlewares || []
stack = Rack::Builder.new do
middlewares.each do |middleware|
| 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
| 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|
| ruby | {
"resource": ""
} |
q21242 | SAPOCI.Document.to_html | train | def to_html(options = {})
html = []
self.items.each do |item|
| 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,
| 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 -= | ruby | {
"resource": ""
} |
q21245 | GrabzIt.Client.url_to_animation | train | def url_to_animation(url, options = nil)
if options == nil
options = AnimationOptions.new()
end
| ruby | {
"resource": ""
} |
q21246 | GrabzIt.Client.url_to_image | train | def url_to_image(url, options = nil)
if options == nil
options = ImageOptions.new()
end
| ruby | {
"resource": ""
} |
q21247 | GrabzIt.Client.html_to_image | train | def html_to_image(html, options = nil)
if options == nil
options = ImageOptions.new()
end
| ruby | {
"resource": ""
} |
q21248 | GrabzIt.Client.url_to_table | train | def url_to_table(url, options = nil)
if options == nil
options = TableOptions.new()
end
| ruby | {
"resource": ""
} |
q21249 | GrabzIt.Client.html_to_table | train | def html_to_table(html, options = nil)
if options == nil
options = TableOptions.new()
end
| ruby | {
"resource": ""
} |
q21250 | GrabzIt.Client.url_to_pdf | train | def url_to_pdf(url, options = nil)
if options == nil
options = PDFOptions.new()
end
| ruby | {
"resource": ""
} |
q21251 | GrabzIt.Client.html_to_pdf | train | def html_to_pdf(html, options = nil)
if options == nil
options = PDFOptions.new()
end
| ruby | {
"resource": ""
} |
q21252 | GrabzIt.Client.url_to_docx | train | def url_to_docx(url, options = nil)
if options == nil
options = DOCXOptions.new()
end
| ruby | {
"resource": ""
} |
q21253 | GrabzIt.Client.html_to_docx | train | def html_to_docx(html, options = nil)
if options == nil
options = DOCXOptions.new()
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
| 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)))
| 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, | ruby | {
"resource": ""
} |
q21264 | GrabzIt.Client.decrypt_file | train | def decrypt_file(path, key)
data = read_file(path)
decryptedFile = File.new(path, "wb")
| 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")
| 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 | 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'
| 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 | 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 = | 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 | 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 | ruby | {
"resource": ""
} |
q21281 | RConfig.Utils.merge_hashes | train | def merge_hashes(hashes)
hashes.inject({}) | 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
| 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 | ruby | {
"resource": ""
} |
q21284 | RConfig.Cascade.overlay= | train | def overlay=(value)
reload(false) if self.overlay != value
self.overlay | 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})"
| 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(
| 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
| 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]
| 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)
| ruby | {
"resource": ""
} |
q21293 | RConfig.CoreMethods.method_missing | train | def method_missing(method, * args)
value = with_file(method, * args)
logger.debug | ruby | {
"resource": ""
} |
q21294 | SimplerTiles.VectorLayer.query | train | def query(sql, &blk)
layer = SimplerTiles::Query.new(sql, | ruby | {
"resource": ""
} |
q21295 | SimplerTiles.Map.layer | train | def layer(source, &blk)
layer = SimplerTiles::VectorLayer.new(source, &blk)
| ruby | {
"resource": ""
} |
q21296 | SimplerTiles.Map.raster_layer | train | def raster_layer(source, &blk)
layer = SimplerTiles::RasterLayer.new(source, | 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 => | ruby | {
"resource": ""
} |
q21298 | SimplerTiles.Map.to_png | train | def to_png
data = ""
to_png_stream Proc.new { |chunk| data += chunk }
| ruby | {
"resource": ""
} |
q21299 | SimplerTiles.Query.styles | train | def styles(styles)
styles.each do |k,v|
| ruby | {
"resource": ""
} |
Subsets and Splits
SQL Console for CoIR-Retrieval/CodeSearchNet-ccr-ruby-queries-corpus
Retrieves a large number of entries in the 'ruby' language, providing basic information but limited analytical value.