trailblazer 2.0.7 → 2.1.0

data/lib/trailblazer/dsl.rb

@@ -1,47 +0,0 @@
-module Trailblazer
-  module DSL
-    # Boring DSL code that allows to set a skill class, or define it ad-hoc using a block.
-    # passing a constant always wipes out the existing class.
-    #
-    # Used in Contract, Representer, Callback, ..
-    class Build
-      # options[:prefix]
-      # options[:class]
-      # options[:container]
-
-      # Currently, adds .class only to classes. this could break builder instances?
-
-      def call(options, name=nil, constant=nil, dsl_block, &block)
-        # contract MyForm
-        if name.is_a?(Class)
-          constant = name
-          name     = :default
-        end
-
-        is_instance = !(constant.kind_of?(Class) || dsl_block) # i don't like this magic too much, but since it's the only DSL method in TRB, it should be ok. # DISCUSS: options[:is_instance]
-
-        path = path_name(options[:prefix], name, is_instance ? nil : "class") # "contract.default.class"
-
-        if is_instance
-          skill = constant
-        else
-          extended = options[:container][path] # Operation["contract.default.class"]
-          extended = yield extended if extended && block_given?
-
-          # only extend an existing skill class when NO constant was passed.
-          constant = (extended || options[:class]) if constant.nil?# && block_given?
-
-          skill = Class.new(constant)
-          skill.class_eval(&dsl_block) if dsl_block
-        end
-
-        [path, skill]
-      end
-
-    private
-      def path_name(prefix, name, suffix)
-        [prefix, name, suffix].compact.join(".") # "contract.class" for default, otherwise "contract.params.class" etc.
-      end
-    end
-  end
-end

data/lib/trailblazer/operation/auto_inject.rb

@@ -1,47 +0,0 @@
-require "dry/auto_inject"
-
-class Trailblazer::Operation
-  # Thanks, @timriley! <3
-  # https://gist.github.com/timriley/d314a58da9784912159006e208ba8ea9
-  module AutoInject
-    class InjectStrategy < Module
-      ClassMethods = Class.new(Module)
-
-      attr_reader :container
-      attr_reader :dependency_map
-      attr_reader :class_mod
-
-      def initialize(container, *dependency_names)
-        @container = container
-        @dependency_map = Dry::AutoInject::DependencyMap.new(*dependency_names)
-        @class_mod = ClassMethods.new
-      end
-
-      def included(klass)
-        define_call
-
-        klass.singleton_class.prepend @class_mod
-
-        super
-      end
-
-      private
-
-      def define_call
-        class_mod.class_exec(container, dependency_map) do |container, dependency_map|
-          define_method :call do |params={}, options={}, *dependencies|
-            options_with_deps = dependency_map.to_h.each_with_object({}) { |(name, identifier), obj|
-              obj[name] = options[name] || container[identifier]
-            }.merge(options)
-
-            super(params, options_with_deps, *dependencies)
-          end
-        end
-      end
-    end
-  end
-
-  def self.AutoInject(container)
-    Dry::AutoInject(container, strategies: {default: AutoInject::InjectStrategy})
-  end
-end

data/lib/trailblazer/operation/callback.rb

@@ -1,35 +0,0 @@
-require "disposable/callback"
-
-class Trailblazer::Operation
-  def self.Callback(group)
-    step = ->(input, options) { Callback.(group, input, options) }
-
-    [ step, name: "callback.#{group}" ]
-  end
-
-  module Callback
-    def self.call(name=:default, operation, options)
-      config  = options["callback.#{name}.class"] || raise #.fetch(name) # TODO: test exception
-      group   = config[:group].new(options["contract.default"])
-
-      options[:context] ||= (config[:context] == :operation ? operation : group)
-      group.(options)
-
-      options["result.callback.#{name}"] = group
-    end
-
-    module DSL
-      def callback(name=:default, constant=nil, &block)
-        heritage.record(:callback, 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!
-        extended = self["callback.#{name}.class"] && self["callback.#{name}.class"]
-
-        path, group_class = Trailblazer::DSL::Build.new.({ prefix: :callback, class: Disposable::Callback::Group, container: self }, name, constant, block) { |extended| extended[:group] }
-
-        self[path] = { group: group_class, context: constant ? nil : :operation }
-      end
-    end
-  end
-end

data/lib/trailblazer/operation/contract.rb

@@ -1,46 +0,0 @@
-# Best practices for using contract.
-#
-# * inject contract instance via constructor to #contract
-# * allow contract setup and memo via #contract(model, options)
-# * allow implicit automatic setup via #contract and class.contract_class
-#
-# Needs Operation#model.
-# Needs #[], #[]= skill dependency.
-class Trailblazer::Operation
-  module Contract
-    def self.Build(name:"default", constant:nil, builder: nil)
-      step = ->(input, options) { Build.for(input, options, name: name, constant: constant, builder: builder) }
-
-      [ step, name: "contract.build" ]
-    end
-
-    module Build
-      # bla build contract at runtime.
-      def self.for(operation, options, name:"default", constant:nil, builder: nil)
-        # TODO: we could probably clean this up a bit at some point.
-        contract_class = constant || options["contract.#{name}.class"]
-        model          = options["model"] # FIXME: model.default
-        name           = "contract.#{name}"
-
-        return options[name] = Option::KW.(builder).(operation, options, constant: contract_class, name: name) if builder
-
-        options[name] = contract_class.new(model)
-      end
-    end
-
-    module DSL
-      # This is the class level DSL method.
-      #   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(name=:default, constant=nil, base: Reform::Form, &block)
-        heritage.record(:contract, name, constant, &block)
-
-        path, form_class = Trailblazer::DSL::Build.new.({ prefix: :contract, class: base, container: self }, name, constant, block)
-
-        self[path] = form_class
-      end
-    end # Contract
-  end
-end

data/lib/trailblazer/operation/guard.rb

@@ -1,18 +0,0 @@
-require "trailblazer/operation/policy"
-
-class Trailblazer::Operation
-  module Policy
-    def self.Guard(proc, name: :default, &block)
-      Policy.step(Guard.build(proc), name: name)
-    end
-
-    module Guard
-      def self.build(callable)
-        value = Option::KW.(callable) # Operation::Option
-
-        # this gets wrapped in a Operation::Result object.
-        ->(input, options) { Result.new( !!value.(input, options), {} ) }
-      end
-    end # Guard
-  end
-end

data/lib/trailblazer/operation/model.rb

@@ -1,60 +0,0 @@
-class Trailblazer::Operation
-  def self.Model(model_class, action=nil)
-    step = Model.for(model_class, action)
-
-    step = Pipetree::Step.new(step, "model.class" => model_class, "model.action" => action)
-
-    [ step, name: "model.build" ]
-  end
-
-  module Model
-    def self.for(model_class, action)
-      builder = Model::Builder.new
-
-      ->(input, options) do
-        options["model"] = model = builder.(options, options["params"])
-
-        options["result.model"] = result = Result.new(!model.nil?, {})
-
-        result.success?
-      end
-    end
-
-    class Builder
-      def call(options, params)
-        deprecate_update!(options)
-        action      = options["model.action"] || :new
-        model_class = options["model.class"]
-
-        action = :pass_through unless [:new, :find_by, :find].include?(action)
-
-        send("#{action}!", model_class, params, options["model.action"])
-      end
-
-      def new!(model_class, params, *)
-        model_class.new
-      end
-
-      def find!(model_class, params, *)
-        model_class.find(params[:id])
-      end
-
-      # Doesn't throw an exception and will return false to divert to Left.
-      def find_by!(model_class, params, *)
-        model_class.find_by(id: params[:id])
-      end
-
-      # Call any method on the model class and pass :id.
-      def pass_through!(model_class, params, action)
-        model_class.send(action, params[:id])
-      end
-
-    private
-      def deprecate_update!(options) # TODO: remove in 2.1.
-        return unless options["model.action"] == :update
-        options["model.action"] = :find
-        warn "[Trailblazer] Model( .., :update ) is deprecated, please use :find or :find_by."
-      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/nested.rb

@@ -1,113 +0,0 @@
-class Trailblazer::Operation
-  def self.Nested(callable, input:nil, output:nil)
-    step = Nested.for(callable, input, output)
-
-    [ step, { name: "Nested(#{callable})" } ]
-  end
-
-  # WARNING: this is experimental API, but it will end up with something like that.
-  module Element
-    # DISCUSS: add builders here.
-    def initialize(wrapped=nil)
-      @wrapped = wrapped
-    end
-
-    module Dynamic
-      def initialize(wrapped)
-        @wrapped = Option::KW.(wrapped)
-      end
-    end
-  end
-
-  module Nested
-    # Please note that the instance_variable_get are here on purpose since the
-    # superinternal API is not entirely decided, yet.
-    # @api private
-    def self.for(step, input, output, is_nestable_object=method(:nestable_object?)) # DISCUSS: use builders here?
-      invoker            = Caller::Dynamic.new(step)
-      invoker            = Caller.new(step) if is_nestable_object.(step)
-
-      options_for_nested = Options.new
-      options_for_nested = Options::Dynamic.new(input) if input
-
-      options_for_composer = Options::Output.new
-      options_for_composer = Options::Output::Dynamic.new(output) if output
-
-      # This lambda is the strut added on the track, executed at runtime.
-      ->(operation, options) do
-        result = invoker.(operation, options, options_for_nested.(operation, options)) # TODO: what about containers?
-
-        options_for_composer.(operation, options, result).each { |k,v| options[k] = v }
-
-        result.success? # DISCUSS: what if we could simply return the result object here?
-      end
-    end
-
-    def self.nestable_object?(object)
-      # interestingly, with < we get a weird nil exception. bug in Ruby?
-      object.is_a?(Class) && object <= Trailblazer::Operation
-    end
-
-    # Is executed at runtime and calls the nested operation.
-    class Caller
-      include Element
-
-      def call(input, options, options_for_nested)
-        call_nested(nested(input, options), options_for_nested)
-      end
-
-    private
-      def call_nested(operation, options)
-        operation._call(options)
-      end
-
-      def nested(*); @wrapped end
-
-      class Dynamic < Caller
-        include Element::Dynamic
-
-        def nested(input, options)
-          @wrapped.(input, options)
-        end
-      end
-    end
-
-    class Options
-      include Element
-
-      # Per default, only runtime data for nested operation.
-      def call(input, options)
-        options.to_runtime_data[0]
-      end
-
-      class Dynamic
-        include Element::Dynamic
-
-        def call(operation, options)
-          @wrapped.(operation, options, runtime_data: options.to_runtime_data[0], mutable_data: options.to_mutable_data )
-        end
-      end
-
-      class Output
-        include Element
-
-        def call(input, options, result)
-          mutable_data_for(result).each { |k,v| options[k] = v }
-        end
-
-        def mutable_data_for(result)
-          result.instance_variable_get(:@data).to_mutable_data
-        end
-
-        class Dynamic < Output
-          include Element::Dynamic
-
-          def call(input, options, result)
-            @wrapped.(input, options, mutable_data: mutable_data_for(result))
-          end
-        end
-      end
-    end
-  end
-end
-

data/lib/trailblazer/operation/persist.rb

@@ -1,10 +0,0 @@
-class Trailblazer::Operation
-  module Contract
-    def self.Persist(method: :save, name: "default")
-      path = "contract.#{name}"
-      step = ->(input, options) { options[path].send(method) }
-
-      [ step, name: "persist.save" ]
-    end
-  end
-end

data/lib/trailblazer/operation/policy.rb

@@ -1,35 +0,0 @@
-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.
-    class Eval
-      def initialize(name:nil, path:nil)
-        @name = name
-        @path = path
-      end
-
-      def call(input, options)
-        condition = options[@path] # this allows dependency injection.
-        result    = condition.(input, options)
-
-        options["policy.#{@name}"]        = result["policy"] # assign the policy as a skill.
-        options["result.policy.#{@name}"] = result
-
-        # 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
-
-    # Adds the `yield` result to the pipe and treats it like a
-    # policy-compatible  object at runtime.
-    def self.step(condition, options, &block)
-      name = options[:name]
-      path = "policy.#{name}.eval"
-
-      step = Eval.new( name: name, path: path )
-      step = Pipetree::Step.new(step, path => condition)
-
-      [ step, name: path ]
-    end
-  end
-end