trailblazer 2.1.0.rc1 → 2.1.0.rc12

data/lib/trailblazer/deprecation/call.rb

@@ -1,46 +0,0 @@
-module Trailblazer
-  module Deprecation
-    module Operation
-      # This is super hacky. Fix you call calls everywhere (shouldn't take too long) and never load this file, again.
-      module Call
-        def self.options_for_call(params, *containers)
-          if containers == []
-            if params.is_a?(Hash) # this means we assume everything is cool. Create.( {...} )
-
-            else # this means someone did Create.( #<WeirdParamsObject> )
-              deprecate_positional_params(params, *containers)
-              return { params: params }, *containers
-            end
-          else # Create.( params, "current_user" => ... )
-            options, containers = containers[0], (containers[1..-1] || [])
-            if options.is_a?(Hash) # old API
-              warn "[Trailblazer] Please don't pass the `params` object as a positional argument into `Operation.()`, use the `:params` key and one hash for all: `Operation.( params: my_params, current_user: ... )` ."
-              return options.merge( params: params ), *containers
-            end
-          end
-
-          return params, *containers
-        end
-
-        def self.deprecate_positional_params(params, *containers)
-          warn "[Trailblazer] Please don't pass the `params` object as a positional argument into `Operation.()`, use the `:params` key: `Operation.( params: my_params )` ."
-        end
-      end
-    end
-  end
-end
-
-Trailblazer::Operation.module_eval do
-  # this sucks:
-  def self.call(options={}, *containers)
-    options, *containers = Trailblazer::Deprecation::Operation::Call.options_for_call(options, *containers)
-
-    ctx = Trailblazer::Operation::PublicCall.options_for_public_call(options, *containers)
-
-    # call the activity.
-    last_signal, (options, flow_options) = __call__( [ctx, {}] ) # Railway::call # DISCUSS: this could be ::call_with_context.
-
-    # Result is successful if the activity ended with an End event derived from Railway::End::Success.
-    Trailblazer::Operation::Railway::Result(last_signal, options, flow_options)
-  end
-end

data/lib/trailblazer/deprecation/context.rb

@@ -1,43 +0,0 @@
-module Trailblazer
-  module Deprecation
-    class ContextWithIndifferentAccess < Trailblazer::Context
-      def [](key)
-        return super unless Trailblazer::Operation::PublicCall.deprecatable?(key)
-        key, _ = Trailblazer::Operation::PublicCall.deprecate_string(key, nil)
-        super(key)
-      end
-
-      def []=(key, value)
-        return super unless Trailblazer::Operation::PublicCall.deprecatable?(key)
-        key, _ = Trailblazer::Operation::PublicCall.deprecate_string(key, nil)
-        super(key, value)
-      end
-    end
-  end
-end
-
-Trailblazer::Operation::PublicCall.module_eval do
-  def self.options_for_public_call(options={}, *containers)
-    hash_transformer = ->(containers) { containers[0].to_hash } # FIXME: don't transform any containers into kw args.
-
-    options = deprecate_strings(options)
-
-    immutable_options = Trailblazer::Context::ContainerChain.new( [options, *containers], to_hash: hash_transformer ) # Runtime options, immutable.
-
-    Trailblazer::Deprecation::ContextWithIndifferentAccess.new(immutable_options, {})
-  end
-
-  def self.deprecatable?(key)
-    key.is_a?(String) && key.split(".").size == 1
-  end
-
-  def self.deprecate_strings(options)
-    ary = options.collect { |k,v| deprecatable?(k) ? deprecate_string(k, v) : [k,v]  }
-    Hash[ary]
-  end
-
-  def self.deprecate_string(key, value)
-    warn "[Trailblazer] Using a string key for non-namespaced keys is deprecated. Please use `:#{key}` instead of `#{key.inspect}`."
-    [ key.to_sym, value ]
-  end
-end

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_with_public_interface do |ctx={}, *dependencies|
-            ctx_with_deps = dependency_map.to_h.each_with_object({}) { |(name, identifier), obj|
-              obj[name] = ctx[name] || container[identifier]
-            }.merge(ctx)
-
-            super(ctx_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/deprecations.rb

@@ -1,21 +0,0 @@
-module Trailblazer
-  class Operation
-    class DeprecatedOptions < Option
-      def self.call!(proc, direction, options, flow_options, *args)
-        if proc.is_a?(Proc) && proc.arity == 1
-          deprecate(proc)
-          proc.(options)
-        elsif proc.method(:call).arity == 1
-          deprecate(proc)
-          proc.(options)
-        else
-          super
-        end
-      end
-
-      def self.deprecate(proc)
-        warn "[Trailblazer] Please use the step API `def my_step!(options, **)` for your step: #{proc}"
-      end
-    end # DeprecatedOptions
-  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/test.rb

@@ -1,17 +0,0 @@
-module Trailblazer
-  module Test
-    module Run
-      # DISCUSS: use Endpoint here?
-      # DISCUSS: use Controller code here?
-      module_function
-      def run(operation_class, *args)
-        result = operation_class.(*args)
-
-        raise "[Trailblazer] #{operation_class} wasn't run successfully. #{result.inspect}" if result.failure?
-
-        result
-
-      end
-    end
-  end
-end

data/test/benchmark.rb

@@ -1,63 +0,0 @@
-require "test_helper"
-
-require "benchmark/ips"
-
-
-def positional_vs_decompose
-  arg = [ [1, 2], 3 ]
-
-  def a((one, two), three)
-    one + two + three
-  end
-
-  def b(arr, three)
-    arr[0] + arr[1] + three
-  end
-
-  Benchmark.ips do |x|
-    x.report("decompose") { a(*arg) }
-    x.report("positional") { b(*arg) }
-    x.compare!
-  end
-
-  #  decompose      5.646M (± 3.1%) i/s -     28.294M in   5.015759s
-  # positional      5.629M (± 8.0%) i/s -     28.069M in   5.029745s
-end
-
-# positional_vs_decompose
-
-##########################################################
-
-class Callable
-  def initialize(proc, i)
-    @proc = proc
-    @i = i
-  end
-
-  def call(args)
-    @proc.(@i, args)
-  end
-end
-
-def scoped(proc, i)
-  ->(args) { proc.(i, args) }
-end
-
-def object_vs_method_scope
-  proc = ->(i, args) { i + args }
-
-  callable = Callable.new(proc, 2)
-  scoped  = scoped(proc, 2)
-
-  Benchmark.ips do |x|
-    x.report("callable") { callable.(1) }
-    x.report("scoped")   { scoped.(1) }
-    x.compare!
-  end
-end
-
-object_vs_method_scope
-
-# Comparison:
-#             callable:  4620906.3 i/s
-#               scoped:  3388535.6 i/s - 1.36x  slower

data/test/deprecation/call_test.rb

@@ -1,42 +0,0 @@
-require "test_helper"
-
-require "trailblazer/deprecation/context"
-require "trailblazer/deprecation/call"
-
-class DeprecationCallTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step :create_model
-
-    def create_model(options, params:, **)
-      options["model"] = params.inspect
-      options[:user] = options["current_user"]
-    end
-  end
-
-  it "works with correct style" do
-    result = Create.( params: { title: "Hello" } )
-    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:false ["{:title=>\\\"Hello\\\"}", nil, nil, {:title=>\"Hello\"}] >}
-  end
-
-  it "works with correct style plus dependencies" do
-    result = Create.( params: { title: "Hello" }, current_user: Object )
-    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:true ["{:title=>\\\"Hello\\\"}", Object, Object, {:title=>\"Hello\"}] >}
-  end
-
-  it "converts old positional style" do
-    result = Create.( { title: "Hello" }, "current_user" => user=Object )
-    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:true ["{:title=>\\\"Hello\\\"}", Object, Object, {:title=>\"Hello\"}] >}
-  end
-
-  class WeirdStrongParameters < Hash
-  end
-
-  it "converts old positional style with StrongParameters" do
-    params = WeirdStrongParameters.new
-    params[:title] = "Hello"
-
-    result = Create.( params, "current_user" => user=Object )
-
-    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:true ["{:title=>\\\"Hello\\\"}", Object, Object, {:title=>\"Hello\"}] >}
-  end
-end

data/test/deprecation/context_test.rb

@@ -1,19 +0,0 @@
-require "test_helper"
-
-require "trailblazer/deprecation/context"
-
-class DeprecationContextTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step :create_model
-
-    def create_model(options, params:, **)
-      options["model"] = params.inspect
-      options[:user] = options["current_user"]
-    end
-  end
-
-  it do
-    result = Create.( "params"=> {title: "Hello"}, "current_user" => user=Object)
-    result.inspect(:model, :user, :current_user, :params).must_equal %{<Result:true ["{:title=>\\\"Hello\\\"}", Object, Object, {:title=>\"Hello\"}] >}
-  end
-end

data/test/docs/auto_inject_test.rb

@@ -1,37 +0,0 @@
-require "test_helper"
-require "dry/container"
-require "trailblazer/operation/auto_inject"
-
-class DryAutoInjectTest < Minitest::Spec
-  my_container = Dry::Container.new
-  my_container.register(:user_repository, -> { Object })
-
-  AutoInject = Trailblazer::Operation::AutoInject(my_container)
-
-  class Create < Trailblazer::Operation
-    include AutoInject[:user_repository]
-
-    pass :use_it!
-
-    def use_it!(ctx, user_repository:, **)
-      ctx[:my_repo] = user_repository
-    end
-  end
-
-  it "auto-injects user_repository" do
-    res = Create.(params: {})
-    res[:user_repository].must_equal Object
-    res[:my_repo].must_equal Object
-  end
-
-  it "allows dependency injection via ::call" do
-    Create.(params: {}, user_repository: String)[:user_repository].must_equal String
-  end
-
-  describe "inheritance" do
-    class Update < Create
-    end
-
-    it { Update.()[:user_repository].must_equal Object }
-  end
-end

data/test/docs/fast_test.rb

@@ -1,284 +0,0 @@
-require "test_helper"
-
-class DocsFailFastOptionTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find_by(id); nil end
-  end
-
-  class MyContract < Reform::Form
-  end
-
-
-  #:ffopt
-  class Update < Trailblazer::Operation
-    step    Model( Song, :find_by )
-    failure :abort!,                                fail_fast: true
-    step    Contract::Build( constant: MyContract )
-    step    Contract::Validate( )
-    failure :handle_invalid_contract!  # won't be executed if #abort! is executed.
-
-    def abort!(options, params:, **)
-      options["result.model.song"] = "Something went wrong with ID #{params[:id]}!"
-    end
-    # ..
-  end
-  #:ffopt end
-
-  it { Update.(params: {id: 1}).inspect("result.model.song", "contract.default").must_equal %{<Result:false [\"Something went wrong with ID 1!\", nil] >} }
-  it do
-  #:ffopt-res
-    result = Update.(params: {id: 1})
-    result["result.model.song"] #=> "Something went wrong with ID 1!"
-  #:ffopt-res end
-  end
-end
-
-class DocsFailFastOptionWithStepTest < Minitest::Spec
-  Song = Class.new do
-    def self.find_by(*); Object end
-  end
-
-  #:ffopt-step
-  class Update < Trailblazer::Operation
-    step :empty_id?,             fail_fast: true
-    step Model( Song, :find_by )
-    failure :handle_empty_db!   # won't be executed if #empty_id? returns falsey.
-
-    def empty_id?(options, params:, **)
-      params[:id] # returns false if :id missing.
-    end
-  end
-  #:ffopt-step end
-
-  it { Update.(params: { id: nil }).inspect(:model).must_equal %{<Result:false [nil] >} }
-  it { Update.(params: { id: 1 }).inspect(:model).must_equal %{<Result:true [Object] >} }
-  it do
-  #:ffopt-step-res
-    result = Update.(params: { id: nil })
-
-    result.failure? #=> true
-    result["model"] #=> nil
-  #:ffopt-step-res end
-  end
-end
-
-class DocsPassFastWithStepOptionTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find_by(id); nil end
-  end
-
-  class MyContract < Reform::Form
-  end
-
-  #:pfopt-step
-  class Update < Trailblazer::Operation
-    step    Model( Song, :find_by )
-    failure :abort!,                                fail_fast: true
-    step    Contract::Build( constant: MyContract )
-    step    Contract::Validate( )
-    failure :handle_invalid_contract!  # won't be executed if #abort! is executed.
-
-    def abort!(options, params:, **)
-      options["result.model.song"] = "Something went wrong with ID #{params[:id]}!"
-    end
-    # ..
-  end
-  #:pfopt-step end
-
-  it { Update.(params: {id: 1}).inspect("result.model.song", "contract.default").must_equal %{<Result:false [\"Something went wrong with ID 1!\", nil] >} }
-  it do
-  #:pfopt-step-res
-    result = Update.(params: {id: 1})
-    result["result.model.song"] #=> "Something went wrong with ID 1!"
-  #:pfopt-step-res end
-  end
-end
-
-class DocsFailFastMethodTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def self.find_by(id); nil end
-  end
-
-  #:ffmeth
-  class Update < Trailblazer::Operation
-    step :filter_params!,         fast_track: true # emits fail_fast!
-    step Model( Song, :find_by )
-    failure :handle_fail!
-
-    def filter_params!(options, params:, **)
-      unless params[:id]
-        options["result.params"] = "No ID in params!"
-        return Railway.fail_fast!
-      end
-    end
-
-    def handle_fail!(options, **)
-      options["my.status"] = "Broken!"
-    end
-  end
-  #:ffmeth end
-
-  it { Update.(params: {}).inspect("result.params", "my.status").must_equal %{<Result:false [\"No ID in params!\", nil] >} }
-  it do
-  #:ffmeth-res
-    result = Update.(params: {id: 1})
-    result["result.params"] #=> "No ID in params!"
-    result["my.status"]     #=> nil
-  #:ffmeth-res end
-  end
-end
-
-class DocsPassFastMethodTest < Minitest::Spec
-  Song = Struct.new(:id, :title) do
-    def save; end
-  end
-
-  class MyContract < Reform::Form
-  end
-
-  #:pfmeth
-  class Create < Trailblazer::Operation
-    step Model( Song, :new )
-    step :empty_model!,         fast_track: true  # emits pass_fast!
-    step Contract::Build( constant: MyContract )
-    # ..
-
-    def empty_model!(options, is_empty:, model:, **)
-      return unless is_empty
-      model.save
-      Railway.pass_fast!
-    end
-  end
-  #:pfmeth end
-
-  it { Create.(params: { title: "Tyrant"}, "is_empty" => true).inspect(:model).must_equal %{<Result:true [#<struct DocsPassFastMethodTest::Song id=nil, title=nil>] >} }
-  it do
-  #:pfmeth-res
-    result = Create.(params: {}, "is_empty" => true)
-    result["model"] #=> #<Song id=nil, title=nil>
-  #:pfmeth-res end
-  end
-end
-
-
-class FastTrackWithNestedTest < Minitest::Spec
-  module Lib; end
-  module Memo; end
-
-  #:ft-nested
-  class Lib::Authenticate < Trailblazer::Operation
-    step :verify_input, fail_fast: true
-    step :user_ok?
-    #~ign
-    def verify_input(options, w:true, **); options[:w] = true; w; end
-    def user_ok?(options, u:true, **);     options[:u] = true; u; end
-    #~ign end
-  end
-  #:ft-nested end
-
-  #:ft-create
-  class Memo::Create < Trailblazer::Operation
-    step :validate
-    step Nested( Lib::Authenticate ) # fail_fast goes to End.fail_fast
-    step :create_model
-    step :save
-    #~igncr
-    def validate(options, v:true, **);     options[:v] = true; v; end
-    def create_model(options, c:true, **); options[:c] = true; c; end
-    def save(options, s:true, **);         options[:s] = true; s; end
-    #~igncr end
-  end
-  #:ft-create end
-
-  it "everything goes :success ===> End.success" do
-    result = Memo::Create.()
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:true [true, true, true, true, true] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Success
-  end
-
-  it "validate => failure ===> End.failure" do
-    result = Memo::Create.(v: false)
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, nil, nil, nil, nil] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
-  end
-
-  it "verify_input? => fail_fast ===> End.fail_fast" do
-    result = Memo::Create.(w: false)
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, nil, nil, nil] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::FailFast
-  end
-
-  it "user_ok? => fail ===> End.failure" do
-    result = Memo::Create.(u: false)
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, true, nil, nil] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
-  end
-
-  it "create_model? => fail ===> End.failure" do
-    result = Memo::Create.(c: false)
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, true, true, nil] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
-  end
-
-  module Rewire
-    module Memo; end
-
-    #:ft-rewire
-    class Memo::Create < Trailblazer::Operation
-      step :validate
-      step Nested( Lib::Authenticate ), Output(:fail_fast) => Track(:failure)
-      step :create_model
-      step :save
-      #~ignrw
-      def validate(options, v:true, **);     options[:v] = true; v; end
-      def create_model(options, c:true, **); options[:c] = true; c; end
-      def save(options, s:true, **);         options[:s] = true; s; end
-      #~ignrw end
-    end
-    #:ft-rewire end
-  end
-
-  it "everything goes :success ===> End.success" do
-    result = Rewire::Memo::Create.()
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:true [true, true, true, true, true] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Success
-  end
-
-  it "validate => failure ===> End.failure" do
-    result = Rewire::Memo::Create.(v: false)
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, nil, nil, nil, nil] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
-  end
-
-  # this is the only test differing.
-  it "verify_input? => fail_fast ===> End.failure" do
-    result = Rewire::Memo::Create.(w: false)
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, nil, nil, nil] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
-  end
-
-  it "user_ok? => fail ===> End.failure" do
-    result = Rewire::Memo::Create.(u: false)
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, true, nil, nil] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
-  end
-
-  it "create_model? => fail ===> End.failure" do
-    result = Rewire::Memo::Create.(c: false)
-
-    result.inspect(:v,:w,:u,:c,:s).must_equal %{<Result:false [true, true, true, true, nil] >}
-    result.event.must_be_instance_of Trailblazer::Operation::Railway::End::Failure
-  end
-end
-
-# fail!
-# pass!