trailblazer-context 0.3.0 → 0.5.0

data/.travis.yml

@@ -1,12 +0,0 @@
-language: ruby
-before_install: gem install bundler
-cache: bundler
-rvm:
-  - ruby-head
-  - 2.7
-  - 2.6
-  - 2.5
-  - 2.4
-jobs:
-  allow_failures:
-    - rvm: ruby-head

data/lib/trailblazer/context/aliasing.rb

@@ -1,38 +0,0 @@
-module Trailblazer
-  class Context
-    module Aliasing
-      def initialize(wrapped_options, mutable_options, context_alias: {}, **)
-        super(wrapped_options, mutable_options)
-
-        @aliases = context_alias.invert
-      end
-
-      def [](key)
-        return super unless (aka = @aliases[key]) # yepp, nil/false won't work
-
-        super(aka)
-      end
-
-      def key?(key)
-        return super unless (aka = @aliases[key]) # yepp, nil/false won't work
-
-        super(aka)
-      end
-
-      # @private ?
-      def merge(hash)
-        original, mutable_options = decompose
-
-        self.class.new(
-          original,
-          mutable_options.merge(hash),
-          context_alias: @aliases.invert # DISCUSS: maybe we can speed up by remembering the original options?
-        )
-      end
-
-      def to_hash
-        super.merge(Hash[@aliases.collect { |aka, k| key?(k) ? [aka, self[k]] : nil }.compact]) # FIXME: performance!
-      end
-    end
-  end
-end

data/lib/trailblazer/context/indifferent_access.rb

@@ -1,38 +0,0 @@
-require "trailblazer/context/aliasing"
-
-module Trailblazer
-  class Context
-    class IndifferentAccess < Context
-      module InstanceMethods
-        def [](name)
-          # TODO: well...
-          @mutable_options.key?(name.to_sym) and return @mutable_options[name.to_sym]
-          @mutable_options.key?(name.to_s) and return @mutable_options[name.to_s]
-          @wrapped_options.key?(name.to_sym) and return @wrapped_options[name.to_sym]
-          @wrapped_options[name.to_s]
-        end
-
-        def self.build(wrapped_options, mutable_options, (_ctx, flow_options), **)
-          new(wrapped_options, mutable_options, flow_options)
-        end
-      end
-      include InstanceMethods
-
-      def key?(name)
-        super(name.to_sym) || super(name.to_s)
-      end
-
-      include Aliasing # FIXME
-
-
-      class << self
-        # This also builds IndifferentAccess::Aliasing.
-        # The {#build} method is designed to take all args from {for_circuit} and then
-        # translate that to the constructor.
-        def build(wrapped_options, mutable_options, (_ctx, flow_options), **)
-          new(wrapped_options, mutable_options, **flow_options)
-        end
-      end
-    end
-  end
-end

data/lib/trailblazer/option.rb

@@ -1,77 +0,0 @@
-module Trailblazer
-  class Option
-    # A call implementation invoking `proc.(*args)` and plainly forwarding all arguments.
-    # Override this for your own step strategy (see KW#call!).
-    # @private
-    def self.call!(proc, *args, &block)
-      proc.(*args, &block)
-    end
-
-    # Note that both #evaluate_callable and #evaluate_method drop most of the args.
-    # If you need those, override this class.
-    # @private
-    def self.evaluate_callable(proc, *args, **, &block)
-      call!(proc, *args, &block)
-    end
-
-    # Make the context's instance method a "lambda" and reuse #call!.
-    # @private
-    def self.evaluate_method(proc, *args, exec_context: raise("No :exec_context given."), **, &block)
-      call!(exec_context.method(proc), *args, &block)
-    end
-
-    # Generic builder for a callable "option".
-    # @param call_implementation [Class, Module] implements the process of calling the proc
-    #   while passing arguments/options to it in a specific style (e.g. kw args, step interface).
-    # @return [Proc] when called, this proc will evaluate its option (at run-time).
-    def self.build(call_implementation, proc)
-      if proc.is_a? Symbol
-        ->(*args, &block) { call_implementation.evaluate_method(proc, *args, &block) }
-      else
-        ->(*args, &block) { call_implementation.evaluate_callable(proc, *args, &block) }
-      end
-    end
-
-    # Returns a {Proc} that, when called, invokes the `proc` argument with keyword arguments.
-    # This is known as "step (call) interface".
-    #
-    # This is commonly used by `Operation::step` to wrap the argument and make it
-    # callable in the circuit.
-    #
-    #   my_proc = ->(options, **kws) { options["i got called"] = true }
-    #   task    = Trailblazer::Option::KW(my_proc)
-    #   task.(options = {})
-    #   options["i got called"] #=> true
-    #
-    # Alternatively, you can pass a symbol and an `:exec_context`.
-    #
-    #   my_proc = :some_method
-    #   task    = Trailblazer::Option::KW(my_proc)
-    #
-    #   class A
-    #     def some_method(options, **kws)
-    #       options["i got called"] = true
-    #     end
-    #   end
-    #
-    #   task.(options = {}, exec_context: A.new)
-    #   options["i got called"] #=> true
-    def self.KW(proc)
-      Option.build(KW, proc)
-    end
-
-    # TODO: It would be cool if call! was typed and had `options SymbolizedHash` or something.
-    class KW < Option
-      # A different call implementation that calls `proc` with a "step interface".
-      #   your_code.(options, **options)
-      # @private
-      def self.call!(proc, options, *)
-        proc.(options, **options.to_hash) # Step interface: (options, **)
-      end
-    end
-  end
-  # @note This might go to trailblazer-args along with `Context` at some point.
-  def self.Option(proc)
-    Option.build(Option, proc)
-  end
-end

data/test/option_test.rb

@@ -1,186 +0,0 @@
-require "test_helper"
-
-class OptionTest < Minitest::Spec
-  def assert_result(result, block = nil)
-    _(result).must_equal([{a: 1}, 2, {b: 3}, block])
-
-    _(positional.inspect).must_equal %({:a=>1})
-    _(keywords.inspect).must_equal %({:a=>2, :b=>3})
-  end
-
-  describe "positional and kws" do
-    class Step
-      def with_positional_and_keywords(options, a: nil, **more_options, &block)
-        [options, a, more_options, block]
-      end
-    end
-
-    WITH_POSITIONAL_AND_KEYWORDS = ->(options, a: nil, **more_options, &block) do
-      [options, a, more_options, block]
-    end
-
-    class WithPositionalAndKeywords
-      def self.call(options, a: nil, **more_options, &block)
-        [options, a, more_options, block]
-      end
-    end
-
-    let(:positional) { {a: 1} }
-    let(:keywords)   { {a: 2, b: 3} }
-
-    let(:block) { ->(*) { snippet } }
-
-    describe ":method" do
-      let(:option) { Trailblazer::Option(:with_positional_and_keywords) }
-
-      it "passes through all args" do
-        step = Step.new
-
-        # positional = { a: 1 }
-        # keywords   = { a: 2, b: 3 }
-        assert_result option.(positional, keywords, exec_context: step)
-      end
-
-      it "allows passing a block, too" do
-        step = Step.new
-
-        assert_result option.(positional, keywords, {exec_context: step}, &block), block
-      end
-    end
-
-    describe "lambda" do
-      let(:option) { Trailblazer::Option(WITH_POSITIONAL_AND_KEYWORDS) }
-
-      it "-> {} lambda" do
-        assert_result option.(positional, keywords, {})
-      end
-
-      it "allows passing a block, too" do
-        assert_result option.(positional, keywords, {}, &block), block
-      end
-
-      it "doesn't mind :exec_context" do
-        assert_result option.(positional, keywords, exec_context: "bogus")
-      end
-    end
-
-    describe "Callable" do
-      let(:option) { Trailblazer::Option(WithPositionalAndKeywords) }
-
-      it "passes through all args" do
-        assert_result option.(positional, keywords, exec_context: nil)
-      end
-
-      it "allows passing a block, too" do
-        assert_result option.(positional, keywords, {exec_context: nil}, &block), block
-      end
-    end
-  end
-
-  describe "positionals" do
-    def assert_result_pos(result)
-      _(result).must_equal([1, 2, [3, 4]])
-      _(positionals).must_equal [1, 2, 3, 4]
-    end
-
-    class Step
-      def with_positionals(a, b, *args)
-        [a, b, args]
-      end
-    end
-
-    WITH_POSITIONALS = ->(a, b, *args) do
-      [a, b, args]
-    end
-
-    class WithPositionals
-      def self.call(a, b, *args)
-        [a, b, args]
-      end
-    end
-
-    let(:positionals) { [1, 2, 3, 4] }
-
-    it ":method" do
-      step = Step.new
-
-      option = Trailblazer::Option(:with_positionals)
-
-      assert_result_pos option.(*positionals, exec_context: step)
-    end
-
-    it "-> {} lambda" do
-      option = Trailblazer::Option(WITH_POSITIONALS)
-
-      assert_result_pos option.(*positionals, exec_context: "something")
-    end
-
-    it "callable" do
-      option = Trailblazer::Option(WithPositionals)
-
-      assert_result_pos option.(*positionals, exec_context: "something")
-    end
-  end
-
-  describe "Option::KW" do
-    def assert_result_kws(result)
-      _(result).must_equal([{a: 1, b: 2, c: 3}, 1, 2, {c: 3}])
-    end
-
-    class Step
-      def with_kws(options, a: nil, b: nil, **rest)
-        [options, a, b, rest]
-      end
-    end
-
-    module Task
-      def self.with_kws(options, a: nil, b: nil, **rest)
-        [options, a, b, rest]
-      end
-    end
-
-    WITH_KWS = ->(options, a: nil, b: nil, **rest) do
-      [options, a, b, rest]
-    end
-
-    class WithKWs
-      def self.call(options, a: nil, b: nil, **rest)
-        [options, a, b, rest]
-      end
-    end
-
-    let(:options) { {a: 1, b: 2, c: 3} }
-
-    it ":method" do
-      step = Step.new
-
-      option = Trailblazer::Option::KW(:with_kws)
-
-      assert_result_kws option.(options, exec_context: step)
-    end
-
-    it "Method instance" do
-      option = Trailblazer::Option::KW(Task.method(:with_kws))
-
-      assert_result_kws option.(options, {})
-    end
-
-    it "-> {} lambda" do
-      option = Trailblazer::Option::KW(WITH_KWS)
-
-      assert_result_kws option.(options, {})
-    end
-
-    it "lambda ignores :exec_context" do
-      option = Trailblazer::Option::KW(WITH_KWS)
-
-      assert_result_kws option.(options, exec_context: "something")
-    end
-
-    it "callable" do
-      option = Trailblazer::Option::KW(WithKWs)
-
-      assert_result_kws option.(options, {})
-    end
-  end
-end