repo stringlengths 5 58 | path stringlengths 9 168 | func_name stringlengths 9 130 | original_string stringlengths 66 10.5k | language stringclasses 1
value | code stringlengths 66 10.5k | code_tokens list | docstring stringlengths 8 16k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 94 266 | partition stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
jmettraux/ruote | lib/ruote/exp/flow_expression.rb | Ruote::Exp.FlowExpression.pre_apply_child | def pre_apply_child(child_index, workitem, forget)
child_fei = h.fei.merge(
'expid' => "#{h.fei['expid']}_#{child_index}",
'subid' => Ruote.generate_subid(h.fei.inspect))
h.children << child_fei unless forget
msg = {
'fei' => child_fei,
'tree' => tree.last[child_inde... | ruby | def pre_apply_child(child_index, workitem, forget)
child_fei = h.fei.merge(
'expid' => "#{h.fei['expid']}_#{child_index}",
'subid' => Ruote.generate_subid(h.fei.inspect))
h.children << child_fei unless forget
msg = {
'fei' => child_fei,
'tree' => tree.last[child_inde... | [
"def",
"pre_apply_child",
"(",
"child_index",
",",
"workitem",
",",
"forget",
")",
"child_fei",
"=",
"h",
".",
"fei",
".",
"merge",
"(",
"'expid'",
"=>",
"\"#{h.fei['expid']}_#{child_index}\"",
",",
"'subid'",
"=>",
"Ruote",
".",
"generate_subid",
"(",
"h",
".... | Used locally but also by ConcurrenceExpression, when preparing children
before they get applied. | [
"Used",
"locally",
"but",
"also",
"by",
"ConcurrenceExpression",
"when",
"preparing",
"children",
"before",
"they",
"get",
"applied",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/flow_expression.rb#L965-L983 | train |
jmettraux/ruote | lib/ruote/exp/flow_expression.rb | Ruote::Exp.FlowExpression.apply_child | def apply_child(child_index, workitem, forget=false)
msg = pre_apply_child(child_index, workitem, forget)
persist_or_raise unless forget
# no need to persist the parent (this) if the child is to be forgotten
@context.storage.put_msg('apply', msg)
end | ruby | def apply_child(child_index, workitem, forget=false)
msg = pre_apply_child(child_index, workitem, forget)
persist_or_raise unless forget
# no need to persist the parent (this) if the child is to be forgotten
@context.storage.put_msg('apply', msg)
end | [
"def",
"apply_child",
"(",
"child_index",
",",
"workitem",
",",
"forget",
"=",
"false",
")",
"msg",
"=",
"pre_apply_child",
"(",
"child_index",
",",
"workitem",
",",
"forget",
")",
"persist_or_raise",
"unless",
"forget",
"@context",
".",
"storage",
".",
"put_m... | Used by expressions when, well, applying a child expression of theirs. | [
"Used",
"by",
"expressions",
"when",
"well",
"applying",
"a",
"child",
"expression",
"of",
"theirs",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/flow_expression.rb#L987-L995 | train |
jmettraux/ruote | lib/ruote/exp/flow_expression.rb | Ruote::Exp.FlowExpression.leave_tag | def leave_tag(workitem)
unset_variable(h.tagname)
Ruote::Workitem.new(workitem).send(:remove_tag, h.tagname)
@context.storage.put_msg(
'left_tag',
'tag' => h.tagname,
'full_tag' => h.full_tagname,
'fei' => h.fei,
'workitem' => workitem)
return unless h... | ruby | def leave_tag(workitem)
unset_variable(h.tagname)
Ruote::Workitem.new(workitem).send(:remove_tag, h.tagname)
@context.storage.put_msg(
'left_tag',
'tag' => h.tagname,
'full_tag' => h.full_tagname,
'fei' => h.fei,
'workitem' => workitem)
return unless h... | [
"def",
"leave_tag",
"(",
"workitem",
")",
"unset_variable",
"(",
"h",
".",
"tagname",
")",
"Ruote",
"::",
"Workitem",
".",
"new",
"(",
"workitem",
")",
".",
"send",
"(",
":remove_tag",
",",
"h",
".",
"tagname",
")",
"@context",
".",
"storage",
".",
"pu... | Called when the expression is about to reply to its parent and wants
to get rid of its tags. | [
"Called",
"when",
"the",
"expression",
"is",
"about",
"to",
"reply",
"to",
"its",
"parent",
"and",
"wants",
"to",
"get",
"rid",
"of",
"its",
"tags",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/flow_expression.rb#L1041-L1085 | train |
jmettraux/ruote | lib/ruote/util/filter.rb | Ruote.RuleSession.do_merge | def do_merge(field, target, value)
value = Rufus::Json.dup(value)
if target.is_a?(Array)
target.push(value)
elsif value.is_a?(Hash)
target.merge!(value)
else # deal with non Hash
target[field.split('.').last] = value
end
target.delete('~')
target.dele... | ruby | def do_merge(field, target, value)
value = Rufus::Json.dup(value)
if target.is_a?(Array)
target.push(value)
elsif value.is_a?(Hash)
target.merge!(value)
else # deal with non Hash
target[field.split('.').last] = value
end
target.delete('~')
target.dele... | [
"def",
"do_merge",
"(",
"field",
",",
"target",
",",
"value",
")",
"value",
"=",
"Rufus",
"::",
"Json",
".",
"dup",
"(",
"value",
")",
"if",
"target",
".",
"is_a?",
"(",
"Array",
")",
"target",
".",
"push",
"(",
"value",
")",
"elsif",
"value",
".",... | Used by both _merge_to and _merge_from | [
"Used",
"by",
"both",
"_merge_to",
"and",
"_merge_from"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/util/filter.rb#L275-L289 | train |
jmettraux/ruote | lib/ruote/dboard/process_status.rb | Ruote.ProcessStatus.tags | def tags
variables ? Hash[variables.select { |k, v| Ruote.is_a_fei?(v) }] : nil
end | ruby | def tags
variables ? Hash[variables.select { |k, v| Ruote.is_a_fei?(v) }] : nil
end | [
"def",
"tags",
"variables",
"?",
"Hash",
"[",
"variables",
".",
"select",
"{",
"|",
"k",
",",
"v",
"|",
"Ruote",
".",
"is_a_fei?",
"(",
"v",
")",
"}",
"]",
":",
"nil",
"end"
] | Returns a hash tagname => fei of tags set at the root of the process
instance.
Returns nil if there is no defined root expression. | [
"Returns",
"a",
"hash",
"tagname",
"=",
">",
"fei",
"of",
"tags",
"set",
"at",
"the",
"root",
"of",
"the",
"process",
"instance",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/dboard/process_status.rb#L153-L156 | train |
jmettraux/ruote | lib/ruote/dboard/process_status.rb | Ruote.ProcessStatus.all_tags | def all_tags
all_variables.remap do |(fei, vars), h|
vars.each { |k, v| (h[k] ||= []) << v if Ruote.is_a_fei?(v) }
end
end | ruby | def all_tags
all_variables.remap do |(fei, vars), h|
vars.each { |k, v| (h[k] ||= []) << v if Ruote.is_a_fei?(v) }
end
end | [
"def",
"all_tags",
"all_variables",
".",
"remap",
"do",
"|",
"(",
"fei",
",",
"vars",
")",
",",
"h",
"|",
"vars",
".",
"each",
"{",
"|",
"k",
",",
"v",
"|",
"(",
"h",
"[",
"k",
"]",
"||=",
"[",
"]",
")",
"<<",
"v",
"if",
"Ruote",
".",
"is_a... | Returns a hash tagname => array of feis of all the tags set in the process
instance. | [
"Returns",
"a",
"hash",
"tagname",
"=",
">",
"array",
"of",
"feis",
"of",
"all",
"the",
"tags",
"set",
"in",
"the",
"process",
"instance",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/dboard/process_status.rb#L161-L166 | train |
jmettraux/ruote | lib/ruote/dboard/process_status.rb | Ruote.ProcessStatus.wfid | def wfid
l = [ @expressions, @errors, @stored_workitems ].find { |l| l.any? }
l ? l.first.fei.wfid : nil
end | ruby | def wfid
l = [ @expressions, @errors, @stored_workitems ].find { |l| l.any? }
l ? l.first.fei.wfid : nil
end | [
"def",
"wfid",
"l",
"=",
"[",
"@expressions",
",",
"@errors",
",",
"@stored_workitems",
"]",
".",
"find",
"{",
"|",
"l",
"|",
"l",
".",
"any?",
"}",
"l",
"?",
"l",
".",
"first",
".",
"fei",
".",
"wfid",
":",
"nil",
"end"
] | Returns the unique identifier for this process instance. | [
"Returns",
"the",
"unique",
"identifier",
"for",
"this",
"process",
"instance",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/dboard/process_status.rb#L197-L202 | train |
jmettraux/ruote | lib/ruote/dboard/process_status.rb | Ruote.ProcessStatus.position | def position
workitems.collect { |wi|
r = [ wi.fei.sid, wi.participant_name ]
params = (wi.fields['params'] || {}).dup
params.delete('ref')
if err = errors.find { |e| e.fei == wi.fei }
params['error'] = err.message
end
r << params
r
}
... | ruby | def position
workitems.collect { |wi|
r = [ wi.fei.sid, wi.participant_name ]
params = (wi.fields['params'] || {}).dup
params.delete('ref')
if err = errors.find { |e| e.fei == wi.fei }
params['error'] = err.message
end
r << params
r
}
... | [
"def",
"position",
"workitems",
".",
"collect",
"{",
"|",
"wi",
"|",
"r",
"=",
"[",
"wi",
".",
"fei",
".",
"sid",
",",
"wi",
".",
"participant_name",
"]",
"params",
"=",
"(",
"wi",
".",
"fields",
"[",
"'params'",
"]",
"||",
"{",
"}",
")",
".",
... | Returns the 'position' of the process.
pdef = Ruote.process_definition do
alpha :task => 'clean car'
end
wfid = engine.launch(pdef)
sleep 0.500
engine.process(wfid) # => [["0_0", "alpha", {"task"=>"clean car"}]]
A process with concurrent branches will yield multiple 'positions'.
It uses #work... | [
"Returns",
"the",
"position",
"of",
"the",
"process",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/dboard/process_status.rb#L255-L271 | train |
jmettraux/ruote | lib/ruote/dboard/process_status.rb | Ruote.ProcessStatus.leaves | def leaves
expressions.inject([]) { |a, exp|
a.select { |e| ! exp.ancestor?(e.fei) } + [ exp ]
}
end | ruby | def leaves
expressions.inject([]) { |a, exp|
a.select { |e| ! exp.ancestor?(e.fei) } + [ exp ]
}
end | [
"def",
"leaves",
"expressions",
".",
"inject",
"(",
"[",
"]",
")",
"{",
"|",
"a",
",",
"exp",
"|",
"a",
".",
"select",
"{",
"|",
"e",
"|",
"!",
"exp",
".",
"ancestor?",
"(",
"e",
".",
"fei",
")",
"}",
"+",
"[",
"exp",
"]",
"}",
"end"
] | Returns the expressions where the flow is currently, ak the leaves
of the execution tree.
Whereas #position only looks at participant expressions (and errors),
#leaves looks at any expressions that is a leave (which has no
child at this point).
Returns an array of FlowExpression instances. (Note that they may
h... | [
"Returns",
"the",
"expressions",
"where",
"the",
"flow",
"is",
"currently",
"ak",
"the",
"leaves",
"of",
"the",
"execution",
"tree",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/dboard/process_status.rb#L283-L288 | train |
jmettraux/ruote | lib/ruote/dboard/process_status.rb | Ruote.ProcessStatus.workitems | def workitems
@expressions.select { |fexp|
#fexp.is_a?(Ruote::Exp::ParticipantExpression)
fexp.h.name == 'participant'
}.collect { |fexp|
Ruote::Workitem.new(fexp.h.applied_workitem)
}
end | ruby | def workitems
@expressions.select { |fexp|
#fexp.is_a?(Ruote::Exp::ParticipantExpression)
fexp.h.name == 'participant'
}.collect { |fexp|
Ruote::Workitem.new(fexp.h.applied_workitem)
}
end | [
"def",
"workitems",
"@expressions",
".",
"select",
"{",
"|",
"fexp",
"|",
"fexp",
".",
"h",
".",
"name",
"==",
"'participant'",
"}",
".",
"collect",
"{",
"|",
"fexp",
"|",
"Ruote",
"::",
"Workitem",
".",
"new",
"(",
"fexp",
".",
"h",
".",
"applied_wo... | Returns a list of the workitems currently 'out' to participants
For example, with an instance of
Ruote.process_definition do
concurrence do
alpha :task => 'clean car'
bravo :task => 'sell car'
end
end
calling engine.process(wfid).workitems will yield two workitems
(alpha and bravo).
... | [
"Returns",
"a",
"list",
"of",
"the",
"workitems",
"currently",
"out",
"to",
"participants"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/dboard/process_status.rb#L326-L334 | train |
jmettraux/ruote | lib/ruote/dboard/process_status.rb | Ruote.ProcessStatus.to_dot | def to_dot(opts={})
s = [ "digraph \"process wfid #{wfid}\" {" ]
@expressions.each { |e| s.push(*e.send(:to_dot, opts)) }
@errors.each { |e| s.push(*e.send(:to_dot, opts)) }
s << '}'
s.join("\n")
end | ruby | def to_dot(opts={})
s = [ "digraph \"process wfid #{wfid}\" {" ]
@expressions.each { |e| s.push(*e.send(:to_dot, opts)) }
@errors.each { |e| s.push(*e.send(:to_dot, opts)) }
s << '}'
s.join("\n")
end | [
"def",
"to_dot",
"(",
"opts",
"=",
"{",
"}",
")",
"s",
"=",
"[",
"\"digraph \\\"process wfid #{wfid}\\\" {\"",
"]",
"@expressions",
".",
"each",
"{",
"|",
"e",
"|",
"s",
".",
"push",
"(",
"*",
"e",
".",
"send",
"(",
":to_dot",
",",
"opts",
")",
")",
... | Returns a 'dot' representation of the process. A graph describing
the tree of flow expressions that compose the process. | [
"Returns",
"a",
"dot",
"representation",
"of",
"the",
"process",
".",
"A",
"graph",
"describing",
"the",
"tree",
"of",
"flow",
"expressions",
"that",
"compose",
"the",
"process",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/dboard/process_status.rb#L477-L485 | train |
jmettraux/ruote | lib/ruote/part/template.rb | Ruote.TemplateMixin.render_template | def render_template(template, flow_expression, workitem)
template = (File.read(template) rescue nil) if is_a_file?(template)
return render_default_template(workitem) unless template
template = template.to_s
workitem = workitem.to_h if workitem.respond_to?(:to_h)
@context.dollar_sub.s(t... | ruby | def render_template(template, flow_expression, workitem)
template = (File.read(template) rescue nil) if is_a_file?(template)
return render_default_template(workitem) unless template
template = template.to_s
workitem = workitem.to_h if workitem.respond_to?(:to_h)
@context.dollar_sub.s(t... | [
"def",
"render_template",
"(",
"template",
",",
"flow_expression",
",",
"workitem",
")",
"template",
"=",
"(",
"File",
".",
"read",
"(",
"template",
")",
"rescue",
"nil",
")",
"if",
"is_a_file?",
"(",
"template",
")",
"return",
"render_default_template",
"(",
... | Do the rendering. | [
"Do",
"the",
"rendering",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/template.rb#L44-L54 | train |
jmettraux/ruote | lib/ruote/part/template.rb | Ruote.TemplateMixin.render_default_template | def render_default_template(workitem)
workitem = workitem.to_h if workitem.respond_to?(:to_h)
s = []
s << "workitem for #{workitem['participant_name']}"
s << ''
s << Rufus::Json.pretty_encode(workitem['fei'])
s << ''
workitem['fields'].keys.sort.each do |key|
s << " -... | ruby | def render_default_template(workitem)
workitem = workitem.to_h if workitem.respond_to?(:to_h)
s = []
s << "workitem for #{workitem['participant_name']}"
s << ''
s << Rufus::Json.pretty_encode(workitem['fei'])
s << ''
workitem['fields'].keys.sort.each do |key|
s << " -... | [
"def",
"render_default_template",
"(",
"workitem",
")",
"workitem",
"=",
"workitem",
".",
"to_h",
"if",
"workitem",
".",
"respond_to?",
"(",
":to_h",
")",
"s",
"=",
"[",
"]",
"s",
"<<",
"\"workitem for #{workitem['participant_name']}\"",
"s",
"<<",
"''",
"s",
... | Simply returns a pretty-printed view of the workitem | [
"Simply",
"returns",
"a",
"pretty",
"-",
"printed",
"view",
"of",
"the",
"workitem"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/template.rb#L58-L71 | train |
jmettraux/ruote | lib/ruote/exp/fe_participant.rb | Ruote::Exp.ParticipantExpression.consider_participant_timers | def consider_participant_timers(p_info)
return if h.has_timers
# process definition takes precedence over participant defined timers.
timers = nil
[ :rtimers, :timers, :rtimeout ].each do |meth|
pa = @context.plist.instantiate(p_info, :if_respond_to? => meth)
next unless p... | ruby | def consider_participant_timers(p_info)
return if h.has_timers
# process definition takes precedence over participant defined timers.
timers = nil
[ :rtimers, :timers, :rtimeout ].each do |meth|
pa = @context.plist.instantiate(p_info, :if_respond_to? => meth)
next unless p... | [
"def",
"consider_participant_timers",
"(",
"p_info",
")",
"return",
"if",
"h",
".",
"has_timers",
"timers",
"=",
"nil",
"[",
":rtimers",
",",
":timers",
",",
":rtimeout",
"]",
".",
"each",
"do",
"|",
"meth",
"|",
"pa",
"=",
"@context",
".",
"plist",
".",... | Determines and schedules timeout if any.
Note that process definition timeout has priority over participant
specified timeout. | [
"Determines",
"and",
"schedules",
"timeout",
"if",
"any",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/fe_participant.rb#L279-L307 | train |
jmettraux/ruote | lib/ruote/part/local_participant.rb | Ruote.LocalParticipant.re_dispatch | def re_dispatch(wi=nil, opts=nil)
wi, opts = [ nil, wi ] if wi.is_a?(Hash) && opts.nil?
wi ||= workitem()
opts ||= {}
wi.h.re_dispatch_count = wi.h.re_dispatch_count.to_s.to_i + 1
msg = {
'action' => 'dispatch',
'fei' => wi.h.fei,
'workitem' => wi.to_h,
'... | ruby | def re_dispatch(wi=nil, opts=nil)
wi, opts = [ nil, wi ] if wi.is_a?(Hash) && opts.nil?
wi ||= workitem()
opts ||= {}
wi.h.re_dispatch_count = wi.h.re_dispatch_count.to_s.to_i + 1
msg = {
'action' => 'dispatch',
'fei' => wi.h.fei,
'workitem' => wi.to_h,
'... | [
"def",
"re_dispatch",
"(",
"wi",
"=",
"nil",
",",
"opts",
"=",
"nil",
")",
"wi",
",",
"opts",
"=",
"[",
"nil",
",",
"wi",
"]",
"if",
"wi",
".",
"is_a?",
"(",
"Hash",
")",
"&&",
"opts",
".",
"nil?",
"wi",
"||=",
"workitem",
"(",
")",
"opts",
"... | Use this method to re_dispatch the workitem.
It takes two options :in and :at for "later re_dispatch".
Look at the unschedule_re_dispatch method for an example of
participant implementation that uses re_dispatch.
Without one of those options, the method is a "reject". | [
"Use",
"this",
"method",
"to",
"re_dispatch",
"the",
"workitem",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/local_participant.rb#L156-L183 | train |
jmettraux/ruote | lib/ruote/svc/error_handler.rb | Ruote.ErrorHandler.msg_handle | def msg_handle(msg, err)
fexp = Ruote::Exp::FlowExpression.fetch(
@context, msg['fei'] || msg['workitem']['fei']
) rescue nil
handle(msg, fexp, err)
end | ruby | def msg_handle(msg, err)
fexp = Ruote::Exp::FlowExpression.fetch(
@context, msg['fei'] || msg['workitem']['fei']
) rescue nil
handle(msg, fexp, err)
end | [
"def",
"msg_handle",
"(",
"msg",
",",
"err",
")",
"fexp",
"=",
"Ruote",
"::",
"Exp",
"::",
"FlowExpression",
".",
"fetch",
"(",
"@context",
",",
"msg",
"[",
"'fei'",
"]",
"||",
"msg",
"[",
"'workitem'",
"]",
"[",
"'fei'",
"]",
")",
"rescue",
"nil",
... | As used by the dispatch pool and the worker. | [
"As",
"used",
"by",
"the",
"dispatch",
"pool",
"and",
"the",
"worker",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/error_handler.rb#L59-L66 | train |
jmettraux/ruote | lib/ruote/svc/error_handler.rb | Ruote.ErrorHandler.msg_raise | def msg_raise(msg, err)
fei = msg['fei']
wfid = msg['wfid'] || msg.fetch('fei', {})['wfid']
@context.storage.put_msg(
'raise',
'fei' => fei,
'wfid' => wfid,
'msg' => msg,
'error' => deflate(err, fei))
end | ruby | def msg_raise(msg, err)
fei = msg['fei']
wfid = msg['wfid'] || msg.fetch('fei', {})['wfid']
@context.storage.put_msg(
'raise',
'fei' => fei,
'wfid' => wfid,
'msg' => msg,
'error' => deflate(err, fei))
end | [
"def",
"msg_raise",
"(",
"msg",
",",
"err",
")",
"fei",
"=",
"msg",
"[",
"'fei'",
"]",
"wfid",
"=",
"msg",
"[",
"'wfid'",
"]",
"||",
"msg",
".",
"fetch",
"(",
"'fei'",
",",
"{",
"}",
")",
"[",
"'wfid'",
"]",
"@context",
".",
"storage",
".",
"pu... | Packages the error in a 'raise' msg and places it in the storage,
for a worker to pick it up.
TODO: investigate: is it still used, relevant? (probably yes, ruote-swf) | [
"Packages",
"the",
"error",
"in",
"a",
"raise",
"msg",
"and",
"places",
"it",
"in",
"the",
"storage",
"for",
"a",
"worker",
"to",
"pick",
"it",
"up",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/error_handler.rb#L73-L84 | train |
jmettraux/ruote | lib/ruote/svc/error_handler.rb | Ruote.ErrorHandler.handle | def handle(msg, fexp, err)
err = RaisedError.new(err) unless err.respond_to?(:backtrace)
meta = err.is_a?(Ruote::MetaError)
fei = msg['fei'] || (fexp.h.fei rescue nil)
wfid = msg['wfid'] || (fei || {})['wfid']
# on_error ?
return if ( ! meta) && fexp && fexp.handle_on_error(msg,... | ruby | def handle(msg, fexp, err)
err = RaisedError.new(err) unless err.respond_to?(:backtrace)
meta = err.is_a?(Ruote::MetaError)
fei = msg['fei'] || (fexp.h.fei rescue nil)
wfid = msg['wfid'] || (fei || {})['wfid']
# on_error ?
return if ( ! meta) && fexp && fexp.handle_on_error(msg,... | [
"def",
"handle",
"(",
"msg",
",",
"fexp",
",",
"err",
")",
"err",
"=",
"RaisedError",
".",
"new",
"(",
"err",
")",
"unless",
"err",
".",
"respond_to?",
"(",
":backtrace",
")",
"meta",
"=",
"err",
".",
"is_a?",
"(",
"Ruote",
"::",
"MetaError",
")",
... | Called by msg_handle or action_handle. | [
"Called",
"by",
"msg_handle",
"or",
"action_handle",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/error_handler.rb#L108-L156 | train |
jmettraux/ruote | lib/ruote/svc/error_handler.rb | Ruote.ErrorHandler.deflate | def deflate(err, fei, fexp=nil)
return err unless err.respond_to?(:backtrace)
fexp ||=
Ruote::Exp::FlowExpression.dummy('fei' => fei, 'original_tree' => nil)
fexp.deflate(err)
end | ruby | def deflate(err, fei, fexp=nil)
return err unless err.respond_to?(:backtrace)
fexp ||=
Ruote::Exp::FlowExpression.dummy('fei' => fei, 'original_tree' => nil)
fexp.deflate(err)
end | [
"def",
"deflate",
"(",
"err",
",",
"fei",
",",
"fexp",
"=",
"nil",
")",
"return",
"err",
"unless",
"err",
".",
"respond_to?",
"(",
":backtrace",
")",
"fexp",
"||=",
"Ruote",
"::",
"Exp",
"::",
"FlowExpression",
".",
"dummy",
"(",
"'fei'",
"=>",
"fei",
... | Returns a serializable hash with all the details of the error. | [
"Returns",
"a",
"serializable",
"hash",
"with",
"all",
"the",
"details",
"of",
"the",
"error",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/error_handler.rb#L160-L168 | train |
jmettraux/ruote | lib/ruote/exp/fe_concurrence.rb | Ruote::Exp.ConcurrenceExpression.expected_count | def expected_count
if h.ccount.nil?
count_list_size
elsif h.ccount >= 0
[ h.ccount, count_list_size ].min
else # all but 1, 2, ...
i = count_list_size + h.ccount
i < 1 ? 1 : i
end
end | ruby | def expected_count
if h.ccount.nil?
count_list_size
elsif h.ccount >= 0
[ h.ccount, count_list_size ].min
else # all but 1, 2, ...
i = count_list_size + h.ccount
i < 1 ? 1 : i
end
end | [
"def",
"expected_count",
"if",
"h",
".",
"ccount",
".",
"nil?",
"count_list_size",
"elsif",
"h",
".",
"ccount",
">=",
"0",
"[",
"h",
".",
"ccount",
",",
"count_list_size",
"]",
".",
"min",
"else",
"i",
"=",
"count_list_size",
"+",
"h",
".",
"ccount",
"... | How many branch replies are expected before the concurrence is over ? | [
"How",
"many",
"branch",
"replies",
"are",
"expected",
"before",
"the",
"concurrence",
"is",
"over",
"?"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/fe_concurrence.rb#L449-L459 | train |
jmettraux/ruote | lib/ruote/exp/fe_concurrence.rb | Ruote::Exp.ConcurrenceExpression.merge_workitems | def merge_workitems(workitems, merge_type)
workitems.inject(nil) do |t, wi|
Ruote.merge_workitem(workitem_index(wi), t, wi, merge_type)
end
end | ruby | def merge_workitems(workitems, merge_type)
workitems.inject(nil) do |t, wi|
Ruote.merge_workitem(workitem_index(wi), t, wi, merge_type)
end
end | [
"def",
"merge_workitems",
"(",
"workitems",
",",
"merge_type",
")",
"workitems",
".",
"inject",
"(",
"nil",
")",
"do",
"|",
"t",
",",
"wi",
"|",
"Ruote",
".",
"merge_workitem",
"(",
"workitem_index",
"(",
"wi",
")",
",",
"t",
",",
"wi",
",",
"merge_typ... | Given a list of workitems and a merge_type, will merge according to
the merge type.
The return value is the merged workitem.
(Still used when dealing with highest/lowest merge_type and legacy
concurrence/citerator expressions) | [
"Given",
"a",
"list",
"of",
"workitems",
"and",
"a",
"merge_type",
"will",
"merge",
"according",
"to",
"the",
"merge",
"type",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/fe_concurrence.rb#L593-L598 | train |
jmettraux/ruote | lib/ruote/workitem.rb | Ruote.Workitem.as_json | def as_json(pretty=false)
pretty ? Rufus::Json.pretty_encode(@h) : Rufus::Json.encode(@h)
end | ruby | def as_json(pretty=false)
pretty ? Rufus::Json.pretty_encode(@h) : Rufus::Json.encode(@h)
end | [
"def",
"as_json",
"(",
"pretty",
"=",
"false",
")",
"pretty",
"?",
"Rufus",
"::",
"Json",
".",
"pretty_encode",
"(",
"@h",
")",
":",
"Rufus",
"::",
"Json",
".",
"encode",
"(",
"@h",
")",
"end"
] | Encodes this workitem as JSON. If pretty is set to true, will output
prettified JSON. | [
"Encodes",
"this",
"workitem",
"as",
"JSON",
".",
"If",
"pretty",
"is",
"set",
"to",
"true",
"will",
"output",
"prettified",
"JSON",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/workitem.rb#L385-L388 | train |
jmettraux/ruote | lib/ruote/workitem.rb | Ruote.Workitem.remove_tag | def remove_tag(tag)
# it's a bit convoluted... trying to cope with potential inconsistencies
#
# normally, it should only be a tags.pop(), but since user have
# access to the workitem and its fields... better be safe than sorry
tags = (h.fields['__tags__'] || [])
if index = tags.r... | ruby | def remove_tag(tag)
# it's a bit convoluted... trying to cope with potential inconsistencies
#
# normally, it should only be a tags.pop(), but since user have
# access to the workitem and its fields... better be safe than sorry
tags = (h.fields['__tags__'] || [])
if index = tags.r... | [
"def",
"remove_tag",
"(",
"tag",
")",
"tags",
"=",
"(",
"h",
".",
"fields",
"[",
"'__tags__'",
"]",
"||",
"[",
"]",
")",
"if",
"index",
"=",
"tags",
".",
"rindex",
"(",
"tag",
")",
"tags",
".",
"delete_at",
"(",
"index",
")",
"end",
"h",
".",
"... | Used by FlowExpression when leaving a tag. | [
"Used",
"by",
"FlowExpression",
"when",
"leaving",
"a",
"tag",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/workitem.rb#L415-L429 | train |
jmettraux/ruote | lib/ruote/svc/dispatch_pool.rb | Ruote.DispatchPool.dispatch | def dispatch(msg)
participant = @context.plist.lookup(
msg['participant'] || msg['participant_name'], msg['workitem'])
if
@context['participant_threads_enabled'] == false ||
do_not_thread?(participant, msg)
then
do_dispatch(participant, msg)
else
do_thre... | ruby | def dispatch(msg)
participant = @context.plist.lookup(
msg['participant'] || msg['participant_name'], msg['workitem'])
if
@context['participant_threads_enabled'] == false ||
do_not_thread?(participant, msg)
then
do_dispatch(participant, msg)
else
do_thre... | [
"def",
"dispatch",
"(",
"msg",
")",
"participant",
"=",
"@context",
".",
"plist",
".",
"lookup",
"(",
"msg",
"[",
"'participant'",
"]",
"||",
"msg",
"[",
"'participant_name'",
"]",
",",
"msg",
"[",
"'workitem'",
"]",
")",
"if",
"@context",
"[",
"'partici... | Dispatching the msg. | [
"Dispatching",
"the",
"msg",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/dispatch_pool.rb#L53-L66 | train |
jmettraux/ruote | lib/ruote/svc/dispatch_pool.rb | Ruote.DispatchPool.do_dispatch | def do_dispatch(participant, msg)
do_raw_dispatch(participant, msg)
rescue => err
@context.error_handler.msg_handle(msg, err)
end | ruby | def do_dispatch(participant, msg)
do_raw_dispatch(participant, msg)
rescue => err
@context.error_handler.msg_handle(msg, err)
end | [
"def",
"do_dispatch",
"(",
"participant",
",",
"msg",
")",
"do_raw_dispatch",
"(",
"participant",
",",
"msg",
")",
"rescue",
"=>",
"err",
"@context",
".",
"error_handler",
".",
"msg_handle",
"(",
"msg",
",",
"err",
")",
"end"
] | The raw dispatch work, wrapped in error handling. | [
"The",
"raw",
"dispatch",
"work",
"wrapped",
"in",
"error",
"handling",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/dispatch_pool.rb#L93-L99 | train |
jmettraux/ruote | lib/ruote/svc/dispatch_pool.rb | Ruote.DispatchPool.do_threaded_dispatch | def do_threaded_dispatch(participant, msg)
msg = Rufus::Json.dup(msg)
#
# the thread gets its own copy of the message
# (especially important if the main thread does something with
# the message 'during' the dispatch)
# Maybe at some point a limit on the number of dispatch ... | ruby | def do_threaded_dispatch(participant, msg)
msg = Rufus::Json.dup(msg)
#
# the thread gets its own copy of the message
# (especially important if the main thread does something with
# the message 'during' the dispatch)
# Maybe at some point a limit on the number of dispatch ... | [
"def",
"do_threaded_dispatch",
"(",
"participant",
",",
"msg",
")",
"msg",
"=",
"Rufus",
"::",
"Json",
".",
"dup",
"(",
"msg",
")",
"Thread",
".",
"new",
"{",
"do_dispatch",
"(",
"participant",
",",
"msg",
")",
"}",
"end"
] | Wraps the call to do_dispatch in a thread. | [
"Wraps",
"the",
"call",
"to",
"do_dispatch",
"in",
"a",
"thread",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/dispatch_pool.rb#L103-L116 | train |
jmettraux/ruote | lib/ruote/svc/dispatch_pool.rb | Ruote.DispatchPool.dispatch_cancel | 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' =>... | ruby | 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' =>... | [
"def",
"dispatch_cancel",
"(",
"msg",
")",
"flavour",
"=",
"msg",
"[",
"'flavour'",
"]",
"participant",
"=",
"@context",
".",
"plist",
".",
"instantiate",
"(",
"msg",
"[",
"'participant'",
"]",
")",
"result",
"=",
"begin",
"Ruote",
".",
"participant_send",
... | Instantiates the participant and calls its cancel method. | [
"Instantiates",
"the",
"participant",
"and",
"calls",
"its",
"cancel",
"method",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/dispatch_pool.rb#L134-L157 | train |
jmettraux/ruote | lib/ruote/receiver/base.rb | Ruote.ReceiverMixin.receive | 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 | 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 | [
"def",
"receive",
"(",
"workitem",
")",
"workitem",
"=",
"workitem",
".",
"to_h",
"if",
"workitem",
".",
"respond_to?",
"(",
":to_h",
")",
"@context",
".",
"storage",
".",
"put_msg",
"(",
"'receive'",
",",
"'fei'",
"=>",
"workitem",
"[",
"'fei'",
"]",
",... | This method pipes back a workitem into the engine, letting it resume
in its flow, hopefully. | [
"This",
"method",
"pipes",
"back",
"a",
"workitem",
"into",
"the",
"engine",
"letting",
"it",
"resume",
"in",
"its",
"flow",
"hopefully",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/receiver/base.rb#L75-L85 | train |
jmettraux/ruote | lib/ruote/receiver/base.rb | Ruote.ReceiverMixin.flunk | 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
... | ruby | 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
... | [
"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",
"Ex... | Can be used to raise an error in the workflow instance.
Can be called either with an error class and arguments, either with
an error instance (and no arguments), or a string message and no
arguments.
The workitem can be either an instance of Ruote::Workitem or a workitem
in its Hash representation.
receiver.... | [
"Can",
"be",
"used",
"to",
"raise",
"an",
"error",
"in",
"the",
"workflow",
"instance",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/receiver/base.rb#L116-L163 | train |
jmettraux/ruote | lib/ruote/receiver/base.rb | Ruote.ReceiverMixin.launch | 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] || ... | ruby | 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] || ... | [
"def",
"launch",
"(",
"process_definition",
",",
"fields",
"=",
"{",
"}",
",",
"variables",
"=",
"{",
"}",
",",
"root_stash",
"=",
"nil",
")",
"wfid",
"=",
"fields",
"[",
":wfid",
"]",
"||",
"@context",
".",
"wfidgen",
".",
"generate",
"fields",
"=",
... | Given a process definitions and optional initial fields and variables,
launches a new process instance.
This method is mostly used from the Ruote::Dashboard class (which
includes this mixin).
process_definition must be a result of Ruote.process_definition call
or XML or JSON serialized process definition, as acc... | [
"Given",
"a",
"process",
"definitions",
"and",
"optional",
"initial",
"fields",
"and",
"variables",
"launches",
"a",
"new",
"process",
"instance",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/receiver/base.rb#L186-L211 | train |
jmettraux/ruote | lib/ruote/receiver/base.rb | Ruote.ReceiverMixin.fetch_flow_expression | def fetch_flow_expression(workitem_or_fei)
Ruote::Exp::FlowExpression.fetch(
@context,
Ruote::FlowExpressionId.extract_h(workitem_or_fei))
end | ruby | def fetch_flow_expression(workitem_or_fei)
Ruote::Exp::FlowExpression.fetch(
@context,
Ruote::FlowExpressionId.extract_h(workitem_or_fei))
end | [
"def",
"fetch_flow_expression",
"(",
"workitem_or_fei",
")",
"Ruote",
"::",
"Exp",
"::",
"FlowExpression",
".",
"fetch",
"(",
"@context",
",",
"Ruote",
"::",
"FlowExpressionId",
".",
"extract_h",
"(",
"workitem_or_fei",
")",
")",
"end"
] | Convenience method, given a workitem or a fei, returns the
corresponding flow expession. | [
"Convenience",
"method",
"given",
"a",
"workitem",
"or",
"a",
"fei",
"returns",
"the",
"corresponding",
"flow",
"expession",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/receiver/base.rb#L225-L230 | train |
jmettraux/ruote | lib/ruote/receiver/base.rb | Ruote.ReceiverMixin.stash_get | 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 | 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 | [
"def",
"stash_get",
"(",
"workitem_or_fei",
",",
"key",
"=",
"nil",
")",
"stash",
"=",
"fetch_flow_expression",
"(",
"workitem_or_fei",
")",
".",
"h",
"[",
"'stash'",
"]",
"rescue",
"nil",
"stash",
"||=",
"{",
"}",
"key",
"?",
"stash",
"[",
"key",
"]",
... | Fetches back a stashed value.
get(fei, 'colour')
# => 'blue'
To return the whole stash
get(fei)
# => { 'colour' => 'blue' }
put & get are useful for a participant that needs to communicate
between its consume and its cancel. | [
"Fetches",
"back",
"a",
"stashed",
"value",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/receiver/base.rb#L306-L312 | train |
jmettraux/ruote | lib/ruote/worker.rb | Ruote.Worker.inactive? | 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']
}
... | ruby | 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']
}
... | [
"def",
"inactive?",
"return",
"false",
"if",
"@msgs",
".",
"size",
">",
"0",
"return",
"false",
"unless",
"@context",
".",
"storage",
".",
"empty?",
"(",
"'schedules'",
")",
"return",
"false",
"unless",
"@context",
".",
"storage",
".",
"empty?",
"(",
"'msg... | Returns true if the engine system is inactive, ie if all the process
instances are terminated or are stuck in an error.
NOTE : for now, if a branch of a process is in error while another is
still running, this method will consider the process instance inactive
(and it will return true if all the processes are cons... | [
"Returns",
"true",
"if",
"the",
"engine",
"system",
"is",
"inactive",
"ie",
"if",
"all",
"the",
"process",
"instances",
"are",
"terminated",
"or",
"are",
"stuck",
"in",
"an",
"error",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/worker.rb#L149-L166 | train |
jmettraux/ruote | lib/ruote/worker.rb | Ruote.Worker.turn_schedule_to_msg | 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 | 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 | [
"def",
"turn_schedule_to_msg",
"(",
"schedule",
")",
"return",
"false",
"unless",
"@storage",
".",
"reserve",
"(",
"schedule",
")",
"msg",
"=",
"Ruote",
".",
"fulldup",
"(",
"schedule",
"[",
"'msg'",
"]",
")",
"@storage",
".",
"put_msg",
"(",
"msg",
".",
... | Given a schedule, attempts to trigger it.
It first tries to reserve the schedule. If the reservation fails
(another worker was successful probably), false is returned.
The schedule is triggered if the reservation was successful, true
is returned. | [
"Given",
"a",
"schedule",
"attempts",
"to",
"trigger",
"it",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/worker.rb#L355-L364 | train |
jmettraux/ruote | lib/ruote/worker.rb | Ruote.Worker.process | 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)
w... | ruby | 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)
w... | [
"def",
"process",
"(",
"msg",
")",
"return",
"false",
"unless",
"@storage",
".",
"reserve",
"(",
"msg",
")",
"begin",
"@context",
".",
"pre_notify",
"(",
"msg",
")",
"case",
"msg",
"[",
"'action'",
"]",
"when",
"'launch'",
",",
"'apply'",
",",
"'regenera... | Processes one msg.
Will return false immediately if the msg reservation failed (another
worker grabbed the message.
Else will execute the action ordered in the msg, and return true.
Exceptions in execution are intercepted here and passed to the
engine's (context's) error_handler. | [
"Processes",
"one",
"msg",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/worker.rb#L376-L433 | train |
jmettraux/ruote | lib/ruote/worker.rb | Ruote.Worker.launch | 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... | ruby | 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... | [
"def",
"launch",
"(",
"msg",
")",
"tree",
"=",
"msg",
"[",
"'tree'",
"]",
"variables",
"=",
"msg",
"[",
"'variables'",
"]",
"wi",
"=",
"msg",
"[",
"'workitem'",
"]",
"exp_class",
"=",
"@context",
".",
"expmap",
".",
"expression_class",
"(",
"tree",
"."... | Works for both the 'launch' and the 'apply' msgs.
Creates a new expression, gives and applies it with the
workitem contained in the msg. | [
"Works",
"for",
"both",
"the",
"launch",
"and",
"the",
"apply",
"msgs",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/worker.rb#L440-L509 | train |
jmettraux/ruote | lib/ruote/worker.rb | Ruote.Worker.pause_process | 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 | 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 | [
"def",
"pause_process",
"(",
"msg",
")",
"root",
"=",
"@storage",
".",
"find_root_expression",
"(",
"msg",
"[",
"'wfid'",
"]",
")",
"return",
"unless",
"root",
"@storage",
".",
"put_msg",
"(",
"msg",
"[",
"'action'",
"]",
"==",
"'pause_process'",
"?",
"'pa... | Handles 'pause_process' and 'resume_process'. | [
"Handles",
"pause_process",
"and",
"resume_process",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/worker.rb#L547-L557 | train |
jmettraux/ruote | lib/ruote/worker.rb | Ruote.Worker.reput | 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 | 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 | [
"def",
"reput",
"(",
"msg",
")",
"if",
"doc",
"=",
"msg",
"[",
"'doc'",
"]",
"r",
"=",
"@storage",
".",
"put",
"(",
"doc",
")",
"return",
"unless",
"r",
".",
"is_a?",
"(",
"Hash",
")",
"doc",
"[",
"'_rev'",
"]",
"=",
"r",
"[",
"'_rev'",
"]",
... | Reputs a doc or a msg.
Used by certain storage implementations to pass documents around workers
or to reschedule msgs (see ruote-swf). | [
"Reputs",
"a",
"doc",
"or",
"a",
"msg",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/worker.rb#L566-L582 | train |
jmettraux/ruote | lib/ruote/exp/fe_filter.rb | Ruote::Exp.FilterExpression.block_filter | 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... | ruby | 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... | [
"def",
"block_filter",
"return",
"nil",
"if",
"tree",
".",
"last",
".",
"empty?",
"tree",
".",
"last",
".",
"collect",
"{",
"|",
"line",
"|",
"next",
"'or'",
"if",
"line",
".",
"first",
"==",
"'or'",
"rule",
"=",
"line",
"[",
"1",
"]",
".",
"remap"... | Filter is passed in a block (which is not evaluted as a ruote branch
but immediately translated into a filter.
pdef = Ruote.process_definition do
filter do
field 'x', :type => 'string'
field 'y', :type => 'number'
end
end
Note : 'or' is OK
pdef = Ruote.process_definition do
fi... | [
"Filter",
"is",
"passed",
"in",
"a",
"block",
"(",
"which",
"is",
"not",
"evaluted",
"as",
"a",
"ruote",
"branch",
"but",
"immediately",
"translated",
"into",
"a",
"filter",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/fe_filter.rb#L599-L619 | train |
jmettraux/ruote | lib/ruote/exp/fe_filter.rb | Ruote::Exp.FilterExpression.one_line_filter | 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 | 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 | [
"def",
"one_line_filter",
"if",
"(",
"attributes",
".",
"keys",
"-",
"COMMON_ATT_KEYS",
"-",
"%w[",
"ref",
"original_ref",
"]",
")",
".",
"empty?",
"return",
"nil",
"end",
"[",
"attributes",
".",
"remap",
"{",
"|",
"(",
"k",
",",
"v",
")",
",",
"h",
... | Filter thanks to the attributes of the expression.
pdef = Ruote.process_definition do
filter 'x', :type => 'string', :record => true
filter 'y', :type => 'number', :record => true
end | [
"Filter",
"thanks",
"to",
"the",
"attributes",
"of",
"the",
"expression",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/fe_filter.rb#L662-L675 | train |
jmettraux/ruote | lib/ruote/exp/ro_variables.rb | Ruote::Exp.FlowExpression.compile_variables | def compile_variables
vars = h.parent_id ? parent.compile_variables : {}
vars.merge!(h.variables) if h.variables
vars
end | ruby | def compile_variables
vars = h.parent_id ? parent.compile_variables : {}
vars.merge!(h.variables) if h.variables
vars
end | [
"def",
"compile_variables",
"vars",
"=",
"h",
".",
"parent_id",
"?",
"parent",
".",
"compile_variables",
":",
"{",
"}",
"vars",
".",
"merge!",
"(",
"h",
".",
"variables",
")",
"if",
"h",
".",
"variables",
"vars",
"end"
] | Returns a fresh hash of all the variables visible from this expression.
This is used mainly when forgetting an expression. | [
"Returns",
"a",
"fresh",
"hash",
"of",
"all",
"the",
"variables",
"visible",
"from",
"this",
"expression",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/ro_variables.rb#L44-L50 | train |
jmettraux/ruote | lib/ruote/exp/ro_variables.rb | Ruote::Exp.FlowExpression.unset_variable | 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 | 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 | [
"def",
"unset_variable",
"(",
"var",
",",
"override",
"=",
"false",
")",
"fexp",
",",
"v",
"=",
"locate_set_var",
"(",
"var",
",",
"override",
")",
"||",
"locate_var",
"(",
"var",
")",
"fexp",
".",
"un_set_variable",
"(",
":unset",
",",
"v",
",",
"nil"... | Unbinds a variables. | [
"Unbinds",
"a",
"variables",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/ro_variables.rb#L107-L112 | train |
jmettraux/ruote | lib/ruote/exp/ro_variables.rb | Ruote::Exp.FlowExpression.split_prefix | 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 | 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 | [
"def",
"split_prefix",
"(",
"var",
",",
"prefix",
")",
"if",
"prefix",
".",
"nil?",
"m",
"=",
"VAR_PREFIX_REGEX",
".",
"match",
"(",
"var",
".",
"to_s",
")",
"prefix",
"=",
"m",
"[",
"1",
"]",
"var",
"=",
"m",
"[",
"2",
"]",
"end",
"[",
"var",
... | Used by lookup_variable and set_variable to extract the
prefix in a variable name | [
"Used",
"by",
"lookup_variable",
"and",
"set_variable",
"to",
"extract",
"the",
"prefix",
"in",
"a",
"variable",
"name"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/ro_variables.rb#L160-L169 | train |
jmettraux/ruote | lib/ruote/dboard/mutation.rb | Ruote.Mutation.walk | 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_a... | ruby | 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_a... | [
"def",
"walk",
"(",
"fexp",
",",
"tree",
")",
"ftree",
"=",
"Ruote",
".",
"compact_tree",
"(",
"@ps",
".",
"current_tree",
"(",
"fexp",
")",
")",
"if",
"ftree",
"[",
"0",
"]",
"!=",
"tree",
"[",
"0",
"]",
"||",
"ftree",
"[",
"1",
"]",
"!=",
"tr... | Look for mutation points in an expression and its children. | [
"Look",
"for",
"mutation",
"points",
"in",
"an",
"expression",
"and",
"its",
"children",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/dboard/mutation.rb#L146-L183 | train |
jmettraux/ruote | lib/ruote/dboard/mutation.rb | Ruote.Mutation.walk_sequence | 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 att... | ruby | 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 att... | [
"def",
"walk_sequence",
"(",
"fexp",
",",
"ftree",
",",
"tree",
")",
"i",
"=",
"fexp",
".",
"child_ids",
".",
"first",
"ehead",
"=",
"ftree",
"[",
"2",
"]",
".",
"take",
"(",
"i",
")",
"ecurrent",
"=",
"ftree",
"[",
"2",
"]",
"[",
"i",
"]",
"et... | Look for mutation points in any non-concurrent expression. | [
"Look",
"for",
"mutation",
"points",
"in",
"any",
"non",
"-",
"concurrent",
"expression",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/dboard/mutation.rb#L244-L279 | train |
jmettraux/ruote | lib/ruote/exp/fe_cursor.rb | Ruote::Exp.CursorExpression.move_on | 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', '... | ruby | 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', '... | [
"def",
"move_on",
"(",
"workitem",
"=",
"h",
".",
"applied_workitem",
")",
"position",
"=",
"workitem",
"[",
"'fei'",
"]",
"==",
"h",
".",
"fei",
"?",
"-",
"1",
":",
"Ruote",
"::",
"FlowExpressionId",
".",
"child_id",
"(",
"workitem",
"[",
"'fei'",
"]"... | Determines which child expression of the cursor is to be applied next. | [
"Determines",
"which",
"child",
"expression",
"of",
"the",
"cursor",
"is",
"to",
"be",
"applied",
"next",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/fe_cursor.rb#L259-L287 | train |
jmettraux/ruote | lib/ruote/exp/fe_cursor.rb | Ruote::Exp.CursorExpression.jump_to | 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'], ... | ruby | 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'], ... | [
"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",
... | Jumps to an integer position, or the name of an expression
or a tag name of a ref name. | [
"Jumps",
"to",
"an",
"integer",
"position",
"or",
"the",
"name",
"of",
"an",
"expression",
"or",
"a",
"tag",
"name",
"of",
"a",
"ref",
"name",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/fe_cursor.rb#L299-L320 | train |
jmettraux/ruote | lib/ruote/storage/base.rb | Ruote.StorageBase.clear | def clear
%w[ msgs schedules errors expressions workitems ].each do |type|
purge_type!(type)
end
end | ruby | def clear
%w[ msgs schedules errors expressions workitems ].each do |type|
purge_type!(type)
end
end | [
"def",
"clear",
"%w[",
"msgs",
"schedules",
"errors",
"expressions",
"workitems",
"]",
".",
"each",
"do",
"|",
"type",
"|",
"purge_type!",
"(",
"type",
")",
"end",
"end"
] | Used when doing integration tests, removes all
msgs, schedules, errors, expressions and workitems.
NOTE that it doesn't remove engine variables (danger) | [
"Used",
"when",
"doing",
"integration",
"tests",
"removes",
"all",
"msgs",
"schedules",
"errors",
"expressions",
"and",
"workitems",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/storage/base.rb#L267-L272 | train |
jmettraux/ruote | lib/ruote/storage/base.rb | Ruote.StorageBase.remove_process | 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}") }
... | ruby | 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}") }
... | [
"def",
"remove_process",
"(",
"wfid",
")",
"2",
".",
"times",
"do",
"Thread",
".",
"pass",
"%w[",
"schedules",
"expressions",
"errors",
"workitems",
"]",
".",
"each",
"do",
"|",
"type",
"|",
"get_many",
"(",
"type",
",",
"wfid",
")",
".",
"each",
"{",
... | Removes a process by removing all its schedules, expressions, errors,
workitems and trackers.
Warning: will not trigger any cancel behaviours at all, just removes
the process. | [
"Removes",
"a",
"process",
"by",
"removing",
"all",
"its",
"schedules",
"expressions",
"errors",
"workitems",
"and",
"trackers",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/storage/base.rb#L280-L297 | train |
jmettraux/ruote | lib/ruote/storage/base.rb | Ruote.StorageBase.prepare_msg_doc | 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 = (@cou... | ruby | 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 = (@cou... | [
"def",
"prepare_msg_doc",
"(",
"action",
",",
"options",
")",
"@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' % @coun... | Used by put_msg | [
"Used",
"by",
"put_msg"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/storage/base.rb#L310-L329 | train |
jmettraux/ruote | lib/ruote/storage/base.rb | Ruote.StorageBase.prepare_schedule_doc | 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 ... | ruby | 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 ... | [
"def",
"prepare_schedule_doc",
"(",
"flavour",
",",
"owner_fei",
",",
"s",
",",
"msg",
")",
"at",
"=",
"if",
"s",
".",
"is_a?",
"(",
"Time",
")",
"s",
"elsif",
"Ruote",
".",
"cron_string?",
"(",
"s",
")",
"Rufus",
"::",
"Scheduler",
"::",
"CronLine",
... | Used by put_schedule | [
"Used",
"by",
"put_schedule"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/storage/base.rb#L333-L362 | train |
jmettraux/ruote | lib/ruote/exp/ro_on_x.rb | Ruote::Exp.FlowExpression.handle_on_error | 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 == ''
... | ruby | 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 == ''
... | [
"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"... | Looks up parent with on_error attribute and triggers it | [
"Looks",
"up",
"parent",
"with",
"on_error",
"attribute",
"and",
"triggers",
"it"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/ro_on_x.rb#L68-L105 | train |
jmettraux/ruote | lib/ruote/exp/ro_on_x.rb | Ruote::Exp.FlowExpression.local_on_error | 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)).ma... | ruby | 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)).ma... | [
"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?",
... | Given an error, returns the on_error registered for it, or nil if none. | [
"Given",
"an",
"error",
"returns",
"the",
"on_error",
"registered",
"for",
"it",
"or",
"nil",
"if",
"none",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/ro_on_x.rb#L167-L188 | train |
jmettraux/ruote | lib/ruote/svc/tracker.rb | Ruote.Tracker.remove | 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 work... | ruby | 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 work... | [
"def",
"remove",
"(",
"tracker_ids",
",",
"wfid",
")",
"return",
"if",
"tracker_ids",
".",
"empty?",
"doc",
"||=",
"@context",
".",
"storage",
".",
"get_trackers",
"(",
"wfid",
")",
"return",
"if",
"(",
"doc",
"[",
"'trackers'",
"]",
".",
"keys",
"&",
... | Removes a set of tracker ids and updated the tracker document. | [
"Removes",
"a",
"set",
"of",
"tracker",
"ids",
"and",
"updated",
"the",
"tracker",
"document",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/tracker.rb#L110-L127 | train |
jmettraux/ruote | lib/ruote/svc/tracker.rb | Ruote.Tracker.on_message | 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 = []
trac... | ruby | 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 = []
trac... | [
"def",
"on_message",
"(",
"pre",
",",
"message",
")",
"m_wfid",
"=",
"message",
"[",
"'wfid'",
"]",
"||",
"(",
"message",
"[",
"'fei'",
"]",
"[",
"'wfid'",
"]",
"rescue",
"nil",
")",
"m_error",
"=",
"message",
"[",
"'error'",
"]",
"m_action",
"=",
"m... | The method behind on_pre_msg and on_msg. Filters msgs against trackers.
Triggers trackers if there is a match. | [
"The",
"method",
"behind",
"on_pre_msg",
"and",
"on_msg",
".",
"Filters",
"msgs",
"against",
"trackers",
".",
"Triggers",
"trackers",
"if",
"there",
"is",
"a",
"match",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/tracker.rb#L132-L178 | train |
jmettraux/ruote | lib/ruote/svc/tracker.rb | Ruote.Tracker.alter | 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 | 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 | [
"def",
"alter",
"(",
"m_wfid",
",",
"m_error",
",",
"m_action",
",",
"msg",
",",
"tracker",
")",
"case",
"tracker",
"[",
"'msg'",
"]",
".",
"delete",
"(",
"'_alter'",
")",
"when",
"'merge'",
"then",
"msg",
".",
"merge!",
"(",
"tracker",
"[",
"'msg'",
... | Alters the msg, only called in "pre" mode. | [
"Alters",
"the",
"msg",
"only",
"called",
"in",
"pre",
"mode",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/tracker.rb#L182-L188 | train |
jmettraux/ruote | lib/ruote/svc/tracker.rb | Ruote.Tracker.trigger | 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'] = m... | ruby | 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'] = m... | [
"def",
"trigger",
"(",
"m_wfid",
",",
"m_error",
",",
"m_action",
",",
"msg",
",",
"tracker",
")",
"t_action",
"=",
"tracker",
"[",
"'action'",
"]",
"tracker_id",
"=",
"tracker",
"[",
"'id'",
"]",
"m",
"=",
"Ruote",
".",
"fulldup",
"(",
"tracker",
"[",... | Prepares the message that gets placed on the ruote msg queue. | [
"Prepares",
"the",
"message",
"that",
"gets",
"placed",
"on",
"the",
"ruote",
"msg",
"queue",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/tracker.rb#L192-L220 | train |
jmettraux/ruote | lib/ruote/svc/tracker.rb | Ruote.Tracker.does_match? | 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... | ruby | 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... | [
"def",
"does_match?",
"(",
"msg",
",",
"conditions",
")",
"return",
"true",
"unless",
"conditions",
"conditions",
".",
"each",
"do",
"|",
"k",
",",
"v",
"|",
"return",
"false",
"unless",
"Array",
"(",
"v",
")",
".",
"find",
"do",
"|",
"vv",
"|",
"vv"... | Given a msg and a hash of conditions, returns true if the msg
matches the conditions. | [
"Given",
"a",
"msg",
"and",
"a",
"hash",
"of",
"conditions",
"returns",
"true",
"if",
"the",
"msg",
"matches",
"the",
"conditions",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/tracker.rb#L236-L262 | train |
jmettraux/ruote | lib/ruote/log/wait_logger.rb | Ruote.WaitLogger.on_msg | 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 | 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 | [
"def",
"on_msg",
"(",
"msg",
")",
"puts",
"(",
"fancy_print",
"(",
"msg",
",",
"@noisy",
")",
")",
"if",
"@noisy",
"return",
"if",
"msg",
"[",
"'action'",
"]",
"==",
"'noop'",
"@mutex",
".",
"synchronize",
"do",
"@seen",
"<<",
"msg",
"@log",
"<<",
"m... | The context will call this method for each msg sucessfully processed
by the worker. | [
"The",
"context",
"will",
"call",
"this",
"method",
"for",
"each",
"msg",
"sucessfully",
"processed",
"by",
"the",
"worker",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/log/wait_logger.rb#L96-L110 | train |
jmettraux/ruote | lib/ruote/log/wait_logger.rb | Ruote.WaitLogger.wait_for | 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 ... | ruby | 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 ... | [
"def",
"wait_for",
"(",
"interests",
",",
"opts",
"=",
"{",
"}",
")",
"@waiting",
"<<",
"[",
"Thread",
".",
"current",
",",
"interests",
"]",
"Thread",
".",
"current",
"[",
"'__result__'",
"]",
"=",
"nil",
"start",
"=",
"Time",
".",
"now",
"to",
"=",... | Blocks until one or more interests are satisfied.
interests must be an array of interests. Please refer to
Dashboard#wait_for documentation for allowed values of each interest.
If multiple interests are given, wait_for blocks until
all of the interests are satisfied.
wait_for may only be used by one thread at a... | [
"Blocks",
"until",
"one",
"or",
"more",
"interests",
"are",
"satisfied",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/log/wait_logger.rb#L140-L164 | train |
jmettraux/ruote | lib/ruote/log/wait_logger.rb | Ruote.WaitLogger.matches | 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
(FINA... | ruby | 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
(FINA... | [
"def",
"matches",
"(",
"interests",
",",
"msg",
")",
"action",
"=",
"msg",
"[",
"'action'",
"]",
"interests",
".",
"each",
"do",
"|",
"interest",
"|",
"satisfied",
"=",
"case",
"interest",
"when",
":or_error",
"interests",
".",
"clear",
"if",
"action",
"... | Checks whether message msg matches any of interests being waited for.
Some interests look for actions on particular workflows (e.g.,
waiting for some workflow to finish). Other interests are not
attached to any particular workflow (e.g., :inactive waits until
the engine finishes processing all active and pending w... | [
"Checks",
"whether",
"message",
"msg",
"matches",
"any",
"of",
"interests",
"being",
"waited",
"for",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/log/wait_logger.rb#L221-L282 | train |
jmettraux/ruote | lib/ruote/context.rb | Ruote.Context.has_service? | 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 | 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 | [
"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",
... | Returns true if this context has a given service registered. | [
"Returns",
"true",
"if",
"this",
"context",
"has",
"a",
"given",
"service",
"registered",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/context.rb#L216-L222 | train |
jmettraux/ruote | lib/ruote/exp/ro_persist.rb | Ruote::Exp.FlowExpression.do_p | 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 | 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 | [
"def",
"do_p",
"(",
"pers",
")",
"case",
"r",
"=",
"pers",
"?",
"try_persist",
":",
"try_unpersist",
"when",
"true",
"false",
"when",
"Hash",
"self",
".",
"h",
"=",
"r",
"self",
".",
"send",
"(",
"\"do_#{@msg['action']}\"",
",",
"@msg",
")",
"if",
"@ms... | Does persist or unpersist, if successful then returns true. If the
expression is gone, returns false.
If there is a 'fresher' version of the expression, re-attempt and returns
false. | [
"Does",
"persist",
"or",
"unpersist",
"if",
"successful",
"then",
"returns",
"true",
".",
"If",
"the",
"expression",
"is",
"gone",
"returns",
"false",
".",
"If",
"there",
"is",
"a",
"fresher",
"version",
"of",
"the",
"expression",
"re",
"-",
"attempt",
"an... | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/ro_persist.rb#L151-L163 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.on_workitem | 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... | ruby | 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... | [
"def",
"on_workitem",
"doc",
"=",
"workitem",
".",
"to_h",
"doc",
".",
"merge!",
"(",
"'type'",
"=>",
"'workitems'",
",",
"'_id'",
"=>",
"to_id",
"(",
"doc",
"[",
"'fei'",
"]",
")",
",",
"'participant_name'",
"=>",
"doc",
"[",
"'participant_name'",
"]",
... | This is the method called by ruote when passing a workitem to
this participant. | [
"This",
"is",
"the",
"method",
"called",
"by",
"ruote",
"when",
"passing",
"a",
"workitem",
"to",
"this",
"participant",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L80-L93 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.proceed | def proceed(workitem)
r = remove_workitem('proceed', workitem)
return proceed(workitem) if r != nil
workitem.h.delete('_rev')
reply_to_engine(workitem)
end | ruby | def proceed(workitem)
r = remove_workitem('proceed', workitem)
return proceed(workitem) if r != nil
workitem.h.delete('_rev')
reply_to_engine(workitem)
end | [
"def",
"proceed",
"(",
"workitem",
")",
"r",
"=",
"remove_workitem",
"(",
"'proceed'",
",",
"workitem",
")",
"return",
"proceed",
"(",
"workitem",
")",
"if",
"r",
"!=",
"nil",
"workitem",
".",
"h",
".",
"delete",
"(",
"'_rev'",
")",
"reply_to_engine",
"(... | Removes the workitem from the storage and replies to the engine. | [
"Removes",
"the",
"workitem",
"from",
"the",
"storage",
"and",
"replies",
"to",
"the",
"engine",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L155-L164 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.flunk | 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 | 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 | [
"def",
"flunk",
"(",
"workitem",
",",
"err_class_or_instance",
",",
"*",
"err_arguments",
")",
"r",
"=",
"remove_workitem",
"(",
"'reject'",
",",
"workitem",
")",
"return",
"flunk",
"(",
"workitem",
")",
"if",
"r",
"!=",
"nil",
"workitem",
".",
"h",
".",
... | Removes the workitem and hands it back to the flow with an error to
raise for the participant expression that emitted the workitem. | [
"Removes",
"the",
"workitem",
"and",
"hands",
"it",
"back",
"to",
"the",
"flow",
"with",
"an",
"error",
"to",
"raise",
"for",
"the",
"participant",
"expression",
"that",
"emitted",
"the",
"workitem",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L169-L178 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.all | def all(opts={})
res = fetch_all(opts)
res.is_a?(Array) ? res.map { |hwi| Ruote::Workitem.new(hwi) } : res
end | ruby | def all(opts={})
res = fetch_all(opts)
res.is_a?(Array) ? res.map { |hwi| Ruote::Workitem.new(hwi) } : res
end | [
"def",
"all",
"(",
"opts",
"=",
"{",
"}",
")",
"res",
"=",
"fetch_all",
"(",
"opts",
")",
"res",
".",
"is_a?",
"(",
"Array",
")",
"?",
"res",
".",
"map",
"{",
"|",
"hwi",
"|",
"Ruote",
"::",
"Workitem",
".",
"new",
"(",
"hwi",
")",
"}",
":",
... | Returns all the workitems stored in here. | [
"Returns",
"all",
"the",
"workitems",
"stored",
"in",
"here",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L209-L214 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.by_wfid | 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 | 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 | [
"def",
"by_wfid",
"(",
"wfid",
",",
"opts",
"=",
"{",
"}",
")",
"if",
"@context",
".",
"storage",
".",
"respond_to?",
"(",
":by_wfid",
")",
"return",
"@context",
".",
"storage",
".",
"by_wfid",
"(",
"'workitems'",
",",
"wfid",
",",
"opts",
")",
"end",
... | Return all workitems for the specified wfid | [
"Return",
"all",
"workitems",
"for",
"the",
"specified",
"wfid"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L226-L233 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.by_participant | 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 | 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 | [
"def",
"by_participant",
"(",
"participant_name",
",",
"opts",
"=",
"{",
"}",
")",
"return",
"@context",
".",
"storage",
".",
"by_participant",
"(",
"'workitems'",
",",
"participant_name",
",",
"opts",
")",
"if",
"@context",
".",
"storage",
".",
"respond_to?",... | Returns all workitems for the specified participant name | [
"Returns",
"all",
"workitems",
"for",
"the",
"specified",
"participant",
"name"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L237-L246 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.query | 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.d... | ruby | 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.d... | [
"def",
"query",
"(",
"criteria",
")",
"cr",
"=",
"Ruote",
".",
"keys_to_s",
"(",
"criteria",
")",
"if",
"@context",
".",
"storage",
".",
"respond_to?",
"(",
":query_workitems",
")",
"return",
"@context",
".",
"storage",
".",
"query_workitems",
"(",
"cr",
"... | Queries the store participant for workitems.
Some examples :
part.query(:wfid => @wfid).size
part.query('place' => 'nara').size
part.query('place' => 'heiankyou').size
part.query(:wfid => @wfid, :place => 'heiankyou').size
There are two 'reserved' criterion : 'wfid' and 'participant'
('participant_nam... | [
"Queries",
"the",
"store",
"participant",
"for",
"workitems",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L290-L320 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.per_participant_count | def per_participant_count
per_participant.remap { |(k, v), h| h[k] = v.size }
end | ruby | def per_participant_count
per_participant.remap { |(k, v), h| h[k] = v.size }
end | [
"def",
"per_participant_count",
"per_participant",
".",
"remap",
"{",
"|",
"(",
"k",
",",
"v",
")",
",",
"h",
"|",
"h",
"[",
"k",
"]",
"=",
"v",
".",
"size",
"}",
"end"
] | Mostly a test method. Returns a Hash were keys are participant names
and values are integers, the count of workitems for a given participant
name. | [
"Mostly",
"a",
"test",
"method",
".",
"Returns",
"a",
"Hash",
"were",
"keys",
"are",
"participant",
"names",
"and",
"values",
"are",
"integers",
"the",
"count",
"of",
"workitems",
"for",
"a",
"given",
"participant",
"name",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L356-L359 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.delegate | 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 deleg... | ruby | 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 deleg... | [
"def",
"delegate",
"(",
"workitem",
",",
"new_owner",
")",
"hwi",
"=",
"fetch",
"(",
"workitem",
")",
"fail",
"ArgumentError",
".",
"new",
"(",
"\"workitem not found\"",
")",
"if",
"hwi",
"==",
"nil",
"fail",
"ArgumentError",
".",
"new",
"(",
"\"cannot deleg... | Delegates a currently owned workitem to a new owner.
Fails if the workitem can't be found, belongs to noone, or if the
workitem passed as argument is out of date (got modified in the mean
time).
It's OK to delegate to nil, thus freeing the workitem.
See #reserve for an an explanation of the reserve/delegate/pro... | [
"Delegates",
"a",
"currently",
"owned",
"workitem",
"to",
"a",
"new",
"owner",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L405-L430 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.do_select | 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|... | ruby | 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|... | [
"def",
"do_select",
"(",
"opts",
",",
"&",
"block",
")",
"skip",
"=",
"opts",
"[",
":offset",
"]",
"||",
"opts",
"[",
":skip",
"]",
"limit",
"=",
"opts",
"[",
":limit",
"]",
"count",
"=",
"opts",
"[",
":count",
"]",
"hwis",
"=",
"fetch_all",
"(",
... | Given a few options and a block, returns all the workitems that match
the block | [
"Given",
"a",
"few",
"options",
"and",
"a",
"block",
"returns",
"all",
"the",
"workitems",
"that",
"match",
"the",
"block"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L457-L472 | train |
jmettraux/ruote | lib/ruote/part/storage_participant.rb | Ruote.StorageParticipant.to_id | def to_id(fei)
a = [ Ruote.to_storage_id(fei) ]
a.unshift(@store_name) if @store_name
a.unshift('wi')
a.join('!')
end | ruby | def to_id(fei)
a = [ Ruote.to_storage_id(fei) ]
a.unshift(@store_name) if @store_name
a.unshift('wi')
a.join('!')
end | [
"def",
"to_id",
"(",
"fei",
")",
"a",
"=",
"[",
"Ruote",
".",
"to_storage_id",
"(",
"fei",
")",
"]",
"a",
".",
"unshift",
"(",
"@store_name",
")",
"if",
"@store_name",
"a",
".",
"unshift",
"(",
"'wi'",
")",
"a",
".",
"join",
"(",
"'!'",
")",
"end... | Computes the id for the document representing the document in the storage. | [
"Computes",
"the",
"id",
"for",
"the",
"document",
"representing",
"the",
"document",
"in",
"the",
"storage",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/storage_participant.rb#L476-L485 | train |
jmettraux/ruote | lib/ruote/exp/fe_command.rb | Ruote::Exp.CommandExpression.fetch_command_target | 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 | 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 | [
"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"... | Walks up the expression tree (process instance and returns the first
expression that includes the CommandMixin
(CommandExpression includes CommandMixin, but since it doesn't have
children, no need to 'evince' it) | [
"Walks",
"up",
"the",
"expression",
"tree",
"(",
"process",
"instance",
"and",
"returns",
"the",
"first",
"expression",
"that",
"includes",
"the",
"CommandMixin"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/fe_command.rb#L149-L156 | train |
jmettraux/ruote | lib/ruote/part/rev_participant.rb | Ruote.RevParticipant.lookup_code | 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 ],
... | ruby | 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 ],
... | [
"def",
"lookup_code",
"wi",
"=",
"workitem",
"rev",
"=",
"wi",
".",
"params",
"[",
"'revision'",
"]",
"||",
"wi",
".",
"params",
"[",
"'rev'",
"]",
"[",
"[",
"wi",
".",
"wf_name",
",",
"wi",
".",
"wf_revision",
",",
"wi",
".",
"participant_name",
","... | Maybe "lookup_real_participant_code" would be a better name... | [
"Maybe",
"lookup_real_participant_code",
"would",
"be",
"a",
"better",
"name",
"..."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/part/rev_participant.rb#L143-L175 | train |
jmettraux/ruote | lib/ruote/exp/fe_if.rb | Ruote::Exp.IfExpression.reply | 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_... | ruby | 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_... | [
"def",
"reply",
"(",
"workitem",
")",
"if",
"workitem",
"[",
"'fei'",
"]",
"==",
"h",
".",
"fei",
"h",
".",
"test",
"=",
"attribute",
"(",
":test",
")",
"h",
".",
"test",
"=",
"attribute",
"(",
":t",
")",
"if",
"h",
".",
"test",
".",
"nil?",
"h... | called by 'else', 'then' or perhaps 'equals' | [
"called",
"by",
"else",
"then",
"or",
"perhaps",
"equals"
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/exp/fe_if.rb#L169-L193 | train |
jmettraux/ruote | lib/ruote/svc/participant_list.rb | Ruote.ParticipantList.unregister | 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[... | ruby | 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[... | [
"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",
"... | Removes a participant, given via its name or directly from this
participant list.
Called usually by Engine#unregister_participant. | [
"Removes",
"a",
"participant",
"given",
"via",
"its",
"name",
"or",
"directly",
"from",
"this",
"participant",
"list",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/participant_list.rb#L140-L164 | train |
jmettraux/ruote | lib/ruote/svc/participant_list.rb | Ruote.ParticipantList.lookup | def lookup(participant_name, workitem, opts={})
pinfo = participant_name.is_a?(String) ?
lookup_info(participant_name, workitem) : participant_name
instantiate(pinfo, opts)
end | ruby | def lookup(participant_name, workitem, opts={})
pinfo = participant_name.is_a?(String) ?
lookup_info(participant_name, workitem) : participant_name
instantiate(pinfo, opts)
end | [
"def",
"lookup",
"(",
"participant_name",
",",
"workitem",
",",
"opts",
"=",
"{",
"}",
")",
"pinfo",
"=",
"participant_name",
".",
"is_a?",
"(",
"String",
")",
"?",
"lookup_info",
"(",
"participant_name",
",",
"workitem",
")",
":",
"participant_name",
"insta... | Returns a participant instance, or nil if there is no participant
for the given participant name.
Mostly a combination of #lookup_info and #instantiate. | [
"Returns",
"a",
"participant",
"instance",
"or",
"nil",
"if",
"there",
"is",
"no",
"participant",
"for",
"the",
"given",
"participant",
"name",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/participant_list.rb#L171-L177 | train |
jmettraux/ruote | lib/ruote/svc/participant_list.rb | Ruote.ParticipantList.lookup_info | 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 = instan... | ruby | 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 = instan... | [
"def",
"lookup_info",
"(",
"pname",
",",
"workitem",
")",
"return",
"nil",
"unless",
"pname",
"wi",
"=",
"workitem",
"?",
"Ruote",
"::",
"Workitem",
".",
"new",
"(",
"workitem",
".",
"merge",
"(",
"'participant_name'",
"=>",
"pname",
")",
")",
":",
"nil"... | Given a participant name, returns participant details.
Returns nil if there is no participant registered that covers the given
participant name. | [
"Given",
"a",
"participant",
"name",
"returns",
"participant",
"details",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/participant_list.rb#L184-L207 | train |
jmettraux/ruote | lib/ruote/svc/participant_list.rb | Ruote.ParticipantList.instantiate | 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_method... | ruby | 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_method... | [
"def",
"instantiate",
"(",
"pinfo",
",",
"opts",
"=",
"{",
"}",
")",
"return",
"nil",
"unless",
"pinfo",
"pa_class_name",
",",
"options",
"=",
"pinfo",
"if",
"rp",
"=",
"options",
"[",
"'require_path'",
"]",
"require",
"(",
"rp",
")",
"end",
"if",
"lp"... | Returns an instance of a participant. | [
"Returns",
"an",
"instance",
"of",
"a",
"participant",
"."
] | 30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c | https://github.com/jmettraux/ruote/blob/30a6bb88a4e48ed2e1b9089754f1c8be8c1a879c/lib/ruote/svc/participant_list.rb#L211-L234 | train |
icoretech/spotify-client | lib/spotify_client.rb | Spotify.Client.create_user_playlist | 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 | 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 | [
"def",
"create_user_playlist",
"(",
"user_id",
",",
"name",
",",
"is_public",
"=",
"true",
")",
"run",
"(",
":post",
",",
"\"/v1/users/#{user_id}/playlists\"",
",",
"[",
"201",
"]",
",",
"JSON",
".",
"dump",
"(",
"name",
":",
"name",
",",
"public",
":",
... | Create a playlist for a Spotify user. The playlist will be empty until you add tracks.
Requires playlist-modify-public for a public playlist.
Requires playlist-modify-private for a private playlist. | [
"Create",
"a",
"playlist",
"for",
"a",
"Spotify",
"user",
".",
"The",
"playlist",
"will",
"be",
"empty",
"until",
"you",
"add",
"tracks",
"."
] | 2368530f0f509a5123c44d40f79a8ea11ce61394 | https://github.com/icoretech/spotify-client/blob/2368530f0f509a5123c44d40f79a8ea11ce61394/lib/spotify_client.rb#L91-L93 | train |
icoretech/spotify-client | lib/spotify_client.rb | Spotify.Client.add_user_tracks_to_playlist | 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)
... | ruby | 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)
... | [
"def",
"add_user_tracks_to_playlist",
"(",
"user_id",
",",
"playlist_id",
",",
"uris",
"=",
"[",
"]",
",",
"position",
"=",
"nil",
")",
"params",
"=",
"{",
"uris",
":",
"Array",
".",
"wrap",
"(",
"uris",
")",
"[",
"0",
"..",
"99",
"]",
".",
"join",
... | Add an Array of track uris to an existing playlist.
Adding tracks to a user's public playlist requires authorization of the playlist-modify-public scope;
adding tracks to a private playlist requires the playlist-modify-private scope.
client.add_user_tracks_to_playlist('1181346016', '7i3thJWDtmX04dJhFwYb0x', %w(spo... | [
"Add",
"an",
"Array",
"of",
"track",
"uris",
"to",
"an",
"existing",
"playlist",
"."
] | 2368530f0f509a5123c44d40f79a8ea11ce61394 | https://github.com/icoretech/spotify-client/blob/2368530f0f509a5123c44d40f79a8ea11ce61394/lib/spotify_client.rb#L101-L107 | train |
icoretech/spotify-client | lib/spotify_client.rb | Spotify.Client.follow | def follow(type, ids)
params = { type: type, ids: Array.wrap(ids).join(',') }
run(:put, "/v1/me/following", [204], params)
end | ruby | def follow(type, ids)
params = { type: type, ids: Array.wrap(ids).join(',') }
run(:put, "/v1/me/following", [204], params)
end | [
"def",
"follow",
"(",
"type",
",",
"ids",
")",
"params",
"=",
"{",
"type",
":",
"type",
",",
"ids",
":",
"Array",
".",
"wrap",
"(",
"ids",
")",
".",
"join",
"(",
"','",
")",
"}",
"run",
"(",
":put",
",",
"\"/v1/me/following\"",
",",
"[",
"204",
... | Follow artists or users
client.follow('artist', ['0BvkDsjIUla7X0k6CSWh1I']) | [
"Follow",
"artists",
"or",
"users"
] | 2368530f0f509a5123c44d40f79a8ea11ce61394 | https://github.com/icoretech/spotify-client/blob/2368530f0f509a5123c44d40f79a8ea11ce61394/lib/spotify_client.rb#L186-L189 | train |
matiaskorhonen/monit | lib/monit/status.rb | Monit.Status.url | 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 | 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 | [
"def",
"url",
"url_params",
"=",
"{",
":host",
"=>",
"@host",
",",
":port",
"=>",
"@port",
",",
":path",
"=>",
"\"/_status\"",
",",
":query",
"=>",
"\"format=xml\"",
"}",
"@ssl",
"?",
"URI",
"::",
"HTTPS",
".",
"build",
"(",
"url_params",
")",
":",
"UR... | Create a new instance of the status class with the given options
<b>Options:</b>
* +host+ - the host for monit, defaults to +localhost+
* +port+ - the Monit port, defaults to +2812+
* +ssl+ - should we use SSL for the connection to Monit (default: false)
* +auth+ - should authentication be used, defaults to false... | [
"Create",
"a",
"new",
"instance",
"of",
"the",
"status",
"class",
"with",
"the",
"given",
"options"
] | ace938155259e269e4ba492bec6e24502d33a8cf | https://github.com/matiaskorhonen/monit/blob/ace938155259e269e4ba492bec6e24502d33a8cf/lib/monit/status.rb#L40-L43 | train |
matiaskorhonen/monit | lib/monit/status.rb | Monit.Status.get | 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
req... | ruby | 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
req... | [
"def",
"get",
"uri",
"=",
"self",
".",
"url",
"http",
"=",
"Net",
"::",
"HTTP",
".",
"new",
"(",
"uri",
".",
"host",
",",
"uri",
".",
"port",
")",
"if",
"@ssl",
"http",
".",
"use_ssl",
"=",
"true",
"http",
".",
"verify_mode",
"=",
"OpenSSL",
"::"... | Get the status from Monit. | [
"Get",
"the",
"status",
"from",
"Monit",
"."
] | ace938155259e269e4ba492bec6e24502d33a8cf | https://github.com/matiaskorhonen/monit/blob/ace938155259e269e4ba492bec6e24502d33a8cf/lib/monit/status.rb#L46-L75 | train |
matiaskorhonen/monit | lib/monit/status.rb | Monit.Status.parse | 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 => @us... | ruby | 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 => @us... | [
"def",
"parse",
"(",
"xml",
")",
"@hash",
"=",
"Hash",
".",
"from_xml",
"(",
"xml",
")",
"@server",
"=",
"Server",
".",
"new",
"(",
"@hash",
"[",
"\"monit\"",
"]",
"[",
"\"server\"",
"]",
")",
"@platform",
"=",
"Platform",
".",
"new",
"(",
"@hash",
... | Parse the XML from Monit into a hash and into a Ruby representation. | [
"Parse",
"the",
"XML",
"from",
"Monit",
"into",
"a",
"hash",
"and",
"into",
"a",
"Ruby",
"representation",
"."
] | ace938155259e269e4ba492bec6e24502d33a8cf | https://github.com/matiaskorhonen/monit/blob/ace938155259e269e4ba492bec6e24502d33a8cf/lib/monit/status.rb#L78-L102 | train |
berkshelf/solve | lib/solve/graph.rb | Solve.Graph.artifact | 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 | 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 | [
"def",
"artifact",
"(",
"name",
",",
"version",
")",
"unless",
"artifact?",
"(",
"name",
",",
"version",
")",
"artifact",
"=",
"Artifact",
".",
"new",
"(",
"self",
",",
"name",
",",
"version",
")",
"@artifacts",
"[",
"\"#{name}-#{version}\"",
"]",
"=",
"... | Add an artifact to the graph
@param [String] name
@Param [String] version | [
"Add",
"an",
"artifact",
"to",
"the",
"graph"
] | a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2 | https://github.com/berkshelf/solve/blob/a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2/lib/solve/graph.rb#L28-L36 | train |
berkshelf/solve | lib/solve/graph.rb | Solve.Graph.versions | 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... | ruby | 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... | [
"def",
"versions",
"(",
"name",
",",
"constraint",
"=",
"Semverse",
"::",
"DEFAULT_CONSTRAINT",
")",
"constraint",
"=",
"Semverse",
"::",
"Constraint",
".",
"coerce",
"(",
"constraint",
")",
"if",
"constraint",
"==",
"Semverse",
"::",
"DEFAULT_CONSTRAINT",
"@art... | Return all the artifacts from the collection of artifacts
with the given name.
@param [String] name
@return [Array<Solve::Artifact>] | [
"Return",
"all",
"the",
"artifacts",
"from",
"the",
"collection",
"of",
"artifacts",
"with",
"the",
"given",
"name",
"."
] | a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2 | https://github.com/berkshelf/solve/blob/a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2/lib/solve/graph.rb#L51-L61 | train |
berkshelf/solve | lib/solve/constraint.rb | Solve.Constraint.satisfies? | def satisfies?(target)
target = Semverse::Version.coerce(target)
return false if !(version == 0) && greedy_match?(target)
compare(target)
end | ruby | def satisfies?(target)
target = Semverse::Version.coerce(target)
return false if !(version == 0) && greedy_match?(target)
compare(target)
end | [
"def",
"satisfies?",
"(",
"target",
")",
"target",
"=",
"Semverse",
"::",
"Version",
".",
"coerce",
"(",
"target",
")",
"return",
"false",
"if",
"!",
"(",
"version",
"==",
"0",
")",
"&&",
"greedy_match?",
"(",
"target",
")",
"compare",
"(",
"target",
"... | Returns true or false if the given version would be satisfied by
the version constraint.
@param [Semverse::Version, #to_s] target
@return [Boolean] | [
"Returns",
"true",
"or",
"false",
"if",
"the",
"given",
"version",
"would",
"be",
"satisfied",
"by",
"the",
"version",
"constraint",
"."
] | a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2 | https://github.com/berkshelf/solve/blob/a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2/lib/solve/constraint.rb#L201-L207 | train |
berkshelf/solve | lib/solve/gecode_solver.rb | Solve.GecodeSolver.solve_demands | 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::... | ruby | 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::... | [
"def",
"solve_demands",
"(",
"demands_as_constraints",
")",
"selector",
"=",
"DepSelector",
"::",
"Selector",
".",
"new",
"(",
"ds_graph",
",",
"(",
"timeout_ms",
"/",
"1000.0",
")",
")",
"selector",
".",
"find_solution",
"(",
"demands_as_constraints",
",",
"all... | Runs the solver with the set of demands given. If any DepSelector
exceptions are raised, they are rescued and re-raised | [
"Runs",
"the",
"solver",
"with",
"the",
"set",
"of",
"demands",
"given",
".",
"If",
"any",
"DepSelector",
"exceptions",
"are",
"raised",
"they",
"are",
"rescued",
"and",
"re",
"-",
"raised"
] | a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2 | https://github.com/berkshelf/solve/blob/a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2/lib/solve/gecode_solver.rb#L94-L111 | train |
berkshelf/solve | lib/solve/ruby_solver.rb | Solve.RubySolver.requirement_satisfied_by? | 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_... | ruby | 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_... | [
"def",
"requirement_satisfied_by?",
"(",
"requirement",
",",
"activated",
",",
"spec",
")",
"version",
"=",
"spec",
".",
"version",
"return",
"false",
"unless",
"requirement",
".",
"constraint",
".",
"satisfies?",
"(",
"version",
")",
"shared_possibility_versions",
... | Callback required by Molinillo
Determines whether the given `requirement` is satisfied by the given
`spec`, in the context of the current `activated` dependency graph.
@param [Object] requirement
@param [DependencyGraph] activated the current dependency graph in the
resolution process.
@param [Object] spec
@r... | [
"Callback",
"required",
"by",
"Molinillo",
"Determines",
"whether",
"the",
"given",
"requirement",
"is",
"satisfied",
"by",
"the",
"given",
"spec",
"in",
"the",
"context",
"of",
"the",
"current",
"activated",
"dependency",
"graph",
"."
] | a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2 | https://github.com/berkshelf/solve/blob/a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2/lib/solve/ruby_solver.rb#L171-L177 | train |
berkshelf/solve | lib/solve/ruby_solver.rb | Solve.RubySolver.possibility_versions | 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
... | ruby | 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
... | [
"def",
"possibility_versions",
"(",
"requirement",
",",
"activated",
")",
"activated",
".",
"vertices",
".",
"values",
".",
"flat_map",
"do",
"|",
"vertex",
"|",
"next",
"unless",
"vertex",
".",
"payload",
"next",
"unless",
"vertex",
".",
"name",
"==",
"requ... | Searches the current dependency graph to find previously activated
requirements for the current artifact.
@param [Object] requirement
@param [DependencyGraph] activated the current dependency graph in the
resolution process.
@return [Array<Semverse::Version> the list of currently activated versions
of this req... | [
"Searches",
"the",
"current",
"dependency",
"graph",
"to",
"find",
"previously",
"activated",
"requirements",
"for",
"the",
"current",
"artifact",
"."
] | a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2 | https://github.com/berkshelf/solve/blob/a0e03ede13e2f66b8dd6d0d34c9c9db70fba94d2/lib/solve/ruby_solver.rb#L187-L200 | train |
jwhitehorn/pi_piper | lib/pi_piper/spi.rb | PiPiper.Spi.clock | 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
2500... | ruby | 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
2500... | [
"def",
"clock",
"(",
"frequency",
")",
"options",
"=",
"{",
"4000",
"=>",
"0",
",",
"8000",
"=>",
"32768",
",",
"15625",
"=>",
"16384",
",",
"31250",
"=>",
"8192",
",",
"62500",
"=>",
"4096",
",",
"125000",
"=>",
"2048",
",",
"250000",
"=>",
"1024"... | Sets the SPI clock frequency | [
"Sets",
"the",
"SPI",
"clock",
"frequency"
] | bf17c88c8d27f87baf04868482b8082b6a8390ea | https://github.com/jwhitehorn/pi_piper/blob/bf17c88c8d27f87baf04868482b8082b6a8390ea/lib/pi_piper/spi.rb#L64-L81 | train |
jwhitehorn/pi_piper | lib/pi_piper/spi.rb | PiPiper.Spi.chip_select | 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 | 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 | [
"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_... | Activate a specific chip so that communication can begin
When a block is provided, the chip is automatically deactivated after the block completes.
When a block is not provided, the user is responsible for calling chip_select(CHIP_SELECT_NONE)
@example With block (preferred)
spi.chip_select do
spi.write(0x... | [
"Activate",
"a",
"specific",
"chip",
"so",
"that",
"communication",
"can",
"begin"
] | bf17c88c8d27f87baf04868482b8082b6a8390ea | https://github.com/jwhitehorn/pi_piper/blob/bf17c88c8d27f87baf04868482b8082b6a8390ea/lib/pi_piper/spi.rb#L113-L123 | train |
jwhitehorn/pi_piper | lib/pi_piper/spi.rb | PiPiper.Spi.chip_select_active_low | 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 | 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 | [
"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",
"?... | Configure the active state of the chip select line
The default state for most chips is active low.
"active low" means the clock line is kept high during idle, and goes low when communicating.
"active high" means the clock line is kept low during idle, and goes high when communicating.
@param [Boolean] active_lo... | [
"Configure",
"the",
"active",
"state",
"of",
"the",
"chip",
"select",
"line"
] | bf17c88c8d27f87baf04868482b8082b6a8390ea | https://github.com/jwhitehorn/pi_piper/blob/bf17c88c8d27f87baf04868482b8082b6a8390ea/lib/pi_piper/spi.rb#L135-L140 | train |
jwhitehorn/pi_piper | lib/pi_piper/spi.rb | PiPiper.Spi.write | 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
... | ruby | 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
... | [
"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",
... | Write to the bus
@example Write a single byte
spi.write(0x22)
@example Write multiple bytes
spi.write(0x22, 0x33, 0x44)
@return [Number|Array] data that came out of MISO during write | [
"Write",
"to",
"the",
"bus"
] | bf17c88c8d27f87baf04868482b8082b6a8390ea | https://github.com/jwhitehorn/pi_piper/blob/bf17c88c8d27f87baf04868482b8082b6a8390ea/lib/pi_piper/spi.rb#L172-L192 | train |
infinitered/rmq | motion/ruby_motion_query/subviews.rb | RubyMotionQuery.RMQ.add_subview | 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 = ... | ruby | 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 = ... | [
"def",
"add_subview",
"(",
"view_or_constant",
",",
"opts",
"=",
"{",
"}",
")",
"subviews_added",
"=",
"[",
"]",
"selected",
".",
"each",
"do",
"|",
"selected_view",
"|",
"created",
"=",
"false",
"appended",
"=",
"false",
"built",
"=",
"false",
"if",
"vi... | This is used by build, create, and append. You really shouldn't use it
directly. Although it's totally fine if you do
@return [RMQ] | [
"This",
"is",
"used",
"by",
"build",
"create",
"and",
"append",
".",
"You",
"really",
"shouldn",
"t",
"use",
"it",
"directly",
".",
"Although",
"it",
"s",
"totally",
"fine",
"if",
"you",
"do"
] | a8329e1574ce3275c9fe56b91127c8b5e4b7693e | https://github.com/infinitered/rmq/blob/a8329e1574ce3275c9fe56b91127c8b5e4b7693e/motion/ruby_motion_query/subviews.rb#L20-L73 | train |
infinitered/rmq | motion/ruby_motion_query/subviews.rb | RubyMotionQuery.RMQ.find_or_append | 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 | 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 | [
"def",
"find_or_append",
"(",
"view_or_constant",
",",
"style",
"=",
"nil",
",",
"opts",
"=",
"{",
"}",
",",
"&",
"block",
")",
"if",
"style",
"&&",
"(",
"q",
"=",
"self",
".",
"find",
"(",
"style",
")",
")",
"&&",
"q",
".",
"length",
">",
"0",
... | Same as append, but will look for a view with the same name and reapply styles
to it if it finds one. If it doesn't, it'll append as normal.
@example
@my_button = rmq.find_or_append(UIButton, :my_button)
@my_button = rmq.find_or_append(UIButton, :my_button) # Only one created | [
"Same",
"as",
"append",
"but",
"will",
"look",
"for",
"a",
"view",
"with",
"the",
"same",
"name",
"and",
"reapply",
"styles",
"to",
"it",
"if",
"it",
"finds",
"one",
".",
"If",
"it",
"doesn",
"t",
"it",
"ll",
"append",
"as",
"normal",
"."
] | a8329e1574ce3275c9fe56b91127c8b5e4b7693e | https://github.com/infinitered/rmq/blob/a8329e1574ce3275c9fe56b91127c8b5e4b7693e/motion/ruby_motion_query/subviews.rb#L120-L126 | train |
infinitered/rmq | motion/ruby_motion_query/subviews.rb | RubyMotionQuery.RMQ.find_or_append! | def find_or_append!(view_or_constant, style=nil, opts = {}, &block)
find_or_append(view_or_constant, style, opts, &block).get
end | ruby | def find_or_append!(view_or_constant, style=nil, opts = {}, &block)
find_or_append(view_or_constant, style, opts, &block).get
end | [
"def",
"find_or_append!",
"(",
"view_or_constant",
",",
"style",
"=",
"nil",
",",
"opts",
"=",
"{",
"}",
",",
"&",
"block",
")",
"find_or_append",
"(",
"view_or_constant",
",",
"style",
",",
"opts",
",",
"&",
"block",
")",
".",
"get",
"end"
] | Same as append!, but will look for a view with the same name and reapply styles
to it if it finds one. If it doesn't, it'll append! as normal.
@example
@my_button = rmq.find_or_append!(UIButton, :my_button)
@my_button = rmq.find_or_append!(UIButton, :my_button) # Only one created | [
"Same",
"as",
"append!",
"but",
"will",
"look",
"for",
"a",
"view",
"with",
"the",
"same",
"name",
"and",
"reapply",
"styles",
"to",
"it",
"if",
"it",
"finds",
"one",
".",
"If",
"it",
"doesn",
"t",
"it",
"ll",
"append!",
"as",
"normal",
"."
] | a8329e1574ce3275c9fe56b91127c8b5e4b7693e | https://github.com/infinitered/rmq/blob/a8329e1574ce3275c9fe56b91127c8b5e4b7693e/motion/ruby_motion_query/subviews.rb#L134-L136 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.