trailblazer-operation 0.0.13 → 0.4.1

data/lib/trailblazer/operation/skill.rb

@@ -1,41 +0,0 @@
-require "trailblazer/skill"
-# Dependency ("skill") management for Operation.
-# Op::[]
-# Op::[]=
-# Writing, even with an existing name, will never mutate a container.
-# Op#[]
-# Op#[]=
-# Op.(params, { "constructor" => competences })
-class Trailblazer::Operation
-  module Skill
-    # The class-level skill container: Operation::[], ::[]=.
-    module Accessors
-      # :private:
-      def skills
-        @skills ||= {}
-      end
-
-      extend Forwardable
-      def_delegators :skills, :[], :[]=
-    end
-
-    # Overrides Operation::call, creates the Skill hash and passes it to :call.
-    module Call
-      def call(options={}, *dependencies)
-        super Trailblazer::Skill.new(options, *dependencies, self.skills)
-        # DISCUSS: should this be: Trailblazer::Skill.new(runtime_options: [options, *dependencies], compiletime_options: [self.skills])
-      end
-      alias :_call :call
-
-      # It really sucks that Ruby doesn't have method overloading where we could simply have
-      # two different implementations of ::call.
-      # FIXME: that shouldn't be here in this namespace.
-      module Positional
-        def call(params={}, options={}, *dependencies)
-          super(options.merge("params" => params), *dependencies)
-        end
-      end
-    end
-
-  end
-end

data/lib/trailblazer/skill.rb

@@ -1,70 +0,0 @@
-# TODO: mark/make all but mutable_options as frozen.
-# The idea of Skill is to have a generic, ordered read/write interface that
-# collects mutable runtime-computed data while providing access to compile-time
-# information.
-# The runtime-data takes precedence over the class data.
-module Trailblazer
-  class Skill
-    def initialize(*containers)
-      @mutable_options = {}
-      @resolver        = Resolver.new(@mutable_options, *containers)
-    end
-
-    def [](name)
-      @resolver[name]
-    end
-
-    def []=(name, value)
-      @mutable_options[name] = value
-    end
-
-    # THIS METHOD IS CONSIDERED PRIVATE AND MIGHT BE REMOVED.
-    # Options from ::call (e.g. "user.current"), containers, etc.
-    # NO mutual data from the caller operation. no class state.
-    def to_runtime_data
-      @resolver.instance_variable_get(:@containers).slice(1..-2)
-    end
-
-    # THIS METHOD IS CONSIDERED PRIVATE AND MIGHT BE REMOVED.
-    def to_mutable_data
-      @mutable_options
-    end
-
-    # Called when Ruby transforms options into kw args, via **options.
-    # TODO: this method has massive potential for speed improvements.
-    # The `tmp_options` argument is experimental. It allows adding temporary options
-    # to the kw args.
-    #:private:
-    def to_hash(tmp_options={})
-      {}.tap do |h|
-        arr = to_runtime_data << to_mutable_data << tmp_options
-
-        arr.each { |hsh|
-          hsh.each { |k, v| h[k.to_sym] = v }
-        }
-      end
-    end
-
-    # Look through a list of containers until you find the skill.
-    class Resolver
-    # alternative implementation:
-    # containers.reverse.each do |container| @mutable_options.merge!(container) end
-    #
-    # benchmark, merging in #initialize vs. this resolver.
-    #                merge     39.678k (± 9.1%) i/s -    198.700k in   5.056653s
-    #             resolver     68.928k (± 6.4%) i/s -    342.836k in   5.001610s
-      def initialize(*containers)
-        @containers = containers
-      end
-
-      def [](name)
-        @containers.find { |container| container.key?(name) && (return container[name]) }
-      end
-    end
-
-    # private API.
-    def inspect
-      "<Skill #{@resolver.instance_variable_get(:@containers).collect { |c| c.inspect }.join(" ")}>"
-    end
-  end
-end

data/test/2.0.0-pipetree_test.rb

@@ -1,100 +0,0 @@
-require "test_helper"
-
-class KWBugsTest < Minitest::Spec
-  Merchant = Struct.new(:id)
-
-  class Merchant::New < Trailblazer::Operation
-    step ->(options) {
-      options["model"] = 1
-       options["bla"] = true # this breaks Ruby 2.2.2.
-     }
-
-    step :add!
-    def add!(yo:nil, model:nil, **)
-      raise if model.nil?
-    end
-  end
-
-  it { Merchant::New.( {}, { "yo"=> nil   } ) }
-end
-
-class KWOptionsTest < Minitest::Spec
-  X = Trailblazer::Operation::Option::KW.( ->(options, **) { options["x"] = true } )
-  Y = Trailblazer::Operation::Option::KW.( ->(options, params:nil, **) { options["y"] = params } )
-  Z = Trailblazer::Operation::Option::KW.( ->(options, params:nil, z:nil, **) { options["kw_z"] = z } )
-  A = Trailblazer::Operation::Option::KW.( ->(options, params:nil, z:nil, **) { options["options_z"] = options["z"] } )
-
-  class Create < Trailblazer::Operation
-    step [ ->(input, options) { X.(input, options, z: "Z!") }, name: "X" ]
-    step [ ->(input, options) { Y.(input, options, z: "Z!") }, name: "Y" ]
-    step [ ->(input, options) { Z.(input, options, z: "Z!") }, name: "Z" ]
-    step [ ->(input, options) { A.(input, options, z: "Z!") }, name: "A" ]
-  end
-
-  it { Create.({ params: "yo" }, "z" => 1).inspect("x", "y", "kw_z", "options_z").must_equal %{<Result:true [true, {:params=>\"yo\"}, "Z!", 1] >} }
-end
-
-
-class Ruby200PipetreeTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step ->(*, params:nil, **) { params["run"] }    # only test kws.
-    step ->(options, params:nil, **) { options["x"] = params["run"] } # read and write.
-    step ->(options) { options["y"] = options["params"]["run"] } # old API.
-  end
-
-  it { Create.("run" => false).inspect("x", "y").must_equal %{<Result:false [nil, nil] >} }
-  it { Create.("run" => true).inspect("x", "y").must_equal %{<Result:true [true, true] >} }
-
-  #- instance methods
-  class Update < Trailblazer::Operation
-    step :params!    # only test kws.
-    step :x! # read and write.
-    step :y! # old API.
-
-    def params!(*, params:nil, **)
-      params["run"]
-    end
-
-    def x!(options, params:nil, **)
-      options["x"] = params["run"]
-    end
-
-    def y!(options)
-      options["y"] = options["params"]["run"]
-    end
-  end
-
-  it { Update.("run" => false).inspect("x", "y").must_equal %{<Result:false [nil, nil] >} }
-  it { Update.("run" => true).inspect("x", "y").must_equal %{<Result:true [true, true] >} }
-
-
-  class Delete < Trailblazer::Operation
-    class Params
-      extend Uber::Callable
-      def self.call(*, params:nil, **)
-        params["run"]
-      end
-    end
-
-    class X
-      extend Uber::Callable
-      def self.call(options, params:nil, **)
-        options["x"] = params["run"]
-      end
-    end
-
-    class Y
-      extend Uber::Callable
-      def self.call(options)
-        options["y"] = options["params"]["run"]
-      end
-    end
-
-    step Params
-    step X
-    step Y
-  end
-
-  it { Delete.("run" => false).inspect("x", "y").must_equal %{<Result:false [nil, nil] >} }
-  it { Delete.("run" => true).inspect("x", "y").must_equal %{<Result:true [true, true] >} }
-end

data/test/2.1.0-pipetree_test.rb

@@ -1,100 +0,0 @@
-require "test_helper"
-
-class KWBugsTest < Minitest::Spec
-  Merchant = Struct.new(:id)
-
-  class Merchant::New < Trailblazer::Operation
-    step ->(options) {
-      options["model"] = 1
-       options["bla"] = true # this breaks Ruby 2.2.2.
-     }
-
-    step :add!
-    def add!(yo:, model:, **)
-      raise if model.nil?
-    end
-  end
-
-  it { Merchant::New.( {}, { "yo"=> nil   } ) }
-end
-
-class KWOptionsTest < Minitest::Spec
-  X = Trailblazer::Operation::Option::KW.( ->(options, **) { options["x"] = true } )
-  Y = Trailblazer::Operation::Option::KW.( ->(options, params:, **) { options["y"] = params } )
-  Z = Trailblazer::Operation::Option::KW.( ->(options, params:, z:, **) { options["kw_z"] = z } )
-  A = Trailblazer::Operation::Option::KW.( ->(options, params:, z:, **) { options["options_z"] = options["z"] } )
-
-  class Create < Trailblazer::Operation
-    step [ ->(input, options) { X.(input, options, z: "Z!") }, name: "X" ]
-    step [ ->(input, options) { Y.(input, options, z: "Z!") }, name: "Y" ]
-    step [ ->(input, options) { Z.(input, options, z: "Z!") }, name: "Z" ]
-    step [ ->(input, options) { A.(input, options, z: "Z!") }, name: "A" ]
-  end
-
-  it { Create.({ params: "yo" }, "z" => 1).inspect("x", "y", "kw_z", "options_z").must_equal %{<Result:true [true, {:params=>\"yo\"}, "Z!", 1] >} }
-end
-
-
-class Ruby200PipetreeTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step ->(*, params:, **) { params["run"] }    # only test kws.
-    step ->(options, params:nil, **) { options["x"] = params["run"] } # read and write.
-    step ->(options) { options["y"] = options["params"]["run"] } # old API.
-  end
-
-  it { Create.("run" => false).inspect("x", "y").must_equal %{<Result:false [nil, nil] >} }
-  it { Create.("run" => true).inspect("x", "y").must_equal %{<Result:true [true, true] >} }
-
-  #- instance methods
-  class Update < Trailblazer::Operation
-    step :params!    # only test kws.
-    step :x! # read and write.
-    step :y! # old API.
-
-    def params!(*, params:, **)
-      params["run"]
-    end
-
-    def x!(options, params:nil, **)
-      options["x"] = params["run"]
-    end
-
-    def y!(options)
-      options["y"] = options["params"]["run"]
-    end
-  end
-
-  it { Update.("run" => false).inspect("x", "y").must_equal %{<Result:false [nil, nil] >} }
-  it { Update.("run" => true).inspect("x", "y").must_equal %{<Result:true [true, true] >} }
-
-
-  class Delete < Trailblazer::Operation
-    class Params
-      extend Uber::Callable
-      def self.call(*, params:, **)
-        params["run"]
-      end
-    end
-
-    class X
-      extend Uber::Callable
-      def self.call(options, params:nil, **)
-        options["x"] = params["run"]
-      end
-    end
-
-    class Y
-      extend Uber::Callable
-      def self.call(options)
-        options["y"] = options["params"]["run"]
-      end
-    end
-
-    step Params
-    step X
-    step Y
-  end
-
-  it { Delete.("run" => false).inspect("x", "y").must_equal %{<Result:false [nil, nil] >} }
-  it { Delete.("run" => true).inspect("x", "y").must_equal %{<Result:true [true, true] >} }
-end

data/test/operation_skill_test.rb

@@ -1,89 +0,0 @@
-require "test_helper"
-
-class OperationSkillTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-  end
-
-  # no dependencies provided.
-  it { Create.()[:not_existent].must_equal nil }
-  # dependencies provided.
-  it { Create.({}, contract: Object)[:not_existent].must_equal nil }
-  it { Create.({}, contract: Object)[:contract].must_equal Object }
-end
-
-class OperationCompetenceTest < Minitest::Spec
-  # Operation#[]
-  # Operation#[]=
-  # arbitrary options can be saved via Op#[].
-  class Create < Trailblazer::Operation
-    success :call
-
-    def call(*)
-      self["drink"] = "Little Creatures"
-      self["drink"]
-    end
-  end
-
-  it { Create.()["drink"].must_equal "Little Creatures" }
-  # instance can override constructor options.
-  it { Create.({}, "drink" => "Four Pines")["drink"].must_equal "Little Creatures" }
-  # original hash doesn't get changed.
-  it do
-    Create.({}, hash = { "drink" => "Four Pines" })
-    hash.must_equal( { "drink" => "Four Pines" })
-  end
-
-
-  # Operation::[]
-  # Operation::[]=
-  class Update < Trailblazer::Operation
-    success :call
-
-    self["drink"] = "Beer"
-
-    def call(*)
-      self["drink"]
-    end
-  end
-
-  it { Update["drink"].must_equal "Beer" }
-
-  # class-level are available on instance-level via Op#[]
-  it { Update.()["drink"].must_equal "Beer" }
-
-  # runtime constructor options can override class-level.
-  it { Update.({}, "drink" => "Little Creatures")["drink"].must_equal "Little Creatures" }
-
-  # instance can override class-level
-  class Delete < Trailblazer::Operation
-    success :call
-
-    self["drink"] = "Beer"
-
-    def call(*)
-      self["drink"] = "Little Creatures"
-      self["drink"]
-    end
-  end
-
-  # Op#[]= can override class-level...
-  it { Delete.()["drink"].must_equal "Little Creatures" }
-  # ...but it doesn't change class-level.
-  it { Delete["drink"].must_equal "Beer" }
-
-  # we don't really need this test.
-  class Reward < Trailblazer::Operation
-    self["drink"] = "Beer"
-  end
-
-  it { Reward.()["drink"].must_equal "Beer" }
-end
-
-# {
-#   user_repository: ..,
-#   current_user: ..,
-# }
-
-
-# 1. initialize(params, {})
-# 2. extend AutoInject[] shouldn't override constructor but simply pass injected dependencies in second arg (by adding dependencies to hash).

data/test/pipetree_test.rb

@@ -1,185 +0,0 @@
-require "test_helper"
-
-class PipetreeTest < Minitest::Spec
-  def self.Validate
-    step = ->{ snippet }
-
-    [ step, name: "validate", before: "operation.new" ]
-  end
-
-  # without options
-  class Create < Trailblazer::Operation
-    step PipetreeTest::Validate()
-    step PipetreeTest::Validate(), name: "VALIDATE!"
-  end
-
-  it { Create["pipetree"].inspect.must_equal %{[>validate,>VALIDATE!,>operation.new]} }
-
-
-
-  # with options
-  class Update < Trailblazer::Operation
-    step PipetreeTest::Validate(), after: "operation.new"
-  end
-
-  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>validate]} }
-
-  #---
-  # ::step
-
-  #-
-  #- with :symbol
-  class Delete < Trailblazer::Operation
-    step :call!
-
-    def call!(options)
-      self["x"] = options["params"]
-    end
-  end
-
-  it { Delete.("yo")["x"].must_equal "yo" }
-
-  #- inheritance
-  class Remove < Delete
-  end
-
-  it { Remove.("yo")["x"].must_equal "yo" }
-
-  # proc arguments
-  class Forward < Trailblazer::Operation
-    step ->(input, options) { puts "@@@@@ #{input.inspect}"; puts "@@@@@ #{options.inspect}" }
-  end
-
-  it { skip; Forward.({ id: 1 }) }
-
-  #---
-  # ::>, ::<, ::>>, :&
-  # with proc, method, callable.
-  class Right < Trailblazer::Operation
-    MyProc = ->(*) { }
-    success ->(options) { options[">"] = options["params"][:id] }, better_api: true
-
-    success :method_name!
-    def method_name!(options); self["method_name!"] = options["params"][:id] end
-
-    class MyCallable
-      include Uber::Callable
-      def call(options); options["callable"] = options["params"][:id] end
-    end
-    success MyCallable.new
-  end
-
-  it { Right.( id: 1 ).slice(">", "method_name!", "callable").must_equal [1, 1, 1] }
-  it { Right["pipetree"].inspect.must_equal %{[>operation.new,>pipetree_test.rb:60,>method_name!,>PipetreeTest::Right::MyCallable]} }
-
-  #---
-  # inheritance
-  class Righter < Right
-    success ->(options) { options["righter"] = true }
-  end
-
-  it { Righter.( id: 1 ).slice(">", "method_name!", "callable", "righter").must_equal [1, 1, 1, true] }
-end
-
-
-class FailPassFastOptionTest < Minitest::Spec
-  # #failure fails fast.
-  class Create < Trailblazer::Operation
-    step ->(options, *) { options["x"] = options["dont_fail"] }
-    failure ->(options, *) { options["a"] = true; options["fail_fast"] }, fail_fast: true
-    failure ->(options, *) { options["b"] = true }
-    step ->(options, *) { options["y"] = true }
-  end
-
-  it { Create.({}, "fail_fast" => true, "dont_fail" => true ).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, nil, nil, true] >} }
-  it { Create.({}, "fail_fast" => true                  ).inspect("x", "a", "b", "y").must_equal %{<Result:false [nil, true, nil, nil] >} }
-  it { Create.({}, "fail_fast" => false                 ).inspect("x", "a", "b", "y").must_equal %{<Result:false [nil, true, nil, nil] >} }
-
-  # #success passes fast.
-  class Retrieve < Trailblazer::Operation
-    success ->(options, *) { options["x"] = options["dont_fail"] }, pass_fast: true
-    failure ->(options, *) { options["b"] = true }
-    step ->(options, *) { options["y"] = true }
-  end
-
-  it { Retrieve.({}, "dont_fail" => true  ).inspect("x", "b", "y").must_equal %{<Result:true [true, nil, nil] >} }
-  it { Retrieve.({}, "dont_fail" => false ).inspect("x", "b", "y").must_equal %{<Result:true [false, nil, nil] >} }
-
-  # #step fails fast if option set and returns false.
-  class Update < Trailblazer::Operation
-    step ->(options, *) { options["x"] = true }
-    step ->(options, *) { options["a"] = options["dont_fail"] }, fail_fast: true # only on false.
-    failure ->(options, *) { options["b"] = true }
-    step ->(options, *) { options["y"] = true }
-  end
-
-  it { Update.({}, "dont_fail" => true).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, true, nil, true] >} }
-  it { Update.({}                     ).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, nil, nil] >} }
-
-  # #step passes fast if option set and returns true.
-  class Delete < Trailblazer::Operation
-    step ->(options, *) { options["x"] = true }
-    step ->(options, *) { options["a"] = options["dont_fail"] }, pass_fast: true # only on true.
-    failure ->(options, *) { options["b"] = true }
-    step ->(options, *) { options["y"] = true }
-  end
-
-  it { Delete.({}, "dont_fail" => true).inspect("x", "a", "b", "y").must_equal %{<Result:true [true, true, nil, nil] >} }
-  it { Delete.({}                     ).inspect("x", "a", "b", "y").must_equal %{<Result:false [true, nil, true, nil] >} }
-end
-
-class FailBangTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step ->(options, *) { options["x"] = true; Railway.fail! }
-    step ->(options, *) { options["y"] = true }
-    failure ->(options, *) { options["a"] = true }
-  end
-
-  it { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, true] >} }
-end
-
-class PassBangTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step ->(options, *) { options["x"] = true; Railway.pass! }
-    step ->(options, *) { options["y"] = true }
-    failure ->(options, *) { options["a"] = true }
-  end
-
-  it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, true, nil] >} }
-end
-
-class FailFastBangTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step ->(options, *) { options["x"] = true; Railway.fail_fast! }
-    step ->(options, *) { options["y"] = true }
-    failure ->(options, *) { options["a"] = true }
-  end
-
-  it { Create.().inspect("x", "y", "a").must_equal %{<Result:false [true, nil, nil] >} }
-end
-
-class PassFastBangTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step ->(options, *) { options["x"] = true; Railway.pass_fast! }
-    step ->(options, *) { options["y"] = true }
-    failure ->(options, *) { options["a"] = true }
-  end
-
-  it { Create.().inspect("x", "y", "a").must_equal %{<Result:true [true, nil, nil] >} }
-end
-
-
-class OverrideTest < Minitest::Spec
-  class Create < Trailblazer::Operation
-    step :a
-    step :b
-  end
-
-  class Update < Create
-    step :a, override: true
-  end
-
-# FIXME: also test Macro
-  it { Create["pipetree"].inspect.must_equal %{[>operation.new,>a,>b]} }
-  it { Update["pipetree"].inspect.must_equal %{[>operation.new,>a,>b]} }
-end