_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q24800 | TeaLeaves.MovingAverage.check_weights | train | def check_weights
raise ArgumentError.new("Weights should be an odd list") unless @span.odd?
sum = weights.inject(&:+)
if sum < 0.999999 || sum > 1.000001
raise ArgumentError.new("Weights must sum to 1")
end
end | ruby | {
"resource": ""
} |
q24801 | MediaWiki.Purge.purge_request | train | def purge_request(params, *titles)
params[:action] = 'purge'
params[:titles] = titles.join('|')
post(params)['purge'].inject({}) do |result, hash|
title = hash['title']
result[title] = hash.key?('purged') && !hash.key?('missing')
warn "Invalid purge (#{title}) #{hash['invalidreason']}" if hash.key?('invalid')
result
end
end | ruby | {
"resource": ""
} |
q24802 | Spice.Config.reset | train | def reset
self.user_agent = DEFAULT_USER_AGENT
self.server_url = DEFAULT_SERVER_URL
self.chef_version = DEFAULT_CHEF_VERSION
self.client_name = DEFAULT_CLIENT_NAME
self.client_key = DEFAULT_CLIENT_KEY
self.connection_options = DEFAULT_CONNECTION_OPTIONS
self.middleware = DEFAULT_MIDDLEWARE
self
end | ruby | {
"resource": ""
} |
q24803 | DataSift.Client.valid? | train | def valid?(csdl, boolResponse = true)
requires({ :csdl => csdl })
res = DataSift.request(:POST, 'validate', @config, :csdl => csdl )
boolResponse ? res[:http][:status] == 200 : res
end | ruby | {
"resource": ""
} |
q24804 | DataSift.Client.dpu | train | def dpu(hash = '', historics_id = '')
fail ArgumentError, 'Must pass a filter hash or Historics ID' if
hash.empty? && historics_id.empty?
fail ArgumentError, 'Must only pass hash or Historics ID; not both' unless
hash.empty? || historics_id.empty?
params = {}
params.merge!(hash: hash) unless hash.empty?
params.merge!(historics_id: historics_id) unless historics_id.empty?
DataSift.request(:POST, 'dpu', @config, params)
end | ruby | {
"resource": ""
} |
q24805 | Danger.DangerSynx.synx_issues | train | def synx_issues
(git.modified_files + git.added_files)
.select { |f| f.include? '.xcodeproj' }
.reduce([]) { |i, f| i + synx_project(f) }
end | ruby | {
"resource": ""
} |
q24806 | Teambition.API.valid_token? | train | def valid_token?
uri = URI.join(Teambition::API_DOMAIN, "/api/applications/#{Teambition.client_key}/tokens/check")
req = Net::HTTP::Get.new(uri)
req['Authorization'] = "OAuth2 #{token}"
res = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |https|
https.request(req)
end
res.code == '200'
end | ruby | {
"resource": ""
} |
q24807 | S3SwfUpload.Signature.core_sha1 | train | def core_sha1(x, len)
# append padding
x[len >> 5] ||= 0
x[len >> 5] |= 0x80 << (24 - len % 32)
x[((len + 64 >> 9) << 4) + 15] = len
w = Array.new(80, 0)
a = 1_732_584_193
b = -271_733_879
c = -1_732_584_194
d = 271_733_878
e = -1_009_589_776
# for(var i = 0; i < x.length; i += 16)
i = 0
while i < x.length
olda = a
oldb = b
oldc = c
oldd = d
olde = e
# for(var j = 0; j < 80; j++)
j = 0
while j < 80
if j < 16
w[j] = x[i + j] || 0
else
w[j] = rol(w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16], 1)
end
t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
safe_add(safe_add(e, w[j]), sha1_kt(j)))
e = d
d = c
c = rol(b, 30)
b = a
a = t
j += 1
end
a = safe_add(a, olda)
b = safe_add(b, oldb)
c = safe_add(c, oldc)
d = safe_add(d, oldd)
e = safe_add(e, olde)
i += 16
end
[a, b, c, d, e]
end | ruby | {
"resource": ""
} |
q24808 | S3SwfUpload.Signature.sha1_ft | train | def sha1_ft(t, b, c, d)
return (b & c) | ((~b) & d) if t < 20
return b ^ c ^ d if t < 40
return (b & c) | (b & d) | (c & d) if t < 60
b ^ c ^ d
end | ruby | {
"resource": ""
} |
q24809 | S3SwfUpload.Signature.core_hmac_sha1 | train | def core_hmac_sha1(key, data)
bkey = str2binb(key)
bkey = core_sha1(bkey, key.length * $chrsz) if bkey.length > 16
ipad = Array.new(16, 0)
opad = Array.new(16, 0)
# for(var i = 0; i < 16; i++)
i = 0
while i < 16
ipad[i] = (bkey[i] || 0) ^ 0x36363636
opad[i] = (bkey[i] || 0) ^ 0x5C5C5C5C
i += 1
end
hash = core_sha1((ipad + str2binb(data)), 512 + data.length * $chrsz)
core_sha1((opad + hash), 512 + 160)
end | ruby | {
"resource": ""
} |
q24810 | S3SwfUpload.Signature.str2binb | train | def str2binb(str)
bin = []
mask = (1 << $chrsz) - 1
# for(var i = 0; i < str.length * $chrsz; i += $chrsz)
i = 0
while i < str.length * $chrsz
bin[i >> 5] ||= 0
bin[i >> 5] |= (str[i / $chrsz] & mask) << (32 - $chrsz - i % 32)
i += $chrsz
end
bin
end | ruby | {
"resource": ""
} |
q24811 | S3SwfUpload.Signature.binb2b64 | train | def binb2b64(binarray)
tab = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
str = ''
# for(var i = 0; i < binarray.length * 4; i += 3)
i = 0
while i < binarray.length * 4
triplet = (((binarray[i >> 2].to_i >> 8 * (3 - i % 4)) & 0xFF) << 16) |
(((binarray[i + 1 >> 2].to_i >> 8 * (3 - (i + 1) % 4)) & 0xFF) << 8) |
((binarray[i + 2 >> 2].to_i >> 8 * (3 - (i + 2) % 4)) & 0xFF)
# for(var j = 0; j < 4; j++)
j = 0
while j < 4
if i * 8 + j * 6 > binarray.length * 32
str += $b64pad
else
str += tab[(triplet >> 6 * (3 - j)) & 0x3F].chr
end
j += 1
end
i += 3
end
str
end | ruby | {
"resource": ""
} |
q24812 | DataSift.AccountIdentity.create | train | def create(label = '', status = 'active', master = '')
fail ArgumentError, 'label is missing' if label.empty?
params = { label: label }
params.merge!(status: status) unless status.empty?
params.merge!(master: master) if [TrueClass, FalseClass].include?(master.class)
DataSift.request(:POST, 'account/identity', @config, params)
end | ruby | {
"resource": ""
} |
q24813 | DataSift.AccountIdentity.list | train | def list(label = '', per_page = '', page = '')
params = {}
params.merge!(label: label) unless label.empty?
params.merge!(per_page: per_page) unless per_page.empty?
params.merge!(page: page) unless page.empty?
DataSift.request(:GET, 'account/identity', @config, params)
end | ruby | {
"resource": ""
} |
q24814 | EmbeddedAssociations.Processor.handle_resource | train | def handle_resource(definition, parent, parent_params)
if definition.is_a? Array
return definition.each{|d| handle_resource(d, parent, parent_params)}
end
# normalize to a hash
unless definition.is_a? Hash
definition = {definition => nil}
end
definition.each do |name, child_definition|
if !parent_params || !parent_params.has_key?(name.to_s)
next
end
reflection = parent.class.reflect_on_association(name)
attrs = parent_params.delete(name.to_s)
if reflection.collection?
attrs ||= []
handle_plural_resource parent, name, attrs, child_definition
else
handle_singular_resource parent, name, attrs, child_definition
end
end
end | ruby | {
"resource": ""
} |
q24815 | GoogleBook.Book.search | train | def search(query,type = nil)
checking_type(type)
type = set_type(type) unless type.nil?
if query.nil?
puts 'Enter the text to search'
text = gets
end
json = JSON.parse(connect_google(@api_key,type,query))
@total_count = json["totalItems"]
@items = json["items"]
end | ruby | {
"resource": ""
} |
q24816 | GoogleBook.Book.filter | train | def filter(query, type = nil)
checking_filter_type(type)
filter_type = set_filter_type(type) unless type.nil?
json = JSON.parse(connect_google(@api_key,nil,query,filter_type))
@total_count = json["totalItems"]
@items = json["items"]
end | ruby | {
"resource": ""
} |
q24817 | DataSift.Push.valid? | train | def valid?(params, bool_response = true)
requires params
res = DataSift.request(:POST, 'push/validate', @config, params)
bool_response ? res[:http][:status] == 200 : res
end | ruby | {
"resource": ""
} |
q24818 | DataSift.Push.log_for | train | def log_for(id, page = 1, per_page = 20, order_by = :request_time, order_dir = :desc)
params = {
:id => id
}
requires params
params.merge!(
:page => page,
:per_page => per_page,
:order_by => order_by,
:order_dir => order_dir
)
DataSift.request(:GET, 'push/log', @config, params)
end | ruby | {
"resource": ""
} |
q24819 | DataSift.Push.log | train | def log(page = 1, per_page = 20, order_by = :request_time, order_dir = :desc)
params = {
:page => page,
:per_page => per_page,
:order_by => order_by,
:order_dir => order_dir
}
DataSift.request(:GET, 'push/log', @config, params)
end | ruby | {
"resource": ""
} |
q24820 | DataSift.Push.get_by_hash | train | def get_by_hash(hash, page = 1, per_page = 20, order_by = :created_at, order_dir = :desc, include_finished = 0, all = false)
params = {
:hash => hash
}
requires params
params.merge!(
:page => page,
:per_page => per_page,
:order_by => order_by,
:order_dir => order_dir,
:include_finished => include_finished,
:all => all
)
DataSift.request(:GET, 'push/get', @config, params)
end | ruby | {
"resource": ""
} |
q24821 | DataSift.Push.get_by_historics_id | train | def get_by_historics_id(historics_id, page = 1, per_page = 20, order_by = :created_at, order_dir = :desc, include_finished = 0, all = false)
params = {
:historics_id => historics_id,
:page => page,
:per_page => per_page,
:order_by => order_by,
:order_dir => order_dir,
:include_finished => include_finished,
:all => all
}
DataSift.request(:GET, 'push/get', @config, params)
end | ruby | {
"resource": ""
} |
q24822 | DataSift.Push.get | train | def get(page = 1, per_page = 20, order_by = :created_at, order_dir = :desc, include_finished = 0, all = false)
params = {
:page => page,
:per_page => per_page,
:order_by => order_by,
:order_dir => order_dir,
:include_finished => include_finished,
:all => all
}
DataSift.request(:GET, 'push/get', @config, params)
end | ruby | {
"resource": ""
} |
q24823 | DataSift.Push.pull | train | def pull(id, size = 52_428_800, cursor = '', callback = nil)
params = {
:id => id
}
requires params
params.merge!(
:size => size,
:cursor => cursor
)
params.merge!({:on_interaction => callback}) unless callback.nil?
DataSift.request(:GET, 'pull', @config, params, {}, 30, 30, true)
end | ruby | {
"resource": ""
} |
q24824 | MediaWiki.Edit.edit | train | def edit(title, text, opts = {})
opts[:bot] = opts.key?(:bot) ? opts[:bot] : true
params = {
action: 'edit',
title: title,
text: text,
nocreate: 1,
format: 'json',
token: get_token
}
params[:summary] ||= opts[:summary]
params[:minor] = '1' if opts[:minor]
params[:bot] = '1' if opts[:bot]
response = post(params)
if response.dig('edit', 'result') == 'Success'
return false if response.dig('edit', 'nochange')
return response.dig('edit', 'newrevid')
end
raise MediaWiki::Butt::EditError.new(response.dig('error', 'code') || 'Unknown error code')
end | ruby | {
"resource": ""
} |
q24825 | MediaWiki.Edit.create_page | train | def create_page(title, text, opts = {})
opts[:bot] = opts.key?(:bot) ? opts[:bot] : true
opts[:summary] ||= 'New page'
params = {
action: 'edit',
title: title,
text: text,
summary: opts[:summary],
createonly: 1,
format: 'json',
token: get_token
}
params[:bot] = '1' if opts[:bot]
response = post(params)
return response['edit']['pageid'] if response.dig('edit', 'result') == 'Success'
raise MediaWiki::Butt::EditError.new(response.dig('error', 'code') || 'Unknown error code')
end | ruby | {
"resource": ""
} |
q24826 | MediaWiki.Edit.upload | train | def upload(url, filename = nil)
params = {
action: 'upload',
url: url,
token: get_token
}
filename = filename.nil? ? url.split('/')[-1] : filename.sub(/^File:/, '')
ext = filename.split('.')[-1]
allowed_extensions = get_allowed_file_extensions
raise MediaWiki::Butt::UploadInvalidFileExtError.new unless allowed_extensions.include?(ext)
params[:filename] = filename
response = post(params)
response.dig('upload', 'warnings')&.each do |warning|
warn warning
end
return true if response.dig('upload', 'result') == 'Success'
raise MediaWiki::Butt::EditError.new(response.dig('error', 'code') || 'Unknown error code')
end | ruby | {
"resource": ""
} |
q24827 | MediaWiki.Edit.move | train | def move(from, to, opts = {})
opts[:talk] = opts.key?(:talk) ? opts[:talk] : true
params = {
action: 'move',
from: from,
to: to,
token: get_token
}
params[:reason] ||= opts[:reason]
params[:movetalk] = '1' if opts[:talk]
params[:noredirect] = '1' if opts[:suppress_redirect]
response = post(params)
return true if response['move']
raise MediaWiki::Butt::EditError.new(response.dig('error', 'code') || 'Unknown error code')
end | ruby | {
"resource": ""
} |
q24828 | MediaWiki.Edit.delete | train | def delete(title, reason = nil)
params = {
action: 'delete',
title: title,
token: get_token
}
params[:reason] = reason unless reason.nil?
response = post(params)
return true if response['delete']
raise MediaWiki::Butt::EditError.new(response.dig('error', 'code') || 'Unknown error code')
end | ruby | {
"resource": ""
} |
q24829 | Middleman::Cli.ListAll.list_all | train | def list_all
# Determine the valid targets.
app = ::Middleman::Application.new do
config[:exit_before_ready] = true
end
app_config = app.config.clone
app.shutdown!
# Because after_configuration won't run again until we
# build, we'll fake the strings with the one given for
# the default. So for each target, gsub the target for
# the initial target already given in config.
app_config[:targets].each do |target|
target_org = app_config[:target].to_s
target_req = target[0].to_s
path_org = app_config[:build_dir]
path_req = path_org.reverse.sub(target_org.reverse, target_req.reverse).reverse
say "#{target_req}, #{File.expand_path(path_req)}", :cyan
end
end | ruby | {
"resource": ""
} |
q24830 | ActionMailer.Base.render_with_layout_and_partials | train | def render_with_layout_and_partials(format)
# looking for system mail.
template = MailEngine::MailTemplate.where(:path => "#{controller_path}/#{action_name}", :format => format, :locale => I18n.locale, :partial => false, :for_marketing => false).first
# looking for marketing mail.
template = MailEngine::MailTemplate.where(:path => action_name, :format => format, :locale => I18n.locale, :partial => false, :for_marketing => true).first if template.blank?
# if found db template set the layout and partial for it.
if template
related_partial_paths = {}
# set @footer or @header
template.template_partials.each do |tmp|
related_partial_paths["#{tmp.placeholder_name}_path".to_sym] = tmp.partial.path
end
# set layout
render :template => "#{controller_path}/#{action_name}", :layout => "layouts/mail_engine/mail_template_layouts/#{template.layout}", :locals => related_partial_paths
else
# if not found db template should render file template
render(action_name)
end
end | ruby | {
"resource": ""
} |
q24831 | Diane.Recorder.record | train | def record
if File.exist? DIFILE
CSV.open(DIFILE, 'a') { |csv| csv << [@user, @message, @time] }
else
CSV.open(DIFILE, 'a') do |csv|
csv << %w[user message time]
csv << [@user, @message, @time]
end
end
puts '✓'.green
rescue StandardError => e
abort 'Broken'.magenta + e
end | ruby | {
"resource": ""
} |
q24832 | Diane.Recorder.slug | train | def slug(user)
abort 'User is nil. Fuck off.'.magenta if user.nil?
user.downcase.strip.tr(' ', '_').gsub(/[^\w-]/, '')
end | ruby | {
"resource": ""
} |
q24833 | FREDAPI.Connection.connection | train | def connection opts={}
connection = Faraday.new(opts) do |conn|
if opts[:force_urlencoded]
conn.request :url_encoded
else
conn.request :json
end
conn.request :json
conn.use FaradayMiddleware::FollowRedirects
conn.use FaradayMiddleware::Mashify
conn.use FaradayMiddleware::ParseJson, :content_type => /\bjson$/
conn.use FaradayMiddleware::ParseXml, :content_type => /\bxml$/
conn.adapter adapter
end
connection.headers[:user_agent] = user_agent
connection
end | ruby | {
"resource": ""
} |
q24834 | Aequitas.Violation.message | train | def message(transformer = Undefined)
return @custom_message if @custom_message
transformer = self.transformer if Undefined.equal?(transformer)
transformer.transform(self)
end | ruby | {
"resource": ""
} |
q24835 | Eldritch.DSL.together | train | def together
old = Thread.current.eldritch_group
group = Group.new
Thread.current.eldritch_group = group
yield group
group.join_all
Thread.current.eldritch_group = old
end | ruby | {
"resource": ""
} |
q24836 | AlchemyFlux.Service.start | train | def start
return if @state != :stopped
Service.start(@options[:ampq_uri], @options[:threadpool_size])
EM.run do
@channel = AMQP::Channel.new(@@connection)
@channel.on_error do |ch, channel_close|
message = "Channel exception: [#{channel_close.reply_code}] #{channel_close.reply_text}"
puts message
raise message
end
@channel.prefetch(@options[:prefetch])
@channel.auto_recovery = true
@service_queue = @channel.queue( @service_queue_name, {:durable => true})
@service_queue.subscribe({:ack => true}) do |metadata, payload|
payload = JSON.parse(payload)
process_service_queue_message(metadata, payload)
end
response_queue = @channel.queue(@response_queue_name, {:exclusive => true, :auto_delete => true})
response_queue.subscribe({}) do |metadata, payload|
payload = JSON.parse(payload)
process_response_queue_message(metadata, payload)
end
@channel.default_exchange.on_return do |basic_return, frame, payload|
payload = JSON.parse(payload)
process_returned_message(basic_return, frame.properties, payload)
end
# RESOURCES HANDLE
@resources_exchange = @channel.topic("resources.exchange", {:durable => true})
@resources_exchange.on_return do |basic_return, frame, payload|
payload = JSON.parse(payload)
process_returned_message(basic_return, frame.properties, payload)
end
bound_resources = 0
for resource_path in @options[:resource_paths]
binding_key = "#{path_to_routing_key(resource_path)}.#"
@service_queue.bind(@resources_exchange, :key => binding_key) {
bound_resources += 1
}
end
begin
# simple loop to wait for the resources to be bound
sleep(0.01)
end until bound_resources == @options[:resource_paths].length
@state = :started
end
end | ruby | {
"resource": ""
} |
q24837 | AlchemyFlux.Service.stop | train | def stop
return if @state != :started
# stop receiving new incoming messages
@service_queue.unsubscribe
# only stop the service if all incoming and outgoing messages are complete
decisecond_timeout = @options[:timeout]/100
waited_deciseconds = 0 # guarantee that this loop will stop
while (@transactions.length > 0 || @processing_messages > 0) && waited_deciseconds < decisecond_timeout
sleep(0.1) # wait a decisecond to check the incoming and outgoing messages again
waited_deciseconds += 1
end
@channel.close
@state = :stopped
end | ruby | {
"resource": ""
} |
q24838 | AlchemyFlux.Service.process_service_queue_message | train | def process_service_queue_message(metadata, payload)
service_to_reply_to = metadata.reply_to
message_replying_to = metadata.message_id
this_message_id = AlchemyFlux::Service.generateUUID()
delivery_tag = metadata.delivery_tag
operation = proc {
@processing_messages += 1
begin
response = @service_fn.call(payload)
{
'status_code' => response['status_code'] || 200,
'body' => response['body'] || "",
'headers' => response['headers'] || {}
}
rescue AlchemyFlux::NAckError => e
AlchemyFlux::NAckError
rescue Exception => e
e
end
}
callback = proc { |result|
if result == AlchemyFlux::NAckError
@service_queue.reject(delivery_tag)
elsif result.is_a?(Exception)
# if there is an unhandled exception from the service,
# raise it to force exit and container management can spin up a new one
raise result
else
#if there is a service to reply to then reply, else ignore
if service_to_reply_to
send_message(@channel.default_exchange, service_to_reply_to, result, {
:message_id => this_message_id,
:correlation_id => message_replying_to,
:type => 'http_response'
})
end
@processing_messages -= 1
@service_queue.acknowledge(delivery_tag)
end
}
EventMachine.defer(operation, callback)
end | ruby | {
"resource": ""
} |
q24839 | AlchemyFlux.Service.process_response_queue_message | train | def process_response_queue_message(metadata, payload)
response_queue = @transactions.delete metadata.correlation_id
response_queue << payload if response_queue
end | ruby | {
"resource": ""
} |
q24840 | AlchemyFlux.Service.process_returned_message | train | def process_returned_message(basic_return, metadata, payload)
response_queue = @transactions.delete metadata[:message_id]
response_queue << MessageNotDeliveredError if response_queue
end | ruby | {
"resource": ""
} |
q24841 | AlchemyFlux.Service.send_message | train | def send_message(exchange, routing_key, message, options)
message_options = options.merge({:routing_key => routing_key})
message = message.to_json
EventMachine.next_tick do
exchange.publish message, message_options
end
end | ruby | {
"resource": ""
} |
q24842 | AlchemyFlux.Service.send_request_to_service | train | def send_request_to_service(service_name, message)
if block_given?
EventMachine.defer do
yield send_request_to_service(service_name, message)
end
else
send_HTTP_request(@channel.default_exchange, service_name, message)
end
end | ruby | {
"resource": ""
} |
q24843 | AlchemyFlux.Service.send_request_to_resource | train | def send_request_to_resource(message)
routing_key = path_to_routing_key(message['path'])
if block_given?
EventMachine.defer do
yield send_request_to_resource(message)
end
else
send_HTTP_request(@resources_exchange, routing_key, message)
end
end | ruby | {
"resource": ""
} |
q24844 | AlchemyFlux.Service.path_to_routing_key | train | def path_to_routing_key(path)
new_path = ""
path.split('').each_with_index do |c,i|
if c == '/' and i != 0 and i != path.length-1
new_path += '.'
elsif c != '/'
new_path += c
end
end
new_path
end | ruby | {
"resource": ""
} |
q24845 | AlchemyFlux.Service.format_HTTP_message | train | def format_HTTP_message(message)
message = {
# Request Parameters
'body' => message['body'] || "",
'verb' => message['verb'] || "GET",
'headers' => message['headers'] || {},
'path' => message['path'] || "/",
'query' => message['query'] || {},
# Location
'scheme' => message['protocol'] || 'http',
'host' => message['hostname'] || '127.0.0.1',
'port' => message['port'] || 8080,
# Custom Authentication
'session' => message['session']
}
message
end | ruby | {
"resource": ""
} |
q24846 | OhEmbedr.OhEmbedr.gets | train | def gets
begin
data = make_http_request
@hash = send(@@formats[@format][:oembed_parser], data) # Call the method specified in default_formats hash above
rescue RuntimeError => e
if e.message == "401"
# Embedding disabled
return nil
elsif e.message == "501"
# Format not supported
raise UnsupportedError, "#{@format} not supported by #{@domain}"
elsif e.message == "404"
# Not found
raise Error, "#{@url} not found"
else
raise e
end
end
end | ruby | {
"resource": ""
} |
q24847 | OhEmbedr.OhEmbedr.load_format | train | def load_format requested_format = nil
raise ArgumentError, "Requested format not supported" if !requested_format.nil? && @@formats[requested_format].nil?
@format = requested_format || @@default_format
attempted_formats = ""
begin
attempted_formats += @@formats[@format][:require]
require @@formats[@format][:require]
return true
rescue LoadError
# If the user requested the format and it failed. Just give up!
raise Error("Please install: '#{@@formats[@format][:require]}' to use #{@format} format.") unless requested_format.nil?
# Otherwise lets exhaust all our other options first
available_formats = @@formats
available_formats.delete(@format)
available_formats.each_key do |format|
begin
attempted_formats += ", "
require @@formats[format][:require]
@format = format
return true
rescue LoadError
attempted_formats += @@formats[format][:require]
end
end
raise Error, "Could not find any suitable library to parse response with, tried: #{attempted_formats}. Please install one of these to use OEmbed."
end
end | ruby | {
"resource": ""
} |
q24848 | BcmsBlog.BlogObserver.create_post_portlet_page | train | def create_post_portlet_page
page = Cms::Page.find_by_name(portlet_name = "#{@blog.name}: Post") || Cms::Page.create!(
:name => portlet_name,
:path => "/#{@blog.name_for_path}/post",
:section => @section,
:template_file_name => "default.html.erb",
:hidden => true)
page.publish
create_route(page, portlet_name, "/#{@blog.name_for_path}/:year/:month/:day/:slug")
create_portlet(page, portlet_name, BlogPostPortlet)
end | ruby | {
"resource": ""
} |
q24849 | Evnt.Command.err | train | def err(message, code: nil)
@state[:result] = false
@state[:errors].push(
message: message,
code: code
)
# raise error if command needs exceptions
raise message if @options[:exceptions]
end | ruby | {
"resource": ""
} |
q24850 | Evnt.Command._init_command_data | train | def _init_command_data(params)
# set state
@state = {
result: true,
errors: []
}
# set options
initial_options = {
exceptions: false,
nullify_empty_params: false
}
default_options = _safe_default_options || {}
params_options = params[:_options] || {}
@options = initial_options.merge(default_options)
.merge(params_options)
# set other data
@params = params
end | ruby | {
"resource": ""
} |
q24851 | Evnt.Command._validate_single_params | train | def _validate_single_params
validations = _safe_validations
validations.each do |val|
value_to_validate = _value_to_validate(val)
validator = Evnt::Validator.new(value_to_validate, val[:options])
if validator.passed?
@params[val[:param]] = validator.value
else
error = val[:options][:err] || "#{val[:param].capitalize} value not accepted"
err_code = val[:options][:err_code] || val[:param].to_sym
err(error, code: err_code)
break
end
end
@params
end | ruby | {
"resource": ""
} |
q24852 | RubyOnAcid.Factory.choose | train | def choose(key, *choices)
all_choices = choices.flatten
index = (get_unit(key) * all_choices.length).floor
index = all_choices.length - 1 if index > all_choices.length - 1
all_choices[index]
end | ruby | {
"resource": ""
} |
q24853 | ActionController.Permittance.permitter | train | def permitter(pclass = permitter_class)
pinstance = (@permitter_class_to_permitter ||= {})[pclass]
return pinstance if pinstance
current_authorizer_method = ActionController::Permitter.current_authorizer_method ? ActionController::Permitter.current_authorizer_method.to_sym : nil
@permitter_class_to_permitter[pclass] = pclass.new(params, defined?(current_user) ? current_user : nil, current_authorizer_method && defined?(current_authorizer_method) ? __send__(current_authorizer_method) : nil)
end | ruby | {
"resource": ""
} |
q24854 | StateMachine.Transition.handle_in_source_state | train | def handle_in_source_state
if @state_machine.initial_queue.nil?
raise RuntimeError, "State machine not started yet."
end
if Dispatch::Queue.current.to_s != @state_machine.initial_queue.to_s
raise RuntimeError,
"#{self.class.event_type}:#{@event_trigger_value} must be "\
"called from the queue where the state machine was started."
end
@source_state.send :guarded_execute,
self.class.event_type,
@event_trigger_value
end | ruby | {
"resource": ""
} |
q24855 | Cube.Client.actual_send | train | def actual_send(type, time, id, data)
# Namespace support!
prefix = "#{@namespace}_" unless @namespace.nil?
# Get rid of any unwanted characters, and replace each of them with an _.
type = type.to_s.gsub RESERVED_CHARS_REGEX, '_'
# Start constructing the message to be sent to Cube over UDP.
message = {
type: "#{prefix}#{type}"
}
message[:time] = time.iso8601 unless time.nil?
message[:id] = id unless id.nil?
message[:data] = data unless data.nil?
# JSONify it, log it, and send it off.
message_str = message.to_json
self.class.logger.debug { "Cube: #{message_str}" } if self.class.logger
socket.send message_str, 0, @host, @port
rescue => err
self.class.logger.error { "Cube: #{err.class} #{err}" } if self.class.logger
end | ruby | {
"resource": ""
} |
q24856 | Rubaidh.GoogleAnalyticsViewHelper.link_to_tracked | train | def link_to_tracked(name, track_path = "/", options = {}, html_options = {})
raise AnalyticsError.new("You must set Rubaidh::GoogleAnalytics.defer_load = false to use outbound link tracking") if GoogleAnalytics.defer_load == true
html_options.merge!({:onclick => tracking_call(track_path)})
link_to name, options, html_options
end | ruby | {
"resource": ""
} |
q24857 | Rubaidh.GoogleAnalyticsViewHelper.link_to_tracked_if | train | def link_to_tracked_if(condition, name, track_path = "/", options = {}, html_options = {}, &block)
raise AnalyticsError.new("You must set Rubaidh::GoogleAnalytics.defer_load = false to use outbound link tracking") if GoogleAnalytics.defer_load == true
html_options.merge!({:onclick => tracking_call(track_path)})
link_to_unless !condition, name, options, html_options, &block
end | ruby | {
"resource": ""
} |
q24858 | Rubaidh.GoogleAnalyticsViewHelper.link_to_tracked_unless_current | train | def link_to_tracked_unless_current(name, track_path = "/", options = {}, html_options = {}, &block)
raise AnalyticsError.new("You must set Rubaidh::GoogleAnalytics.defer_load = false to use outbound link tracking") if GoogleAnalytics.defer_load == true
html_options.merge!({:onclick =>tracking_call(track_path)})
link_to_unless current_page?(options), name, options, html_options, &block
end | ruby | {
"resource": ""
} |
q24859 | SidekiqSimpleDelay.DelayMethods.simple_sidekiq_delay_for | train | def simple_sidekiq_delay_for(interval, options = {})
Proxy.new(simple_delayed_worker, self, options.merge('at' => Time.now.to_f + interval.to_f))
end | ruby | {
"resource": ""
} |
q24860 | SidekiqSimpleDelay.DelayMethods.simple_sidekiq_delay_until | train | def simple_sidekiq_delay_until(timestamp, options = {})
Proxy.new(simple_delayed_worker, self, options.merge('at' => timestamp.to_f))
end | ruby | {
"resource": ""
} |
q24861 | SidekiqSimpleDelay.DelayMethods.simple_sidekiq_delay_spread | train | def simple_sidekiq_delay_spread(options = {})
local_opts = options.dup
spread_duration = Utils.extract_option(local_opts, :spread_duration, 1.hour).to_f
spread_in = Utils.extract_option(local_opts, :spread_in, 0).to_f
spread_at = Utils.extract_option(local_opts, :spread_at)
spread_method = Utils.extract_option(local_opts, :spread_method, :rand)
spread_mod_value = Utils.extract_option(local_opts, :spread_mod_value)
spread_mod_method = Utils.extract_option(local_opts, :spread_mod_method)
spread_duration = 0 if spread_duration < 0
spread_in = 0 if spread_in < 0
spread =
# kick of immediately if the duration is 0
if spread_duration.zero?
0
else
case spread_method.to_sym
when :rand
Utils.random_number(spread_duration)
when :mod
mod_value =
# The mod value has been supplied
if !spread_mod_value.nil?
spread_mod_value
# Call the supplied method on the target object to get mod value
elsif !spread_mod_method.nil?
send(spread_mod_method)
# Call `spread_mod_method` on target object to get mod value
elsif respond_to?(:spread_mod_method)
send(send(:spread_mod_method))
else
raise ArgumentError, 'must specify `spread_mod_value` or `spread_mod_method` or taget must respond to `spread_mod_method`'
end
# calculate the mod based offset
mod_value % spread_duration
else
raise ArgumentError, "spread_method must :rand or :mod, `#{spread_method} is invalid`"
end
end
t =
if !spread_at.nil?
# add spread to a timestamp
spread_at.to_f + spread
elsif !spread_in.nil?
# add spread to no plus constant offset
Time.now.to_f + spread_in.to_f + spread
else
# add spread to current time
Time.now.to_f + spread
end
Proxy.new(SimpleDelayedWorker, self, local_opts.merge('at' => t))
end | ruby | {
"resource": ""
} |
q24862 | CelluloidPubsub.WebServer.handle_dispatched_message | train | def handle_dispatched_message(reactor, data)
log_debug "#{self.class} trying to dispatch message #{data.inspect}"
message = reactor.parse_json_data(data)
final_data = message.present? && message.is_a?(Hash) ? message.to_json : data.to_json
reactor.websocket << final_data
end | ruby | {
"resource": ""
} |
q24863 | Middleman::Cli.BuildAll.build_all | train | def build_all
# The first thing we want to do is create a temporary application
# instance so that we can determine the valid targets.
app = ::Middleman::Application.new do
config[:exit_before_ready] = true
end
build_list = app.config[:targets].each_key.collect { |item| item.to_s }
bad_builds = []
build_list.each do |target|
bad_builds << target unless Build.start(['--target', target])
end
unless bad_builds.count == 0
say
say 'These targets produced errors during build:', :red
bad_builds.each { |item| say " #{item}", :red}
end
bad_builds.count == 0
end | ruby | {
"resource": ""
} |
q24864 | Datatable.Helper.ruby_aocolumns | train | def ruby_aocolumns
result = []
column_def_keys = %w[ asSorting bSearchable bSortable
bUseRendered bVisible fnRender iDataSort
mDataProp sClass sDefaultContent sName
sSortDataType sTitle sType sWidth link_to ]
index = 0
@datatable.columns.each_value do |column_hash|
column_result = {}
column_hash.each do |key,value|
if column_def_keys.include?(key.to_s)
column_result[key.to_s] = value
end
end
# rewrite any link_to values as fnRender functions
if column_result.include?('link_to')
column_result['fnRender'] = %Q|function(oObj) { return replace('#{column_result['link_to']}', oObj.aData);}|
column_result.delete('link_to')
end
if column_result.empty?
result << nil
else
result << column_result
end
end
result
end | ruby | {
"resource": ""
} |
q24865 | Gattica.Auth.parse_tokens | train | def parse_tokens(data)
tokens = {}
data.split("\n").each do |t|
tokens.merge!({ t.split('=').first.downcase.to_sym => t.split('=').last })
end
return tokens
end | ruby | {
"resource": ""
} |
q24866 | AllscriptsApi.NamedMagicMethods.get_provider | train | def get_provider(provider_id = nil, user_name = nil)
params =
MagicParams.format(
parameter1: provider_id,
parameter2: user_name
)
results = magic("GetProvider", magic_params: params)
results["getproviderinfo"]
end | ruby | {
"resource": ""
} |
q24867 | AllscriptsApi.NamedMagicMethods.get_providers | train | def get_providers(security_filter = nil,
name_filter = nil,
show_only_providers_flag = "Y",
internal_external = "I",
ordering_authority = nil,
real_provider = "N")
params =
MagicParams.format(
parameter1: security_filter,
parameter2: name_filter,
parameter3: show_only_providers_flag,
parameter4: internal_external,
parameter5: ordering_authority,
parameter6: real_provider
)
results = magic("GetProviders", magic_params: params)
results["getprovidersinfo"]
end | ruby | {
"resource": ""
} |
q24868 | AllscriptsApi.NamedMagicMethods.get_patient_problems | train | def get_patient_problems(patient_id,
show_by_encounter = "N",
assessed = nil,
encounter_id = nil,
filter_on_id = nil,
display_in_progress = nil)
params = MagicParams.format(
user_id: @allscripts_username,
patient_id: patient_id,
parameter1: show_by_encounter,
parameter2: assessed,
parameter3: encounter_id,
parameter4: filter_on_id,
parameter5: display_in_progress
)
results = magic("GetPatientProblems", magic_params: params)
results["getpatientproblemsinfo"]
end | ruby | {
"resource": ""
} |
q24869 | AllscriptsApi.NamedMagicMethods.get_results | train | def get_results(patient_id,
since = nil)
params = MagicParams.format(
user_id: @allscripts_username,
patient_id: patient_id,
parameter1: since
)
results = magic("GetResults", magic_params: params)
results["getresultsinfo"]
end | ruby | {
"resource": ""
} |
q24870 | AllscriptsApi.NamedMagicMethods.get_schedule | train | def get_schedule(start_date, end_date, other_username = nil)
params =
MagicParams.format(
user_id: @allscripts_username,
parameter1: format_date_range(start_date, end_date),
parameter4: other_username
)
results = magic("GetSchedule", magic_params: params)
results["getscheduleinfo"]
end | ruby | {
"resource": ""
} |
q24871 | AllscriptsApi.NamedMagicMethods.get_encounter_list | train | def get_encounter_list(patient_id = "", encounter_type = "",
when_or_limit = "", nostradamus = 0,
show_past_flag = "Y",
billing_provider_user_name = "")
params =
MagicParams.format(
user_id: @allscripts_username,
patient_id: patient_id,
parameter1: encounter_type, # from Encounter_Type_DE
parameter2: when_or_limit,
parameter3: nostradamus,
parameter4: show_past_flag,
parameter5: billing_provider_user_name,
)
results = magic("GetEncounterList", magic_params: params)
results["getencounterlistinfo"]
end | ruby | {
"resource": ""
} |
q24872 | AllscriptsApi.NamedMagicMethods.get_list_of_dictionaries | train | def get_list_of_dictionaries
params = MagicParams.format(user_id: @allscripts_username)
results = magic("GetListOfDictionaries", magic_params: params)
results["getlistofdictionariesinfo"]
end | ruby | {
"resource": ""
} |
q24873 | AllscriptsApi.NamedMagicMethods.get_dictionary | train | def get_dictionary(dictionary_name)
params = MagicParams.format(
user_id: @allscripts_username,
parameter1: dictionary_name
)
results = magic("GetDictionary", magic_params: params)
results["getdictionaryinfo"]
end | ruby | {
"resource": ""
} |
q24874 | AllscriptsApi.NamedMagicMethods.get_server_info | train | def get_server_info
params = MagicParams.format(user_id: @allscripts_username)
results = magic("GetServerInfo", magic_params: params)
results["getserverinfoinfo"][0] # infoinfo is an Allscript typo
end | ruby | {
"resource": ""
} |
q24875 | Borutus.Account.balance | train | def balance(options={})
if self.class == Borutus::Account
raise(NoMethodError, "undefined method 'balance'")
else
if self.normal_credit_balance ^ contra
credits_balance(options) - debits_balance(options)
else
debits_balance(options) - credits_balance(options)
end
end
end | ruby | {
"resource": ""
} |
q24876 | Humperdink.Tracker.shutdown | train | def shutdown(exception)
begin
notify_event(:shutdown, { :exception_message => exception.message })
rescue => e
$stderr.puts([e.message, e.backtrace].join("\n")) rescue nil
end
@config = default_config
@config[:enabled] = false
end | ruby | {
"resource": ""
} |
q24877 | Microdata.Item.add_itemprop | train | def add_itemprop(itemprop)
properties = Itemprop.parse(itemprop, @page_url)
properties.each { |name, value| (@properties[name] ||= []) << value }
end | ruby | {
"resource": ""
} |
q24878 | Microdata.Item.add_itemref_properties | train | def add_itemref_properties(element)
itemref = element.attribute('itemref')
if itemref
itemref.value.split(' ').each {|id| parse_elements(find_with_id(id))}
end
end | ruby | {
"resource": ""
} |
q24879 | RuboCopMethodOrder.MethodNodeCollection.replacements | train | def replacements
nodes.reject { |node| method_order_correct?(node) }.each_with_object({}) do |node, obj|
node_to_replace = nodes[expected_method_index(node)]
obj[node] = {
node => node_to_replace,
node_to_replace => nodes[expected_method_index(node_to_replace)]
}
end
end | ruby | {
"resource": ""
} |
q24880 | XsdReader.Shared.class_for | train | def class_for(n)
class_mapping = {
"#{schema_namespace_prefix}schema" => Schema,
"#{schema_namespace_prefix}element" => Element,
"#{schema_namespace_prefix}attribute" => Attribute,
"#{schema_namespace_prefix}choice" => Choice,
"#{schema_namespace_prefix}complexType" => ComplexType,
"#{schema_namespace_prefix}sequence" => Sequence,
"#{schema_namespace_prefix}simpleContent" => SimpleContent,
"#{schema_namespace_prefix}complexContent" => ComplexContent,
"#{schema_namespace_prefix}extension" => Extension,
"#{schema_namespace_prefix}import" => Import,
"#{schema_namespace_prefix}simpleType" => SimpleType
}
return class_mapping[n.is_a?(Nokogiri::XML::Node) ? n.name : n]
end | ruby | {
"resource": ""
} |
q24881 | Aequitas.ViolationSet.full_messages | train | def full_messages
violations.inject([]) do |list, (attribute_name, violations)|
messages = violations
messages = violations.full_messages if violations.respond_to?(:full_messages)
list.concat(messages)
end
end | ruby | {
"resource": ""
} |
q24882 | RubyOnAcid.MetaFactory.get_unit | train | def get_unit(key)
@assigned_factories[key] ||= source_factories[rand(source_factories.length)]
@assigned_factories[key].get_unit(key)
end | ruby | {
"resource": ""
} |
q24883 | RubyOnAcid.ExampleFactory.generate_factories | train | def generate_factories
random_factory = RubyOnAcid::RandomFactory.new
factories = []
5.times do
factory = RubyOnAcid::LoopFactory.new
factory.interval = random_factory.get(:increment, :min => -0.1, :max => 0.1)
factories << factory
end
3.times do
factory = RubyOnAcid::ConstantFactory.new
factory.value = random_factory.get(:constant)
factories << factory
end
factories << RubyOnAcid::FlashFactory.new(
:interval => random_factory.get(:interval, :max => 100)
)
2.times do
factories << RubyOnAcid::LissajousFactory.new(
:interval => random_factory.get(:interval, :max => 10.0),
:scale => random_factory.get(:scale, :min => 0.1, :max => 2.0)
)
end
factories << RubyOnAcid::RandomWalkFactory.new(
:interval => random_factory.get(:interval, :max => 0.1)
)
4.times do
factory = RubyOnAcid::SineFactory.new
factory.interval = random_factory.get(:increment, :min => -0.1, :max => 0.1)
factories << factory
end
2.times do
factory = RubyOnAcid::RepeatFactory.new
factory.repeat_count = random_factory.get(:interval, :min => 2, :max => 100)
factory.source_factories << random_element(factories)
factories << factory
end
2.times do
factories << RubyOnAcid::RoundingFactory.new(
:source_factories => [random_element(factories)],
:nearest => random_factory.get(:interval, :min => 0.1, :max => 0.5)
)
end
combination_factory = RubyOnAcid::CombinationFactory.new
combination_factory.constrain_mode = random_factory.choose(:constrain_mode,
CombinationFactory::CONSTRAIN,
CombinationFactory::WRAP,
CombinationFactory::REBOUND
)
combination_factory.operation = random_factory.choose(:operation,
CombinationFactory::ADD,
CombinationFactory::SUBTRACT,
CombinationFactory::MULTIPLY,
CombinationFactory::DIVIDE
)
2.times do
combination_factory.source_factories << random_element(factories)
end
factories << combination_factory
weighted_factory = RubyOnAcid::WeightedFactory.new
2.times do
source_factory = random_element(factories)
weighted_factory.source_factories << source_factory
weighted_factory.weights[source_factory] = rand
end
factories << weighted_factory
proximity_factory = RubyOnAcid::ProximityFactory.new
2.times do
proximity_factory.source_factories << random_element(factories)
end
factories << proximity_factory
8.times do
attraction_factory = RubyOnAcid::AttractionFactory.new(
:attractor_factory => random_element(factories)
)
attraction_factory.source_factories << random_element(factories)
factories << attraction_factory
end
factories
end | ruby | {
"resource": ""
} |
q24884 | Aequitas.Macros.validates_acceptance_of | train | def validates_acceptance_of(*attribute_names)
options = Macros.extract_options(attribute_names)
validation_rules.add(Rule::Acceptance, attribute_names, options)
end | ruby | {
"resource": ""
} |
q24885 | Aequitas.Macros.validates_confirmation_of | train | def validates_confirmation_of(*attribute_names)
options = Macros.extract_options(attribute_names)
validation_rules.add(Rule::Confirmation, attribute_names, options)
end | ruby | {
"resource": ""
} |
q24886 | Aequitas.Macros.validates_numericalness_of | train | def validates_numericalness_of(*attribute_names)
options = Macros.extract_options(attribute_names)
validation_rules.add(Rule::Value, attribute_names, options)
validation_rules.add(Rule::Numericalness, attribute_names, options)
end | ruby | {
"resource": ""
} |
q24887 | Aequitas.Macros.validates_presence_of | train | def validates_presence_of(*attribute_names)
options = Macros.extract_options(attribute_names)
validation_rules.add(Rule::Presence::NotBlank, attribute_names, options)
end | ruby | {
"resource": ""
} |
q24888 | Aequitas.Macros.validates_primitive_type_of | train | def validates_primitive_type_of(*attribute_names)
options = Macros.extract_options(attribute_names)
validation_rules.add(Rule::PrimitiveType, attribute_names, options)
end | ruby | {
"resource": ""
} |
q24889 | Diane.Player.all_recordings | train | def all_recordings
opts = {
headers: true,
header_converters: :symbol,
encoding: 'utf-8'
}
CSV.read(DIFILE, opts).map(&:to_hash)
end | ruby | {
"resource": ""
} |
q24890 | Diane.Player.play | train | def play
abort %(None from #{@user}. Fuck off.).magenta if @recordings.empty?
stdout = preface
@recordings.each do |r|
stdout += "\n#{r[:time]} : ".cyan + "@#{r[:user]}".yellow
stdout += "\n#{r[:message]}\n\n"
end
puts stdout
stdout
end | ruby | {
"resource": ""
} |
q24891 | Schematron.Schema.rule_hits | train | def rule_hits(results_doc, instance_doc, rule_type, xpath)
results = []
results_doc.root.find(xpath, NS_PREFIXES).each do |hit|
context = instance_doc.root.find_first hit['location']
hit.find('svrl:text/text()', NS_PREFIXES).each do |message|
results << {
:rule_type => rule_type,
:type => context.node_type_name,
:name => context.name,
:line => context.line_num,
:message => message.content.strip }
end
end
results
end | ruby | {
"resource": ""
} |
q24892 | Rlimiter.RedisClient.limit | train | def limit(key, count, duration)
@key = key.to_s
@duration = duration.to_i
# :incr_count increases the hit count and simultaneously checks for breach
if incr_count > count
# :elapsed is the time window start Redis cache
# If the time elapsed is less than window duration, the limit has been breached for the current window (return false).
return false if @duration - elapsed > 0
# Else reset the hit count to zero and window start time.
reset
end
true
end | ruby | {
"resource": ""
} |
q24893 | Rlimiter.RedisClient.next_in | train | def next_in(key, count, duration)
@key = key
@duration = duration
return 0 if current_count(key) < count
[@duration - elapsed, 0].max
end | ruby | {
"resource": ""
} |
q24894 | RubyOnAcid.RindaFactory.get_unit | train | def get_unit(key)
@prior_values[key] ||= 0.0
begin
key, value = @space.take([key, Float], @timeout)
@prior_values[key] = value
rescue Rinda::RequestExpiredError => exception
if source_factories.empty?
value = @prior_values[key]
else
value = super
end
end
value
end | ruby | {
"resource": ""
} |
q24895 | ContentfulRedis.ModelBase.matching_attributes? | train | def matching_attributes?(attribute, filter)
attribute.to_s.downcase == filter.to_s.delete('_').downcase
end | ruby | {
"resource": ""
} |
q24896 | Cloudster.ChefClient.add_to | train | def add_to(ec2)
ec2_template = ec2.template
@instance_name = ec2.name
chef_client_template = template
ec2.template.inner_merge(chef_client_template)
end | ruby | {
"resource": ""
} |
q24897 | Aequitas.RuleSet.validate | train | def validate(resource)
rules = rules_for_resource(resource)
rules.map { |rule| rule.validate(resource) }.compact
# TODO:
# violations = rules.map { |rule| rule.validate(resource) }.compact
# ViolationSet.new(resource).concat(violations)
end | ruby | {
"resource": ""
} |
q24898 | Cloudster.Cloud.template | train | def template(options = {})
require_options(options, [:resources])
resources = options[:resources]
description = options[:description] || 'This stack is created by Cloudster'
resource_template = {}
output_template = {}
resources.each do |resource|
resource_template.merge!(resource.template['Resources'])
output_template.merge!(resource.template['Outputs']) unless resource.template['Outputs'].nil?
end
cloud_template = {'AWSTemplateFormatVersion' => '2010-09-09',
'Description' => description
}
cloud_template['Resources'] = resource_template if !resource_template.empty?
cloud_template['Outputs'] = output_template if !output_template.empty?
return cloud_template.delete_nil.to_json
end | ruby | {
"resource": ""
} |
q24899 | Cloudster.Cloud.get_rds_details | train | def get_rds_details(options = {})
stack_resources = resources(options)
rds_resource_ids = get_resource_ids(stack_resources, "AWS::RDS::DBInstance")
rds = Fog::AWS::RDS.new(:aws_access_key_id => @access_key_id, :aws_secret_access_key => @secret_access_key, :region => @region)
rds_details = {}
rds_resource_ids.each do |key, value|
rds_instance_details = rds.describe_db_instances(value)
rds_details[key] = rds_instance_details.body["DescribeDBInstancesResult"]["DBInstances"][0] rescue nil
end
return rds_details
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.