_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3 values | text stringlengths 66 10.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q20200 | Ruote.DispatchPool.dispatch_cancel | train | def dispatch_cancel(msg)
flavour = msg['flavour']
participant = @context.plist.instantiate(msg['participant'])
result = begin
Ruote.participant_send(
participant,
[ :on_cancel, :cancel ],
'fei' => Ruote::FlowExpressionId.new(msg['fei']),
'flavour' => flavour)
rescue => e
raise(e) if flavour != 'kill'
end
@context.storage.put_msg(
'reply',
'fei' => msg['fei'],
'workitem' => msg['workitem']
) if result != false
end | ruby | {
"resource": ""
} |
q20201 | Ruote.ReceiverMixin.receive | train | def receive(workitem)
workitem = workitem.to_h if workitem.respond_to?(:to_h)
@context.storage.put_msg(
'receive',
'fei' => workitem['fei'],
'workitem' => workitem,
'participant_name' => workitem['participant_name'],
'receiver' => sign)
end | ruby | {
"resource": ""
} |
q20202 | Ruote.ReceiverMixin.flunk | train | def flunk(workitem, error_class_or_instance_or_message, *err_arguments)
err = error_class_or_instance_or_message
trace = Ruote.pop_trace(err_arguments)
err =
case err
when Exception
err
when Class
err.new(*err_arguments)
when String
begin
Ruote.constantize(err).new(*err_arguments)
rescue #NameError # rescue instanciation errors too
RuntimeError.new(err)
end
else
ArgumentError.new(
"flunk() failed, cannot bring back err from #{err.inspect}")
end
err.set_backtrace(trace || err.backtrace || caller)
workitem = workitem.to_h if workitem.respond_to?(:to_h)
at = Ruote.now_to_utc_s
@context.storage.put_msg(
'raise',
'fei' => workitem['fei'],
'wfid' => workitem['wfid'],
'msg' => {
'action' => 'dispatch',
'fei' => workitem['fei'],
'participant_name' => workitem['participant_name'],
'participant' => nil,
'workitem' => workitem,
'put_at' => at
},
'error' => {
'class' => err.class.name,
'message' => err.message,
'trace' => err.backtrace,
'at' => at,
'details' => err.respond_to?(:ruote_details) ? err.ruote_details : nil
})
end | ruby | {
"resource": ""
} |
q20203 | Ruote.ReceiverMixin.launch | train | def launch(process_definition, fields={}, variables={}, root_stash=nil)
#puts caller.select { |l|
# ! (l.match(/test\/unit[\.\/]/) or l.match(/\/rspec-core-/))
#} if @context.logger.noisy
#
# this is useful when noisy and running through a set of tests
wfid = fields[:wfid] || @context.wfidgen.generate
fields = Rufus::Json.dup(fields)
variables = Rufus::Json.dup(variables)
root_stash = Rufus::Json.dup(root_stash)
#
# making sure symbols are turned to strings
@context.storage.put_msg(
'launch',
'wfid' => wfid,
'tree' => @context.reader.read(process_definition),
'workitem' => { 'fields' => fields },
'variables' => variables,
'stash' => root_stash)
wfid
end | ruby | {
"resource": ""
} |
q20204 | Ruote.ReceiverMixin.fetch_flow_expression | train | def fetch_flow_expression(workitem_or_fei)
Ruote::Exp::FlowExpression.fetch(
@context,
Ruote::FlowExpressionId.extract_h(workitem_or_fei))
end | ruby | {
"resource": ""
} |
q20205 | Ruote.ReceiverMixin.stash_get | train | def stash_get(workitem_or_fei, key=nil)
stash = fetch_flow_expression(workitem_or_fei).h['stash'] rescue nil
stash ||= {}
key ? stash[key] : stash
end | ruby | {
"resource": ""
} |
q20206 | Ruote.Worker.inactive? | train | def inactive?
# the cheaper tests first
return false if @msgs.size > 0
return false unless @context.storage.empty?('schedules')
return false unless @context.storage.empty?('msgs')
wfids = @context.storage.get_many('expressions').collect { |exp|
exp['fei']['wfid']
}
error_wfids = @context.storage.get_many('errors').collect { |err|
err['fei']['wfid']
}
(wfids - error_wfids == [])
end | ruby | {
"resource": ""
} |
q20207 | Ruote.Worker.turn_schedule_to_msg | train | def turn_schedule_to_msg(schedule)
return false unless @storage.reserve(schedule)
msg = Ruote.fulldup(schedule['msg'])
@storage.put_msg(msg.delete('action'), msg)
true
end | ruby | {
"resource": ""
} |
q20208 | Ruote.Worker.process | train | def process(msg)
return false unless @storage.reserve(msg)
begin
@context.pre_notify(msg)
case msg['action']
when 'launch', 'apply', 'regenerate'
launch(msg)
when *EXP_ACTIONS
Ruote::Exp::FlowExpression.do_action(@context, msg)
when *DISP_ACTIONS
@context.dispatch_pool.handle(msg)
when *PROC_ACTIONS
self.send(msg['action'], msg)
when 'reput'
reput(msg)
when 'raise'
@context.error_handler.msg_handle(msg['msg'], msg['error'])
when 'respark'
respark(msg)
#else
# no special processing required for message, let it pass
# to the subscribers (the notify two lines after)
end
@context.notify(msg)
# notify subscribers of successfully processed msgs
rescue => err
@context.error_handler.msg_handle(msg, err)
end
@context.storage.done(msg) if @context.storage.respond_to?(:done)
@info << msg if @info
# for the stats
true
end | ruby | {
"resource": ""
} |
q20209 | Ruote.Worker.launch | train | def launch(msg)
tree = msg['tree']
variables = msg['variables']
wi = msg['workitem']
exp_class = @context.expmap.expression_class(tree.first)
# msg['wfid'] only: it's a launch
# msg['fei']: it's a sub launch (a supplant ?)
if is_launch?(msg, exp_class)
name = tree[1]['name'] || tree[1].keys.find { |k| tree[1][k] == nil }
revision = tree[1]['revision'] || tree[1]['rev']
wi['wf_name'] ||= name
wi['wf_revision'] ||= revision
wi['wf_launched_at'] ||= Ruote.now_to_utc_s
wi['sub_wf_name'] = name
wi['sub_wf_revision'] = revision
wi['sub_wf_launched_at'] = Ruote.now_to_utc_s
end
exp_hash = {
'fei' => msg['fei'] || {
'engine_id' => @context.engine_id,
'wfid' => msg['wfid'],
'subid' => Ruote.generate_subid(msg.inspect),
'expid' => msg['expid'] || '0' },
'parent_id' => msg['parent_id'],
'variables' => variables,
'applied_workitem' => wi,
'forgotten' => msg['forgotten'],
'lost' => msg['lost'],
'flanking' => msg['flanking'],
'attached' => msg['attached'],
'supplanted' => msg['supplanted'],
'stash' => msg['stash'],
'trigger' => msg['trigger'],
'on_reply' => msg['on_reply']
}
if not exp_class
exp_class = Ruote::Exp::RefExpression
elsif is_launch?(msg, exp_class)
def_name, tree = Ruote::Exp::DefineExpression.reorganize(tree)
variables[def_name] = [ '0', tree ] if def_name
exp_class = Ruote::Exp::SequenceExpression
end
exp_hash = exp_hash.reject { |k, v| v.nil? }
# compact nils away
exp_hash['original_tree'] = tree
# keep track of original tree
exp = exp_class.new(@context, exp_hash)
exp.initial_persist
exp.do(:apply, msg)
end | ruby | {
"resource": ""
} |
q20210 | Ruote.Worker.pause_process | train | def pause_process(msg)
root = @storage.find_root_expression(msg['wfid'])
return unless root
@storage.put_msg(
msg['action'] == 'pause_process' ? 'pause' : 'resume',
'fei' => root['fei'],
'wfid' => msg['wfid']) # it was triggered by {pause|resume}_process
end | ruby | {
"resource": ""
} |
q20211 | Ruote.Worker.reput | train | def reput(msg)
if doc = msg['doc']
r = @storage.put(doc)
return unless r.is_a?(Hash)
doc['_rev'] = r['_rev']
reput(msg)
elsif msg = msg['msg']
@storage.put_msg(msg['action'], msg)
end
end | ruby | {
"resource": ""
} |
q20212 | Ruote::Exp.FilterExpression.block_filter | train | def block_filter
return nil if tree.last.empty?
tree.last.collect { |line|
next 'or' if line.first == 'or'
rule = line[1].remap { |(k, v), h|
if v == nil
h['field'] = k
else
h[k] = v
end
}
rule['field'] ||= line.first
rule
}
end | ruby | {
"resource": ""
} |
q20213 | Ruote::Exp.FilterExpression.one_line_filter | train | def one_line_filter
if (attributes.keys - COMMON_ATT_KEYS - %w[ ref original_ref ]).empty?
return nil
end
[ attributes.remap { |(k, v), h|
if v.nil?
h['field'] = k
else
h[k] = v
end
} ]
end | ruby | {
"resource": ""
} |
q20214 | Ruote::Exp.FlowExpression.compile_variables | train | def compile_variables
vars = h.parent_id ? parent.compile_variables : {}
vars.merge!(h.variables) if h.variables
vars
end | ruby | {
"resource": ""
} |
q20215 | Ruote::Exp.FlowExpression.unset_variable | train | def unset_variable(var, override=false)
fexp, v = locate_set_var(var, override) || locate_var(var)
fexp.un_set_variable(:unset, v, nil, (fexp.h.fei != h.fei)) if fexp
end | ruby | {
"resource": ""
} |
q20216 | Ruote::Exp.FlowExpression.split_prefix | train | def split_prefix(var, prefix)
if prefix.nil?
m = VAR_PREFIX_REGEX.match(var.to_s)
prefix = m[1]
var = m[2]
end
[ var, prefix ]
end | ruby | {
"resource": ""
} |
q20217 | Ruote.Mutation.walk | train | def walk(fexp, tree)
ftree = Ruote.compact_tree(@ps.current_tree(fexp))
if ftree[0] != tree[0] || ftree[1] != tree[1]
#
# if there is anything different between the current tree and the
# desired tree, let's force a re-apply
register(MutationPoint.new(fexp.fei, tree, :re_apply))
elsif ftree[2] == tree[2]
#
# else, if the tree children are the same, exit, there is nothing to do
return
else
register(MutationPoint.new(fexp.fei, tree, :update))
#
# NOTE: maybe a switch for this mutation not to be added would
# be necessary...
if fexp.is_concurrent?
#
# concurrent expressions follow a different heuristic
walk_concurrence(fexp, ftree, tree)
else
#
# all other expressions are considered sequence-like
walk_sequence(fexp, ftree, tree)
end
end
end | ruby | {
"resource": ""
} |
q20218 | Ruote.Mutation.walk_sequence | train | def walk_sequence(fexp, ftree, tree)
i = fexp.child_ids.first
ehead = ftree[2].take(i)
ecurrent = ftree[2][i]
etail = ftree[2].drop(i + 1)
head = tree[2].take(i)
current = tree[2][i]
tail = tree[2].drop(i + 1)
if ehead != head
#
# if the name and/or attributes of the exp are supposed to change
# then we have to reapply it
#
register(MutationPoint.new(fexp.fei, tree, :re_apply))
return
end
if ecurrent != current
#
# if the child currently applied is supposed to change, let's walk
# it down
#
walk(@ps.fexp(fexp.children.first), current)
end
#if etail != tail
# #
# # if elements are added at the end of the sequence, let's register
# # a mutation that simply changes the tree (no need to re-apply)
# #
# register(MutationPoint.new(fexp.fei, tree, :update))
#end
end | ruby | {
"resource": ""
} |
q20219 | Ruote::Exp.CursorExpression.move_on | train | def move_on(workitem=h.applied_workitem)
position = workitem['fei'] == h.fei ?
-1 : Ruote::FlowExpressionId.child_id(workitem['fei'])
position += 1
com, arg = get_command(workitem)
return reply_to_parent(workitem) if com == 'break'
case com
when 'rewind', 'continue', 'reset' then position = 0
when 'skip' then position += arg
when 'jump' then position = jump_to(workitem, position, arg)
end
position = 0 if position >= tree_children.size && is_loop?
if position < tree_children.size
workitem = h.applied_workitem if com == 'reset'
apply_child(position, workitem)
else
reply_to_parent(workitem)
end
end | ruby | {
"resource": ""
} |
q20220 | Ruote::Exp.CursorExpression.jump_to | train | def jump_to(workitem, position, arg)
pos = Integer(arg) rescue nil
return pos if pos != nil
tree_children.each_with_index do |c, i|
found = [
c[0], # exp_name
c[1]['ref'], # ref
c[1]['tag'], # tag
(c[1].find { |k, v| v.nil? } || []).first # participant 'xxx'
].find do |v|
v ? (dsub(v, workitem) == arg) : false
end
if found then pos = i; break; end
end
pos ? pos : position
end | ruby | {
"resource": ""
} |
q20221 | Ruote.StorageBase.clear | train | def clear
%w[ msgs schedules errors expressions workitems ].each do |type|
purge_type!(type)
end
end | ruby | {
"resource": ""
} |
q20222 | Ruote.StorageBase.remove_process | train | def remove_process(wfid)
2.times do
# two passes
Thread.pass
%w[ schedules expressions errors workitems ].each do |type|
get_many(type, wfid).each { |d| delete(d) }
end
doc = get_trackers
doc['trackers'].delete_if { |k, v| k.end_with?("!#{wfid}") }
@context.storage.put(doc)
end
end | ruby | {
"resource": ""
} |
q20223 | Ruote.StorageBase.prepare_msg_doc | train | def prepare_msg_doc(action, options)
# merge! is way faster than merge (no object creation probably)
@counter ||= 0
t = Time.now.utc
ts = "#{t.strftime('%Y-%m-%d')}!#{t.to_i}.#{'%06d' % t.usec}"
_id = "#{$$}!#{Thread.current.object_id}!#{ts}!#{'%03d' % @counter}"
@counter = (@counter + 1) % 1000
# some platforms (windows) have shallow usecs, so adding that counter...
msg = options.merge!('type' => 'msgs', '_id' => _id, 'action' => action)
msg.delete('_rev')
# in case of message replay
msg
end | ruby | {
"resource": ""
} |
q20224 | Ruote.StorageBase.prepare_schedule_doc | train | def prepare_schedule_doc(flavour, owner_fei, s, msg)
at = if s.is_a?(Time) # at or every
s
elsif Ruote.cron_string?(s) # cron
Rufus::Scheduler::CronLine.new(s).next_time(Time.now + 1)
else # at or every
Ruote.s_to_at(s)
end
at = at.utc
if at <= Time.now.utc && flavour == 'at'
put_msg(msg.delete('action'), msg)
return false
end
sat = at.strftime('%Y%m%d%H%M%S')
i = "#{flavour}-#{Ruote.to_storage_id(owner_fei)}-#{sat}"
{
'_id' => i,
'type' => 'schedules',
'flavour' => flavour,
'original' => s,
'at' => Ruote.time_to_utc_s(at),
'owner' => owner_fei,
'wfid' => owner_fei['wfid'],
'msg' => msg
}
end | ruby | {
"resource": ""
} |
q20225 | Ruote::Exp.FlowExpression.handle_on_error | train | def handle_on_error(msg, error)
return false if h.state == 'failing'
err = deflate(error)
oe_parent = lookup_on_error(err)
return false unless oe_parent
# no parent with on_error attribute found
handler = oe_parent.local_on_error(err)
return false if handler.to_s == ''
# empty on_error handler nullifies ancestor's on_error
workitem = msg['workitem']
workitem['fields']['__error__'] = err
immediate =
if handler.is_a?(String)
!! handler.match(/^!/)
elsif handler.is_a?(Array)
!! handler.first.to_s.match(/^!/)
else
false
end
# NOTE: why not pass the handler in the msg?
# no, because of HandlerEntry (not JSON serializable)
@context.storage.put_msg(
'fail',
'fei' => oe_parent.h.fei,
'workitem' => workitem,
'immediate' => immediate)
true # yes, error is being handled.
end | ruby | {
"resource": ""
} |
q20226 | Ruote::Exp.FlowExpression.local_on_error | train | def local_on_error(err)
if h.on_error.is_a?(String) or Ruote.is_tree?(h.on_error)
return h.on_error
end
if h.on_error.is_a?(Array)
# all for the 'on_error' expression
# see test/functional/eft_38_
h.on_error.each do |oe|
if (he = HandlerEntry.new(oe)).match(err)
return he.narrow
end
end
end
nil
end | ruby | {
"resource": ""
} |
q20227 | Ruote.Tracker.remove | train | def remove(tracker_ids, wfid)
return if tracker_ids.empty?
doc ||= @context.storage.get_trackers(wfid)
return if (doc['trackers'].keys & tracker_ids).empty?
doc['wfid'] = wfid
# a little helper for some some storage implementations like ruote-swf
# they need to know what workflow execution is targetted.
tracker_ids.each { |ti| doc['trackers'].delete(ti) }
r = @context.storage.put(doc)
remove(tracker_ids, wfid) if r
# the put failed, have to redo the work
end | ruby | {
"resource": ""
} |
q20228 | Ruote.Tracker.on_message | train | def on_message(pre, message)
m_wfid = message['wfid'] || (message['fei']['wfid'] rescue nil)
m_error = message['error']
m_action = message['action']
m_action = "pre_#{m_action}" if pre
msg = m_action == 'error_intercepted' ? message['msg'] : message
ids_to_remove = []
trackers.each do |tracker_id, tracker|
# filter msgs
t_wfid = tracker['wfid']
t_action = tracker['action']
next if t_wfid && t_wfid != m_wfid
next if t_action && t_action != m_action
next unless does_match?(message, tracker['conditions'])
if tracker_id == 'on_error' || tracker_id == 'on_terminate'
fs = msg['workitem']['fields']
next if m_action == 'error_intercepted' && fs['__error__']
next if m_action == 'terminated' && (fs['__error__'] || fs['__terminate__'])
end
# remove the message post-trigger?
ids_to_remove << tracker_id if tracker['msg'].delete('_auto_remove')
# OK, have to pull the trigger (or alter the message) then
if pre && tracker['msg']['_alter']
alter(m_wfid, m_error, m_action, msg, tracker)
else
trigger(m_wfid, m_error, m_action, msg, tracker)
end
end
remove(ids_to_remove, nil)
end | ruby | {
"resource": ""
} |
q20229 | Ruote.Tracker.alter | train | def alter(m_wfid, m_error, m_action, msg, tracker)
case tracker['msg'].delete('_alter')
when 'merge' then msg.merge!(tracker['msg'])
#else ...
end
end | ruby | {
"resource": ""
} |
q20230 | Ruote.Tracker.trigger | train | def trigger(m_wfid, m_error, m_action, msg, tracker)
t_action = tracker['action']
tracker_id = tracker['id']
m = Ruote.fulldup(tracker['msg'])
action = m.delete('action')
m['wfid'] = m_wfid if m['wfid'] == 'replace'
m['wfid'] ||= @context.wfidgen.generate
m['workitem'] = msg['workitem'] if m['workitem'] == 'replace'
if t_action == 'error_intercepted'
m['workitem']['fields']['__error__'] = m_error
elsif tracker_id == 'on_error' && m_action == 'error_intercepted'
m['workitem']['fields']['__error__'] = m_error
elsif tracker_id == 'on_terminate' && m_action == 'terminated'
m['workitem']['fields']['__terminate__'] = { 'wfid' => m_wfid }
end
if m['variables'] == 'compile'
fexp = Ruote::Exp::FlowExpression.fetch(@context, msg['fei'])
m['variables'] = fexp ? fexp.compile_variables : {}
end
@context.storage.put_msg(action, m)
end | ruby | {
"resource": ""
} |
q20231 | Ruote.Tracker.does_match? | train | def does_match?(msg, conditions)
return true unless conditions
conditions.each do |k, v|
return false unless Array(v).find do |vv|
# the Array(v) is for backward compatibility, although newer
# track conditions are already stored as arrays.
vv = Ruote.regex_or_s(vv)
val = case k
when 'class' then msg['error']['class']
when 'message' then msg['error']['message']
else Ruote.lookup(msg, k)
end
val && (vv.is_a?(Regexp) ? vv.match(val) : vv == val)
end
end
true
end | ruby | {
"resource": ""
} |
q20232 | Ruote.WaitLogger.on_msg | train | def on_msg(msg)
puts(fancy_print(msg, @noisy)) if @noisy
return if msg['action'] == 'noop'
@mutex.synchronize do
@seen << msg
@log << msg
while @log.size > @log_max; @log.shift; end
while @seen.size > @log_max; @seen.shift; end
end
end | ruby | {
"resource": ""
} |
q20233 | Ruote.WaitLogger.wait_for | train | def wait_for(interests, opts={})
@waiting << [ Thread.current, interests ]
Thread.current['__result__'] = nil
start = Time.now
to = opts[:timeout] || @timeout
to = nil if to.nil? || to <= 0
loop do
raise(
Ruote::LoggerTimeout.new(interests, to)
) if to && (Time.now - start) > to
@mutex.synchronize { check_waiting }
break if Thread.current['__result__']
sleep 0.007
end
Thread.current['__result__']
end | ruby | {
"resource": ""
} |
q20234 | Ruote.WaitLogger.matches | train | def matches(interests, msg)
action = msg['action']
interests.each do |interest|
satisfied = case interest
when :or_error
#
# let's force an immediate reply
interests.clear if action == 'error_intercepted'
when :inactive
(FINAL_ACTIONS.include?(action) && @context.worker.inactive?)
when :empty
(action == 'terminated' && @context.storage.empty?('expressions'))
when Symbol
(action == 'dispatch' && msg['participant_name'] == interest.to_s)
when Fixnum
interests.delete(interest)
if (interest > 1)
interests << (interest - 1)
false
else
true
end
when Hash
interest.all? { |k, v|
k = 'tree.0' if k == 'exp_name'
Ruote.lookup(msg, k) == v
}
when /^[a-z_]+$/
(action == interest)
else # wfid
(FINAL_ACTIONS.include?(action) && msg['wfid'] == interest)
end
interests.delete(interest) if satisfied
end
if interests.include?(:or_error)
(interests.size < 2)
else
(interests.size < 1)
end
end | ruby | {
"resource": ""
} |
q20235 | Ruote.Context.has_service? | train | def has_service?(service_name)
service_name = service_name.to_s
service_name = "s_#{service_name}" if ! SERVICE_PREFIX.match(service_name)
@services.has_key?(service_name)
end | ruby | {
"resource": ""
} |
q20236 | Ruote::Exp.FlowExpression.do_p | train | def do_p(pers)
case r = pers ? try_persist : try_unpersist
when true
false # do not go on
when Hash
self.h = r
self.send("do_#{@msg['action']}", @msg) if @msg
false # do not go on
else
true # success, do go on
end
end | ruby | {
"resource": ""
} |
q20237 | Ruote.StorageParticipant.on_workitem | train | def on_workitem
doc = workitem.to_h
doc.merge!(
'type' => 'workitems',
'_id' => to_id(doc['fei']),
'participant_name' => doc['participant_name'],
'wfid' => doc['fei']['wfid'])
doc['store_name'] = @store_name if @store_name
@context.storage.put(doc, :update_rev => true)
end | ruby | {
"resource": ""
} |
q20238 | Ruote.StorageParticipant.proceed | train | def proceed(workitem)
r = remove_workitem('proceed', workitem)
return proceed(workitem) if r != nil
workitem.h.delete('_rev')
reply_to_engine(workitem)
end | ruby | {
"resource": ""
} |
q20239 | Ruote.StorageParticipant.flunk | train | def flunk(workitem, err_class_or_instance, *err_arguments)
r = remove_workitem('reject', workitem)
return flunk(workitem) if r != nil
workitem.h.delete('_rev')
super(workitem, err_class_or_instance, *err_arguments)
end | ruby | {
"resource": ""
} |
q20240 | Ruote.StorageParticipant.all | train | def all(opts={})
res = fetch_all(opts)
res.is_a?(Array) ? res.map { |hwi| Ruote::Workitem.new(hwi) } : res
end | ruby | {
"resource": ""
} |
q20241 | Ruote.StorageParticipant.by_wfid | train | def by_wfid(wfid, opts={})
if @context.storage.respond_to?(:by_wfid)
return @context.storage.by_wfid('workitems', wfid, opts)
end
wis(@context.storage.get_many('workitems', wfid, opts))
end | ruby | {
"resource": ""
} |
q20242 | Ruote.StorageParticipant.by_participant | train | def by_participant(participant_name, opts={})
return @context.storage.by_participant(
'workitems', participant_name, opts
) if @context.storage.respond_to?(:by_participant)
do_select(opts) do |hwi|
hwi['participant_name'] == participant_name
end
end | ruby | {
"resource": ""
} |
q20243 | Ruote.StorageParticipant.query | train | def query(criteria)
cr = Ruote.keys_to_s(criteria)
if @context.storage.respond_to?(:query_workitems)
return @context.storage.query_workitems(cr)
end
opts = {}
opts[:skip] = cr.delete('offset') || cr.delete('skip')
opts[:limit] = cr.delete('limit')
opts[:count] = cr.delete('count')
wfid = cr.delete('wfid')
count = opts[:count]
pname = cr.delete('participant_name') || cr.delete('participant')
opts.delete(:count) if pname
hwis = wfid ?
@context.storage.get_many('workitems', wfid, opts) : fetch_all(opts)
return hwis unless hwis.is_a?(Array)
hwis = hwis.select { |hwi|
Ruote::StorageParticipant.matches?(hwi, pname, cr)
}
count ? hwis.size : wis(hwis)
end | ruby | {
"resource": ""
} |
q20244 | Ruote.StorageParticipant.per_participant_count | train | def per_participant_count
per_participant.remap { |(k, v), h| h[k] = v.size }
end | ruby | {
"resource": ""
} |
q20245 | Ruote.StorageParticipant.delegate | train | def delegate(workitem, new_owner)
hwi = fetch(workitem)
fail ArgumentError.new(
"workitem not found"
) if hwi == nil
fail ArgumentError.new(
"cannot delegate, workitem doesn't belong to anyone"
) if hwi['owner'] == nil
fail ArgumentError.new(
"cannot delegate, " +
"workitem owned by '#{hwi['owner']}', not '#{workitem.owner}'"
) if hwi['owner'] != workitem.owner
hwi['owner'] = new_owner
r = @context.storage.put(hwi, :update_rev => true)
fail ArgumentError.new("workitem is gone") if r == true
fail ArgumentError.new("workitem got modified meanwhile") if r != nil
Workitem.new(hwi)
end | ruby | {
"resource": ""
} |
q20246 | Ruote.StorageParticipant.do_select | train | def do_select(opts, &block)
skip = opts[:offset] || opts[:skip]
limit = opts[:limit]
count = opts[:count]
hwis = fetch_all({})
hwis = hwis.select(&block)
hwis = hwis[skip..-1] if skip
hwis = hwis[0, limit] if limit
return hwis.size if count
hwis.collect { |hwi| Ruote::Workitem.new(hwi) }
end | ruby | {
"resource": ""
} |
q20247 | Ruote.StorageParticipant.to_id | train | def to_id(fei)
a = [ Ruote.to_storage_id(fei) ]
a.unshift(@store_name) if @store_name
a.unshift('wi')
a.join('!')
end | ruby | {
"resource": ""
} |
q20248 | Ruote::Exp.CommandExpression.fetch_command_target | train | def fetch_command_target(exp=parent)
case exp
when nil then nil
when Ruote::Exp::CommandedExpression then exp
else fetch_command_target(exp.parent)
end
end | ruby | {
"resource": ""
} |
q20249 | Ruote.RevParticipant.lookup_code | train | def lookup_code
wi = workitem
rev = wi.params['revision'] || wi.params['rev']
[
[ wi.wf_name, wi.wf_revision, wi.participant_name, rev ],
[ wi.wf_name, wi.wf_revision, wi.participant_name ],
[ wi.wf_name, '', wi.participant_name ],
[ wi.participant_name, rev ],
[ wi.participant_name ],
].each do |fname|
fname = File.join(@dir, "#{fname.compact.join('__')}.rb")
next unless File.exist?(fname)
cpart = Class.new
cpart.send(:include, Ruote::LocalParticipant)
cpart.module_eval(File.read(fname))
part = cpart.new
part.context = @context
next if part.respond_to?(:accept?) and (not part.accept?(wi))
return part
end
raise ArgumentError.new(
"couldn't find code for participant #{wi.participant_name} " +
"in dir #{@dir}"
)
end | ruby | {
"resource": ""
} |
q20250 | Ruote::Exp.IfExpression.reply | train | def reply(workitem)
if workitem['fei'] == h.fei # apply --> reply
h.test = attribute(:test)
h.test = attribute(:t) if h.test.nil?
h.test = attribute_text if h.test.nil?
h.test = nil if h.test == ''
offset = (h.test.nil? || Condition.true?(h.test)) ? 0 : 1
apply_child(offset, workitem)
else # reply from a child
if h.test != nil || Ruote::FlowExpressionId.child_id(workitem['fei']) != 0
reply_to_parent(workitem)
else
apply_child(workitem['fields']['__result__'] == true ? 1 : 2, workitem)
end
end
end | ruby | {
"resource": ""
} |
q20251 | Ruote.ParticipantList.unregister | train | def unregister(name_or_participant)
code = nil
entry = nil
list = get_list
name_or_participant = name_or_participant.to_s
entry = list['list'].find { |re, pa| name_or_participant.match(re) }
return nil unless entry
code = entry.last if entry.last.is_a?(String)
list['list'].delete(entry)
if r = @context.storage.put(list)
#
# put failed, have to redo it
#
return unregister(name_or_participant)
end
entry.first
end | ruby | {
"resource": ""
} |
q20252 | Ruote.ParticipantList.lookup | train | def lookup(participant_name, workitem, opts={})
pinfo = participant_name.is_a?(String) ?
lookup_info(participant_name, workitem) : participant_name
instantiate(pinfo, opts)
end | ruby | {
"resource": ""
} |
q20253 | Ruote.ParticipantList.lookup_info | train | def lookup_info(pname, workitem)
return nil unless pname
wi = workitem ?
Ruote::Workitem.new(workitem.merge('participant_name' => pname)) :
nil
get_list['list'].each do |regex, pinfo|
next unless pname.match(regex)
return pinfo if workitem.nil?
pa = instantiate(pinfo, :if_respond_to? => :accept?)
return pinfo if pa.nil?
return pinfo if Ruote.participant_send(pa, :accept?, 'workitem' => wi)
end
# nothing found...
nil
end | ruby | {
"resource": ""
} |
q20254 | Ruote.ParticipantList.instantiate | train | def instantiate(pinfo, opts={})
return nil unless pinfo
pa_class_name, options = pinfo
if rp = options['require_path']
require(rp)
end
if lp = options['load_path']
load(lp)
end
pa_class = Ruote.constantize(pa_class_name)
pa_m = pa_class.instance_methods
irt = opts[:if_respond_to?]
if irt && ! (pa_m.include?(irt.to_s) || pa_m.include?(irt.to_sym))
return nil
end
initialize_participant(pa_class, options)
end | ruby | {
"resource": ""
} |
q20255 | Spotify.Client.create_user_playlist | train | def create_user_playlist(user_id, name, is_public = true)
run(:post, "/v1/users/#{user_id}/playlists", [201], JSON.dump(name: name, public: is_public), false)
end | ruby | {
"resource": ""
} |
q20256 | Spotify.Client.add_user_tracks_to_playlist | train | def add_user_tracks_to_playlist(user_id, playlist_id, uris = [], position = nil)
params = { uris: Array.wrap(uris)[0..99].join(',') }
if position
params.merge!(position: position)
end
run(:post, "/v1/users/#{user_id}/playlists/#{playlist_id}/tracks", [201], JSON.dump(params), false)
end | ruby | {
"resource": ""
} |
q20257 | Spotify.Client.follow | train | def follow(type, ids)
params = { type: type, ids: Array.wrap(ids).join(',') }
run(:put, "/v1/me/following", [204], params)
end | ruby | {
"resource": ""
} |
q20258 | Monit.Status.url | train | def url
url_params = { :host => @host, :port => @port, :path => "/_status", :query => "format=xml" }
@ssl ? URI::HTTPS.build(url_params) : URI::HTTP.build(url_params)
end | ruby | {
"resource": ""
} |
q20259 | Monit.Status.get | train | def get
uri = self.url
http = Net::HTTP.new(uri.host, uri.port)
if @ssl
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
end
request = Net::HTTP::Get.new(uri.request_uri)
if @auth
request.basic_auth(@username, @password)
end
request["User-Agent"] = "Monit Ruby client #{Monit::VERSION}"
begin
response = http.request(request)
rescue Errno::ECONNREFUSED
return false
end
if (response.code =~ /\A2\d\d\z/)
@xml = response.body
return self.parse(@xml)
else
return false
end
end | ruby | {
"resource": ""
} |
q20260 | Monit.Status.parse | train | def parse(xml)
@hash = Hash.from_xml(xml)
@server = Server.new(@hash["monit"]["server"])
@platform = Platform.new(@hash["monit"]["platform"])
options = {
:host => @host,
:port => @port,
:ssl => @ssl,
:auth => @auth,
:username => @username,
:password => @password
}
if @hash["monit"]["service"].is_a? Array
@services = @hash["monit"]["service"].map do |service|
Service.new(service, options)
end
else
@services = [Service.new(@hash["monit"]["service"], options)]
end
true
rescue
false
end | ruby | {
"resource": ""
} |
q20261 | Solve.Graph.artifact | train | def artifact(name, version)
unless artifact?(name, version)
artifact = Artifact.new(self, name, version)
@artifacts["#{name}-#{version}"] = artifact
@artifacts_by_name[name] << artifact
end
@artifacts["#{name}-#{version}"]
end | ruby | {
"resource": ""
} |
q20262 | Solve.Graph.versions | train | def versions(name, constraint = Semverse::DEFAULT_CONSTRAINT)
constraint = Semverse::Constraint.coerce(constraint)
if constraint == Semverse::DEFAULT_CONSTRAINT
@artifacts_by_name[name]
else
@artifacts_by_name[name].select do |artifact|
constraint.satisfies?(artifact.version)
end
end
end | ruby | {
"resource": ""
} |
q20263 | Solve.Constraint.satisfies? | train | def satisfies?(target)
target = Semverse::Version.coerce(target)
return false if !(version == 0) && greedy_match?(target)
compare(target)
end | ruby | {
"resource": ""
} |
q20264 | Solve.GecodeSolver.solve_demands | train | def solve_demands(demands_as_constraints)
selector = DepSelector::Selector.new(ds_graph, (timeout_ms / 1000.0))
selector.find_solution(demands_as_constraints, all_artifacts)
rescue DepSelector::Exceptions::InvalidSolutionConstraints => e
report_invalid_constraints_error(e)
rescue DepSelector::Exceptions::NoSolutionExists => e
report_no_solution_error(e)
rescue DepSelector::Exceptions::TimeBoundExceeded
# DepSelector timed out trying to find the solution. There may or may
# not be a solution.
raise Solve::Errors::NoSolutionError.new(
"The dependency constraints could not be solved in the time allotted.")
rescue DepSelector::Exceptions::TimeBoundExceededNoSolution
# DepSelector determined there wasn't a solution to the problem, then
# timed out trying to determine which constraints cause the conflict.
raise Solve::Errors::NoSolutionCauseUnknown.new(
"There is a dependency conflict, but the solver could not determine the precise cause in the time allotted.")
end | ruby | {
"resource": ""
} |
q20265 | Solve.RubySolver.requirement_satisfied_by? | train | def requirement_satisfied_by?(requirement, activated, spec)
version = spec.version
return false unless requirement.constraint.satisfies?(version)
shared_possibility_versions = possibility_versions(requirement, activated)
return false if !shared_possibility_versions.empty? && !shared_possibility_versions.include?(version)
true
end | ruby | {
"resource": ""
} |
q20266 | Solve.RubySolver.possibility_versions | train | def possibility_versions(requirement, activated)
activated.vertices.values.flat_map do |vertex|
next unless vertex.payload
next unless vertex.name == requirement.name
if vertex.payload.respond_to?(:possibilities)
vertex.payload.possibilities.map(&:version)
else
vertex.payload.version
end
end.compact
end | ruby | {
"resource": ""
} |
q20267 | PiPiper.Spi.clock | train | def clock(frequency)
options = {4000 => 0, #4 kHz
8000 => 32768, #8 kHz
15625 => 16384, #15.625 kHz
31250 => 8192, #31.25 kHz
62500 => 4096, #62.5 kHz
125000 => 2048, #125 kHz
250000 => 1024, #250 kHz
500000 => 512, #500 kHz
1000000 => 256, #1 MHz
2000000 => 128, #2 MHz
4000000 => 64, #4 MHz
8000000 => 32, #8 MHz
20000000 => 16 #20 MHz
}
divider = options[frequency]
PiPiper.driver.spi_clock(divider)
end | ruby | {
"resource": ""
} |
q20268 | PiPiper.Spi.chip_select | train | def chip_select(chip=CHIP_SELECT_0)
chip = @chip if @chip
PiPiper.driver.spi_chip_select(chip)
if block_given?
begin
yield
ensure
PiPiper.driver.spi_chip_select(CHIP_SELECT_NONE)
end
end
end | ruby | {
"resource": ""
} |
q20269 | PiPiper.Spi.chip_select_active_low | train | def chip_select_active_low(active_low, chip=nil)
chip = @chip if @chip
chip = CHIP_SELECT_0 unless chip
PiPiper.driver.spi_chip_select_polarity(chip, active_low ? 0 : 1)
end | ruby | {
"resource": ""
} |
q20270 | PiPiper.Spi.write | train | def write(*args)
case args.count
when 0
raise ArgumentError, "missing arguments"
when 1
data = args.first
else
data = args
end
enable do
case data
when Numeric
PiPiper.driver.spi_transfer(data)
when Enumerable
PiPiper.driver.spi_transfer_bytes(data)
else
raise ArgumentError, "#{data.class} is not valid data. Use Numeric or an Enumerable of numbers"
end
end
end | ruby | {
"resource": ""
} |
q20271 | RubyMotionQuery.RMQ.add_subview | train | def add_subview(view_or_constant, opts={})
subviews_added = []
selected.each do |selected_view|
created = false
appended = false
built = false
if view_or_constant.is_a?(UIView)
new_view = view_or_constant
else
created = true
new_view = create_view(view_or_constant, opts)
end
rmq_data = new_view.rmq_data
unless rmq_data.built
rmq_data.built = true # build only once
built = true
end
rmq_data.view_controller = self.weak_view_controller
subviews_added << new_view
unless opts[:do_not_add]
if at_index = opts[:at_index]
selected_view.insertSubview(new_view, atIndex: at_index)
elsif below_view = opts[:below_view]
selected_view.insertSubview(new_view, belowSubview: below_view)
else
selected_view.addSubview(new_view)
end
appended = true
end
if created
new_view.rmq_created
end
new_view.rmq_build if built
new_view.rmq_appended if appended
if self.stylesheet
apply_style_to_view(new_view, opts[:style]) if opts[:style]
end
end
view = RMQ.create_with_array_and_selectors(subviews_added, selectors, @context, self)
opts[:block].call view if opts[:block]
opts[:raw_block].call view.get if opts[:raw_block]
view
end | ruby | {
"resource": ""
} |
q20272 | RubyMotionQuery.RMQ.find_or_append | train | def find_or_append(view_or_constant, style=nil, opts = {}, &block)
if style && (q = self.find(style)) && q.length > 0
view_or_constant = q.get
end
append(view_or_constant, style, opts, &block)
end | ruby | {
"resource": ""
} |
q20273 | RubyMotionQuery.RMQ.find_or_append! | train | def find_or_append!(view_or_constant, style=nil, opts = {}, &block)
find_or_append(view_or_constant, style, opts, &block).get
end | ruby | {
"resource": ""
} |
q20274 | RubyMotionQuery.RMQ.unshift | train | def unshift(view_or_constant, style=nil, opts = {}, &block)
opts[:at_index] = 0
opts[:style] = style
opts[:block] = block if block
add_subview view_or_constant, opts
end | ruby | {
"resource": ""
} |
q20275 | RubyMotionQuery.RMQ.build | train | def build(view, style = nil, opts = {}, &block)
opts[:do_not_add] = true
opts[:style] = style
opts[:block] = block if block
add_subview view, opts
end | ruby | {
"resource": ""
} |
q20276 | RubyMotionQuery.Validation.universal_validation_checks | train | def universal_validation_checks (data, options={})
# shortcircuit if debugging
return true if RubyMotionQuery::RMQ.debugging?
# allow blank data if specified
return true if (options[:allow_blank] && (data.nil? || data.empty?))
# allow whitelist data if specified
return true if (options[:white_list] && options[:white_list].include?(data))
false
end | ruby | {
"resource": ""
} |
q20277 | RubyMotionQuery.Debug.log_detailed | train | def log_detailed(label, params = {})
return unless RMQ.app.development? || RMQ.app.test?
objects = params[:objects]
skip_first_caller = params[:skip_first_caller]
if block_given? && !objects
objects = yield
end
callers = caller
callers = callers.drop(1) if skip_first_caller
out = %(
------------------------------------------------
Deep log - #{label}
At: #{Time.now.to_s}
Callers:
#{callers.join("\n - ")}
Objects:
#{objects.map{|k, v| "#{k.to_s}: #{v.inspect}" }.join("\n\n")}
------------------------------------------------
).gsub(/^ +/, '')
NSLog out
label
end | ruby | {
"resource": ""
} |
q20278 | RubyMotionQuery.Debug.assert | train | def assert(truthy, label = nil, objects = nil)
if (RMQ.app.development? || RMQ.app.test?) && !truthy
label ||= 'Assert failed'
if block_given? && !objects
objects = yield
end
log_detailed label, objects: objects, skip_first_caller: true
end
end | ruby | {
"resource": ""
} |
q20279 | RubyMotionQuery.RMQ.subviews_bottom_right | train | def subviews_bottom_right(view, args = {})
w = 0
h = 0
view.subviews.each do |subview|
rect = subview.rmq.frame
w = [rect.right, w].max
h = [rect.bottom, h].max
end
rect = view.rmq.frame
w = rect.width if (w == 0 || args[:only_height])
h = rect.height if (h == 0 || args[:only_width])
{w: (w + (args[:right] || 0)), h: (h + (args[:bottom] || 0))}
end | ruby | {
"resource": ""
} |
q20280 | RubyMotionQuery.RMQ.context= | train | def context=(value)
if value
if value.is_a?(UIViewController)
@context = RubyMotionQuery::RMQ.weak_ref(value)
elsif value.is_a?(UIView)
@context = value
#else
#debug.log_detailed('Invalid context', objects: {value: value})
end
else
@context = nil
end
@context
end | ruby | {
"resource": ""
} |
q20281 | RubyMotionQuery.RMQ.selected | train | def selected
if @selected_dirty
@_selected = []
if RMQ.is_blank?(self.selectors)
@_selected << context_or_context_view
else
working_selectors = self.selectors.dup
extract_views_from_selectors(@_selected, working_selectors)
unless RMQ.is_blank?(working_selectors)
subviews = all_subviews_for(root_view)
subviews.each do |subview|
@_selected << subview if match(subview, working_selectors)
end
end
@_selected.uniq!
end
@selected_dirty = false
else
@_selected ||= []
end
@_selected
end | ruby | {
"resource": ""
} |
q20282 | RubyMotionQuery.RMQ.wrap | train | def wrap(*views)
views.flatten!
views.select!{ |v| v.is_a?(UIView) }
RMQ.create_with_array_and_selectors(views, views, views.first, self)
end | ruby | {
"resource": ""
} |
q20283 | RubyMotionQuery.RMQ.log | train | def log(opt = nil)
if opt == :tree
puts tree_to_s(selected)
return
end
wide = (opt == :wide)
out = "\n object_id | class | style_name | frame |"
out << "\n" unless wide
out << " sv id | superview | subviews count | tags |"
line = " - - - - - - | - - - - - - - - - - - | - - - - - - - - - - - - | - - - - - - - - - - - - - - - - |\n"
out << "\n"
out << line.chop if wide
out << line
selected.each do |view|
out << " #{view.object_id.to_s.ljust(12)}|"
out << " #{view.class.name[0..21].ljust(22)}|"
out << " #{(view.rmq_data.style_name || '')[0..23].ljust(24)}|"
s = ""
if view.origin
format = '#0.#'
s = " {l: #{RMQ.format.numeric(view.origin.x, format)}"
s << ", t: #{RMQ.format.numeric(view.origin.y, format)}"
s << ", w: #{RMQ.format.numeric(view.size.width, format)}"
s << ", h: #{RMQ.format.numeric(view.size.height, format)}}"
end
out << s.ljust(33)
out << '|'
out << "\n" unless wide
out << " #{view.superview.object_id.to_s.ljust(12)}|"
out << " #{(view.superview ? view.superview.class.name : '')[0..21].ljust(22)}|"
out << " #{view.subviews.length.to_s.ljust(23)} |"
#out << " #{view.subviews.length.to_s.rjust(8)} #{view.superview.class.name.ljust(20)} #{view.superview.object_id.to_s.rjust(10)}"
out << " #{view.rmq_data.tag_names.join(',').ljust(32)}|"
out << "\n"
out << line unless wide
end
out << "RMQ #{self.object_id}. #{self.count} selected. selectors: #{self.selectors}"
puts out
end | ruby | {
"resource": ""
} |
q20284 | Aspector.Interception.apply_to_method | train | def apply_to_method(method)
filtered_advices = filter_advices advices, method
return if filtered_advices.empty?
logger.debug 'apply-to-method', method
scope ||= context.instance_method_type(method)
recreate_method method, filtered_advices, scope
end | ruby | {
"resource": ""
} |
q20285 | Aspector.Interception.define_methods_for_advice_blocks | train | def define_methods_for_advice_blocks
advices.each do |advice|
next if advice.raw?
next unless advice.advice_block
context.send :define_method, advice.with_method, advice.advice_block
context.send :private, advice.with_method
end
end | ruby | {
"resource": ""
} |
q20286 | Aspector.Interception.apply_to_methods | train | def apply_to_methods
# If method/methods option is set and all are String or Symbol, apply to those only, instead of
# iterating through all methods
methods = [@options[:method] || @options[:methods]]
methods.compact!
methods.flatten!
if !methods.empty? && methods.all?{ |method| method.is_a?(String) || method.is_a?(Symbol) }
methods.each do |method|
apply_to_method(method.to_s)
end
return
end
context.public_instance_methods.each do |method|
apply_to_method(method.to_s)
end
context.protected_instance_methods.each do |method|
apply_to_method(method.to_s)
end
if @options[:private_methods]
context.private_instance_methods.each do |method|
apply_to_method(method.to_s)
end
end
end | ruby | {
"resource": ""
} |
q20287 | Aspector.Interception.invoke_deferred_logics | train | def invoke_deferred_logics
logics = @aspect.class.storage.deferred_logics
return if logics.empty?
logics.each do |logic|
result = logic.apply context, aspect
if advices.detect { |advice| advice.use_deferred_logic? logic }
@deferred_logic_results ||= {}
@deferred_logic_results[logic] = result
end
end
end | ruby | {
"resource": ""
} |
q20288 | Aspector.Interception.add_method_hooks | train | def add_method_hooks
eigen_class = @target.singleton_class
if @options[:class_methods]
return unless @target.is_a?(Module)
orig_singleton_method_added = @target.method(:singleton_method_added)
eigen_class.send :define_method, :singleton_method_added do |method|
aspector_singleton_method_added(method)
orig_singleton_method_added.call(method)
end
else
if @target.is_a? Module
orig_method_added = @target.method(:method_added)
else
orig_method_added = eigen_class.method(:method_added)
end
eigen_class.send :define_method, :method_added do |method|
aspector_instance_method_added(method)
orig_method_added.call(method)
end
end
end | ruby | {
"resource": ""
} |
q20289 | Aspector.Interception.recreate_method | train | def recreate_method(method, advices, scope)
context.instance_variable_set(:@aspector_creating_method, true)
raw_advices = advices.select(&:raw?)
if raw_advices.size > 0
raw_advices.each do |advice|
if @target.is_a?(Module) && !@options[:class_methods]
@target.class_exec method, self, &advice.advice_block
else
@target.instance_exec method, self, &advice.advice_block
end
end
return if raw_advices.size == advices.size
end
begin
@wrapped_methods[method] = context.instance_method(method)
rescue
# ignore undefined method error
if @options[:existing_methods_only]
logger.log Logging::WARN, 'method-not-found', method
end
return
end
before_advices = advices.select(&:before?) + advices.select(&:before_filter?)
after_advices = advices.select(&:after?)
around_advices = advices.select(&:around?)
(around_advices.size - 1).downto(1) do |i|
advice = around_advices[i]
recreate_method_with_advices method, [], [], advice
end
recreate_method_with_advices(
method,
before_advices,
after_advices,
around_advices.first
)
context.send scope, method if scope != :public
ensure
context.send :remove_instance_variable, :@aspector_creating_method
end | ruby | {
"resource": ""
} |
q20290 | Aspector.Logger.message | train | def message(*args)
msg = []
if context.is_a? Aspector::Base
msg << context.class.to_s
msg << context.target.to_s
else
msg << context.to_s
end
msg += args
msg.join(' | ')
end | ruby | {
"resource": ""
} |
q20291 | Squid.Plotter.legend | train | def legend(labels, height:, right: 0, colors: [])
left = @pdf.bounds.width/2
box(x: left, y: @pdf.bounds.top, w: left, h: height) do
x = @pdf.bounds.right - right
options = {size: 7, height: @pdf.bounds.height, valign: :center}
labels.each.with_index do |label, i|
index = labels.size - 1 - i
series_color = colors.fetch index, series_colors(index)
color = Array.wrap(series_color).first
x = legend_item label, x, color, options
end
end
end | ruby | {
"resource": ""
} |
q20292 | Squid.Plotter.horizontal_line | train | def horizontal_line(y, options = {})
with options do
at = y + @bottom
@pdf.stroke_horizontal_line left, @pdf.bounds.right - right, at: at
end
end | ruby | {
"resource": ""
} |
q20293 | Squid.Plotter.legend_item | train | def legend_item(label, x, color, options)
size, symbol_padding, entry_padding = 5, 3, 12
x -= @pdf.width_of(label, size: 7).ceil
@pdf.text_box label, options.merge(at: [x, @pdf.bounds.height])
x -= (symbol_padding + size)
with fill_color: color do
@pdf.fill_rectangle [x, @pdf.bounds.height - size], size, size
end
x - entry_padding
end | ruby | {
"resource": ""
} |
q20294 | Squid.Plotter.with | train | def with(new_values = {})
transparency = new_values.delete(:transparency) { 1.0 }
old_values = Hash[new_values.map{|k,_| [k,@pdf.public_send(k)]}]
new_values.each{|k, new_value| @pdf.public_send "#{k}=", new_value }
@pdf.transparent(transparency) do
@pdf.stroke { yield }
end
old_values.each{|k, old_value| @pdf.public_send "#{k}=", old_value }
end | ruby | {
"resource": ""
} |
q20295 | PoiseApplication.Utils.primary_group_for | train | def primary_group_for(user)
# Force a reload in case any users were created earlier in the run.
Etc.endpwent
Etc.endgrent
user = if user.is_a?(Integer)
Etc.getpwuid(user)
else
Etc.getpwnam(user.to_s)
end
Etc.getgrgid(user.gid).name
rescue ArgumentError
# One of the get* calls exploded. ¯\_(ツ)_/¯
user.to_s
end | ruby | {
"resource": ""
} |
q20296 | Fluent::Plugin.SplunkHECOutput.write | train | def write(chunk)
body = ''
chunk.msgpack_each {|(tag,time,record)|
# define index and sourcetype dynamically
begin
index = expand_param(@index, tag, time, record)
sourcetype = expand_param(@sourcetype, tag, time, record)
event_host = expand_param(@event_host, tag, time, record)
token = expand_param(@token, tag, time, record)
rescue => e
# handle dynamic parameters misconfigurations
router.emit_error_event(tag, time, record, e)
next
end
log.debug "routing event from #{event_host} to #{index} index"
log.debug "expanded token #{token}"
# Parse record to Splunk event format
case record
when Integer
event = record.to_s
when Hash
if @send_event_as_json
event = record.to_json
else
event = record.to_json.gsub("\"", %q(\\\"))
end
else
event = record
end
sourcetype = @sourcetype == 'tag' ? tag : @sourcetype
# Build body for the POST request
if !@usejson
event = record["time"]+ " " + record["message"].to_json.gsub(/^"|"$/,"")
body << '{"time":"'+ DateTime.parse(record["time"]).strftime("%Q") +'", "event":"' + event + '", "sourcetype" :"' + sourcetype + '", "source" :"' + @source + '", "index" :"' + index + '", "host" : "' + event_host + '"}'
elsif @send_event_as_json
body << '{"time" :' + time.to_s + ', "event" :' + event + ', "sourcetype" :"' + sourcetype + '", "source" :"' + source + '", "index" :"' + index + '", "host" : "' + event_host + '"}'
else
body << '{"time" :' + time.to_s + ', "event" :"' + event + '", "sourcetype" :"' + sourcetype + '", "source" :"' + source + '", "index" :"' + index + '", "host" : "' + event_host + '"}'
end
if @send_batched_events
body << "\n"
else
send_to_splunk(body, token)
body = ''
end
}
if @send_batched_events
send_to_splunk(body, token)
end
end | ruby | {
"resource": ""
} |
q20297 | Poise.Utils.find_cookbook_name | train | def find_cookbook_name(run_context, filename)
possibles = {}
Poise.debug("[Poise] Checking cookbook for #{filename.inspect}")
run_context.cookbook_collection.each do |name, ver|
# This special method is added by Halite::Gem#as_cookbook_version.
if ver.respond_to?(:halite_root)
# The join is there because ../poise-ruby/lib starts with ../poise so
# we want a trailing /.
if filename.start_with?(File.join(ver.halite_root, ''))
Poise.debug("[Poise] Found matching halite_root in #{name}: #{ver.halite_root.inspect}")
possibles[ver.halite_root] = name
end
else
Chef::CookbookVersion::COOKBOOK_SEGMENTS.each do |seg|
ver.segment_filenames(seg).each do |file|
if ::File::ALT_SEPARATOR
file = file.gsub(::File::ALT_SEPARATOR, ::File::SEPARATOR)
end
# Put this behind an environment variable because it is verbose
# even for normal debugging-level output.
Poise.debug("[Poise] Checking #{seg} in #{name}: #{file.inspect}")
if file == filename
Poise.debug("[Poise] Found matching #{seg} in #{name}: #{file.inspect}")
possibles[file] = name
end
end
end
end
end
raise Poise::Error.new("Unable to find cookbook for file #{filename.inspect}") if possibles.empty?
# Sort the items by matching path length, pick the name attached to the longest.
possibles.sort_by{|key, value| key.length }.last[1]
end | ruby | {
"resource": ""
} |
q20298 | Poise.Utils.ancestor_send | train | def ancestor_send(obj, msg, *args, default: nil, ignore: [default])
# Class is a subclass of Module, if we get something else use its class.
obj = obj.class unless obj.is_a?(Module)
ancestors = []
if obj.respond_to?(:superclass)
# Check the superclass first if present.
ancestors << obj.superclass
end
# Make sure we don't check obj itself.
ancestors.concat(obj.ancestors.drop(1))
ancestors.each do |mod|
if mod.respond_to?(msg)
val = mod.send(msg, *args)
# If we get the default back, assume we should keep trying.
return val unless ignore.include?(val)
end
end
# Nothing valid found, use the default.
default
end | ruby | {
"resource": ""
} |
q20299 | Poise.Utils.parameterized_module | train | def parameterized_module(mod, &block)
raise Poise::Error.new("Cannot parameterize an anonymous module") unless mod.name && !mod.name.empty?
parent_name_parts = mod.name.split(/::/)
# Grab the last piece which will be the method name.
mod_name = parent_name_parts.pop
# Find the enclosing module or class object.
parent = parent_name_parts.inject(Object) {|memo, name| memo.const_get(name) }
# Object is a special case since we need #define_method instead.
method_type = if parent == Object
:define_method
else
:define_singleton_method
end
# Scoping hack.
self_ = self
# Construct the method.
parent.send(method_type, mod_name) do |*args|
self_.send(:check_block_arity!, block, args)
# Create a new anonymous module to be returned from the method.
Module.new do
# Fake the name.
define_singleton_method(:name) do
super() || mod.name
end
# When the stub module gets included, activate our behaviors.
define_singleton_method(:included) do |klass|
super(klass)
klass.send(:include, mod)
klass.instance_exec(*args, &block)
end
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.