_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q21000 | Ruby.RubyCompiler.on_array | train | def on_array expression
ArrayStatement.new expression.children.collect{ |elem| process(elem) }
end | ruby | {
"resource": ""
} |
q21001 | Ruby.RubyCompiler.on_super | train | def on_super( statement )
arguments = process_all(statement.children)
SendStatement.new( nil , SuperExpression.new , arguments)
end | 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 && super_class_name != :Object )
method = self.super_class.resolve_method(m_name)
end
me... | ruby | {
"resource": ""
} |
q21003 | OpenAsset.RestClient.create_albums | train | def create_albums(data=nil,generate_objects=false)
uri = URI.parse(@uri + '/Albums')
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21004 | OpenAsset.RestClient.update_albums | train | def update_albums(data=nil,generate_objects=false)
uri = URI.parse(@uri + '/Albums')
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21005 | OpenAsset.RestClient.update_categories | train | def update_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Categories")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21006 | OpenAsset.RestClient.create_copyright_holders | train | def create_copyright_holders(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/CopyrightHolders")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21007 | OpenAsset.RestClient.update_copyright_holders | train | def update_copyright_holders(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/CopyrightHolders")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21008 | OpenAsset.RestClient.create_copyright_policies | train | def create_copyright_policies(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/CopyrightPolicies")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21009 | OpenAsset.RestClient.update_copyright_policies | train | def update_copyright_policies(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/CopyrightPolicies")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21010 | OpenAsset.RestClient.create_fields | train | def create_fields(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Fields")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21011 | OpenAsset.RestClient.update_fields | train | def update_fields(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Fields")
put(uri,data,generate_objects)
end | 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" + "/#{id}" + "/FieldLookupStrings")
handle_get_request(uri,query_obj,with_nested_resources,u... | 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" + "/#{id}" + "/FieldLookupStrings")
post(uri,data,generate_objects)
end | 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" + "/#{id}" + "/FieldLookupStrings")
put(uri,data,generate_objects)
end | 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,
replacement_file_path,
... | 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 with
# the Array class' DownloadHelper module
files = [files] unless files.is_a?(Array)
files.download(image_size,download_locat... | ruby | {
"resource": ""
} |
q21018 | OpenAsset.RestClient.update_files | train | def update_files(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Files")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21019 | OpenAsset.RestClient.create_groups | train | def create_groups(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Groups")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21020 | OpenAsset.RestClient.update_groups | train | def update_groups(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Groups")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21021 | OpenAsset.RestClient.create_keywords | train | def create_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Keywords")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21022 | OpenAsset.RestClient.update_keywords | train | def update_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Keywords")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21023 | OpenAsset.RestClient.merge_keywords | train | def merge_keywords(target,source)
uri = URI.parse(@uri + "/Keywords")
merge(uri,target,source)
end | ruby | {
"resource": ""
} |
q21024 | OpenAsset.RestClient.create_keyword_categories | train | def create_keyword_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/KeywordCategories")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21025 | OpenAsset.RestClient.update_keyword_categories | train | def update_keyword_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/KeywordCategories")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21026 | OpenAsset.RestClient.merge_keyword_categories | train | def merge_keyword_categories(target,source)
uri = URI.parse(@uri + "/KeywordCategories")
merge(uri,target,source)
end | ruby | {
"resource": ""
} |
q21027 | OpenAsset.RestClient.create_photographers | train | def create_photographers(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Photographers")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21028 | OpenAsset.RestClient.update_photographers | train | def update_photographers(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Photographers")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21029 | OpenAsset.RestClient.create_projects | train | def create_projects(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Projects")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21030 | OpenAsset.RestClient.update_projects | train | def update_projects(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Projects")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21031 | OpenAsset.RestClient.create_project_keywords | train | def create_project_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/ProjectKeywords")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21032 | OpenAsset.RestClient.update_project_keywords | train | def update_project_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/ProjectKeywords")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21033 | OpenAsset.RestClient.merge_project_keywords | train | def merge_project_keywords(target,source)
uri = URI.parse(@uri + "/ProjectKeywords")
merge(uri,target,source)
end | ruby | {
"resource": ""
} |
q21034 | OpenAsset.RestClient.create_project_keyword_categories | train | def create_project_keyword_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/ProjectKeywordCategories")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21035 | OpenAsset.RestClient.update_project_keyword_categories | train | def update_project_keyword_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/ProjectKeywordCategories")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21036 | OpenAsset.RestClient.merge_project_keyword_categories | train | def merge_project_keyword_categories(target,source)
uri = URI.parse(@uri + "/ProjectKeywordCategories")
merge(uri,target,source)
end | ruby | {
"resource": ""
} |
q21037 | OpenAsset.RestClient.create_employee_keywords | train | def create_employee_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/EmployeeKeywords")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21038 | OpenAsset.RestClient.update_employee_keywords | train | def update_employee_keywords(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/EmployeeKeywords")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21039 | OpenAsset.RestClient.merge_employee_keywords | train | def merge_employee_keywords(target,source)
uri = URI.parse(@uri + "/EmployeeKeywords")
merge(uri,target,source)
end | ruby | {
"resource": ""
} |
q21040 | OpenAsset.RestClient.create_employee_keyword_categories | train | def create_employee_keyword_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/EmployeeKeywordCategories")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21041 | OpenAsset.RestClient.update_employee_keyword_categories | train | def update_employee_keyword_categories(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/EmployeeKeywordCategories")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21042 | OpenAsset.RestClient.merge_employee_keyword_categories | train | def merge_employee_keyword_categories(target,source)
uri = URI.parse(@uri + "/EmployeeKeywordCategories")
merge(uri,target,source)
end | ruby | {
"resource": ""
} |
q21043 | OpenAsset.RestClient.create_searches | train | def create_searches(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Searches")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21044 | OpenAsset.RestClient.update_searches | train | def update_searches(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Searches")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21045 | OpenAsset.RestClient.create_image_sizes | train | def create_image_sizes(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Sizes")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21046 | OpenAsset.RestClient.update_image_sizes | train | def update_image_sizes(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Sizes")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21047 | OpenAsset.RestClient.create_users | train | def create_users(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Users")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21048 | OpenAsset.RestClient.update_users | train | def update_users(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Users")
put(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21049 | OpenAsset.RestClient.create_employees | train | def create_employees(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Employees")
post(uri,data,generate_objects)
end | ruby | {
"resource": ""
} |
q21050 | OpenAsset.RestClient.update_employees | train | def update_employees(data=nil,generate_objects=false)
uri = URI.parse(@uri + "/Employees")
put(uri,data,generate_objects)
end | 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 = options[:host] if options.key?(:host)
self.auto_port = options[:auto_port] if options.key?(:auto_port)
end | ruby | {
"resource": ""
} |
q21052 | Roger.Server.free_port_for_host_above | train | def free_port_for_host_above(host, port)
test_port = port
test_port += 1 until port_free?(host, test_port) || port + 100 <= test_port
test_port
end | ruby | {
"resource": ""
} |
q21053 | Roger.Server.port_free? | train | def port_free?(host, port)
Addrinfo.tcp(host, port).listen.close
true
rescue SocketError, Errno::EADDRINUSE, Errno::EACCES
false
end | 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]
rescue LoadError
handler = nil
rescue NameError
handler = nil
... | 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
""
end
... | 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, Roger::Release::Processors.map), options]
end | ruby | {
"resource": ""
} |
q21058 | Roger.Release.run! | train | def run!
project.mode = :release
# Validate paths
validate_paths!
# Extract mockup
copy_source_path_to_build_path!
validate_stack!
# Run stack
run_stack!
# Cleanup
cleanup! if config[:cleanup_build]
ensure
project.mode = nil
end | 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, :handler, :host].each do |k|
server_options[:server][k] = server_options.delete(k) if server_options.key?(k)
end
@project.server.set_options(server_options... | ruby | {
"resource": ""
} |
q21060 | Roger.Rogerfile.load | train | def load
return unless File.exist?(@path) && !loaded?
@source = File.read(@path)
context = Context.new(self)
eval @source, context.binding, @path.to_s, 1 # rubocop:disable Lint/Eval
@loaded = true
end | 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
template_nesting.push(template)
template.render(options[:locals] || {})
ensure
# Only pop the template from the... | 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:
# - Template is the top... | 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
end
# We're good, no deeper recursion then MAX... | 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)
when :layout
... | 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)
# Extend context with all helpers
self.class.helpers.each do |mod|
context.extend(mod)
end
context
end | 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,
layouts_path: project.layouts_path
)
renderer.render(file_path, project.options[:renderer] || {})
end | 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
path += ".#{prefer || 'html'}" unless File.basename(path).include?(".")
path
end | ruby | {
"resource": ""
} |
q21072 | Para.Cloneable.build_clone_callback | train | def build_clone_callback(callback)
case callback
when Proc
callback
when Symbol
->(original, clone) {
original.send(callback, clone) if original.respond_to?(callback, true)
}
end
end | ruby | {
"resource": ""
} |
q21073 | MoreCoreExtensions.BenchmarkRealtimeStore.realtime_store | train | def realtime_store(hash, key)
ret = nil
r0 = Time.now
begin
ret = yield
ensure
r1 = Time.now
hash[key] = (hash[key] || 0) + (r1.to_f - r0.to_f)
end
ret
end | 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 : self.class.namespace)[0, val_ns.length]
end | ruby | {
"resource": ""
} |
q21076 | MoreCoreExtensions.ArrayElementCounts.element_counts | train | def element_counts
each_with_object(Hash.new(0)) do |i, h|
key = block_given? ? yield(i) : i
h[key] += 1
end
end | ruby | {
"resource": ""
} |
q21077 | Raml.ResourceType.instantiate | train | def instantiate(params)
instance = Instance.new( *interpolate(params), @parent )
instance.apply_resource_type
instance
end | 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
iter = self.end if iter > self.end
end
self
... | ruby | {
"resource": ""
} |
q21079 | MoreCoreExtensions.ArrayInclusions.include_any? | train | def include_any?(*items)
items = items.first if items.length == 1 && items.first.kind_of?(Array)
!(self & items).empty?
end | ruby | {
"resource": ""
} |
q21080 | MoreCoreExtensions.ArrayInclusions.include_none? | train | def include_none?(*items)
items = items.first if items.length == 1 && items.first.kind_of?(Array)
(self & items).empty?
end | ruby | {
"resource": ""
} |
q21081 | MoreCoreExtensions.ArrayInclusions.include_all? | train | def include_all?(*items)
items = items.first if items.length == 1 && items.first.kind_of?(Array)
(items - self).empty?
end | 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 }
raise ArgumentError, "#{desc_name} is not a descendant of #{name}" unless klass
klass
end | ruby | {
"resource": ""
} |
q21084 | Raml.Root.expand | train | def expand
unless @expanded
resources.values.each(&:apply_resource_type)
resources.values.each(&:apply_traits)
inline_reference SchemaReference, schemas, @children
@expanded = true
end
end | ruby | {
"resource": ""
} |
q21085 | MoreCoreExtensions.ArrayStretch.stretch! | train | def stretch!(*arys)
max_size = (arys + [self]).collect { |a| a.length }.max
self[max_size - 1] = nil unless self.length == max_size
return self
end | 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 && from_exception(attribute, &block)) || args[attribute] || default
end | 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, {})
end
Para::AttributeFieldMappings.new(
model, whitelist_a... | 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
end
end
end
if ns
... | 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,
:last_published_msg=>@last_published_msg)
connec... | ruby | {
"resource": ""
} |
q21094 | ROS::TCPROS.Server.publish_msg | train | def publish_msg(socket, msg)
data = write_msg(socket, msg)
@last_published_msg = msg
# for getBusStats
@byte_sent += data.length
@num_sent += 1
end | 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)
case code
when 1
return true
when -1
raise message
else
return false
end
end | 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
return true
else
return false
end
end | 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
raise message
else
return false
end
end | 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
raise message
else
return false
end
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.