trailblazer-context 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f888d046e1096b02494a7a5fede3827027321d7553d6a01fb5f7ac2dc9fb43cc
-  data.tar.gz: 67f3bd4537ea2671a94ac3a74c55ed2f49ed9e9b58169af8eb2e1767fbc0416b
+  metadata.gz: fec7a9c801fedda32fee29585bf8108b6a730980fe826df22d00cd7f0b6c8d1b
+  data.tar.gz: 6a39db80e891a99c802c1262b26434389869fc2b367c34cfffb5923acdd574b4
 SHA512:
-  metadata.gz: 950342604fd800574b188606453e5dbe2b685fe8bb49c8b4c042d27c4beb91be298c2a4a0e07cc509164b6c5ebc0987785e631f487179dbecffacfb180a11ca3
-  data.tar.gz: f8fafddb80a3441a623c0db104776919313ff99f4eea0d2c0aa8826c00ba0fb89319294e0c3f892db11061825d41f67e9d2d68637768ce67be984533c1d92230
+  metadata.gz: cdfce2ccb6119793c8971e70d0161f8b330b5941f07c7b06467713f3a3ebe42ce2563bcc9c0259bc412fbb12c2264586dde4414456d24f7d3eb2b2c4eec65fc7
+  data.tar.gz: 8f34a42f0b7a245586e86a45482e5d797d40edf9c6164cb149fd11de4bdbfe750b067d69a19eebdd747631df85bd40ce0789b2ce65c050c9309f87bed398795d

data/CHANGES.md

@@ -1,3 +1,13 @@
+# 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.

data/lib/trailblazer/context.rb

@@ -14,10 +14,22 @@ module Trailblazer
   # only public creator: Build
   # :data object:
   class Context
-    # NOTE: in the future, we might look up the Context to use in the ctx.
-    # The options we pass in here to be forward-compatible.
-    def self.for(wrapped_options, (ctx, flow_options), circuit_options)
-      implementation.new(wrapped_options, {})
+    # 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.
@@ -25,7 +37,7 @@ module Trailblazer
       IndifferentAccess
     end
 
-    def initialize(wrapped_options, mutable_options)
+    def initialize(wrapped_options, mutable_options, *)
       @wrapped_options = wrapped_options
       @mutable_options = mutable_options
       # TODO: wrapped_options should be optimized for lookups here since

data/lib/trailblazer/context/aliasing.rb

@@ -0,0 +1,36 @@
+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,18 +1,35 @@
+require "trailblazer/context/aliasing"
+
 module Trailblazer
   class Context
     class IndifferentAccess < Context
-      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]
+      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), circuit_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
+
+      # 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 self.build(wrapped_options, mutable_options, (ctx, flow_options), circuit_options)
+        new(wrapped_options, mutable_options, **flow_options)
+      end
     end
   end
 end

data/lib/trailblazer/context/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Context
-    VERSION = "0.1.4"
+    VERSION = "0.2.0"
   end
 end

data/lib/trailblazer/option.rb

@@ -27,13 +27,13 @@ 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, **circuit_options, &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."), **flow_options, &block)
+    def self.evaluate_method(proc, *args, exec_context: raise("No :exec_context given."), **circuit_options, &block)
       call!(exec_context.method(proc), *args, &block)
     end
 

data/test/context_test.rb

@@ -75,7 +75,7 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
 
     immutable       = {model: Object, "policy" => Hash}
 
-    ctx = Trailblazer::Context.for(immutable, [immutable, flow_options], circuit_options)
+    ctx = Trailblazer::Context.for_circuit(immutable, {}, [immutable, flow_options], circuit_options)
 
     ctx[:model].must_equal Object
     ctx["model"].must_equal Object
@@ -92,7 +92,7 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
     ctx.key?(:"contract.default").must_equal true
 
 # context in context
-    ctx2 = Trailblazer::Context.for(ctx, [ctx, flow_options], circuit_options)
+    ctx2 = Trailblazer::Context.for_circuit(ctx, {}, [ctx, flow_options], circuit_options)
 
     ctx2[:model].must_equal Object
     ctx2["model"].must_equal Object
@@ -120,6 +120,94 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
     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
+    ctx[:result].must_equal nil
+    ctx["result"].must_equal nil
+
+    ctx[:contract].must_equal Module
+
+    ctx[:stack].must_equal nil
+
+  # 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.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-context
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-18 00:00:00.000000000 Z
+date: 2019-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,6 +86,7 @@ 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