trailblazer 1.1.1 → 2.1.0

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

@@ -1,34 +0,0 @@
-require "trailblazer/operation/model"
-
-class Trailblazer::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/operation/model.rb

@@ -1,50 +0,0 @@
-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
-      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/operation/module.rb

@@ -1,29 +0,0 @@
-module Trailblazer::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/operation/policy/guard.rb

@@ -1,35 +0,0 @@
-module Trailblazer
-  # 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/operation/policy.rb

@@ -1,85 +0,0 @@
-require "trailblazer/operation/policy/guard"
-
-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.
-      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/operation/representer.rb

@@ -1,98 +0,0 @@
-# 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?]
-        )
-      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/operation/resolver.rb

@@ -1,30 +0,0 @@
-require "trailblazer/operation/model/external"
-require "trailblazer/operation/policy"
-
-class Trailblazer::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/operation/uploaded_file.rb

@@ -1,77 +0,0 @@
-require 'trailblazer/operation'
-require 'action_dispatch/http/upload'
-require 'tempfile'
-
-module Trailblazer
-  # TODO: document:
-  # to_hash
-  # from_hash
-  # initialize/tmp_dir
-  class Operation::UploadedFile
-    def initialize(uploaded, options={})
-      @uploaded = uploaded
-      @options  = options
-      @tmp_dir  = options[:tmp_dir]
-    end
-
-    def to_hash
-      path = persist!
-
-      hash = {
-        filename: @uploaded.original_filename,
-        type: @uploaded.content_type,
-        tempfile_path: path
-      }
-
-      cleanup!
-
-      hash
-    end
-
-    # Returns a ActionDispatch::Http::UploadedFile as if the upload was in the same request.
-    def self.from_hash(hash)
-      suffix = File.extname(hash[:filename])
-
-      # we need to create a Tempfile to make Http::UploadedFile work.
-      tmp  = Tempfile.new(["bla", suffix]) # always force file suffix to avoid problems with imagemagick etc.
-      file = File.open(hash[:tempfile_path])# doesn't close automatically :( # fixme: introduce strategy (Tempfile:=>slow, File:=> hopefully less memory footprint)
-      tmp.write(file.read) # DISCUSS: We need Tempfile.new(<File>) to avoid this slow and memory-consuming mechanics.
-
-      file.close # TODO: can we test that?
-      File.unlink(file)
-
-      ActionDispatch::Http::UploadedFile.new(hash.merge(tempfile: tmp))
-    end
-
-  private
-    attr_reader :tmp_dir
-
-     # convert Tempfile from Rails upload into persistent "temp" file so it is available in workers.
-    def persist!
-      path = @uploaded.path # original Tempfile path (from Rails).
-      path = path_with_tmp_dir(path)
-
-      path = path + "_trailblazer_upload"
-
-      FileUtils.mv(@uploaded.path, path) # move Rails upload file into persistent `path`.
-      path
-    end
-
-    def path_with_tmp_dir(path)
-      return path unless tmp_dir # if tmp_dir set, create path in it.
-
-      @with_tmp_dir = Tempfile.new(File.basename(path), tmp_dir)
-      @with_tmp_dir.path # use Tempfile to create nested dirs (os-dependent.)
-    end
-
-    def delete!(file)
-      file.close
-      file.unlink # the Rails uploaded file is already unlinked since moved.
-    end
-
-    def cleanup!
-      delete!(@uploaded.tempfile) if @uploaded.respond_to?(:tempfile) # this is Rails' uploaded file, not sure if we need to do that. in 3.2, we don't have UploadedFile#close, yet.
-      delete!(@with_tmp_dir) if @with_tmp_dir # we used that file to create a tmp file path below tmp_dir.
-    end
-  end
-end

data/lib/trailblazer/operation.rb

@@ -1,175 +0,0 @@
-require "reform"
-
-module Trailblazer
-  class Operation
-    require "trailblazer/operation/builder"
-    extend Builder # imports ::builder_class and ::build_operation.
-
-    extend Uber::InheritableAttr
-    inheritable_attr :contract_class
-    self.contract_class = Reform::Form.clone
-
-    class << self
-      def run(params, &block) # Endpoint behaviour
-        res, op = build_operation(params).run
-
-        if block_given?
-          yield op if res
-          return op
-        end
-
-        [res, op]
-      end
-
-      # Like ::run, but yield block when invalid.
-      def reject(*args)
-        res, op = run(*args)
-        yield op if res == false
-        op
-      end
-
-      # ::call only returns the Operation instance (or whatever was returned from #validate).
-      # This is useful in tests or in irb, e.g. when using Op as a factory and you already know it's valid.
-      def call(params)
-        build_operation(params, raise_on_invalid: true).run.last
-      end
-
-      def [](*args) # TODO: remove in 1.2.
-        warn "[Trailblazer] Operation[] is deprecated. Please use Operation.() and have a nice day."
-        call(*args)
-      end
-
-      # Runs #setup! but doesn't process the operation.
-      def present(params)
-        build_operation(params)
-      end
-
-      # This is a DSL method. Use ::contract_class and ::contract_class= for the explicit version.
-      #   Op.contract #=> returns contract class
-      #   Op.contract do .. end # defines contract
-      #   Op.contract CommentForm # copies (and subclasses) external contract.
-      #   Op.contract CommentForm do .. end # copies and extends contract.
-      def contract(constant=nil, &block)
-        return contract_class unless constant or block_given?
-
-        self.contract_class= Class.new(constant) if constant
-        contract_class.class_eval(&block) if block_given?
-      end
-    end
-
-
-    def initialize(params, options={})
-      @options          = options
-      @valid            = true
-
-      setup!(params) # assign/find the model
-    end
-
-    #   Operation.run(body: "Fabulous!") #=> [true, <Comment body: "Fabulous!">]
-    def run
-      process(@params)
-
-      [valid?, self]
-    end
-
-    attr_reader :model
-
-    def errors
-      contract.errors
-    end
-
-    def valid?
-      @valid
-    end
-
-    def contract(*args)
-      contract!(*args)
-    end
-
-  private
-    module Setup
-      attr_writer :model
-
-      def setup!(params)
-        params = assign_params!(params)
-        setup_params!(params)
-        build_model!(params)
-        params # TODO: test me.
-      end
-
-      def assign_params!(params)
-        @params = params!(params)
-      end
-
-      # Overwrite #params! if you need to change its structure, by returning a new params object
-      # from this method.
-      # This is helpful if you don't want to change the original via #setup_params!.
-      def params!(params)
-        params
-      end
-
-      def setup_params!(params)
-      end
-
-      def build_model!(*args)
-        assign_model!(*args) # @model = ..
-        setup_model!(*args)
-      end
-
-      def assign_model!(*args)
-        @model = model!(*args)
-      end
-
-      # Implement #model! to find/create your operation model (if required).
-      def model!(params)
-      end
-
-      # Override to add attributes that can be infered from params.
-      def setup_model!(params)
-      end
-    end
-    include Setup
-
-    def validate(params, model=nil, contract_class=nil)
-      contract!(model, contract_class)
-
-      if @valid = validate_contract(params)
-        yield contract if block_given?
-      else
-        raise!(contract)
-      end
-
-      @valid
-    end
-
-    def validate_contract(params)
-      contract.validate(params)
-    end
-
-    def invalid!(result=self)
-      @valid = false
-      result
-    end
-
-    # When using Op.(), an invalid contract will raise an exception.
-    def raise!(contract)
-      raise InvalidContract.new(contract.errors.to_s) if @options[:raise_on_invalid]
-    end
-
-    # Instantiate the contract, either by using the user's contract passed into #validate
-    # or infer the Operation contract.
-    def contract_for(model=nil, contract_class=nil)
-      model          ||= self.model
-      contract_class ||= self.class.contract_class
-
-      contract_class.new(model)
-    end
-
-    def contract!(*args)
-      @contract ||= contract_for(*args)
-    end
-
-    class InvalidContract < RuntimeError
-    end
-  end
-end