trailblazer-context 0.1.4 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f888d046e1096b02494a7a5fede3827027321d7553d6a01fb5f7ac2dc9fb43cc
-  data.tar.gz: 67f3bd4537ea2671a94ac3a74c55ed2f49ed9e9b58169af8eb2e1767fbc0416b
+  metadata.gz: 278837bbeb41d58a08abe15cfa239e7c2d0030cf4d4d7de19e98f0982fd70ea1
+  data.tar.gz: 1dffd41a315387722858cf987a4289211cc8ea537664c98b5042539fcee11e6a
 SHA512:
-  metadata.gz: 950342604fd800574b188606453e5dbe2b685fe8bb49c8b4c042d27c4beb91be298c2a4a0e07cc509164b6c5ebc0987785e631f487179dbecffacfb180a11ca3
-  data.tar.gz: f8fafddb80a3441a623c0db104776919313ff99f4eea0d2c0aa8826c00ba0fb89319294e0c3f892db11061825d41f67e9d2d68637768ce67be984533c1d92230
+  metadata.gz: 553c3dd7b3d9ff2ed9493c4a0d44369d1f6f4442ab9b53679e6e1147f7e052d98974273fa38466056e377e2de03fdd662f8e12d28b99cfde99d1074c5d4aa9e3
+  data.tar.gz: abfddac36f7d1a789f45018d3a79e98f5443e4934a29513f80d728453e5c12cf10e85bd8f061eead6b96006c3f0df85a26a2a80c9184524255b9e7b7a197504c

data/.gitignore

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

data/.travis.yml

@@ -1,8 +1,12 @@
-sudo: false
 language: ruby
 before_install: gem install bundler
+cache: bundler
 rvm:
-  - 2.5.1
-  - 2.4.4
-  - 2.3.7
-  - 2.2.10
+  - ruby-head
+  - 2.7
+  - 2.6
+  - 2.5
+  - 2.4
+jobs:
+  allow_failures:
+    - rvm: ruby-head

data/CHANGES.md

@@ -1,3 +1,34 @@
+# 0.3.3
+
+* Remove an unsolicited `puts`.
+
+# 0.3.2
+
+* Relax gem dependency: `hashie` >= 3.0.
+
+# 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
+
+# 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/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

@@ -1,6 +1,5 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
-require "rubocop/rake_task"
 
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
@@ -8,6 +7,10 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/*_test.rb"]
 end
 
-RuboCop::RakeTask.new(:rubocop)
+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/container_chain.rb

@@ -39,11 +39,9 @@ class Trailblazer::Context::ContainerChain
   end
 end
 
-# rubocop:disable Style/AsciiComments
 # alternative implementation:
 # containers.reverse.each do |container| @mutable_options.merge!(container) end
 #
 # benchmark, merging in #initialize vs. this resolver.
 #                merge     39.678k (± 9.1%) i/s -    198.700k in   5.056653s
 #             resolver     68.928k (± 6.4%) i/s -    342.836k in   5.001610s
-# rubocop:enable Style/AsciiComments

data/lib/trailblazer/context.rb

@@ -1,92 +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 options we pass in here to be forward-compatible.
-    def self.for(wrapped_options, (ctx, flow_options), circuit_options)
-      implementation.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
-
-    # 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)
-    end
-
-    def []=(name, value)
-      @mutable_options[name] = value
-    end
-
-    # @private
-    def merge(hash)
-      original, mutable_options = decompose
+  module Context
+    autoload :Container, "trailblazer/context/container"
 
-      self.class.new(original, mutable_options.merge(hash))
+    module Store
+      autoload :IndifferentAccess, "trailblazer/context/store/indifferent_access"
     end
 
-    # Return the Context's two components. Used when computing the new output for
-    # the next activity.
-    def decompose
-      [@wrapped_options, @mutable_options]
-    end
+    module_function
 
-    def keys
-      @mutable_options.keys + @wrapped_options.keys # FIXME.
+    def for_circuit(wrapped_options, mutable_options, (_, flow_options), **)
+      build(wrapped_options, mutable_options, flow_options.fetch(:context_options))
     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