_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q2700
|
MongoidShortener.ShortenedUrlsController.translate
|
train
|
def translate
# pull the link out of the db
sl = ShortenedUrl.where(:unique_key => params[:unique_key][1..-1]).first
if sl
sl.inc(:use_count, 1)
# do a 301 redirect to the destination url
head :moved_permanently, :location => sl.url
else
# if we don't find the shortened link, redirect to the root
# make this configurable in future versions
head :moved_permanently, :location => MongoidShortener.root_url
end
end
|
ruby
|
{
"resource": ""
}
|
q2701
|
ActsAsFerret.ActMethods.acts_as_ferret
|
train
|
def acts_as_ferret(options={})
extend ClassMethods
include InstanceMethods
include MoreLikeThis::InstanceMethods
if options[:rdig]
cattr_accessor :rdig_configuration
self.rdig_configuration = options[:rdig]
require 'rdig_adapter'
include ActsAsFerret::RdigAdapter
end
unless included_modules.include?(ActsAsFerret::WithoutAR)
# set up AR hooks
after_create :ferret_create
after_update :ferret_update
after_destroy :ferret_destroy
end
cattr_accessor :aaf_configuration
# apply default config for rdig based models
if options[:rdig]
options[:fields] ||= { :title => { :boost => 3, :store => :yes },
:content => { :store => :yes } }
end
# name of this index
index_name = options.delete(:index) || self.name.underscore
index = ActsAsFerret::register_class_with_index(self, index_name, options)
self.aaf_configuration = index.index_definition.dup
# logger.debug "configured index for class #{self.name}:\n#{aaf_configuration.inspect}"
# update our copy of the global index config with options local to this class
aaf_configuration[:class_name] ||= self.name
aaf_configuration[:if] ||= options[:if]
# add methods for retrieving field values
add_fields options[:fields]
add_fields options[:additional_fields]
add_fields aaf_configuration[:fields]
add_fields aaf_configuration[:additional_fields]
end
|
ruby
|
{
"resource": ""
}
|
q2702
|
ActsAsFerret.ActMethods.define_to_field_method
|
train
|
def define_to_field_method(field, options = {})
method_name = "#{field}_to_ferret"
return if instance_methods.include?(method_name) # already defined
aaf_configuration[:defined_fields] ||= {}
aaf_configuration[:defined_fields][field] = options
dynamic_boost = options[:boost] if options[:boost].is_a?(Symbol)
via = options[:via] || field
define_method(method_name.to_sym) do
val = begin
content_for_field_name(field, via, dynamic_boost)
rescue
logger.warn("Error retrieving value for field #{field}: #{$!}")
''
end
logger.debug("Adding field #{field} with value '#{val}' to index")
val
end
end
|
ruby
|
{
"resource": ""
}
|
q2703
|
Minke.Command.create_dependencies
|
train
|
def create_dependencies task
project_name = "minke#{SecureRandom.urlsafe_base64(12)}".downcase.gsub(/[^0-9a-z ]/i, '')
network_name = ENV['DOCKER_NETWORK'] ||= "#{project_name}_default"
ENV['DOCKER_PROJECT'] = project_name
ENV['DOCKER_NETWORK'] = network_name
logger = Minke::Logging.create_logger(STDOUT, self.verbose)
shell = Minke::Helpers::Shell.new(logger)
task_runner = Minke::Tasks::TaskRunner.new ({
:ruby_helper => Minke::Helpers::Ruby.new,
:copy_helper => Minke::Helpers::Copy.new,
:service_discovery => Minke::Docker::ServiceDiscovery.new(project_name, Minke::Docker::DockerRunner.new(logger), network_name),
:logger_helper => logger
})
consul = Minke::Docker::Consul.new(
{
:health_check => Minke::Docker::HealthCheck.new(logger),
:service_discovery => Minke::Docker::ServiceDiscovery.new( project_name, Minke::Docker::DockerRunner.new(logger, network_name), network_name),
:consul_loader => ConsulLoader::Loader.new(ConsulLoader::ConfigParser.new),
:docker_runner => Minke::Docker::DockerRunner.new(logger, network_name),
:network => network_name,
:project_name => project_name,
:logger_helper => logger
}
)
network = Minke::Docker::Network.new(
network_name,
shell
)
return {
:config => @config,
:task_name => task,
:docker_runner => Minke::Docker::DockerRunner.new(logger, network_name, project_name),
:task_runner => task_runner,
:shell_helper => shell,
:logger_helper => logger,
:generator_config => generator_config,
:docker_compose_factory => Minke::Docker::DockerComposeFactory.new(shell, project_name, network_name),
:consul => consul,
:docker_network => network,
:health_check => Minke::Docker::HealthCheck.new(logger),
:service_discovery => Minke::Docker::ServiceDiscovery.new(project_name, Minke::Docker::DockerRunner.new(logger), network_name)
}
end
|
ruby
|
{
"resource": ""
}
|
q2704
|
Rapinoe.Slide.write_preview_to_file
|
train
|
def write_preview_to_file(path)
FileUtils.mkdir_p(File.dirname(path))
File.open(path, 'wb') do |out|
out.write(preview_data)
end
end
|
ruby
|
{
"resource": ""
}
|
q2705
|
Gemnasium.Configuration.is_valid?
|
train
|
def is_valid?
site_option_valid = !site.nil? && !site.empty?
api_key_option_valid = !api_key.nil? && !api_key.empty?
use_ssl_option_valid = !use_ssl.nil? && !!use_ssl == use_ssl # Check this is a boolean
api_version_option_valid = !api_version.nil? && !api_version.empty?
project_name_option_valid = !project_name.nil? && !project_name.empty?
ignored_paths_option_valid = ignored_paths.kind_of?(Array)
site_option_valid && api_key_option_valid && use_ssl_option_valid && api_version_option_valid &&
project_name_option_valid && ignored_paths_option_valid
end
|
ruby
|
{
"resource": ""
}
|
q2706
|
GScraper.SponsoredLinks.ads_with_title
|
train
|
def ads_with_title(title)
return enum_for(:ads_with_title,title) unless block_given?
comparitor = if title.kind_of?(Regexp)
lambda { |ad| ad.title =~ title }
else
lambda { |ad| ad.title == title }
end
return ads_with do |ad|
if comparitor.call(ad)
yield ad
true
end
end
end
|
ruby
|
{
"resource": ""
}
|
q2707
|
GScraper.SponsoredLinks.ads_with_url
|
train
|
def ads_with_url(url)
return enum_for(:ads_with_url,url) unless block_given?
comparitor = if url.kind_of?(Regexp)
lambda { |ad| ad.url =~ url }
else
lambda { |ad| ad.url == url }
end
return ads_with do |ad|
if comparitor.call(ad)
yield ad
true
end
end
end
|
ruby
|
{
"resource": ""
}
|
q2708
|
GScraper.SponsoredLinks.ads_with_direct_url
|
train
|
def ads_with_direct_url(direct_url)
return enum_for(:ads_with_direct_url,direct_url) unless block_given?
comparitor = if direct_url.kind_of?(Regexp)
lambda { |ad| ad.direct_url =~ direct_url }
else
lambda { |ad| ad.direct_url == direct_url }
end
return ads_with do |ad|
if comparitor.call(ad)
yield ad
true
end
end
end
|
ruby
|
{
"resource": ""
}
|
q2709
|
Rapinoe.Keynote.aspect_ratio
|
train
|
def aspect_ratio
path = "/tmp/rapinoe-aspect"
write_preview_to_file(path)
dimensions = FastImage.size(path)
widescreen = (16/9.0)
if widescreen == (dimensions[0] / dimensions[1].to_f)
:widescreen
else
:standard
end
end
|
ruby
|
{
"resource": ""
}
|
q2710
|
Rapinoe.Keynote.colors
|
train
|
def colors
return @colors if @colors
path = "/tmp/rapinoe-aspect"
write_preview_to_file(path)
colors = Miro::DominantColors.new(path)
by_percentage = colors.by_percentage
hash = {}
colors.to_rgb.each_with_index do |hex, i|
hash[hex] = by_percentage[i]
end
@colors = hash
end
|
ruby
|
{
"resource": ""
}
|
q2711
|
XCRes::XCAssets.ResourceImage.read
|
train
|
def read(hash)
self.scale = hash.delete('scale').sub(/x$/, '').to_i unless hash['scale'].nil?
KNOWN_KEYS.each do |key|
value = hash.delete(key.to_s.dasherize)
next if value.nil?
self.send "#{key}=".to_sym, value
end
self.attributes = hash
return self
end
|
ruby
|
{
"resource": ""
}
|
q2712
|
XCRes::XCAssets.ResourceImage.to_hash
|
train
|
def to_hash
hash = {}
hash['scale'] = "#{scale}x" unless scale.nil?
(KNOWN_KEYS - [:scale]).each do |key|
value = self.send(key)
hash[key.to_s.dasherize] = value.to_s unless value.nil?
end
attributes.each do |key, value|
hash[key.to_s] = value
end
hash
end
|
ruby
|
{
"resource": ""
}
|
q2713
|
XCRes.AggregateAnalyzer.add_with_class
|
train
|
def add_with_class(analyzer_class, options={})
analyzer = analyzer_class.new(target, self.options.merge(options))
analyzer.exclude_file_patterns = exclude_file_patterns
analyzer.logger = logger
self.analyzers << analyzer
analyzer
end
|
ruby
|
{
"resource": ""
}
|
q2714
|
Lieu.Request.post
|
train
|
def post(path, options={})
response = request(:post, path, options)
response.delete(:status) if response.respond_to?(:status)
response
end
|
ruby
|
{
"resource": ""
}
|
q2715
|
MongoidShortener.ShortenedUrlsHelper.shortened_url
|
train
|
def shortened_url(url)
raise "Only String accepted: #{url}" unless url.class == String
short_url = MongoidShortener::ShortenedUrl.generate(url)
short_url
end
|
ruby
|
{
"resource": ""
}
|
q2716
|
ActsAsFerret.LocalIndex.ferret_index
|
train
|
def ferret_index
ensure_index_exists
(@ferret_index ||= Ferret::Index::Index.new(index_definition[:ferret])).tap do |idx|
idx.batch_size = index_definition[:reindex_batch_size]
idx.logger = logger
end
end
|
ruby
|
{
"resource": ""
}
|
q2717
|
ActsAsFerret.LocalIndex.rebuild_index
|
train
|
def rebuild_index
models = index_definition[:registered_models]
logger.debug "rebuild index with models: #{models.inspect}"
close
index = Ferret::Index::Index.new(index_definition[:ferret].dup.update(:auto_flush => false,
:field_infos => ActsAsFerret::field_infos(index_definition),
:create => true))
index.batch_size = index_definition[:reindex_batch_size]
index.logger = logger
index.index_models models
reopen!
end
|
ruby
|
{
"resource": ""
}
|
q2718
|
ActsAsFerret.LocalIndex.process_query
|
train
|
def process_query(query, options = {})
return query unless String === query
ferret_index.synchronize do
if options[:analyzer]
# use per-query analyzer if present
qp = Ferret::QueryParser.new ferret_index.instance_variable_get('@options').merge(options)
reader = ferret_index.reader
qp.fields =
reader.fields unless options[:all_fields] || options[:fields]
qp.tokenized_fields =
reader.tokenized_fields unless options[:tokenized_fields]
return qp.parse query
else
return ferret_index.process_query(query)
end
end
end
|
ruby
|
{
"resource": ""
}
|
q2719
|
ActsAsFerret.LocalIndex.total_hits
|
train
|
def total_hits(query, options = {})
ferret_index.search(process_query(query, options), options).total_hits
end
|
ruby
|
{
"resource": ""
}
|
q2720
|
ActsAsFerret.LocalIndex.highlight
|
train
|
def highlight(key, query, options = {})
logger.debug("highlight: #{key} query: #{query}")
options.reverse_merge! :num_excerpts => 2, :pre_tag => '<em>', :post_tag => '</em>'
highlights = []
ferret_index.synchronize do
doc_num = document_number(key)
if options[:field]
highlights << ferret_index.highlight(query, doc_num, options)
else
query = process_query(query) # process only once
index_definition[:ferret_fields].each_pair do |field, config|
next if config[:store] == :no || config[:highlight] == :no
options[:field] = field
highlights << ferret_index.highlight(query, doc_num, options)
end
end
end
return highlights.compact.flatten[0..options[:num_excerpts]-1]
end
|
ruby
|
{
"resource": ""
}
|
q2721
|
ActsAsFerret.LocalIndex.document_number
|
train
|
def document_number(key)
docnum = ferret_index.doc_number(key)
# hits = ferret_index.search query_for_record(key)
# return hits.hits.first.doc if hits.total_hits == 1
raise "cannot determine document number for record #{key}" if docnum.nil?
docnum
end
|
ruby
|
{
"resource": ""
}
|
q2722
|
SocialMedia::Service.Facebook.get_app_access_token
|
train
|
def get_app_access_token
return connection_params[:app_access_token] if connection_params.has_key? :app_access_token
@oauth = Koala::Facebook::OAuth.new(connection_params[:app_id], connection_params[:app_secret], callback_url)
connection_params[:app_access_token] = @oauth.get_app_access_token
end
|
ruby
|
{
"resource": ""
}
|
q2723
|
ESP.Suppression.regions
|
train
|
def regions
# When regions come back in an include, the method still gets called, to return the object from the attributes.
return attributes['regions'] if attributes['regions'].present?
return [] unless respond_to? :region_ids
ESP::Region.where(id_in: region_ids)
end
|
ruby
|
{
"resource": ""
}
|
q2724
|
ESP.Suppression.external_accounts
|
train
|
def external_accounts
# When external_accounts come back in an include, the method still gets called, to return the object from the attributes.
return attributes['external_accounts'] if attributes['external_accounts'].present?
return [] unless respond_to? :external_account_ids
ESP::ExternalAccount.where(id_in: external_account_ids)
end
|
ruby
|
{
"resource": ""
}
|
q2725
|
ESP.Suppression.signatures
|
train
|
def signatures
# When signatures come back in an include, the method still gets called, to return the object from the attributes.
return attributes['signatures'] if attributes['signatures'].present?
return [] unless respond_to? :signature_ids
ESP::Signature.where(id_in: signature_ids)
end
|
ruby
|
{
"resource": ""
}
|
q2726
|
ESP.Suppression.custom_signatures
|
train
|
def custom_signatures
# When custom_signatures come back in an include, the method still gets called, to return the object from the attributes.
return attributes['custom_signatures'] if attributes['custom_signatures'].present?
return [] unless respond_to? :custom_signature_ids
ESP::CustomSignature.where(id_in: custom_signature_ids)
end
|
ruby
|
{
"resource": ""
}
|
q2727
|
ESP.Region.suppress
|
train
|
def suppress(arguments = {})
arguments = arguments.with_indifferent_access
ESP::Suppression::Region.create(regions: [code], external_account_ids: Array(arguments[:external_account_ids]), reason: arguments[:reason])
end
|
ruby
|
{
"resource": ""
}
|
q2728
|
Tolaria.HelpLink.validate!
|
train
|
def validate!
if title.blank?
raise RuntimeError, "HelpLinks must provide a string title"
end
file_configured = (slug.present? && markdown_file.present?)
link_configured = link_to.present?
unless file_configured || link_configured
raise RuntimeError, "Incomplete HelpLink config. You must provide link_to, or both slug and markdown_file."
end
if file_configured && link_configured
raise RuntimeError, "Ambiguous HelpLink config. You must provide link_to, or both slug and markdown_file, but not all three."
end
end
|
ruby
|
{
"resource": ""
}
|
q2729
|
Jabber.Bot.presence
|
train
|
def presence(presence=nil, status=nil, priority=nil)
@config[:presence] = presence
@config[:status] = status
@config[:priority] = priority
status_message = Presence.new(presence, status, priority)
@jabber.send!(status_message) if @jabber.connected?
end
|
ruby
|
{
"resource": ""
}
|
q2730
|
Jabber.Bot.add_command_alias
|
train
|
def add_command_alias(command_name, alias_command, callback) #:nodoc:
original_command = @commands[:meta][command_name]
original_command[:syntax] << alias_command[:syntax]
alias_name = command_name(alias_command[:syntax])
alias_command[:is_public] = original_command[:is_public]
add_command_meta(alias_name, original_command, true)
add_command_spec(alias_command, callback)
end
|
ruby
|
{
"resource": ""
}
|
q2731
|
Jabber.Bot.add_command_meta
|
train
|
def add_command_meta(name, command, is_alias=false) #:nodoc:
syntax = command[:syntax]
@commands[:meta][name] = {
:syntax => syntax.is_a?(Array) ? syntax : [syntax],
:description => command[:description],
:is_public => command[:is_public] || false,
:is_alias => is_alias
}
end
|
ruby
|
{
"resource": ""
}
|
q2732
|
Jabber.Bot.help_message
|
train
|
def help_message(sender, command_name) #:nodoc:
if command_name.nil? || command_name.length == 0
# Display help for all commands
help_message = "I understand the following commands:\n\n"
@commands[:meta].sort.each do |command|
# Thank you, Hash.sort
command = command[1]
if !command[:is_alias] && (command[:is_public] || master?(sender))
command[:syntax].each { |syntax| help_message += "#{syntax}\n" }
help_message += " #{command[:description]}\n\n"
end
end
else
# Display help for the given command
command = @commands[:meta][command_name]
if command.nil?
help_message = "I don't understand '#{command_name}' Try saying" +
" 'help' to see what commands I understand."
else
help_message = ''
command[:syntax].each { |syntax| help_message += "#{syntax}\n" }
help_message += " #{command[:description]} "
end
end
help_message
end
|
ruby
|
{
"resource": ""
}
|
q2733
|
Jabber.Bot.start_listener_thread
|
train
|
def start_listener_thread #:nodoc:
listener_thread = Thread.new do
loop do
if @jabber.received_messages?
@jabber.received_messages do |message|
# Remove the Jabber resourse, if any
sender = message.from.to_s.sub(/\/.+$/, '')
if message.type == :chat
parse_thread = Thread.new do
parse_command(sender, message.body)
end
parse_thread.join
end
end
end
sleep 1
end
end
listener_thread.join
end
|
ruby
|
{
"resource": ""
}
|
q2734
|
EPP.Server.prepare_request
|
train
|
def prepare_request(command, extension = nil)
cmd = EPP::Requests::Command.new(req_tid, command, extension)
EPP::Request.new(cmd)
end
|
ruby
|
{
"resource": ""
}
|
q2735
|
EPP.Server.connection
|
train
|
def connection
@connection_errors = []
addrinfo.each do |_,port,_,addr,_,_,_|
retried = false
begin
@conn = TCPSocket.new(addr, port)
rescue Errno::EINVAL => e
if retried
message = e.message.split(" - ")[1]
@connection_errors << Errno::EINVAL.new(
"#{message}: TCPSocket.new(#{addr.inspect}, #{port.inspect})")
next
end
retried = true
retry
end
args = [@conn]
args << options[:ssl_context] if options[:ssl_context]
@sock = OpenSSL::SSL::SSLSocket.new(*args)
@sock.sync_close = true
begin
@sock.connect
@greeting = recv_frame # Perform initial recv
return yield
rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH => e
@connection_errors << e
next # try the next address in the list
rescue OpenSSL::SSL::SSLError => e
# Connection error, most likely the IP isn't in the allow list
if e.message =~ /returned=5 errno=0/
@connection_errors << ConnectionError.new("SSL Connection error, IP may not be permitted to connect to #{@host}",
@conn.addr, @conn.peeraddr, e)
next
else
raise e
end
ensure
@sock.close # closes @conn
@conn = @sock = nil
end
end
# Should only get here if we didn't return from the block above
addrinfo(true) # Update our addrinfo in case the DNS has changed
raise @connection_errors.last unless @connection_errors.empty?
raise Errno::EHOSTUNREACH, "Failed to connect to host #{@host}"
end
|
ruby
|
{
"resource": ""
}
|
q2736
|
EPP.Server.send_frame
|
train
|
def send_frame(xml)
xml = xml.to_s if xml.kind_of?(Request)
@sock.write([xml.size + HEADER_LEN].pack("N") + xml)
end
|
ruby
|
{
"resource": ""
}
|
q2737
|
EPP.Server.recv_frame
|
train
|
def recv_frame
header = @sock.read(HEADER_LEN)
if header.nil? && @sock.eof?
raise ServerError, "Connection terminated by remote host"
elsif header.nil?
raise ServerError, "Failed to read header from remote host"
else
len = header.unpack('N')[0]
raise ServerError, "Bad frame header from server, should be greater than #{HEADER_LEN}" unless len > HEADER_LEN
@sock.read(len - HEADER_LEN)
end
end
|
ruby
|
{
"resource": ""
}
|
q2738
|
Tolaria.MarkdownRendererProxy.render
|
train
|
def render(document)
if Tolaria.config.markdown_renderer.nil?
return simple_format(document)
else
@markdown_renderer ||= Tolaria.config.markdown_renderer.constantize
return @markdown_renderer.render(document)
end
end
|
ruby
|
{
"resource": ""
}
|
q2739
|
ProblemChild.Helpers.base_sha
|
train
|
def base_sha
default_branch = client.repo(repo)[:default_branch]
branches.find { |branch| branch[:name] == default_branch }[:commit][:sha]
end
|
ruby
|
{
"resource": ""
}
|
q2740
|
ProblemChild.Helpers.patch_branch
|
train
|
def patch_branch
num = 1
branch_name = form_data['title'].parameterize
return branch_name unless branch_exists?(branch_name)
branch = "#{branch_name}-#{num}"
while branch_exists?(branch)
num += 1
branch = "#{branch_name}-#{num}"
end
branch
end
|
ruby
|
{
"resource": ""
}
|
q2741
|
ProblemChild.Helpers.create_pull_request
|
train
|
def create_pull_request
unless uploads.empty?
branch = patch_branch
create_branch(branch)
uploads.each do |key, upload|
client.create_contents(
repo,
upload[:filename],
"Create #{upload[:filename]}",
branch: branch,
file: upload[:tempfile]
)
session["file_#{key}"] = nil
end
end
pr = client.create_pull_request(repo, 'master', branch, form_data['title'], issue_body, labels: labels)
pr['number'] if pr
end
|
ruby
|
{
"resource": ""
}
|
q2742
|
Runfile.ExecHandler.run
|
train
|
def run(cmd)
cmd = @before_run_block.call(cmd) if @before_run_block
return false unless cmd
say "!txtgrn!> #{cmd}" unless Runfile.quiet
system cmd
@after_run_block.call(cmd) if @after_run_block
end
|
ruby
|
{
"resource": ""
}
|
q2743
|
Runfile.ExecHandler.run!
|
train
|
def run!(cmd)
cmd = @before_run_block.call(cmd) if @before_run_block
return false unless cmd
say "!txtgrn!> #{cmd}" unless Runfile.quiet
exec cmd
end
|
ruby
|
{
"resource": ""
}
|
q2744
|
Runfile.ExecHandler.run_bg
|
train
|
def run_bg(cmd, pid: nil, log: '/dev/null')
cmd = @before_run_block.call(cmd) if @before_run_block
return false unless cmd
full_cmd = "exec #{cmd} >#{log} 2>&1"
say "!txtgrn!> #{full_cmd}" unless Runfile.quiet
process = IO.popen "exec #{cmd} >#{log} 2>&1"
File.write pidfile(pid), process.pid if pid
@after_run_block.call(cmd) if @after_run_block
return process.pid
end
|
ruby
|
{
"resource": ""
}
|
q2745
|
Runfile.ExecHandler.stop_bg
|
train
|
def stop_bg(pid)
file = pidfile(pid)
if File.exist? file
pid = File.read file
File.delete file
run "kill -s TERM #{pid}"
else
say "!txtred!PID file not found." unless Runfile.quiet
end
end
|
ruby
|
{
"resource": ""
}
|
q2746
|
ESP.Console.start
|
train
|
def start # rubocop:disable Metrics/MethodLength
ARGV.clear
IRB.setup nil
IRB.conf[:PROMPT] = {}
IRB.conf[:IRB_NAME] = 'espsdk'
IRB.conf[:PROMPT][:ESPSDK] = {
PROMPT_I: '%N:%03n:%i> ',
PROMPT_N: '%N:%03n:%i> ',
PROMPT_S: '%N:%03n:%i%l ',
PROMPT_C: '%N:%03n:%i* ',
RETURN: "# => %s\n"
}
IRB.conf[:PROMPT_MODE] = :ESPSDK
IRB.conf[:RC] = false
require 'irb/completion'
require 'irb/ext/save-history'
IRB.conf[:READLINE] = true
IRB.conf[:SAVE_HISTORY] = 1000
IRB.conf[:HISTORY_FILE] = '~/.esp_sdk_history'
context = Class.new do
include ESP
end
irb = IRB::Irb.new(IRB::WorkSpace.new(context.new))
IRB.conf[:MAIN_CONTEXT] = irb.context
trap("SIGINT") do
irb.signal_handle
end
begin
catch(:IRB_EXIT) do
irb.eval_input
end
ensure
IRB.irb_at_exit
end
end
|
ruby
|
{
"resource": ""
}
|
q2747
|
EPP.XMLHelpers.epp_namespace
|
train
|
def epp_namespace(node, name = nil, namespaces = {})
return namespaces['epp'] if namespaces.has_key?('epp')
xml_namespace(node, name, 'urn:ietf:params:xml:ns:epp-1.0')
end
|
ruby
|
{
"resource": ""
}
|
q2748
|
EPP.XMLHelpers.epp_node
|
train
|
def epp_node(name, value = nil, namespaces = {})
value, namespaces = nil, value if value.kind_of?(Hash)
node = xml_node(name, value)
node.namespaces.namespace = epp_namespace(node, nil, namespaces)
node
end
|
ruby
|
{
"resource": ""
}
|
q2749
|
EPP.XMLHelpers.xml_namespace
|
train
|
def xml_namespace(node, name, uri, namespaces = {})
XML::Namespace.new(node, name, uri)
end
|
ruby
|
{
"resource": ""
}
|
q2750
|
EPP.XMLHelpers.xml_document
|
train
|
def xml_document(obj)
case obj
when XML::Document
XML::Document.document(obj)
else
XML::Document.new('1.0')
end
end
|
ruby
|
{
"resource": ""
}
|
q2751
|
Vanguard.DSL.method_missing
|
train
|
def method_missing(method_name, *arguments)
klass = REGISTRY.fetch(method_name) { super }
Evaluator.new(klass, arguments).rules.each do |rule|
add(rule)
end
self
end
|
ruby
|
{
"resource": ""
}
|
q2752
|
Cliqr.Interface.execute
|
train
|
def execute(args = [], **options)
execute_internal(args, options)
Executor::ExitCode.code(:success)
rescue Cliqr::Error::CliqrError => e
puts e.message
Executor::ExitCode.code(e)
end
|
ruby
|
{
"resource": ""
}
|
q2753
|
Cliqr.Interface.execute_internal
|
train
|
def execute_internal(args = [], **options)
options = {
output: :default,
environment: :cli
}.merge(options)
@runner.execute(args, options)
end
|
ruby
|
{
"resource": ""
}
|
q2754
|
Cliqr.InterfaceBuilder.build
|
train
|
def build
raise Cliqr::Error::ConfigNotFound, 'a valid config should be defined' if @config.nil?
unless @config.valid?
raise Cliqr::Error::ValidationError, \
"invalid Cliqr interface configuration - [#{@config.errors}]"
end
Interface.new(@config)
end
|
ruby
|
{
"resource": ""
}
|
q2755
|
Runfile.Runner.execute
|
train
|
def execute(argv, filename='Runfile')
@ignore_settings = !filename
argv = expand_shortcuts argv
filename and File.file?(filename) or handle_no_runfile argv
begin
load settings.helper if settings.helper
load filename
rescue => ex
abort "Runfile error:\n#{ex.message}\n#{ex.backtrace[0]}"
end
run(*argv)
end
|
ruby
|
{
"resource": ""
}
|
q2756
|
Runfile.Runner.add_action
|
train
|
def add_action(name, altname=nil, &block)
if @last_usage.nil?
@last_usage = altname ? "(#{name}|#{altname})" : name
end
[@namespace, @superspace].each do |prefix|
prefix or next
name = "#{prefix}_#{name}"
@last_usage = "#{prefix} #{last_usage}" unless @last_usage == false
end
name = name.to_sym
@actions[name] = Action.new(block, @last_usage, @last_help)
@last_usage = nil
@last_help = nil
if altname
@last_usage = false
add_action(altname, nil, &block)
end
end
|
ruby
|
{
"resource": ""
}
|
q2757
|
Runfile.Runner.add_option
|
train
|
def add_option(flag, text, scope=nil)
scope or scope = 'Options'
@options[scope] ||= {}
@options[scope][flag] = text
end
|
ruby
|
{
"resource": ""
}
|
q2758
|
Runfile.Runner.add_param
|
train
|
def add_param(name, text, scope=nil)
scope or scope = 'Parameters'
@params[scope] ||= {}
@params[scope][name] = text
end
|
ruby
|
{
"resource": ""
}
|
q2759
|
Runfile.Runner.run
|
train
|
def run(*argv)
begin
docopt_exec argv
rescue Docopt::Exit => ex
puts ex.message
exit 2
end
end
|
ruby
|
{
"resource": ""
}
|
q2760
|
ActiveResource.Validations.load_remote_errors
|
train
|
def load_remote_errors(remote_errors, save_cache = false)
if self.class.format == ActiveResource::Formats::JsonAPIFormat
errors.from_json_api(remote_errors.response.body, save_cache)
elsif self.class.format == ActiveResource::Formats[:json]
super
end
end
|
ruby
|
{
"resource": ""
}
|
q2761
|
Slugalicious.ClassMethods.find_from_slug_path
|
train
|
def find_from_slug_path(path)
slug = path.split('/').last
scope = path[0..(-(slug.size + 1))]
find_from_slug slug, scope
end
|
ruby
|
{
"resource": ""
}
|
q2762
|
Oxblood.Pipeline.sync
|
train
|
def sync
serialized_commands = @commands.map { |c| Protocol.build_command(*c) }
connection.socket.write(serialized_commands.join)
Array.new(@commands.size) { connection.read_response }
ensure
@commands.clear
end
|
ruby
|
{
"resource": ""
}
|
q2763
|
LonoCfn.Base.get_source_path
|
train
|
def get_source_path(path, type)
default_convention_path = convention_path(@stack_name, type)
return default_convention_path if path.nil?
# convention path based on the input from the user
convention_path(path, type)
end
|
ruby
|
{
"resource": ""
}
|
q2764
|
LonoCfn.Base.detect_format
|
train
|
def detect_format
formats = Dir.glob("#{@project_root}/output/**/*").map { |path| path }.
reject { |s| s =~ %r{/params/} }. # reject output/params folder
map { |path| File.extname(path) }.
reject { |s| s.empty? }. # reject ""
uniq
if formats.size > 1
puts "ERROR: Detected multiple formats: #{formats.join(", ")}".colorize(:red)
puts "All the output files must use the same format. Either all json or all yml."
exit 1
else
formats.first.sub(/^\./,'')
end
end
|
ruby
|
{
"resource": ""
}
|
q2765
|
ActiveResource.PaginatedCollection.page
|
train
|
def page(page_number = nil)
fail ArgumentError, "You must supply a page number." unless page_number.present?
fail ArgumentError, "Page number cannot be less than 1." if page_number.to_i < 1
fail ArgumentError, "Page number cannot be greater than the last page number." if page_number.to_i > last_page_number.to_i
page_number.to_i != current_page_number.to_i ? updated_collection(from: from, page: { number: page_number, size: (next_page_params || previous_page_params)['page']['size'] }) : self
end
|
ruby
|
{
"resource": ""
}
|
q2766
|
Runfile.RunfileHelper.make_runfile
|
train
|
def make_runfile(name=nil)
name = 'Runfile' if name.nil?
template = File.expand_path("../templates/Runfile", __FILE__)
name += ".runfile" unless name == 'Runfile'
dest = "#{Dir.pwd}/#{name}"
begin
File.write(dest, File.read(template))
puts "#{name} created."
rescue => e
abort "Failed creating #{name}\n#{e.message}"
end
end
|
ruby
|
{
"resource": ""
}
|
q2767
|
Runfile.RunfileHelper.show_make_help
|
train
|
def show_make_help(runfiles, compact=false)
say "!txtpur!Runfile engine v#{Runfile::VERSION}" unless compact
if runfiles.size < 3 and !compact
say "\nTip: Type '!txtblu!run new!txtrst!' or '!txtblu!run new name!txtrst!' to create a runfile.\nFor global access, place !txtblu!named.runfiles!txtrst! in ~/runfile/ or in /etc/runfile/."
end
if runfiles.empty?
say "\n!txtred!Runfile not found."
else
say ""
compact ? say_runfile_usage(runfiles) : say_runfile_list(runfiles)
end
end
|
ruby
|
{
"resource": ""
}
|
q2768
|
Runfile.RunfileHelper.say_runfile_list
|
train
|
def say_runfile_list(runfiles)
runfile_paths = runfiles.map { |f| File.dirname f }
max = runfile_paths.max_by(&:length).size
width = detect_terminal_size[0]
runfiles.each do |f|
f[/([^\/]+).runfile$/]
command = "run #{$1}"
spacer_size = width - max - command.size - 6
spacer_size = [1, spacer_size].max
spacer = '.' * spacer_size
say " !txtgrn!#{command}!txtrst! #{spacer} #{File.dirname f}"
end
end
|
ruby
|
{
"resource": ""
}
|
q2769
|
Runfile.RunfileHelper.say_runfile_usage
|
train
|
def say_runfile_usage(runfiles)
runfiles_as_columns = get_runfiles_as_columns runfiles
say "#{settings.intro}\n" if settings.intro
say "Usage: run <file>"
say runfiles_as_columns
show_shortcuts if settings.shortcuts
end
|
ruby
|
{
"resource": ""
}
|
q2770
|
Runfile.RunfileHelper.show_shortcuts
|
train
|
def show_shortcuts
say "\nShortcuts:"
max = settings.shortcuts.keys.max_by(&:length).length
settings.shortcuts.each_pair do |shortcut, command|
say " #{shortcut.rjust max} : #{command}"
end
end
|
ruby
|
{
"resource": ""
}
|
q2771
|
Runfile.RunfileHelper.get_runfiles_as_columns
|
train
|
def get_runfiles_as_columns(runfiles)
namelist = runfile_names runfiles
width = detect_terminal_size[0]
max = namelist.max_by(&:length).length
message = " " + namelist.map {|f| f.ljust max+1 }.join(' ')
word_wrap message, width
end
|
ruby
|
{
"resource": ""
}
|
q2772
|
ESP.Resource.serializable_hash
|
train
|
def serializable_hash(*)
h = attributes.extract!('included')
h['data'] = { 'type' => self.class.to_s.underscore.sub('esp/', '').pluralize,
'attributes' => changed_attributes.except('id', 'type', 'created_at', 'updated_at', 'relationships') }
h['data']['id'] = id if id.present?
h
end
|
ruby
|
{
"resource": ""
}
|
q2773
|
Oxblood.Pool.with
|
train
|
def with
conn = @pool.checkout
session = Session.new(conn)
yield(session)
ensure
if conn
session.discard if conn.in_transaction?
@pool.checkin
end
end
|
ruby
|
{
"resource": ""
}
|
q2774
|
Runfile.DocoptHelper.docopt_usage
|
train
|
def docopt_usage
doc = ["\nUsage:"];
@actions.each do |_name, action|
doc << " run #{action.usage}" unless action.usage == false
end
basic_flags = @version ? "(-h|--help|--version)" : "(-h|--help)"
if @superspace
doc << " run #{@superspace} #{basic_flags}\n"
else
doc << " run #{basic_flags}\n"
end
doc
end
|
ruby
|
{
"resource": ""
}
|
q2775
|
Runfile.DocoptHelper.docopt_commands
|
train
|
def docopt_commands(width)
doc = []
caption_printed = false
@actions.each do |_name, action|
action.help or next
doc << "Commands:" unless caption_printed
caption_printed = true
helpline = " #{action.help}"
wrapped = word_wrap helpline, width
doc << " #{action.usage}\n#{wrapped}\n" unless action.usage == false
end
doc
end
|
ruby
|
{
"resource": ""
}
|
q2776
|
Runfile.DocoptHelper.docopt_examples
|
train
|
def docopt_examples(width)
return [] if @examples.empty?
doc = ["Examples:"]
base_command = @superspace ? "run #{@superspace}" : "run"
@examples.each do |command|
helpline = " #{base_command} #{command}"
wrapped = word_wrap helpline, width
doc << "#{wrapped}"
end
doc
end
|
ruby
|
{
"resource": ""
}
|
q2777
|
Tolaria.FormBuildable.hint
|
train
|
def hint(hint_text, options = {})
css_class = "hint #{options.delete(:class)}"
content_tag(:p, content_tag(:span, hint_text.chomp), class:css_class, **options)
end
|
ruby
|
{
"resource": ""
}
|
q2778
|
Tolaria.FormBuildable.image_association_select
|
train
|
def image_association_select(method, collection, value_method, text_method, preview_url_method, options = {})
render(partial:"admin/shared/forms/image_association_select", locals: {
f: self,
method: method,
collection: collection,
value_method: value_method,
text_method: text_method,
preview_url_method: preview_url_method,
options: options,
html_options: options,
})
end
|
ruby
|
{
"resource": ""
}
|
q2779
|
Tolaria.FormBuildable.markdown_composer
|
train
|
def markdown_composer(method, options = {})
render(partial:"admin/shared/forms/markdown_composer", locals: {
f: self,
method: method,
options: options,
})
end
|
ruby
|
{
"resource": ""
}
|
q2780
|
Tolaria.FormBuildable.attachment_field
|
train
|
def attachment_field(method, options = {})
render(partial:"admin/shared/forms/attachment_field", locals: {
f: self,
method: method,
options: options,
})
end
|
ruby
|
{
"resource": ""
}
|
q2781
|
Tolaria.FormBuildable.image_field
|
train
|
def image_field(method, options = {})
render(partial:"admin/shared/forms/image_field", locals: {
f: self,
method: method,
options: options,
preview_url: options[:preview_url]
})
end
|
ruby
|
{
"resource": ""
}
|
q2782
|
Tolaria.FormBuildable.timestamp_field
|
train
|
def timestamp_field(method, options = {})
render(partial:"admin/shared/forms/timestamp_field", locals: {
f: self,
method: method,
options: options,
})
end
|
ruby
|
{
"resource": ""
}
|
q2783
|
Tolaria.FormBuildable.slug_field
|
train
|
def slug_field(method, options = {})
pattern = options.delete(:pattern)
preview_value = self.object.send(method).try(:parameterize).presence || "*"
render(partial:"admin/shared/forms/slug_field", locals: {
f: self,
method: method,
options: options,
preview_value: preview_value,
pattern: (pattern || "/blog-example/*")
})
end
|
ruby
|
{
"resource": ""
}
|
q2784
|
Tolaria.FormBuildable.swatch_field
|
train
|
def swatch_field(method, options = {})
render(partial:"admin/shared/forms/swatch_field", locals: {
f: self,
method: method,
options: options,
})
end
|
ruby
|
{
"resource": ""
}
|
q2785
|
Oxblood.RSocket.gets
|
train
|
def gets(separator, timeout = @timeout)
while (crlf = @buffer.index(separator)).nil?
@buffer << readpartial(1024, timeout)
end
@buffer.slice!(0, crlf + separator.bytesize)
end
|
ruby
|
{
"resource": ""
}
|
q2786
|
Oxblood.RSocket.write
|
train
|
def write(data, timeout = @timeout)
full_size = data.bytesize
while data.bytesize > 0
written = socket.write_nonblock(data, exception: false)
if written == :wait_writable
socket.wait_writable(timeout) or fail_with_timeout!
else
data = data.byteslice(written..-1)
end
end
full_size
end
|
ruby
|
{
"resource": ""
}
|
q2787
|
Laundry.SOAPModel.instance_action_module
|
train
|
def instance_action_module
@instance_action_module ||= Module.new do
# Returns the <tt>Savon::Client</tt> from the class instance.
def client(&block)
self.class.client(&block)
end
private
def merged_default_body(body = {})
default = self.respond_to?(:default_body) ? self.default_body : nil
(default || {}).merge (body || {})
end
end.tap { |mod| include(mod) }
end
|
ruby
|
{
"resource": ""
}
|
q2788
|
Vanguard.Result.violations
|
train
|
def violations
validator.rules.each_with_object(Set.new) do |rule, violations|
violations.merge(rule.violations(resource))
end
end
|
ruby
|
{
"resource": ""
}
|
q2789
|
RFuse.Fuse.run
|
train
|
def run(signals=Signal.list.keys)
if mounted?
begin
traps = trap_signals(*signals)
self.loop()
ensure
traps.each { |t| Signal.trap(t,"DEFAULT") }
unmount()
end
end
end
|
ruby
|
{
"resource": ""
}
|
q2790
|
RFuse.Fuse.loop
|
train
|
def loop()
raise RFuse::Error, "Already running!" if @running
raise RFuse::Error, "FUSE not mounted" unless mounted?
@running = true
while @running do
begin
ready, ignore, errors = IO.select([@fuse_io,@pr],[],[@fuse_io])
if ready.include?(@pr)
signo = @pr.read_nonblock(1).unpack("c")[0]
# Signal.signame exist in Ruby 2, but returns horrible errors for non-signals in 2.1.0
if (signame = Signal.list.invert[signo])
call_sigmethod(sigmethod(signame))
end
elsif errors.include?(@fuse_io)
@running = false
raise RFuse::Error, "FUSE error"
elsif ready.include?(@fuse_io)
if process() < 0
# Fuse has been unmounted externally
# TODO: mounted? should now return false
# fuse_exited? is not true...
@running = false
end
end
rescue Errno::EWOULDBLOCK, Errno::EAGAIN
#oh well...
end
end
end
|
ruby
|
{
"resource": ""
}
|
q2791
|
RFuse.FuseDelegator.debug=
|
train
|
def debug=(value)
value = value ? true : false
if @debug && !value
$stderr.puts "=== #{ self }.debug=false"
elsif !@debug && value
$stderr.puts "=== #{ self }.debug=true"
end
@debug = value
end
|
ruby
|
{
"resource": ""
}
|
q2792
|
Watir.Element.dom_changed?
|
train
|
def dom_changed?(delay: 1.1)
element_call do
begin
driver.manage.timeouts.script_timeout = delay + 1
driver.execute_async_script(DOM_WAIT_JS, wd, delay)
rescue Selenium::WebDriver::Error::JavascriptError => error
# sometimes we start script execution before new page is loaded and
# in rare cases ChromeDriver throws this error, we just swallow it and retry
retry if error.message.include?('document unloaded while waiting for result')
raise
ensure
# TODO: make sure we rollback to user-defined timeout
# blocked by https://github.com/seleniumhq/selenium-google-code-issue-archive/issues/6608
driver.manage.timeouts.script_timeout = 1
end
end
end
|
ruby
|
{
"resource": ""
}
|
q2793
|
ESP.Signature.run!
|
train
|
def run!(arguments = {})
result = run(arguments)
return result if result.is_a?(ActiveResource::Collection)
result.message = result.errors.full_messages.join(' ')
fail(ActiveResource::ResourceInvalid.new(result)) # rubocop:disable Style/RaiseArgs
end
|
ruby
|
{
"resource": ""
}
|
q2794
|
ESP.Signature.run
|
train
|
def run(arguments = {})
arguments = arguments.with_indifferent_access
attributes['external_account_id'] ||= arguments[:external_account_id]
attributes['region'] ||= arguments[:region]
response = connection.post("#{self.class.prefix}signatures/#{id}/run.json", to_json)
ESP::Alert.send(:instantiate_collection, self.class.format.decode(response.body))
rescue ActiveResource::BadRequest, ActiveResource::ResourceInvalid, ActiveResource::ResourceNotFound => error
load_remote_errors(error, true)
self.code = error.response.code
self
end
|
ruby
|
{
"resource": ""
}
|
q2795
|
ESP.Signature.suppress
|
train
|
def suppress(arguments = {})
arguments = arguments.with_indifferent_access
ESP::Suppression::Signature.create(signature_ids: [id], regions: Array(arguments[:regions]), external_account_ids: Array(arguments[:external_account_ids]), reason: arguments[:reason])
end
|
ruby
|
{
"resource": ""
}
|
q2796
|
TableSetter.Table.csv_data
|
train
|
def csv_data
case
when google_key || url then Curl::Easy.perform(uri).body_str
when file then File.open(uri).read
end
end
|
ruby
|
{
"resource": ""
}
|
q2797
|
TableSetter.Table.updated_at
|
train
|
def updated_at
csv_time = google_key.nil? ? modification_time(uri) : google_modification_time
(csv_time > yaml_time ? csv_time : yaml_time).to_s
end
|
ruby
|
{
"resource": ""
}
|
q2798
|
TableSetter.Table.paginate!
|
train
|
def paginate!(curr_page)
return if !hard_paginate?
@page = curr_page.to_i
raise ArgumentError if @page < 1 || @page > total_pages
adj_page = @page - 1 > 0 ? @page - 1 : 0
@prev_page = adj_page > 0 ? adj_page : nil
@next_page = page < total_pages ? (@page + 1) : nil
@data.only!(adj_page * per_page..(@page * per_page - 1))
end
|
ruby
|
{
"resource": ""
}
|
q2799
|
TableSetter.Table.sort_array
|
train
|
def sort_array
if @data.sorted_by
@data.sorted_by.inject([]) do |memo, (key, value)|
memo << [@data.columns.index(key), value == 'descending' ? 1 : 0]
end
end
end
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.