trailblazer-context 0.1.2 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 067526c4453158c411b7c4416eb16c6054f51b92
-  data.tar.gz: 8c5d5b8cddb29477858653ec4e3ece78c6d08e99
+SHA256:
+  metadata.gz: 74b7b17574531adba20826815dc6bc735063774b17b6f652d13d2800f48972b1
+  data.tar.gz: f761aa2b0a53ffe8699df2cb7dc97d724d52d794e218813e9691f9a5762be211
 SHA512:
-  metadata.gz: a83649f3eb107686ce63c1f5474f52a5bbb8a9dbab165117712bedfce838dd05c155764eb723bb5b43a9eeb93829305dd4efe2a3c041ca6c5eb52d66d4e2ccab
-  data.tar.gz: ebcec8767f92ef3923b88a0b11eb9f9fa3075e7f55cd0052b80d9a074fcd45ed3b00fa6d7c42dc73451c60a35b34499d748c3bc85fde698e3f6ad8e8d69f3723
+  metadata.gz: 718ce62a0c23a69c017580a140af0e273b51b8724654ed55cc0d0594162faf7f8885b64778f34b4c45cfb292f564955213ae297606f4cab81062d677e52df432
+  data.tar.gz: 00dbfe9f61ecb3ae20c06a715d8607a3320611a6b05d099c162f58c7043a598ad06e6902dce1860ea00b9f8bc210043aa18ac04efd563d6ffb2ac6f027235db1

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+*.swp
 /.config
 /coverage/
 /InstalledFiles
@@ -9,6 +10,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,34 @@
+# 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.
+
+# 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.".

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,13 @@ 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
+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

@@ -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,79 +1,33 @@
 # 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
-  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.
-    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
+  # :data object:
+  module Context
+    autoload :Container, "trailblazer/context/container"
 
-    def []=(name, value)
-      @mutable_options[name] = value
+    module Store
+      autoload :IndifferentAccess, "trailblazer/context/store/indifferent_access"
     end
 
-    # @private
-    #
-    # This method might be removed.
-    def merge(hash)
-      original, mutable_options = decompose
+    module_function
 
-      ctx = Trailblazer::Context( original, mutable_options.merge(hash) )
+    def for_circuit(wrapped_options, mutable_options, (_, flow_options), **)
+      build(wrapped_options, mutable_options, flow_options.fetch(:context_options))
     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 # Trailblazer
+end

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