_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q23100
|
Dare.Window.add_keyboard_event_listeners
|
train
|
def add_keyboard_event_listeners
Element.find("html").on :keydown do |event|
@keys[get_key_id(event)] = true
end
Element.find("html").on :keyup do |event|
@keys[get_key_id(event)] = false
end
::Window.on :blur do |event|
@keys.fill false
end
end
|
ruby
|
{
"resource": ""
}
|
q23101
|
POI.Worksheet.[]
|
train
|
def [](row_index)
if Fixnum === row_index
rows[row_index]
else
ref = org.apache.poi.ss.util.CellReference.new(row_index)
cell = rows[ref.row][ref.col]
cell && cell.value ? cell.value : cell
end
end
|
ruby
|
{
"resource": ""
}
|
q23102
|
IniParse.Generator.section
|
train
|
def section(name, opts = {})
if @in_section
# Nesting sections is bad, mmmkay?
raise LineNotAllowed, "You can't nest sections in INI files."
end
# Add to a section if it already exists
if @document.has_section?(name.to_s())
@context = @document[name.to_s()]
else
@context = Lines::Section.new(name, line_options(opts))
@document.lines << @context
end
if block_given?
begin
@in_section = true
with_options(opts) { yield self }
@context = @document
blank()
ensure
@in_section = false
end
end
end
|
ruby
|
{
"resource": ""
}
|
q23103
|
IniParse.Generator.option
|
train
|
def option(key, value, opts = {})
@context.lines << Lines::Option.new(
key, value, line_options(opts)
)
rescue LineNotAllowed
# Tried to add an Option to a Document.
raise NoSectionError,
'Your INI document contains an option before the first section is ' \
'declared which is not allowed.'
end
|
ruby
|
{
"resource": ""
}
|
q23104
|
IniParse.Generator.comment
|
train
|
def comment(comment, opts = {})
@context.lines << Lines::Comment.new(
line_options(opts.merge(:comment => comment))
)
end
|
ruby
|
{
"resource": ""
}
|
q23105
|
IniParse.Generator.with_options
|
train
|
def with_options(opts = {}) # :nodoc:
opts = opts.dup
opts.delete(:comment)
@opt_stack.push( @opt_stack.last.merge(opts))
yield self
@opt_stack.pop
end
|
ruby
|
{
"resource": ""
}
|
q23106
|
Yt.Response.videos_for
|
train
|
def videos_for(items, key, options)
items.body['items'].map{|item| item['id'] = item[key]['videoId']}
if options[:parts] == %i(id)
items
else
options[:ids] = items.body['items'].map{|item| item['id']}
options[:offset] = nil
get('/youtube/v3/videos', resource_params(options)).tap do |response|
response.body['nextPageToken'] = items.body['nextPageToken']
end
end
end
|
ruby
|
{
"resource": ""
}
|
q23107
|
GoogleAnalytics.InstanceMethods.ga_track_event
|
train
|
def ga_track_event(category, action, label = nil, value = nil)
ga_events.push(GoogleAnalytics::Event.new(category, action, label, value))
end
|
ruby
|
{
"resource": ""
}
|
q23108
|
IniParse.Document.to_ini
|
train
|
def to_ini
string = @lines.to_a.map { |line| line.to_ini }.join($/)
string = "#{ string }\n" unless string[-1] == "\n"
string
end
|
ruby
|
{
"resource": ""
}
|
q23109
|
IniParse.Document.to_hash
|
train
|
def to_hash
result = {}
@lines.entries.each do |section|
result[section.key] ||= {}
section.entries.each do |option|
opts = Array(option)
val = opts.map { |o| o.respond_to?(:value) ? o.value : o }
val = val.size > 1 ? val : val.first
result[section.key][opts.first.key] = val
end
end
result
end
|
ruby
|
{
"resource": ""
}
|
q23110
|
IniParse.Document.save
|
train
|
def save(path = nil)
@path = path if path
raise IniParseError, 'No path given to Document#save' if @path !~ /\S/
File.open(@path, 'w') { |f| f.write(self.to_ini) }
end
|
ruby
|
{
"resource": ""
}
|
q23111
|
POI.Workbook.[]
|
train
|
def [](reference)
if Fixnum === reference
return worksheets[reference]
end
if sheet = worksheets.detect{|e| e.name == reference}
return sheet.poi_worksheet.nil? ? nil : sheet
end
cell = cell(reference)
if Array === cell
cell.collect{|e| e.value}
elsif Hash === cell
values = {}
cell.each_pair{|column_name, cells| values[column_name] = cells.collect{|e| e.value}}
values
else
cell.value
end
end
|
ruby
|
{
"resource": ""
}
|
q23112
|
IniParse.Parser.parse
|
train
|
def parse
IniParse::Generator.gen do |generator|
@source.split("\n", -1).each do |line|
generator.send(*Parser.parse_line(line))
end
end
end
|
ruby
|
{
"resource": ""
}
|
q23113
|
IniParse.LineCollection.[]=
|
train
|
def []=(key, value)
key = key.to_s
if has_key?(key)
@lines[ @indicies[key] ] = value
else
@lines << value
@indicies[key] = @lines.length - 1
end
end
|
ruby
|
{
"resource": ""
}
|
q23114
|
IniParse.LineCollection.each
|
train
|
def each(include_blank = false)
@lines.each do |line|
if include_blank || ! (line.is_a?(Array) ? line.empty? : line.blank?)
yield(line)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q23115
|
IniParse.LineCollection.delete
|
train
|
def delete(key)
key = key.key if key.respond_to?(:key)
unless (idx = @indicies[key]).nil?
@indicies.delete(key)
@indicies.each { |k,v| @indicies[k] = v -= 1 if v > idx }
@lines.delete_at(idx)
end
end
|
ruby
|
{
"resource": ""
}
|
q23116
|
IniParse.OptionCollection.<<
|
train
|
def <<(line)
if line.kind_of?(IniParse::Lines::Section)
raise IniParse::LineNotAllowed,
"You can't add a Section to an OptionCollection."
end
if line.blank? || (! has_key?(line.key))
super # Adding a new option, comment or blank line.
else
self[line.key] = [self[line.key], line].flatten
end
self
end
|
ruby
|
{
"resource": ""
}
|
q23117
|
IniParse.OptionCollection.keys
|
train
|
def keys
map { |line| line.kind_of?(Array) ? line.first.key : line.key }
end
|
ruby
|
{
"resource": ""
}
|
q23118
|
Exchange.Helper.assure_time
|
train
|
def assure_time arg=nil, opts={}
if arg
arg.kind_of?(Time) ? arg : Time.gm(*arg.split('-'))
elsif opts[:default]
Time.send(opts[:default])
end
end
|
ruby
|
{
"resource": ""
}
|
q23119
|
TranslationCenter.CenterController.set_language_from
|
train
|
def set_language_from
session[:lang_from] = params[:lang].to_sym
I18n.locale = session[:lang_from]
render nothing: true
end
|
ruby
|
{
"resource": ""
}
|
q23120
|
TranslationCenter.CenterController.set_language_to
|
train
|
def set_language_to
session[:lang_to] = params[:lang].to_sym
respond_to do |format|
format.html { redirect_to root_url }
format.js { render nothing: true }
end
end
|
ruby
|
{
"resource": ""
}
|
q23121
|
TranslationCenter.ActivityQuery.translation_ids
|
train
|
def translation_ids
query = Translation.all
query = query.where(lang: lang) unless lang.blank?
query = query.joins(:translation_key).where("translation_center_translation_keys.name LIKE ?", "%#{translation_key_name}%") unless translation_key_name.blank?
if translator_identifier
translator_class = TranslationCenter::CONFIG['translator_type'].camelize.constantize
translators_ids = translator_class.where("#{TranslationCenter::CONFIG['identifier_type']} LIKE ? ", "%#{translator_identifier}%").map(&:id)
query = query.where(translator_id: translators_ids)
end
query.map(&:id)
end
|
ruby
|
{
"resource": ""
}
|
q23122
|
TranslationCenter.TranslationKey.add_category
|
train
|
def add_category
category_name = self.name.to_s.split('.').first
# if one word then add to general category
category_name = self.name.to_s.split('.').size == 1 ? 'general' : self.name.to_s.split('.').first
self.category = TranslationCenter::Category.where(name: category_name).first_or_create
self.last_accessed = Time.now
end
|
ruby
|
{
"resource": ""
}
|
q23123
|
TranslationCenter.TranslationKey.update_status
|
train
|
def update_status(lang)
if self.translations.in(lang).blank?
self.update_attribute("#{lang}_status", UNTRANSLATED)
elsif !self.translations.in(lang).accepted.blank?
self.update_attribute("#{lang}_status", TRANSLATED)
else
self.update_attribute("#{lang}_status", PENDING)
end
end
|
ruby
|
{
"resource": ""
}
|
q23124
|
TranslationCenter.TranslationKey.create_default_translation
|
train
|
def create_default_translation
translation = self.translations.build(value: self.name.to_s.split('.').last.titleize,
lang: :en, status: 'accepted')
translation.translator = TranslationCenter.prepare_translator
translation.save
end
|
ruby
|
{
"resource": ""
}
|
q23125
|
TranslationCenter.TranslationKey.add_to_hash
|
train
|
def add_to_hash(all_translations, lang)
levels = self.name.split('.')
add_to_hash_rec(all_translations, levels, lang.to_s)
end
|
ruby
|
{
"resource": ""
}
|
q23126
|
Exchange.Typecasting.money
|
train
|
def money *attributes
options = attributes.last.is_a?(Hash) ? attributes.pop : {}
attributes.each do |attribute|
# Get the attribute typecasted into money
# @return [Exchange::Money] an instance of money
#
install_money_getter attribute, options
# Set the attribute either with money or just any data
# Implicitly converts values given that are not in the same currency as the currency option evaluates to
# @param [Exchange::Money, String, Numberic] data The data to set the attribute to
#
install_money_setter attribute, options
end
# Evaluates options given either as symbols or as procs
# @param [Symbol, Proc] option The option to evaluate
#
install_money_option_eval
# Evaluates whether an error should be raised because there is no currency present
# @param [Symbol] currency The currency, if given
#
install_currency_error_tester
end
|
ruby
|
{
"resource": ""
}
|
q23127
|
Capybara.BootstrapDatepicker.select_date
|
train
|
def select_date(value, datepicker: :bootstrap, format: nil, from: nil, xpath: nil, **args)
fail "Must pass a hash containing 'from' or 'xpath'" if from.nil? && xpath.nil?
value = value.respond_to?(:to_date) ? value.to_date : Date.parse(value)
date_input = xpath ? find(:xpath, xpath, **args) : find_field(from, **args)
case datepicker
when :bootstrap
select_bootstrap_date date_input, value
else
select_simple_date date_input, value, format
end
first(:xpath, '//body').click
end
|
ruby
|
{
"resource": ""
}
|
q23128
|
Capybara.BootstrapDatepicker.select_simple_date
|
train
|
def select_simple_date(date_input, value, format = nil)
value = value.strftime format unless format.nil?
date_input.set "#{value}\e"
end
|
ruby
|
{
"resource": ""
}
|
q23129
|
Capybara.BootstrapDatepicker.select_bootstrap_date
|
train
|
def select_bootstrap_date(date_input, value)
date_input.click
picker = Picker.new
picker.goto_decade_panel
picker.navigate_through_decades value.year
picker.find_year(value.year).click
picker.find_month(value.month).click
picker.find_day(value.day).click
fail if Date.parse(date_input.value) != value
end
|
ruby
|
{
"resource": ""
}
|
q23130
|
Exchange.Configurable.subclass_with_constantize
|
train
|
def subclass_with_constantize
self.subclass = parent_module.const_get camelize(self.subclass_without_constantize) unless !self.subclass_without_constantize || self.subclass_without_constantize.is_a?(Class)
subclass_without_constantize
end
|
ruby
|
{
"resource": ""
}
|
q23131
|
Exchange.ISO.assert_currency!
|
train
|
def assert_currency! arg
defines?(arg) ? (country_map[arg] || arg) : raise(Exchange::NoCurrencyError.new("#{arg} is not a currency nor a country code matchable to a currency"))
end
|
ruby
|
{
"resource": ""
}
|
q23132
|
Exchange.ISO.instantiate
|
train
|
def instantiate amount, currency
if amount.is_a?(BigDecimal)
amount
else
BigDecimal.new(amount.to_s, precision_for(amount, currency))
end
end
|
ruby
|
{
"resource": ""
}
|
q23133
|
Exchange.ISO.stringify
|
train
|
def stringify amount, currency, opts={}
definition = definitions[currency]
separators = definition[:separators] || {}
format = "%.#{definition[:minor_unit]}f"
string = format % amount
major, minor = string.split('.')
major.gsub!(/(\d)(?=(\d\d\d)+(?!\d))/) { $1 + separators[:major] } if separators[:major] && opts[:format] != :plain
string = minor ? major + (opts[:format] == :plain || !separators[:minor] ? '.' : separators[:minor]) + minor : major
pre = [[:amount, :plain].include?(opts[:format]) && '', opts[:format] == :symbol && definition[:symbol], currency.to_s.upcase + ' '].detect{|a| a.is_a?(String)}
"#{pre}#{string}"
end
|
ruby
|
{
"resource": ""
}
|
q23134
|
Exchange.ISO.symbolize_keys
|
train
|
def symbolize_keys hsh
new_hsh = Hash.new
hsh.each_pair do |k,v|
v = symbolize_keys v if v.is_a?(Hash)
new_hsh[k.downcase.to_sym] = v
end
new_hsh
end
|
ruby
|
{
"resource": ""
}
|
q23135
|
Exchange.ISO.precision_for
|
train
|
def precision_for amount, currency
defined_minor_precision = definitions[currency][:minor_unit]
match = amount.to_s.match(/^-?(\d*)\.?(\d*)e?(-?\d+)?$/).to_a[1..3]
given_major_precision, given_minor_precision = precision_from_match *match
given_major_precision + [defined_minor_precision, given_minor_precision].max
end
|
ruby
|
{
"resource": ""
}
|
q23136
|
ActsAsTranslator.InstanceMethods.translation_for
|
train
|
def translation_for(key, lang)
self.translations.find_or_initialize_by(translation_key_id: key.id, lang: lang.to_s, translator_type: self.class.name)
end
|
ruby
|
{
"resource": ""
}
|
q23137
|
TranslationCenter.Category.complete_percentage_in
|
train
|
def complete_percentage_in(lang)
if self.keys.blank?
100
else
accepted_keys = accepted_keys(lang)
100 * accepted_keys.count / self.keys.count
end
end
|
ruby
|
{
"resource": ""
}
|
q23138
|
Exchange.Money.to
|
train
|
def to other, options={}
other = ISO.assert_currency!(other)
if api_supports_currency?(currency) && api_supports_currency?(other)
opts = { :at => time, :from => self }.merge(options)
Money.new(api.new.convert(value, currency, other, opts), other, opts)
elsif fallback!
to other, options
else
raise_no_rate_error(other)
end
rescue ExternalAPI::APIError
if fallback!
to other, options
else
raise
end
end
|
ruby
|
{
"resource": ""
}
|
q23139
|
Exchange.Money.fallback!
|
train
|
def fallback!
fallback = Exchange.configuration.api.fallback
new_api = fallback.index(api) ? fallback[fallback.index(api) + 1] : fallback.first
if new_api
@api = new_api
return true
end
return false
end
|
ruby
|
{
"resource": ""
}
|
q23140
|
TranslationCenter.Translation.accept
|
train
|
def accept
# If translation is accepted do nothing
unless self.accepted?
self.translation_key.accepted_translation_in(self.lang)
.try(:update_attribute, :status, TranslationKey::PENDING)
# reload the translation key as it has changed
self.translation_key.reload
self.update_attribute(:status, ACCEPTED)
end
end
|
ruby
|
{
"resource": ""
}
|
q23141
|
TranslationCenter.Translation.one_translation_per_lang_per_key
|
train
|
def one_translation_per_lang_per_key
translation_exists = Translation.exists?(
lang: self.lang,
translator_id: self.translator.id,
translator_type: self.translator.class.name,
translation_key_id: self.key.id
)
unless translation_exists
true
else
false
self.errors.add(:lang, I18n.t('.one_translation_per_lang_per_key'))
end
end
|
ruby
|
{
"resource": ""
}
|
q23142
|
PointlessFeedback.ApplicationHelper.method_missing
|
train
|
def method_missing(method, *args, &block)
if main_app_url_helper?(method)
main_app.send(method, *args)
else
super
end
end
|
ruby
|
{
"resource": ""
}
|
q23143
|
SWF.DecisionTaskHandler.tags
|
train
|
def tags
runner.tag_lists[decision_task.workflow_execution] ||= begin
collision = 0
begin
decision_task.workflow_execution.tags
rescue => e
collision += 1 if collision < 10
max_slot_delay = 2**collision - 1
sleep(slot_time * rand(0 .. max_slot_delay))
retry
end
end
end
|
ruby
|
{
"resource": ""
}
|
q23144
|
AlexaRubykit.Response.say_response
|
train
|
def say_response(speech, end_session = true, ssml = false)
output_speech = add_speech(speech,ssml)
{ :outputSpeech => output_speech, :shouldEndSession => end_session }
end
|
ruby
|
{
"resource": ""
}
|
q23145
|
AlexaRubykit.Response.say_response_with_reprompt
|
train
|
def say_response_with_reprompt(speech, reprompt_speech, end_session = true, speech_ssml = false, reprompt_ssml = false)
output_speech = add_speech(speech,speech_ssml)
reprompt_speech = add_reprompt(reprompt_speech,reprompt_ssml)
{ :outputSpeech => output_speech, :reprompt => reprompt_speech, :shouldEndSession => end_session }
end
|
ruby
|
{
"resource": ""
}
|
q23146
|
AlexaRubykit.Response.build_response
|
train
|
def build_response(session_end = true)
response_object = build_response_object(session_end)
response = Hash.new
response[:version] = @version
response[:sessionAttributes] = @session_attributes unless @session_attributes.empty?
response[:response] = response_object
response.to_json
end
|
ruby
|
{
"resource": ""
}
|
q23147
|
AlexaRubykit.IntentRequest.add_hash_slots
|
train
|
def add_hash_slots(slots)
raise ArgumentError, 'Slots can\'t be empty'
slots.each do |slot|
@slots[:slot[:name]] = Slot.new(slot[:name], slot[:value])
end
@slots
end
|
ruby
|
{
"resource": ""
}
|
q23148
|
AlexaRubykit.IntentRequest.add_slot
|
train
|
def add_slot(name, value)
slot = Slot.new(name, value)
@slots[:name] = slot
slot
end
|
ruby
|
{
"resource": ""
}
|
q23149
|
ActiveJob.Execution.perform_now
|
train
|
def perform_now
deserialize_arguments_if_needed
run_callbacks :perform do
perform(*arguments)
end
rescue => exception
rescue_with_handler(exception) || raise(exception)
end
|
ruby
|
{
"resource": ""
}
|
q23150
|
Rack.Ratelimit.apply_rate_limit?
|
train
|
def apply_rate_limit?(env)
@exceptions.none? { |e| e.call(env) } && @conditions.all? { |c| c.call(env) }
end
|
ruby
|
{
"resource": ""
}
|
q23151
|
Rack.Ratelimit.seconds_until_epoch
|
train
|
def seconds_until_epoch(epoch)
sec = (epoch - Time.now.to_f).ceil
sec = 0 if sec < 0
sec
end
|
ruby
|
{
"resource": ""
}
|
q23152
|
ActiveJob.Enqueuing.enqueue
|
train
|
def enqueue(options={})
self.scheduled_at = options[:wait].seconds.from_now.to_f if options[:wait]
self.scheduled_at = options[:wait_until].to_f if options[:wait_until]
self.queue_name = self.class.queue_name_from_part(options[:queue]) if options[:queue]
run_callbacks :enqueue do
if self.scheduled_at
self.class.queue_adapter.enqueue_at self, self.scheduled_at
else
self.class.queue_adapter.enqueue self
end
end
self
end
|
ruby
|
{
"resource": ""
}
|
q23153
|
TournamentSystem.Driver.create_match
|
train
|
def create_match(home_team, away_team)
home_team, away_team = away_team, home_team unless home_team
raise 'Invalid match' unless home_team
build_match(home_team, away_team)
end
|
ruby
|
{
"resource": ""
}
|
q23154
|
TournamentSystem.Driver.loss_count_hash
|
train
|
def loss_count_hash
@loss_count_hash ||= matches.each_with_object(Hash.new(0)) { |match, hash| hash[get_match_loser(match)] += 1 }
end
|
ruby
|
{
"resource": ""
}
|
q23155
|
SurveyGizmo::API.Answer.to_hash
|
train
|
def to_hash
{
response_id: response_id,
question_id: question_id,
option_id: option_id,
question_pipe: question_pipe,
submitted_at: submitted_at,
survey_id: survey_id,
other_text: other_text,
answer_text: option_id || other_text ? nil : answer_text
}.reject { |k, v| v.nil? }
end
|
ruby
|
{
"resource": ""
}
|
q23156
|
Smalruby.Color.rgb_to_hsl
|
train
|
def rgb_to_hsl(red, green, blue)
red = round_rgb_color(red)
green = round_rgb_color(green)
blue = round_rgb_color(blue)
color_max = [red, green, blue].max
color_min = [red, green, blue].min
color_range = color_max - color_min
if color_range == 0
return [0, 0, (color_max * 100.0 / 255).to_i]
end
color_range = color_range.to_f
hue = (case color_max
when red then
HUE_PER_6 * ((green - blue) / color_range)
when green then
HUE_PER_6 * ((blue - red) / color_range) + HUE_PER_6 * 2
else
HUE_PER_6 * ((red - green) / color_range) + HUE_PER_6 * 4
end)
cnt = color_range / 2.0
if cnt <= 127
saturation = color_range / (color_max + color_min) * 100
else
saturation = color_range / (510 - color_max - color_min) * 100
end
lightness = (color_max + color_min) / 2.0 / 255.0 * 100
[hue.round, saturation.round, lightness.round]
end
|
ruby
|
{
"resource": ""
}
|
q23157
|
Smalruby.Color.hsl_to_rgb
|
train
|
def hsl_to_rgb(h, s, l)
h %= 201
s %= 101
l %= 101
if l <= 49
color_max = 255.0 * (l + l * (s / 100.0)) / 100.0
color_min = 255.0 * (l - l * (s / 100.0)) / 100.0
else
color_max = 255.0 * (l + (100 - l) * (s / 100.0)) / 100.0
color_min = 255.0 * (l - (100 - l) * (s / 100.0)) / 100.0
end
if h < HUE_PER_6
base = h
elsif h < HUE_PER_6 * 3
base = (h - HUE_PER_6 * 2).abs
elsif h < HUE_PER_6 * 5
base = (h - HUE_PER_6 * 4).abs
else
base = (200 - h)
end
base = base / HUE_PER_6 * (color_max - color_min) + color_min
divide = (h / HUE_PER_6).to_i
red, green, blue = (case divide
when 0 then [color_max, base, color_min]
when 1 then [base, color_max, color_min]
when 2 then [color_min, color_max, base]
when 3 then [color_min, base, color_max]
when 4 then [base, color_min, color_max]
else [color_max, color_min, base]
end)
[red.round, green.round, blue.round]
end
|
ruby
|
{
"resource": ""
}
|
q23158
|
Racker.Template.to_packer
|
train
|
def to_packer
# Create the new smash
packer = Smash.new
# Variables
packer['variables'] = self['variables'].dup unless self['variables'].nil? || self['variables'].empty?
# Builders
packer['builders'] = [] unless self['builders'].nil? || self['builders'].empty?
logger.info("Processing builders...")
self['builders'].each do |name,config|
logger.info("Processing builder: #{name} with type: #{config['type']}")
# Get the builder for this config
builder = get_builder(config['type'])
# Have the builder convert the config to packer format
packer['builders'] << builder.to_packer(name, config.dup)
end
# Provisioners
packer['provisioners'] = [] unless self['provisioners'].nil? || self['provisioners'].empty?
logger.info("Processing provisioners...")
self['provisioners'].sort.map do |index, provisioners|
provisioners.each do |name,config|
logger.debug("Processing provisioner: #{name}")
packer['provisioners'] << config.dup
end
end
# Post-Processors
packer['post-processors'] = [] unless self['postprocessors'].nil? || self['postprocessors'].empty?
logger.info("Processing post-processors...")
self['postprocessors'].each do |name,config|
logger.debug("Processing post-processor: #{name}")
packer['post-processors'] << config.dup unless config.nil?
end
packer
end
|
ruby
|
{
"resource": ""
}
|
q23159
|
SurveyGizmo.Resource.route_params
|
train
|
def route_params
params = { id: id }
self.class.routes.values.each do |route|
route.gsub(/:(\w+)/) do |m|
m = m.delete(':').to_sym
params[m] = self.send(m)
end
end
params
end
|
ruby
|
{
"resource": ""
}
|
q23160
|
Smalruby.Character.pen_color=
|
train
|
def pen_color=(val)
if val.is_a?(Numeric)
val %= 201
_, s, l = Color.rgb_to_hsl(*pen_color)
val = Color.hsl_to_rgb(val, s, l)
end
@pen_color = val
end
|
ruby
|
{
"resource": ""
}
|
q23161
|
Smalruby.Character.change_pen_color_by
|
train
|
def change_pen_color_by(val)
h, s, l = Color.rgb_to_hsl(*pen_color)
@pen_color = Color.hsl_to_rgb(h + val, s, l)
end
|
ruby
|
{
"resource": ""
}
|
q23162
|
Smalruby.Character.pen_shade=
|
train
|
def pen_shade=(val)
val %= 101
h, s, = *Color.rgb_to_hsl(*pen_color)
@pen_color = Color.hsl_to_rgb(h, s, val)
end
|
ruby
|
{
"resource": ""
}
|
q23163
|
WillPaginate.ViewHelpers.page_entries_info
|
train
|
def page_entries_info(collection, options = {})
entry_name = options[:entry_name] ||
(collection.empty?? 'entry' : collection.first.class.name.underscore.sub('_', ' '))
if collection.total_pages < 2
case collection.size
when 0; "No #{entry_name.pluralize} found"
when 1; "Displaying <b>1</b> #{entry_name}"
else; "Displaying <b>all #{collection.size}</b> #{entry_name.pluralize}"
end
else
%{Displaying #{entry_name.pluralize} <b>%d - %d</b> of <b>%d</b> in total} % [
collection.offset + 1,
collection.offset + collection.length,
collection.total_entries
]
end
end
|
ruby
|
{
"resource": ""
}
|
q23164
|
WillPaginate.LinkRenderer.to_html
|
train
|
def to_html
links = @options[:page_links] ? windowed_links : []
# previous/next buttons
links.unshift page_link_or_span(@collection.previous_page, 'disabled prev_page', @options[:prev_label])
links.push page_link_or_span(@collection.next_page, 'disabled next_page', @options[:next_label])
html = links.join(@options[:separator])
@options[:container] ? @template.content_tag(:div, html, html_attributes) : html
end
|
ruby
|
{
"resource": ""
}
|
q23165
|
WillPaginate.LinkRenderer.html_attributes
|
train
|
def html_attributes
return @html_attributes if @html_attributes
@html_attributes = @options.except *(WillPaginate::ViewHelpers.pagination_options.keys - [:class])
# pagination of Post models will have the ID of "posts_pagination"
if @options[:container] and @options[:id] === true
@html_attributes[:id] = @collection.first.class.name.underscore.pluralize + '_pagination'
end
@html_attributes
end
|
ruby
|
{
"resource": ""
}
|
q23166
|
WillPaginate.LinkRenderer.windowed_links
|
train
|
def windowed_links
prev = nil
visible_page_numbers.inject [] do |links, n|
# detect gaps:
links << gap_marker if prev and n > prev + 1
links << page_link_or_span(n, 'current')
prev = n
links
end
end
|
ruby
|
{
"resource": ""
}
|
q23167
|
WillPaginate.LinkRenderer.stringified_merge
|
train
|
def stringified_merge(target, other)
other.each do |key, value|
key = key.to_s # this line is what it's all about!
existing = target[key]
if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?)
stringified_merge(existing || (target[key] = {}), value)
else
target[key] = value
end
end
end
|
ruby
|
{
"resource": ""
}
|
q23168
|
TaxCloud.TaxCodeGroup.tax_codes
|
train
|
def tax_codes
@tax_codes ||= begin
response = TaxCloud.client.request :get_ti_cs_by_group, tic_group: group_id
tax_codes = TaxCloud::Responses::TaxCodesByGroup.parse response
Hash[tax_codes.map { |tic| [tic.ticid, tic] }]
end
end
|
ruby
|
{
"resource": ""
}
|
q23169
|
TaxCloud.Transaction.authorized
|
train
|
def authorized(options = {})
options = { date_authorized: Date.today }.merge(options)
request_params = {
'customerID' => customer_id,
'cartID' => cart_id,
'orderID' => order_id,
'dateAuthorized' => xml_date(options[:date_authorized])
}
response = TaxCloud.client.request :authorized, request_params
TaxCloud::Responses::Authorized.parse response
end
|
ruby
|
{
"resource": ""
}
|
q23170
|
TaxCloud.Transaction.returned
|
train
|
def returned(options = {})
options = { returned_date: Date.today }.merge(options)
request_params = {
'orderID' => order_id,
'cartItems' => { 'CartItem' => cart_items.map(&:to_hash) },
'returnedDate' => xml_date(options[:returned_date])
}
response = TaxCloud.client.request :returned, request_params
TaxCloud::Responses::Returned.parse response
end
|
ruby
|
{
"resource": ""
}
|
q23171
|
Paperclip.Geometry.to_s
|
train
|
def to_s
s = ""
s << width.to_i.to_s if width > 0
s << "x#{height.to_i}" if height > 0
s << modifier.to_s
s
end
|
ruby
|
{
"resource": ""
}
|
q23172
|
Paperclip.Shoulda.should_have_attached_file
|
train
|
def should_have_attached_file name
klass = self.name.gsub(/Test$/, '').constantize
matcher = have_attached_file name
should matcher.description do
assert_accepts(matcher, klass)
end
end
|
ruby
|
{
"resource": ""
}
|
q23173
|
Paperclip.Shoulda.should_validate_attachment_presence
|
train
|
def should_validate_attachment_presence name
klass = self.name.gsub(/Test$/, '').constantize
matcher = validate_attachment_presence name
should matcher.description do
assert_accepts(matcher, klass)
end
end
|
ruby
|
{
"resource": ""
}
|
q23174
|
Paperclip.Shoulda.stub_paperclip_s3
|
train
|
def stub_paperclip_s3(model, attachment, extension)
definition = model.gsub(" ", "_").classify.constantize.
attachment_definitions[attachment.to_sym]
path = "http://s3.amazonaws.com/:id/#{definition[:path]}"
path.gsub!(/:([^\/\.]+)/) do |match|
"([^\/\.]+)"
end
begin
FakeWeb.register_uri(:put, Regexp.new(path), :body => "OK")
rescue NameError
raise NameError, "the stub_paperclip_s3 shoulda macro requires the fakeweb gem."
end
end
|
ruby
|
{
"resource": ""
}
|
q23175
|
Danger.DangerJira.check
|
train
|
def check(key: nil, url: nil, emoji: ":link:", search_title: true, search_commits: false, fail_on_warning: false, report_missing: true, skippable: true)
throw Error("'key' missing - must supply JIRA issue key") if key.nil?
throw Error("'url' missing - must supply JIRA installation URL") if url.nil?
return if skippable && should_skip_jira?(search_title: search_title)
jira_issues = find_jira_issues(
key: key,
search_title: search_title,
search_commits: search_commits
)
if !jira_issues.empty?
jira_urls = jira_issues.map { |issue| link(href: ensure_url_ends_with_slash(url), issue: issue) }.join(", ")
message("#{emoji} #{jira_urls}")
elsif report_missing
msg = "This PR does not contain any JIRA issue keys in the PR title or commit messages (e.g. KEY-123)"
if fail_on_warning
fail(msg)
else
warn(msg)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q23176
|
Paperclip.Thumbnail.make
|
train
|
def make
src = @file
dst = Tempfile.new([@basename, @format ? ".#{@format}" : ''])
dst.binmode
begin
parameters = []
parameters << source_file_options
parameters << ":source"
parameters << transformation_command
parameters << convert_options
parameters << ":dest"
parameters = parameters.flatten.compact.join(" ").strip.squeeze(" ")
success = Paperclip.run("convert", parameters, :source => "#{File.expand_path(src.path)}[0]", :dest => File.expand_path(dst.path))
rescue PaperclipCommandLineError => e
raise PaperclipError, "There was an error processing the thumbnail for #{@basename}" if @whiny
end
dst
end
|
ruby
|
{
"resource": ""
}
|
q23177
|
Paperclip.Thumbnail.transformation_command
|
train
|
def transformation_command
scale, crop = @current_geometry.transformation_to(@target_geometry, crop?)
trans = []
trans << "-resize" << %["#{scale}"] unless scale.nil? || scale.empty?
trans << "-crop" << %["#{crop}"] << "+repage" if crop
trans
end
|
ruby
|
{
"resource": ""
}
|
q23178
|
TinyMCE.Configuration.add_options
|
train
|
def add_options(options = {}, raw_options = nil)
@options.merge!(options.stringify_keys) unless options.blank?
@raw_options << raw_options unless raw_options.blank?
end
|
ruby
|
{
"resource": ""
}
|
q23179
|
TinyMCE.Configuration.reverse_add_options
|
train
|
def reverse_add_options(options = {}, raw_options = nil)
@options.reverse_merge!(options.stringify_keys) unless options.blank?
@raw_options << raw_options unless raw_options.blank?
end
|
ruby
|
{
"resource": ""
}
|
q23180
|
Paperclip.Upfile.content_type
|
train
|
def content_type
type = (self.path.match(/\.(\w+)$/)[1] rescue "octet-stream").downcase
case type
when %r"jp(e|g|eg)" then "image/jpeg"
when %r"tiff?" then "image/tiff"
when %r"png", "gif", "bmp" then "image/#{type}"
when "txt" then "text/plain"
when %r"html?" then "text/html"
when "js" then "application/js"
when "csv", "xml", "css" then "text/#{type}"
else
# On BSDs, `file` doesn't give a result code of 1 if the file doesn't exist.
content_type = (Paperclip.run("file", "-b --mime-type :file", :file => self.path).split(':').last.strip rescue "application/x-#{type}")
content_type = "application/x-#{type}" if content_type.match(/\(.*?\)/)
content_type
end
end
|
ruby
|
{
"resource": ""
}
|
q23181
|
Shikashi.Sandbox.packet
|
train
|
def packet(*args)
code = args.pick(String,:code)
base_namespace = args.pick(:base_namespace) do nil end
no_base_namespace = args.pick(:no_base_namespace) do @no_base_namespace end
privileges_ = args.pick(Privileges,:privileges) do Privileges.new end
encoding = get_source_encoding(code) || args.pick(:encoding) do nil end
hook_handler = nil
if base_namespace
hook_handler = instantiate_evalhook_handler
hook_handler.base_namespace = base_namespace
hook_handler.sandbox = self
else
hook_handler = @hook_handler
base_namespace = hook_handler.base_namespace
end
source = args.pick(:source) do generate_id end
self.privileges[source] = privileges_
code = "nil;\n " + code
unless no_base_namespace
if (eval(base_namespace.to_s).instance_of? Module)
code = "module #{base_namespace}\n #{code}\n end\n"
else
code = "class #{base_namespace}\n #{code}\n end\n"
end
end
if encoding
code = "# encoding: #{encoding}\n" + code
end
evalhook_packet = @hook_handler.packet(code)
Shikashi::Sandbox::Packet.new(evalhook_packet, privileges_, source)
end
|
ruby
|
{
"resource": ""
}
|
q23182
|
TaxCloud.Address.verify
|
train
|
def verify
params = to_hash.downcase_keys
if TaxCloud.configuration.usps_username
params = params.merge(
'uspsUserID' => TaxCloud.configuration.usps_username
)
end
response = TaxCloud.client.request(:verify_address, params)
TaxCloud::Responses::VerifyAddress.parse(response)
end
|
ruby
|
{
"resource": ""
}
|
q23183
|
TaxCloud.Address.zip
|
train
|
def zip
return nil unless zip5 && !zip5.empty?
[zip5, zip4].select { |z| z && !z.empty? }.join('-')
end
|
ruby
|
{
"resource": ""
}
|
q23184
|
Paperclip.Style.processor_options
|
train
|
def processor_options
args = {}
@other_args.each do |k,v|
args[k] = v.respond_to?(:call) ? v.call(attachment) : v
end
[:processors, :geometry, :format, :whiny, :convert_options].each do |k|
(arg = send(k)) && args[k] = arg
end
args
end
|
ruby
|
{
"resource": ""
}
|
q23185
|
Paperclip.Attachment.styles
|
train
|
def styles
unless @normalized_styles
@normalized_styles = {}
(@styles.respond_to?(:call) ? @styles.call(self) : @styles).each do |name, args|
@normalized_styles[name] = Paperclip::Style.new(name, args.dup, self)
end
end
@normalized_styles
end
|
ruby
|
{
"resource": ""
}
|
q23186
|
Paperclip.Attachment.url
|
train
|
def url(style_name = default_style, use_timestamp = @use_timestamp)
url = original_filename.nil? ? interpolate(@default_url, style_name) : interpolate(@url, style_name)
use_timestamp && updated_at ? [url, updated_at].compact.join(url.include?("?") ? "&" : "?") : url
end
|
ruby
|
{
"resource": ""
}
|
q23187
|
Elasticity.EMR.add_tags
|
train
|
def add_tags(jobflow_id, tags)
params = {
:operation => 'AddTags',
:resource_id => jobflow_id,
:tags => tags
}
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
end
|
ruby
|
{
"resource": ""
}
|
q23188
|
Elasticity.EMR.describe_cluster
|
train
|
def describe_cluster(jobflow_id)
params = {
:operation => 'DescribeCluster',
:cluster_id => jobflow_id,
}
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
JSON.parse(aws_result)
end
|
ruby
|
{
"resource": ""
}
|
q23189
|
Elasticity.EMR.describe_step
|
train
|
def describe_step(jobflow_id, step_id)
params = {
:operation => 'DescribeStep',
:cluster_id => jobflow_id,
:step_id => step_id
}
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
JSON.parse(aws_result)
end
|
ruby
|
{
"resource": ""
}
|
q23190
|
Elasticity.EMR.list_clusters
|
train
|
def list_clusters(options={})
params = {
:operation => 'ListClusters'
}
params.merge!(:cluster_states => options[:states]) if options[:states]
params.merge!(:created_before => options[:created_before].to_i) if options[:created_before]
params.merge!(:created_after => options[:created_after].to_i) if options[:created_after]
params.merge!(:marker => options[:marker]) if options[:marker]
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
JSON.parse(aws_result)
end
|
ruby
|
{
"resource": ""
}
|
q23191
|
Elasticity.EMR.list_instance_groups
|
train
|
def list_instance_groups(jobflow_id)
params = {
:operation => 'ListInstanceGroups',
:cluster_id => jobflow_id,
}
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
JSON.parse(aws_result)
end
|
ruby
|
{
"resource": ""
}
|
q23192
|
Elasticity.EMR.list_bootstrap_actions
|
train
|
def list_bootstrap_actions(jobflow_id)
params = {
:operation => 'ListBootstrapActions',
:cluster_id => jobflow_id,
}
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
JSON.parse(aws_result)
end
|
ruby
|
{
"resource": ""
}
|
q23193
|
Elasticity.EMR.list_steps
|
train
|
def list_steps(jobflow_id, options={})
params = {
:operation => 'ListSteps',
:cluster_id => jobflow_id,
}
params.merge!(:step_ids => options[:step_ids]) if options[:step_ids]
params.merge!(:step_states => options[:step_states]) if options[:step_states]
params.merge!(:marker => options[:marker]) if options[:marker]
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
JSON.parse(aws_result)
end
|
ruby
|
{
"resource": ""
}
|
q23194
|
Elasticity.EMR.remove_tags
|
train
|
def remove_tags(jobflow_id, keys)
params = {
:operation => 'RemoveTags',
:resource_id => jobflow_id,
:tag_keys => keys
}
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
end
|
ruby
|
{
"resource": ""
}
|
q23195
|
Elasticity.EMR.set_termination_protection
|
train
|
def set_termination_protection(jobflow_ids, protection_enabled=true)
params = {
:operation => 'SetTerminationProtection',
:termination_protected => protection_enabled,
:job_flow_ids => jobflow_ids
}
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
end
|
ruby
|
{
"resource": ""
}
|
q23196
|
Elasticity.EMR.set_visible_to_all_users
|
train
|
def set_visible_to_all_users(jobflow_ids, visible=true)
params = {
:operation => 'SetVisibleToAllUsers',
:visible_to_all_users => visible,
:job_flow_ids => jobflow_ids
}
aws_result = @aws_request.submit(params)
yield aws_result if block_given?
end
|
ruby
|
{
"resource": ""
}
|
q23197
|
Bonsai.Page.assets
|
train
|
def assets
Dir["#{directory}/**/*"].sort.select{|path| !File.directory?(path) && !File.basename(path).include?("yml") }.map do |file|
file_to_hash(file)
end
end
|
ruby
|
{
"resource": ""
}
|
q23198
|
Bonsai.Page.to_hash
|
train
|
def to_hash
hash = {
:slug => slug,
:permalink => permalink,
:name => name,
:children => children,
:siblings => siblings,
:parent => parent,
:ancestors => ancestors,
:navigation => Bonsai::Navigation.tree,
:updated_at => mtime,
:created_at => ctime
}.merge(formatted_content).merge(disk_assets).merge(Bonsai.site)
hash.stringify_keys
end
|
ruby
|
{
"resource": ""
}
|
q23199
|
Bonsai.Page.formatted_content
|
train
|
def formatted_content
formatted_content = content
formatted_content.each do |k,v|
if v.is_a?(String) and v =~ /\n/
formatted_content[k] = to_markdown(v)
end
end
formatted_content
end
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.