trailblazer-compat 0.1.0

data/lib/trailblazer/1.1/operation/controller/active_record.rb

@@ -0,0 +1,21 @@
+# Assigns an additional instance variable for +@model+ named after the model's table name (e.g. @comment).
+#
+# THIS MODULE IS DEPRECATED!
+#
+# Please don't use this module. Instead, use @model in your controller or pass the
+# operation instance to a cell to present it.
+module Trailblazer::V1_1::Operation::Controller::ActiveRecord
+private
+  def setup_operation_instance_variables!(operation, options)
+    super
+    instance_variable_set(:"@#{operation_model_name}", @model)
+  end
+
+  def operation_model_name
+    # set the right variable name if collection
+    if @operation.is_a?(Trailblazer::Operation::Collection)
+      return @model.model.table_name.split(".").last
+    end
+    @model.class.table_name.split(".").last.singularize
+  end
+end

data/lib/trailblazer/1.1/operation/dispatch.rb

@@ -0,0 +1,3 @@
+require "trailblazer/1.1/operation/callback"
+# TODO: deprecate this module.
+Trailblazer::V1_1::Operation::Dispatch = Trailblazer::V1_1::Operation::Callback

data/lib/trailblazer/1.1/operation/model.rb

@@ -0,0 +1,50 @@
+require "trailblazer/1.1/operation/model/dsl"
+
+module Trailblazer::V1_1
+  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
+      end
+
+      # Methods to create the model according to class configuration and params.
+      module BuildModel
+        def model!(params)
+          instantiate_model(params)
+        end
+
+        def instantiate_model(params)
+          send("#{action_name}_model", params)
+        end
+
+        def create_model(params)
+          model_class.new
+        end
+
+        def update_model(params)
+          model_class.find(params[:id])
+        end
+
+        alias_method :find_model, :update_model
+      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)
+      end
+
+    private
+      include BuildModel
+
+      def model_class
+        self.class.model_class
+      end
+      def action_name
+        self.class.action_name
+      end
+    end
+  end
+end

data/lib/trailblazer/1.1/operation/model/active_model.rb

@@ -0,0 +1,11 @@
+module Trailblazer::V1_1
+  module Operation::Model
+    # Automatically set model_name on operation's contract.
+    module ActiveModel
+      def contract(*, &block)
+        super
+        contract_class.model(model_class) # this assumes that Form::ActiveModel is mixed in.
+      end
+    end
+  end
+end

data/lib/trailblazer/1.1/operation/model/dsl.rb

@@ -0,0 +1,29 @@
+class Trailblazer::V1_1::Operation
+  module Model
+    # Imports ::model and ::action into an operation.
+    module DSL
+      def self.extended(extender)
+        extender.extend Uber::InheritableAttr
+        extender.inheritable_attr :config
+        extender.config = {}
+      end
+
+      def model(name, action=nil)
+        self.config[:model] = name
+        action(action) if action # coolest line ever.
+      end
+
+      def action(name)
+        self.config[:action] = name
+      end
+
+      def action_name # considered private.
+        self.config[:action] or :create
+      end
+
+      def model_class # considered private.
+        self.config[:model] or raise "[Trailblazer] You didn't call Operation::model."
+      end
+    end
+  end
+end

data/lib/trailblazer/1.1/operation/model/external.rb

@@ -0,0 +1,34 @@
+require "trailblazer/1.1/operation/model"
+
+class Trailblazer::V1_1::Operation
+  module Model
+    # Builds (finds or creates) the model _before_ the operation is instantiated.
+    # Passes the model instance into the builder with the following signature.
+    #
+    #   builds ->(model, params)
+    #
+    # The initializer will now expect you to pass the model in via options[:model]. This
+    # happens automatically when coming from a builder.
+    module External
+      def self.included(includer)
+        includer.extend Model::DSL
+        includer.extend Model::BuildModel
+        includer.extend ClassMethods
+      end
+
+      def assign_model!(*) # i don't like to "disable" the `@model =` like this but it's the simplest for now.
+        @model = @options[:model]
+      end
+
+
+      module ClassMethods
+      private
+        def build_operation(params, options={}) # TODO: merge with Resolver::build_operation.
+          model = model!(params)
+          build_operation_class(model, params). # calls builds->(model, params).
+            new(params, options.merge(model: model))
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/1.1/operation/module.rb

@@ -0,0 +1,29 @@
+module Trailblazer::V1_1::Operation::Module
+  def self.included(base)
+    base.extend ClassMethods
+    base.extend Included
+  end
+
+  module Included # TODO: use representable's inheritance mechanism.
+    def included(base)
+      super
+      instructions.each { |cfg|
+        method  = cfg[0]
+        args    = cfg[1].dup
+        block   = cfg[2]
+        # options = args.extract_options!.dup # we need to duplicate options has as AM::Validations messes it up later.
+
+        base.send(method, *args, &block) } # property :name, {} do .. end
+    end
+  end
+
+  module ClassMethods
+    def method_missing(method, *args, &block)
+      instructions << [method, args, block]
+    end
+
+    def instructions
+      @instructions ||= []
+    end
+  end
+end

data/lib/trailblazer/1.1/operation/policy.rb

@@ -0,0 +1,85 @@
+require "trailblazer/1.1/operation/policy/guard"
+
+module Trailblazer::V1_1
+  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.
+      end
+
+      def policy(*args, &block)
+        self.policy_config = permission_class.new(*args, &block)
+      end
+
+      def permission_class
+        Permission
+      end
+    end
+
+    attr_reader :policy
+
+  private
+    module Setup
+      def setup!(params)
+        evaluate_policy(super)
+      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
+
+    def policy_exception(policy, action, model)
+      NotAuthorizedError.new(query: action, record: model, policy: policy)
+    end
+
+    # 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
+    end
+  end
+end

data/lib/trailblazer/1.1/operation/policy/guard.rb

@@ -0,0 +1,35 @@
+module Trailblazer::V1_1
+  # Policy::Guard is a very simple policy implementation.
+  # It adds #evaluate_policy to Operation#setup! and calls whatever
+  # you provided to ::policy.
+  #
+  # http://trailblazer.to/gems/operation/policy.html#guard
+  module Operation::Policy
+    module Guard
+      def self.included(includer)
+        includer.extend(DSL) # Provides ::policy(CallableObject)
+        includer.extend(ClassMethods)
+        includer.send(:include, Setup)
+      end
+
+      module ClassMethods
+        def policy(callable=nil, &block)
+          self.policy_config = Uber::Options::Value.new(callable || block)
+        end
+      end
+
+      def evaluate_policy(params)
+        call_policy(params) or raise policy_exception
+      end
+
+      # Override if you want your own policy invocation, e.g. with more args.
+      def call_policy(params)
+        self.class.policy_config.(self, params)
+      end
+
+      def policy_exception
+        NotAuthorizedError.new
+      end
+    end
+  end
+end

data/lib/trailblazer/1.1/operation/representer.rb

@@ -0,0 +1,98 @@
+# 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::V1_1::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?]
+        )
+      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
+      end
+    end
+  end
+  include Deserializer::JSON
+end

data/lib/trailblazer/1.1/operation/resolver.rb

@@ -0,0 +1,30 @@
+require "trailblazer/1.1/operation/model/external"
+require "trailblazer/1.1/operation/policy"
+
+class Trailblazer::V1_1::Operation
+  # Provides builds-> (model, policy, params).
+  module Resolver
+    def self.included(includer)
+      includer.class_eval do
+        include Policy # ::build_policy
+        include Model::External # ::build_operation_class
+
+        extend BuildOperation # ::build_operation
+      end
+    end
+
+    module BuildOperation
+      def build_operation(params, options={})
+        model  = model!(params)
+        policy = policy_config.call(params[:current_user], model)
+        build_operation_class(model, policy, params).
+          new(params, options.merge(model: model, policy: policy))
+      end
+    end
+
+    def initialize(params, options)
+      @policy = options[:policy]
+      super
+    end
+  end
+end

data/lib/trailblazer/1.1/operation/responder.rb

@@ -0,0 +1,18 @@
+module Trailblazer::V1_1::Operation::Responder
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def model_name
+      model_class.model_name
+    end
+  end
+
+  extend Forwardable
+  def_delegators :@model, :to_param, :destroyed?, :persisted?
+
+  def to_model
+    @model
+  end
+end