_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q2600 | Regression.Base.covariance2 | train | def covariance2(xs, ys)
raise "Length xs and ys must be equal" unless xs.length == ys.length
ev_x, ev_y = mean(xs), mean(ys)
xs.zip(ys)
| ruby | {
"resource": ""
} |
q2601 | GeoElevation.Srtm.get_file_name | train | def get_file_name(latitude, longitude)
north_south = latitude >= 0 ? 'N' : 'S'
east_west = longitude >= 0 ? 'E' : 'W' | ruby | {
"resource": ""
} |
q2602 | GeoElevation.SrtmFile.get_elevation | train | def get_elevation(latitude, longitude)
if ! (@latitude <= latitude && latitude < @latitude + 1)
raise "Invalid latitude #{latitude} for file #{@file_name}"
end
if ! (@longitude <= longitude && longitude < @longitude + 1)
raise "Invalid longitude #{long... | ruby | {
"resource": ""
} |
q2603 | GeoElevation.Undulations.get_value_at_file_position | train | def get_value_at_file_position(position)
@file.seek(4 + position * 4)
bytes = @file.read(4)
begin
value = bytes[0].ord | ruby | {
"resource": ""
} |
q2604 | GeoElevation.Undulations.unpack | train | def unpack(n)
sign = n >> 31
exponent = (n >> (32 - 9)) & 0b11111111
value = n & 0b11111111111111111111111
resul = nil
if 1 <= exponent and exponent <= 254
| ruby | {
"resource": ""
} |
q2605 | ChefRunDeck.State.add_state | train | def add_state(node, user, params)
# => Create a Node-State Object
(n = {}) && (n[:name] = node)
n[:created] = DateTime.now
n[:creator] = user
n[:type] = params['type'] | ruby | {
"resource": ""
} |
q2606 | ChefRunDeck.State.delete_state | train | def delete_state(node)
# => Find the Node
existing = find_state(node)
return 'Node not present in state' unless existing
# => Delete the Node from State
| ruby | {
"resource": ""
} |
q2607 | Somemoji.EmojiCollection.replace_character | train | def replace_character(string, &block)
string.gsub(character_pattern) do |character|
| ruby | {
"resource": ""
} |
q2608 | Somemoji.EmojiCollection.replace_code | train | def replace_code(string, &block)
string.gsub(code_pattern) do |matched_string| | ruby | {
"resource": ""
} |
q2609 | Somemoji.EmojiCollection.search_by_code | train | def search_by_code(pattern)
self.class.new(
select do |emoji|
pattern === | ruby | {
"resource": ""
} |
q2610 | Scorpion.Hunt.inject | train | def inject( object )
trip.object = object
object.send :scorpion_hunt=, self
object.injected_attributes.each do |attr|
| ruby | {
"resource": ""
} |
q2611 | Scorpion.AttributeSet.define_attribute | train | def define_attribute( name, contract, **options )
| ruby | {
"resource": ""
} |
q2612 | Pluginator::Extensions.PluginsMap.plugins_map | train | def plugins_map(type)
@plugins_map ||= {}
type = type.to_s
@plugins_map[type] ||= | ruby | {
"resource": ""
} |
q2613 | WebsocketGui.Base.run! | train | def run!(runtime_config = {})
@websocket_config.merge! runtime_config
EM.run do
if @websocket_config[:tick_interval]
EM.add_periodic_timer(@websocket_config[:tick_interval]) do
socket_trigger(:on_tick, @socket_connected)
end
end
EventMachine::WebSocket.run(host: @websocket_config[:so... | ruby | {
"resource": ""
} |
q2614 | Pluginator::Extensions.FirstClass.first_class! | train | def first_class!(type, klass)
@plugins[type] or raise Pluginator::MissingType.new(type, @plugins.keys)
klass = string2class(klass)
plugins_map(type)[klass] or
| ruby | {
"resource": ""
} |
q2615 | ZerigoDNS::Resource.ClassMethods.process_response | train | def process_response response
without_root = response.body.values.first
case
when without_root.is_a?(Array) then process_array(response, without_root)
| ruby | {
"resource": ""
} |
q2616 | Scorpion.Object.inject_from | train | def inject_from( dependencies, overwrite = false )
injected_attributes.each do |attr|
next unless dependencies.key? attr.name
| ruby | {
"resource": ""
} |
q2617 | Scorpion.Object.inject_from! | train | def inject_from!( dependencies, overwrite = false )
injected_attributes.each do |attr|
next unless dependencies.key? attr.name
| ruby | {
"resource": ""
} |
q2618 | ZerigoDNS::Resource::Attributes.InstanceMethods.method_missing | train | def method_missing mtd, *args
if mtd.to_s.chars.to_a.last == '='
raise ArgumentError, "Invalid number of arguments (#{args.length} for 1)" if args.length != 1
attributes[mtd.to_s.slice(0,mtd.to_s.length-1)] = args.first
| ruby | {
"resource": ""
} |
q2619 | Beaglebone.AINPin.run_on_change | train | def run_on_change(callback, mv_change=10, interval=0.01, repeats=nil)
| ruby | {
"resource": ""
} |
q2620 | Beaglebone.AINPin.run_on_threshold | train | def run_on_threshold(callback, mv_lower, mv_upper, mv_reset=10, interval=0.01, | ruby | {
"resource": ""
} |
q2621 | Beaglebone.AINPin.run_once_on_threshold | train | def run_once_on_threshold(callback, mv_lower, mv_upper, mv_reset=10, interval=0.01)
| ruby | {
"resource": ""
} |
q2622 | DataMapper.Validation.validate | train | def validate(context_name = default_validation_context)
errors.clear
| ruby | {
"resource": ""
} |
q2623 | Pluginator.Group.register_plugin | train | def register_plugin(type, klass)
type = type.to_s
@plugins[type] | ruby | {
"resource": ""
} |
q2624 | Scorpion.Hunter.find_dependency | train | def find_dependency( hunt )
dependency = dependency_map.find( hunt.contract )
dependency | ruby | {
"resource": ""
} |
q2625 | Pluginator::Extensions.FirstAsk.first_ask! | train | def first_ask!(type, method_name, *params)
@plugins[type] or raise Pluginator::MissingType.new(type, @plugins.keys)
| ruby | {
"resource": ""
} |
q2626 | Beaglebone.GPIOPin.run_on_edge | train | def run_on_edge(callback, edge, timeout=nil, repeats=nil)
| ruby | {
"resource": ""
} |
q2627 | ZerigoDNS::Resource::Naming.ClassMethods.default_resource_name | train | def default_resource_name
result = self.to_s.split("::").last.gsub(/([A-Z])/, '_\1').downcase
| ruby | {
"resource": ""
} |
q2628 | Hdf5.H5Dataspace.offset_simple | train | def offset_simple(offsets)
raise ArgumentError.new("offsets should have ndims elements") unless offsets.size == ndims
| ruby | {
"resource": ""
} |
q2629 | Rundeck.Request.api_token_header | train | def api_token_header(options, path = nil)
return nil if path == '/j_security_check'
unless @api_token
fail Error::MissingCredentials, 'Please set a api_token for user'
end
| ruby | {
"resource": ""
} |
q2630 | Pluginator.NameConverter.name2class | train | def name2class(name)
klass = Kernel
name.to_s.split(%r{/}).each do |part|
| ruby | {
"resource": ""
} |
q2631 | Scorpion.Stinger.sting! | train | def sting!( object )
return object unless scorpion
if object
assign_scorpion object
| ruby | {
"resource": ""
} |
q2632 | Pluginator::Extensions.Matching.matching | train | def matching(type, list)
list.map do |plugin|
(plugins_map(type) | ruby | {
"resource": ""
} |
q2633 | Pluginator::Extensions.Matching.matching! | train | def matching!(type, list)
@plugins[type] or raise Pluginator::MissingType.new(type, @plugins.keys)
list.map do |plugin|
plugin = string2class(plugin)
| ruby | {
"resource": ""
} |
q2634 | Rundeck.Client.objectify | train | def objectify(result)
if result.is_a?(Hash)
ObjectifiedHash.new(result)
elsif result.is_a?(Array)
| ruby | {
"resource": ""
} |
q2635 | ZerigoDNS::Resource::Rest.ClassMethods.convert | train | def convert object
return {resource_name => object} if object.is_a? Hash
| ruby | {
"resource": ""
} |
q2636 | ReqresRspec.Collector.sort | train | def sort
self.records.sort! do |x,y|
comp = x[:request][:symbolized_path] <=> y[:request][:symbolized_path]
| ruby | {
"resource": ""
} |
q2637 | ReqresRspec.Collector.read_response_headers | train | def read_response_headers(response)
raw_headers = response.headers
headers = {}
EXCLUDE_RESPONSE_HEADER_PATTERNS.each do |pattern|
| ruby | {
"resource": ""
} |
q2638 | ReqresRspec.Collector.get_symbolized_path | train | def get_symbolized_path(request)
request_path = (request.env['REQUEST_URI'] || request.path).dup
request_params =
request.env['action_dispatch.request.parameters'] ||
request.env['rack.request.form_hash'] ||
request.env['rack.request.query_hash']
if request_params
requ... | ruby | {
"resource": ""
} |
q2639 | Scorpion.DependencyMap.capture | train | def capture( contract, **options, &builder )
active_dependency_set.unshift Dependency::CapturedDependency.new( define_dependency( contract, | ruby | {
"resource": ""
} |
q2640 | Scorpion.DependencyMap.replicate_from | train | def replicate_from( other_map )
other_map.each do |dependency|
| ruby | {
"resource": ""
} |
q2641 | Beaglebone.SPIDevice.xfer | train | def xfer(tx_data, readbytes=0, speed=nil, delay=nil, | ruby | {
"resource": ""
} |
q2642 | Rundeck.Configuration.options | train | def options
VALID_OPTIONS_KEYS.reduce({}) do |option, key|
| ruby | {
"resource": ""
} |
q2643 | MessageMediaMessages.RepliesController.check_replies | train | def check_replies
# Prepare query url.
_path_url = '/v1/replies'
_query_builder = Configuration.base_uri.dup
_query_builder << _path_url
_query_url = APIHelper.clean_url _query_builder
# Prepare headers.
_headers = {
'accept' => 'application/json'
| ruby | {
"resource": ""
} |
q2644 | FitgemOauth2.Client.heartrate_time_series | train | def heartrate_time_series(start_date: nil, end_date: nil, period: nil)
warn '[DEPRECATION] `heartrate_time_series` is deprecated. Please use `hr_series_for_date_range` or `hr_series_for_period` instead.'
regular_time_series_guard(
start_date: start_date,
end_date: end_date,
| ruby | {
"resource": ""
} |
q2645 | FitgemOauth2.Client.intraday_heartrate_time_series | train | def intraday_heartrate_time_series(start_date: nil, end_date: nil, detail_level: nil, start_time: nil, end_time: nil)
intraday_series_guard(
start_date: start_date,
end_date: end_date,
detail_level: detail_level,
start_time: start_time,
end_time: end_time
)
end... | ruby | {
"resource": ""
} |
q2646 | MessageMediaMessages.FaradayClient.execute_as_string | train | def execute_as_string(http_request)
response = @connection.send(
http_request.http_method.downcase,
http_request.query_url
) do |request|
request.headers = http_request.headers
| ruby | {
"resource": ""
} |
q2647 | MessageMediaMessages.FaradayClient.convert_response | train | def convert_response(response)
HttpResponse.new(response.status, | ruby | {
"resource": ""
} |
q2648 | RailsAdminClone.ModelCloner.clone_object | train | def clone_object(old_object)
object = build_from(old_object) | ruby | {
"resource": ""
} |
q2649 | RailsAdminClone.ModelCloner.clone_has_one | train | def clone_has_one(old_object, new_object)
old_object.class.reflect_on_all_associations(:has_one).each do |association|
old_association = old_object.send(association.name)
| ruby | {
"resource": ""
} |
q2650 | RailsAdminClone.ModelCloner.clone_has_many | train | def clone_has_many(old_object, new_object)
associations = old_object.class.reflect_on_all_associations(:has_many)
.select{|a| !a.options.keys.include?(:through)}
associations.each do |association|
old_object.send(association.name).each do |old_association|
| ruby | {
"resource": ""
} |
q2651 | WatirNokogiri.Button.text | train | def text
assert_exists
tn = @element.node_name.downcase
case tn
when 'input'
@element.get_attribute(:value)
when 'button'
@element.text
| ruby | {
"resource": ""
} |
q2652 | FitgemOauth2.Client.intraday_activity_time_series | train | def intraday_activity_time_series(resource: nil, start_date: nil, end_date: nil, detail_level: nil,
start_time: nil, end_time: nil)
# converting to symbol to allow developer to use either 'calories' or :calories
resource = resource.to_sym
unless %i[calories step... | ruby | {
"resource": ""
} |
q2653 | FitgemOauth2.Client.activity_list | train | def activity_list(date, sort, limit)
date_param = format_date(date)
if sort == "asc"
date_param = "afterDate=#{date_param}"
elsif sort == "desc"
date_param = "beforeDate=#{date_param}"
else
| ruby | {
"resource": ""
} |
q2654 | FitgemOauth2.Client.update_activity_goals | train | def update_activity_goals(period, params)
unless period && %w(daily weekly).include?(period)
raise FitgemOauth2::InvalidArgumentError, "Goal period should either be 'daily' or 'weekly'"
| ruby | {
"resource": ""
} |
q2655 | FitgemOauth2.Client.sleep_time_series | train | def sleep_time_series(resource: nil, start_date: nil, end_date: nil, period: nil)
unless start_date
raise FitgemOauth2::InvalidArgumentError, 'Start date not provided.'
end
unless resource && SLEEP_RESOURCES.include?(resource)
raise FitgemOauth2::InvalidArgumentError, "Invalid resourc... | ruby | {
"resource": ""
} |
q2656 | WatirNokogiri.Option.text | train | def text
assert_exists
# A little unintuitive - we'll return the 'label' or 'text' attribute if
# they exist, otherwise the inner text of the element
attribute = [:label, :text].find { | ruby | {
"resource": ""
} |
q2657 | WatirNokogiri.Element.style | train | def style(property = nil)
assert_exists
styles = attribute_value('style').to_s.strip
if property
properties | ruby | {
"resource": ""
} |
q2658 | WatirNokogiri.Element.parent | train | def parent
assert_exists
e = @element.parent
if e.kind_of?(Nokogiri::XML::Element) | ruby | {
"resource": ""
} |
q2659 | DhtSensor.App.to_hash | train | def to_hash(val)
if @options[:humidity] then
return {"humidity" => val.humidity}
end
if @options[:unit] == :c then
if @options[:temperature] then
return {"temperature" => val.temp}
else
return {"temperature" => val.temp, "humidity" => val.humidity}
... | ruby | {
"resource": ""
} |
q2660 | DhtSensor.App.print | train | def print(val)
if @options[:humidity] then
puts sprintf("Humidity: %.2f%%", val.humidity)
return
end
if @options[:unit] == :c then
if @options[:temperature] then
puts sprintf("Temperature: %.2f C", val.temp)
| ruby | {
"resource": ""
} |
q2661 | WatirNokogiri.CellContainer.cell | train | def cell(*args)
cell = TableCell.new(self, extract_selector(args).merge(:tag_name | ruby | {
"resource": ""
} |
q2662 | WatirNokogiri.CellContainer.cells | train | def cells(*args)
cells = TableCellCollection.new(self, extract_selector(args).merge(:tag_name | ruby | {
"resource": ""
} |
q2663 | MessageMediaMessages.BaseModel.to_hash | train | def to_hash
hash = {}
instance_variables.each do |name|
value = instance_variable_get(name)
next if value.nil?
name = name[1..-1]
key = self.class.names.key?(name) ? self.class.names[name] : name
if value.instance_of? Array
| ruby | {
"resource": ""
} |
q2664 | WatirNokogiri.Document.goto | train | def goto(file_path)
html = File.read(file_path) | ruby | {
"resource": ""
} |
q2665 | Titlekit.Job.run | train | def run
@wants.each do |want|
@haves.each do |have|
import(have)
retime(have, want)
cull(have)
group(have)
want.subtitles += have.subtitles.clone
end
| ruby | {
"resource": ""
} |
q2666 | Titlekit.Job.cull | train | def cull(have)
have.subtitles.reject! { |subtitle| subtitle[:end] < 0 }
have.subtitles.each do |subtitle|
| ruby | {
"resource": ""
} |
q2667 | Titlekit.Job.retime_by_framerate | train | def retime_by_framerate(have, want)
ratio = want.fps.to_f / have.fps.to_f
| ruby | {
"resource": ""
} |
q2668 | MessageMediaMessages.HttpClient.get | train | def get(query_url,
headers: {})
HttpRequest.new(HttpMethodEnum::GET,
| ruby | {
"resource": ""
} |
q2669 | MessageMediaMessages.HttpClient.head | train | def head(query_url,
headers: {})
HttpRequest.new(HttpMethodEnum::HEAD,
| ruby | {
"resource": ""
} |
q2670 | MessageMediaMessages.HttpClient.post | train | def post(query_url,
headers: {},
parameters: {})
HttpRequest.new(HttpMethodEnum::POST,
query_url,
| ruby | {
"resource": ""
} |
q2671 | MessageMediaMessages.HttpClient.put | train | def put(query_url,
headers: {},
parameters: {})
HttpRequest.new(HttpMethodEnum::PUT,
query_url,
| ruby | {
"resource": ""
} |
q2672 | MessageMediaMessages.HttpClient.patch | train | def patch(query_url,
headers: {},
parameters: {})
HttpRequest.new(HttpMethodEnum::PATCH,
query_url,
| ruby | {
"resource": ""
} |
q2673 | MessageMediaMessages.HttpClient.delete | train | def delete(query_url,
headers: {},
parameters: {})
HttpRequest.new(HttpMethodEnum::DELETE,
query_url,
| ruby | {
"resource": ""
} |
q2674 | Capistrano.LogWithAwesome.log | train | def log(level, message, line_prefix=nil)
if level <= self.level
indent = "%*s" % [Capistrano::Logger::MAX_LEVEL, "*" * (Capistrano::Logger::MAX_LEVEL - level)]
(RUBY_VERSION >= "1.9" ? message.lines : message).each do |line|
if line_prefix
self.class.log_with_awesome "#{inden... | ruby | {
"resource": ""
} |
q2675 | ActsAsFerret.ClassMethods.records_for_rebuild | train | def records_for_rebuild(batch_size = 1000)
transaction do
if use_fast_batches?
offset = 0
while (rows = where([ "#{table_name}.id > ?", offset ]).limit(batch_size).all).any?
| ruby | {
"resource": ""
} |
q2676 | ActsAsFerret.ClassMethods.records_for_bulk_index | train | def records_for_bulk_index(ids, batch_size = 1000)
transaction do
offset = 0
ids.each_slice(batch_size) do |id_slice|
records = where(:id => id_slice).all
#yield records, offset
| ruby | {
"resource": ""
} |
q2677 | Sorcerer.Subexpression.within_method_sexp | train | def within_method_sexp(sexp)
case sexp.first
when :call # [:call, target, ".", meth]
recur(sexp[1])
when :method_add_block # [:method_add_block, call, block]
within_method_sexp(sexp[1])
| ruby | {
"resource": ""
} |
q2678 | Brice.Colours.enable_irb | train | def enable_irb
IRB::Inspector.class_eval {
unless method_defined?(:inspect_value_with_colour)
alias_method :inspect_value_without_colour, :inspect_value
def inspect_value_with_colour(value)
| ruby | {
"resource": ""
} |
q2679 | Brice.Colours.colourize | train | def colourize(str)
''.tap { |res| Tokenizer.tokenize(str.to_s) { |token, value|
res << colourize_string(value, colours[token])
} }
| ruby | {
"resource": ""
} |
q2680 | GScraper.HasPages.each_page | train | def each_page(indices)
unless block_given?
enum_for(:each_page,indices)
| ruby | {
"resource": ""
} |
q2681 | GScraper.HasPages.each | train | def each
return enum_for(:each) unless block_given?
index = 1
until ((next_page = page_cache[index]).empty?) do
| ruby | {
"resource": ""
} |
q2682 | GScraper.HasPages.page_cache | train | def page_cache
@page_cache ||= Hash.new { |hash,key| | ruby | {
"resource": ""
} |
q2683 | ActsAsFerret.AbstractIndex.change_index_dir | train | def change_index_dir(new_dir)
logger.debug "[#{index_name}] changing index dir to #{new_dir}"
index_definition[:index_dir] = index_definition[:ferret][:path] = new_dir
| ruby | {
"resource": ""
} |
q2684 | XCRes::XCAssets.Bundle.read | train | def read
@resource_paths = Dir.chdir(path) do
Dir['**/Contents.json'].map { |p| Pathname(p) + '..' }
end
@resources = | ruby | {
"resource": ""
} |
q2685 | XCRes.StringsAnalyzer.build_section | train | def build_section
selected_file_refs = selected_strings_file_refs
# Apply ignore list
file_paths = filter_exclusions(selected_file_refs.map(&:path))
filtered_file_refs = selected_file_refs.select { |file_ref| file_paths.include? file_ref.path }
| ruby | {
"resource": ""
} |
q2686 | XCRes.StringsAnalyzer.info_plist_paths | train | def info_plist_paths
@info_plist_paths ||= target.build_configurations.map do |config|
| ruby | {
"resource": ""
} |
q2687 | XCRes.StringsAnalyzer.native_dev_languages | train | def native_dev_languages
@native_dev_languages ||= absolute_info_plist_paths.map do |path|
begin
read_plist_key(path, :CFBundleDevelopmentRegion)
| ruby | {
"resource": ""
} |
q2688 | XCRes.StringsAnalyzer.keys_by_file | train | def keys_by_file(path)
begin
# Load strings file contents
strings = read_strings_file(path)
# Reject generated identifiers used by Interface Builder
strings.reject! { |key, _| /^[a-zA-Z0-9]{3}-[a-zA-Z0-9]{2,3}-[a-zA-Z0-9]{3}/.match(key) }
keys = Hash[strings.map do |key, ... | ruby | {
"resource": ""
} |
q2689 | ActsAsFerret.InstanceMethods.ferret_enabled? | train | def ferret_enabled?(is_bulk_index = false)
@ferret_disabled.nil? && (is_bulk_index | ruby | {
"resource": ""
} |
q2690 | JMX.RubyNotificationEmitter.removeNotificationListener | train | def removeNotificationListener(listener, filter=nil, handback=nil)
found = false
listeners.delete_if do |clistener, (cfilter, chandback)|
| ruby | {
"resource": ""
} |
q2691 | JMX.MBeanProxy.[] | train | def [](name)
attribute = @server.getAttribute(@object_name, name.to_s)
return attribute.value if | ruby | {
"resource": ""
} |
q2692 | JMX.MBeanProxy.[]= | train | def []=(name, value)
@server.setAttribute | ruby | {
"resource": ""
} |
q2693 | JMX.MBeanProxy.invoke | train | def invoke(name, *params)
op = @info.operations.find { |o| o.name == name.to_s }
raise NoMethodError.new("No such | ruby | {
"resource": ""
} |
q2694 | JMX.MBeanProxy.java_types | train | def java_types(params)
return nil if params.nil?
params.map {|e| | ruby | {
"resource": ""
} |
q2695 | Apkstats::Command.Executable.compare_with | train | def compare_with(apk_filepath, other_apk_filepath)
base = Apkstats::Entity::ApkInfo.new(self, apk_filepath)
other = Apkstats::Entity::ApkInfo.new(self, | ruby | {
"resource": ""
} |
q2696 | XCRes.Analyzer.new_section | train | def new_section(name, data, options={})
XCRes::Section.new(name, data, | ruby | {
"resource": ""
} |
q2697 | XCRes.Analyzer.filter_exclusions | train | def filter_exclusions file_paths
file_paths.reject do |path|
exclude_file_patterns.any? | ruby | {
"resource": ""
} |
q2698 | XCRes.Analyzer.find_file_refs_by_extname | train | def find_file_refs_by_extname(extname)
project.files.select do |file_ref|
| ruby | {
"resource": ""
} |
q2699 | XCRes.Analyzer.resources_files | train | def resources_files
target.resources_build_phase.files.map do |build_file|
if build_file.file_ref.is_a?(Xcodeproj::Project::Object::PBXGroup)
| 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.