trailblazer-context 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f6c3c7ff9c8b061c5ac0d5aca954f03cd1b5ff0bf286aa787ede12f1e187890
-  data.tar.gz: 0fdc45ffab9316c7799f2ce59f54c6409305cf91fa01349d30d026eac998c188
+  metadata.gz: 74b7b17574531adba20826815dc6bc735063774b17b6f652d13d2800f48972b1
+  data.tar.gz: f761aa2b0a53ffe8699df2cb7dc97d724d52d794e218813e9691f9a5762be211
 SHA512:
-  metadata.gz: 2c9f349028afca126e1961e50ebb0ff661a5fe5a0e2573108c9c79f762694cdb03c6914beca4eec4c5b3b25aecae03d4706c47c84854d0ebb57b6e8a42ec279f
-  data.tar.gz: 1fba9db52f9e3680cccb3b89624c8a159bbd144fbd0b86b3a71972ea1feff96978b82867c976a568aec709b09d0fe859d173a1a813fa5747cb42d179bf6c7520
+  metadata.gz: 718ce62a0c23a69c017580a140af0e273b51b8724654ed55cc0d0594162faf7f8885b64778f34b4c45cfb292f564955213ae297606f4cab81062d677e52df432
+  data.tar.gz: 00dbfe9f61ecb3ae20c06a715d8607a3320611a6b05d099c162f58c7043a598ad06e6902dce1860ea00b9f8bc210043aa18ac04efd563d6ffb2ac6f027235db1

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+*.swp
 /.config
 /coverage/
 /InstalledFiles

data/CHANGES.md

@@ -1,3 +1,12 @@
+# 0.3.1
+
+* Even though this is a patch version, but it contains major changes.
+* `to_hash` speed improvement - Same-ish as `Hash#to_hash`.
+* Maintains replica for faster access and copy actions.
+* Support all other `Hash` features (find, dig, collect etc) on `ctx` object.
+* Namespace context related options within `flow_options`. (`{ flow_options: { context_options: { aliases: {}, ** } } }`).
+* Add `Trailblazer::Context()` API with standard default container & replica class.
+
 # 0.3.0
 * Add support for ruby 2.7
 * Drop support for ruby 2.0

data/Rakefile

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

data/lib/trailblazer-context.rb

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

data/lib/trailblazer/context.rb

@@ -1,104 +1,33 @@
-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
+# The idea of Context 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.
-#
-# notes
-# a context is a ContainerChain with two elements (when reading)
 module Trailblazer
   # Holds local options (aka `mutable_options`) and "original" options from the "outer"
   # activity (aka wrapped_options).
-
   # only public creator: Build
   # :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
+  module Context
+    autoload :Container, "trailblazer/context/container"
 
-      context_class.build(wrapped_options, mutable_options, [ctx, flow_options], circuit_options)
+    module Store
+      autoload :IndifferentAccess, "trailblazer/context/store/indifferent_access"
     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)
-      # ContainerChain.find( [@mutable_options, @wrapped_options], name )
-
-      # in 99.9% or cases @mutable_options will be a Hash, and these are already optimized for lookups.
-      # it's up to the ContainerChain to optimize itself.
-      return @mutable_options[name] if @mutable_options.key?(name)
-      @wrapped_options[name]
-    end
+    module_function
 
-    # TODO: use ContainerChain.find here for a generic optimization
-    #
-    # the version here is about 4x faster for now.
-    def key?(name)
-      # ContainerChain.find( [@mutable_options, @wrapped_options], name )
-      @mutable_options.key?(name) || @wrapped_options.key?(name)
+    def for_circuit(wrapped_options, mutable_options, (_, flow_options), **)
+      build(wrapped_options, mutable_options, flow_options.fetch(:context_options))
     end
 
-    def []=(name, value)
-      @mutable_options[name] = value
-    end
-
-    # @private
-    def merge(hash)
-      original, mutable_options = decompose
-
-      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]
-    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.
-    # FIXME: ToKeywordArguments()
-    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|
-          options.each { |k, v| hash[k.to_sym] = v }
-        end
-      end
+    def build(wrapped_options, mutable_options, container_class:, **context_options)
+      container_class.new(wrapped_options, mutable_options, context_options)
     end
   end
 
-  def self.Context(wrapped_options, mutable_options = {})
-    Context.new(wrapped_options, mutable_options)
+  def self.Context(wrapped_options, mutable_options = {}, context_options = nil)
+    defaults = { container_class: Context::Container, replica_class: Context::Store::IndifferentAccess }
+    Context.build(wrapped_options, mutable_options, defaults.merge( Hash(context_options) ))
   end
 end
-
-require "trailblazer/context/indifferent_access"

data/lib/trailblazer/context/container.rb

@@ -0,0 +1,100 @@
+require "forwardable"
+
+module Trailblazer
+  module Context
+    class Container
+      autoload :WithAliases, "trailblazer/context/container/with_aliases"
+
+      class UseWithAliases < RuntimeError
+        def message
+          %{Pass `Trailblazer::Context::Container::WithAliases` as `container_class` while defining `aliases`}
+        end
+      end
+
+      def initialize(wrapped_options, mutable_options, replica_class:, aliases: nil, **)
+        raise UseWithAliases if aliases
+
+        @wrapped_options  = wrapped_options
+        @mutable_options  = mutable_options
+        @replica_class    = replica_class
+
+        @replica = initialize_replica_store
+      end
+
+      # Return the Context's two components. Used when computing the new output for
+      # the next activity.
+      def decompose
+        [@wrapped_options, @mutable_options]
+      end
+
+      def inspect
+        %{#<Trailblazer::Context::Container wrapped_options=#{@wrapped_options} mutable_options=#{@mutable_options}>}
+      end
+      alias_method :to_s, :inspect
+
+      private def initialize_replica_store
+        @replica_class.new([ @wrapped_options, @mutable_options ])
+      end
+
+      # Some common methods made available directly in Context::Container for
+      # performance tuning, extensions and to avoid `@replica` delegations.
+      module CommonMethods
+        def [](key)
+          @replica[key]
+        end
+
+        def []=(key, value)
+          @replica[key] = value
+          @mutable_options[key] = value
+        end
+        alias_method :store, :[]=
+
+        def delete(key)
+          @replica.delete(key)
+          @mutable_options.delete(key)
+        end
+
+        def merge(other_hash)
+          self.class.new(
+            @wrapped_options,
+            @mutable_options.merge(other_hash),
+            replica_class: @replica_class,
+          )
+        end
+
+        def fetch(key, default = nil, &block)
+          @replica.fetch(key, default, &block)
+        end
+
+        def keys; @replica.keys; end
+
+        def key?(key); @replica.key?(key); end
+
+        def values; @replica.values; end
+
+        def value?(value); @replica.value?(value); end
+
+        def to_hash; @replica.to_hash; end
+
+        def each(&block); @replica.each(&block); end
+        include Enumerable
+      end
+
+      # Additional methods being forwarded on Context::Container
+      # NOTE: def_delegated method calls incurs additional cost
+      # compared to actual method defination calls.
+      # https://github.com/JuanitoFatas/fast-ruby/pull/182
+      module Delegations
+        extend Forwardable
+        def_delegators :@replica,
+          :default, :default=, :default_proc, :default_proc=,
+          :fetch_values, :index, :dig, :slice,
+          :key, :each_key,
+          :each_value, :values_at
+      end
+
+      include CommonMethods
+      extend Delegations
+    end
+  end
+end

data/lib/trailblazer/context/container/with_aliases.rb

@@ -0,0 +1,102 @@
+module Trailblazer
+  module Context
+    class Container
+      # Extension to replace Context::Container writers with aliased writers.
+      # It'll mutate the well known `@mutable_options` with only original keys and
+      # `@replica` with both orignal and aliased keys
+      class WithAliases < Container
+        def initialize(wrapped_options, mutable_options, aliases:, replica_class:, **)
+          @wrapped_options  = wrapped_options
+          @mutable_options  = mutable_options
+
+          # { "contract.default" => :contract, "result.default" => :result }
+          @aliases          = aliases
+
+          @replica_class    = replica_class
+          @replica          = initialize_replica_store
+        end
+
+        def inspect
+          %{#<Trailblazer::Context::Container::WithAliases wrapped_options=#{@wrapped_options} mutable_options=#{@mutable_options} aliases=#{@aliases}>}
+        end
+
+        # @public
+        def aliased_writer(key, value)
+          _key, _alias = alias_mapping_for(key)
+
+          @mutable_options[_key] = value
+          @replica[_key]         = value
+          @replica[_alias]       = value if _alias
+        end
+        alias_method :[]=, :aliased_writer
+
+        # @public
+        def aliased_delete(key)
+          _key, _alias = alias_mapping_for(key)
+
+          @mutable_options.delete(_key)
+          @replica.delete(_key)
+          @replica.delete(_alias) if _alias
+        end
+        alias_method :delete, :aliased_delete
+
+        # @public
+        def aliased_merge(other_hash)
+          # other_hash could have aliases and we don't want to store them in @mutable_options.
+          _other_hash = replace_aliases_with_original_keys(other_hash)
+
+          options = { aliases: @aliases, replica_class: @replica_class }
+          self.class.new(@wrapped_options, @mutable_options.merge(_other_hash), **options)
+        end
+        alias_method :merge, :aliased_merge
+
+        # Returns key and it's mapped alias. `key` could be an alias too.
+        #
+        # aliases => { "contract.default" => :contract, "result.default"=>:result }
+        # key, _alias = alias_mapping_for(:contract)
+        # key, _alias = alias_mapping_for("contract.default")
+        #
+        # @public
+        def alias_mapping_for(key)
+          # when key has an alias
+          return [ key, @aliases[key] ] if @aliases.key?(key)
+
+          # when key is an alias
+          return [ @aliases.key(key), key ] if @aliases.value?(key)
+
+          # when there is no alias
+          return [ key, nil ]
+        end
+
+        private
+
+        # Maintain aliases in `@replica` to make ctx actions faster™
+        def initialize_replica_store
+          replica = @replica_class.new([ @wrapped_options, @mutable_options ])
+
+          @aliases.each do |original_key, _alias|
+            replica[_alias] = replica[original_key] if replica.key?(original_key)
+          end
+
+          replica
+        end
+
+        # Replace aliases from `hash` with their orignal keys.
+        # This is used while doing a `merge` which initializes new Container
+        # with original keys and their aliases.
+        def replace_aliases_with_original_keys(hash)
+          # DISCUSS: Better way to check for alias presence in `hash`
+          return hash unless (hash.keys & @aliases.values).any?
+
+          _hash = hash.dup
+
+          @aliases.each do |original_key, _alias|
+            _hash[original_key] = _hash.delete(_alias) if _hash.key?(_alias)
+          end
+
+          return _hash
+        end 
+      end
+    end
+  end
+end

data/lib/trailblazer/context/store/indifferent_access.rb

@@ -0,0 +1,36 @@
+require "hashie"
+
+module Trailblazer
+  module Context
+    module Store
+      # Simple yet indifferently accessible hash store, used as replica in Context::Container.
+      # It maintains cache for multiple hashes (wrapped_options, mutable_options etc).
+      class IndifferentAccess < Hash
+        include Hashie::Extensions::IndifferentAccess
+
+        def initialize(hashes)
+          hashes.each do |hash|
+            hash.each do |key, value|
+              self[key] = value
+            end
+          end
+        end
+
+        # Override of Hashie::Extensions::IndifferentAccess#indifferent_value
+        # to not do deep indifferent access conversion.
+        # DISCUSS: Should we make this configurable ?
+        def indifferent_value(value)
+          value
+        end
+
+        # Override of Hashie::Extensions::IndifferentAccess#convert_key
+        # to store keys as Symbol by default instead of String.
+        # Why ? We need to pass `ctx` as keyword arguments most of the time.
+        def convert_key(key)
+          return key if Symbol === key 
+          String === key ? key.to_sym : key
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/context/version.rb

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

data/test/benchmark/benchmark_helper.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+require 'benchmark/ips'
+
+BenchmarkRepresenter = Struct.new(:benchmark, :times_slower)
+
+Minitest::Spec.class_eval do
+  def benchmark_ips(records, time: 1, warmup: 1)
+    base    = records[:base]
+    target  = records[:target]
+
+    benchmark = Benchmark.ips do |x|
+      x.config(time: time, warmup: warmup)
+
+      x.report(base[:label], &base[:block])
+      x.report(target[:label], &target[:block])
+
+      x.compare!
+    end
+
+    times_slower = benchmark.data[0][:ips] / benchmark.data[1][:ips]
+    BenchmarkRepresenter.new(benchmark, times_slower)
+  end
+
+  def assert_times_slower(result, threshold)
+    base    = result.benchmark.data[0]
+    target  = result.benchmark.data[1]
+
+    msg = "Expected #{target[:name]} to be slower by at most #{threshold} times than #{base[:name]}, but got #{result.times_slower}"
+
+    assert result.times_slower < threshold, msg
+  end
+end

data/test/benchmark/indifferent_access_test.rb

@@ -0,0 +1,89 @@
+require_relative "benchmark_helper"
+
+describe "Context::IndifferentAccess Performance" do
+  wrapped_options = { model: Object, policy: Hash, representer: String }
+  mutable_options = { write: String, read: Integer, delete: Float, merge: Symbol }
+  context_options = {
+    container_class: Trailblazer::Context::Container,
+    replica_class: Trailblazer::Context::Store::IndifferentAccess,
+  }
+
+  default_hash      = Hash(**wrapped_options, **mutable_options)
+  indifferent_hash  = Trailblazer::Context.build(wrapped_options, mutable_options, context_options)
+
+  it "initialize" do
+    result = benchmark_ips(
+      base: { label: :initialize_default_hash, block: ->{
+        Hash(**wrapped_options, **mutable_options)
+      }},
+      target: { label: :initialize_indifferent_hash, block: ->{
+        Trailblazer::Context.build(wrapped_options, mutable_options, context_options)
+      }},
+    )
+
+    assert_times_slower result, 3
+  end
+
+  it "read" do
+    result = benchmark_ips(
+      base: { label: :read_from_default_hash, block: ->{ default_hash[:read] } },
+      target: { label: :read_from_indifferent_hash, block: ->{ indifferent_hash[:read] } },
+    )
+
+    assert_times_slower result, 1.4
+  end
+
+  it "unknown read" do
+    result = benchmark_ips(
+      base: { label: :unknown_read_from_default_hash, block: ->{ default_hash[:unknown] } },
+      target: { label: :unknown_read_from_indifferent_hash, block: ->{ indifferent_hash[:unknown] } },
+    )
+
+    assert_times_slower result, 3.5
+  end
+
+  it "write" do
+    result = benchmark_ips(
+      base: { label: :write_to_default_hash, block: ->{ default_hash[:write] = "" } },
+      target: { label: :write_to_indifferent_hash, block: ->{ indifferent_hash[:write] = "SKU-1" } },
+    )
+
+    assert_times_slower result, 2.3
+  end
+
+  it "delete" do
+    result = benchmark_ips(
+      base: { label: :delete_from_default_hash, block: ->{ default_hash.delete(:delete) } },
+      target: { label: :delete_from_indifferent_hash, block: ->{ indifferent_hash.delete(:delete) } },
+    )
+
+    assert_times_slower result, 2.4
+  end
+
+  it "merge" do
+    result = benchmark_ips(
+      base: { label: :merge_from_default_hash, block: ->{ default_hash.merge(merge: :object_id) } },
+      target: { label: :merge_from_indifferent_hash, block: ->{ indifferent_hash.merge(merge: :object_id) } },
+    )
+
+    assert_times_slower result, 5.55
+  end
+
+  it "to_hash" do
+    result = benchmark_ips(
+      base: { label: :default_to_hash, block: ->{ default_hash.to_hash } },
+      target: { label: :indifferent_to_hash, block: ->{ indifferent_hash.to_hash } },
+    )
+
+    assert_times_slower result, 1.3
+  end
+
+  it "decompose" do
+    result = benchmark_ips(
+      base: { label: :dup_default_hash, block: ->{ default_hash.to_hash } },
+      target: { label: :decompose, block: ->{ indifferent_hash.decompose } },
+    )
+
+    assert_times_slower result, 1.55
+  end
+end

data/test/benchmark/indifferent_access_with_aliasing_test.rb

@@ -0,0 +1,73 @@
+require_relative "benchmark_helper"
+
+describe "Context::Aliasing Performance" do
+  wrapped_options = { model: Object, policy: Hash, representer: String }
+  mutable_options = { write: String, read: Integer, delete: Float, merge: Symbol }
+
+  context_options = {
+    container_class: Trailblazer::Context::Container::WithAliases,
+    replica_class: Trailblazer::Context::Store::IndifferentAccess,
+    aliases: { read: :reader }
+  }
+
+  default_hash  = Hash(**wrapped_options, **mutable_options)
+  aliased_hash  = Trailblazer::Context.build(wrapped_options, mutable_options, context_options)
+
+  it "initialize" do
+    result = benchmark_ips(
+      base: { label: :initialize_default_hash, block: ->{
+        Hash(**wrapped_options, **mutable_options)
+      }},
+      target: { label: :initialize_aliased_hash, block: ->{
+        Trailblazer::Context.build(wrapped_options, mutable_options, context_options)
+      }},
+    )
+
+    assert_times_slower result, 8
+  end
+
+  it "write" do
+    result = benchmark_ips(
+      base: { label: :write_to_default_hash, block: ->{ default_hash[:write] = "" } },
+      target: { label: :write_to_aliased_hash, block: ->{ aliased_hash[:write] = "" } },
+    )
+
+    assert_times_slower result, 3.66
+  end
+
+  it "read" do
+    result = benchmark_ips(
+      base: { label: :read_from_default_hash, block: ->{ default_hash[:read] } },
+      target: { label: :read_from_aliased_hash, block: ->{ aliased_hash[:reader] } },
+    )
+
+    assert_times_slower result, 1.5
+  end
+
+  it "delete" do
+    result = benchmark_ips(
+      base: { label: :delete_from_default_hash, block: ->{ default_hash.delete(:delete) } },
+      target: { label: :delete_from_aliased_hash, block: ->{ aliased_hash.delete(:delete) } },
+    )
+
+    assert_times_slower result, 4
+  end
+
+  it "merge" do
+    result = benchmark_ips(
+      base: { label: :merge_from_default_hash, block: ->{ default_hash.merge(merge: :object_id) } },
+      target: { label: :merge_from_aliased_hash, block: ->{ aliased_hash.merge(merge: :object_id) } },
+    )
+
+    assert_times_slower result, 8.5
+  end
+
+  it "to_hash" do
+    result = benchmark_ips(
+      base: { label: :default_to_hash, block: ->{ default_hash.to_hash } },
+      target: { label: :aliased_to_hash, block: ->{ aliased_hash.to_hash } },
+    )
+
+    assert_times_slower result, 1.5
+  end
+end

data/test/context_test.rb

@@ -19,6 +19,7 @@ class ArgsTest < Minitest::Spec
 
     # it {  }
     _(immutable.inspect).must_equal %({:repository=>\"User\"})
+    _(ctx.inspect).must_equal %{#<Trailblazer::Context::Container wrapped_options={:repository=>\"User\"} mutable_options={:model=>Module, :contract=>Integer}>}
   end
 
   it "allows false/nil values" do
@@ -51,24 +52,36 @@ class ArgsTest < Minitest::Spec
 
       merged = ctx.merge(current_user: Module)
 
+      _(merged.class).must_equal(Trailblazer::Context::Container)
       _(merged.to_hash).must_equal(repository: "User", current_user: Module)
       _(ctx.to_hash).must_equal(repository: "User")
     end
   end
 
-  #-
+  describe "Enumerable behaviour" do
+    it { _(ctx.each.to_a).must_equal [[:repository, "User"]] }
+    it { _(ctx.find{ |k, _| k == :repository }).must_equal [:repository, "User"] }
+    it { _(ctx.inject([]){ |r, (k, _)| r << k}).must_equal [:repository] }
+  end
+
+  #- #decompose
   it do
     immutable = {repository: "User", model: Module, current_user: Class}
+    mutable   = {error: RuntimeError}
 
-    Trailblazer::Context(immutable) do |_original, mutable|
-      mutable
-    end
+    _([immutable, mutable]).must_equal Trailblazer::Context(immutable, mutable).decompose
   end
 end
 
 class ContextWithIndifferentAccessTest < Minitest::Spec
   it do
-    flow_options    = {}
+    flow_options    = {
+      context_options: {
+        container_class: Trailblazer::Context::Container,
+        replica_class: Trailblazer::Context::Store::IndifferentAccess
+      }
+    }
+
     circuit_options = {}
 
     immutable       = {model: Object, "policy" => Hash}
@@ -108,6 +121,12 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
     _(ctx["contract.default"]).must_equal Module
     _(ctx[:"contract.default"]).must_equal Module
 
+# delete
+    ctx[:model] = Object
+    ctx.delete 'model'
+
+    _(ctx.key?(:model)).must_equal false
+    _(ctx.key?("model")).must_equal false
 
     ctx3 = ctx.merge("result" => false)
 
@@ -120,12 +139,24 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
   end
 
   it "Aliasable" do
-    flow_options    = {context_alias: {"contract.default" => :contract, "result.default"=>:result, "trace.stack" => :stack}}
+    flow_options    = {
+      context_options: {
+        container_class: Trailblazer::Context::Container::WithAliases,
+        replica_class: Trailblazer::Context::Store::IndifferentAccess,
+        aliases: { "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.class).must_equal(Trailblazer::Context::Container::WithAliases)
+
+    _(ctx.inspect).must_equal %{#<Trailblazer::Context::Container::WithAliases wrapped_options={:model=>Object, \"policy\"=>Hash} mutable_options={} aliases={\"contract.default\"=>:contract, \"result.default\"=>:result, \"trace.stack\"=>:stack}>}
+
+    _(ctx.to_hash).must_equal(:model=>Object, :policy=>Hash)
 
     _(ctx[:model]).must_equal Object
     _(ctx["model"]).must_equal Object
@@ -141,14 +172,24 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
     assert_nil ctx["result"]
 
     _(ctx[:contract]).must_equal Module
+    _(ctx['contract']).must_equal Module
 
     assert_nil ctx[:stack]
+    assert_nil ctx['stack']
 
   # Set an aliased property via setter
     ctx["trace.stack"] = Object
     _(ctx[:stack]).must_equal Object
+    _(ctx["stack"]).must_equal Object
     _(ctx["trace.stack"]).must_equal Object
 
+  # Set an aliased property with merge
+    ctx["trace.stack"] = String
+    merged = ctx.merge(stack: Integer)
+
+    _(merged.class).must_equal(Trailblazer::Context::Container::WithAliases)
+    _(merged.to_hash).must_equal(:model=>Object, :policy=>Hash, :contract=>Module, :"contract.default"=>Module, :stack=>Integer, :"trace.stack"=>Integer)
+
 # key?
     _(ctx.key?("____contract.default")).must_equal false
     _(ctx.key?("contract.default")).must_equal true
@@ -159,8 +200,19 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
     _(ctx.key?("trace.stack")).must_equal true
     _(ctx.key?(:"trace.stack")).must_equal true
 
+# delete
+    ctx[:result] = Object
+    ctx.delete :result
+
+    _(ctx.key?(:result)).must_equal false
+    _(ctx.key?("result")).must_equal false
+
+    _(ctx.key?(:"result.default")).must_equal false
+    _(ctx.key?("result.default")).must_equal false
+
+
 # to_hash
-    _(ctx.to_hash).must_equal(:model=>Object, :policy=>Hash, :"contract.default"=>Module, :"trace.stack"=>Object, :contract=>Module, :stack=>Object)
+    _(ctx.to_hash).must_equal(:model=>Object, :policy=>Hash, :contract=>Module, :"contract.default"=>Module, :stack=>String, :"trace.stack"=>String)
 
 # context in context
     ctx2 = Trailblazer::Context.for_circuit(ctx, {}, [ctx, flow_options], **circuit_options)
@@ -188,11 +240,58 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
     # todo: TEST flow_options={context_class: SomethingElse}
   end
 
-  it ".build provides default args" do
-    immutable       = {model: Object, "policy.default" => Hash}
+  it ".build accepts custom container class" do
+    MyContainer = Class.new(Trailblazer::Context::Container) do
+      def inspect
+        %{#<MyContainer wrapped=#{@wrapped_options} mutable=#{@mutable_options}>}
+      end
+    end
+
+    immutable = { model: Object }
+    options   = { container_class: MyContainer, replica_class: Trailblazer::Context::Store::IndifferentAccess }
+
+    ctx = Trailblazer::Context.build(immutable, {}, options)
+    _(ctx.class).must_equal(MyContainer)
+    _(ctx.inspect).must_equal("#<MyContainer wrapped=#{immutable} mutable={}>")
 
-  # {Aliasing#initialize}
-    ctx = Trailblazer::Context::IndifferentAccess.new(immutable, {}, context_alias: {"policy.default" => :policy})
+    _(ctx.to_hash).must_equal({ model: Object })
+
+    ctx[:integer] = Integer
+    _(ctx.to_hash).must_equal({ model: Object, integer: Integer })
+
+    ctx2 = ctx.merge(float: Float)
+    _(ctx2.class).must_equal(MyContainer)
+
+    _(ctx2.to_hash).must_equal({ model: Object, integer: Integer, float: Float })
+  end
+
+  it ".build accepts custom replica class (For example, To opt out from indifferent access)" do
+    MyReplica = Class.new(Hash) do
+      def initialize(*containers)
+        containers.each do |container|
+          container.each{ |key, value| self[key] = value }
+        end
+      end
+    end
+
+    immutable = { model: Object }
+    options   = { container_class: Trailblazer::Context::Container, replica_class: MyReplica }
+
+    ctx = Trailblazer::Context.build(immutable, {}, options)
+    ctx[:integer] = Integer
+
+    _(ctx[:integer]).must_equal(Integer)
+    _(ctx['integer']).must_be_nil
+  end
+
+  it "Context() provides default args" do
+    immutable = {model: Object, "policy.default" => Hash}
+    options   = {
+      container_class: Trailblazer::Context::Container::WithAliases,
+      aliases: { "policy.default" => :policy }
+    }
+
+    ctx = Trailblazer::Context(immutable, {}, options)
 
     _(ctx[:model]).must_equal Object
     _(ctx["model"]).must_equal Object
@@ -206,6 +305,19 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
     _(ctx2[:policy]).must_equal Hash
     _(ctx2[:result]).must_equal :success
   end
+
+  it "Context() throws RuntimeError if aliases are passed but container_class doesn't support it" do
+    immutable = {model: Object, "policy.default" => Hash}
+    options   = {
+      aliases: { "policy.default" => :policy }
+    }
+
+    exception = assert_raises Trailblazer::Context::Container::UseWithAliases do
+      Trailblazer::Context(immutable, {}, options)
+    end
+
+    _(exception.message).must_equal %{Pass `Trailblazer::Context::Container::WithAliases` as `container_class` while defining `aliases`}
+  end
 end
 
 # TODO: test overriding Context.implementation.

data/trailblazer-context.gemspec

@@ -20,6 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "hashie", "~> 4.1"
+
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "rake"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-context
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2020-08-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -70,10 +84,14 @@ 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/container.rb
+- lib/trailblazer/context/container/with_aliases.rb
+- lib/trailblazer/context/store/indifferent_access.rb
 - lib/trailblazer/context/version.rb
 - lib/trailblazer/option.rb
+- test/benchmark/benchmark_helper.rb
+- test/benchmark/indifferent_access_test.rb
+- test/benchmark/indifferent_access_with_aliasing_test.rb
 - test/context_test.rb
 - test/option_test.rb
 - test/test_helper.rb
@@ -97,11 +115,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Argument-specific data structures for Trailblazer.
 test_files:
+- test/benchmark/benchmark_helper.rb
+- test/benchmark/indifferent_access_test.rb
+- test/benchmark/indifferent_access_with_aliasing_test.rb
 - test/context_test.rb
 - test/option_test.rb
 - test/test_helper.rb

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