_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q3600 | RETS4R.Client.get_object | train | def get_object(resource, type, id, location = false) #:yields: data_object
header = {
'Accept' => mimemap.keys.join(',')
}
data = {
'Resource' => resource,
'Type' => type,
'ID' => id,
'Location' => location ? '1' : '0'
}
response = reques... | ruby | {
"resource": ""
} |
q3601 | RETS4R.Client.search | train | def search(search_type, klass, query, options = false)
header = {}
# Required Data
data = {
'SearchType' => search_type,
'Class' => klass,
'Query' => query,
'QueryType' => 'DMQL2',
'Format' => format,
'Count' => '0'
}
# ... | ruby | {
"resource": ""
} |
q3602 | XcodeInstaller.Install.cp_r | train | def cp_r(src, dest, options = {})
# fu_check_options options, OPT_TABLE['cp_r']
# fu_output_message "cp -r#{options[:preserve] ? 'p' : ''}#{options[:remove_destination] ? ' --remove-destination' : ''} #{[src,dest].flatten.join ' '}" | ruby | {
"resource": ""
} |
q3603 | Jobbr.Ohm.models | train | def models(parent = nil)
model_paths = Dir["#{Rails.root}/app/models/*_jobs/*.rb"]
model_paths.each{ |path| require path }
sanitized_model_paths = model_paths.map { |path| path.gsub(/.*\/app\/models\//, '').gsub('.rb', '') }
model_constants = sanitized_model_paths.map | ruby | {
"resource": ""
} |
q3604 | Jobbr.Ohm.superclasses | train | def superclasses(klass)
super_classes = []
while klass != Object
klass = klass.superclass
| ruby | {
"resource": ""
} |
q3605 | WADL.HasDocs.define_singleton | train | def define_singleton(r, sym, method)
name = r.send(sym)
if name && name !~ /\W/ && !r.respond_to?(name) && !respond_to?(name)
| ruby | {
"resource": ""
} |
q3606 | WebkitRemote.Process.start | train | def start
return self if running?
unless @pid = ::Process.spawn(*@cli)
# The launch failed.
stop
return nil
end
(@timeout * 20).times do
# Check if the browser exited.
begin
break if ::Process.wait(@pid, ::Process::WNOHANG)
| ruby | {
"resource": ""
} |
q3607 | WebkitRemote.Process.stop | train | def stop
return self unless running?
if @pid
begin
::Process.kill 'TERM', @pid
::Process.wait @pid
rescue SystemCallError
# Process died on its own.
ensure
@pid = nil
| ruby | {
"resource": ""
} |
q3608 | WADL.ResponseFormat.build | train | def build(http_response)
# Figure out which fault or representation to use.
status = http_response.status[0]
unless response_format = faults.find { |f| f.dereference.status == status }
# Try to match the response to a response format using a media
# type.
response_media_type ... | ruby | {
"resource": ""
} |
q3609 | I3.IPC.handle_response | train | def handle_response(type)
# reads 14 bytes
# length of "i3-ipc" + 4 bytes length + 4 bytes type
buffer = read 14
raise WrongMagicCode unless | ruby | {
"resource": ""
} |
q3610 | WADL.ResourceAndAddress.method_missing | train | def method_missing(name, *args, &block)
if @resource.respond_to?(name)
result = @resource.send(name, *args, &block)
| ruby | {
"resource": ""
} |
q3611 | WADL.ResourceAndAddress.resource | train | def resource(*args, &block)
resource = @resource.resource(*args, &block)
resource && | ruby | {
"resource": ""
} |
q3612 | Jobbr.Whenever.schedule_jobs | train | def schedule_jobs(job_list)
Jobbr::Ohm.models(Jobbr::Scheduled).each do |job|
if job.every
job_list.every job.every[0], job.every[1] do
| ruby | {
"resource": ""
} |
q3613 | Sunrise.ActivitiesHelper.timeago_tag | train | def timeago_tag(time, options = {})
options[:class] ||= "timeago" | ruby | {
"resource": ""
} |
q3614 | Sunrise.ActivitiesHelper.link_to_trackable | train | def link_to_trackable(object, object_type)
model_name = object_type.downcase
if object
link_to(model_name, edit_path(:model_name => model_name.pluralize, :id | ruby | {
"resource": ""
} |
q3615 | WADL.Address.deep_copy | train | def deep_copy
address = Address.new(
_deep_copy_array(@path_fragments),
_deep_copy_array(@query_vars),
_deep_copy_hash(@headers),
@path_params.dup,
@query_params.dup, | ruby | {
"resource": ""
} |
q3616 | WADL.Address.bind! | train | def bind!(args = {})
path_var_values = args[:path] || {}
query_var_values = args[:query] || {}
header_var_values = args[:headers] || {}
@auth.each { |header, value| header_var_values[header] = value }.clear
# Bind variables found in the path fragments.
path_params_to_delete... | ruby | {
"resource": ""
} |
q3617 | Launchpad.Interaction.start | train | def start(opts = nil)
logger.debug "starting Launchpad::Interaction##{object_id}"
opts = {
:detached => false
}.merge(opts || {})
@active = true
@reader_thread ||= Thread.new do
begin
while @active do
@device.read_pending_actions.each do |action|
... | ruby | {
"resource": ""
} |
q3618 | Launchpad.Interaction.stop | train | def stop
logger.debug "stopping Launchpad::Interaction##{object_id}"
@active = false
if @reader_thread
# run (resume from sleep) and wait for @reader_thread to end
@reader_thread.run if @reader_thread.alive?
@reader_thread.join
@reader_thread = nil
end
ensure
... | ruby | {
"resource": ""
} |
q3619 | Launchpad.Interaction.response_to | train | def response_to(types = :all, state = :both, opts = nil, &block)
logger.debug "setting response to #{types.inspect} for state #{state.inspect} with #{opts.inspect}"
types = Array(types)
opts ||= {}
no_response_to(types, state) if opts[:exclusive] == true
Array(state == :both ? %w(down up) ... | ruby | {
"resource": ""
} |
q3620 | Launchpad.Interaction.no_response_to | train | def no_response_to(types = nil, state = :both, opts = nil)
logger.debug "removing response to #{types.inspect} for state #{state.inspect}"
types = Array(types)
| ruby | {
"resource": ""
} |
q3621 | Launchpad.Interaction.grid_range | train | def grid_range(range)
return nil if range.nil?
Array(range).flatten.map do |pos|
| ruby | {
"resource": ""
} |
q3622 | WebkitRemote.Event.matches? | train | def matches?(conditions)
conditions.all? do |key, value|
case key
when :class, :type
kind_of? value
when :name
name == value
else | ruby | {
"resource": ""
} |
q3623 | RailsStuff.Statusable.statusable_methods | train | def statusable_methods
# Include generated methods with a module, not right in class.
@statusable_methods ||= Module.new.tap do |m|
| ruby | {
"resource": ""
} |
q3624 | Sunrise.AbstractModel.build_record | train | def build_record
record = model.new
record.send("#{parent_association.name}=", parent_record) if parent_record
| ruby | {
"resource": ""
} |
q3625 | Sunrise.AbstractModel.apply_scopes | train | def apply_scopes(params = nil, pagination = true)
raise ::AbstractController::ActionNotFound.new("List config is turn off") if without_index?
params ||= @request_params
scope = default_scope(params)
if current_list == :tree
| ruby | {
"resource": ""
} |
q3626 | I3.Manpage.manpage | train | def manpage(name)
return "** Can't find groff(1)" unless groff?
require 'open3'
out = nil
| ruby | {
"resource": ""
} |
q3627 | I3.Manpage.raw_manpage | train | def raw_manpage(name)
if File.exists? file = File.dirname(__FILE__) + "/../../man/#{name}.1"
| ruby | {
"resource": ""
} |
q3628 | RailsStuff.RSpecHelpers.clear_logs | train | def clear_logs
::RSpec.configure do |config|
config.add_setting :clear_log_file
config.clear_log_file = Rails.root.join('log', 'test.log') if defined?(Rails.root)
config.add_setting :clear_log_file_proc
config.clear_log_file_proc = ->(file) do
next unless file && File.exi... | ruby | {
"resource": ""
} |
q3629 | WADL.RequestFormat.uri | train | def uri(resource, args = {})
uri = resource.uri(args)
query_values = args[:query] || {}
header_values = args[:headers] || {}
params.each { |param|
name = param.name
if param.style == 'header'
value = header_values[name] || header_values[name.to_sym]
valu... | ruby | {
"resource": ""
} |
q3630 | Launchpad.Device.change | train | def change(type, opts = nil)
opts ||= {}
status = %w(up down left right session user1 user2 mixer).include?(type.to_s) ? | ruby | {
"resource": ""
} |
q3631 | Launchpad.Device.change_all | train | def change_all(*colors)
# ensure that colors is at least and most 80 elements long
colors = colors.flatten[0..79]
colors += [0] * (80 - colors.size) if colors.size < 80
# send normal MIDI message to reset rapid LED change pointer
# in this case, set mapping mode to x-y layout (the default)... | ruby | {
"resource": ""
} |
q3632 | Launchpad.Device.buffering_mode | train | def buffering_mode(opts = nil)
opts = {
:display_buffer => 0,
:update_buffer => 0,
:copy => false,
:flashing => false | ruby | {
"resource": ""
} |
q3633 | Launchpad.Device.output_messages | train | def output_messages(messages)
if @output.nil?
logger.error "trying to write to device that's not been initialized for output"
raise NoOutputAllowedError
end | ruby | {
"resource": ""
} |
q3634 | Impressbox.Provisioner.provision | train | def provision
mass_loader('provision').each do |configurator|
next unless configurator.can_be_configured?(@machine, @@__loaded_config)
| ruby | {
"resource": ""
} |
q3635 | Impressbox.Provisioner.run_primaty_configuration | train | def run_primaty_configuration(root_config)
old_root = root_config.dup
old_loaded = @@__loaded_config.dup
mass_loader('primary').each do |configurator|
next unless configurator.can_be_configured?(old_root, old_loaded)
| ruby | {
"resource": ""
} |
q3636 | Impressbox.Provisioner.mass_loader | train | def mass_loader(type)
namespace = 'Impressbox::Configurators::' + ucfirst(type)
| ruby | {
"resource": ""
} |
q3637 | Impressbox.Provisioner.xaml_config | train | def xaml_config
require_relative File.join('objects', 'config_file')
file = detect_file(config.file)
@machine.ui.info "\t" + | ruby | {
"resource": ""
} |
q3638 | WebkitRemote.Client.wait_for | train | def wait_for(conditions)
unless WebkitRemote::Event.can_receive? self, conditions
raise ArgumentError, "Cannot receive event with #{conditions.inspect}"
end
events = []
| ruby | {
"resource": ""
} |
q3639 | Passphrase.Language.validate | train | def validate(language_list)
language_list.each do |l|
matches_language = @languages.any? { |language| language.match("^#{l}") }
| ruby | {
"resource": ""
} |
q3640 | YPetri::Agent::SimulationAspect.SimulationPoint.identify | train | def identify( name: nil, net: nil, cc: nil, imc: nil, ssc: nil, | ruby | {
"resource": ""
} |
q3641 | Danger.DangerConflictChecker.check_conflict_and_comment | train | def check_conflict_and_comment()
results = check_conflict()
results.each do |result|
next if result[:mergeable]
message = "<p>This PR conflicts with <a href=\"#{result[:pull_request][:html_url]}\">##{result[:pull_request][:number]}</a>.</p>"
table = '<table><thead><tr><th width="100... | ruby | {
"resource": ""
} |
q3642 | Ankusa.CassandraStorage.init_tables | train | def init_tables
# Do nothing if keyspace already exists
if @cassandra.keyspaces.include?(@keyspace)
@cassandra.keyspace = @keyspace
else
freq_table = Cassandra::ColumnFamily.new({:keyspace => @keyspace, :name => "classes"}) # word => {classname => count}
summary_table = Cas... | ruby | {
"resource": ""
} |
q3643 | Ankusa.CassandraStorage.get_word_counts | train | def get_word_counts(word)
# fetch all (class,count) pairs for a given word
row = @cassandra.get(:classes, word.to_s) | ruby | {
"resource": ""
} |
q3644 | Ankusa.CassandraStorage.incr_total_word_count | train | def incr_total_word_count(klass, count)
klass = klass.to_s
wordcount = @cassandra.get(:totals, klass, "wordcount").values.last.to_i
| ruby | {
"resource": ""
} |
q3645 | Ankusa.CassandraStorage.incr_doc_count | train | def incr_doc_count(klass, count)
klass = klass.to_s
doc_count = @cassandra.get(:totals, klass, "doc_count").values.last.to_i
| ruby | {
"resource": ""
} |
q3646 | Ankusa.CassandraStorage.get_summary | train | def get_summary(name)
counts = {}
@cassandra.get_range(:totals, {:start => '', :finish => '', :count => @max_classes}).each do |key_slice|
# keyslice is a clunky thrift object, map into a ruby hash
| ruby | {
"resource": ""
} |
q3647 | CrossValidation.Runner.valid? | train | def valid?
@errors = []
@critical_keys.each do |k|
any_error = public_send(k).nil?
| ruby | {
"resource": ""
} |
q3648 | CrossValidation.Runner.run | train | def run
fail_if_invalid
partitions = Partitioner.subset(documents, k)
results = partitions.map.with_index do |part, i|
training_samples = Partitioner.exclude_index(documents, i)
classifier_instance = classifier.call()
train(classifier_instance, training_samples)
# ... | ruby | {
"resource": ""
} |
q3649 | Medium.Publications.create_post | train | def create_post(publication, opts)
response = @client.post "publications/#{publication['id']}/posts",
| ruby | {
"resource": ""
} |
q3650 | Okta.Jwt.sign_in_user | train | def sign_in_user(username:, password:, client_id:, client_secret:, scope: 'openid')
client(issuer).post do |req|
req.url "/oauth2/#{auth_server_id}/v1/token"
req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
req.headers['Authorization'] = 'Basic: ' + | ruby | {
"resource": ""
} |
q3651 | Okta.Jwt.sign_in_client | train | def sign_in_client(client_id:, client_secret:, scope:)
client(issuer).post do |req|
req.url "/oauth2/#{auth_server_id}/v1/token"
req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
req.headers['Authorization'] = 'Basic: ' + | ruby | {
"resource": ""
} |
q3652 | Okta.Jwt.verify_token | train | def verify_token(token, issuer:, audience:, client_id:)
header, payload = token.split('.').first(2).map{|encoded| JSON.parse(Base64.decode64(encoded))}
# validate claims
raise InvalidToken.new('Invalid issuer') if payload['iss'] != issuer
| ruby | {
"resource": ""
} |
q3653 | Okta.Jwt.get_jwk | train | def get_jwk(header, payload)
kid = header['kid']
# cache hit
return JWKS_CACHE[kid] if JWKS_CACHE[kid]
# fetch jwk
logger.info("[Okta::Jwt] Fetching public key: kid => #{kid} ...") if logger
jwks_response = client(payload['iss']).get do |req|
req.url get_metadata(payload)... | ruby | {
"resource": ""
} |
q3654 | CrossValidation.ConfusionMatrix.store | train | def store(actual, truth)
key = @keys_for.call(truth, actual)
if @values.key?(key)
@values[key] += 1
else | ruby | {
"resource": ""
} |
q3655 | CrossValidation.ConfusionMatrix.fscore | train | def fscore(beta)
b2 = Float(beta**2)
((b2 + 1) * precision * recall) | ruby | {
"resource": ""
} |
q3656 | EvalHook.HookHandler.packet | train | def packet(code)
@global_variable_name = nil
partialruby_packet = partialruby_context.packet(code)
@all_packets ||= []
newpacket = | ruby | {
"resource": ""
} |
q3657 | Fastr.Application.boot | train | def boot
Thread.new do
sleep 1 until EM.reactor_running?
begin
log.info "Loading application..."
app_init
load_settings
Fastr::Plugin.load(self)
load_app_classes
| ruby | {
"resource": ""
} |
q3658 | Fastr.Application.load_app_classes | train | def load_app_classes
@@load_paths.each do |name, path|
log.debug "Loading #{name} classes..."
Dir["#{self.app_path}/#{path}"].each do |f|
| ruby | {
"resource": ""
} |
q3659 | Fastr.Application.setup_watcher | train | def setup_watcher
this = self
Handler.send(:define_method, :app) do
this
end
| ruby | {
"resource": ""
} |
q3660 | Datomic.Client.transact | train | def transact(dbname, data)
data = transmute_data(data)
RestClient.post(db_url(dbname) + "/", {"tx-data" => data},
| ruby | {
"resource": ""
} |
q3661 | Datomic.Client.query | train | def query(query, args_or_dbname, params = {})
query = transmute_data(query)
args = args_or_dbname.is_a?(String) ? [db_alias(args_or_dbname)] : args_or_dbname
| ruby | {
"resource": ""
} |
q3662 | LatoView.ApplicationHelper.view | train | def view(*names)
# mantain compatibility with old cells (lato_view 1.0)
if names.length === 1
puts "YOU ARE USING AND OLD VERSION OF CELLS. PLEASE CONSIDER TO UPDATE YOUR CODE"
old_cell = "LatoView::CellsV1::#{names.first.capitalize}::Cell".constantize
return old_cell
end
... | ruby | {
"resource": ""
} |
q3663 | LatoView.Interface::Images.view_getSidebarLogo | train | def view_getSidebarLogo
return VIEW_SIDEBARLOGO if defined? VIEW_SIDEBARLOGO
dir = "#{Rails.root}/app/assets/images/lato/"
if File.exist?("#{dir}/sidebar_logo.svg")
return "lato/sidebar_logo.svg"
end
if File.exist?("#{dir}/sidebar_logo.png")
return "lato/sidebar_logo.png"
... | ruby | {
"resource": ""
} |
q3664 | LatoView.Interface::Images.view_getLoginLogo | train | def view_getLoginLogo
return VIEW_LOGINLOGO if defined? VIEW_LOGINLOGO
dir = "#{Rails.root}/app/assets/images/lato/"
if File.exist?("#{dir}/login_logo.svg")
return "lato/login_logo.svg"
end
if File.exist?("#{dir}/login_logo.png")
return "lato/login_logo.png"
end
... | ruby | {
"resource": ""
} |
q3665 | LatoView.Interface::Images.view_getApplicationLogo | train | def view_getApplicationLogo
return VIEW_APPLOGO if defined? VIEW_APPLOGO
dir = "#{Rails.root}/app/assets/images/lato/"
if File.exist?("#{dir}/logo.svg")
return "lato/logo.svg"
end
if File.exist?("#{dir}/logo.png")
return "lato/logo.png"
end
| ruby | {
"resource": ""
} |
q3666 | Fastr.Dispatch.dispatch | train | def dispatch(env)
return [500, {'Content-Type' => 'text/plain'}, ["Server Not Ready"]] if @booting
begin
new_env = plugin_before_dispatch(env)
plugin_after_dispatch(new_env, do_dispatch(new_env))
rescue Exception | ruby | {
"resource": ""
} |
q3667 | Fastr.Dispatch.do_dispatch | train | def do_dispatch(env)
path = env['PATH_INFO']
# Try to serve a public file
ret = dispatch_public(env, path)
return ret if not ret.nil?
log.debug "Checking for | ruby | {
"resource": ""
} |
q3668 | Fastr.Dispatch.setup_controller | train | def setup_controller(controller, env, vars)
controller.env = env
controller.headers = {}
| ruby | {
"resource": ""
} |
q3669 | Fastr.Dispatch.setup_controller_params | train | def setup_controller_params(controller, env, vars)
if Fastr::HTTP.method?(env, :get)
controller.get_params = Fastr::HTTP.parse_query_string(env['QUERY_STRING'])
controller.params = controller.get_params.merge(vars)
elsif Fastr::HTTP.method?(env, :post)
controller.post_params | ruby | {
"resource": ""
} |
q3670 | Fastr.Dispatch.plugin_before_dispatch | train | def plugin_before_dispatch(env)
new_env = env
self.plugins.each do |plugin|
if | ruby | {
"resource": ""
} |
q3671 | Fastr.Dispatch.plugin_after_dispatch | train | def plugin_after_dispatch(env, response)
new_response = response
self.plugins.each do |plugin|
if plugin.respond_to? :after_dispatch
new_response | ruby | {
"resource": ""
} |
q3672 | Filepreviews.CLI.options | train | def options(opts)
opts.version = Filepreviews::VERSION
opts.banner = BANNER
opts.set_program_name 'Filepreviews.io'
opts.on('-k', '--api_key [key]', String,
'use API key from Filepreviews.io') do |api_key|
Filepreviews.api_key = api_key
end
opts.on('-s', '--s... | ruby | {
"resource": ""
} |
q3673 | Filepreviews.CLI.parse | train | def parse
opts = OptionParser.new(&method(:options))
opts.parse!(@args)
return opts.help if @args.last.nil?
| ruby | {
"resource": ""
} |
q3674 | Ownlan.Configuration.source_mac | train | def source_mac
@source_mac ||= if self.victim_ip
::ServiceObjects::NetworkInformation.self_mac(interface)
else
gateway_ip = ServiceObjects::NetworkInformation.gateway_ip | ruby | {
"resource": ""
} |
q3675 | Passphrase.DicewareRandom.die_rolls | train | def die_rolls(number_of_words)
# The Diceware method specifies five rolls of the die for each word.
die_rolls_per_word = 5
total_die_rolls = number_of_words * die_rolls_per_word
| ruby | {
"resource": ""
} |
q3676 | Filepreviews.Utils.process_params | train | def process_params(params)
parameters = { url: CGI.unescape(params.url) }
| ruby | {
"resource": ""
} |
q3677 | Fastr.Router.match | train | def match(env)
self.routes.each do |info|
# If the route didn't specify method(s) to limit by, then all HTTP methods are valid.
# If the route specified method(s), we check the request's HTTP method and validate
# that it exists in that list.
next unless info[:methods].nil... | ruby | {
"resource": ""
} |
q3678 | Fastr.Router.for | train | def for(path, *args)
arg = args[0]
log.debug "Adding route, path: #{path}, args: #{args.inspect}"
match = get_regex_for_route(path, arg)
hash = get_to_hash(arg)
route_info = {:regex => match[:regex], :args => arg, :vars => match[:vars], :hash => hash}
# Add the HTTP methods f... | ruby | {
"resource": ""
} |
q3679 | URI.Redis.conf | train | def conf
hsh = {
:host => host,
:port => port,
:db => db
}.merge parse_query(query)
| ruby | {
"resource": ""
} |
q3680 | LatoView.Interface::Themes.view_getCurrentTemplateName | train | def view_getCurrentTemplateName
return VIEW_CURRENTTEMPLATENAME if defined? VIEW_CURRENTTEMPLATENAME
directory = core_getCacheDirectory
if File.exist? "#{directory}/view.yml"
# accedo al view.yml
config = YAML.load(
File.read(File.expand_path("#{directory}/view.yml", __FILE__... | ruby | {
"resource": ""
} |
q3681 | RapGenius.Artist.songs | train | def songs(options = {page: 1})
songs_url = "/artists/#{@id}/songs/?page=#{options[:page]}"
fetch(songs_url)["response"]["songs"].map do |song|
Song.new(
artist: Artist.new(
name: song["primary_artist"]["name"],
| ruby | {
"resource": ""
} |
q3682 | LatoView.Interface::Assets.view_getApplicationsAssetsItems | train | def view_getApplicationsAssetsItems
return VIEW_APPASSETS if defined? VIEW_APPASSETS
# inizializzo la lista delle voci della navbar
assets = []
directory = core_getCacheDirectory
if File.exist? "#{directory}/view.yml"
# accedo al view.yml
config = YAML.load(
File.... | ruby | {
"resource": ""
} |
q3683 | Filepreviews.HTTP.default_connection | train | def default_connection(url = BASE_URL, debug = false)
Faraday.new(url: url) do |conn|
conn.adapter :typhoeus
conn.headers[:user_agent] = USER_AGENT
conn.headers[:content_type] = 'application/json'
| ruby | {
"resource": ""
} |
q3684 | Filepreviews.HTTP.prepare_request | train | def prepare_request(params)
request = process_params(params)
request.store(:sizes, [extract_size(params.size)]) if params.size
request.store(:format, params.format) if params.format
request.store(:data, params.data) if params.data
| ruby | {
"resource": ""
} |
q3685 | Filepreviews.HTTP.fetch | train | def fetch(params, endpoint_path = 'previews')
options = prepare_request(params)
response = default_connection(BASE_URL, params.debug)
.post do |req|
| ruby | {
"resource": ""
} |
q3686 | SkyJam.Client.loadalltracks | train | def loadalltracks
uri = URI(@service_url + 'loadalltracks')
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
req = Net::HTTP::Post.new(uri.path)
| ruby | {
"resource": ""
} |
q3687 | SkyJam.Client.mac_addr | train | def mac_addr
case RUBY_PLATFORM
when /darwin/
if (m = `ifconfig en0`.match(/ether (\S{17})/))
m[1].upcase
end
when /linux/
| ruby | {
"resource": ""
} |
q3688 | Rediska.Driver.zscan_each | train | def zscan_each(key, *args, &block)
data_type_check(key, ZSet)
return [] unless data[key]
return to_enum(:zscan_each, key, options) | ruby | {
"resource": ""
} |
q3689 | Storexplore.WalkerPage.get_all | train | def get_all(selector, separator)
elements = @mechanize_page.search(selector) | ruby | {
"resource": ""
} |
q3690 | TaskMapper::Provider.Helper.easy_finder | train | def easy_finder(api, symbol, options, at_index = 0)
if api.is_a? Class
return api if options.length == 0 and symbol == :first
options.insert(at_index, symbol) if options[at_index].is_a?(Hash)
api.find(*options)
| ruby | {
"resource": ""
} |
q3691 | TaskMapper::Provider.Helper.search_by_attribute | train | def search_by_attribute(things, options = {}, limit = 1000)
things.find_all do |thing|
options.inject(true) do |memo, kv|
break unless memo
key, value = kv
begin
| ruby | {
"resource": ""
} |
q3692 | Daemonizer::Stats.MemoryStats.determine_private_dirty_rss | train | def determine_private_dirty_rss(pid)
total = 0
File.read("/proc/#{pid}/smaps").split("\n").each do |line|
line =~ /^(Private)_Dirty: +(\d+)/
if $2
total += $2.to_i
end
end
if total == 0 | ruby | {
"resource": ""
} |
q3693 | Ankusa.Classifier.train | train | def train(klass, text)
th = TextHash.new(text)
th.each { |word, count|
@storage.incr_word_count klass, word, count
yield word, count if block_given?
}
@storage.incr_total_word_count klass, th.word_count | ruby | {
"resource": ""
} |
q3694 | Trakt.Show.unseen | train | def unseen(title)
all = seasons title
episodes_per_season = {}
episodes_to_remove = []
all.each do |season_info|
season_num = season_info['season']
next if season_num == 0 # dont need to remove specials
episodes = season_info['episodes']
1.upto(episodes) do |ep... | ruby | {
"resource": ""
} |
q3695 | Colorist.Color.+ | train | def +(other_color)
other_color = Colorist::Color.from(other_color)
color = self.dup
color.r += other_color.r
color.g | ruby | {
"resource": ""
} |
q3696 | Colorist.Color.to_hsv | train | def to_hsv
red, green, blue = *[r, g, b].collect {|x| x / 255.0}
max = [red, green, blue].max
min = [red, green, blue].min
if min == max
hue = 0
elsif max == red
hue = 60 * ((green - blue) / (max - min))
elsif max == green
hue = 60 * ((blue | ruby | {
"resource": ""
} |
q3697 | Colorist.Color.gradient_to | train | def gradient_to(color, steps = 10)
color_to = Colorist::Color.from(color)
red = color_to.r - r
green = color_to.g - g
blue = color_to.b - b
result = (1..(steps - 3)).to_a.collect do |step|
percentage = step.to_f / (steps - 1)
Color.from_rgb(r + (red * percentag... | ruby | {
"resource": ""
} |
q3698 | Gematria.TableManager.add_table | train | def add_table(name, table)
if table.is_a? Hash
tables[name.to_sym] = table
else
raise | ruby | {
"resource": ""
} |
q3699 | Debugger.FrameFunctions.get_pr_arguments_with_xml | train | def get_pr_arguments_with_xml(mark, *args)
res = get_pr_arguments_without_xml((!!mark).to_s, | 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.