trailblazer-activity 0.9.1 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 943560a813f46719e16777daa7f1b58f93a5871838a6e1593a913ecc5a7475a5
-  data.tar.gz: 0a4e4286edcb7319f0002d82388dbfa9c7005ed76d214884af91e8290ff86fe3
+  metadata.gz: 0b971b7f8960520b05bcc99a2fe0561056d9ec244cf9faeb072e131604e0bc12
+  data.tar.gz: ec6e1d2c4b2de4d1edfce435c08029a061df61b1b770ad174c005733238269cb
 SHA512:
-  metadata.gz: f754c43ff0f0a815e52b3bb5f80f4962f3c3566262b6f731aed3a1b1237bc73a16824ad68dd795ca5f7f01349030907bba302fb56863de5a2f5d57e0d7b6924f
-  data.tar.gz: 103a79e48cf54ca69767ae4370cec9810d6d5ca5a2352db28896f6ffd232ca98f426ff87d3b6d748173af97589c211f14347ae59779d0f9e834e0ccc7f6d7852
+  metadata.gz: 5de05a662519033f02c6e58595d502e80970b08abe7bd87caa7ff23c6acae6490498453bcf8584b8ea6dcba14ef6f00298b1aeca75c5405f8e281e4d206e44e9
+  data.tar.gz: 35c9f6d275c0da422e0597529424f005af4e44a344c63c0ca8595d87a44ad8c474be21c5e9c985d1f1a01b2d1ff0b2020da06edcc29e9871af9c174c1766d7cb

data/CHANGES.md

@@ -1,3 +1,15 @@
+# 0.9.4
+
+Move some test helpers to `Activity::Testing` to export them to other gems
+
+# 0.9.3
+
+Remove introspection modules, it'll also be part of the `Dev` tools now.
+
+# 0.9.2
+
+Remove tracing modules, it'll be part of the `Dev` tools now.
+
 # 0.9.1
 
 Use `context-0.9.1`.

data/lib/trailblazer/activity.rb

@@ -49,10 +49,6 @@ require "trailblazer/activity/task_wrap/runner"
 require "trailblazer/activity/task_wrap/variable_mapping"
 require "trailblazer/activity/task_wrap/inject"
 
-require "trailblazer/activity/trace"
-require "trailblazer/activity/present"
-
-require "trailblazer/activity/introspect"
 require "trailblazer/option"
 require "trailblazer/context"
 require "trailblazer/activity/task_builder"

data/lib/trailblazer/activity/testing.rb

@@ -47,10 +47,85 @@ module Trailblazer
     end
 
     module Assertions
+        Activity  = Trailblazer::Activity
+        Inter     = Trailblazer::Activity::Schema::Intermediate
+        Schema    = Trailblazer::Activity::Schema
+        TaskWrap  = Trailblazer::Activity::TaskWrap
+
+        module Implementing
+          extend Activity::Testing.def_tasks(:a, :b, :c, :d, :f, :g)
+
+          Start = Activity::Start.new(semantic: :default)
+          Failure = Activity::End(:failure)
+          Success = Activity::End(:success)
+        end
+
         def Cct(activity)
           cct = Trailblazer::Developer::Render::Circuit.(activity)
         end
 
+        # TODO: Remove this once all it's references are removed
+        def implementing
+          Implementing
+        end
+
+        def flat_activity
+          return @_flat_activity if defined?(@_flat_activity)
+
+          intermediate = Inter.new(
+            {
+              Inter::TaskRef("Start.default")      => [Inter::Out(:success, :B)],
+              Inter::TaskRef(:B, additional: true) => [Inter::Out(:success, :C)],
+              Inter::TaskRef(:C)                   => [Inter::Out(:success, "End.success")],
+              Inter::TaskRef("End.success", stop_event: true) => [Inter::Out(:success, nil)]
+            },
+            ["End.success"],
+            ["Start.default"], # start
+          )
+
+          implementation = {
+            "Start.default" => Schema::Implementation::Task(st = Implementing::Start, [Activity::Output(Activity::Right, :success)],        []),
+            :B => Schema::Implementation::Task(b = Implementing.method(:b), [Activity::Output(Activity::Right, :success)],                  []),
+            :C => Schema::Implementation::Task(c = Implementing.method(:c), [Activity::Output(Activity::Right, :success)],                  []),
+            "End.success" => Schema::Implementation::Task(_es = Implementing::Success, [Activity::Output(Implementing::Success, :success)], []), # DISCUSS: End has one Output, signal is itself?
+          }
+
+          schema = Inter.(intermediate, implementation)
+
+          @_flat_activity = Activity.new(schema)
+        end
+
+        def nested_activity
+          return @_nested_activity if defined?(@_nested_activity)
+
+          intermediate = Inter.new(
+            {
+              Inter::TaskRef("Start.default") => [Inter::Out(:success, :B)],
+              Inter::TaskRef(:B, more: true)  => [Inter::Out(:success, :D)],
+              Inter::TaskRef(:D) => [Inter::Out(:success, :E)],
+              Inter::TaskRef(:E) => [Inter::Out(:success, "End.success")],
+              Inter::TaskRef("End.success", stop_event: true) => [Inter::Out(:success, nil)]
+            },
+            ["End.success"],
+            ["Start.default"] # start
+          )
+
+          implementation = {
+            "Start.default" => Schema::Implementation::Task(st = Implementing::Start, [Activity::Output(Activity::Right, :success)],        []),
+            :B => Schema::Implementation::Task(b = Implementing.method(:b), [Activity::Output(Activity::Right, :success)],                  []),
+            :D => Schema::Implementation::Task(c = bc, [Activity::Output(Implementing::Success, :success)],                  []),
+            :E => Schema::Implementation::Task(e = Implementing.method(:f), [Activity::Output(Activity::Right, :success)],                  []),
+            "End.success" => Schema::Implementation::Task(_es = Implementing::Success, [Activity::Output(Implementing::Success, :success)], []), # DISCUSS: End has one Output, signal is itself?
+          }
+
+          schema = Inter.(intermediate, implementation)
+
+          @_nested_activity = Activity.new(schema)
+        end
+
+        alias_method :bc, :flat_activity
+        alias_method :bde, :nested_activity
+
         # Tests {:circuit} and {:outputs} fields so far.
         def assert_process_for(process, *args)
           semantics, circuit = args[0..-2], args[-1]

data/lib/trailblazer/activity/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Activity
-      VERSION = "0.9.1"
+      VERSION = "0.9.4"
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-activity
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.4
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-20 00:00:00.000000000 Z
+date: 2019-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-context
@@ -108,8 +108,6 @@ files:
 - lib/trailblazer/activity.rb
 - lib/trailblazer/activity/circuit.rb
 - lib/trailblazer/activity/config.rb
-- lib/trailblazer/activity/introspect.rb
-- lib/trailblazer/activity/present.rb
 - lib/trailblazer/activity/schema.rb
 - lib/trailblazer/activity/schema/implementation.rb
 - lib/trailblazer/activity/schema/intermediate.rb
@@ -122,7 +120,6 @@ files:
 - lib/trailblazer/activity/task_wrap/runner.rb
 - lib/trailblazer/activity/task_wrap/variable_mapping.rb
 - lib/trailblazer/activity/testing.rb
-- lib/trailblazer/activity/trace.rb
 - lib/trailblazer/activity/version.rb
 - trailblazer-activity.gemspec
 homepage: http://trailblazer.to
@@ -145,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Runtime code for Trailblazer activities.

data/lib/trailblazer/activity/introspect.rb

@@ -1,72 +0,0 @@
-module Trailblazer
-  class Activity
-    # The Introspect API provides inflections for `Activity` instances.
-    # It abstracts internals about circuits and provides a convenient API to third-parties such as
-    # tracing, rendering an activity, or finding particular tasks.
-    module Introspect
-      def self.Graph(*args)
-        Graph.new(*args)
-      end
-
-      # TODO: order of step/fail/pass in Node would be cool to have
-
-      # @private This API is still under construction.
-      class Graph
-        def initialize(activity)
-          @activity = activity
-          @schema   = activity.to_h or raise
-          @circuit  = @schema[:circuit]
-          @map      = @circuit.to_h[:map]
-          @configs  = @schema[:nodes]
-        end
-
-        def find(id=nil, &block)
-          return find_by_id(id) unless block_given?
-          find_with_block(&block)
-        end
-
-        def collect(strategy: :circuit, &block)
-          @map.keys.each_with_index.collect { |task, i| yield find_with_block { |node| node.task==task }, i }
-        end
-
-        def stop_events
-          @circuit.to_h[:end_events]
-        end
-
-        private
-
-        def find_by_id(id)
-          node = @configs.find { |node| node.id == id } or return
-          node_for(node)
-        end
-
-        def find_with_block(&block)
-          existing = @configs.find { |node| yield Node(node.task, node.id, node.outputs, node.data) } or return
-
-          node_for(existing)
-        end
-
-        def node_for(node_attributes)
-          Node(node_attributes.task, node_attributes.id, node_attributes.outputs, outgoings_for(node_attributes), node_attributes.data)
-        end
-
-        def Node(*args)
-          Node.new(*args).freeze
-        end
-
-        Node     = Struct.new(:task, :id, :outputs, :outgoings, :data)
-        Outgoing = Struct.new(:output, :task)
-
-        def outgoings_for(node)
-          outputs     = node.outputs
-          connections = @map[node.task]
-
-          connections.collect do |signal, target|
-            output = outputs.find { |out| out.signal == signal }
-            Outgoing.new(output, target)
-          end
-        end
-      end
-    end #Introspect
-  end
-end

data/lib/trailblazer/activity/present.rb

@@ -1,63 +0,0 @@
-module Trailblazer
-  class Activity
-    # Task < Array
-    # [ input, ..., output ]
-
-    module Trace
-      # TODO: make this simpler.
-      module Present
-        module_function
-
-        INDENTATION = "   |".freeze
-        STEP_PREFIX = "-- ".freeze
-
-        def default_renderer(task_node:, **)
-          [ task_node[:level], %{#{task_node[:name]}} ]
-        end
-
-        def call(stack, level: 1, tree: [], renderer: method(:default_renderer), **options)
-          tree(stack.to_a, level, tree: tree, renderer: renderer, **options)
-        end
-
-        def tree(stack, level, tree:, renderer:, **options)
-          tree_for(stack, level, options.merge(tree: tree))
-
-          nodes = tree.each_with_index.map do |task_node, position|
-            renderer.(task_node: task_node, position: position, tree: tree)
-          end
-
-          render_tree_for(nodes)
-        end
-
-        def render_tree_for(nodes)
-          nodes.map { |level, node|
-            indentation = INDENTATION * (level -1)
-            indentation = indentation[0...-1] + "`" if level == 1 || /End./.match(node) # start or end step
-            indentation + STEP_PREFIX + node
-          }.join("\n")
-        end
-
-        def tree_for(stack, level, tree:, **options)
-          stack.each do |lvl| # always a Stack::Task[input, ..., output]
-            input, output, nested = Trace::Level.input_output_nested_for_level(lvl)
-
-            task = input.task
-
-            graph = Introspect::Graph(input.activity)
-
-            name = (node = graph.find { |node| node[:task] == task }) ? node[:id] : task
-            name ||= task # FIXME: bullshit
-
-            tree << { level: level, input: input, output: output, name: name, **options }
-
-            if nested.any? # nesting
-              tree_for(nested, level + 1, options.merge(tree: tree))
-            end
-
-            tree
-          end
-        end
-      end
-    end
-  end
-end

data/lib/trailblazer/activity/trace.rb

@@ -1,144 +0,0 @@
-module Trailblazer
-  class Activity
-    module Trace
-      class << self
-        # Public entry point to activate tracing when running {activity}.
-        def call(activity, (ctx, flow_options), circuit_options={})
-          activity, (ctx, flow_options), circuit_options = Trace.arguments_for_call( activity, [ctx, flow_options], circuit_options ) # only run once for the entire circuit!
-
-          signal, (ctx, flow_options) = Activity::TaskWrap.invoke(activity, [ctx, flow_options], circuit_options)
-
-          return flow_options[:stack], signal, [ctx, flow_options]
-        end
-
-        alias_method :invoke, :call
-
-        def arguments_for_call(activity, (options, flow_options), **circuit_options)
-          tracing_flow_options = {
-            stack: Trace::Stack.new,
-          }
-
-          tracing_circuit_options = {
-            wrap_runtime:  ::Hash.new(Trace.merge_plan), # DISCUSS: this overrides existing {:wrap_runtime}.
-          }
-
-          return activity, [ options, tracing_flow_options.merge(flow_options) ], circuit_options.merge(tracing_circuit_options)
-        end
-      end
-
-      module_function
-      # Insertions for the trace tasks that capture the arguments just before calling the task,
-      # and before the TaskWrap is finished.
-      #
-      # @private
-      def merge_plan
-        TaskWrap::Pipeline::Merge.new(
-          [TaskWrap::Pipeline.method(:insert_before), "task_wrap.call_task", ["task_wrap.capture_args",   Trace.method(:capture_args)]],
-          [TaskWrap::Pipeline.method(:append),        nil,                   ["task_wrap.capture_return", Trace.method(:capture_return)]],
-        )
-      end
-
-      # taskWrap step to capture incoming arguments of a step.
-      def capture_args(wrap_config, original_args)
-        original_args = capture_for(wrap_config[:task], *original_args)
-
-        return wrap_config, original_args
-      end
-
-      # taskWrap step to capture outgoing arguments from a step.
-      def capture_return(wrap_config, original_args)
-        (original_options, original_flow_options, _) = original_args[0]
-
-        original_flow_options[:stack] << Entity::Output.new(
-          wrap_config[:task], {}, wrap_config[:return_signal]
-        ).freeze
-
-        original_flow_options[:stack].unindent!
-
-
-        return wrap_config, original_args
-      end
-
-      # It's important to understand that {flow[:stack]} is mutated by design. This is needed so
-      # in case of exceptions we still have a "global" trace - unfortunately Ruby doesn't allow
-      # us a better way.
-      def capture_for(task, (ctx, flow), activity:, **circuit_options)
-        flow[:stack].indent!
-
-        flow[:stack] << Entity::Input.new(
-          task, activity, [ctx, ctx.inspect]
-        ).freeze
-
-        return [ctx, flow], circuit_options.merge(activity: activity)
-      end
-
-      # Structures used in {capture_args} and {capture_return}.
-      # These get pushed onto one {Level} in a {Stack}.
-      #
-      #   Level[
-      #     Level[              ==> this is a scalar task
-      #       Entity::Input
-      #       Entity::Output
-      #     ]
-      #     Level[              ==> nested task
-      #       Entity::Input
-      #       Level[
-      #         Entity::Input
-      #         Entity::Output
-      #       ]
-      #       Entity::Output
-      #     ]
-      #   ]
-      Entity         = Struct.new(:task, :activity, :data)
-      Entity::Input  = Class.new(Entity)
-      Entity::Output = Class.new(Entity)
-
-      class Level < Array
-        def inspect
-          %{<Level>#{super}}
-        end
-
-        # @param level {Trace::Level}
-        def self.input_output_nested_for_level(level)
-          input  = level[0]
-          output = level[-1]
-
-          output, nested = output.is_a?(Entity::Output) ? [output, level-[input, output]] : [nil, level[1..-1]]
-
-          return input, output, nested
-        end
-      end
-
-      # Mutable/stateful per design. We want a (global) stack!
-      class Stack
-        def initialize
-          @nested  = Level.new
-          @stack   = [ @nested ]
-        end
-
-        def indent!
-          current << indented = Level.new
-          @stack << indented
-        end
-
-        def unindent!
-          @stack.pop
-        end
-
-        def <<(args)
-          current << args
-        end
-
-        def to_a
-          @nested
-        end
-
-        private
-
-        def current
-          @stack.last
-        end
-      end # Stack
-    end
-  end
-end