trailblazer-context 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fec7a9c801fedda32fee29585bf8108b6a730980fe826df22d00cd7f0b6c8d1b
-  data.tar.gz: 6a39db80e891a99c802c1262b26434389869fc2b367c34cfffb5923acdd574b4
+  metadata.gz: 68c328cb817dbf1889d8e4619afa0b950786a839d8685c145ac9cda543b63c5b
+  data.tar.gz: 3bbe468cf341ebb429715983c3ea284b02251eedfe0084b6225252fbf5240e4b
 SHA512:
-  metadata.gz: cdfce2ccb6119793c8971e70d0161f8b330b5941f07c7b06467713f3a3ebe42ce2563bcc9c0259bc412fbb12c2264586dde4414456d24f7d3eb2b2c4eec65fc7
-  data.tar.gz: 8f34a42f0b7a245586e86a45482e5d797d40edf9c6164cb149fd11de4bdbfe750b067d69a19eebdd747631df85bd40ce0789b2ce65c050c9309f87bed398795d
+  metadata.gz: 0001ec043007eec13ac0ce4c836f406a4fbfcfee8c759fb85c2059d0fffce774423d8986f504a9b0fc36c31e4d0bd75673a02f2d1e9f92b1229f95af3115f029
+  data.tar.gz: 85848da20e2f7639183f4cefc2095294f183f3217927b8ed573ba307ed122871549f1a5409d3369e767a896f8a64c18af598e30fbf10bc33de3918e546e2c6dd

data/.gitignore

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

data/.travis.yml

@@ -1,8 +1,13 @@
-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
+  - 3.0
+  - 2.7
+  - 2.6
+  - 2.5
+  - 2.4
+jobs:
+  allow_failures:
+    - rvm: ruby-head

data/CHANGES.md

@@ -1,3 +1,43 @@
+# 0.4.0
+
+* Ready for Ruby 3.0. :heart:
+* Remove `Option::KW`, after many years it's been superseded by the original `Trailblazer::Option`.
+
+    To achieve an invocation such as
+
+    ```ruby
+    Option::KW(proc).(ctx, another_positional_arg, **circuit_options)
+    ```
+
+    you can use the new `:keyword_arguments` options.
+
+    ```ruby
+    Option(proc).(ctx, another_positional_arg, keyword_arguments: ctx.to_hash, **circuit_options)
+    ```
+
+    This way, no more guessing is happening about what positional arg is the actual `circuit_options`.
+
+# 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`.

data/Gemfile

@@ -1,5 +1,4 @@
 source "https://rubygems.org"
 gemspec
 
-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

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