_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21000 | Ruby.RubyCompiler.on_array | train | def on_array expression
ArrayStatement.new | ruby | {
"resource": ""
} |
q21001 | Ruby.RubyCompiler.on_super | train | def on_super( statement )
arguments = process_all(statement.children) | ruby | {
"resource": ""
} |
q21002 | Parfait.Behaviour.resolve_method | train | def resolve_method( m_name )
raise "resolve_method #{m_name}.#{m_name.class}" unless m_name.is_a?(Symbol)
method = get_instance_method(m_name)
return method if method
if( super_class_name | ruby | {
"resource": ""
} |
q21003 | OpenAsset.RestClient.create_albums | train | def create_albums(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21004 | OpenAsset.RestClient.update_albums | train | def update_albums(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21005 | OpenAsset.RestClient.update_categories | train | def update_categories(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21006 | OpenAsset.RestClient.create_copyright_holders | train | def create_copyright_holders(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/CopyrightHolders") | ruby | {
"resource": ""
} |
q21007 | OpenAsset.RestClient.update_copyright_holders | train | def update_copyright_holders(data=nil,generate_objects=false)
uri = URI.parse(@uri + | ruby | {
"resource": ""
} |
q21008 | OpenAsset.RestClient.create_copyright_policies | train | def create_copyright_policies(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/CopyrightPolicies") | ruby | {
"resource": ""
} |
q21009 | OpenAsset.RestClient.update_copyright_policies | train | def update_copyright_policies(data=nil,generate_objects=false)
uri = URI.parse(@uri + | ruby | {
"resource": ""
} |
q21010 | OpenAsset.RestClient.create_fields | train | def create_fields(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21011 | OpenAsset.RestClient.update_fields | train | def update_fields(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21012 | OpenAsset.RestClient.get_field_lookup_strings | train | def get_field_lookup_strings(field=nil,query_obj=nil,with_nested_resources=false,use_http_query=false)
id = Validator.validate_field_lookup_string_arg(field)
uri = URI.parse(@uri + "/Fields" | ruby | {
"resource": ""
} |
q21013 | OpenAsset.RestClient.create_field_lookup_strings | train | def create_field_lookup_strings(field=nil,data=nil,generate_objects=false)
id = Validator.validate_field_lookup_string_arg(field)
uri = URI.parse(@uri + "/Fields" | ruby | {
"resource": ""
} |
q21014 | OpenAsset.RestClient.update_field_lookup_strings | train | def update_field_lookup_strings(field=nil,data=nil,generate_objects=false)
id = Validator.validate_field_lookup_string_arg(field)
uri = URI.parse(@uri + "/Fields" | ruby | {
"resource": ""
} |
q21015 | OpenAsset.RestClient.upload_file | train | def upload_file(file=nil,
category=nil,
project=nil,
generate_objects=false,
read_timeout=600,
low_priority_processing=false)
__upload_file(file,
category,
... | ruby | {
"resource": ""
} |
q21016 | OpenAsset.RestClient.replace_file | train | def replace_file(original_file_object=nil,
replacement_file_path='',
retain_original_filename_in_oa=false,
generate_objects=false)
__replace_file(original_file_object,
| ruby | {
"resource": ""
} |
q21017 | OpenAsset.RestClient.download_files | train | def download_files(files=nil,image_size='1',download_location='./Rest_Downloads')
# Put single files objects in an array for easy downloading | ruby | {
"resource": ""
} |
q21018 | OpenAsset.RestClient.update_files | train | def update_files(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21019 | OpenAsset.RestClient.create_groups | train | def create_groups(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21020 | OpenAsset.RestClient.update_groups | train | def update_groups(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21021 | OpenAsset.RestClient.create_keywords | train | def create_keywords(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21022 | OpenAsset.RestClient.update_keywords | train | def update_keywords(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21023 | OpenAsset.RestClient.merge_keywords | train | def merge_keywords(target,source)
uri = URI.parse(@uri + "/Keywords")
| ruby | {
"resource": ""
} |
q21024 | OpenAsset.RestClient.create_keyword_categories | train | def create_keyword_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/KeywordCategories") | ruby | {
"resource": ""
} |
q21025 | OpenAsset.RestClient.update_keyword_categories | train | def update_keyword_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri + | ruby | {
"resource": ""
} |
q21026 | OpenAsset.RestClient.merge_keyword_categories | train | def merge_keyword_categories(target,source)
uri | ruby | {
"resource": ""
} |
q21027 | OpenAsset.RestClient.create_photographers | train | def create_photographers(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Photographers")
| ruby | {
"resource": ""
} |
q21028 | OpenAsset.RestClient.update_photographers | train | def update_photographers(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Photographers")
| ruby | {
"resource": ""
} |
q21029 | OpenAsset.RestClient.create_projects | train | def create_projects(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21030 | OpenAsset.RestClient.update_projects | train | def update_projects(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21031 | OpenAsset.RestClient.create_project_keywords | train | def create_project_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/ProjectKeywords") | ruby | {
"resource": ""
} |
q21032 | OpenAsset.RestClient.update_project_keywords | train | def update_project_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/ProjectKeywords") | ruby | {
"resource": ""
} |
q21033 | OpenAsset.RestClient.merge_project_keywords | train | def merge_project_keywords(target,source)
uri = | ruby | {
"resource": ""
} |
q21034 | OpenAsset.RestClient.create_project_keyword_categories | train | def create_project_keyword_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri | ruby | {
"resource": ""
} |
q21035 | OpenAsset.RestClient.update_project_keyword_categories | train | def update_project_keyword_categories(data=nil,generate_objects=false)
uri = | ruby | {
"resource": ""
} |
q21036 | OpenAsset.RestClient.merge_project_keyword_categories | train | def merge_project_keyword_categories(target,source)
uri | ruby | {
"resource": ""
} |
q21037 | OpenAsset.RestClient.create_employee_keywords | train | def create_employee_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/EmployeeKeywords") | ruby | {
"resource": ""
} |
q21038 | OpenAsset.RestClient.update_employee_keywords | train | def update_employee_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + | ruby | {
"resource": ""
} |
q21039 | OpenAsset.RestClient.merge_employee_keywords | train | def merge_employee_keywords(target,source)
uri | ruby | {
"resource": ""
} |
q21040 | OpenAsset.RestClient.create_employee_keyword_categories | train | def create_employee_keyword_categories(data=nil,generate_objects=false)
uri = | ruby | {
"resource": ""
} |
q21041 | OpenAsset.RestClient.update_employee_keyword_categories | train | def update_employee_keyword_categories(data=nil,generate_objects=false)
uri = | ruby | {
"resource": ""
} |
q21042 | OpenAsset.RestClient.merge_employee_keyword_categories | train | def merge_employee_keyword_categories(target,source)
uri | ruby | {
"resource": ""
} |
q21043 | OpenAsset.RestClient.create_searches | train | def create_searches(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21044 | OpenAsset.RestClient.update_searches | train | def update_searches(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21045 | OpenAsset.RestClient.create_image_sizes | train | def create_image_sizes(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Sizes")
| ruby | {
"resource": ""
} |
q21046 | OpenAsset.RestClient.update_image_sizes | train | def update_image_sizes(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Sizes")
| ruby | {
"resource": ""
} |
q21047 | OpenAsset.RestClient.create_users | train | def create_users(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21048 | OpenAsset.RestClient.update_users | train | def update_users(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21049 | OpenAsset.RestClient.create_employees | train | def create_employees(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21050 | OpenAsset.RestClient.update_employees | train | def update_employees(data=nil,generate_objects=false)
| ruby | {
"resource": ""
} |
q21051 | Roger.Server.set_options | train | def set_options(options)
self.port = options[:port].to_i if options.key?(:port)
self.handler = options[:handler] if options.key?(:handler)
self.host | ruby | {
"resource": ""
} |
q21052 | Roger.Server.free_port_for_host_above | train | def free_port_for_host_above(host, port)
test_port = port
| ruby | {
"resource": ""
} |
q21053 | Roger.Server.port_free? | train | def port_free?(host, port)
Addrinfo.tcp(host, port).listen.close
true
| ruby | {
"resource": ""
} |
q21054 | Roger.Server.detect_valid_handler | train | def detect_valid_handler(servers)
handler = nil
while (server_name = servers.shift) && handler.nil?
begin
handler = ::Rack::Handler.get(server_name)
return [handler, server_name]
| ruby | {
"resource": ""
} |
q21055 | Roger.Template.render_with_tilt_template | train | def render_with_tilt_template(template_class, src, locals, &_block)
@current_tilt_template = template_class
template = template_class.new(source_path) { src }
block_content = if block_given?
yield
else
"" | ruby | {
"resource": ""
} |
q21056 | Roger.Template.extract_front_matter | train | def extract_front_matter(source)
fm_regex = /\A(---\s*\n.*?\n?)^(---\s*$\n?)/m
return [{}, source] unless match = source.match(fm_regex)
source = source.sub(fm_regex, "")
begin
data = (YAML.safe_load(match[1]) || {}).inject({}) do |memo, (k, v)|
memo[k.to_sym] = v
| ruby | {
"resource": ""
} |
q21057 | Roger.Release.use | train | def use(processor, options = {})
@stack << [self.class.get_callable(processor, | ruby | {
"resource": ""
} |
q21058 | Roger.Release.run! | train | def run!
project.mode = :release
# Validate paths
validate_paths!
# Extract mockup
copy_source_path_to_build_path!
| ruby | {
"resource": ""
} |
q21059 | Roger.Cli::Serve.serve | train | def serve
server_options = {}
options.each { |k, v| server_options[k.to_sym] = v }
server_options[:server] = {}
[:port, | ruby | {
"resource": ""
} |
q21060 | Roger.Rogerfile.load | train | def load
return unless File.exist?(@path) && !loaded?
@source = File.read(@path)
| ruby | {
"resource": ""
} |
q21061 | Roger.Renderer.render | train | def render(path, options = {}, &block)
template, layout = template_and_layout_for_render(path, options)
# Set new current template
template_nesting.push(template)
# Copy data to our data store. A bit clunky; as this should be inherited
@data = {}.update(@data).update(template.data)
... | ruby | {
"resource": ""
} |
q21062 | Roger.Renderer.render_file | train | def render_file(path, options = {})
pn = absolute_path_from_current_template(path)
template = template(pn.to_s, nil)
# Track rendered file also on the rendered stack | ruby | {
"resource": ""
} |
q21063 | Roger.Renderer.layout_for_template | train | def layout_for_template(template, options)
layout_name = if template.data.key?(:layout)
template.data[:layout]
else
get_default_layout(template, options)
end
# Only attempt to load layout when: | ruby | {
"resource": ""
} |
q21064 | Roger.Renderer.prevent_recursion! | train | def prevent_recursion!(template)
# If this template is not a real file it cannot ever conflict.
return unless template.real_source_path
caller_templates = template_nesting.select do |t|
t.real_source_path == template.real_source_path
| ruby | {
"resource": ""
} |
q21065 | Roger.Renderer.template | train | def template(path, source, type = :template)
if source
template = Template.new(source, @context, source_path: path)
else
template_path = case type
when :partial
find_partial(path)
| ruby | {
"resource": ""
} |
q21066 | Roger.Renderer.find_partial | train | def find_partial(name)
current_path, current_ext = current_template_path_and_extension
# Try to find _ named partials first.
# This will alaso search for partials relative to the current path
local_name = [File.dirname(name), "_" + File.basename(name)].join("/")
resolver = Resolver.new([F... | ruby | {
"resource": ""
} |
q21067 | Roger.Renderer.prepare_context | train | def prepare_context(env)
context = Roger::Template::TemplateContext.new(self, env)
| ruby | {
"resource": ""
} |
q21068 | Roger::Release::Processors.Mockup.run_on_file | train | def run_on_file(file_path, env = {})
renderer = Roger::Renderer.new(
env.dup,
partials_path: project.partial_path, | ruby | {
"resource": ""
} |
q21069 | Roger.Resolver.find_template_path | train | def find_template_path(name, options = {})
options = {
prefer: "html", # Prefer a template with extension
}.update(options)
path = sanitize_name(name, options[:prefer])
# Exact match
return Pathname.new(path) if File.exist?(path)
# Split extension and path
path_exten... | ruby | {
"resource": ""
} |
q21070 | Roger.Resolver.filter_files | train | def filter_files(files, path, path_without_extension, template_extensions)
results = []
files.each do |file|
match = if file.start_with?(path)
path
else
path_without_extension
end
processable_extensions = file[(match.lengt... | ruby | {
"resource": ""
} |
q21071 | Roger.Resolver.sanitize_name | train | def sanitize_name(name, prefer = nil)
path = name.to_s
# Check if we haven't got an extension
# we'll assume you're looking for prefer or "html" otherwise
| ruby | {
"resource": ""
} |
q21072 | Para.Cloneable.build_clone_callback | train | def build_clone_callback(callback)
case callback
when Proc
callback
when Symbol
->(original, clone) {
| ruby | {
"resource": ""
} |
q21073 | MoreCoreExtensions.BenchmarkRealtimeStore.realtime_store | train | def realtime_store(hash, key)
ret = nil
r0 = Time.now
begin
ret = yield
ensure
r1 | ruby | {
"resource": ""
} |
q21074 | MoreCoreExtensions.BenchmarkRealtimeStore.realtime_block | train | def realtime_block(key, &block)
hash = current_realtime
if in_realtime_block?
ret = realtime_store(hash, key, &block)
return ret, hash
else
begin
self.current_realtime = hash
begin
ret = realtime_store(hash, key, &block)
return ret, ... | ruby | {
"resource": ""
} |
q21075 | MoreCoreExtensions.ObjectNamespace.in_namespace? | train | def in_namespace?(val)
val_ns = val.to_s.split("::")
val_ns == (kind_of?(Module) ? namespace : | ruby | {
"resource": ""
} |
q21076 | MoreCoreExtensions.ArrayElementCounts.element_counts | train | def element_counts
each_with_object(Hash.new(0)) do |i, h|
| ruby | {
"resource": ""
} |
q21077 | Raml.ResourceType.instantiate | train | def instantiate(params)
instance = Instance.new( *interpolate(params), | ruby | {
"resource": ""
} |
q21078 | MoreCoreExtensions.RangeStepValue.step_value | train | def step_value(value)
if block_given?
return if self.begin > self.end
iter = self.begin
loop do
yield iter unless iter == self.end && exclude_end?
break if iter == self.end
iter += value
| ruby | {
"resource": ""
} |
q21079 | MoreCoreExtensions.ArrayInclusions.include_any? | train | def include_any?(*items)
items = items.first if items.length | ruby | {
"resource": ""
} |
q21080 | MoreCoreExtensions.ArrayInclusions.include_none? | train | def include_none?(*items)
items = items.first if items.length | ruby | {
"resource": ""
} |
q21081 | MoreCoreExtensions.ArrayInclusions.include_all? | train | def include_all?(*items)
items = items.first if items.length | ruby | {
"resource": ""
} |
q21082 | Airbrake.Sender.send_to_airbrake | train | def send_to_airbrake(data)
logger.debug { "Sending request to #{url.to_s}:\n#{data}" } if logger
http =
Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass).
new(url.host, url.port)
http.read_timeout = http_read_timeout
http.open_timeout = http_open_timeout
i... | ruby | {
"resource": ""
} |
q21083 | MoreCoreExtensions.Descendants.descendant_get | train | def descendant_get(desc_name)
return self if desc_name == name || desc_name.nil?
klass = descendants.find { |desc| desc.name == desc_name }
| ruby | {
"resource": ""
} |
q21084 | Raml.Root.expand | train | def expand
unless @expanded
resources.values.each(&:apply_resource_type)
resources.values.each(&:apply_traits)
| ruby | {
"resource": ""
} |
q21085 | MoreCoreExtensions.ArrayStretch.stretch! | train | def stretch!(*arys)
max_size = (arys + [self]).collect { |a| a.length }.max
self[max_size - | ruby | {
"resource": ""
} |
q21086 | Airbrake.Notice.to_xml | train | def to_xml
builder = Builder::XmlMarkup.new
builder.instruct!
xml = builder.notice(:version => Airbrake::API_VERSION) do |notice|
notice.tag!("api-key", api_key)
notice.notifier do |notifier|
notifier.name(notifier_name)
notifier.version(notifier_version)
... | ruby | {
"resource": ""
} |
q21087 | Airbrake.Notice.exception_attribute | train | def exception_attribute(attribute, default = nil, &block)
(exception | ruby | {
"resource": ""
} |
q21088 | Para.ModelHelper.model_field_mappings | train | def model_field_mappings(model, options = {})
if Array == options
whitelist_attributes = options
else
whitelist_attributes = options.fetch(:whitelist_attributes, nil)
mappings = options.fetch(:mappings, {})
| ruby | {
"resource": ""
} |
q21089 | MoreCoreExtensions.CacheWithTimeout.cache_with_timeout | train | def cache_with_timeout(method, timeout = nil, &block)
raise "no block given" if block.nil?
raise ArgumentError, "method must be a Symbol" unless method.respond_to?(:to_sym)
key = "#{name}.#{method}".to_sym
$cache_with_timeout_lock.synchronize(:EX) do
$cache_with_timeout[key] = {}
... | ruby | {
"resource": ""
} |
q21090 | ROS.Name.resolve_name_with_call_id | train | def resolve_name_with_call_id(caller_id, ns, name, remappings)
name = canonicalize_name(expand_local_name(caller_id, name))
if remappings
remappings.each_pair do |key, value|
if name == canonicalize_name(key)
name = value
| ruby | {
"resource": ""
} |
q21091 | ROS::TCPROS.ServiceServer.read_and_callback | train | def read_and_callback(socket)
request = @service_type.request_class.new
response = @service_type.response_class.new
data = read_all(socket)
@byte_received += data.length
request.deserialize(data)
result = @callback.call(request, response)
if result
send_ok_byte(socket)
... | ruby | {
"resource": ""
} |
q21092 | ROS::TCPROS.ServiceServer.serve | train | def serve(socket)
header = read_header(socket)
# not documented protocol?
if header['probe'] == '1'
write_header(socket, build_header)
elsif check_header(header)
write_header(socket, build_header)
read_and_callback(socket)
if header['persistent'] == '1'
| ruby | {
"resource": ""
} |
q21093 | ROS.Publisher.add_connection | train | def add_connection(caller_id) #:nodoc:
connection = TCPROS::Server.new(@caller_id, @topic_name, @topic_type,
:host=>@host,
:latched=>@is_latched,
| ruby | {
"resource": ""
} |
q21094 | ROS::TCPROS.Server.publish_msg | train | def publish_msg(socket, msg)
data = write_msg(socket, msg)
@last_published_msg = | ruby | {
"resource": ""
} |
q21095 | ROS::TCPROS.Server.serve | train | def serve(socket) #:nodoc:
header = read_header(socket)
if check_header(header)
if header['tcp_nodelay'] == '1'
socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
end
begin
write_header(socket, build_header)
if latching?
if @last_... | ruby | {
"resource": ""
} |
q21096 | ROS.ParameterManager.set_param | train | def set_param(key, value)
code, message, value = @server.call("setParam", @caller_id, key, value)
| ruby | {
"resource": ""
} |
q21097 | ROS.ParameterManager.delete_param | train | def delete_param(key)
code, message, value = @server.call("deleteParam", @caller_id, key)
case code
when 1 | ruby | {
"resource": ""
} |
q21098 | ROS.ParameterManager.search_param | train | def search_param(key)
code, message, value = @server.call("searchParam", @caller_id, key)
case code
when 1
return value
when -1
| ruby | {
"resource": ""
} |
q21099 | ROS.ParameterManager.has_param | train | def has_param(key)
code, message, value = @server.call("hasParam", @caller_id, key)
case code
when 1
return value
when -1
| 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.