_id
stringlengths 2
6
| title
stringlengths 9
130
| partition
stringclasses 3
values | text
stringlengths 66
10.5k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q24000
|
Handshake.ClauseMethods.Block
|
train
|
def Block(contract_hash)
pc = Handshake::ProcContract.new
pc.signature = contract_hash
pc
end
|
ruby
|
{
"resource": ""
}
|
q24001
|
Openapi2ruby.Openapi::Schema.properties
|
train
|
def properties
return [] if @definition['properties'].nil?
@definition['properties'].each_with_object([]) do |(key, value), results|
content = { name: key, definition: value }
results << Openapi2ruby::Openapi::Schema::Property.new(content)
end
end
|
ruby
|
{
"resource": ""
}
|
q24002
|
TeslaAPI.Connection.vehicles
|
train
|
def vehicles
@vehicles ||= begin
_, json = get_json("/vehicles")
json.map { |data| Vehicle.new(self, data) }
end
end
|
ruby
|
{
"resource": ""
}
|
q24003
|
Omniship.Carrier.valid_credentials?
|
train
|
def valid_credentials?
location = self.class.default_location
find_rates(location,location,Package.new(100, [5,15,30]), :test => test_mode)
rescue Omniship::ResponseError
false
else
true
end
|
ruby
|
{
"resource": ""
}
|
q24004
|
RDF.Statement.to_mongo
|
train
|
def to_mongo
self.to_hash.inject({}) do |hash, (place_in_statement, entity)|
hash.merge(RDF::Mongo::Conversion.to_mongo(entity, place_in_statement))
end
end
|
ruby
|
{
"resource": ""
}
|
q24005
|
RLP.DecodeLazy.decode_lazy
|
train
|
def decode_lazy(rlp, sedes: nil, sedes_options: {})
item, next_start = consume_item_lazy(rlp, 0)
raise DecodingError.new("RLP length prefix announced wrong length", rlp) if next_start != rlp.size
if item.instance_of?(LazyList)
item.sedes = sedes
item.sedes_options = sedes_options
item
elsif sedes
# FIXME: lazy man's kwargs
sedes_options.empty? ?
sedes.deserialize(item) :
sedes.deserialize(item, **sedes_options)
else
item
end
end
|
ruby
|
{
"resource": ""
}
|
q24006
|
RLP.DecodeLazy.consume_item_lazy
|
train
|
def consume_item_lazy(rlp, start)
t, l, s = consume_length_prefix(rlp, start)
if t == :str
consume_payload(rlp, s, :str, l)
elsif t == :list
[LazyList.new(rlp, s, s+l), s+l]
else
raise "Invalid item type: #{t}"
end
end
|
ruby
|
{
"resource": ""
}
|
q24007
|
RLP.DecodeLazy.peek
|
train
|
def peek(rlp, index, sedes: nil)
ll = decode_lazy(rlp)
index = Array(index)
index.each do |i|
raise IndexError, "Too many indices given" if primitive?(ll)
ll = ll.fetch(i)
end
sedes ? sedes.deserialize(ll) : ll
end
|
ruby
|
{
"resource": ""
}
|
q24008
|
Handshake.ClassMethods.contract_reader
|
train
|
def contract_reader(meth_to_clause)
attr_reader(*(meth_to_clause.keys))
meth_to_clause.each do |meth, cls|
contract meth, nil => cls
end
end
|
ruby
|
{
"resource": ""
}
|
q24009
|
Handshake.ClassMethods.contract_writer
|
train
|
def contract_writer(meth_to_clause)
attr_writer(*(meth_to_clause.keys))
meth_to_clause.each do |meth, cls|
contract "#{meth}=".to_sym, cls => anything
end
end
|
ruby
|
{
"resource": ""
}
|
q24010
|
Handshake.ClassMethods.method_added
|
train
|
def method_added(meth_name)
@deferred ||= {}
unless @deferred.empty?
@deferred.each do |k, v|
case k
when :before, :after, :around
define_condition meth_name, k, v
when :contract
define_contract meth_name, v
end
end
@deferred.clear
end
end
|
ruby
|
{
"resource": ""
}
|
q24011
|
Handshake.MethodContract.accepts=
|
train
|
def accepts=(args)
if args.last == Block # Transform into a ProcContract
args.pop
@block_contract = ProcContract.new
@block_contract.accepts = ClauseMethods::ANYTHING
@block_contract.returns = ClauseMethods::ANYTHING
elsif args.last.is_a?(ProcContract)
@block_contract = args.pop
end
if args.find_all {|o| o.is_a? Array}.length > 1
raise ContractError, "Cannot define more than one expected variable argument"
end
super(args)
end
|
ruby
|
{
"resource": ""
}
|
q24012
|
RackStatsD.RequestStatus.call
|
train
|
def call(env)
if env[REQUEST_METHOD] == GET
if env[PATH_INFO] == @status_path
if @callback.respond_to?(:call)
return @callback.call
else
return [200, HEADERS, [@callback.to_s]]
end
end
end
@app.call env
end
|
ruby
|
{
"resource": ""
}
|
q24013
|
RackStatsD.RequestHostname.call
|
train
|
def call(env)
status, headers, body = @app.call(env)
headers['X-Node'] = @host if @host
headers['X-Revision'] = @sha
[status, headers, body]
end
|
ruby
|
{
"resource": ""
}
|
q24014
|
RackStatsD.ProcessUtilization.procline
|
train
|
def procline
"unicorn %s[%s] worker[%02d]: %5d reqs, %4.1f req/s, %4dms avg, %5.1f%% util" % [
domain,
revision,
worker_number.to_i,
total_requests.to_i,
requests_per_second.to_f,
average_response_time.to_i,
percentage_active.to_f
]
end
|
ruby
|
{
"resource": ""
}
|
q24015
|
RackStatsD.ProcessUtilization.record_request
|
train
|
def record_request(status, env)
now = Time.now
diff = (now - @start)
@active_time += diff
@requests += 1
$0 = procline
if @stats
@stats.timing("#{@stats_prefix}.response_time", diff * 1000)
if VALID_METHODS.include?(env[REQUEST_METHOD])
stat = "#{@stats_prefix}.response_time.#{env[REQUEST_METHOD].downcase}"
@stats.timing(stat, diff * 1000)
end
if suffix = status_suffix(status)
@stats.increment "#{@stats_prefix}.status_code.#{status_suffix(status)}"
end
if @track_gc && GC.time > 0
@stats.timing "#{@stats_prefix}.gc.time", GC.time / 1000
@stats.count "#{@stats_prefix}.gc.collections", GC.collections
end
end
reset_horizon if now - horizon > @window
rescue => boom
warn "ProcessUtilization#record_request failed: #{boom}"
end
|
ruby
|
{
"resource": ""
}
|
q24016
|
RackStatsD.ProcessUtilization.call
|
train
|
def call(env)
@start = Time.now
GC.clear_stats if @track_gc
@total_requests += 1
first_request if @total_requests == 1
env['process.request_start'] = @start.to_f
env['process.total_requests'] = total_requests
# newrelic X-Request-Start
env.delete('HTTP_X_REQUEST_START')
status, headers, body = @app.call(env)
body = Body.new(body) { record_request(status, env) }
[status, headers, body]
end
|
ruby
|
{
"resource": ""
}
|
q24017
|
HammerCLIForemanTasks.Helper.task_progress
|
train
|
def task_progress(task_or_id)
task_id = task_or_id.is_a?(Hash) ? task_or_id['id'] : task_or_id
if !task_id.empty?
options = { verbosity: @context[:verbosity] || HammerCLI::V_VERBOSE }
task_progress = TaskProgress.new(task_id, options) { |id| load_task(id) }
task_progress.render
task_progress.success?
else
signal_usage_error(_('Please mention appropriate attribute value'))
end
end
|
ruby
|
{
"resource": ""
}
|
q24018
|
RLP.Decode.decode
|
train
|
def decode(rlp, **options)
rlp = str_to_bytes(rlp)
sedes = options.delete(:sedes)
strict = options.has_key?(:strict) ? options.delete(:strict) : true
begin
item, next_start = consume_item(rlp, 0)
rescue Exception => e
raise DecodingError.new("Cannot decode rlp string: #{e}", rlp)
end
raise DecodingError.new("RLP string ends with #{rlp.size - next_start} superfluous bytes", rlp) if next_start != rlp.size && strict
if sedes
obj = sedes.instance_of?(Class) && sedes.include?(Sedes::Serializable) ?
sedes.deserialize(item, **options) :
sedes.deserialize(item)
if obj.respond_to?(:_cached_rlp)
obj._cached_rlp = rlp
raise "RLP::Sedes::Serializable object must be immutable after decode" if obj.is_a?(Sedes::Serializable) && obj.mutable?
end
obj
else
item
end
end
|
ruby
|
{
"resource": ""
}
|
q24019
|
RLP.Decode.consume_item
|
train
|
def consume_item(rlp, start)
t, l, s = consume_length_prefix(rlp, start)
consume_payload(rlp, s, t, l)
end
|
ruby
|
{
"resource": ""
}
|
q24020
|
RLP.Decode.consume_payload
|
train
|
def consume_payload(rlp, start, type, length)
case type
when :str
[rlp[start...(start+length)], start+length]
when :list
items = []
next_item_start = start
payload_end = next_item_start + length
while next_item_start < payload_end
item, next_item_start = consume_item rlp, next_item_start
items.push item
end
raise DecodingError.new('List length prefix announced a too small length', rlp) if next_item_start > payload_end
[items, next_item_start]
else
raise TypeError, 'Type must be either :str or :list'
end
end
|
ruby
|
{
"resource": ""
}
|
q24021
|
Pipes.Context.add
|
train
|
def add(values)
values.each do |key, val|
k_sym = key.to_sym
fail Override, "Property :#{key} already present" if respond_to?(k_sym)
define_singleton_method(k_sym) { val }
end
end
|
ruby
|
{
"resource": ""
}
|
q24022
|
RubyFS.Stream.run
|
train
|
def run
logger.debug "Starting up..."
@socket = TCPSocket.from_ruby_socket ::TCPSocket.new(@host, @port)
post_init
loop { receive_data @socket.readpartial(4096) }
rescue EOFError, IOError, Errno::ECONNREFUSED => e
logger.info "Client socket closed due to (#{e.class}) #{e.message}!"
async.terminate
end
|
ruby
|
{
"resource": ""
}
|
q24023
|
RubyFS.Stream.command
|
train
|
def command(command, options = {}, &callback)
uuid = SecureRandom.uuid
@command_callbacks << (callback || lambda { |reply| signal uuid, reply })
string = "#{command}\n"
body_value = options.delete :command_body_value
options.each_pair do |key, value|
string << "#{key.to_s.gsub '_', '-'}: #{value}\n" if value
end
string << "\n" << body_value << "\n" if body_value
string << "\n"
send_data string
wait uuid unless callback
end
|
ruby
|
{
"resource": ""
}
|
q24024
|
RubyFS.Stream.application
|
train
|
def application(call, appname, options = nil)
opts = {call_command: 'execute', execute_app_name: appname}
if options
opts[:content_type] = 'text/plain'
opts[:content_length] = options.bytesize
opts[:command_body_value] = options
end
sendmsg call, opts
end
|
ruby
|
{
"resource": ""
}
|
q24025
|
GdprExporter.ClassMethods.gdpr_collect
|
train
|
def gdpr_collect(*args)
# Params handling
if args.class == Hash # when user provides the hash_params only
simple_fields, hash_params = [[], args]
else
simple_fields, hash_params = [args[0..-2], args.last]
end
unless hash_params.class == Hash
raise ArgumentError.new("Gdpr fields collection error: last argument must be a hash!")
end
unless hash_params.key?(:user_id)
raise ArgumentError.new("Gdpr fields collection error: the field aliasing user_id is not declared for '#{self}'!")
end
# Adds the eigen class to the set of classes eligible for gdpr data collection.
GdprExporter.add_klass(self)
# Adds instance fields to the eigenclass. They store
# all the fields and info we are interested in.
@gdpr_simple_fields = simple_fields
@gdpr_hash_params = hash_params
# Add readers for the instance vars declared above (for testing reasons)
self.class.send :attr_reader, :gdpr_simple_fields
self.class.send :attr_reader, :gdpr_hash_params
# Build the csv header and prepare the fields used for querying
#
user_id_field = hash_params[:user_id]
# csv_headers = [:user_id].concat @gdpr_simple_fields # Uncomment if user_id needed
# query_fields = [user_id_field].concat @gdpr_simple_fields # Uncomment if user_id needed
csv_headers = [].concat @gdpr_simple_fields
query_fields = [].concat @gdpr_simple_fields
if hash_params[:renamed_fields]
csv_headers.concat hash_params[:renamed_fields].values
query_fields.concat hash_params[:renamed_fields].keys
end
# Adds the class method 'gdpr_query' to the eigenclass.
# It will execute the query.
self.define_singleton_method(:gdpr_query) do |_user_id|
result = self.where(user_id_field => _user_id)
# When there are multiple joins defined, just keep calling 'joins'
# for each association.
if hash_params[:joins]
result = hash_params[:joins].inject(result) do | query, assoc |
query.send(:joins, assoc)
end
end
result
end
# Adds a method to export to csv to the eigenclass.
self.define_singleton_method(:gdpr_export) do |rows, csv|
return unless !rows.empty?
csv << (hash_params[:table_name] ? [hash_params[:table_name]] :
[self.to_s])
if hash_params[:desc]
csv << ['Description:', hash_params[:desc]]
end
csv << csv_headers
rows.each do |r|
csv << query_fields.map do |f|
f_splitted = f.to_s.split(' ')
if (f_splitted.size == 2)
# field f is coming from an assoc, i.e. field has been defined
# as "<tablename> <field>" in gdpr_collect then to get its value
# do r.<tablename>.<field>
f_splitted.inject(r) { |result, method| result.send(method) }
elsif (f_splitted.size > 2)
raise ArgumentError.new("Field #{f} is made of more than 2 words!?")
else
# No association involved, simply retrieve the field value.
r.send(f)
end
end
end
csv << []
end
end
|
ruby
|
{
"resource": ""
}
|
q24026
|
SpinningCursor.ConsoleHelpers.reset_line
|
train
|
def reset_line(text = "")
# Initialise ANSI escape string
escape = ""
# Get terminal window width
cols = console_columns
# The number of lines the previous message spanned
lines = @@prev / cols
# If cols == 80 and @@prev == 80, @@prev / cols == 1 but we don't want to
# go up an extra line since it fits exactly
lines -= 1 if @@prev % cols == 0
# Clear and go up a line
lines.times { escape += "#{ESC_R_AND_CLR}#{ESC_UP_A_LINE}" }
# Clear the line that is to be printed on
escape += "#{ESC_R_AND_CLR}"
# Console is clear, we can print!
$console.print "#{escape}#{text}"
# Store the current message so we know how many lines it spans
@@prev = text.to_s.length
end
|
ruby
|
{
"resource": ""
}
|
q24027
|
Bump.BumpInfo.valid?
|
train
|
def valid?
create_update_rules.each do |rule|
return false if !rule.file_exists || !rule.pattern_exists
end
true
end
|
ruby
|
{
"resource": ""
}
|
q24028
|
Hermitage.RailsRenderCore.render
|
train
|
def render
# Initialize the resulting tag
tag_parts = []
# Slice objects into separate lists
lists = slice_objects
# Render each list into `tag` variable
lists.each do |list|
items = list.collect { |item| render_link_for(item) }
tag_parts << render_content_tag_for(items)
end
tag_parts.join.html_safe
end
|
ruby
|
{
"resource": ""
}
|
q24029
|
Hermitage.RailsRenderCore.value_for
|
train
|
def value_for(item, option)
attribute = @options[option]
if attribute.is_a? Proc
attribute.call(item)
else
eval("item.#{attribute}")
end
end
|
ruby
|
{
"resource": ""
}
|
q24030
|
Hermitage.RailsRenderCore.render_link_for
|
train
|
def render_link_for(item)
original_path = value_for(item, :original)
thumbnail_path = value_for(item, :thumbnail)
title = @options[:title] ? value_for(item, :title) : nil
image = @template.image_tag(thumbnail_path, class: @options[:image_class])
@template.link_to(image, original_path, rel: 'hermitage',
class: @options[:link_class],
title: title)
end
|
ruby
|
{
"resource": ""
}
|
q24031
|
RLP.Encode.encode
|
train
|
def encode(obj, sedes: nil, infer_serializer: true, cache: false)
return obj._cached_rlp if obj.is_a?(Sedes::Serializable) && obj._cached_rlp && sedes.nil?
really_cache = obj.is_a?(Sedes::Serializable) && sedes.nil? && cache
if sedes
item = sedes.serialize(obj)
elsif infer_serializer
item = Sedes.infer(obj).serialize(obj)
else
item = obj
end
result = encode_raw(item)
if really_cache
obj._cached_rlp = result
obj.make_immutable!
end
result
end
|
ruby
|
{
"resource": ""
}
|
q24032
|
Bump.Application.create_bump_info
|
train
|
def create_bump_info
repo = BumpInfoRepository.new @file
begin
bump_info = repo.from_file
rescue Errno::ENOENT
log_red "Error: the file `#{@file}` not found."
return nil
end
bump_info
end
|
ruby
|
{
"resource": ""
}
|
q24033
|
Bump.Application.print_version_patterns
|
train
|
def print_version_patterns(bump_info)
log 'Current Version:', false
log_green " #{bump_info.before_version}"
log 'Version patterns:'
bump_info.update_rules.each do |rule|
print_rule rule
end
end
|
ruby
|
{
"resource": ""
}
|
q24034
|
Bump.Application.print_rule
|
train
|
def print_rule(rule)
unless rule.file_exists
log_red " #{rule.file}:", false
log_red " '#{rule.before_pattern}' (file not found)"
return
end
log " #{rule.file}:", false
unless rule.pattern_exists
log_red " '#{rule.before_pattern}' (pattern not found)"
return
end
log_green " '#{rule.before_pattern}'"
end
|
ruby
|
{
"resource": ""
}
|
q24035
|
Bump.Application.report
|
train
|
def report(bump_info)
bump_info.update_rules.each do |rule|
log rule.file.to_s
log ' Performed pattern replacement:'
log_green " '#{rule.before_pattern}' => '#{rule.after_pattern}'"
log
end
end
|
ruby
|
{
"resource": ""
}
|
q24036
|
Bump.Application.action_bump
|
train
|
def action_bump
bump_info = create_bump_info
return false if bump_info.nil?
print_bump_plan bump_info
unless bump_info.valid?
print_invalid_bump_info bump_info
return false
end
bump_info.perform_update
report bump_info
save_bump_info bump_info
commit_and_tag bump_info if @options[:commit]
true
end
|
ruby
|
{
"resource": ""
}
|
q24037
|
Bump.Application.print_bump_plan
|
train
|
def print_bump_plan(bump_info)
level = bump_level
print_bump_plan_level level, bump_info unless level.nil?
preid = @options[:preid]
print_bump_plan_preid preid, bump_info unless preid.nil?
print_bump_plan_release bump_info if @options[:release]
log
end
|
ruby
|
{
"resource": ""
}
|
q24038
|
Bump.Application.print_bump_plan_preid
|
train
|
def print_bump_plan_preid(preid, bump_info)
bump_info.preid = preid
log 'Set pre-release version id: ', false
log_green preid
print_version_transition bump_info
end
|
ruby
|
{
"resource": ""
}
|
q24039
|
Omniship.UPS.create_shipment
|
train
|
def create_shipment(origin, destination, packages, options={})
@options = @options.merge(options)
origin, destination = upsified_location(origin), upsified_location(destination)
options = @options.merge(options)
options[:test] = options[:test].nil? ? true : options[:test]
packages = Array(packages)
access_request = build_access_request
ship_confirm_request = build_ship_confirm(origin, destination, packages, options)
response = commit(:shipconfirm, save_request(access_request.gsub("\n", "") + ship_confirm_request.gsub("\n", "")), options[:test])
parse_ship_confirm_response(origin, destination, packages, response, options)
end
|
ruby
|
{
"resource": ""
}
|
q24040
|
Ansible.Vault.write
|
train
|
def write
file = FileWriter.new(@path)
encryptor = Encryptor.new(password: @password, file: file)
encryptor.encrypt(@plaintext)
file.write
end
|
ruby
|
{
"resource": ""
}
|
q24041
|
Ansible.Vault.read
|
train
|
def read
file = FileReader.new(@path)
return File.read(@path) unless file.encrypted?
decryptor = Decryptor.new(password: @password, file: file)
decryptor.plaintext
end
|
ruby
|
{
"resource": ""
}
|
q24042
|
JSchema.ValidationHelpers.non_empty_array?
|
train
|
def non_empty_array?(value, uniqueness_check = true)
result = value.is_a?(Array) && !value.empty?
if uniqueness_check
result && value.size == value.uniq.size
else
result
end
end
|
ruby
|
{
"resource": ""
}
|
q24043
|
JSchema.ValidationHelpers.schema_array?
|
train
|
def schema_array?(value, id, uniqueness_check = true)
non_empty_array?(value, uniqueness_check) &&
value.to_enum.with_index.all? do |schema, index|
full_id = [id, index].join('/')
valid_schema? schema, full_id
end
end
|
ruby
|
{
"resource": ""
}
|
q24044
|
JSchema.ValidationHelpers.valid_schema?
|
train
|
def valid_schema?(schema, id)
schema.is_a?(Hash) && Schema.build(schema, parent, id)
rescue InvalidSchema
false
end
|
ruby
|
{
"resource": ""
}
|
q24045
|
Redmine.AcceptJson.get
|
train
|
def get(path, headers = {})
response = super(path, { 'Accept' => ACCEPT }.merge(headers.to_h))
case response.content_type
when CONTENT_TYPE then [parse_response(response), response]
else raise "Unknown content type #{response.content_type.inspect}"
end
end
|
ruby
|
{
"resource": ""
}
|
q24046
|
Kondate.HashExt.deep_merge!
|
train
|
def deep_merge!(other_hash, &block)
other_hash.each_pair do |current_key, other_value|
this_value = self[current_key]
self[current_key] = if this_value.is_a?(Hash) && other_value.is_a?(Hash)
_this_value = HashExt.new.replace(this_value)
_this_value.deep_merge(other_value, &block).to_h
else
if block_given? && key?(current_key)
block.call(current_key, this_value, other_value)
else
other_value
end
end
end
self
end
|
ruby
|
{
"resource": ""
}
|
q24047
|
RestfulResource.Request.format_headers
|
train
|
def format_headers
@headers.stringify_keys.each_with_object({}) do |key_with_value, headers|
headers[format_key(key_with_value.first)] = key_with_value.last
end
end
|
ruby
|
{
"resource": ""
}
|
q24048
|
CFoundry.Zip.unpack
|
train
|
def unpack(file, dest)
::Zip::ZipFile.foreach(file) do |zentry|
epath = "#{dest}/#{zentry}"
dirname = File.dirname(epath)
FileUtils.mkdir_p(dirname) unless File.exists?(dirname)
zentry.extract(epath) unless File.exists?(epath)
end
end
|
ruby
|
{
"resource": ""
}
|
q24049
|
CFoundry.Zip.files_to_pack
|
train
|
def files_to_pack(dir)
Dir.glob("#{dir}/**/*", File::FNM_DOTMATCH).select do |f|
File.exists?(f) &&
PACK_EXCLUSION_GLOBS.none? do |e|
File.fnmatch(e, File.basename(f))
end
end
end
|
ruby
|
{
"resource": ""
}
|
q24050
|
CFoundry.Zip.pack
|
train
|
def pack(dir, zipfile)
files = files_to_pack(dir)
return false if files.empty?
::Zip::ZipFile.open(zipfile, true) do |zf|
files.each do |f|
zf.add(f.sub("#{dir}/",''), f)
end
end
true
end
|
ruby
|
{
"resource": ""
}
|
q24051
|
Effective.FormBuilder.remote_link_to
|
train
|
def remote_link_to(name, url, options = {}, &block)
options[:href] ||= url
Effective::FormInputs::RemoteLinkTo.new(name, options, builder: self).to_html(&block)
end
|
ruby
|
{
"resource": ""
}
|
q24052
|
Slackbotsy.Api.get_objects
|
train
|
def get_objects(method, key)
self.class.get("/#{method}", query: { token: @token }).tap do |response|
raise "error retrieving #{key} from #{method}: #{response.fetch('error', 'unknown error')}" unless response['ok']
end.fetch(key)
end
|
ruby
|
{
"resource": ""
}
|
q24053
|
Slackbotsy.Api.join
|
train
|
def join(channel)
self.class.post('/channels.join', body: {name: channel, token: @token}).tap do |response|
raise "error posting message: #{response.fetch('error', 'unknown error')}" unless response['ok']
end
end
|
ruby
|
{
"resource": ""
}
|
q24054
|
Slackbotsy.Api.post_message
|
train
|
def post_message(params)
self.class.post('/chat.postMessage', body: params.merge({token: @token})).tap do |response|
raise "error posting message: #{response.fetch('error', 'unknown error')}" unless response['ok']
end
end
|
ruby
|
{
"resource": ""
}
|
q24055
|
CFoundry.UploadHelpers.prune_empty_directories
|
train
|
def prune_empty_directories(path)
all_files = all_files(path)
directories = all_files.select { |x| File.directory?(x) }
directories.sort! { |a, b| b.size <=> a.size }
directories.each do |directory|
entries = all_files(directory)
FileUtils.rmdir(directory) if entries.empty?
end
end
|
ruby
|
{
"resource": ""
}
|
q24056
|
Slackbotsy.Bot.setup_incoming_webhook
|
train
|
def setup_incoming_webhook
## incoming_webhook will be used if provided, otherwise fallback to old-style url with team and token
url = @options.fetch('incoming_webhook', false) || "https://#{@options['team']}.slack.com/services/hooks/incoming-webhook?token=#{@options['incoming_token']}"
@uri = URI.parse(url)
@http = Net::HTTP.new(@uri.host, @uri.port)
@http.use_ssl = true
@http.verify_mode = OpenSSL::SSL::VERIFY_PEER
end
|
ruby
|
{
"resource": ""
}
|
q24057
|
Slackbotsy.Bot.post
|
train
|
def post(options)
payload = {
username: @options['name'],
channel: @options['channel']
}.merge(options)
payload[:channel] = payload[:channel].gsub(/^#?/, '#') #slack api needs leading # on channel
request = Net::HTTP::Post.new(@uri.request_uri)
request.set_form_data(payload: payload.to_json)
@http.request(request)
return nil # so as not to trigger text in outgoing webhook reply
end
|
ruby
|
{
"resource": ""
}
|
q24058
|
Slackbotsy.Bot.hear
|
train
|
def hear(regex, &block)
@listeners << OpenStruct.new(regex: regex, desc: @last_desc, proc: block)
@last_desc = nil
end
|
ruby
|
{
"resource": ""
}
|
q24059
|
Slackbotsy.Bot.eval_scripts
|
train
|
def eval_scripts(*files)
files.flatten.each do |file|
self.instance_eval(File.open(file).read)
end
end
|
ruby
|
{
"resource": ""
}
|
q24060
|
Slackbotsy.Bot.handle_outgoing_webhook
|
train
|
def handle_outgoing_webhook(msg)
return nil unless @options['outgoing_token'].include?(msg[:token]) # ensure messages are for us from slack
return nil if msg[:user_name] == 'slackbot' # do not reply to self
return nil unless msg[:text].is_a?(String) # skip empty messages
responses = get_responses(msg, msg[:text].strip)
if responses
{ text: responses.compact.join("\n") }.to_json # webhook responses are json
end
end
|
ruby
|
{
"resource": ""
}
|
q24061
|
Slackbotsy.Bot.get_responses
|
train
|
def get_responses(msg, text)
message = Slackbotsy::Message.new(self, msg)
@listeners.map do |listener|
text.match(listener.regex) do |mdata|
begin
message.instance_exec(mdata, *mdata[1..-1], &listener.proc)
rescue => err # keep running even with a broken script, but report the error
err
end
end
end
end
|
ruby
|
{
"resource": ""
}
|
q24062
|
CFoundry::V2.Client.current_user
|
train
|
def current_user
return unless token
token_data = @base.token.token_data
if guid = token_data[:user_id]
user = user(guid)
user.emails = [{ :value => token_data[:email] }]
user
end
end
|
ruby
|
{
"resource": ""
}
|
q24063
|
Twittbot.Bot.auth
|
train
|
def auth
require 'oauth'
say "This will reset your current access tokens.", :red if already_authed?
# get the request token URL
callback = OAuth::OUT_OF_BAND
consumer = OAuth::Consumer.new $bot[:config][:consumer_key],
$bot[:config][:consumer_secret],
site: Twitter::REST::Client::BASE_URL,
scheme: :header
request_token = consumer.get_request_token(oauth_callback: callback)
url = request_token.authorize_url(oauth_callback: callback)
puts "Open this URL in a browser: #{url}"
pin = ''
until pin =~ /^\d+$/
print "Enter PIN =>"
pin = $stdin.gets.strip
end
access_token = request_token.get_access_token(oauth_verifier: pin)
$bot[:config][:access_token] = access_token.token
$bot[:config][:access_token_secret] = access_token.secret
# get the bot's user name (screen_name) and print it to the console
$bot[:config][:screen_name] = get_screen_name access_token
puts "Hello, #{$bot[:config][:screen_name]}!"
end
|
ruby
|
{
"resource": ""
}
|
q24064
|
Twittbot.Bot.start
|
train
|
def start
check_config
init_clients
if $bot[:stream]
puts "connecting to streaming APIs"
@userstream_thread ||= Thread.new do
loop do
begin
puts "connected to user stream"
@streamer.user do |obj|
handle_stream_object obj, :user
end
rescue => e
puts "lost user stream connection: " + e.message
end
puts "reconnecting in #{Twittbot::RECONNECT_WAIT_TIME} seconds..."
sleep Twittbot::RECONNECT_WAIT_TIME
end
end
@tweetstream_thread ||= Thread.new do
loop do
begin
puts "connected to tweet stream"
@streamer.filter track: $bot[:config][:track].join(",") do |obj|
handle_stream_object obj, :filter
end
rescue
puts "lost tweet stream connection: " + e.message
end
puts "reconnecting in #{Twittbot::RECONNECT_WAIT_TIME} seconds..."
sleep Twittbot::RECONNECT_WAIT_TIME
end
end
end
@periodic_thread ||= Thread.new do
loop do
begin
Thread.new { do_periodic }
rescue => _
end
sleep 60
end
end
do_callbacks :load, nil
if $bot[:stream]
@userstream_thread.join
@tweetstream_thread.join
end
@periodic_thread.join
end
|
ruby
|
{
"resource": ""
}
|
q24065
|
Twittbot.Bot.load_bot_code
|
train
|
def load_bot_code
load_special_tasks
files = Dir["#{File.expand_path('./lib', @options[:current_dir])}/**/*"]
files.each do |file|
require_relative file.sub(/\.rb$/, '') if file.end_with? '.rb'
end
end
|
ruby
|
{
"resource": ""
}
|
q24066
|
Twittbot.Bot.do_callbacks
|
train
|
def do_callbacks(callback_type, object, options = {})
return if $bot[:callbacks][callback_type].nil?
$bot[:callbacks][callback_type].each do |c|
c[:block].call object, options
end
end
|
ruby
|
{
"resource": ""
}
|
q24067
|
Twittbot.Bot.do_direct_message
|
train
|
def do_direct_message(dm, opts = {})
return if dm.sender.screen_name == $bot[:config][:screen_name]
return do_callbacks(:direct_message, dm, opts) unless dm.text.start_with? $bot[:config][:dm_command_prefix]
dm_text = dm.text.sub($bot[:config][:dm_command_prefix], '').strip
return if dm_text.empty?
return unless /(?<command>[A-Za-z0-9]+)(?:\s*)(?<args>.*)/m =~ dm_text
command = Regexp.last_match(:command).to_sym
args = Regexp.last_match :args
cmd = $bot[:commands][command]
return say_status :dm, "#{dm.sender.screen_name} tried to issue non-existent command :#{command}, ignoring", :cyan if cmd.nil?
return say_status :dm, "#{dm.sender.screen_name} tried to issue admin command :#{command}, ignoring", :cyan if cmd[:admin] and !dm.sender.admin?
say_status :dm, "#{dm.sender.screen_name} issued command :#{command}", :cyan
cmd[:block].call(args, dm.sender)
end
|
ruby
|
{
"resource": ""
}
|
q24068
|
Twittbot.Bot.list_tasks
|
train
|
def list_tasks
tasks = $bot[:tasks].map do |name, value|
[name, value[:desc]]
end.to_h
longest_name = tasks.keys.map(&:to_s).max { |a, b| a.length <=> b.length }.length
tasks = tasks.map do |name, desc|
"twittbot cron %-*s # %s" % [longest_name + 2, name, desc]
end.sort
puts tasks
end
|
ruby
|
{
"resource": ""
}
|
q24069
|
Phys.Quantity.want
|
train
|
def want(unit=nil)
case unit
when Unit
expr = unit.expr
when Quantity
expr = unit.expr
unit = unit.unit
when String,Symbol
expr = unit
unit = Unit.parse(expr)
when Numeric
unit = Unit.cast(unit)
when NilClass
unit = Unit.cast(1)
else
raise TypeError, "invalid argument: #{unit.inspect}"
end
val = unit.convert(self)
self.class.new( val, expr, unit )
end
|
ruby
|
{
"resource": ""
}
|
q24070
|
Phys.Quantity.close_to
|
train
|
def close_to(other,epsilon=Float::EPSILON)
other_value = @unit.convert(other)
abs_sum = @value.abs+other_value.abs
(@value-other_value).abs <= abs_sum*epsilon
end
|
ruby
|
{
"resource": ""
}
|
q24071
|
Phys.Quantity.to_base_unit
|
train
|
def to_base_unit
unit = @unit.base_unit
val = unit.convert(self)
expr = unit.unit_string
self.class.new( val, expr, unit )
end
|
ruby
|
{
"resource": ""
}
|
q24072
|
Phys.Quantity.inspect
|
train
|
def inspect
expr = @expr || @unit.expr
expr = (expr) ? ","+expr.inspect : ""
sufx = (@@verbose_inspect) ? " "[email protected] : ""
self.class.to_s+"["+Unit::Utils.num_inspect(@value)+expr+"]"+sufx
end
|
ruby
|
{
"resource": ""
}
|
q24073
|
LIS::Message.Base.to_message
|
train
|
def to_message
@fields ||= {}
arr = Array.new(self.class.default_fields)
type_id + @fields.inject(arr) { |a,(k,v)| a[k-1] = v; a }.join("|")
end
|
ruby
|
{
"resource": ""
}
|
q24074
|
Slaw.ActGenerator.guess_section_number_after_title
|
train
|
def guess_section_number_after_title(text)
before = text.scan(/^\w{4,}[^\n]+\n\d+\. /).length
after = text.scan(/^\s*\n\d+\. \w{4,}/).length
before > after * 1.25
end
|
ruby
|
{
"resource": ""
}
|
q24075
|
Slaw.ActGenerator.text_from_act
|
train
|
def text_from_act(doc)
# look on the load path for an XSL file for this grammar
filename = "/slaw/grammars/#{@grammar}/act_text.xsl"
if dir = $LOAD_PATH.find { |p| File.exist?(p + filename) }
xslt = Nokogiri::XSLT(File.read(dir + filename))
xslt.transform(doc).child.to_xml
else
raise "Unable to find text XSL for grammar #{@grammar}: #{fragment}"
end
end
|
ruby
|
{
"resource": ""
}
|
q24076
|
ThreeScale.Client.authorize
|
train
|
def authorize(options)
extensions = options.delete :extensions
creds = creds_params(options)
path = "/transactions/authorize.xml" + options_to_params(options, ALL_PARAMS) + '&' + creds
headers = extensions_to_header extensions if extensions
http_response = @http.get(path, headers: headers)
case http_response
when Net::HTTPSuccess,Net::HTTPConflict
build_authorize_response(http_response.body)
when Net::HTTPClientError
build_error_response(http_response.body, AuthorizeResponse)
else
raise ServerError.new(http_response)
end
end
|
ruby
|
{
"resource": ""
}
|
q24077
|
ThreeScale.Client.usage_report
|
train
|
def usage_report(node)
period_start = node.at('period_start')
period_end = node.at('period_end')
{ :metric => node['metric'].to_s.strip,
:period => node['period'].to_s.strip.to_sym,
:period_start => period_start ? period_start.content : '',
:period_end => period_end ? period_end.content : '',
:current_value => node.at('current_value').content.to_i,
:max_value => node.at('max_value').content.to_i }
end
|
ruby
|
{
"resource": ""
}
|
q24078
|
ThreeScale.Client.generate_creds_params
|
train
|
def generate_creds_params
define_singleton_method :creds_params,
if @service_tokens
lambda do |options|
token = options.delete(:service_token)
service_id = options[:service_id]
raise ArgumentError, "need to specify a service_token and a service_id" unless token && service_id
'service_token='.freeze + CGI.escape(token)
end
elsif @provider_key
warn DEPRECATION_MSG_PROVIDER_KEY if @warn_deprecated
lambda do |_|
"provider_key=#{CGI.escape @provider_key}".freeze
end
else
raise ArgumentError, 'missing credentials - either use "service_tokens: true" or specify a provider_key value'
end
end
|
ruby
|
{
"resource": ""
}
|
q24079
|
Twitter.Tweet.reply
|
train
|
def reply(tweet_text, options = {})
return if $bot.nil? or $bot[:client].nil?
opts = {
reply_all: false
}.merge(options)
mentions = self.mentioned_users(opts[:reply_all])
result = "@#{mentions.join(" @")} #{tweet_text}"[(0...140)]
$bot[:client].update result, in_reply_to_status_id: self.id
rescue Twitter::Error => e
puts "caught Twitter error while replying: #{e.message}"
end
|
ruby
|
{
"resource": ""
}
|
q24080
|
Twitter.Tweet.mentioned_users
|
train
|
def mentioned_users(reply_all = true, screen_name = $bot[:config][:screen_name])
userlist = [ self.user.screen_name ]
if reply_all
self.text.scan /@([A-Za-z0-9_]{1,16})/ do |user_name|
user_name = user_name[0]
userlist << user_name unless userlist.include?(user_name) or screen_name == user_name
end
end
userlist
end
|
ruby
|
{
"resource": ""
}
|
q24081
|
Twitter.DirectMessage.reply
|
train
|
def reply(direct_message_text)
return if $bot.nil? or $bot[:client].nil?
$bot[:client].create_direct_message self.sender.id, direct_message_text
rescue Twitter::Error => e
puts "caught Twitter error while replying via DM: #{e.message}"
end
|
ruby
|
{
"resource": ""
}
|
q24082
|
Sinew.Request.perform
|
train
|
def perform
validate!
party_options = options.dup
# merge proxy
if proxy = self.proxy
addr, port = proxy.split(':')
party_options[:http_proxyaddr] = addr
party_options[:http_proxyport] = port || 80
end
# now merge runtime_options
party_options = party_options.merge(sinew.runtime_options.httparty_options)
# merge headers
headers = sinew.runtime_options.headers
headers = headers.merge(party_options[:headers]) if party_options[:headers]
party_options[:headers] = headers
party_response = HTTParty.send(method, uri, party_options)
Response.from_network(self, party_response)
end
|
ruby
|
{
"resource": ""
}
|
q24083
|
Sinew.Request.parse_url
|
train
|
def parse_url(url)
s = url
# remove entities
s = HTML_ENTITIES.decode(s)
# fix a couple of common encoding bugs
s = s.gsub(' ', '%20')
s = s.gsub("'", '%27')
# append query manually (instead of letting HTTParty handle it) so we can
# include it in cache_key
query = options.delete(:query)
if query.present?
q = HTTParty::HashConversions.to_params(query)
separator = s.include?('?') ? '&' : '?'
s = "#{s}#{separator}#{q}"
end
URI.parse(s)
end
|
ruby
|
{
"resource": ""
}
|
q24084
|
Twittbot.BotPart.cmd
|
train
|
def cmd(name, options = {}, &block)
raise "Command already exists: #{name}" if $bot[:commands].include? name
raise "Command name does not contain only alphanumerical characters" unless name.to_s.match /\A[A-Za-z0-9]+\z/
opts = {
admin: true
}.merge(options)
$bot[:commands][name] ||= {
admin: opts[:admin],
block: block
}
end
|
ruby
|
{
"resource": ""
}
|
q24085
|
Twittbot.BotPart.task
|
train
|
def task(name, options = {}, &block)
name = name.to_s.downcase.to_sym
task_re = /\A[a-z0-9.:-_]+\z/
raise "Task already exists: #{name}" if $bot[:tasks].include?(name)
raise "Task name does not match regexp #{task_re.to_s}" unless name.to_s.match(task_re)
opts = {
desc: ''
}.merge(options)
$bot[:tasks][name] ||= {
block: block,
desc: opts[:desc]
}
end
|
ruby
|
{
"resource": ""
}
|
q24086
|
Twittbot.BotPart.save_config
|
train
|
def save_config
botpart_config = Hash[@config.to_a - $bot[:config].to_a]
unless botpart_config.empty?
File.open @botpart_config_path, 'w' do |f|
f.write botpart_config.to_yaml
end
end
end
|
ruby
|
{
"resource": ""
}
|
q24087
|
CFoundry::V2.App.health
|
train
|
def health
if state == "STARTED"
healthy_count = running_instances
expected = total_instances
if expected > 0
ratio = healthy_count / expected.to_f
if ratio == 1.0
"RUNNING"
else
"#{(ratio * 100).to_i}%"
end
else
"N/A"
end
else
state
end
rescue CFoundry::StagingError, CFoundry::NotStaged
"STAGING FAILED"
end
|
ruby
|
{
"resource": ""
}
|
q24088
|
CFoundry::V2.App.bind
|
train
|
def bind(*instances)
instances.each do |i|
binding = @client.service_binding
binding.app = self
binding.service_instance = i
binding.create!
end
self
end
|
ruby
|
{
"resource": ""
}
|
q24089
|
CFoundry::V2.App.unbind
|
train
|
def unbind(*instances)
service_bindings.each do |b|
if instances.include? b.service_instance
b.delete!
end
end
self
end
|
ruby
|
{
"resource": ""
}
|
q24090
|
Metar.Station.parser
|
train
|
def parser
raw = Metar::Raw::Noaa.new(@cccc)
Metar::Parser.new(raw)
end
|
ruby
|
{
"resource": ""
}
|
q24091
|
Openfoodfacts.Product.weburl
|
train
|
def weburl(locale: nil, domain: DEFAULT_DOMAIN)
locale ||= self.lc || DEFAULT_LOCALE
if self.code && prefix = LOCALE_WEBURL_PREFIXES[locale]
path = "#{prefix}/#{self.code}"
"https://#{locale}.#{domain}/#{path}"
end
end
|
ruby
|
{
"resource": ""
}
|
q24092
|
Metar.Parser.seek_visibility
|
train
|
def seek_visibility
if observer.value == :auto # WMO 15.4
if @chunks[0] == '////'
@chunks.shift # Simply dispose of it
return
end
end
if @chunks[0] == '1' or @chunks[0] == '2'
@visibility = Metar::Data::Visibility.parse(@chunks[0] + ' ' + @chunks[1])
if @visibility
@chunks.shift
@chunks.shift
end
else
@visibility = Metar::Data::Visibility.parse(@chunks[0])
if @visibility
@chunks.shift
end
end
@visibility
end
|
ruby
|
{
"resource": ""
}
|
q24093
|
Phys.Unit.inspect
|
train
|
def inspect
use_dimension
a = [Utils.num_inspect(@factor), @dim.inspect]
a << "@name="[email protected] if @name
a << "@expr="[email protected] if @expr
a << "@offset="[email protected] if @offset
a << "@dimensionless=true" if @dimensionless
if @dimension_value && @dimension_value!=1
a << "@dimension_value="+@dimension_value.inspect
end
s = a.join(",")
"#<#{self.class} #{s}>"
end
|
ruby
|
{
"resource": ""
}
|
q24094
|
Phys.Unit.unit_string
|
train
|
def unit_string
use_dimension
a = []
a << Utils.num_inspect(@factor) if @factor!=1
a += @dim.map do |k,d|
if d==1
k
else
"#{k}^#{d}"
end
end
a.join(" ")
end
|
ruby
|
{
"resource": ""
}
|
q24095
|
Phys.Unit.conversion_factor
|
train
|
def conversion_factor
use_dimension
f = @factor
@dim.each do |k,d|
if d != 0
u = LIST[k]
if u.dimensionless?
f *= u.dimension_value**d
end
end
end
f
end
|
ruby
|
{
"resource": ""
}
|
q24096
|
Phys.Unit.convert
|
train
|
def convert(quantity)
if Quantity===quantity
assert_same_dimension(quantity.unit)
v = quantity.unit.convert_value_to_base_unit(quantity.value)
convert_value_from_base_unit(v)
else
quantity / to_numeric
end
end
|
ruby
|
{
"resource": ""
}
|
q24097
|
Phys.Unit.convert_scale
|
train
|
def convert_scale(quantity)
if Quantity===quantity
assert_same_dimension(quantity.unit)
v = quantity.value * quantity.unit.conversion_factor
v = v / self.conversion_factor
else
quantity / to_numeric
end
end
|
ruby
|
{
"resource": ""
}
|
q24098
|
Phys.Unit.+
|
train
|
def +(x)
x = Unit.cast(x)
check_operable2(x)
assert_same_dimension(x)
Unit.new(@factor+x.factor,@dim.dup)
end
|
ruby
|
{
"resource": ""
}
|
q24099
|
Phys.Unit.*
|
train
|
def *(x)
x = Unit.cast(x)
if scalar?
return x
elsif x.scalar?
return self.dup
end
check_operable2(x)
dims = dimension_binop(x){|a,b| a+b}
factor = self.factor * x.factor
Unit.new(factor,dims)
end
|
ruby
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.