_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
method
end | 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,use_http_query)
end | 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,
project,
generate_objects,
read_timeout,
low_priority_processing)
end | 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,
retain_original_filename_in_oa,
generate_objects)
end | 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_location)
end | 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
end
end
end | 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
template.render(@context, locals) do |name|
if name
@context._content_for_blocks[name]
else
block_content
end
end
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
memo
end
rescue *YAML_ERRORS => e
puts "YAML Exception: #{e.message}"
return false
end
[data, source]
rescue
[{}, source]
end | 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[:server])
end | 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)
# Render the template first so we have access to
# it's data in the layout.
render_result = template.render(options[:locals] || {}, &block)
# Wrap it in a layout
layout.render do
render_result
end
ensure
# Only pop the template from the nesting if we actually
# put it on the nesting stack.
template_nesting.pop if template
end | 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 nesting if we actually
# put it on the nesting stack.
template_nesting.pop if template
end | 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 toplevel template
# - A layout_name is available
return BlankTemplate.new if current_template || !layout_name
template(layout_name, nil, :layout)
end | 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_ALLOWED_TEMPLATE_NESTING
return if caller_templates.length <= MAX_ALLOWED_TEMPLATE_NESTING
err = "Recursive render detected for '#{template.source_path}'"
err += " in '#{current_template.source_path}'"
raise ArgumentError, err
end | 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
find_layout(path)
else
path
end
if template_path && File.exist?(template_path)
template = Template.open(template_path, @context)
else
template_not_found!(type, path)
end
end
prevent_recursion!(template)
template
end | 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([File.dirname(current_path)] + @paths[:partials])
result = resolver.find_template(local_name, prefer: current_ext)
return result if result
# Try to look for templates the old way
resolver = Resolver.new(@paths[:partials])
resolver.find_template(name, prefer: current_ext)
end | 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_extension, path_without_extension = split_path(path)
# Get possible output extensions for path_extension
template_extensions = template_extensions_for_output(path_extension, options[:prefer])
# Let's look at the disk to see what files we've got
files = Dir.glob(path_without_extension + ".*")
results = filter_files(files, path, path_without_extension, template_extensions)
if !results[0]
# No results found, but maybe there is a directory
# with the same name and it contains an index.XYZ
find_template_path(File.join(name, "index")) if File.directory?(name)
else
Pathname.new(results[0])
end
end | 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.length + 1)..-1].split(".")
# All processable_extensions must be processable
# by a template_extension
next unless (processable_extensions - template_extensions).empty?
if file.start_with?(path)
# The whole path is found in the filename, not just
# the path without the extension.
# it must have priority over all else
results.unshift(file)
else
results.push(file)
end
end
results
end | 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, hash
rescue Exception => err # rubocop:disable Lint/RescueException
err.define_singleton_method(:timings) { hash } unless err.respond_to?(:timings)
raise
ensure
delete_current_realtime
end
ensure
# A second layer of protection in case Timeout::Error struck right after
# setting self.current_realtime, or right before `delete_current_realtime`.
# In those cases, current_realtime might (wrongly) still exist.
delete_current_realtime if in_realtime_block?
end
end
end | 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
else
ret = []
step_value(value) { |v| ret << v }
ret
end
end | 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
if secure
http.use_ssl = true
http.ca_file = OpenSSL::X509::DEFAULT_CERT_FILE if File.exist?(OpenSSL::X509::DEFAULT_CERT_FILE)
http.verify_mode = OpenSSL::SSL::VERIFY_PEER
else
http.use_ssl = false
end
response = begin
http.post(url.path, data, HEADERS)
rescue *HTTP_ERRORS => e
log :error, "Timeout while contacting the Airbrake server."
nil
end
case response
when Net::HTTPSuccess then
log :info, "Success: #{response.class}", response
else
log :error, "Failure: #{response.class}", response
end
if response && response.respond_to?(:body)
error_id = response.body.match(%r{<error-id[^>]*>(.*?)</error-id>})
error_id[1] if error_id
end
end | 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)
notifier.url(notifier_url)
end
notice.error do |error|
error.tag!('class', error_class)
error.message(error_message)
error.backtrace do |backtrace|
self.backtrace.lines.each do |line|
backtrace.line(:number => line.number,
:file => line.file,
:method => line.method)
end
end
end
if url ||
controller ||
action ||
!parameters.blank? ||
!cgi_data.blank? ||
!session_data.blank?
notice.request do |request|
request.url(url)
request.component(controller)
request.action(action)
unless parameters.nil? || parameters.empty?
request.params do |params|
xml_vars_for(params, parameters)
end
end
unless session_data.nil? || session_data.empty?
request.session do |session|
xml_vars_for(session, session_data)
end
end
unless cgi_data.nil? || cgi_data.empty?
request.tag!("cgi-data") do |cgi_datum|
xml_vars_for(cgi_datum, cgi_data)
end
end
end
end
notice.tag!("server-environment") do |env|
env.tag!("project-root", project_root)
env.tag!("environment-name", environment_name)
env.tag!("hostname", hostname)
end
end
xml.to_s
end | 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_attributes: whitelist_attributes, mappings: mappings
)
end | 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] = {}
end
define_singleton_method(method) do |*args|
force_reload = args.first
return $cache_with_timeout_lock.synchronize(:EX) do
cache = $cache_with_timeout[key]
old_timeout = cache[:timeout]
cache.clear if force_reload || (old_timeout && Time.now.utc > old_timeout)
break cache[:value] if cache.key?(:value)
new_timeout = timeout || 300 # 5 minutes
new_timeout = new_timeout.call if new_timeout.kind_of?(Proc)
new_timeout = Time.now.utc + new_timeout
new_value = block.call
cache[:timeout] = new_timeout
cache[:value] = new_value
end
end
define_singleton_method("#{method}_clear_cache") do |*_args|
$cache_with_timeout_lock.synchronize(:EX) do
$cache_with_timeout[key].clear
end
end
define_singleton_method("#{method}_cached?") do |*_args|
$cache_with_timeout_lock.synchronize(:EX) do
!$cache_with_timeout[key].empty?
end
end
method.to_sym
end | 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
name = ns + SEP + name
end
return canonicalize_name(name)
end | 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)
data = write_msg(socket, response)
@byte_sent += data.length
else
send_ng_byte(socket)
write_header(socket, build_header)
# write some message
end
result
end | 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'
loop do
read_and_callback(socket)
end
end
else
socket.close
raise 'header check error'
end
end | 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)
connection.start
connection.id = "#{@topic_name}_out_#{@connection_id_number}"
@connection_id_number += 1
@connections.push(connection)
return connection
end | 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_published_msg
publish_msg(socket, @last_published_msg)
end
end
loop do
@last_published_msg = @msg_queue.pop
publish_msg(socket, @last_published_msg)
end
rescue
socket.shutdown
end
else
socket.shutdown
p "header check error: #{header}"
raise 'header check error'
end
end | 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.