trailblazer-activity 0.15.0 → 0.16.0

data/lib/trailblazer/activity/introspect.rb

@@ -5,142 +5,49 @@ module Trailblazer
     # 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
-      # A TaskMap is a way to introspect an {Activity}. It allows finding a {TaskAttributes}
-      # instance by its ID given at compile-time, or its task.
-      #
-      # It is much simpler and faster than the Graph interface that might get (re)moved.
-      def self.TaskMap(activity)
+      # Public entry point for {Activity} instance introspection.
+      def self.Nodes(activity, task: nil, **options)
         schema = activity.to_h
         nodes  = schema[:nodes]
 
-        task_map_tuples =
-          nodes.collect do |node_attributes|
-            [
-              task = node_attributes[:task],
-              TaskMap::TaskAttributes(id: node_attributes[:id], task: task)
-            ]
-          end
-
-        TaskMap[task_map_tuples].freeze
+        return Nodes.find_by_id(nodes, options[:id]) if options.key?(:id)
+        return nodes.fetch(task)                     if task
+        nodes
       end
 
-      class TaskMap < Hash
-        TaskAttributes = Struct.new(:id, :task) # TODO: extend at some point.
-
-        def self.TaskAttributes(id:, task:)
-          TaskMap::TaskAttributes.new(id, task).freeze
-        end
-
-        def find_by_id(id)
-          tuple = find { |task, attrs| attrs[:id] == id } or return
+      module Nodes
+        # @private
+        # @return Attributes data structure
+        def self.find_by_id(nodes, id)
+          tuple = nodes.find { |task, attrs| attrs.id == id } or return
           tuple[1]
         end
       end
 
-      # TODO: order of step/fail/pass in Node would be cool to have
-
-      # TODO: Remove Graph. This is only useful to render the full
-      # circuit, which is a very specific task that could sit in `developer`,
-      # instead.
-      # Some thoughts here:
-      # * where do we need Schema.outputs? and where task.outputs?
-      #
-      #
-      # @private This API is still under construction.
-      class Graph
-        def initialize(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
-
-        # TODO: convert to {#to_a}.
-        def collect(strategy: :circuit)
-          @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
-          existing = @configs.find { |node| yield Node(node.task, node.id, node.outputs, node.data) } or return
-
-          node_for(existing)
-        end
-
-        # Build a {Graph::Node} with outputs etc.
-        def node_for(node_attributes)
-          Node(
-            node_attributes.task,
-            node_attributes.id,
-            node_attributes.outputs, # [#<struct Trailblazer::Activity::Output signal=Trailblazer::Activity::Right, semantic=:success>]
-            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
-
-      def self.Graph(*args)
-        Graph.new(*args)
-      end
-
       # @private
       def self.find_path(activity, segments)
-        raise ArgumentError.new(%{[Trailblazer] Please pass #{activity}.to_h[:activity] into #find_path.}) unless activity.kind_of?(Trailblazer::Activity)
+        raise ArgumentError.new(%([Trailblazer] Please pass #{activity}.to_h[:activity] into #find_path.)) unless activity.is_a?(Trailblazer::Activity)
 
-        task_attributes           = TaskMap::TaskAttributes(id: nil, task: activity)
-        last_graph, last_activity = nil, TaskWrap.container_activity_for(activity) # needed for empty/root path
+        segments = [nil, *segments]
 
-        segments.each do |segment|
-          task_map              = Introspect.TaskMap(activity)
-          task, task_attributes = (task_map.find { |task, attributes| attributes[:id] == segment } or return) # DISCUSS: should we abstract these internals of {TaskMap} in {find_by_id}?
+        attributes    = nil
+        last_activity = nil
+        activity      = TaskWrap.container_activity_for(activity) # needed for empty/root path
 
+        segments.each do |segment|
+          attributes    = Introspect.Nodes(activity, id: segment) or return nil
           last_activity = activity
-          last_graph    = task_map
-
-          activity      = task
+          activity      = attributes.task
         end
 
-        return task_attributes, last_activity, last_graph
+        return attributes, last_activity
       end
 
       def self.render_task(proc)
         if proc.is_a?(Method)
 
           receiver = proc.receiver
-          receiver = receiver.is_a?(Class) ? (receiver.name || "#<Class:0x>") : (receiver.name || "#<Module:0x>") #"#<Class:0x>"
+          receiver = receiver.is_a?(Class) ? (receiver.name || "#<Class:0x>") : (receiver.name || "#<Module:0x>") # "#<Class:0x>"
 
           return "#<Method: #{receiver}.#{proc.name}>"
         elsif proc.is_a?(Symbol)
@@ -149,6 +56,13 @@ module Trailblazer
 
         proc.inspect
       end
+
+      # TODO: remove with 0.1.0.
+      def self.Graph(*args)
+        Deprecate.warn caller_locations[0], %(`Trailblazer::Activity::Introspect::Graph` is deprecated. Please use `Trailblazer::Developer::Introspect.Graph`)
+
+        Trailblazer::Developer::Introspect::Graph.new(*args)
+      end
     end # Introspect
   end
 end

data/lib/trailblazer/activity/schema/compiler.rb

@@ -0,0 +1,106 @@
+module Trailblazer
+  class Activity
+    class Schema
+      class Intermediate
+        # @private This class might get removed in 0.17.0.
+        module Compiler
+          module_function
+
+          DEFAULT_CONFIG = {wrap_static: Hash.new(Activity::TaskWrap.initial_wrap_static.freeze)} # DISCUSS: this really doesn't have to be here, but works for now and we want it in 99%.
+
+          # Compiles a {Schema} instance from an {intermediate} structure and
+          # the {implementation} object references.
+          #
+          # Intermediate structure, Implementation, calls extensions, passes {config} # TODO
+          def call(intermediate, implementation, config_merge: {})
+            config = DEFAULT_CONFIG
+              .merge(config_merge)
+              .freeze
+
+            circuit, outputs, nodes, config = schema_components(intermediate, implementation, config)
+
+            Schema.new(circuit, outputs, nodes, config)
+          end
+
+          # From the intermediate "template" and the actual implementation, compile a {Circuit} instance.
+          def schema_components(intermediate, implementation, config)
+            wiring = {}
+            nodes_attributes  = []
+
+            intermediate.wiring.each do |task_ref, outs|
+              id        = task_ref.id
+              impl_task = implementation.fetch(id)
+              task      = impl_task.circuit_task
+              outputs   = impl_task.outputs
+
+              wiring[task] = connections_for(outs, outputs, implementation)
+
+              nodes_attributes << [
+                id,               # id
+                task,             # task
+                task_ref[:data],  # TODO: allow adding data from implementation.
+                outputs           # {Activity::Output}s
+              ]
+
+              # Invoke each task's extensions (usually coming from the DSL user or some macro).
+              # We're expecting each {ext} to be a {TaskWrap::Extension::WrapStatic} instance.
+              config = invoke_extensions_for(config, impl_task, id)
+            end
+
+            start_id = intermediate.start_task_id
+
+            terminus_to_output  = terminus_to_output(intermediate, implementation)
+            activity_outputs    = terminus_to_output.values
+
+            circuit = Circuit.new(
+              wiring,
+              terminus_to_output.keys, # termini
+              start_task: implementation.fetch(start_id).circuit_task
+            )
+
+            return circuit,
+              activity_outputs,
+              Schema::Nodes(nodes_attributes),
+              config
+          end
+
+          # Compute the connections for {circuit_task}.
+          # For a terminus, this produces an empty hash.
+          def connections_for(intermediate_outs, task_outputs, implementation)
+            intermediate_outs.collect { |intermediate_out| # Intermediate::Out, it's abstract.
+              [
+                output_for_semantic(task_outputs, intermediate_out.semantic).signal,
+                implementation.fetch(intermediate_out.target).circuit_task    # Find the implementation task, the Ruby code component for runtime.
+              ]
+            }.to_h
+          end
+
+          def terminus_to_output(intermediate, implementation)
+            terminus_to_semantic = intermediate.stop_task_ids
+
+            terminus_to_semantic.collect do |id, semantic|
+              terminus_task = implementation.fetch(id).circuit_task
+
+              [
+                terminus_task,
+                Activity::Output(terminus_task, semantic) # The End instance is the signal.
+              ]
+            end.to_h
+          end
+
+          # Run all Implementation::Task.extensions and return new {config}
+          def invoke_extensions_for(config, impl_task, id)
+            impl_task
+              .extensions
+              .inject(config) { |cfg, ext| ext.(config: cfg, id: id, task: impl_task) } # {ext} must return new config hash.
+          end
+
+          # In an array of {Activity::Output}, find the output matching {semantic}.
+          def output_for_semantic(outputs, semantic)
+            outputs.find { |out| out.semantic == semantic } or raise "`#{semantic}` not found in implementation"
+          end
+        end # Intermediate
+      end
+    end
+  end
+end

data/lib/trailblazer/activity/schema/implementation.rb

@@ -1,10 +1,11 @@
 class Trailblazer::Activity
   class Schema
+    # @private This class might get removed in 0.17.0.
     module Implementation
       # Implementation structures
       Task = Struct.new(:circuit_task, :outputs, :extensions)
 
-      def self.Task(task, outputs, extensions=[])
+      def self.Task(task, outputs, extensions = [])
         Task.new(task, outputs, extensions)
       end
     end

data/lib/trailblazer/activity/schema/intermediate.rb

@@ -2,97 +2,17 @@ class Trailblazer::Activity
   class Schema
     # An {Intermediate} structure defines the *structure* of the circuit. It usually
     # comes from a DSL or a visual editor.
-    class Intermediate < Struct.new(:wiring, :stop_task_ids, :start_task_ids)
+    # @private This class might get removed in 0.17.0.
+    class Intermediate < Struct.new(:wiring, :stop_task_ids, :start_task_id)
       TaskRef = Struct.new(:id, :data) # TODO: rename to NodeRef
       Out     = Struct.new(:semantic, :target)
 
-      def self.TaskRef(id, data={}); TaskRef.new(id, data) end
-      def self.Out(*args);           Out.new(*args)        end
-
-      # Compiles a {Schema} instance from an {intermediate} structure and
-      # the {implementation} object references.
-      #
-      # Intermediate structure, Implementation, calls extensions, passes {config} # TODO
-      def self.call(intermediate, implementation, config_merge: {})
-        config_default = {wrap_static: Hash.new(TaskWrap.initial_wrap_static)} # DISCUSS: this really doesn't have to be here, but works for now and we want it in 99%.
-        config         = config_default.merge(config_merge)
-        config.freeze
-
-        circuit = circuit(intermediate, implementation)
-        nodes   = node_attributes(intermediate, implementation)
-        outputs = outputs(intermediate.stop_task_ids, nodes)
-        config  = config(implementation, config: config)
-
-        Schema.new(circuit, outputs, nodes, config)
-      end
-
-      # From the intermediate "template" and the actual implementation, compile a {Circuit} instance.
-      def self.circuit(intermediate, implementation)
-        end_events = intermediate.stop_task_ids
-
-        wiring = Hash[
-          intermediate.wiring.collect do |task_ref, outs|
-            task = implementation.fetch(task_ref.id)
-
-            [
-              task.circuit_task,
-              end_events.include?(task_ref.id) ? {} : connections_for(outs, task.outputs, implementation)
-            ]
-          end
-        ]
-
-        Circuit.new(
-          wiring,
-          intermediate.stop_task_ids.collect { |id| implementation.fetch(id).circuit_task },
-          start_task: intermediate.start_task_ids.collect { |id| implementation.fetch(id).circuit_task }[0]
-        )
-      end
-
-      # Compute the connections for {circuit_task}.
-      def self.connections_for(outs, task_outputs, implementation)
-        Hash[
-          outs.collect { |required_out| # Intermediate::Out, it's abstract.
-            [
-              for_semantic(task_outputs, required_out.semantic).signal,
-              implementation.fetch(required_out.target).circuit_task
-            ]
-          }.compact
-        ]
+      def self.TaskRef(id, data = {})
+        TaskRef.new(id, data)
       end
 
-      def self.node_attributes(intermediate, implementation)
-        intermediate.wiring.collect do |task_ref, outputs|
-          id                  = task_ref.id
-          implementation_task = implementation.fetch(id)
-          data                = task_ref[:data] # TODO: allow adding data from implementation.
-
-          NodeAttributes.new(id, implementation_task.outputs, implementation_task.circuit_task, data)
-        end
-      end
-
-      # intermediate/implementation independent.
-      def self.outputs(stop_task_ids, nodes_attributes)
-        stop_task_ids.collect do |id|
-          # Grab the {outputs} of the stop nodes.
-          nodes_attributes.find { |node_attrs| id == node_attrs.id }.outputs
-        end.flatten(1)
-      end
-
-      # Invoke each task's extensions (usually coming from the DSL user or some macro).
-      # We're expecting each {ext} to be a {TaskWrap::Extension::WrapStatic} instance.
-      def self.config(implementation, config:)
-        implementation.each do |id, task|
-          task.extensions.each { |ext| config = ext.(config: config, id: id, task: task) } # DISCUSS: ext must return new {Config}.
-        end
-
-        config
-      end
-
-
-
-      # Apply to any array.
-      private_class_method def self.for_semantic(outputs, semantic)
-        outputs.find { |out| out.semantic == semantic } or raise "`#{semantic}` not found"
+      def self.Out(*args)
+        Out.new(*args)
       end
     end # Intermediate
   end

data/lib/trailblazer/activity/schema.rb

@@ -1,15 +1,38 @@
 module Trailblazer
   class Activity
-    # In NodeAttributes we store data from Intermediate and Implementing compile-time.
-    # This would be lost otherwise.
-    NodeAttributes = Struct.new(:id, :outputs, :task, :data) # TODO: rename to Schema::Task::Attributes.
-
+    # The idea with {:config} is to have a generic runtime store for feature fields
+    # like {:wrap_static} but also for flags, e.g. `each: true` from the Each() macro.
     class Schema < Struct.new(:circuit, :outputs, :nodes, :config)
       # {:nodes} is passed directly from {compile_activity}. We need to store this data here.
 
       # @!method to_h()
       #   Returns a hash containing the schema's components.
 
+      class Nodes < Hash
+        # In Attributes we store data from Intermediate and Implementing compile-time.
+        # This would be lost otherwise.
+        Attributes = Struct.new(:id, :task, :data, :outputs)
+      end
+
+      # Builder for {Schema::Nodes} datastructure.
+      #
+      # A {Nodes} instance is a hash of Attributes, keyed by task. It turned out that
+      # 90% of introspect lookups, we search for attributes for a particular *task*, not ID.
+      # That's why in 0.16.0 we changed this structure.5
+      #
+      # Nodes{#<task> => #<Nodes::Attributes id= task= data= outputs=>}
+      #
+      # @private Please use {Introspect.Nodes} for querying nodes.
+      def self.Nodes(nodes)
+        Nodes[
+          nodes.collect do |attrs|
+            [
+              attrs[1], # task
+              Nodes::Attributes.new(*attrs).freeze
+            ]
+          end
+        ].freeze
+      end
     end # Schema
   end
 end

data/lib/trailblazer/activity/structures.rb

@@ -12,8 +12,8 @@ module Trailblazer
         @options = options.merge(semantic: semantic)
       end
 
-      def call(args, **circuit_options)
-        return self, args, **circuit_options
+      def call(args, **)
+        return self, args
       end
 
       def to_h
@@ -21,21 +21,23 @@ module Trailblazer
       end
 
       def to_s
-        %{#<#{self.class.name} #{@options.collect { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>}
+        %(#<#{self.class.name} #{@options.collect { |k, v| "#{k}=#{v.inspect}" }.join(" ")}>)
       end
 
       alias inspect to_s
     end
 
     class Start < End
-      def call(args, **circuit_options)
-        return Activity::Right, args, **circuit_options
+      def call(args, **)
+        return Activity::Right, args
       end
     end
 
-    class Signal;         end
+    class Signal; end
+
     class Right < Signal; end
-    class Left  < Signal; end
+
+    class Left < Signal; end
 
     # signal:   actual signal emitted by the task
     # color:    the mapping, where this signal will travel to. This can be e.g. Left=>:success. The polarization when building the graph.

data/lib/trailblazer/activity/task_wrap/call_task.rb

@@ -13,7 +13,10 @@ class Trailblazer::Activity
       return_signal, return_args = task.(original_arguments, **original_circuit_options)
 
       # DISCUSS: do we want original_args here to be passed on, or the "effective" return_args which are different to original_args now?
-      wrap_ctx = wrap_ctx.merge( return_signal: return_signal, return_args: return_args )
+      wrap_ctx = wrap_ctx.merge(
+        return_signal: return_signal,
+        return_args:   return_args
+      )
 
       return wrap_ctx, original_args
     end

data/lib/trailblazer/activity/task_wrap/extension.rb

@@ -9,7 +9,7 @@ module Trailblazer
     #   |-- Call (call actual task) id: "task_wrap.call_task"
     #   |-- Trace.capture_return [optional]
     #   |-- Wrap::End
-    module TaskWrap      
+    module TaskWrap
       # inserts must be
       # An {Extension} can be used for {:wrap_runtime}. It expects a collection of
       # "friendly interface" arrays.
@@ -19,6 +19,9 @@ module Trailblazer
       # If you want a {wrap_static} extension, wrap it using `Extension.WrapStatic.new`.
       def self.Extension(*inserts, merge: nil)
         if merge
+          Deprecate.warn caller_locations[0], "The :merge option for TaskWrap.Extension is deprecated and will be removed in 0.16.
+Please refer to https://trailblazer.to/2.1/docs/activity.html#activity-taskwrap-static and have a great day."
+
           return Extension::WrapStatic.new(extension: Extension.new(*merge))
           # TODO: remove me once we drop the pre-friendly interface.
         end
@@ -56,8 +59,8 @@ module Trailblazer
         def deprecated_extension_for(extension_rows)
           return extension_rows unless extension_rows.find { |ext| ext.is_a?(Array) }
 
-          warn "[Trailblazer] You are using the old API for taskWrap extensions.
-Please update to the new TaskWrap.Extension() API: # FIXME !!!!!"
+          Deprecate.warn caller_locations[3], "You are using the old API for taskWrap extensions.
+Please update to the new TaskWrap.Extension() API."
 
           extension_rows.collect do |ary|
             {
@@ -67,6 +70,13 @@ Please update to the new TaskWrap.Extension() API: # FIXME !!!!!"
           end
         end
 
+        # Create extensions from the friendly interface that can alter the wrap_static
+        # of a step in an activity. The returned extensionn can be passed directly via {:extensions}
+        # to the compiler, or when using the `#step` DSL.
+        def self.WrapStatic(*inserts)
+          WrapStatic.new(extension: TaskWrap.Extension(*inserts))
+        end
+
         # Extension are used at compile-time with {wrap_static}, mostly with the {dsl} gem.
         # {WrapStatic} extensions are called for setup through {Intermediate.config} at compile-time.
         # Each extension alters the activity's wrap_static taskWrap.
@@ -76,14 +86,20 @@ Please update to the new TaskWrap.Extension() API: # FIXME !!!!!"
           end
 
           def call(config:, task:, **)
-            # Add the extension's task(s) to the activity's {wrap_static} taskWrap
-            # by using the immutable {Config} interface.
-            before_pipe = Config.get(config, :wrap_static, task.circuit_task)
+            # DISCUSS: does it make sense to test the immutable behavior here? What would be the worst outcome?
+            task = task.circuit_task # Receives {Schema::Implementation::Task}. DISCUSS: why?
 
-            Config.set(config, :wrap_static, task.circuit_task, @extension.(before_pipe))
+            # Add the extension's task(s) to the activity's {:wrap_static} taskWrap
+            # which is stored in the {:config} field.
+            wrap_static = config[:wrap_static]                 # the activity's {wrap_static}.
+            task_wrap   = wrap_static[task] # the "original" taskWrap for {task}.
+
+            # Overwrite the original task_wrap:
+            wrap_static = wrap_static.merge(task => @extension.(task_wrap))
+
+            config.merge(wrap_static: wrap_static) # Return new config hash. This needs to be immutable code!
           end
         end # WrapStatic
-
       end # Extension
     end # TaskWrap
   end

data/lib/trailblazer/activity/task_wrap/pipeline.rb

@@ -29,7 +29,7 @@ class Trailblazer::Activity
           insert_before: :Prepend,
           insert_after: :Append,
           append: :Append,
-          prepend: :Prepend,
+          prepend: :Prepend
         }.fetch(name)
 
         warn "[Trailblazer] Using `Trailblazer::Activity::TaskWrap::Pipeline.method(:#{name})` is deprecated.

data/lib/trailblazer/activity/task_wrap/runner.rb

@@ -10,7 +10,7 @@ class Trailblazer::Activity
       # @api private
       # @interface Runner
       def self.call(task, args, **circuit_options)
-        wrap_ctx = { task: task }
+        wrap_ctx = {task: task}
 
         # this pipeline is "wrapped around" the actual `task`.
         task_wrap_pipeline = merge_static_with_runtime(task, **circuit_options) || raise
@@ -28,14 +28,13 @@ class Trailblazer::Activity
         return wrap_ctx[:return_signal], wrap_ctx[:return_args]
       end
 
-
       # Compute the task's wrap by applying alterations both static and from runtime.
       #
       # NOTE: this is for performance reasons: we could have only one hash containing everything but that'd mean
       # unnecessary computations at `call`-time since steps might not even be executed.
       # TODO: make this faster.
-      private_class_method def self.merge_static_with_runtime(task, wrap_runtime:, **circuit_options)
-        static_wrap = TaskWrap.wrap_static_for(task, **circuit_options) # find static wrap for this specific task [, or default wrap activity].
+      private_class_method def self.merge_static_with_runtime(task, wrap_runtime:, activity:, **circuit_options)
+        static_wrap = TaskWrap.wrap_static_for(task, activity) # find static wrap for this specific task [, or default wrap activity].
 
         # Apply runtime alterations.
         # Grab the additional wirings for the particular `task` from `wrap_runtime`.
@@ -44,9 +43,11 @@ class Trailblazer::Activity
     end # Runner
 
     # Retrieve the static wrap config from {activity}.
-    def self.wrap_static_for(task, activity:, **)
-      wrap_static = activity[:wrap_static]
-      wrap_static[task] or raise "#{task}"
+    # @private
+    def self.wrap_static_for(task, activity)
+      activity.to_h
+        .fetch(:config)
+        .fetch(:wrap_static)[task] # the {wrap_static} for {task}.
     end
   end
 end

data/lib/trailblazer/activity/task_wrap.rb

@@ -21,7 +21,7 @@ module Trailblazer
         circuit_options = circuit_options.merge(
           runner:       TaskWrap::Runner,
           wrap_runtime: wrap_runtime,
-          activity:     container_activity, # for Runner. Ideally we'd have a list of all static_wraps here (even nested).
+          activity:     container_activity # for Runner. Ideally we'd have a list of all static_wraps here (even nested).
         )
 
         # signal, (ctx, flow), circuit_options =
@@ -43,10 +43,13 @@ module Trailblazer
       #
       # DISCUSS: we could cache that on Strategy/Operation level.
       #          merging the **config hash is 1/4 slower than before.
-      def container_activity_for(activity, wrap_static: initial_wrap_static, **config)
+      def container_activity_for(activity, wrap_static: initial_wrap_static, id: nil, **config)
         {
-          wrap_static:  {activity => wrap_static},
-          **config
+          config: {
+            wrap_static: {activity => wrap_static},
+            **config
+          },
+          nodes:  Schema.Nodes([[id, activity]])
         }
       end
 
@@ -54,4 +57,3 @@ module Trailblazer
     end # TaskWrap
   end
 end
-