trailblazer-macro 2.1.0.rc1 → 2.1.0.rc11

data/.travis.yml

@@ -1,15 +1,11 @@
+sudo: false
 language: ruby
-before_install:
-  - gem install bundler
-matrix:
-  include:
-    - rvm: 2.1
-      gemfile: Gemfile
-    - rvm: 2.2
-      gemfile: Gemfile
-    - rvm: 2.3.1
-      gemfile: Gemfile
-    - rvm: 2.4.1
-      gemfile: Gemfile
-    - rvm: 2.5.0
-      gemfile: Gemfile
+rvm:
+  - 2.6.2
+  - 2.5.5
+  - 2.4.4
+  - 2.3.7
+  - 2.2
+  - 2.1
+
+cache: bundler

data/CHANGES.md

@@ -1,3 +1,8 @@
+# 2.1.0.rc11
+
+* Works with `>= activity-0.8`.
+* Implement old functionality of `Nested()`.
+
 # 2.1.0.rc1
 
 * Use `operation-0.4.1`.

data/Gemfile

@@ -5,7 +5,9 @@ gemspec
 
 # gem "trailblazer", github: "trailblazer/trailblazer"
 # gem "trailblazer-activity", path: "../trailblazer-activity"
-# gem "trailblazer-operation", path: "../operation"
+# gem "trailblazer-activity-dsl-linear", github: "trailblazer/trailblazer-activity-dsl-linear", branch: 'master'
+# gem "trailblazer-activity-dsl-linear", path: "../trailblazer-activity-dsl-linear"
+# gem "trailblazer-operation", github: "trailblazer/trailblazer-operation", branch: 'linear'
 # gem "trailblazer-activity"#, github: "trailblazer/trailblazer-activity"
 # gem "trailblazer-macro-contract", git: "https://github.com/trailblazer/trailblazer-macro-contract"
 

data/Rakefile

@@ -1,8 +1,5 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
-require "rubocop/rake_task"
-
-task :default => %i[test rubocop]
 
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
@@ -10,8 +7,4 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-RuboCop::RakeTask.new(:rubocop) do |task|
-  task.patterns = ['lib/**/*.rb', 'test/**/*.rb']
-  task.options << "--display-cop-names"
-  task.fail_on_error = false
-end
+task default: :test

data/lib/trailblazer-macro.rb

@@ -1,2 +1,2 @@
-require "trailblazer/macro/version"
+require "trailblazer/macro/version" # rubocop:disable Naming/FileName
 require "trailblazer/macro"

data/lib/trailblazer/macro.rb

@@ -1,11 +1,29 @@
-require "trailblazer/operation"
+require "trailblazer/activity"
+require "trailblazer/activity/dsl/linear" # TODO: remove this dependency
+require "trailblazer/operation" # TODO: remove this dependency
 
-require "trailblazer/operation/inject"
+require "trailblazer/macro/model"
+require "trailblazer/macro/policy"
+require "trailblazer/macro/guard"
+require "trailblazer/macro/pundit"
+require "trailblazer/macro/nested"
+require "trailblazer/macro/rescue"
+require "trailblazer/macro/wrap"
 
-require "trailblazer/operation/model"
-require "trailblazer/operation/policy"
-require "trailblazer/operation/guard"
-require "trailblazer/operation/pundit"
-require "trailblazer/operation/nested"
-require "trailblazer/operation/rescue"
-require "trailblazer/operation/wrap"
+module Trailblazer
+  module Macro
+    # All macros sit in the {Trailblazer::Macro} namespace, where we forward calls from
+    # operations and activities to.
+    def self.forward_macros(target)
+      target.singleton_class.def_delegators Trailblazer::Macro, :Model, :Wrap, :Rescue, :Nested
+      target.const_set(:Policy, Trailblazer::Macro::Policy)
+    end
+  end
+end
+
+# TODO: Forwardable.def_delegators(Operation, Macro, :Model, :Wrap) would be amazing. It really sucks to extend a foreign class.
+# Trailblazer::Operation.singleton_class.extend Forwardable
+# Trailblazer::Macro.forward_macros(Trailblazer::Operation)
+
+Trailblazer::Activity::FastTrack.singleton_class.extend Forwardable
+Trailblazer::Macro.forward_macros(Trailblazer::Activity::FastTrack) # monkey-patching sucks.

data/lib/trailblazer/{operation → macro}/guard.rb

@@ -1,7 +1,7 @@
-class Trailblazer::Operation
+module Trailblazer::Macro
   module Policy
     def self.Guard(proc, name: :default, &block)
-      Policy.step( Guard.build(proc), name: name )
+      Policy.step(Guard.build(proc), name: name)
     end
 
     module Guard
@@ -9,8 +9,8 @@ class Trailblazer::Operation
         option = Trailblazer::Option::KW(callable)
 
         # this gets wrapped in a Operation::Result object.
-        ->( (options, *), circuit_args ) do
-          Result.new(!!option.call(options, circuit_args), {})
+        ->((options, *), circuit_args) do
+          Trailblazer::Operation::Result.new(!!option.call(options, circuit_args), {})
         end
       end
     end

data/lib/trailblazer/{operation → macro}/model.rb

@@ -1,23 +1,21 @@
-class Trailblazer::Operation
-  def self.Model(model_class, action=nil, find_by_key=nil)
+module Trailblazer::Macro
+  def self.Model(model_class, action = nil, find_by_key = nil)
     task = Trailblazer::Activity::TaskBuilder::Binary(Model.new)
 
-    extension = Trailblazer::Activity::TaskWrap::Merge.new(
-      Wrap::Inject::Defaults(
-        "model.class"          => model_class,
-        "model.action"         => action,
-        "model.find_by_key"    => find_by_key
-      )
+    injection = Trailblazer::Activity::TaskWrap::Inject::Defaults::Extension(
+      "model.class"          => model_class,
+      "model.action"         => action,
+      "model.find_by_key"    => find_by_key
     )
 
-    { task: task, id: "model.build", Trailblazer::Activity::DSL::Extension.new(extension) => true }
+    {task: task, id: "model.build", extensions: [injection]}
   end
 
   class Model
     def call(options, params:,  **)
       builder                 = Model::Builder.new
       options[:model]         = model = builder.call(options, params)
-      options["result.model"] = result = Result.new(!model.nil?, {})
+      options["result.model"] = result = Trailblazer::Operation::Result.new(!model.nil?, {})
 
       result.success?
     end

data/lib/trailblazer/macro/nested.rb

@@ -0,0 +1,76 @@
+# per default, everything we pass into a circuit is immutable. it's the ops/act's job to allow writing (via a Context)
+module Trailblazer
+  module Macro
+    # {Nested} macro.
+    def self.Nested(callable, id: "Nested(#{callable})")
+      if callable.is_a?(Class) && callable < Nested.operation_class
+        warn %{[Trailblazer] Using the `Nested()` macro with operations and activities is deprecated. Replace `Nested(Create)` with `Subprocess(Create)`.}
+        return Nested.operation_class.Subprocess(callable)
+      end
+
+      # dynamic
+      task = Nested::Dynamic.new(callable)
+
+      merge = [
+        [Activity::TaskWrap::Pipeline.method(:insert_before), "task_wrap.call_task", ["Nested.compute_nested_activity", task.method(:compute_nested_activity)]],
+        [Activity::TaskWrap::Pipeline.method(:insert_after),  "task_wrap.call_task", ["Nested.compute_return_signal", task.method(:compute_return_signal)]],
+      ]
+
+      task_wrap_extension = Activity::TaskWrap::Extension(merge: merge)
+
+      {
+        task:       task,
+        id:         id,
+        extensions: [task_wrap_extension],
+        outputs:    task.outputs,
+      }
+    end
+
+    # @private
+    module Nested
+      def self.operation_class
+        Operation
+      end
+
+      # For dynamic `Nested`s that do not expose an {Activity} interface.
+      # Since we do not know its outputs, we have to map them to :success and :failure, only.
+      #
+      # This is what {Nested} in 2.0 used to do, where the outcome could only be true/false (or success/failure).
+      class Dynamic
+        def initialize(nested_activity_decider)
+          @nested_activity_decider = Option::KW(nested_activity_decider)
+
+          @outputs         = {
+            :success => Activity::Output(Activity::Railway::End::Success.new(semantic: :success), :success),
+            :failure => Activity::Output(Activity::Railway::End::Failure.new(semantic: :failure), :failure)
+          }
+        end
+
+        attr_reader :outputs
+
+        # TaskWrap step.
+        def compute_nested_activity(wrap_ctx, original_args)
+          (ctx, _), original_circuit_options = original_args
+
+          # TODO: evaluate the option to get the actual "object" to call.
+          activity = @nested_activity_decider.(ctx, original_circuit_options)
+
+          # Overwrite :task so task_wrap.call_task will call this activity.
+          # This is a trick so we don't have to repeat logic from #call_task here.
+          wrap_ctx[:task] = activity
+
+          return wrap_ctx, original_args
+        end
+
+        def compute_return_signal(wrap_ctx, original_args)
+          # Translate the genuine nested signal to the generic Dynamic end (success/failure, only).
+          # Note that here we lose information about what specific event was emitted.
+          wrap_ctx[:return_signal] = wrap_ctx[:return_signal].kind_of?(Activity::Railway::End::Success) ?
+            @outputs[:success].signal : @outputs[:failure].signal
+
+          return wrap_ctx, original_args
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/{operation → macro}/policy.rb

@@ -1,9 +1,9 @@
-class Trailblazer::Operation
+module Trailblazer::Macro
   module Policy
     # Step: This generically `call`s a policy and then pushes its result to `options`.
     # You can use any callable object as a policy with this step.
     class Eval
-      def initialize(name:nil, path:nil)
+      def initialize(name: nil, path: nil)
         @name = name
         @path = path
       end
@@ -11,8 +11,8 @@ class Trailblazer::Operation
       # incoming low-level {Task API}.
       # outgoing Task::Binary API.
       def call((options, flow_options), **circuit_options)
-        condition = options[ @path ] # this allows dependency injection.
-        result    = condition.( [options, flow_options], **circuit_options )
+        condition = options[@path] # this allows dependency injection.
+        result    = condition.([options, flow_options], **circuit_options)
 
         options["policy.#{@name}"]        = result["policy"] # assign the policy as a skill.
         options["result.policy.#{@name}"] = result
@@ -20,7 +20,7 @@ class Trailblazer::Operation
         # flow control
         signal = result.success? ? Trailblazer::Activity::Right : Trailblazer::Activity::Left # since we & this, it's only executed OnRight and the return boolean decides the direction, input is passed straight through.
 
-        return signal, [ options, flow_options ]
+        return signal, [options, flow_options]
       end
     end
 
@@ -30,15 +30,13 @@ class Trailblazer::Operation
       name = options[:name]
       path = "policy.#{name}.eval"
 
-      task = Eval.new( name: name, path: path )
+      task = Eval.new(name: name, path: path)
 
-      extension = Trailblazer::Activity::TaskWrap::Merge.new(
-        Trailblazer::Operation::Wrap::Inject::Defaults(
-          path => condition
-        )
+      injection = Trailblazer::Activity::TaskWrap::Inject::Defaults::Extension(
+        path => condition
       )
 
-      { task: task, id: path, Trailblazer::Activity::DSL::Extension.new(extension) => true }
+      {task: task, id: path, extensions: [injection]}
     end
   end
 end

data/lib/trailblazer/{operation → macro}/pundit.rb

@@ -1,7 +1,7 @@
-class Trailblazer::Operation
+module Trailblazer::Macro
   module Policy
     def self.Pundit(policy_class, action, name: :default)
-      Policy.step( Pundit.build(policy_class, action), name: name )
+      Policy.step(Pundit.build(policy_class, action), name: name)
     end
 
     module Pundit
@@ -17,7 +17,7 @@ class Trailblazer::Operation
 
         # Instantiate the actual policy object, and call it.
         def call((options), *)
-          policy = build_policy(options)          # this translates to Pundit interface.
+          policy = build_policy(options) # this translates to Pundit interface.
           result!(policy.send(@action), policy)
         end
 
@@ -27,10 +27,10 @@ class Trailblazer::Operation
         end
 
         def result!(success, policy)
-          data = { "policy" => policy }
+          data = {"policy" => policy}
           data["message"] = "Breach" if !success # TODO: how to allow messages here?
 
-          Result.new(success, data)
+          Trailblazer::Operation::Result.new(success, data)
         end
       end
     end

data/lib/trailblazer/macro/rescue.rb

@@ -0,0 +1,44 @@
+module Trailblazer
+  module Macro
+    NoopHandler = lambda { |*| }
+
+    def self.Rescue(*exceptions, handler: NoopHandler, &block)
+      exceptions = [StandardError] unless exceptions.any?
+
+      handler    = Rescue.deprecate_positional_handler_signature(handler)
+      handler    = Trailblazer::Option(handler)
+
+      # This block is evaluated by {Wrap}.
+      rescue_block = ->((ctx, flow_options), **circuit_options, &nested_activity) do
+        begin
+          nested_activity.call
+        rescue *exceptions => exception
+          # DISCUSS: should we deprecate this signature and rather apply the Task API here?
+          handler.call(exception, ctx, **circuit_options) # FIXME: when there's an error here, it shows the wrong exception!
+
+          [Operation::Railway.fail!, [ctx, flow_options]]
+        end
+      end
+
+      Wrap(rescue_block, id: "Rescue(#{rand(100)})", &block)
+      # FIXME: name
+      # [ step, name: "Rescue:#{block.source_location.last}" ]
+    end
+
+    # TODO: remove me in 2.2.
+    module Rescue
+      def self.deprecate_positional_handler_signature(handler)
+        return handler if handler.is_a?(Symbol) # can't do nutting about this.
+
+        arity = handler.is_a?(Class) ? handler.method(:call).arity : handler.arity
+
+        return handler if arity != 2 # means (exception, (ctx, flow_options), *, &block), "new style"
+
+        ->(exception, (ctx, flow_options), **circuit_options, &block) do
+          warn "[Trailblazer] Rescue handlers have a new signature: (exception, *, &block)"
+          handler.(exception, ctx, &block)
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/macro/version.rb

@@ -1,5 +1,7 @@
 module Trailblazer
-  module Macro
-    VERSION = "2.1.0.rc1".freeze
+  module Version
+    module Macro
+      VERSION = "2.1.0.rc11".freeze
+    end
   end
 end

data/lib/trailblazer/macro/wrap.rb

@@ -0,0 +1,80 @@
+module Trailblazer
+  module Macro
+    def self.Wrap(user_wrap, id: "Wrap/#{rand(100)}", &block)
+      activity = Class.new(Activity::FastTrack, &block) # This is currently coupled to {dsl-linear}.
+
+      outputs  = activity.to_h[:outputs]
+      outputs  = Hash[outputs.collect { |output| [output.semantic, output] }] # TODO: make that a helper somewhere.
+
+      wrapped  = Wrap::Wrapped.new(activity, user_wrap, outputs)
+
+      {task: wrapped, id: id, outputs: outputs}
+    end
+
+    module Wrap
+      # behaves like an operation so it plays with Nested and simply calls the operation in the user-provided block.
+      class Wrapped
+        private def deprecate_positional_wrap_signature(user_wrap)
+          parameters = user_wrap.is_a?(Module) ? user_wrap.method(:call).parameters : user_wrap.parameters
+
+          return user_wrap if parameters[0] == [:req] # means ((ctx, flow_options), *, &block), "new style"
+
+          ->((ctx, flow_options), **circuit_options, &block) do
+            warn "[Trailblazer] Wrap handlers have a new signature: ((ctx), *, &block)"
+            user_wrap.(ctx, &block)
+          end
+        end
+
+        def initialize(operation, user_wrap, outputs)
+          user_wrap = deprecate_positional_wrap_signature(user_wrap)
+
+          @operation  = operation
+          @user_wrap  = user_wrap
+
+          # Since in the user block, you can return Railway.pass! etc, we need to map
+          # those to the actual wrapped operation's end.
+          @signal_to_output = {
+            Operation::Railway.pass!      => outputs[:success].signal,
+            Operation::Railway.fail!      => outputs[:failure].signal,
+            Operation::Railway.pass_fast! => outputs[:pass_fast].signal,
+            Operation::Railway.fail_fast! => outputs[:fail_fast].signal,
+            true               => outputs[:success].signal,
+            false              => outputs[:failure].signal,
+            nil                => outputs[:failure].signal,
+          }
+        end
+
+        def call((ctx, flow_options), **circuit_options)
+          block_calling_wrapped = -> {
+            call_wrapped_activity([ctx, flow_options], circuit_options)
+          }
+
+          # call the user's Wrap {} block in the operation.
+          # This will invoke block_calling_wrapped above if the user block yields.
+          returned = @user_wrap.([ctx, flow_options], **circuit_options, &block_calling_wrapped)
+
+          # {returned} can be
+          #   1. {circuit interface return} from the begin block, because the wrapped OP passed
+          #   2. {task interface return} because the user block returns "customized" signals, true of fale
+
+          if returned.is_a?(Array) # 1. {circuit interface return}, new style.
+            signal, (ctx, flow_options) = returned
+          else                     # 2. {task interface return}, only a signal (or true/false)
+            # TODO: deprecate this?
+            signal = returned
+          end
+
+          # Use the original {signal} if there's no mapping.
+          # This usually means signal is an End instance or a custom signal.
+          signal = @signal_to_output.fetch(signal, signal)
+
+          return signal, [ctx, flow_options]
+        end
+
+        def call_wrapped_activity((ctx, flow_options), **circuit_options)
+          @operation.to_h[:activity].([ctx, flow_options], **circuit_options) # :exec_context is this instance.
+        end
+      end
+    end # Wrap
+  end
+end