_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 30 4.3k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q9400 | Activr.Registry.classes_from_path | train | def classes_from_path(dir_path)
Dir["#{dir_path}/*.rb"].sort.inject({ }) do |memo, file_path|
klass = File.basename(file_path, '.rb').camelize.constantize
if !memo[klass.kind].nil?
| ruby | {
"resource": ""
} |
q9401 | SycLink.InternetExplorer.read | train | def read
files = Dir.glob(File.join(path, "**/*"))
regex = Regexp.new("(?<=#{path}).*")
files.map do |file|
unless ((File.directory? file) || (File.extname(file).upcase != ".URL"))
url = File.read(file).scan(/(?<=\nURL=)(.*)$/).flatten.first.chomp
name = url_name(Fi... | ruby | {
"resource": ""
} |
q9402 | GMath3D.::Matrix.multi_new | train | def multi_new(rhs)
if(rhs.kind_of?(Vector3))
ans = self.multi_inner(rhs.to_column_vector) | ruby | {
"resource": ""
} |
q9403 | LatoBlog.Tag.check_meta_permalink | train | def check_meta_permalink
candidate = (self.meta_permalink ? self.meta_permalink : self.title.parameterize)
accepted = nil
counter = 0
while accepted.nil?
if LatoBlog::Tag.find_by(meta_permalink: candidate)
counter += 1
candidate = | ruby | {
"resource": ""
} |
q9404 | LatoBlog.Tag.check_lato_blog_tag_parent | train | def check_lato_blog_tag_parent
tag_parent = LatoBlog::TagParent.find_by(id: lato_blog_tag_parent_id)
if !tag_parent
errors.add('Tag parent', 'not exist for the tag')
throw :abort
return
end
same_language_tag = tag_parent.tags.find_by(meta_language: meta_language)
i... | ruby | {
"resource": ""
} |
q9405 | Tinycert.Request.prepare_params | train | def prepare_params p
results = {}
# Build a new hash with string keys
p.each { |k, v| results[k.to_s] = v }
| ruby | {
"resource": ""
} |
q9406 | ProgneTapera::EnumList.ClassMethods.enum_constants | train | def enum_constants
constants.select { |constant|
| ruby | {
"resource": ""
} |
q9407 | ChronuscopClient.Configuration.load_yaml_configuration | train | def load_yaml_configuration
yaml_config = YAML.load_file("#{@rails_root_dir}/config/chronuscop.yml")
@redis_db_number = yaml_config[@rails_environment]['redis_db_number']
@redis_server_port = yaml_config[@rails_environment]['redis_server_port']
@project_number = yaml_config[@rails_environment]['... | ruby | {
"resource": ""
} |
q9408 | Ponder.User.whois | train | def whois
connected do
fiber = Fiber.current
callbacks = {}
# User is online.
callbacks[311] = @thaum.on(311) do |event_data|
nick = event_data[:params].split(' ')[1]
if nick.downcase == @nick.downcase
@online = true
# TODO: Add properti... | ruby | {
"resource": ""
} |
q9409 | Lazymodel.Base.attributes | train | def attributes
_attributes.inject(HashWithIndifferentAccess.new) do |hash, attribute|
| ruby | {
"resource": ""
} |
q9410 | Joinable.PermissionsAttributeWrapper.permission_attributes= | train | def permission_attributes=(permissions)
self.permissions = [] # Reset permissions in anticipation for re-population
permissions.each do |key, value|
key, value = key.dup, value.dup
# Component Permissions
if key.ends_with? "_permissions"
| ruby | {
"resource": ""
} |
q9411 | Joinable.PermissionsAttributeWrapper.has_permission? | train | def has_permission?(*levels)
if levels.all? { |level| permissions.include? level.to_sym }
| ruby | {
"resource": ""
} |
q9412 | Joinable.PermissionsAttributeWrapper.method_missing | train | def method_missing(method_name, *args, &block)
# NOTE: As of Rails 4, respond_to? must be checked inside the case statement otherwise it breaks regular AR attribute accessors
case method_name.to_s
when /.+_permissions/
return component_permissions_reader(method_name) | ruby | {
"resource": ""
} |
q9413 | Joinable.PermissionsAttributeWrapper.verify_and_sort_permissions | train | def verify_and_sort_permissions
# DefaultPermissionSet is allowed to have blank permissions (private joinable), the other models need at least find and view
self.permissions += [:find, :view] unless is_a?(DefaultPermissionSet)
raise "Invalid permissions: #{(permissions - allowed_permissions).insp... | ruby | {
"resource": ""
} |
q9414 | RSpec.Approvals.verify | train | def verify( options={}, &block )
approval = Git::Approvals::Approval.new( approval_path, options )
approval.diff( block.call ) do |err|
::RSpec::Expectations.fail_with err
| ruby | {
"resource": ""
} |
q9415 | RSpec.Approvals.approval_filename | train | def approval_filename
parts = [ example, *example.example_group.parent_groups ].map do |ex|
| ruby | {
"resource": ""
} |
q9416 | Octo.Trends.aggregate_and_create | train | def aggregate_and_create(oftype, ts = Time.now.floor)
Octo::Enterprise.each do |enterprise|
| ruby | {
"resource": ""
} |
q9417 | Octo.Trends.aggregate! | train | def aggregate!(ts = Time.now.floor)
| ruby | {
"resource": ""
} |
q9418 | Octo.Trends.calculate | train | def calculate(enterprise_id, trend_type, ts = Time.now.floor)
args = {
enterprise_id: enterprise_id,
ts: ts,
type: trend_type
}
klass = @trend_for.constantize
hitsResult = klass.public_send(:where, args)
trends = hitsResult.map { |h| counter2trend(h... | ruby | {
"resource": ""
} |
q9419 | Octo.Trends.get_trending | train | def get_trending(enterprise_id, type, opts={})
ts = opts.fetch(:ts, Time.now.floor)
args = {
enterprise_id: enterprise_id,
ts: opts.fetch(:ts, Time.now.floor),
type: type
}
res = where(args).limit(opts.fetch(:limit, DEFAULT_COUNT))
enterprise = Octo::Enterprise.find... | ruby | {
"resource": ""
} |
q9420 | Octo.Trends.counter2trend | train | def counter2trend(counter)
self.new({
enterprise: counter.enterprise,
score: score(counter.divergence),
| ruby | {
"resource": ""
} |
q9421 | Uninhibited.Formatter.example_pending | train | def example_pending(example)
if example_group.metadata[:feature] && example.metadata[:skipped]
@skipped_examples << pending_examples.delete(example)
@skipped_count += 1
| ruby | {
"resource": ""
} |
q9422 | Uninhibited.Formatter.summary_line | train | def summary_line(example_count, failure_count, pending_count)
pending_count -= skipped_count
summary = pluralize(example_count, "example")
summary << " ("
summary << red(pluralize(failure_count, "failure"))
summary << ", | ruby | {
"resource": ""
} |
q9423 | PayuLatam.SubscriptionInterceptor.run | train | def run
PayuLatam::SubscriptionService.new(context.params, | ruby | {
"resource": ""
} |
q9424 | Logsly::Logging182::Stats.Sampler.coalesce | train | def coalesce( other )
@sum += other.sum
@sumsq += other.sumsq
if other.num > 0
@min = other.min if @min > other.min
@max | ruby | {
"resource": ""
} |
q9425 | Logsly::Logging182::Stats.Sampler.sample | train | def sample( s )
@sum += s
@sumsq += s * s
if @num == 0
@min = @max = | ruby | {
"resource": ""
} |
q9426 | Logsly::Logging182::Stats.Sampler.sd | train | def sd
return 0.0 if num < 2
# (sqrt( ((s).sumsq - ( (s).sum * (s).sum / (s).num)) / ((s).num-1) ))
begin
return Math.sqrt( | ruby | {
"resource": ""
} |
q9427 | Logsly::Logging182::Stats.Tracker.coalesce | train | def coalesce( other )
sync {
other.stats.each do |name,sampler|
| ruby | {
"resource": ""
} |
q9428 | Logsly::Logging182::Stats.Tracker.time | train | def time( event )
sync {stats[event].mark}
yield
ensure
| ruby | {
"resource": ""
} |
q9429 | Logsly::Logging182::Stats.Tracker.periodically_run | train | def periodically_run( period, &block )
raise ArgumentError, 'a runner already exists' unless @runner.nil?
@runner = Thread.new do
start = stop = Time.now.to_f
loop do
seconds = period - (stop-start)
seconds = period if seconds <= 0
sleep seconds
| ruby | {
"resource": ""
} |
q9430 | Palimpsest.Assets.write | train | def write(target, gzip: options[:gzip], hash: options[:hash])
asset = assets[target]
return if asset.nil?
name = hash ? asset.digest_path : asset.logical_path.to_s
name = File.join(options[:output], name) unless | ruby | {
"resource": ""
} |
q9431 | BreadcrumbTrail.Breadcrumb.computed_path | train | def computed_path(context)
@_path ||= case @path
when String, Hash
@path
when Symbol
context.public_send(@path) # todo | ruby | {
"resource": ""
} |
q9432 | BreadcrumbTrail.Breadcrumb.computed_name | train | def computed_name(context)
@_name ||= case @name
when String
@name
when Symbol
I18n.translate(@name)
when Proc
context.instance_exec(&@name)
when nil
computed_path(context)
else
| ruby | {
"resource": ""
} |
q9433 | SycLink.Firefox.read | train | def read
bookmark_file = Dir.glob(File.expand_path(path)).shift
raise "Did not find file #{path}" unless bookmark_file
| ruby | {
"resource": ""
} |
q9434 | SycLink.Firefox.rows | train | def rows
read.map do |row|
a = row[0]; b = row[1]; c = row[2]; d = row[3]; e = row[4]; f = row[5]
[a,
b || c,
(d | ruby | {
"resource": ""
} |
q9435 | FaviconParty.Image.to_png | train | def to_png
return @png_data if !@png_data.nil?
image = minimagick_image
image.resize '16x16!'
image.format 'png'
image.strip
| ruby | {
"resource": ""
} |
q9436 | Palimpsest.Repo.extract_repo | train | def extract_repo(path, destination, reference)
fail 'Git not installed' unless Utils.command? 'git'
Dir.chdir path do
| ruby | {
"resource": ""
} |
q9437 | BreadcrumbTrail.BlockBuilder.call | train | def call
buffer = ActiveSupport::SafeBuffer.new
@breadcrumbs.each do |breadcrumb|
| ruby | {
"resource": ""
} |
q9438 | BreadcrumbTrail.HTMLBuilder.call | train | def call
outer_tag = @options.fetch(:outer, "ol")
inner_tag = @options.fetch(:inner, "li")
outer = tag(outer_tag,
@options.fetch(:outer_options, nil),
true) if outer_tag
inner = tag(inner_tag,
@options.fetch(:inner_options, nil),
... | ruby | {
"resource": ""
} |
q9439 | Swift.FiberConnectionPool.acquire | train | def acquire id, fiber
if conn = @available.pop
@reserved[id] = conn
else
| ruby | {
"resource": ""
} |
q9440 | Swift.FiberConnectionPool.method_missing | train | def method_missing method, *args, &blk
__reserve__ do |conn|
if @trace
conn.trace(@trace) {conn.__send__(method, *args, &blk)}
else
| ruby | {
"resource": ""
} |
q9441 | LegoNXT::LowLevel.UsbConnection.transmit! | train | def transmit! bits
bytes_sent = @handle.bulk_transfer | ruby | {
"resource": ""
} |
q9442 | LegoNXT::LowLevel.UsbConnection.transceive | train | def transceive bits
raise ::LegoNXT::BadOpCodeError unless bytestring(DirectOps::REQUIRE_RESPONSE, SystemOps::REQUIRE_RESPONSE).include? bits[0]
raise ::LegoNXT::TransmitError unless transmit! bits
| ruby | {
"resource": ""
} |
q9443 | LegoNXT::LowLevel.UsbConnection.open | train | def open
context = LIBUSB::Context.new
device = context.devices(:idVendor => LEGO_VENDOR_ID, :idProduct => NXT_PRODUCT_ID).first
| ruby | {
"resource": ""
} |
q9444 | Gricer.RequestsController.handle_special_fields | train | def handle_special_fields
if ['referer_host', 'referer_path', 'referer_params', 'search_engine', 'search_query'].include?(params[:field])
@items = @items.only_first_in_session
end
if ['search_engine', 'search_query'].include?(params[:field])
@items = @items.without_nil_in params... | ruby | {
"resource": ""
} |
q9445 | StixSchemaSpy.Node.referenced_element | train | def referenced_element
ref = @xml.attributes['ref'].value
@referenced_element ||= if ref =~ /:/
prefix, element = ref.split(':')
schema.find_element(element) | ruby | {
"resource": ""
} |
q9446 | HasPrice.PriceBuilder.item | train | def item(price, item_name)
@current_nesting_level[item_name.to_s] | ruby | {
"resource": ""
} |
q9447 | HasPrice.PriceBuilder.group | train | def group(group_name, &block)
group_key = group_name.to_s
@current_nesting_level[group_key] ||= {}
if block_given?
| ruby | {
"resource": ""
} |
q9448 | Kat.Search.query= | train | def query=(search_term)
@search_term =
case search_term
when nil, '' then []
when String, Symbol then [search_term]
when Array then search_term.flatten.select { |e| [String, Symbol].include? e.class }
| ruby | {
"resource": ""
} |
q9449 | Kat.Search.options= | train | def options=(options)
fail ArgumentError, 'options must be a Hash. ' \
"#{ options.inspect | ruby | {
"resource": ""
} |
q9450 | Kat.Search.build_query | train | def build_query
@query = @search_term.dup
@pages = -1
@results = []
@query << "\"#{ @options[:exact] }\"" if @options[:exact]
@query << @options[:or].join(' OR ') unless @options[:or].nil? or @options[:or].empty?
@query += @options[:without].map { |s| "-#{ s }" } if @options[:wi... | ruby | {
"resource": ""
} |
q9451 | Kat.Search.results_column | train | def results_column(name)
@results.compact.map do |rs|
rs.map | ruby | {
"resource": ""
} |
q9452 | Aker.User.full_name | train | def full_name
display_name_parts = [first_name, last_name].compact
if display_name_parts.empty?
username
| ruby | {
"resource": ""
} |
q9453 | EasyPartials.HelperAdditions.concat_partial | train | def concat_partial(partial, *args, &block)
rendered | ruby | {
"resource": ""
} |
q9454 | Aker::Authorities.Static.valid_credentials? | train | def valid_credentials?(kind, *credentials)
found_username =
(all_credentials(kind).detect { |c| c[:credentials] == | ruby | {
"resource": ""
} |
q9455 | Aker::Authorities.Static.load! | train | def load!(io)
doc = YAML.load(io)
return self unless doc
(doc["groups"] || {}).each do |portal, top_level_groups|
@groups[portal.to_sym] = top_level_groups.collect { |group_data| build_group(group_data) }
end
(doc["users"] || {}).each do |username, config|
attr_keys = confi... | ruby | {
"resource": ""
} |
q9456 | Reaction.Client.broadcast | train | def broadcast(name, message, opts={})
# encapsulation
encap = { n: name,
m: message,
t: opts[:to] || /.*/,
e: opts[:except] || []
| ruby | {
"resource": ""
} |
q9457 | Manage.ResourceHelper.action_link | train | def action_link(scope, link_data)
value = nil
case link_data
when Proc
value = link_data.call(scope)
when Hash
relation = link_data.keys.first
entity = Fields::Reader.field_value(scope, relation)
unless entity.present?
return ''
end
if ... | ruby | {
"resource": ""
} |
q9458 | Addresslogic.ClassMethods.apply_addresslogic | train | def apply_addresslogic(options = {})
n = options[:namespace]
options[:fields] ||= [
"#{n}street1".to_sym,
"#{n}street2".to_sym,
["#{n}city".to_sym, ["#{n}state".to_sym, "#{n}zip".to_sym]],
| ruby | {
"resource": ""
} |
q9459 | Yargraph.UndirectedGraph.hamiltonian_cycles_dynamic_programming | train | def hamiltonian_cycles_dynamic_programming(operational_limit=nil)
stack = DS::Stack.new
return [] if @vertices.empty?
origin_vertex = @vertices.to_a[0]
hamiltonians = []
num_operations = 0
# This hash keeps track of subproblems that have already been
# solved. ie is there a p... | ruby | {
"resource": ""
} |
q9460 | Overcloud.Node.introspect_node | train | def introspect_node(node_uuid)
workflow = 'tripleo.baremetal.v1.introspect'
input = { | ruby | {
"resource": ""
} |
q9461 | SiteAnalyzer.Site.add_pages_for_scan! | train | def add_pages_for_scan!
@pages_for_scan = []
@bad_pages = []
@pages.each do |page|
@bad_pages << page.page_url unless page.page_a_tags
next unless page.page_a_tags
| ruby | {
"resource": ""
} |
q9462 | SiteAnalyzer.Site.add_page | train | def add_page(url)
unless robot_txt_allowed?(url)
@scanned_pages << url
return nil
end | ruby | {
"resource": ""
} |
q9463 | SiteAnalyzer.Site.all_titles | train | def all_titles
result = []
@pages.each do |page|
| ruby | {
"resource": ""
} |
q9464 | SiteAnalyzer.Site.all_descriptions | train | def all_descriptions
result = []
@pages.each do |page|
| ruby | {
"resource": ""
} |
q9465 | SiteAnalyzer.Site.all_h2 | train | def all_h2
result = []
@pages.each do |page|
result << [page.page_url, | ruby | {
"resource": ""
} |
q9466 | SiteAnalyzer.Site.all_a | train | def all_a
result = []
@pages.each do |page|
next unless page.page_a_tags
page.page_a_tags.compact.each do |tag|
tag[0] = '-' unless tag[0]
tag[1] = '-' unless tag[1]
tag[2] | ruby | {
"resource": ""
} |
q9467 | SiteAnalyzer.Site.convert_to_valid | train | def convert_to_valid(url)
return nil if url =~ /.jpg$/i
url.insert(0, @main_url.first(5)) if url.start_with? '//'
link = URI(url)
main_page = URI(@main_url)
if link && link.scheme && link.scheme.empty?
link.scheme = main_page.scheme
elsif link.nil?
return nil
| ruby | {
"resource": ""
} |
q9468 | Sawaal.Selections.read_char | train | def read_char
input = $stdin.getch
return input unless input == "\e"
begin
Timeout.timeout(0.01) do
| ruby | {
"resource": ""
} |
q9469 | TodoLint.Reporter.number_of_spaces | train | def number_of_spaces
todo.character_number - 1 - (todo.line.length | ruby | {
"resource": ""
} |
q9470 | Swift.Adapter.create | train | def create record, resources
result = [resources].flatten.map do |resource|
resource = record.new(resource) unless resource.kind_of?(record)
result = execute(command_create(record), *resource.tuple.values_at(*record.header.insertable))
| ruby | {
"resource": ""
} |
q9471 | Swift.Adapter.update | train | def update record, resources
result = [resources].flatten.map do |resource|
resource = record.new(resource) unless resource.kind_of?(record)
keys = resource.tuple.values_at(*record.header.keys)
# TODO: Name the key field(s) missing.
raise ArgumentError, "#{record} resource has... | ruby | {
"resource": ""
} |
q9472 | Swift.Adapter.delete | train | def delete record, resources
result = [resources].flatten.map do |resource|
resource = record.new(resource) unless resource.kind_of?(record)
keys = resource.tuple.values_at(*record.header.keys)
# TODO: Name the key field(s) missing.
raise ArgumentError, "#{record} resource has... | ruby | {
"resource": ""
} |
q9473 | Swift.Adapter.prepare | train | def prepare record = nil, command
record ? Statement.new(record, | ruby | {
"resource": ""
} |
q9474 | Swift.Adapter.execute | train | def execute command, *bind
start = Time.now
record, command = command, bind.shift if command.kind_of?(Class) && | ruby | {
"resource": ""
} |
q9475 | Troy.Page.method_missing | train | def method_missing(name, *args, &block)
return meta[name.to_s] if | ruby | {
"resource": ""
} |
q9476 | Troy.Page.render | train | def render
ExtensionMatcher.new(path)
.default { content }
.on("html") { | ruby | {
"resource": ""
} |
q9477 | Troy.Page.save_to | train | def save_to(path)
File.open(path, "w") do |file|
I18n.with_locale(meta.locale) do
| ruby | {
"resource": ""
} |
q9478 | ZeevexThreadsafe::ThreadLocals.InstanceMethods._thread_local_clean | train | def _thread_local_clean
ids = Thread.list.map &:object_id
| ruby | {
"resource": ""
} |
q9479 | CaRuby.Properties.[]= | train | def []=(key, value)
return super if has_key?(key)
alt = alternate_key(key)
| ruby | {
"resource": ""
} |
q9480 | CaRuby.Properties.load_properties | train | def load_properties(file)
raise ConfigurationError.new("Properties file not found: #{File.expand_path(file)}") unless File.exists?(file)
properties = {}
begin
YAML.load_file(file).each { |key, value| properties[key.to_sym] = value }
rescue
raise ConfigurationError.new("Could not ... | ruby | {
"resource": ""
} |
q9481 | SycLink.Infrastructure.copy_file_if_missing | train | def copy_file_if_missing(file, to_directory)
unless File.exists? | ruby | {
"resource": ""
} |
q9482 | SycLink.Infrastructure.load_config | train | def load_config(file)
unless File.exists? file
File.open(file, 'w') do | ruby | {
"resource": ""
} |
q9483 | RailsViewHelpers.DatetimeHelper.datetime_to_s | train | def datetime_to_s(date_or_datetime, format)
return '' if date_or_datetime.blank?
| ruby | {
"resource": ""
} |
q9484 | Authpwn.HttpTokenControllerInstanceMethods.authenticate_using_http_token | train | def authenticate_using_http_token
return if current_user
authenticate_with_http_token do |token_code, options|
auth = Tokens::Api.authenticate token_code
# NOTE: Setting the instance variable directly bypasses the session
# | ruby | {
"resource": ""
} |
q9485 | XES.Document.format | train | def format
raise FormatError.new(self) unless formattable?
REXML::Document.new.tap do |doc|
| ruby | {
"resource": ""
} |
q9486 | Polyseerio.Request.execute | train | def execute(method, *args)
new_args = args
@pre_request.each do |middleware|
new_args = middleware.call(*new_args)
end
path = new_args.empty? ? '' : new_args.shift
req = proc do ||
@resource[path].send(method, *new_args)
end
post | ruby | {
"resource": ""
} |
q9487 | ThumbnailHoverEffect.Image.render | train | def render(parameters = {})
has_thumbnail = parameters.fetch(:has_thumbnail, true)
effect_number = parameters.fetch(:effect_number, false)
thumbnail_template = self.get_template(effect_number)
if has_thumbnail
| ruby | {
"resource": ""
} |
q9488 | Geo.Itudes.distance | train | def distance other, units = :km
o = Itudes.new other
raise ArgumentError.new "operand must be lat-/longitudable" if (o.latitude.nil? || o.longitude.nil?)
dlat = Itudes.radians(o.latitude - @latitude)
dlon = Itudes.radians(o.longitude - @longitude)
lat1 = Itudes.radians(@latitude... | ruby | {
"resource": ""
} |
q9489 | Checkdin.Promotions.promotions | train | def promotions(options={})
response = connection.get do |req|
| ruby | {
"resource": ""
} |
q9490 | Checkdin.Promotions.promotion_votes_leaderboard | train | def promotion_votes_leaderboard(id, options={})
response = connection.get do |req|
| ruby | {
"resource": ""
} |
q9491 | Fishbans.PlayerSkins.get_player_image | train | def get_player_image(username, type, size)
url = "http://i.fishbans.com/#{type}/#{username}/#{size}"
response = get(url, | ruby | {
"resource": ""
} |
q9492 | CopyCsv.ClassMethods.write_to_csv | train | def write_to_csv(file_name, mode = "w")
File.open(file_name, mode) do |file|
| ruby | {
"resource": ""
} |
q9493 | Gricer.BaseController.process_stats | train | def process_stats
@items = basic_collection
handle_special_fields
data = {
alternatives: [
{
type: 'spread',
uri: url_for(action: "spread_stats", field: params[:field], filters: params[:filters], only_path: true)
},
{
... | ruby | {
"resource": ""
} |
q9494 | Gricer.BaseController.spread_stats | train | def spread_stats
@items = basic_collection.between_dates(@stat_from, @stat_thru)
handle_special_fields
data = {
alternatives: [
{
type: 'spread'
},
{
type: 'process',
uri: url_for(action: "process_stats", fiel... | ruby | {
"resource": ""
} |
q9495 | Gricer.BaseController.guess_from_thru | train | def guess_from_thru
begin
@stat_thru = Time.parse(params[:thru]).to_date
rescue
end
begin
@stat_from = Time.parse(params[:from]).to_date
rescue
end
if @stat_from.nil?
if @stat_thru.nil?
@stat_thru = Time.now.localtime.to_date ... | ruby | {
"resource": ""
} |
q9496 | PutText.POFile.write_to | train | def write_to(io)
deduplicate
io.write(@header_entry.to_s)
@entries.each do |entry|
| ruby | {
"resource": ""
} |
q9497 | CaRuby.Cache.clear | train | def clear
if @sticky.empty? then
@ckh.clear
else
@ckh.each | ruby | {
"resource": ""
} |
q9498 | HS.Chapter.find_module | train | def find_module(slug)
modules.find { |m| | ruby | {
"resource": ""
} |
q9499 | LolitaPaypal.TransactionsController.answer | train | def answer
if request.post?
if ipn_notify.acknowledge
LolitaPaypal::Transaction.create_transaction(ipn_notify, payment_from_ipn, request)
end
render nothing: true
else
if payment_from_ipn
redirect_to payment_from_ipn.paypal_return_path
else
| 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.