_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q6500 | KeytechKit.ElementFileHandler.load | train | def load(element_key)
parameter = { basic_auth: @auth }
response = self.class.get("/elements/#{element_key}/files", | ruby | {
"resource": ""
} |
q6501 | KeytechKit.ElementFileHandler.load_masterfile | train | def load_masterfile(element_key)
parameter = { basic_auth: @auth }
response | ruby | {
"resource": ""
} |
q6502 | KeytechKit.ElementFileHandler.upload_masterfile | train | def upload_masterfile(element_key, file, original_filename)
# file, elementkey , name??
content_length = file.size
content_type = 'application/octet-stream; charset=utf-8'
parameter = { basic_auth: @auth,
headers: { 'Content-Type' => content_type,
... | ruby | {
"resource": ""
} |
q6503 | Shells.ShellBase.change_quit | train | def change_quit(quit_command)
raise Shells::NotRunning unless running?
self.options = | ruby | {
"resource": ""
} |
q6504 | Taaze.TaazeComments.url_get_html | train | def url_get_html(url_str)
url = URI.parse(URI.encode(url_str)) # first get total size
| ruby | {
"resource": ""
} |
q6505 | Taaze.TaazeComments.extract_comments | train | def extract_comments(content, user_id)
# Json format~
# "content":"勇氣就是熱誠，來自於我們對自己工作的自信心；.....",
# "title":"",
# "status":"C",
# "stars":"5",
# "prodId":"11100597685",
# "titleMain":"行銷之神原一平全集(精裝版)",
# "orgProdId":"11100597685",
# "pkNo":"1000243977",
# "mdf_t... | ruby | {
"resource": ""
} |
q6506 | Model.ClassMethods.find! | train | def find!( *args )
raise_not_found_error_was = Mongoid.raise_not_found_error
begin
Mongoid.raise_not_found_error = true
self.find( *args )
| ruby | {
"resource": ""
} |
q6507 | ThinkFeelDoDashboard.ApplicationHelper.breadcrumbs | train | def breadcrumbs
return unless show_breadcrumbs?
content_for(
:breadcrumbs,
content_tag(:ol, class: "breadcrumb") do
concat(content_tag(:li, link_to("Home", root_path)))
if can_view_resource_index?
concat(
| ruby | {
"resource": ""
} |
q6508 | Sndacs.Bucket.put_bucket_policy | train | def put_bucket_policy(bucket_policy)
if bucket_policy && bucket_policy.is_a?(String) && bucket_policy.strip != | ruby | {
"resource": ""
} |
q6509 | Bebox.ProfileWizard.create_new_profile | train | def create_new_profile(project_root, profile_name, profile_base_path)
# Clean the profile_path to make it a valid path
profile_base_path = Bebox::Profile.cleanpath(profile_base_path)
# Check if the profile name is valid
return unless name_valid?(profile_name, profile_base_path)
# Check if ... | ruby | {
"resource": ""
} |
q6510 | Bebox.ProfileWizard.name_valid? | train | def name_valid?(profile_name, profile_base_path)
unless valid_puppet_class_name?(profile_name)
error _('wizard.profile.invalid_name')%{words: Bebox::RESERVED_WORDS.join(', ')}
return false
end
return true if profile_base_path.empty?
# Check if the path name is valid
| ruby | {
"resource": ""
} |
q6511 | Bebox.ProfileWizard.remove_profile | train | def remove_profile(project_root)
# Choose a profile from the availables
profiles = Bebox::Profile.list(project_root)
# Get a profile if exist
if profiles.count > 0
profile = choose_option(profiles, _('wizard.choose_remove_profile'))
else
return error _('wizard.profile.no_de... | ruby | {
"resource": ""
} |
q6512 | Remi.DataSubject.field_symbolizer | train | def field_symbolizer(arg = nil)
return @field_symbolizer unless arg
@field_symbolizer = if arg.is_a? Symbol
Remi::FieldSymbolizers[arg]
| ruby | {
"resource": ""
} |
q6513 | Remi.DataSubject.df= | train | def df=(new_dataframe)
dsl_eval
if new_dataframe.respond_to? :df_type
@dataframe = new_dataframe
else
| ruby | {
"resource": ""
} |
q6514 | Jinx.MultiEnumerator.method_missing | train | def method_missing(symbol, *args)
self.class.new(@components.map | ruby | {
"resource": ""
} |
q6515 | Gogetit.GogetLXD.generate_user_data | train | def generate_user_data(lxd_params, options)
logger.info("Calling <#{__method__.to_s}>")
lxd_params[:config] = {}
if options[:'no-maas']
lxd_params[:config][:"user.user-data"] = {}
else
sshkeys = maas.get_sshkeys
pkg_repos = maas.get_package_repos
lxd_params[:co... | ruby | {
"resource": ""
} |
q6516 | Pyrite.Dsl.fill_in | train | def fill_in(element, value)
if element.match /date/ # Try to guess at date selects
select_date(element, value)
else | ruby | {
"resource": ""
} |
q6517 | Pyrite.Dsl.select_date | train | def select_date(element, value)
suffixes = {
:year => '1i',
:month => '2i',
:day => '3i',
:hour => '4i',
:minute => '5i'
}
date = value.respond_to?(:year) ? value : Date.parse(value)
browser.select "jquery=#{element}_#{suffixes[:year]}", date.year
... | ruby | {
"resource": ""
} |
q6518 | Pyrite.Dsl.wait_for | train | def wait_for(element)
case element
when :page_load
browser.wait_for(:wait_for => :page)
when :ajax
| ruby | {
"resource": ""
} |
q6519 | Maguro.Features.create_database_files | train | def create_database_files
username = builder.options['database-username']
password = builder.options['database-password']
builder.remove_file "config/database.yml"
| ruby | {
"resource": ""
} |
q6520 | Kamaze::Project::Concern::Observable.ClassMethods.add_observer | train | def add_observer(observer_class, func = :handle_event)
func = func.to_sym
unless observer_class.instance_methods.include?(func)
m = "#<#{observer_class}> does not respond to `#{func}'"
| ruby | {
"resource": ""
} |
q6521 | MuckEngine.SslRequirement.ssl_required? | train | def ssl_required?
return ENV['SSL'] == 'on' ? true : false if defined? ENV['SSL']
return false if local_request?
return false if RAILS_ENV == 'test'
| ruby | {
"resource": ""
} |
q6522 | RootedTree.Node.ancestors | train | def ancestors
return to_enum(__callee__) unless block_given?
node = self
loop do
| ruby | {
"resource": ""
} |
q6523 | RootedTree.Node.child | train | def child(index = nil)
unless index
raise ArgumentError, 'No index for node with degree != 1' if degree != 1
return first
| ruby | {
"resource": ""
} |
q6524 | RootedTree.Node.edges | train | def edges(&block)
return to_enum(__callee__) unless block_given?
children do |v|
| ruby | {
"resource": ""
} |
q6525 | RootedTree.Node.+ | train | def +(other)
unless root? && other.root?
raise StructureException, 'Only roots can be added'
| ruby | {
"resource": ""
} |
q6526 | SwaggerDocsGenerator.Methods.swagger_doc | train | def swagger_doc(action, &block)
parse = | ruby | {
"resource": ""
} |
q6527 | SwaggerDocsGenerator.Methods.swagger_definition | train | def swagger_definition(name, &block)
parse = | ruby | {
"resource": ""
} |
q6528 | Whenner.Conversions.Promise | train | def Promise(obj)
return obj.to_promise if obj.respond_to?(:to_promise)
| ruby | {
"resource": ""
} |
q6529 | RogerEslint.Lint.normalize_path | train | def normalize_path(test, path)
Pathname.ne | ruby | {
"resource": ""
} |
q6530 | MMETools.ArgsProc.assert_valid_keys | train | def assert_valid_keys(options, valid_options)
unknown_keys = options.keys - valid_options.keys
raise(ArgumentError, "Unknown options(s): | ruby | {
"resource": ""
} |
q6531 | CLIntegracon.Formatter.describe_file_diff | train | def describe_file_diff(diff, max_width=80)
description = []
description << "File comparison error `#{diff.relative_path}` for #{spec.spec_folder}:"
description << "--- DIFF ".ljust(max_width, '-')
description += diff.map do |line|
case line
when /^\+/ then line.green
... | ruby | {
"resource": ""
} |
q6532 | Gitkite.GitkitController.sign_in_success | train | def sign_in_success
g_user = signed_in?
if g_user
user = {
:email => g_user.email,
:user_id => g_user.user_id,
:name => g_user.name,
:photo_url => g_user.photo_url,
:provider_id => g_user.provider_id
}
@user = User.find_by(user_id: ... | ruby | {
"resource": ""
} |
q6533 | Bebox.FilesHelper.render_erb_template | train | def render_erb_template(template_path, options)
require | ruby | {
"resource": ""
} |
q6534 | Bebox.FilesHelper.write_content_to_file | train | def write_content_to_file(file_path, content)
File.open(file_path, 'w') do |f|
| ruby | {
"resource": ""
} |
q6535 | TriglavClient.ResourcesApi.create_resource | train | def create_resource(resource, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q6536 | TriglavClient.ResourcesApi.get_resource | train | def get_resource(id_or_uri, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q6537 | TriglavClient.ResourcesApi.list_aggregated_resources | train | def list_aggregated_resources(uri_prefix, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q6538 | TriglavClient.ResourcesApi.update_resource | train | def update_resource(id_or_uri, resource, opts = {})
data, _status_code, _headers = | ruby | {
"resource": ""
} |
q6539 | Coinstack.UserPair.add_list_data | train | def add_list_data(data)
raise symbol.to_s if data.nil?
self.exchange_rate = data['price_usd'].to_f | ruby | {
"resource": ""
} |
q6540 | Poster.Forum.new_topic | train | def new_topic board: 92, subj: 'test', msg: 'msg', icon: "exclamation"
board = board.instance_of?(Symbol) ? @opts[:boards][board] : board
# Check board posting page first (to get sequence numbers)
get "/index.php?action=post;board=#{board}.0"
raise "Not logged, cannot post!" unless logged?
... | ruby | {
"resource": ""
} |
q6541 | Tangle.BaseGraphPrivate.each_vertex_breadth_first | train | def each_vertex_breadth_first(start_vertex, walk_method)
remaining = [start_vertex]
remaining.each_with_object([]) do |vertex, history|
| ruby | {
"resource": ""
} |
q6542 | RequiresApproval.ClassMethods.create_versions_class | train | def create_versions_class
versions_table_name = self.versions_table_name
self.const_set self.versions_class_name, Class.new(ActiveRecord::Base)
self.versions_class.class_eval do
self.table_name = versions_table_name
# Whitelist public attributes
# Everything since this class... | ruby | {
"resource": ""
} |
q6543 | Aims.Geometry.make_bonds | train | def make_bonds(bond_length = 3.0)
# initialize an empty array
@bonds = Array.new
# Make bonds between all atoms
# stack = atoms.dup
atoms_extended = atoms.dup
if periodic?
v1 = lattice_vectors[0]
v2 = lattice_vectors[1]
atoms.each{|a|
[-1, 0, 1].each{|n1|
... | ruby | {
"resource": ""
} |
q6544 | Aims.Geometry.recache_visible_atoms | train | def recache_visible_atoms(makeBonds = false)
plane_count = (@clip_planes ? @clip_planes.length : 0)
return if plane_count == 0
if @visibleAtoms
@visibleAtoms.clear
else
@visibleAtoms = []
end
@atoms.each{|a|
i = plane_count
@clip_planes.each{|p|
... | ruby | {
"resource": ""
} |
q6545 | Aims.Geometry.center | train | def center(visible_only = true)
if atoms.empty?
return Atom.new(0,0,0)
else
bounds = bounding_box(visible_only)
x = (bounds[0].x + bounds[1].x)/2.0
| ruby | {
"resource": ""
} |
q6546 | Aims.Geometry.displace | train | def displace(x,y,z)
Geometry.new(atoms(:all).collect{|a|
| ruby | {
"resource": ""
} |
q6547 | Aims.Geometry.repeat | train | def repeat(nx=1, ny=1, nz=1)
raise "Not a periodic system." if self.lattice_vectors.nil?
u = self.copy
v1 = self.lattice_vectors[0]
v2 = self.lattice_vectors[1]
v3 = self.lattice_vectors[2]
nx_sign = (0 < nx) ? 1 : -1
ny_sign = (0 < ny) ? 1 : -1
nz_sign = (... | ruby | {
"resource": ""
} |
q6548 | Aims.Geometry.format_geometry_in | train | def format_geometry_in
output = ""
if self.lattice_vectors
output << self.lattice_vectors.collect{|v| "lattice_vector #{v[0]} #{v[1]} #{v[2]}"}.join("\n")
output << "\n"
| ruby | {
"resource": ""
} |
q6549 | Aims.Geometry.format_xyz | train | def format_xyz(title = "Aims Geoemtry")
output = self.atoms.size.to_s + "\n"
output << "#{title} \n"
self.atoms.each{ |a|
| ruby | {
"resource": ""
} |
q6550 | Aims.Geometry.delta | train | def delta(aCell)
raise "Cells do not have the same number of atoms" unless self.atoms.size == aCell.atoms.size
pseudo_atoms = []
self.atoms.size.times {|i|
a1 = self.atoms[i]
a2 = aCell.atoms[i]
raise "Species do not match" unless a1.species == a2.species
| ruby | {
"resource": ""
} |
q6551 | Dynabix.Metadata.has_metadata | train | def has_metadata(serializer=:metadata, *attributes)
serialize(serializer, HashWithIndifferentAccess)
if RUBY_VERSION < '1.9'
raise "has_metadata serializer must be named ':metadata', this restriction is lifted in Ruby 1.9+" unless serializer == :metadata
else
# we can safely define ad... | ruby | {
"resource": ""
} |
q6552 | Shells.ShellBase.queue_input | train | def queue_input(data) #:doc:
sync do
if options[:unbuffered_input]
data = data.chars
input_fifo.push | ruby | {
"resource": ""
} |
q6553 | CLIntegracon::Adapter::Bacon.Context.subject | train | def subject &block
@subject ||= CLIntegracon::shared_config.subject.dup
return @subject if | ruby | {
"resource": ""
} |
q6554 | CLIntegracon::Adapter::Bacon.Context.file_tree_spec_context | train | def file_tree_spec_context &block
@file_tree_spec_context ||= CLIntegracon.shared_config.file_tree_spec_context.dup
return @file_tree_spec_context if | ruby | {
"resource": ""
} |
q6555 | Garcon.ReadWriteLock.acquire_read_lock | train | def acquire_read_lock
while(true)
c = @counter.value
raise ResourceLimitError, 'Too many reader threads' if max_readers?(c)
if waiting_writer?(c)
@reader_mutex.synchronize do
@reader_q.wait(@reader_mutex) if waiting_writer?
end
while(true)
... | ruby | {
"resource": ""
} |
q6556 | Garcon.ReadWriteLock.release_read_lock | train | def release_read_lock
while(true)
c = @counter.value
if @counter.compare_and_swap(c,c-1)
if waiting_writer?(c) && running_readers(c) == 1
| ruby | {
"resource": ""
} |
q6557 | Garcon.ReadWriteLock.acquire_write_lock | train | def acquire_write_lock
while(true)
c = @counter.value
raise ResourceLimitError, 'Too many writer threads' if max_writers?(c)
if c == 0
break if @counter.compare_and_swap(0,RUNNING_WRITER)
elsif @counter.compare_and_swap(c,c+WAITING_WRITER)
while(true)
... | ruby | {
"resource": ""
} |
q6558 | Garcon.ReadWriteLock.release_write_lock | train | def release_write_lock
while(true)
c = @counter.value
if @counter.compare_and_swap(c,c-RUNNING_WRITER)
@reader_mutex.synchronize { @reader_q.broadcast }
if waiting_writers(c) > 0
| ruby | {
"resource": ""
} |
q6559 | CommandModel.Model.parameters | train | def parameters
self.class.parameters.each_with_object({}) do |parameter, hash|
| ruby | {
"resource": ""
} |
q6560 | ModelsAuditor.Controller.user_for_models_auditor | train | def user_for_models_auditor
user =
case
when defined?(current_user)
current_user
when defined?(current_employee)
current_employee
else
| ruby | {
"resource": ""
} |
q6561 | ModelsAuditor.Controller.info_for_models_auditor | train | def info_for_models_auditor
{
ip: request.remote_ip,
user_agent: request.user_agent,
controller: self.class.name,
| ruby | {
"resource": ""
} |
q6562 | AuthRocket.Credential.verify | train | def verify(code, attribs={})
params = parse_request_params(attribs.merge(code: code), json_root: json_root).merge credentials: api_creds
parsed, | ruby | {
"resource": ""
} |
q6563 | Bullring.RhinoServer.fetch_library | train | def fetch_library(name)
library_script = @server_registry['library', name]
logger.debug {"#{logname}: Tried to fetch script '#{name}' from the registry and it " +
"was #{'not ' if library_script.nil?}found."}
| ruby | {
"resource": ""
} |
q6564 | RailsExtension::ActionControllerExtension::AccessibleViaUser.ClassMethods.assert_access_without_login | train | def assert_access_without_login(*actions)
user_options = actions.extract_options!
options = {}
if ( self.constants.include?('ASSERT_ACCESS_OPTIONS') )
options.merge!(self::ASSERT_ACCESS_OPTIONS)
end
options.merge!(user_options)
actions += options[:actions]||[]
m_key = options[:model].try(:und... | ruby | {
"resource": ""
} |
q6565 | Jinx.Collection.to_json | train | def to_json(state=nil)
# Make a new State from the options if this is a top-level call.
state | ruby | {
"resource": ""
} |
q6566 | Myreplicator.Export.export | train | def export
Log.run(:job_type => "export", :name => schedule_name,
:file => filename, :export_id => id) do |log|
exporter = MysqlExporter.new
| ruby | {
"resource": ""
} |
q6567 | Myreplicator.Export.is_running? | train | def is_running?
return false if state != "exporting"
begin
Process.getpgid(exporter_pid)
raise | ruby | {
"resource": ""
} |
q6568 | Furnish.SSH.run | train | def run(cmd)
ret = {
:exit_status => 0,
:stdout => "",
:stderr => ""
}
port = ssh_args[:port]
Net::SSH.start(host, username, ssh_args) do |ssh|
ssh.open_channel do |ch|
if stdin
ch.send_data(stdin)
ch.eof!
en... | ruby | {
"resource": ""
} |
q6569 | TrackableTasks.TaskRun.run_time_or_time_elapsed | train | def run_time_or_time_elapsed
if self.end_time
return Time.at(self.end_time - self.start_time)
else
| ruby | {
"resource": ""
} |
q6570 | BarkestCore.DatabaseConfig.extra_label | train | def extra_label(index)
return nil if index < 1 || index > 5
txt = send("extra_#{index}_label")
txt = | ruby | {
"resource": ""
} |
q6571 | BarkestCore.DatabaseConfig.extra_field_type | train | def extra_field_type(index)
t = extra_type(index).to_s
case t
when 'password'
'password'
when 'integer', 'float'
'number'
when 'boolean'
'checkbox'
| ruby | {
"resource": ""
} |
q6572 | BarkestCore.DatabaseConfig.extra_value | train | def extra_value(index, convert = false)
return nil if index < 1 || index > 5
val = send "extra_#{index}_value"
if convert
case extra_type(index)
when 'boolean'
| ruby | {
"resource": ""
} |
q6573 | MailRelay.Base.resend_to | train | def resend_to(destinations)
if destinations.size > 0
message.smtp_envelope_to = destinations
# Set envelope from and sender to local server to satisfy SPF:
# http://www.openspf.org/Best_Practices/Webgenerated
| ruby | {
"resource": ""
} |
q6574 | MailRelay.Base.receiver_from_received_header | train | def receiver_from_received_header
if received = message.received
received = received.first if received.respond_to?(:first)
| ruby | {
"resource": ""
} |
q6575 | HttpMonkey.Client::Environment.uri= | train | def uri=(uri)
self['SERVER_NAME'] = uri.host
self['SERVER_PORT'] = uri.port.to_s
self['QUERY_STRING'] = (uri.query || "")
self['PATH_INFO'] = (!uri.path || uri.path.empty?) ? "/" : uri.path
self['rack.url_scheme'] = uri.scheme
| ruby | {
"resource": ""
} |
q6576 | HttpMonkey.Client::Environment.uri | train | def uri
uri = %Q{#{self['rack.url_scheme']}://#{self['SERVER_NAME']}:#{self['SERVER_PORT']}#{self['REQUEST_URI']}}
begin
URI.parse(uri)
| ruby | {
"resource": ""
} |
q6577 | Roroacms.Admin::MenusController.edit | train | def edit
@menu = Menu.find(params[:id])
# add breadcrumb and set title
add_breadcrumb I18n.t("controllers.admin.menus.edit.breadcrumb", | ruby | {
"resource": ""
} |
q6578 | Roroacms.Admin::MenusController.destroy | train | def destroy
@menu = Menu.find(params[:id])
@menu.destroy
respond_to do |format|
format.html | ruby | {
"resource": ""
} |
q6579 | Chap.Hook.symlink_configs | train | def symlink_configs
paths = Dir.glob("#{shared_path}/config/**/*").
select {|p| File.file?(p) }
paths.each do |src|
relative_path = src.gsub(%r{.*config/},'config/')
dest = "#{release_path}/#{relative_path}"
# make sure the directory exist for symlink creation
... | ruby | {
"resource": ""
} |
q6580 | MotionMastr.MastrBuilder.apply_attributes | train | def apply_attributes(attributed_string, start, length, styles)
return unless attributed_string && start && length && styles # sanity
return unless start >= 0 && length > 0 && styles.length > 0 # minimums
return unless start + length <= attributed_string.length # maximums
range = [start, le... | ruby | {
"resource": ""
} |
q6581 | TransactionReliability.Helpers.with_transaction_retry | train | def with_transaction_retry(options = {})
retry_count = options.fetch(:retry_count, 4)
backoff = options.fetch(:backoff, 0.25)
exit_on_fail = options.fetch(:exit_on_fail, false)
exit_on_disconnect = options.fetch(:exit_on_disconnect, true)... | ruby | {
"resource": ""
} |
q6582 | TransactionReliability.Helpers.transaction_with_retry | train | def transaction_with_retry(txn_options = {}, retry_options = {})
base_obj = self.respond_to?(:transaction) ? self : ActiveRecord::Base
with_transaction_retry(retry_options) do
| ruby | {
"resource": ""
} |
q6583 | GoogleAnymote.TV.connect_to_unit | train | def connect_to_unit
puts "Connecting to '#{@host}..."
begin
tcp_client = TCPSocket.new @host, @port
@ssl_client = OpenSSL::SSL::SSLSocket.new tcp_client, @context
@ssl_client.connect
| ruby | {
"resource": ""
} |
q6584 | GoogleAnymote.TV.fling_uri | train | def fling_uri(uri)
send_request RequestMessage.new(f | ruby | {
"resource": ""
} |
q6585 | GoogleAnymote.TV.send_keycode | train | def send_keycode(keycode)
send_request RequestMessage.new(key_event_message: KeyEvent.new(keycode: keycode, action: Action::DOWN))
| ruby | {
"resource": ""
} |
q6586 | GoogleAnymote.TV.send_data | train | def send_data(msg)
send_request RequestMessage.new(data_message: | ruby | {
"resource": ""
} |
q6587 | GoogleAnymote.TV.move_mouse | train | def move_mouse(x_delta, y_delta)
send_request RequestMessage.new(mouse_event_message: | ruby | {
"resource": ""
} |
q6588 | GoogleAnymote.TV.scroll_mouse | train | def scroll_mouse(x_amount, y_amount)
send_request RequestMessage.new(mouse_wheel_message: | ruby | {
"resource": ""
} |
q6589 | GoogleAnymote.TV.send_request | train | def send_request(request)
message = RemoteMessage.new(request_message: request).serialize_to_string | ruby | {
"resource": ""
} |
q6590 | GoogleAnymote.TV.send_message | train | def send_message(msg)
# Build the message and get it's size
message = msg.serialize_to_string
message_size = [message.length].pack('N')
# Try to send the message
try_again = true
begin
data = ""
@ssl_client.write(message_size + message)
| ruby | {
"resource": ""
} |
q6591 | CabooseStore.CabooseStoreHelper.init_routes | train | def init_routes
puts "Adding the caboose store routes..."
filename = File.join(@app_path,'config','routes.rb')
return if !File.exists?(filename)
return if !@force
str = ""
str << "\t# Catch everything with caboose\n"
str << "\tmount CabooseStore::Engine => '/'\n"
... | ruby | {
"resource": ""
} |
q6592 | Cashboard.BadRequest.errors | train | def errors
parsed_errors = XmlSimple.xml_in(response.response.body)
error_hash = {}
parsed_errors['error'].each do |e|
| ruby | {
"resource": ""
} |
q6593 | Tickspot.Client.clients | train | def clients(options = {})
post("/clients", | ruby | {
"resource": ""
} |
q6594 | Tickspot.Client.projects | train | def projects(options = {})
post("/projects", | ruby | {
"resource": ""
} |
q6595 | Tickspot.Client.tasks | train | def tasks(options = {})
post("/tasks", | ruby | {
"resource": ""
} |
q6596 | Tickspot.Client.entries | train | def entries(options = {})
post("/entries", | ruby | {
"resource": ""
} |
q6597 | Tickspot.Client.users | train | def users(options = {})
post("/users", | ruby | {
"resource": ""
} |
q6598 | BasicCache.TimeCache.cache | train | def cache(key = nil)
key ||= BasicCache.caller_name
key = key.to_sym
if include? key
| ruby | {
"resource": ""
} |
q6599 | BasicCache.TimeCache.include? | train | def include?(key = nil)
key ||= BasicCache.caller_name
key = key.to_sym
| 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.