trailblazer-context 0.3.0 → 0.5.0

data/lib/trailblazer/context/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
-  class Context
-    VERSION = "0.3.0"
+  module Context
+    VERSION = "0.5.0"
   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

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
 
   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.homepage      = "https://trailblazer.to/"
   spec.licenses      = ["MIT"]
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
@@ -20,6 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "hashie", ">= 3.0.0"
+
   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.5.0
 platform: ruby
 authors:
 - Nick Sutterer
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-29 00:00:00.000000000 Z
+date: 2021-04-10 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -60,8 +74,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
-- ".travis.yml"
 - CHANGES.md
 - Gemfile
 - LICENSE
@@ -70,19 +84,21 @@ 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
 - trailblazer-context.gemspec
-homepage: http://trailblazer.to/gems/workflow
+homepage: https://trailblazer.to/
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -97,11 +113,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+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