trailblazer-activity-dsl-linear 0.5.0 → 1.0.0.beta1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.github/workflows/ci.yml +1 -1
- data/CHANGES.md +52 -0
- data/Gemfile +3 -1
- data/README.md +9 -17
- data/lib/trailblazer/activity/dsl/linear/feature/merge.rb +36 -0
- data/lib/trailblazer/activity/dsl/linear/feature/patch.rb +40 -0
- data/lib/trailblazer/activity/dsl/linear/feature/variable_mapping/dsl.rb +281 -0
- data/lib/trailblazer/activity/dsl/linear/feature/variable_mapping/inherit.rb +38 -0
- data/lib/trailblazer/activity/dsl/linear/feature/variable_mapping.rb +298 -0
- data/lib/trailblazer/activity/dsl/linear/helper/path.rb +106 -0
- data/lib/trailblazer/activity/dsl/linear/helper.rb +54 -128
- data/lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb +92 -0
- data/lib/trailblazer/activity/dsl/linear/normalizer.rb +194 -77
- data/lib/trailblazer/activity/dsl/linear/sequence/builder.rb +47 -0
- data/lib/trailblazer/activity/dsl/linear/sequence/compiler.rb +72 -0
- data/lib/trailblazer/activity/dsl/linear/sequence/search.rb +58 -0
- data/lib/trailblazer/activity/dsl/linear/sequence.rb +34 -0
- data/lib/trailblazer/activity/dsl/linear/strategy.rb +116 -71
- data/lib/trailblazer/activity/dsl/linear/version.rb +1 -1
- data/lib/trailblazer/activity/dsl/linear.rb +21 -177
- data/lib/trailblazer/activity/fast_track.rb +42 -53
- data/lib/trailblazer/activity/path.rb +52 -127
- data/lib/trailblazer/activity/railway.rb +48 -68
- data/trailblazer-activity-dsl-linear.gemspec +3 -2
- metadata +41 -13
- data/lib/trailblazer/activity/dsl/linear/compiler.rb +0 -70
- data/lib/trailblazer/activity/dsl/linear/state.rb +0 -63
- data/lib/trailblazer/activity/dsl/linear/variable_mapping.rb +0 -240
@@ -1,48 +1,27 @@
|
|
1
1
|
module Trailblazer
|
2
2
|
class Activity
|
3
3
|
# {Strategy} that helps building simple linear activities.
|
4
|
-
class Path
|
4
|
+
class Path < DSL::Linear::Strategy
|
5
5
|
# Functions that help creating a path-specific sequence.
|
6
6
|
module DSL
|
7
7
|
Linear = Activity::DSL::Linear
|
8
8
|
|
9
9
|
module_function
|
10
10
|
|
11
|
-
def
|
12
|
-
|
13
|
-
|
11
|
+
def Normalizer
|
12
|
+
# Retrieve the base normalizer from {linear/normalizer.rb} and add processing steps.
|
13
|
+
dsl_normalizer = Linear::Normalizer.Normalizer()
|
14
14
|
|
15
|
-
|
16
|
-
|
17
|
-
|
18
|
-
"
|
19
|
-
|
20
|
-
|
21
|
-
|
22
|
-
|
23
|
-
|
24
|
-
|
25
|
-
end
|
26
|
-
|
27
|
-
def start_sequence(track_name:)
|
28
|
-
start_default = Activity::Start.new(semantic: :default)
|
29
|
-
start_event = Linear::Sequence.create_row(task: start_default, id: "Start.default", magnetic_to: nil, wirings: [Linear::Search::Forward(unary_outputs[:success], track_name)])
|
30
|
-
_sequence = Linear::Sequence[start_event]
|
31
|
-
end
|
32
|
-
|
33
|
-
# DISCUSS: still not sure this should sit here.
|
34
|
-
# Pseudo-DSL that prepends {steps} to {sequence}.
|
35
|
-
def prepend_to_path(sequence, steps, insertion_method=Linear::Insert.method(:Prepend), insert_id="End.success") # FIXME: where do we need you?
|
36
|
-
new_rows = steps.collect do |id, task|
|
37
|
-
Linear::Sequence.create_row(
|
38
|
-
task: task,
|
39
|
-
magnetic_to: :success,
|
40
|
-
wirings: [Linear::Search::Forward(unary_outputs[:success], :success)],
|
41
|
-
id: id,
|
42
|
-
)
|
43
|
-
end
|
44
|
-
|
45
|
-
insertion_method.(sequence, new_rows, insert_id)
|
15
|
+
Linear::Normalizer.prepend_to(
|
16
|
+
dsl_normalizer,
|
17
|
+
# "activity.wirings",
|
18
|
+
"activity.normalize_outputs_from_dsl",
|
19
|
+
{
|
20
|
+
"path.outputs" => Linear::Normalizer.Task(method(:merge_path_outputs)),
|
21
|
+
"path.connections" => Linear::Normalizer.Task(method(:merge_path_connections)),
|
22
|
+
"path.magnetic_to" => Linear::Normalizer.Task(method(:normalize_magnetic_to)),
|
23
|
+
}
|
24
|
+
)
|
46
25
|
end
|
47
26
|
|
48
27
|
def unary_outputs
|
@@ -50,7 +29,7 @@ module Trailblazer
|
|
50
29
|
end
|
51
30
|
|
52
31
|
def unary_connections(track_name: :success)
|
53
|
-
{success: [Linear::Search.method(:Forward), track_name]}
|
32
|
+
{success: [Linear::Sequence::Search.method(:Forward), track_name]}
|
54
33
|
end
|
55
34
|
|
56
35
|
def merge_path_outputs(ctx, outputs: nil, **)
|
@@ -61,124 +40,70 @@ module Trailblazer
|
|
61
40
|
ctx[:connections] = connections || unary_connections(track_name: track_name)
|
62
41
|
end
|
63
42
|
|
64
|
-
#
|
65
|
-
|
66
|
-
def normalize_sequence_insert(ctx, end_id:, **)
|
67
|
-
insertion = ctx.keys & sequence_insert_options.keys
|
68
|
-
insertion = insertion[0] || :before
|
69
|
-
target = ctx[insertion] || end_id
|
70
|
-
|
71
|
-
insertion_method = sequence_insert_options[insertion]
|
72
|
-
|
73
|
-
ctx[:sequence_insert] = [Linear::Insert.method(insertion_method), target]
|
74
|
-
end
|
75
|
-
|
76
|
-
# @private
|
77
|
-
def sequence_insert_options
|
78
|
-
{
|
79
|
-
:before => :Prepend,
|
80
|
-
:after => :Append,
|
81
|
-
:replace => :Replace,
|
82
|
-
:delete => :Delete,
|
83
|
-
}
|
43
|
+
def normalize_magnetic_to(ctx, track_name:, **) # TODO: merge with Railway.merge_magnetic_to
|
44
|
+
ctx[:magnetic_to] = ctx.key?(:magnetic_to) ? ctx[:magnetic_to] : track_name # FIXME: can we be magnetic_to {nil}?
|
84
45
|
end
|
85
46
|
|
86
|
-
|
87
|
-
|
88
|
-
|
89
|
-
|
90
|
-
|
91
|
-
|
47
|
+
# This is slow and should be done only once at compile-time,
|
48
|
+
# DISCUSS: maybe make this a function?
|
49
|
+
# These are the normalizers for an {Activity}, to be injected into a State.
|
50
|
+
Normalizers = Linear::Normalizer::Normalizers.new(
|
51
|
+
step: Normalizer(), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
|
52
|
+
terminus: Linear::Normalizer::Terminus.Normalizer(),
|
53
|
+
)
|
92
54
|
|
93
|
-
|
94
|
-
raise "ID #{id} is already taken. Please specify an `:id`." if sequence.find { |row| row[3][:id] == id }
|
95
|
-
end
|
55
|
+
# pp Normalizers
|
96
56
|
|
97
|
-
|
98
|
-
return unless task.is_a?(Class)
|
57
|
+
# DISCUSS: following methods are not part of Normalizer
|
99
58
|
|
100
|
-
|
59
|
+
def append_terminus(sequence, task, normalizers:, **options)
|
60
|
+
_sequence = Linear::Sequence::Builder.update_sequence_for(:terminus, task, options, normalizers: normalizers, sequence: sequence, normalizer_options: {})
|
101
61
|
end
|
102
62
|
|
103
|
-
|
104
|
-
|
63
|
+
# @private
|
64
|
+
def start_sequence(track_name:)
|
65
|
+
Linear::Strategy::DSL.start_sequence(wirings: [Linear::Sequence::Search::Forward(unary_outputs[:success], track_name)])
|
105
66
|
end
|
106
67
|
|
107
68
|
# Returns an initial two-step sequence with {Start.default > End.success}.
|
108
69
|
def initial_sequence(track_name:, end_task:, end_id:)
|
109
|
-
# TODO: this could be an Activity itself but maybe a bit too much for now.
|
110
70
|
sequence = start_sequence(track_name: track_name)
|
111
|
-
sequence =
|
71
|
+
sequence = append_terminus(sequence, end_task, id: end_id, magnetic_to: track_name, normalizers: Normalizers, append_to: "Start.default")
|
112
72
|
end
|
113
73
|
|
114
|
-
def
|
115
|
-
|
116
|
-
|
117
|
-
|
118
|
-
def append_end_options(task:, magnetic_to:, id:, append_to: "End.success")
|
119
|
-
end_args = {sequence_insert: [Linear::Insert.method(:Append), append_to], stop_event: true}
|
74
|
+
def OptionsForSequenceBuilder(normalizers:, track_name: :success, end_task: Activity::End.new(semantic: :success), end_id: "End.success", **options)
|
75
|
+
# DISCUSS: instead of calling a separate {initial_sequence} method we could make DSL strategies
|
76
|
+
# use the actual DSL to build up the initial_sequence, somewhere outside? Maybe using {:adds}?
|
77
|
+
initial_sequence = initial_sequence(track_name: track_name, end_task: end_task, end_id: end_id)
|
120
78
|
|
121
79
|
{
|
122
|
-
|
123
|
-
|
124
|
-
id: id,
|
125
|
-
wirings: [
|
126
|
-
Linear::Search::Noop(
|
127
|
-
Activity::Output.new(task, task.to_h[:semantic]), # DISCUSS: do we really want to transport the semantic "in" the object?
|
128
|
-
# magnetic_to
|
129
|
-
)],
|
130
|
-
# outputs: {magnetic_to => },
|
131
|
-
# connections: {magnetic_to => [Linear::Search.method(:Noop)]},
|
132
|
-
**end_args
|
133
|
-
}
|
134
|
-
end
|
135
|
-
|
136
|
-
# This is slow and should be done only once at compile-time,
|
137
|
-
# DISCUSS: maybe make this a function?
|
138
|
-
# These are the normalizers for an {Activity}, to be injected into a State.
|
139
|
-
Normalizers = Linear::State::Normalizer.new(
|
140
|
-
step: Linear::Normalizer.activity_normalizer(Path::DSL.normalizer), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
|
141
|
-
)
|
142
|
-
|
143
|
-
# pp Normalizers
|
144
|
-
|
145
|
-
def self.OptionsForState(normalizers: Normalizers, track_name: :success, end_task: Activity::End.new(semantic: :success), end_id: "End.success", **options)
|
146
|
-
initial_sequence = Path::DSL.initial_sequence(track_name: track_name, end_task: end_task, end_id: end_id) # DISCUSS: the standard initial_seq could be cached.
|
147
|
-
|
148
|
-
{
|
149
|
-
normalizers: normalizers,
|
150
|
-
initial_sequence: initial_sequence,
|
151
|
-
|
80
|
+
sequence: initial_sequence,
|
81
|
+
normalizers: normalizers,
|
152
82
|
track_name: track_name,
|
153
83
|
end_id: end_id,
|
154
84
|
step_interface_builder: Activity::TaskBuilder.method(:Binary), # DISCUSS: this is currently the only option we want to pass on in Path() ?
|
155
|
-
adds: [],
|
85
|
+
adds: [], # DISCUSS: needed?
|
156
86
|
**options
|
157
87
|
}
|
158
88
|
end
|
159
|
-
|
160
|
-
# Implements the actual API ({#step} and friends).
|
161
|
-
# This can be used later to create faster DSLs where the activity is compiled only once, a la
|
162
|
-
# Path() do ... end
|
163
|
-
class State < Linear::State
|
164
|
-
def step(*args)
|
165
|
-
_seq = Linear::Strategy.task_for!(self, :step, *args) # mutate @state
|
166
|
-
end
|
167
|
-
end
|
168
|
-
|
169
89
|
end # DSL
|
170
90
|
|
171
|
-
|
172
|
-
extend DSL::Linear::Strategy
|
173
|
-
|
174
|
-
initialize!(Path::DSL::State.new(**DSL.OptionsForState()))
|
91
|
+
compile_strategy!(DSL, normalizers: DSL::Normalizers) # sets :normalizer, normalizer_options, sequence and activity
|
175
92
|
end # Path
|
176
93
|
|
177
|
-
def self.Path(**options)
|
178
|
-
|
179
|
-
initialize!(Path::DSL::State.new(**Path::DSL.OptionsForState(**options)))
|
180
|
-
end
|
94
|
+
def self.Path(**options, &block)
|
95
|
+
Activity::DSL::Linear::Strategy::DSL.Build(Path, **options, &block)
|
181
96
|
end
|
182
97
|
end
|
183
98
|
end
|
184
99
|
|
100
|
+
=begin
|
101
|
+
class Operation
|
102
|
+
def self.subclassed(track_name:) # FIXME: it should be run in SubOperation context.
|
103
|
+
# initialize code here
|
104
|
+
end
|
105
|
+
|
106
|
+
end
|
107
|
+
|
108
|
+
SubOperation = Class.new(Operation, track_name: :green)
|
109
|
+
=end
|
@@ -1,43 +1,50 @@
|
|
1
1
|
module Trailblazer
|
2
|
-
# Implementation module that can be passed to `Activity[]`.
|
3
2
|
class Activity
|
4
|
-
class Railway
|
3
|
+
class Railway < DSL::Linear::Strategy
|
4
|
+
|
5
5
|
module DSL
|
6
6
|
Linear = Activity::DSL::Linear
|
7
7
|
|
8
8
|
module_function
|
9
9
|
|
10
|
-
def
|
11
|
-
|
12
|
-
end
|
10
|
+
def Normalizer
|
11
|
+
path_normalizer = Path::DSL.Normalizer()
|
13
12
|
|
14
|
-
|
15
|
-
|
13
|
+
Linear::Normalizer.prepend_to(
|
14
|
+
path_normalizer,
|
15
|
+
"activity.wirings",
|
16
|
+
{
|
17
|
+
"railway.outputs" => Linear::Normalizer.Task(method(:normalize_path_outputs)),
|
18
|
+
"railway.connections" => Linear::Normalizer.Task(method(:normalize_path_connections)),
|
19
|
+
},
|
20
|
+
)
|
21
|
+
end
|
16
22
|
|
17
|
-
|
18
|
-
|
19
|
-
|
20
|
-
|
23
|
+
# Change some parts of the step-{Normalizer} pipeline.
|
24
|
+
# We're bound to using a very primitive Pipeline API, remember, we don't have
|
25
|
+
# a DSL at this point!
|
26
|
+
def NormalizerForFail
|
27
|
+
pipeline = Linear::Normalizer.prepend_to(
|
28
|
+
Normalizer(),
|
29
|
+
"activity.wirings",
|
21
30
|
{
|
22
31
|
"railway.magnetic_to.fail" => Linear::Normalizer.Task(Fail.method(:merge_magnetic_to)),
|
23
32
|
}
|
24
33
|
)
|
25
34
|
|
26
|
-
pipeline =
|
35
|
+
pipeline = Linear::Normalizer.replace(
|
27
36
|
pipeline,
|
28
37
|
"path.connections",
|
29
|
-
|
30
|
-
"railway.connections.fail.success_to_failure" => Linear::Normalizer.Task(Fail.method(:connect_success_to_failure)),
|
31
|
-
},
|
32
|
-
replace: 1 # replace {"path.connections"}
|
38
|
+
["railway.connections.fail.success_to_failure", Linear::Normalizer.Task(Fail.method(:connect_success_to_failure))],
|
33
39
|
)
|
34
40
|
end
|
35
41
|
|
36
|
-
def
|
37
|
-
|
38
|
-
|
39
|
-
"
|
40
|
-
|
42
|
+
def NormalizerForPass
|
43
|
+
Linear::Normalizer.prepend_to(
|
44
|
+
Normalizer(),
|
45
|
+
"activity.normalize_outputs_from_dsl",
|
46
|
+
# "path.connections",
|
47
|
+
{"railway.connections.pass.failure_to_success" => Linear::Normalizer.Task(Pass.method(:connect_failure_to_success))}.to_a
|
41
48
|
)
|
42
49
|
end
|
43
50
|
|
@@ -49,7 +56,7 @@ module Trailblazer
|
|
49
56
|
end
|
50
57
|
|
51
58
|
def connect_success_to_failure(ctx, connections: nil, **)
|
52
|
-
ctx[:connections] = connections || {success: [Linear::Search.method(:Forward), :failure]}
|
59
|
+
ctx[:connections] = connections || {success: [Linear::Sequence::Search.method(:Forward), :failure]}
|
53
60
|
end
|
54
61
|
end
|
55
62
|
|
@@ -57,22 +64,10 @@ module Trailblazer
|
|
57
64
|
module_function
|
58
65
|
|
59
66
|
def connect_failure_to_success(ctx, connections:, **)
|
60
|
-
ctx[:connections] = connections.merge({failure: [Linear::Search.method(:Forward), :success]})
|
67
|
+
ctx[:connections] = connections.merge({failure: [Linear::Sequence::Search.method(:Forward), :success]})
|
61
68
|
end
|
62
69
|
end
|
63
70
|
|
64
|
-
# Add {Railway} steps to normalizer path.
|
65
|
-
def step_options(pipeline)
|
66
|
-
TaskWrap::Pipeline.prepend(
|
67
|
-
pipeline,
|
68
|
-
"path.wirings",
|
69
|
-
{
|
70
|
-
"railway.outputs" => Linear::Normalizer.Task(method(:normalize_path_outputs)),
|
71
|
-
"railway.connections" => Linear::Normalizer.Task(method(:normalize_path_connections)),
|
72
|
-
},
|
73
|
-
)
|
74
|
-
end
|
75
|
-
|
76
71
|
# Add {:failure} output to {:outputs}.
|
77
72
|
# TODO: assert that failure_outputs doesn't override existing {:outputs}
|
78
73
|
def normalize_path_outputs(ctx, outputs:, **)
|
@@ -88,65 +83,50 @@ module Trailblazer
|
|
88
83
|
def failure_outputs
|
89
84
|
{failure: Activity::Output(Activity::Left, :failure)}
|
90
85
|
end
|
86
|
+
|
91
87
|
def failure_connections
|
92
|
-
{failure: [Linear::Search.method(:Forward), :failure]}
|
88
|
+
{failure: [Linear::Sequence::Search.method(:Forward), :failure]}
|
93
89
|
end
|
94
90
|
|
95
|
-
def initial_sequence(failure_end:,
|
96
|
-
|
97
|
-
_seq = Path::DSL.append_end(initial_sequence, task: failure_end, magnetic_to: :failure, id: "End.failure")
|
91
|
+
def initial_sequence(failure_end:, sequence:, **path_options)
|
92
|
+
_seq = Path::DSL.append_terminus(sequence, failure_end, magnetic_to: :failure, id: "End.failure", normalizers: Normalizers)
|
98
93
|
end
|
99
94
|
|
100
|
-
|
101
|
-
|
102
|
-
|
103
|
-
|
104
|
-
|
105
|
-
def pass(*args)
|
106
|
-
_seq = Linear::Strategy.task_for!(self, :pass, *args) # mutate @state
|
107
|
-
end
|
108
|
-
end # Instance
|
109
|
-
|
110
|
-
Normalizers = Linear::State::Normalizer.new(
|
111
|
-
step: Linear::Normalizer.activity_normalizer( Railway::DSL.normalizer ), # here, we extend the generic FastTrack::step_normalizer with the Activity-specific DSL
|
112
|
-
fail: Linear::Normalizer.activity_normalizer( Railway::DSL.normalizer_for_fail ),
|
113
|
-
pass: Linear::Normalizer.activity_normalizer( Railway::DSL.normalizer_for_pass ),
|
95
|
+
Normalizers = Linear::Normalizer::Normalizers.new(
|
96
|
+
step: Railway::DSL.Normalizer(),
|
97
|
+
fail: Railway::DSL.NormalizerForFail(),
|
98
|
+
pass: Railway::DSL.NormalizerForPass(),
|
99
|
+
terminus: Linear::Normalizer::Terminus.Normalizer(),
|
114
100
|
)
|
115
101
|
|
116
|
-
def self.
|
117
|
-
options = Path::DSL.
|
118
|
-
merge(
|
102
|
+
def self.OptionsForSequenceBuilder(failure_end: Activity::End.new(semantic: :failure), **options)
|
103
|
+
options = Path::DSL.OptionsForSequenceBuilder(**options).
|
104
|
+
merge(failure_end: failure_end)
|
119
105
|
|
120
106
|
initial_sequence = Railway::DSL.initial_sequence(failure_end: failure_end, **options)
|
121
107
|
|
122
108
|
{
|
123
109
|
**options,
|
124
|
-
|
110
|
+
sequence: initial_sequence,
|
125
111
|
}
|
126
112
|
end
|
127
|
-
|
128
113
|
end # DSL
|
129
114
|
|
130
115
|
class << self
|
131
|
-
|
116
|
+
def fail(*args, &block)
|
132
117
|
recompile_activity_for(:fail, *args, &block)
|
133
118
|
end
|
134
119
|
|
135
|
-
|
120
|
+
def pass(*args, &block)
|
136
121
|
recompile_activity_for(:pass, *args, &block)
|
137
122
|
end
|
138
123
|
end
|
139
124
|
|
140
|
-
|
141
|
-
extend DSL::Linear::Strategy
|
142
|
-
|
143
|
-
initialize!(Railway::DSL::State.new(**DSL.OptionsForState()))
|
125
|
+
compile_strategy!(DSL, normalizers: DSL::Normalizers)
|
144
126
|
end # Railway
|
145
127
|
|
146
|
-
def self.Railway(options)
|
147
|
-
|
148
|
-
initialize!(Railway::DSL::State.new(**Railway::DSL.OptionsForState(**options)))
|
149
|
-
end
|
128
|
+
def self.Railway(**options, &block)
|
129
|
+
Activity::DSL::Linear::Strategy::DSL.Build(Railway, **options, &block)
|
150
130
|
end
|
151
131
|
end
|
152
132
|
end
|
@@ -19,12 +19,13 @@ Gem::Specification.new do |spec|
|
|
19
19
|
end
|
20
20
|
spec.require_paths = ["lib"]
|
21
21
|
|
22
|
-
spec.add_dependency "trailblazer-activity", ">= 0.
|
22
|
+
spec.add_dependency "trailblazer-activity", ">= 0.14.0.beta1", "< 0.15.0"
|
23
|
+
spec.add_dependency "trailblazer-declarative", ">= 0.0.1", "< 0.1.0"
|
23
24
|
|
24
25
|
spec.add_development_dependency "bundler"
|
25
26
|
spec.add_development_dependency "minitest", "~> 5.0"
|
26
27
|
spec.add_development_dependency "rake"
|
27
|
-
spec.add_development_dependency "trailblazer-developer", ">= 0.0.
|
28
|
+
spec.add_development_dependency "trailblazer-developer", ">= 0.0.24"
|
28
29
|
|
29
30
|
spec.required_ruby_version = '>= 2.1.0'
|
30
31
|
end
|
metadata
CHANGED
@@ -1,14 +1,14 @@
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
2
2
|
name: trailblazer-activity-dsl-linear
|
3
3
|
version: !ruby/object:Gem::Version
|
4
|
-
version: 0.
|
4
|
+
version: 1.0.0.beta1
|
5
5
|
platform: ruby
|
6
6
|
authors:
|
7
7
|
- Nick Sutterer
|
8
8
|
autorequire:
|
9
9
|
bindir: bin
|
10
10
|
cert_chain: []
|
11
|
-
date:
|
11
|
+
date: 2022-07-19 00:00:00.000000000 Z
|
12
12
|
dependencies:
|
13
13
|
- !ruby/object:Gem::Dependency
|
14
14
|
name: trailblazer-activity
|
@@ -16,20 +16,40 @@ dependencies:
|
|
16
16
|
requirements:
|
17
17
|
- - ">="
|
18
18
|
- !ruby/object:Gem::Version
|
19
|
-
version: 0.
|
19
|
+
version: 0.14.0.beta1
|
20
20
|
- - "<"
|
21
21
|
- !ruby/object:Gem::Version
|
22
|
-
version:
|
22
|
+
version: 0.15.0
|
23
23
|
type: :runtime
|
24
24
|
prerelease: false
|
25
25
|
version_requirements: !ruby/object:Gem::Requirement
|
26
26
|
requirements:
|
27
27
|
- - ">="
|
28
28
|
- !ruby/object:Gem::Version
|
29
|
-
version: 0.
|
29
|
+
version: 0.14.0.beta1
|
30
30
|
- - "<"
|
31
31
|
- !ruby/object:Gem::Version
|
32
|
-
version:
|
32
|
+
version: 0.15.0
|
33
|
+
- !ruby/object:Gem::Dependency
|
34
|
+
name: trailblazer-declarative
|
35
|
+
requirement: !ruby/object:Gem::Requirement
|
36
|
+
requirements:
|
37
|
+
- - ">="
|
38
|
+
- !ruby/object:Gem::Version
|
39
|
+
version: 0.0.1
|
40
|
+
- - "<"
|
41
|
+
- !ruby/object:Gem::Version
|
42
|
+
version: 0.1.0
|
43
|
+
type: :runtime
|
44
|
+
prerelease: false
|
45
|
+
version_requirements: !ruby/object:Gem::Requirement
|
46
|
+
requirements:
|
47
|
+
- - ">="
|
48
|
+
- !ruby/object:Gem::Version
|
49
|
+
version: 0.0.1
|
50
|
+
- - "<"
|
51
|
+
- !ruby/object:Gem::Version
|
52
|
+
version: 0.1.0
|
33
53
|
- !ruby/object:Gem::Dependency
|
34
54
|
name: bundler
|
35
55
|
requirement: !ruby/object:Gem::Requirement
|
@@ -78,14 +98,14 @@ dependencies:
|
|
78
98
|
requirements:
|
79
99
|
- - ">="
|
80
100
|
- !ruby/object:Gem::Version
|
81
|
-
version: 0.0.
|
101
|
+
version: 0.0.24
|
82
102
|
type: :development
|
83
103
|
prerelease: false
|
84
104
|
version_requirements: !ruby/object:Gem::Requirement
|
85
105
|
requirements:
|
86
106
|
- - ">="
|
87
107
|
- !ruby/object:Gem::Version
|
88
|
-
version: 0.0.
|
108
|
+
version: 0.0.24
|
89
109
|
description: Simple DSL to define Trailblazer activities with arbitrary wirings.
|
90
110
|
email:
|
91
111
|
- apotonick@gmail.com
|
@@ -103,12 +123,20 @@ files:
|
|
103
123
|
- Rakefile
|
104
124
|
- lib/trailblazer-activity-dsl-linear.rb
|
105
125
|
- lib/trailblazer/activity/dsl/linear.rb
|
106
|
-
- lib/trailblazer/activity/dsl/linear/
|
126
|
+
- lib/trailblazer/activity/dsl/linear/feature/merge.rb
|
127
|
+
- lib/trailblazer/activity/dsl/linear/feature/patch.rb
|
128
|
+
- lib/trailblazer/activity/dsl/linear/feature/variable_mapping.rb
|
129
|
+
- lib/trailblazer/activity/dsl/linear/feature/variable_mapping/dsl.rb
|
130
|
+
- lib/trailblazer/activity/dsl/linear/feature/variable_mapping/inherit.rb
|
107
131
|
- lib/trailblazer/activity/dsl/linear/helper.rb
|
132
|
+
- lib/trailblazer/activity/dsl/linear/helper/path.rb
|
108
133
|
- lib/trailblazer/activity/dsl/linear/normalizer.rb
|
109
|
-
- lib/trailblazer/activity/dsl/linear/
|
134
|
+
- lib/trailblazer/activity/dsl/linear/normalizer/terminus.rb
|
135
|
+
- lib/trailblazer/activity/dsl/linear/sequence.rb
|
136
|
+
- lib/trailblazer/activity/dsl/linear/sequence/builder.rb
|
137
|
+
- lib/trailblazer/activity/dsl/linear/sequence/compiler.rb
|
138
|
+
- lib/trailblazer/activity/dsl/linear/sequence/search.rb
|
110
139
|
- lib/trailblazer/activity/dsl/linear/strategy.rb
|
111
|
-
- lib/trailblazer/activity/dsl/linear/variable_mapping.rb
|
112
140
|
- lib/trailblazer/activity/dsl/linear/version.rb
|
113
141
|
- lib/trailblazer/activity/fast_track.rb
|
114
142
|
- lib/trailblazer/activity/path.rb
|
@@ -129,9 +157,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
|
|
129
157
|
version: 2.1.0
|
130
158
|
required_rubygems_version: !ruby/object:Gem::Requirement
|
131
159
|
requirements:
|
132
|
-
- - "
|
160
|
+
- - ">"
|
133
161
|
- !ruby/object:Gem::Version
|
134
|
-
version:
|
162
|
+
version: 1.3.1
|
135
163
|
requirements: []
|
136
164
|
rubygems_version: 3.2.3
|
137
165
|
signing_key:
|
@@ -1,70 +0,0 @@
|
|
1
|
-
module Trailblazer
|
2
|
-
class Activity
|
3
|
-
module DSL
|
4
|
-
module Linear
|
5
|
-
# Compile a {Schema} by computing {implementations} and {intermediate} from a {Sequence}.
|
6
|
-
module Compiler
|
7
|
-
module_function
|
8
|
-
|
9
|
-
# Default strategy to find out what's a stop event is to inspect the TaskRef's {data[:stop_event]}.
|
10
|
-
def find_stop_task_ids(intermediate_wiring)
|
11
|
-
intermediate_wiring.collect { |task_ref, outs| task_ref.data[:stop_event] ? task_ref.id : nil }.compact
|
12
|
-
end
|
13
|
-
|
14
|
-
# The first task in the wiring is the default start task.
|
15
|
-
def find_start_task_ids(intermediate_wiring)
|
16
|
-
[intermediate_wiring.first.first.id]
|
17
|
-
end
|
18
|
-
|
19
|
-
def call(sequence, find_stops: method(:find_stop_task_ids), find_start: method(:find_start_task_ids))
|
20
|
-
_implementations, intermediate_wiring =
|
21
|
-
sequence.inject([[], []]) do |(implementations, intermediates), seq_row|
|
22
|
-
_magnetic_to, task, connections, data = seq_row
|
23
|
-
id = data[:id]
|
24
|
-
|
25
|
-
# execute all {Search}s for one sequence row.
|
26
|
-
connections = find_connections(seq_row, connections, sequence)
|
27
|
-
|
28
|
-
# FIXME: {:extensions} should be initialized
|
29
|
-
implementations += [[id, Schema::Implementation::Task(task, connections.collect { |output, _| output }, data[:extensions] || []) ]]
|
30
|
-
|
31
|
-
intermediates += [
|
32
|
-
[
|
33
|
-
Schema::Intermediate::TaskRef(id, data),
|
34
|
-
# Compute outputs.
|
35
|
-
connections.collect { |output, target_id| Schema::Intermediate::Out(output.semantic, target_id) }
|
36
|
-
]
|
37
|
-
]
|
38
|
-
|
39
|
-
[implementations, intermediates]
|
40
|
-
end
|
41
|
-
|
42
|
-
start_task_ids = find_start.(intermediate_wiring)
|
43
|
-
stop_task_refs = find_stops.(intermediate_wiring)
|
44
|
-
|
45
|
-
intermediate = Schema::Intermediate.new(Hash[intermediate_wiring], stop_task_refs, start_task_ids)
|
46
|
-
implementation = Hash[_implementations]
|
47
|
-
|
48
|
-
Schema::Intermediate.(intermediate, implementation) # implemented in the generic {trailblazer-activity} gem.
|
49
|
-
end
|
50
|
-
|
51
|
-
# private
|
52
|
-
|
53
|
-
def find_connections(seq_row, strategies, sequence)
|
54
|
-
strategies.collect do |search|
|
55
|
-
output, target_seq_row = search.(sequence, seq_row) # invoke the node's "connection search" strategy.
|
56
|
-
|
57
|
-
target_seq_row = sequence[-1] if target_seq_row.nil? # connect to an End if target unknown. # DISCUSS: make this configurable, maybe?
|
58
|
-
|
59
|
-
[
|
60
|
-
output, # implementation
|
61
|
-
target_seq_row[3][:id], # intermediate # FIXME. this sucks.
|
62
|
-
target_seq_row # DISCUSS: needed?
|
63
|
-
]
|
64
|
-
end.compact
|
65
|
-
end
|
66
|
-
end # Compiler
|
67
|
-
end
|
68
|
-
end
|
69
|
-
end
|
70
|
-
end
|