trailblazer 1.1.2 → 2.0.0.beta1

data/lib/trailblazer/operation/guard.rb

@@ -0,0 +1,24 @@
+require "trailblazer/operation/policy"
+require "uber/option"
+
+class Trailblazer::Operation
+  module Policy
+    module Guard
+      def self.import!(operation, import, user_proc, options={})
+        Policy.add!(operation, import, options) { Guard.build(user_proc) }
+      end
+
+      def self.build(callable)
+        value = Uber::Option[callable]
+
+        # call'ing the Uber::Option will run either proc or block.
+        # this gets wrapped in a Operation::Result object.
+        ->(options) { Result.new( !!value.(options), {} ) }
+      end
+    end # Guard
+
+    def self.Guard(*args, &block)
+      [ Guard, args, block ]
+    end
+  end
+end

data/lib/trailblazer/operation/model.rb

@@ -1,50 +1,58 @@
-require "trailblazer/operation/model/dsl"
-
-module Trailblazer
-  class Operation
-    # The Model module will automatically create/find models for the configured +action+.
-    # It adds a public  +Operation#model+ reader to access the model (after performing).
-    module Model
-      def self.included(base)
-        base.extend DSL
+class Trailblazer::Operation
+  module Model
+    Step = ->(operation, options) { options["model"] = operation.model!(options["params"]) }
+
+    def self.import!(operation, import, model_class, action=nil)
+      if import.inheriting? # not sure how to do overrides!
+        # FIXME: prototyping inheritance. should we handle that here?
+        return operation["model.action"] = model_class
       end
 
-      # Methods to create the model according to class configuration and params.
-      module BuildModel
-        def model!(params)
-          instantiate_model(params)
-        end
+      import.(:&, Step, name: "model.build")
 
-        def instantiate_model(params)
-          send("#{action_name}_model", params)
-        end
+      operation["model.class"] = model_class
+      operation["model.action"] = action
 
-        def create_model(params)
-          model_class.new
-        end
+      operation.send :include, BuildMethods
+    end
 
-        def update_model(params)
-          model_class.find(params[:id])
-        end
+    # Methods to create the model according to class configuration and params.
+    module BuildMethods
+      def model_class
+        self["model.class"] or raise "[Trailblazer] You didn't call Operation::model."
+      end
 
-        alias_method :find_model, :update_model
+      def action_name
+        self["model.action"] or :new
       end
 
+      def model!(params)
+        instantiate_model(params)
+      end
 
-      # #validate no longer accepts a model since this module instantiates it for you.
-      def validate(params, model=self.model, *args)
-        super(params, model, *args)
+      def instantiate_model(params)
+        send("#{action_name}_model", params)
       end
 
-    private
-      include BuildModel
+      def new_model(params)
+        model_class.new
+      end
 
-      def model_class
-        self.class.model_class
+      def update_model(params)
+        model_class.find(params[:id])
       end
-      def action_name
-        self.class.action_name
+
+      alias_method :find_model, :update_model
+
+      # Doesn't throw an exception and will return false to divert to Left.
+      def find_by_model(params)
+        model = model_class.find_by(id: params[:id])
+
+        self["result.model"] = Result.new(!model.nil?, {})
+        model
       end
     end
   end
+
+  DSL.macro!(:Model, Model)
 end

data/lib/trailblazer/operation/nested.rb

@@ -0,0 +1,43 @@
+class Trailblazer::Operation
+  module Nested
+    # Please note that the instance_variable_get are here on purpose since the
+    # superinternal API is not entirely decided, yet.
+    def self.import!(operation, import, step)
+      import.(:&, ->(input, options) {
+        result = step._call(*options.to_runtime_data)
+
+        result.instance_variable_get(:@data).to_mutable_data.each do |k,v|
+          options[k] = v
+        end
+
+        result.success? # DISCUSS: what if we could simply return the result object here?
+      }, {} )
+    end
+  end
+
+  DSL.macro!(:Nested, Nested)
+
+  module Rescue
+    def self.import!(_operation, import, *exceptions, handler:->(*){}, &block)
+      exceptions = [StandardError] unless exceptions.any?
+      handler    = Pipetree::DSL::Option.(handler)
+
+      rescue_block = ->(options, operation, *, &nested_pipe) {
+        begin
+          res = nested_pipe.call
+          res.first == ::Pipetree::Flow::Right # FIXME.
+        rescue *exceptions => exception
+          handler.call(operation, exception, options)
+          #options["result.model.find"] = "argh! because #{exception.class}"
+          false
+        end
+      }
+
+      # operation.| operation.Wrap(rescue_block, &block), name: "Rescue:#{block.source_location.last}"
+      Wrap.import! _operation, import, rescue_block, name: "Rescue:#{block.source_location.last}", &block
+    end
+  end
+
+  DSL.macro!(:Rescue, Rescue)
+end
+

data/lib/trailblazer/operation/params.rb

@@ -0,0 +1,13 @@
+class Trailblazer::Operation
+  module Params
+    def self.included(includer)
+      includer.> Replace, after: New
+    end
+  end
+
+  # Returned object will replace "params". Original is saved in "params.original".
+  Params::Replace = ->(input, options) {
+    options["params.original"] = original = options["params"]
+     options["params"] = input.params!(original)
+   }
+end

data/lib/trailblazer/operation/persist.rb

@@ -0,0 +1,13 @@
+class Trailblazer::Operation
+  module Persist
+    def self.import!(operation, import, options={})
+      save_method   = options[:method] || :save
+      contract_name = options[:name] || "contract.default"
+
+      import.(:&, ->(input, options) { options[contract_name].send(save_method) }, # TODO: test me.
+        name: "persist.save")
+    end
+  end
+
+  DSL.macro!(:Persist, Persist)
+end

data/lib/trailblazer/operation/policy.rb

@@ -1,85 +1,39 @@
-require "trailblazer/operation/policy/guard"
+class Trailblazer::Operation
+  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.
+    # :private:
+    class Eval
+      include Uber::Callable
 
-module Trailblazer
-  class NotAuthorizedError < RuntimeError
-  end
-
-  # Adds #evaluate_policy to #setup!, and ::policy.
-  module Operation::Policy
-    def self.included(includer)
-      includer.extend DSL
-    end
-
-    module DSL
-      def self.extended(extender)
-        extender.inheritable_attr :policy_config
-        extender.policy_config = lambda { |*| true } # return true per default.
+      def initialize(name:nil, path:nil)
+        @name = name
+        @path = path
       end
 
-      def policy(*args, &block)
-        self.policy_config = permission_class.new(*args, &block)
-      end
+      def call(input, options)
+        condition = options[@path] # this allows dependency injection.
+        result    = condition.(options)
 
-      def permission_class
-        Permission
-      end
-    end
+        options["policy.#{@name}"]        = result["policy"] # assign the policy as a skill.
+        options["result.policy.#{@name}"] = result
 
-    attr_reader :policy
-
-  private
-    module Setup
-      def setup!(params)
-        evaluate_policy(super)
+        # flow control
+        result.success? # since we & this, it's only executed OnRight and the return boolean decides the direction, input is passed straight through.
       end
     end
-    include Setup
-
-    def evaluate_policy(params)
-      user = params[:current_user]
 
-      @policy = self.class.policy_config.(user, model, @policy) do |policy, action|
-        raise policy_exception(policy, action, model)
-      end
-    end
+    # Adds the `yield` result to the pipe and treats it like a policy-compatible object at runtime.
+    def self.add!(operation, import, options)
+      name = options[:name] || :default
 
-    def policy_exception(policy, action, model)
-      NotAuthorizedError.new(query: action, record: model, policy: policy)
-    end
+      # configure class level.
+      operation[path = "policy.#{name}.eval"] = yield
 
-    # Encapsulate building the Policy object and calling the defined query action.
-    # This assumes the policy class is "pundit-style", as in Policy.new(user, model).edit?.
-    class Permission
-      def initialize(policy_class, action)
-        @policy_class, @action = policy_class, action
-      end
-
-      # Without a block, return the policy object (which is usually a Pundit-style class).
-      # When block is passed evaluate the default rule and run block when false.
-      def call(user, model, external_policy=nil)
-        policy = build_policy(user, model, external_policy)
-
-        policy.send(@action) || yield(policy, @action) if block_given?
-        policy
-      end
-
-    private
-      def build_policy(user, model, policy)
-        policy or @policy_class.new(user, model)
-      end
-    end
-  end
-
-
-  module Operation::Deny
-    def self.included(includer)
-      includer.extend ClassMethods
-    end
-
-    module ClassMethods
-      def deny!
-        raise NotAuthorizedError
-      end
+      # add step.
+      import.(:&, Eval.new( name: name, path: path ),
+        name: path
+      )
     end
   end
 end

data/lib/trailblazer/operation/present.rb

@@ -0,0 +1,19 @@
+class Trailblazer::Operation
+  module Present
+    def self.included(includer)
+      includer.extend PresentMethod
+      includer.& Stop, before: Call
+    end
+
+    module PresentMethod
+      def present(params={}, options={}, *args)
+        call(params, options.merge("present.stop?" => true), *args)
+      end
+    end
+  end
+
+  # Stops the pipeline if "present.stop?" is set, which usually happens in Operation::present.
+  Present::Stop = ->(input, options) { ! options["present.stop?"] } # false returns Left.
+end
+
+# TODO: another stop for present without the contract!

data/lib/trailblazer/operation/procedural/contract.rb

@@ -0,0 +1,15 @@
+module Trailblazer::Operation::Procedural
+  # THIS IS UNTESTED, PRIVATE API AND WILL BE REMOVED SOON.
+  module Contract
+    # Instantiate the contract, either by using the user's contract passed into #validate
+    # or infer the Operation contract.
+    def contract_for(model:self["model"], options:{}, contract_class:self["contract.default.class"])
+      contract!(model: model, options: options, contract_class: contract_class)
+    end
+
+    # Override to construct your own contract.
+    def contract!(model:nil, options:{}, contract_class:nil)
+      contract_class.new(model, options)
+    end
+  end
+end

data/lib/trailblazer/operation/procedural/validate.rb

@@ -0,0 +1,22 @@
+module Trailblazer::Operation::Procedural
+  module Validate
+    def validate(params, contract:self["contract.default"], path:"contract.default") # :params
+      # DISCUSS: should we only have path here and then look up contract ourselves?
+      result = validate_contract(contract, params) # run validation.  # FIXME: must be overridable.
+
+      self["result.#{path}"] = result
+
+      if valid = result.success? # FIXME: to_bool or success?
+        yield result if block_given?
+      else
+        # self["errors.#{path}"] = result.errors # TODO: remove me
+      end
+
+      valid
+    end
+
+    def validate_contract(contract, params)
+      contract.(params)
+    end
+  end
+end

data/lib/trailblazer/operation/pundit.rb

@@ -0,0 +1,42 @@
+class Trailblazer::Operation
+  module Policy
+    module Pundit
+      def self.import!(operation, import, policy_class, action, options={})
+        Policy.add!(operation, import, options) { Pundit.build(policy_class, action) }
+      end
+
+      def self.build(*args, &block)
+        Condition.new(*args, &block)
+      end
+
+      # Pundit::Condition is invoked at runtime when iterating the pipe.
+      class Condition
+        def initialize(policy_class, action)
+          @policy_class, @action = policy_class, action
+        end
+
+        # Instantiate the actual policy object, and call it.
+        def call(skills)
+          policy = build_policy(skills)          # this translates to Pundit interface.
+          result!(policy.send(@action), policy)
+        end
+
+      private
+        def build_policy(skills)
+          @policy_class.new(skills["current_user"], skills["model"])
+        end
+
+        def result!(success, policy)
+          data = { "policy" => policy }
+          data["message"] = "Breach" if !success # TODO: how to allow messages here?
+
+          Result.new(success, data)
+        end
+      end
+    end
+
+    def self.Pundit(*args, &block)
+      [ Pundit, args, block ]
+    end
+  end
+end

data/lib/trailblazer/operation/representer.rb

@@ -1,98 +1,31 @@
-# Including this will change the way deserialization in #validate works.
-#
-# Instead of treating params as a hash and letting the form object deserialize it,
-# a representer will be infered from the contract. This representer is then passed as
-# deserializer into Form#validate.
-#
-# TODO: so far, we only support JSON, but it's two lines to change to support any kind of format.
-module Trailblazer::Operation::Representer
-  def self.included(base)
-    base.extend DSL
-  end
-
-  module DSL
-    def self.extended(extender)
-      extender.inheritable_attr :_representer_class
-    end
-
-    def representer(constant=nil, &block)
-      return representer_class unless constant or block_given?
-
-      self.representer_class= Class.new(constant) if constant
-      representer_class.class_eval(&block) if block_given?
-    end
-
-    def representer_class
-      self._representer_class ||= infer_representer_class
-    end
-
-    def representer_class=(constant)
-      self._representer_class = constant
-    end
-
-    require "disposable/version"
-    def infer_representer_class
-      if Disposable::VERSION =~ /^0.1/
-        warn "[Trailblazer] Reform 2.0 won't be supported in Trailblazer 1.2. Don't be lazy and upgrade to Reform 2.1."
-
-        Disposable::Twin::Schema.from(contract_class,
-          include:          [Representable::JSON],
-          options_from:     :deserializer, # use :instance etc. in deserializer.
-          superclass:       Representable::Decorator,
-          representer_from: lambda { |inline| inline.representer_class },
-        )
-      else
-        Disposable::Rescheme.from(contract_class,
-          include:          [Representable::JSON],
-          options_from:     :deserializer, # use :instance etc. in deserializer.
-          superclass:       Representable::Decorator,
-          definitions_from: lambda { |inline| inline.definitions },
-          exclude_options:  [:default, :populator], # TODO: test with populator: in an operation.
-          exclude_properties: [:persisted?]
-        )
+class Trailblazer::Operation
+  module Representer
+    def self.infer(contract_class, format:Representable::JSON)
+      Disposable::Rescheme.from(contract_class,
+        include:          [format],
+        options_from:     :deserializer, # use :instance etc. in deserializer.
+        superclass:       Representable::Decorator,
+        definitions_from: lambda { |inline| inline.definitions },
+        exclude_options:  [:default, :populator], # TODO: test with populator: in an operation.
+        exclude_properties: [:persisted?]
+      )
+    end
+
+    module DSL
+      def representer(name=:default, constant=nil, &block)
+        heritage.record(:representer, name, constant, &block)
+
+        # FIXME: make this nicer. we want to extend same-named callback groups.
+        # TODO: allow the same with contract, or better, test it!
+        path, representer_class = Trailblazer::DSL::Build.new.({ prefix: :representer, class: representer_base_class, container: self }, name, constant, block)
+
+        self[path] = representer_class
       end
-    end
-  end
-
-private
-  module Rendering
-    # Override this if you need to pass options to the rendering.
-    #
-    #   def to_json(*)
-    #     super(include: @params[:include])
-    #   end
-    def to_json(options={})
-      self.class.representer_class.new(represented).to_json(options)
-    end
-
-    # Override this if you want to render something else, e.g. the contract.
-    def represented
-      model
-    end
-  end
-  include Rendering
-
-
-  module Deserializer
-    module Hash
-      def validate_contract(params)
-        # use the inferred representer from the contract for deserialization in #validate.
-        contract.validate(params) do |document|
-          self.class.representer_class.new(contract).from_hash(document)
-        end
-      end
-    end
 
-    # This looks crazy, but all it does is using a Reform hook in #validate where we can use
-    # our own representer for deserialization. After the object graph is set up, Reform will
-    # run its validation without even knowing this came from JSON.
-    module JSON
-      def validate_contract(params)
-        contract.validate(params) do |document|
-          self.class.representer_class.new(contract).from_json(document)
-        end
+      # TODO: make engine configurable?
+      def representer_base_class
+        Class.new(Representable::Decorator) { include Representable::JSON; self }
       end
     end
   end
-  include Deserializer::JSON
 end