trailblazer-developer 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4457d9f0cca19b8f72a8e492f8d155c5d8a3459015201d03548a71b26911f0b2
-  data.tar.gz: f6035eaca82336afb3d836f40c96910b37298e2c5eee8b90fac93a2d5c563b5f
+  metadata.gz: 435373419cdb7bb8f3c3b923585cdd83152774c90cb38b0685cf8ac4bdcc417d
+  data.tar.gz: 9f0a93bf955441a20d0f91f538fd3ad563cfda5a3f45b582dfa4edfd0aa8876d
 SHA512:
-  metadata.gz: d7c7243f9b266f750a47046e5fce4ad73c08b8e44dcf6ea5bf7b40f008565130bec440ab1c372dcfc312436c7b5ac44b9113a3411677b87954aa4d232696d804
-  data.tar.gz: ebcd6ebbf1b448a306566b07c1042324eac3291b077cafc62c389cf78533034f187fd467a33e2142ac89d3a7d9b954c873dc31915d1278c71b4ffb7b7921d44e
+  metadata.gz: 983662dc11836f0e42050145b5766c2eaa19d6c1240eb6cfe647c3fe6250a38d32cea7392dfc1ebef56c88ee83f9dee95764dfda7fb8c81703dd30eb84486b4b
+  data.tar.gz: 7591b6a2004491cf86fbe042009e870aafb9f23b904f6e3180b8103b82564d1cdd08761a890db09344af1ffd2564418fafe6f02d174b958dc6f65a104f11eeca

data/LICENSE

@@ -0,0 +1,9 @@
+Copyright (c) 2018 Trailblazer GmbH
+
+Trailblazer is an Open Source project licensed under the terms of
+the LGPLv3 license.  Please see <http://www.gnu.org/licenses/lgpl-3.0.html>
+for license text.
+
+Trailblazer PRO has a commercial-friendly license allowing private forks
+and modifications of Trailblazer.  Please see http://trailblazer.to/pro for
+more detail.

data/lib/trailblazer/developer/CHANGES.md

@@ -1,3 +1,8 @@
+# 0.0.7
+
+* Move `Activity::Trace` and `Activity::Present` from `activity` to `developer`.
+* Remove global configurations and use `flow_options` to override defaults in `wtf?`.
+
 # 0.0.6
 
 * Remove ID extraction logic from `Generate`, this is done on the server-side.

data/lib/trailblazer/developer/render/circuit.rb

@@ -12,7 +12,7 @@ module Trailblazer
 
         # Render an {Activity}'s circuit as a simple hash.
         def call(activity, **options)
-          graph = Activity::Introspect::Graph(activity)
+          graph = Introspect::Graph(activity)
 
           circuit_hash(graph, **options)
         end

data/lib/trailblazer/developer/render/linear.rb

@@ -15,7 +15,7 @@ module Trailblazer
         module_function
 
         def call(operation, options = {style: :line})
-          graph = Activity::Introspect::Graph(operation)
+          graph = Introspect::Graph(operation)
 
           rows = graph.collect do |node, i|
             next if node[:data][:stop_event] # DISCUSS: show this?

data/lib/trailblazer/developer/trace/present.rb

@@ -0,0 +1,59 @@
+require 'trailblazer/activity'
+
+module Trailblazer::Developer
+  module Trace
+    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

data/lib/trailblazer/developer/trace.rb

@@ -0,0 +1,147 @@
+require 'trailblazer/activity'
+
+module Trailblazer::Developer
+  module Trace
+
+    Activity = Trailblazer::Activity
+
+    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
+      Activity::TaskWrap::Pipeline::Merge.new(
+        [Activity::TaskWrap::Pipeline.method(:insert_before), "task_wrap.call_task", ["task_wrap.capture_args",   Trace.method(:capture_args)]],
+        [Activity::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

data/lib/trailblazer/developer/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Developer
-      VERSION = "0.0.6"
+      VERSION = "0.0.7"
     end
   end
 end

data/lib/trailblazer/developer/wtf.rb

@@ -1,5 +1,3 @@
-require 'trailblazer/activity'
-
 module Trailblazer::Developer
   module_function
 
@@ -14,7 +12,15 @@ module Trailblazer::Developer
   module Wtf
     module_function
 
-    COLOR_MAP = Trailblazer::Developer.config.trace_color_map
+    COLOR_MAP = { pass: :green, fail: :brown }
+
+    SIGNALS_MAP = {
+      'Trailblazer::Activity::Right': :pass,
+      'Trailblazer::Activity::FastTrack::PassFast': :pass,
+
+      'Trailblazer::Activity::Left': :fail,
+      'Trailblazer::Activity::FastTrack::FailFast': :fail,
+    }
 
     # Run {activity} with tracing enabled and inject a mutable {Stack} instance.
     # This allows to display the trace even when an exception happened
@@ -23,43 +29,50 @@ module Trailblazer::Developer
 
       # this instance gets mutated with every step. unfortunately, there is
       # no other way in Ruby to keep the trace even when an exception was thrown.
-      stack = Trailblazer::Activity::Trace::Stack.new
-
-      begin
-        _returned_stack, *returned = Trailblazer::Activity::Trace.invoke(
-          activity,
-          [
-            ctx,
-            flow_options.merge(stack: stack)
-          ],
-          *args
-        )
-        puts Trailblazer::Activity::Trace::Present.(stack, renderer: method(:renderer))
-
-      rescue => exception
-        puts Trailblazer::Activity::Trace::Present.(stack, renderer: method(:renderer))
-        raise(exception)
-      end
+      stack = Trace::Stack.new
+
+      _returned_stack, *returned = Trace.invoke(
+        activity,
+        [
+          ctx,
+          flow_options.merge(stack: stack)
+        ],
+        *args
+      )
 
       returned
+    ensure
+      puts Trace::Present.(
+        stack,
+        renderer: method(:renderer),
+        color_map: COLOR_MAP.merge( flow_options[:color_map] || {} )
+      )
     end
 
     def renderer(task_node:, position:, tree:)
-      if task_node[:output].nil? && tree[position.next].nil? # i.e. when exception raised
-        return [ task_node[:level], %{#{fmt(fmt(task_node[:name], :red), :bold)}} ]
+      name, level, output, color_map = task_node.values_at(:name, :level, :output, :color_map)
+
+      if output.nil? && tree[position.next].nil? # i.e. when exception raised
+        return [ level, %{#{fmt(fmt(name, :red), :bold)}} ]
       end
 
-      if task_node[:output].nil? # i.e. on entry/exit point of activity
-        return [ task_node[:level], %{#{fmt(task_node[:name], COLOR_MAP.default)}} ]
+      if output.nil? # i.e. on entry/exit point of activity
+        return [ level, %{#{name}} ]
       end
 
-      [ task_node[:level], %{#{fmt(task_node[:name], COLOR_MAP[task_node[:output].data])}} ]
+      [ level, %{#{fmt( name, color_map[ signal_of(output.data) ] )}} ]
     end
 
     def fmt(line, style)
+      return line unless style
       String.send(style, line)
     end
 
+    def signal_of(entity_output)
+      entity_klass = entity_output.is_a?(Class) ? entity_output : entity_output.class
+      SIGNALS_MAP[entity_klass.name.to_sym]
+    end
+
     # Stolen from https://stackoverflow.com/questions/1489183/colorized-ruby-output
     #
     # TODO: this is just prototyping

data/lib/trailblazer/developer.rb

@@ -6,8 +6,10 @@ module Trailblazer
   end
 end
 
-require "trailblazer/developer/config"
 require "trailblazer/developer/wtf"
+require "trailblazer/developer/trace"
+require "trailblazer/developer/trace/present"
+require "trailblazer/developer/introspect"
 require "trailblazer/developer/generate"
 require "trailblazer/developer/render/circuit"
 require "trailblazer/developer/render/linear"

data/trailblazer-developer.gemspec

@@ -10,7 +10,8 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "Developer tools for Trailblazer."
   spec.description   = "Developer tools for Trailblazer: debugger, tracing, visual editor integration."
-  spec.homepage      = "http://trailblazer.to/gems/trailblazer/developer.html"
+  spec.homepage      = "http://trailblazer.to"
+  spec.license       = "LGPL-3.0"
 
   spec.files = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test)/})
@@ -23,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rubocop"
 
-  spec.add_dependency "trailblazer-activity", ">= 0.8.4"
+  spec.add_dependency "trailblazer-activity", ">= 0.10.0"
   spec.add_dependency "trailblazer-activity-dsl-linear"
   spec.add_dependency "representable"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-developer
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-11 00:00:00.000000000 Z
+date: 2019-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.4
+        version: 0.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.4
+        version: 0.10.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity-dsl-linear
   requirement: !ruby/object:Gem::Requirement
@@ -133,6 +133,7 @@ files:
 - ".rubocop.yml"
 - ".travis.yml"
 - Gemfile
+- LICENSE
 - README.md
 - Rakefile
 - bin/console
@@ -142,16 +143,18 @@ files:
 - lib/trailblazer/developer/CHANGES.md
 - lib/trailblazer/developer/activity.rb
 - lib/trailblazer/developer/client.rb
-- lib/trailblazer/developer/config.rb
 - lib/trailblazer/developer/generate.rb
 - lib/trailblazer/developer/render/circuit.rb
 - lib/trailblazer/developer/render/linear.rb
+- lib/trailblazer/developer/trace.rb
+- lib/trailblazer/developer/trace/present.rb
 - lib/trailblazer/developer/version.rb
 - lib/trailblazer/developer/wtf.rb
 - lib/trailblazer/diagram/bpmn.rb
 - trailblazer-developer.gemspec
-homepage: http://trailblazer.to/gems/trailblazer/developer.html
-licenses: []
+homepage: http://trailblazer.to
+licenses:
+- LGPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -169,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Developer tools for Trailblazer.

data/lib/trailblazer/developer/config.rb

@@ -1,30 +0,0 @@
-module Trailblazer::Developer
-  # {config} gives global settings for Developer
-  # Trailblazer::Developer.configure do |config|
-  #   config.trace_color_map[Trailblazer::Activity::Right] = :green
-  #   config.trace_color_map.default = :green
-  # end
-
-  class << self
-    def configure
-      yield config
-    end
-
-    def config
-      @config ||= Config.new
-    end
-  end
-
-  class Config
-    attr_reader :trace_color_map
-
-    def initialize
-      @trace_color_map = {
-        Trailblazer::Activity::Right => :green,
-        Trailblazer::Activity::Left  => :brown
-      }
-
-      @trace_color_map.default = :green
-    end
-  end
-end