trailblazer-context 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: eb81fa6ece2d3615f46a7b72a066a8316c48065a
-  data.tar.gz: d720c68f9154786ef561e97f67e29ff15e58be6c
+SHA256:
+  metadata.gz: 0f6c3c7ff9c8b061c5ac0d5aca954f03cd1b5ff0bf286aa787ede12f1e187890
+  data.tar.gz: 0fdc45ffab9316c7799f2ce59f54c6409305cf91fa01349d30d026eac998c188
 SHA512:
-  metadata.gz: 720a50aab05ec4de810b88227c7405f5bffaef9e2685419849f09cd56159e5e216c0ae5959b4d6502e2edabc7559bdfcbe5a01b61f9a141bfc01508f407e39a6
-  data.tar.gz: 2aa161d5f6de1b93210f3e1f5f9c187f0dd8b44cc0bf2d335dbc36c6479d6891d1a4ac002dd729d3b824a5fd04304fe952b0038fa16e4105ac242ec584905020
+  metadata.gz: 2c9f349028afca126e1961e50ebb0ff661a5fe5a0e2573108c9c79f762694cdb03c6914beca4eec4c5b3b25aecae03d4706c47c84854d0ebb57b6e8a42ec279f
+  data.tar.gz: 1fba9db52f9e3680cccb3b89624c8a159bbd144fbd0b86b3a71972ea1feff96978b82867c976a568aec709b09d0fe859d173a1a813fa5747cb42d179bf6c7520

data/.gitignore

@@ -9,6 +9,7 @@
 /test/tmp/
 /test/version_tmp/
 /tmp/
+Gemfile.lock
 
 # Used by dotenv library to load environment variables.
 # .env

data/.travis.yml

@@ -0,0 +1,12 @@
+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/CHANGES.md

@@ -1,3 +1,29 @@
+# 0.3.0
+* Add support for ruby 2.7
+* Drop support for ruby 2.0
+
+# 0.2.0
+
+* Added `Context::IndifferentAccess`.
+* Added `Context::Aliasing`.
+* `Context.for_circuit` is not the authorative builder for creating a context.
+
+# 0.1.5
+
+* `Context.build` allows quickly building a Context without requiring the circuit interface.
+
+# 0.1.4
+
+* Fix the `IndifferentAccess` name lookup. Since we can't convert all keys to symbols internally (not every options structure has `collect`) we need to have a lookup chain.
+
+# 0.1.3
+
+* Introduce `Context::IndifferentAccess` which converts all keys to symbol. This, in turn, allows to use both string and symbol keys everywhere. Currently, the implementation is set via the global method `Context.implementation` and defaults to the new `IndifferentAccess`.
+
+# 0.1.2
+
+* More meaningful error message: "No :exec_context given.".
+
 # 0.1.1
 
 * `Option.( *args, &block )` now passes through the block to the option call.

data/Gemfile

@@ -1,5 +1,5 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
 gemspec
 
-gem "minitest-line"
 gem "benchmark-ips"
+gem "minitest-line"

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 TRAILBLAZER GmbH
+Copyright (c) 2017-2020 TRAILBLAZER GmbH
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Rakefile

@@ -4,7 +4,7 @@ require "rake/testtask"
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList['test/*_test.rb']
+  t.test_files = FileList["test/*_test.rb"]
 end
 
-task :default => :test
+task default: %i[test]

data/lib/trailblazer-context.rb

@@ -1,2 +1,2 @@
+require "trailblazer/context/version"
 require "trailblazer/context"
-require "trailblazer/option"

data/lib/trailblazer/container_chain.rb

@@ -1,5 +1,6 @@
 # @private
-class Trailblazer::Context::ContainerChain # used to be called Resolver.
+# used to be called Resolver.
+class Trailblazer::Context::ContainerChain
   # Keeps a list of containers. When looking up a key/value, containers are traversed in
   # the order they were added until key is found.
   #
@@ -28,11 +29,12 @@ class Trailblazer::Context::ContainerChain # used to be called Resolver.
 
   def keys
     @containers.collect(&:keys).flatten
-end
+  end
 
   # @private
   def to_hash
-    return @to_hash.(@containers) if @to_hash # FIXME: introduce pattern matching so we can have different "transformers" for each container type.
+    # FIXME: introduce pattern matching so we can have different "transformers" for each container type.
+    return @to_hash.(@containers) if @to_hash
     @containers.each_with_object({}) { |container, hash| hash.merge!(container.to_hash) }
   end
 end

data/lib/trailblazer/context.rb

@@ -1,3 +1,4 @@
+require "trailblazer/option"
 # 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
@@ -11,10 +12,36 @@ module Trailblazer
   # activity (aka wrapped_options).
 
   # only public creator: Build
-  class Context # :data object:
-    def initialize(wrapped_options, mutable_options)
-      @wrapped_options, @mutable_options = wrapped_options, mutable_options
-      # TODO: wrapped_options should be optimized for lookups here since it could also be a Context instance, but should be a ContainerChain.
+  # :data object:
+  class Context
+    # NOTE: In the future, we might look up the Context to use in the ctx.
+    #       The demanding signature is for forward-compat.
+    # @private
+    def self.for(wrapped_options, (ctx, flow_options), **circuit_options) # TODO: remove
+      implementation.build(wrapped_options, {}, [ctx, flow_options], circuit_options)
+    end
+
+    def self.for_circuit(wrapped_options, mutable_options, (ctx, flow_options), **circuit_options)
+      context_class = flow_options[:context_class] || implementation # Context::IndifferentAccess
+
+      context_class.build(wrapped_options, mutable_options, [ctx, flow_options], circuit_options)
+    end
+
+    # @public
+    def self.build(wrapped_options, *)
+      new(wrapped_options)
+    end
+
+    # I hate globals, but currently this is the only easy way for setting the implementation.
+    def self.implementation
+      IndifferentAccess
+    end
+
+    def initialize(wrapped_options, mutable_options, *)
+      @wrapped_options = wrapped_options
+      @mutable_options = mutable_options
+      # TODO: wrapped_options should be optimized for lookups here since
+      # it could also be a Context instance, but should be a ContainerChain.
     end
 
     def [](name)
@@ -39,26 +66,22 @@ module Trailblazer
     end
 
     # @private
-    #
-    # This method might be removed.
     def merge(hash)
       original, mutable_options = decompose
 
-      ctx = Trailblazer::Context( original, mutable_options.merge(hash) )
+      self.class.new(original, mutable_options.merge(hash))
     end
 
     # Return the Context's two components. Used when computing the new output for
     # the next activity.
     def decompose
-      [ @wrapped_options, @mutable_options ]
+      [@wrapped_options, @mutable_options]
     end
 
     def keys
       @mutable_options.keys + @wrapped_options.keys # FIXME.
     end
 
-
-
     # TODO: maybe we shouldn't allow to_hash from context?
     # TODO: massive performance bottleneck. also, we could already "know" here what keys the
     # transformation wants.
@@ -66,14 +89,16 @@ module Trailblazer
     def to_hash
       {}.tap do |hash|
         # the "key" here is to call to_hash on all containers.
-        [ @wrapped_options.to_hash, @mutable_options.to_hash ].each do |options|
+        [@wrapped_options.to_hash, @mutable_options.to_hash].each do |options|
           options.each { |k, v| hash[k.to_sym] = v }
         end
       end
     end
   end
 
-  def self.Context(wrapped_options, mutable_options={})
+  def self.Context(wrapped_options, mutable_options = {})
     Context.new(wrapped_options, mutable_options)
   end
-end # Trailblazer
+end
+
+require "trailblazer/context/indifferent_access"

data/lib/trailblazer/context/aliasing.rb

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,38 @@
+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/context/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Context
-    VERSION = "0.1.1"
+    VERSION = "0.3.0"
   end
 end

data/lib/trailblazer/option.rb

@@ -1,22 +1,5 @@
 module Trailblazer
-  # @note This might go to trailblazer-args along with `Context` at some point.
-  def self.Option(proc)
-    Option.build(Option, proc)
-  end
-
   class Option
-    # 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
-
     # A call implementation invoking `proc.(*args)` and plainly forwarding all arguments.
     # Override this for your own step strategy (see KW#call!).
     # @private
@@ -27,16 +10,28 @@ module Trailblazer
     # 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, **flow_options, &block)
+    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, **flow_options, &block)
+    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".
     #
@@ -75,4 +70,8 @@ module Trailblazer
       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/context_test.rb

@@ -0,0 +1,211 @@
+require "test_helper"
+require "trailblazer/container_chain"
+
+class ArgsTest < Minitest::Spec
+  let(:immutable) { {repository: "User"} }
+
+  let(:ctx) { Trailblazer::Context(immutable) }
+
+  it do
+    ctx = Trailblazer::Context(immutable)
+
+    # it {  }
+    #-
+    # options[] and options[]=
+    ctx[:model]    = Module
+    ctx[:contract] = Integer
+    _(ctx[:model])   .must_equal Module
+    _(ctx[:contract]).must_equal Integer
+
+    # it {  }
+    _(immutable.inspect).must_equal %({:repository=>\"User\"})
+  end
+
+  it "allows false/nil values" do
+    ctx["x"] = false
+    _(ctx["x"]).must_equal false
+
+    ctx["x"] = nil
+    assert_nil ctx["x"]
+  end
+
+  #- #to_hash
+  it do
+    ctx = Trailblazer::Context(immutable)
+
+    # it {  }
+    _(ctx.to_hash).must_equal(repository: "User")
+
+    # last added has precedence.
+    # only symbol keys.
+    # it {  }
+    ctx[:a] = Symbol
+    ctx["a"] = String
+
+    _(ctx.to_hash).must_equal(repository: "User", a: String)
+  end
+
+  describe "#merge" do
+    it do
+      ctx = Trailblazer::Context(immutable)
+
+      merged = ctx.merge(current_user: Module)
+
+      _(merged.to_hash).must_equal(repository: "User", current_user: Module)
+      _(ctx.to_hash).must_equal(repository: "User")
+    end
+  end
+
+  #-
+  it do
+    immutable = {repository: "User", model: Module, current_user: Class}
+
+    Trailblazer::Context(immutable) do |_original, mutable|
+      mutable
+    end
+  end
+end
+
+class ContextWithIndifferentAccessTest < Minitest::Spec
+  it do
+    flow_options    = {}
+    circuit_options = {}
+
+    immutable       = {model: Object, "policy" => Hash}
+
+    ctx = Trailblazer::Context.for_circuit(immutable, {}, [immutable, flow_options], **circuit_options)
+
+    _(ctx[:model]).must_equal Object
+    _(ctx["model"]).must_equal Object
+    _(ctx[:policy]).must_equal Hash
+    _(ctx["policy"]).must_equal Hash
+
+    ctx["contract.default"] = Module
+    _(ctx["contract.default"]).must_equal Module
+    _(ctx[:"contract.default"]).must_equal Module
+
+# key?
+    _(ctx.key?("____contract.default")).must_equal false
+    _(ctx.key?("contract.default")).must_equal true
+    _(ctx.key?(:"contract.default")).must_equal true
+
+# context in context
+    ctx2 = Trailblazer::Context.for_circuit(ctx, {}, [ctx, flow_options], **circuit_options)
+
+    _(ctx2[:model]).must_equal Object
+    _(ctx2["model"]).must_equal Object
+
+    ctx2["contract.default"] = Class
+    _(ctx2["contract.default"]).must_equal Class
+    _(ctx2[:"contract.default"]).must_equal Class
+
+# key?
+    _(ctx2.key?("contract.default")).must_equal true
+    _(ctx2.key?(:"contract.default")).must_equal true
+    _(ctx2.key?("model")).must_equal true
+
+# wrapped ctx doesn't change
+    _(ctx["contract.default"]).must_equal Module
+    _(ctx[:"contract.default"]).must_equal Module
+
+
+    ctx3 = ctx.merge("result" => false)
+
+    _(ctx3["contract.default"]).must_equal Module
+    _(ctx3[:"contract.default"]).must_equal Module
+    _(ctx3["result"]).must_equal false
+    _(ctx3[:result]).must_equal false
+    _(ctx3.key?("result")).must_equal true
+    _(ctx3.key?(:result)).must_equal true
+  end
+
+  it "Aliasable" do
+    flow_options    = {context_alias: {"contract.default" => :contract, "result.default"=>:result, "trace.stack" => :stack}}
+    circuit_options = {}
+
+    immutable       = {model: Object, "policy" => Hash}
+
+    ctx = Trailblazer::Context.for_circuit(immutable, {}, [immutable, flow_options], **circuit_options)
+
+    _(ctx[:model]).must_equal Object
+    _(ctx["model"]).must_equal Object
+    _(ctx[:policy]).must_equal Hash
+    _(ctx["policy"]).must_equal Hash
+
+    ctx["contract.default"] = Module
+    _(ctx["contract.default"]).must_equal Module
+    _(ctx[:"contract.default"]).must_equal Module
+
+    # alias
+    assert_nil ctx[:result]
+    assert_nil ctx["result"]
+
+    _(ctx[:contract]).must_equal Module
+
+    assert_nil ctx[:stack]
+
+  # Set an aliased property via setter
+    ctx["trace.stack"] = Object
+    _(ctx[:stack]).must_equal Object
+    _(ctx["trace.stack"]).must_equal Object
+
+# key?
+    _(ctx.key?("____contract.default")).must_equal false
+    _(ctx.key?("contract.default")).must_equal true
+    _(ctx.key?(:"contract.default")).must_equal true
+    _(ctx.key?(:contract)).must_equal true
+    _(ctx.key?(:result)).must_equal false
+    _(ctx.key?(:stack)).must_equal true
+    _(ctx.key?("trace.stack")).must_equal true
+    _(ctx.key?(:"trace.stack")).must_equal true
+
+# to_hash
+    _(ctx.to_hash).must_equal(:model=>Object, :policy=>Hash, :"contract.default"=>Module, :"trace.stack"=>Object, :contract=>Module, :stack=>Object)
+
+# context in context
+    ctx2 = Trailblazer::Context.for_circuit(ctx, {}, [ctx, flow_options], **circuit_options)
+
+    _(ctx2.key?("____contract.default")).must_equal false
+    _(ctx2.key?("contract.default")).must_equal true
+    _(ctx2.key?(:"contract.default")).must_equal true
+    _(ctx2.key?(:contract)).must_equal true
+    _(ctx2.key?(:result)).must_equal false
+    _(ctx2.key?("result.default")).must_equal false
+    _(ctx2.key?(:stack)).must_equal true
+    _(ctx2.key?("trace.stack")).must_equal true
+    _(ctx2.key?(:"trace.stack")).must_equal true
+
+  # Set aliased in new context via setter
+    ctx2["result.default"] = Class
+
+    _(ctx2[:result]).must_equal Class
+    _(ctx2[:"result.default"]).must_equal Class
+
+    _(ctx2.key?("result.default")).must_equal true
+    _(ctx2.key?(:"result.default")).must_equal true
+    _(ctx2.key?(:result)).must_equal true
+
+    # todo: TEST flow_options={context_class: SomethingElse}
+  end
+
+  it ".build provides default args" do
+    immutable       = {model: Object, "policy.default" => Hash}
+
+  # {Aliasing#initialize}
+    ctx = Trailblazer::Context::IndifferentAccess.new(immutable, {}, context_alias: {"policy.default" => :policy})
+
+    _(ctx[:model]).must_equal Object
+    _(ctx["model"]).must_equal Object
+    _(ctx[:policy]).must_equal Hash
+
+    ctx2 = ctx.merge(result: :success)
+
+
+    _(ctx2[:model]).must_equal Object
+    _(ctx2["model"]).must_equal Object
+    _(ctx2[:policy]).must_equal Hash
+    _(ctx2[:result]).must_equal :success
+  end
+end
+
+# TODO: test overriding Context.implementation.

data/test/option_test.rb

@@ -0,0 +1,186 @@
+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

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require "trailblazer-context"
+
+require "minitest/autorun"

data/trailblazer-context.gemspec

@@ -1,6 +1,6 @@
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'trailblazer/context/version'
+require "trailblazer/context/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "trailblazer-context"
@@ -8,21 +8,22 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Nick Sutterer"]
   spec.email         = ["apotonick@gmail.com"]
 
-  spec.summary       = %q{Argument-specific data structures for Trailblazer.}
-  spec.description   = %q{Argument-specific data structures for Trailblazer such as Context, Option and ContainerChain.}
+  spec.summary       = "Argument-specific data structures for Trailblazer."
+  spec.description   = "Argument-specific data structures for Trailblazer such as Context, Option and ContainerChain."
   spec.homepage      = "http://trailblazer.to/gems/workflow"
   spec.licenses      = ["MIT"]
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
+    f.match(%r(^test/))
   end
-  spec.bindir        = "exe"
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.test_files    = `git ls-files -z test`.split("\x0")
+
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.14"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rake"
 
-  spec.required_ruby_version = '>= 2.0.0'
+  # maybe we could remove this?
+  spec.required_ruby_version = ">= 2.1.0"
 end

metadata

@@ -1,57 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-context
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2017-12-14 00:00:00.000000000 Z
+date: 2020-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
 description: Argument-specific data structures for Trailblazer such as Context, Option
   and ContainerChain.
 email:
@@ -61,6 +61,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".travis.yml"
 - CHANGES.md
 - Gemfile
 - LICENSE
@@ -69,8 +70,13 @@ files:
 - lib/trailblazer-context.rb
 - lib/trailblazer/container_chain.rb
 - lib/trailblazer/context.rb
+- lib/trailblazer/context/aliasing.rb
+- lib/trailblazer/context/indifferent_access.rb
 - lib/trailblazer/context/version.rb
 - lib/trailblazer/option.rb
+- test/context_test.rb
+- test/option_test.rb
+- test/test_helper.rb
 - trailblazer-context.gemspec
 homepage: http://trailblazer.to/gems/workflow
 licenses:
@@ -84,16 +90,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.8
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Argument-specific data structures for Trailblazer.
-test_files: []
+test_files:
+- test/context_test.rb
+- test/option_test.rb
+- test/test_helper.rb