_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q11300 | Trestle.TableHelper.table | train | def table(name=nil, options={}, &block)
if block_given?
if name.is_a?(Hash)
options = name
else
collection = name
end
table = Table::Builder.build(options, &block)
elsif name.is_a?(Trestle::Table)
table = name
else
table = admin.tabl... | ruby | {
"resource": ""
} |
q11301 | Trestle.PaginationHelper.page_entries_info | train | def page_entries_info(collection, options = {})
entry_name = options[:entry_name] || "entry"
entry_name = entry_name.pluralize unless collection.total_count == 1
if collection.total_pages < 2
t('trestle.helpers.page_entries_info.one_page.display_entries', entry_name: entry_name, count: collec... | ruby | {
"resource": ""
} |
q11302 | Trestle.Configuration.hook | train | def hook(name, options={}, &block)
hooks[name.to_s] | ruby | {
"resource": ""
} |
q11303 | Shipit.Deploy.trigger_rollback | train | def trigger_rollback(user = AnonymousUser.new, env: nil, force: false)
rollback = build_rollback(user, env: env, force: force)
rollback.save!
rollback.enqueue
lock_reason = "A rollback for #{rollback.since_commit.sha} has been triggered. " \
| ruby | {
"resource": ""
} |
q11304 | Jazzy.PodspecDocumenter.compiler_swift_version | train | def compiler_swift_version(user_version)
return LATEST_SWIFT_VERSION unless user_version
LONG_SWIFT_VERSIONS.select do |version|
| ruby | {
"resource": ""
} |
q11305 | JSONAPI.ResourceIdTree.fetch_related_resource_id_tree | train | def fetch_related_resource_id_tree(relationship)
relationship_name = relationship.name.to_sym
| ruby | {
"resource": ""
} |
q11306 | JSONAPI.PrimaryResourceIdTree.add_resource_fragment | train | def add_resource_fragment(fragment, include_related)
fragment.primary = true | ruby | {
"resource": ""
} |
q11307 | JSONAPI.RelatedResourceIdTree.add_resource_fragment | train | def add_resource_fragment(fragment, include_related)
init_included_relationships(fragment, include_related)
fragment.related_from.each do |rid|
| ruby | {
"resource": ""
} |
q11308 | Google.Cloud.error_reporting | train | def error_reporting scope: nil, timeout: nil, client_config: nil
Google::Cloud.error_reporting @project, @keyfile,
| ruby | {
"resource": ""
} |
q11309 | Google.Cloud.dns | train | def dns scope: nil, retries: nil, timeout: nil
Google::Cloud.dns @project, @keyfile, scope: scope,
| ruby | {
"resource": ""
} |
q11310 | Google.Cloud.spanner | train | def spanner scope: nil, timeout: nil, client_config: nil
Google::Cloud.spanner @project, @keyfile, scope: scope,
| ruby | {
"resource": ""
} |
q11311 | Google.Cloud.logging | train | def logging scope: nil, timeout: nil, client_config: nil
timeout ||= @timeout
Google::Cloud.logging @project, @keyfile, scope: | ruby | {
"resource": ""
} |
q11312 | Google.Cloud.bigquery | train | def bigquery scope: nil, retries: nil, timeout: nil
Google::Cloud.bigquery @project, @keyfile, scope: scope,
| ruby | {
"resource": ""
} |
q11313 | Google.Cloud.debugger | train | def debugger service_name: nil, service_version: nil, scope: nil,
timeout: nil, client_config: nil
Google::Cloud.debugger @project, @keyfile,
service_name: service_name,
service_version: service_version,
| ruby | {
"resource": ""
} |
q11314 | Google.Cloud.datastore | train | def datastore scope: nil, timeout: nil, client_config: nil
Google::Cloud.datastore @project, @keyfile,
| ruby | {
"resource": ""
} |
q11315 | Google.Cloud.resource_manager | train | def resource_manager scope: nil, retries: nil, timeout: nil
Google::Cloud.resource_manager @keyfile, scope: scope,
| ruby | {
"resource": ""
} |
q11316 | Google.Cloud.storage | train | def storage scope: nil, retries: nil, timeout: nil
Google::Cloud.storage @project, @keyfile, scope: scope,
| ruby | {
"resource": ""
} |
q11317 | Google.Cloud.translate | train | def translate key = nil, scope: nil, retries: nil, timeout: nil
Google::Cloud.translate key, project_id: @project, credentials: @keyfile,
scope: scope,
| ruby | {
"resource": ""
} |
q11318 | Google.Cloud.firestore | train | def firestore scope: nil, timeout: nil, client_config: nil
Google::Cloud.firestore @project, @keyfile,
| ruby | {
"resource": ""
} |
q11319 | Google.Cloud.trace | train | def trace scope: nil, timeout: nil, client_config: nil
Google::Cloud.trace @project, @keyfile, scope: scope,
| ruby | {
"resource": ""
} |
q11320 | Google.Cloud.bigtable | train | def bigtable scope: nil, timeout: nil, credentials: nil, client_config: nil
Google::Cloud.bigtable(
project_id: @project,
credentials: (credentials || @keyfile),
| ruby | {
"resource": ""
} |
q11321 | WebMock.BodyPattern.matching_body_hashes? | train | def matching_body_hashes?(query_parameters, pattern, content_type)
return false unless query_parameters.is_a?(Hash)
return false unless query_parameters.keys.sort == pattern.keys.sort
query_parameters.each do |key, actual|
expected = pattern[key]
if actual.is_a?(Hash) && expected.is_a... | ruby | {
"resource": ""
} |
q11322 | HTML.Pipeline.call | train | def call(html, context = {}, result = nil)
context = @default_context.merge(context)
context = context.freeze
result ||= @result_class.new
payload = default_payload filters: @filters.map(&:name),
context: context, result: result | ruby | {
"resource": ""
} |
q11323 | HTML.Pipeline.to_document | train | def to_document(input, context = {}, result = nil)
result = call(input, context, result)
| ruby | {
"resource": ""
} |
q11324 | HTML.Pipeline.to_html | train | def to_html(input, context = {}, result = nil)
result = call(input, context, result = nil)
| ruby | {
"resource": ""
} |
q11325 | Kaminari.PageScopeMethods.total_pages | train | def total_pages
count_without_padding = total_count
count_without_padding -= @_padding if defined?(@_padding) && @_padding
count_without_padding = 0 if count_without_padding < 0
total_pages_count = (count_without_padding.to_f / limit_value).ceil
max_pages && (max_pages | ruby | {
"resource": ""
} |
q11326 | Kaminari.PageScopeMethods.current_page | train | def current_page
offset_without_padding = offset_value
offset_without_padding -= @_padding if defined?(@_padding) && @_padding
offset_without_padding = 0 if offset_without_padding < 0
(offset_without_padding / limit_value) + 1 | ruby | {
"resource": ""
} |
q11327 | Kaminari.ActiveRecordRelationMethods.entry_name | train | def entry_name(options = {})
default = options[:count] == 1 ? model_name.human | ruby | {
"resource": ""
} |
q11328 | Guard.Watcher.call_action | train | def call_action(matches)
@action.arity > 0 ? @action.call(matches) : @action.call
| ruby | {
"resource": ""
} |
q11329 | Guard.CLI.start | train | def start
if defined?(JRUBY_VERSION)
unless options[:no_interactions]
abort "\nSorry, JRuby and interactive mode are incompatible.\n"\
"As a workaround, use the '-i' option instead.\n\n"\
"More info: \n"\
" * https://github.com/guard/guard/issues/754\n"\
| ruby | {
"resource": ""
} |
q11330 | Guard.CLI.notifiers | train | def notifiers
Cli::Environments::EvaluateOnly.new(options).evaluate
# TODO: pass | ruby | {
"resource": ""
} |
q11331 | Guard.CLI.init | train | def init(*plugin_names)
env = Cli::Environments::Valid.new(options) | ruby | {
"resource": ""
} |
q11332 | Guard.CLI.show | train | def show
Cli::Environments::EvaluateOnly.new(options).evaluate
| ruby | {
"resource": ""
} |
q11333 | Guard.PluginUtil.add_to_guardfile | train | def add_to_guardfile
klass = plugin_class # call here to avoid failing later
require_relative "guardfile/evaluator"
# TODO: move this to Generator?
options = Guard.state.session.evaluator_options
evaluator = Guardfile::Evaluator.new(options)
begin
evaluator.evaluate
re... | ruby | {
"resource": ""
} |
q11334 | Guard.PluginUtil._plugin_constant | train | def _plugin_constant
@_plugin_constant ||= Guard.constants.detect do |c|
| ruby | {
"resource": ""
} |
q11335 | Guard.Dsl.interactor | train | def interactor(options)
# TODO: remove dependency on Interactor (let session handle this)
case options
when :off
| ruby | {
"resource": ""
} |
q11336 | Guard.Dsl.guard | train | def guard(name, options = {})
@plugin_options = options.merge(watchers: [], callbacks: [])
yield if block_given?
@current_groups ||= []
groups = @current_groups && @current_groups.last | ruby | {
"resource": ""
} |
q11337 | Guard.Dsl.watch | train | def watch(pattern, &action)
# Allow watches in the global scope (to execute arbitrary commands) by
# building a generic Guard::Plugin.
@plugin_options ||= nil
return guard(:plugin) | ruby | {
"resource": ""
} |
q11338 | Guard.Dsl.callback | train | def callback(*args, &block)
@plugin_options ||= nil
fail "callback must be called within a guard block" unless @plugin_options
block, events = if args.size > 1
# block must be the first argument in that case, the
# yielded block is ignored
... | ruby | {
"resource": ""
} |
q11339 | Guard.Dsl.logger | train | def logger(options)
if options[:level]
options[:level] = options[:level].to_sym
unless [:debug, :info, :warn, :error].include? options[:level]
UI.warning(format(WARN_INVALID_LOG_LEVEL, options[:level]))
options.delete :level
end
end
if options[:only] && op... | ruby | {
"resource": ""
} |
q11340 | Guard.Dsl.directories | train | def directories(directories)
directories.each do |dir|
fail "Directory #{dir.inspect} does not exist!" unless Dir.exist?(dir)
| ruby | {
"resource": ""
} |
q11341 | Guard.Commander.start | train | def start(options = {})
setup(options)
UI.debug "Guard starts all plugins"
Runner.new.run(:start)
listener.start
watched = Guard.state.session.watchdirs.join("', '")
UI.info "Guard is now watching at '#{ watched }'"
exitcode = 0
begin
while interactor.foreground... | ruby | {
"resource": ""
} |
q11342 | Guard.Commander.run_all | train | def run_all(scopes = {})
UI.clear(force: true)
| ruby | {
"resource": ""
} |
q11343 | Guard.Commander.pause | train | def pause(expected = nil)
paused = listener.paused?
states = { paused: true, unpaused: false, toggle: !paused }
pause = states[expected || :toggle]
| ruby | {
"resource": ""
} |
q11344 | Guard.DslDescriber.show | train | def show
# collect metadata
groups = Guard.state.session.groups.all
objects = []
empty_plugin = OpenStruct.new
empty_plugin.options = [["", nil]]
groups.each do |group|
plugins = Array(Guard.state.session.plugins.all(group: group.name))
plugins = [empty_plugin] if ... | ruby | {
"resource": ""
} |
q11345 | Guard.DslDescriber.notifiers | train | def notifiers
supported = Notifier.supported
Notifier.connect(notify: true, silent: true)
detected = Notifier.detected
Notifier.disconnect
detected_names = detected.map { |item| item[:name] }
final_rows = supported.each_with_object([]) do |(name, _), rows|
available = detec... | ruby | {
"resource": ""
} |
q11346 | Guard.Runner.run | train | def run(task, scope_hash = {})
Lumberjack.unit_of_work do
items = Guard.state.scope.grouped_plugins(scope_hash || {})
| ruby | {
"resource": ""
} |
q11347 | Guard.Runner.run_on_changes | train | def run_on_changes(modified, added, removed)
types = {
MODIFICATION_TASKS => modified,
ADDITION_TASKS => added,
REMOVAL_TASKS => removed
}
UI.clearable
Guard.state.scope.grouped_plugins.each do |_group, plugins|
_run_group_plugins(plugins) do |plugin|
... | ruby | {
"resource": ""
} |
q11348 | Guard.Runner._supervise | train | def _supervise(plugin, task, *args)
catch self.class.stopping_symbol_for(plugin) do
plugin.hook("#{ task }_begin", *args)
result = UI.options.with_progname(plugin.class.name) do
begin
plugin.send(task, *args)
rescue Interrupt
throw(:task_has_failed)
... | ruby | {
"resource": ""
} |
q11349 | HTTP.Response.content_length | train | def content_length
# http://greenbytes.de/tech/webdav/rfc7230.html#rfc.section.3.3.3
# Clause 3: "If a message is received with both a Transfer-Encoding
# and a Content-Length header field, the Transfer-Encoding overrides the Content-Length.
return nil if @headers.include?(Headers::TRANSFER_ENCO... | ruby | {
"resource": ""
} |
q11350 | HTTP.Connection.readpartial | train | def readpartial(size = BUFFER_SIZE)
return unless @pending_response
chunk = @parser.read(size)
return chunk if chunk
finished = (read_more(size) == :eof) || @parser.finished?
| ruby | {
"resource": ""
} |
q11351 | HTTP.Connection.start_tls | train | def start_tls(req, options)
return unless req.uri.https? && !failed_proxy_connect?
ssl_context = options.ssl_context
unless ssl_context
ssl_context = OpenSSL::SSL::SSLContext.new
| ruby | {
"resource": ""
} |
q11352 | HTTP.Connection.send_proxy_connect_request | train | def send_proxy_connect_request(req)
return unless req.uri.https? && req.using_proxy?
@pending_request = true
req.connect_using_proxy @socket
@pending_request = false
@pending_response = true
read_headers!
@proxy_response_headers = @parser.headers
| ruby | {
"resource": ""
} |
q11353 | HTTP.Connection.set_keep_alive | train | def set_keep_alive
return @keep_alive = false unless @persistent
@keep_alive =
case @parser.http_version
when HTTP_1_0 # HTTP/1.0 requires opt in for Keep Alive
@parser.headers[Headers::CONNECTION] == KEEP_ALIVE
when HTTP_1_1 # HTTP/1.1 is opt-out
| ruby | {
"resource": ""
} |
q11354 | HTTP.Connection.read_more | train | def read_more(size)
return if @parser.finished?
value = @socket.readpartial(size, @buffer)
if value == :eof
@parser << ""
:eof
elsif value
@parser << value
| ruby | {
"resource": ""
} |
q11355 | HTTP.Chainable.via | train | def via(*proxy)
proxy_hash = {}
proxy_hash[:proxy_address] = proxy[0] if proxy[0].is_a?(String)
proxy_hash[:proxy_port] = proxy[1] if proxy[1].is_a?(Integer)
proxy_hash[:proxy_username] = proxy[2] if proxy[2].is_a?(String)
| ruby | {
"resource": ""
} |
q11356 | HTTP.Chainable.basic_auth | train | def basic_auth(opts)
user = opts.fetch :user
pass = opts.fetch :pass
| ruby | {
"resource": ""
} |
q11357 | HTTP.Client.request | train | def request(verb, uri, opts = {}) # rubocop:disable Style/OptionHash
opts = @default_options.merge(opts)
req = build_request(verb, uri, opts)
res = perform(req, opts)
| ruby | {
"resource": ""
} |
q11358 | HTTP.Client.build_request | train | def build_request(verb, uri, opts = {}) # rubocop:disable Style/OptionHash
opts = @default_options.merge(opts)
uri = make_request_uri(uri, opts)
headers = make_request_headers(opts)
body = make_request_body(opts, headers)
req = HTTP::Request.new(
:verb => verb,... | ruby | {
"resource": ""
} |
q11359 | HTTP.Client.verify_connection! | train | def verify_connection!(uri)
if default_options.persistent? && uri.origin != default_options.persistent
raise StateError, "Persistence is enabled for #{default_options.persistent}, but we got #{uri.origin}"
# We re-create the connection object because we want to let prior requests
# lazily load... | ruby | {
"resource": ""
} |
q11360 | HTTP.Client.make_request_uri | train | def make_request_uri(uri, opts)
uri = uri.to_s
if default_options.persistent? && uri !~ HTTP_OR_HTTPS_RE
uri = "#{default_options.persistent}#{uri}"
end
uri = HTTP::URI.parse uri
if opts.params && !opts.params.empty?
uri.query_values = uri.query_values(Array).to_a.concat... | ruby | {
"resource": ""
} |
q11361 | HTTP.Client.make_request_body | train | def make_request_body(opts, headers)
case
when opts.body
opts.body
when opts.form
form = HTTP::FormData.create opts.form
headers[Headers::CONTENT_TYPE] ||= form.content_type
form
when | ruby | {
"resource": ""
} |
q11362 | HTTP.Headers.delete | train | def delete(name)
name = normalize_header | ruby | {
"resource": ""
} |
q11363 | HTTP.Headers.add | train | def add(name, value)
name = normalize_header name.to_s
Array(value).each { |v| | ruby | {
"resource": ""
} |
q11364 | HTTP.Headers.get | train | def get(name)
name = normalize_header name.to_s
@pile.select { |k, | ruby | {
"resource": ""
} |
q11365 | HTTP.Headers.include? | train | def include?(name)
name = normalize_header | ruby | {
"resource": ""
} |
q11366 | HTTP.Headers.merge! | train | def merge!(other)
self.class.coerce(other).to_h.each { |name, | ruby | {
"resource": ""
} |
q11367 | HTTP.Headers.normalize_header | train | def normalize_header(name)
return name if name =~ CANONICAL_NAME_RE
normalized = name.split(/[\-_]/).each(&:capitalize!).join("-")
return normalized | ruby | {
"resource": ""
} |
q11368 | HTTP.Headers.validate_value | train | def validate_value(value)
v = value.to_s
return v unless v.include?("\n")
raise HeaderError, | ruby | {
"resource": ""
} |
q11369 | HTTP.Redirector.redirect_to | train | def redirect_to(uri)
raise StateError, "no Location header in redirect" unless uri
verb = @request.verb
code = @response.status.code
if UNSAFE_VERBS.include?(verb) && STRICT_SENSITIVE_CODES.include?(code)
raise StateError, "can't follow #{@response.status} redirect" if @strict | ruby | {
"resource": ""
} |
q11370 | HTTP.Request.stream | train | def stream(socket)
include_proxy_headers if using_proxy? | ruby | {
"resource": ""
} |
q11371 | HTTP.Request.proxy_connect_headers | train | def proxy_connect_headers
connect_headers = HTTP::Headers.coerce(
Headers::HOST => headers[Headers::HOST],
Headers::USER_AGENT => headers[Headers::USER_AGENT]
)
connect_headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header if | ruby | {
"resource": ""
} |
q11372 | Roo.Excelx.column | train | def column(column_number, sheet = nil)
if column_number.is_a?(::String)
column_number = | ruby | {
"resource": ""
} |
q11373 | Roo.Excelx.excelx_format | train | def excelx_format(row, col, sheet = nil)
key = normalize(row, col)
| ruby | {
"resource": ""
} |
q11374 | Roo.Excelx.process_zipfile | train | def process_zipfile(zipfilename_or_stream)
@sheet_files = []
unless is_stream?(zipfilename_or_stream)
zip_file = Zip::File.open(zipfilename_or_stream)
else
zip_file = Zip::CentralDirectory.new | ruby | {
"resource": ""
} |
q11375 | Roo.OpenOffice.decrypt_if_necessary | train | def decrypt_if_necessary(
zip_file,
content_entry,
roo_content_xml_path, options
)
# Check if content.xml is encrypted by extracting manifest.xml
# and searching for a manifest:encryption-data element
if (manifest_entry = zip_file.glob('META-INF/manifest.xml').first)
roo... | ruby | {
"resource": ""
} |
q11376 | Roo.OpenOffice.perform_decryption | train | def perform_decryption(
encryption_data,
password,
content_entry,
roo_content_xml_path
)
# Extract various expected attributes from the manifest that
# describe the encryption
algorithm_node = encryption_data.xpath('manifest:algorithm').first
key_derivatio... | ruby | {
"resource": ""
} |
q11377 | Roo.OpenOffice.find_cipher_key | train | def find_cipher_key(*args)
fail ArgumentError, 'Unknown key derivation name ', args[1] unless args[1] == 'PBKDF2'
| ruby | {
"resource": ""
} |
q11378 | Roo.OpenOffice.decrypt | train | def decrypt(content_entry, cipher)
# Zip::Entry.extract writes a 0-length file when trying
# to extract an encrypted stream, so we read the
# raw bytes based on the offset and lengths
decrypted = ''
File.open(@filename, 'rb') do |zipfile|
zipfile.seek(
content_entry.local... | ruby | {
"resource": ""
} |
q11379 | Roo.OpenOffice.set_cell_values | train | def set_cell_values(sheet, x, y, i, v, value_type, formula, table_cell, str_v, style_name)
key = [y, x + i]
@cell_type[sheet] ||= {}
@cell_type[sheet][key] = value_type.to_sym if value_type
@formula[sheet] ||= {}
if formula
['of:', 'oooc:'].each do |prefix|
if formula[0, ... | ruby | {
"resource": ""
} |
q11380 | Roo.Utils.num_cells_in_range | train | def num_cells_in_range(str)
cells = str.split(':')
return 1 if cells.count == 1
raise ArgumentError.new("invalid range string: #{str}. Supported range format 'A1:B2'") if cells.count != 2
x1, y1 | ruby | {
"resource": ""
} |
q11381 | Solargraph.ApiMap.catalog | train | def catalog bundle
new_map_hash = {}
# Bundle always needs to be merged if it adds or removes sources
merged = (bundle.sources.length == source_map_hash.values.length)
bundle.sources.each do |source|
if source_map_hash.key?(source.filename)
if source_map_hash[source.filename].c... | ruby | {
"resource": ""
} |
q11382 | Solargraph.ApiMap.clip_at | train | def clip_at filename, position
position = Position.normalize(position)
| ruby | {
"resource": ""
} |
q11383 | Solargraph.ApiMap.get_constants | train | def get_constants namespace, context = ''
namespace ||= ''
cached = cache.get_constants(namespace, context)
return cached.clone unless cached.nil?
skip = []
result = []
bases = context.split('::')
while bases.length > 0
built = bases.join('::')
fqns = qualify(na... | ruby | {
"resource": ""
} |
q11384 | Solargraph.ApiMap.qualify | train | def qualify namespace, context = ''
# @todo The return for self might work better elsewhere
return nil if namespace.nil?
return qualify(context) if namespace == 'self'
cached = cache.get_qualified_namespace(namespace, context)
return cached.clone unless cached.nil?
result = if namesp... | ruby | {
"resource": ""
} |
q11385 | Solargraph.ApiMap.get_instance_variable_pins | train | def get_instance_variable_pins(namespace, scope = :instance)
result = []
result.concat store.get_instance_variables(namespace, scope)
sc = qualify(store.get_superclass(namespace), namespace)
until sc.nil?
| ruby | {
"resource": ""
} |
q11386 | Solargraph.ApiMap.get_methods | train | def get_methods fqns, scope: :instance, visibility: [:public], deep: true
cached = cache.get_methods(fqns, scope, visibility, deep)
return cached.clone unless cached.nil?
result = []
skip = []
if fqns == ''
# @todo Implement domains
# domains.each do |domain|
# ty... | ruby | {
"resource": ""
} |
q11387 | Solargraph.ApiMap.get_complex_type_methods | train | def get_complex_type_methods type, context = '', internal = false
# This method does not qualify the complex type's namespace because
# it can cause conflicts between similar names, e.g., `Foo` vs.
# `Other::Foo`. It still takes a context argument to determine whether
# protected and private met... | ruby | {
"resource": ""
} |
q11388 | Solargraph.ApiMap.get_method_stack | train | def get_method_stack fqns, name, scope: :instance
get_methods(fqns, scope: scope, visibility: [:private, | ruby | {
"resource": ""
} |
q11389 | Solargraph.ApiMap.get_path_suggestions | train | def get_path_suggestions path
return [] if path.nil?
result = []
result.concat store.get_path_pins(path)
# if result.empty?
# | ruby | {
"resource": ""
} |
q11390 | Solargraph.ApiMap.search | train | def search query
rake_yard(store)
found = []
code_object_paths.each do |k|
if found.empty? || (query.include?('.') || | ruby | {
"resource": ""
} |
q11391 | Solargraph.ApiMap.document | train | def document path
rake_yard(store)
docs = []
| ruby | {
"resource": ""
} |
q11392 | Solargraph.ApiMap.query_symbols | train | def query_symbols query
result = []
source_map_hash.values.each do |s|
| ruby | {
"resource": ""
} |
q11393 | Solargraph.ApiMap.require_extensions | train | def require_extensions
Gem::Specification.all_names.select{|n| n.match(/^solargraph\-[a-z0-9_\-]*?\-ext\-[0-9\.]*$/)}.each do |n|
Solargraph::Logging.logger.info "Loading extension #{n}"
| ruby | {
"resource": ""
} |
q11394 | Solargraph.ApiMap.prefer_non_nil_variables | train | def prefer_non_nil_variables pins
result = []
nil_pins = []
pins.each do |pin|
if pin.variable? && pin.nil_assignment?
nil_pins.push pin
| ruby | {
"resource": ""
} |
q11395 | Solargraph.ApiMap.super_and_sub? | train | def super_and_sub?(sup, sub)
fqsup = qualify(sup)
cls = qualify(store.get_superclass(sub), sub)
| ruby | {
"resource": ""
} |
q11396 | Solargraph.Range.contain? | train | def contain? position
position = Position.normalize(position)
return false if position.line < start.line || position.line > ending.line
return false if position.line == start.line && position.character < start.character
| ruby | {
"resource": ""
} |
q11397 | Solargraph.Range.include? | train | def include? position
position = Position.normalize(position)
| ruby | {
"resource": ""
} |
q11398 | Solargraph.Source.tree_at | train | def tree_at(line, column)
# offset = Position.line_char_to_offset(@code, line, column)
position = Position.new(line, column)
stack = | ruby | {
"resource": ""
} |
q11399 | Solargraph.Source.synchronize | train | def synchronize updater
raise 'Invalid synchronization' unless updater.filename == filename
real_code = updater.write(@code)
if real_code == @code
@version = updater.version
return self
end
synced = Source.new(real_code, filename)
if synced.parsed?
synced.vers... | 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.