trailblazer-context 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 278837bbeb41d58a08abe15cfa239e7c2d0030cf4d4d7de19e98f0982fd70ea1
-  data.tar.gz: 1dffd41a315387722858cf987a4289211cc8ea537664c98b5042539fcee11e6a
+  metadata.gz: 68c328cb817dbf1889d8e4619afa0b950786a839d8685c145ac9cda543b63c5b
+  data.tar.gz: 3bbe468cf341ebb429715983c3ea284b02251eedfe0084b6225252fbf5240e4b
 SHA512:
-  metadata.gz: 553c3dd7b3d9ff2ed9493c4a0d44369d1f6f4442ab9b53679e6e1147f7e052d98974273fa38466056e377e2de03fdd662f8e12d28b99cfde99d1074c5d4aa9e3
-  data.tar.gz: abfddac36f7d1a789f45018d3a79e98f5443e4934a29513f80d728453e5c12cf10e85bd8f061eead6b96006c3f0df85a26a2a80c9184524255b9e7b7a197504c
+  metadata.gz: 0001ec043007eec13ac0ce4c836f406a4fbfcfee8c759fb85c2059d0fffce774423d8986f504a9b0fc36c31e4d0bd75673a02f2d1e9f92b1229f95af3115f029
+  data.tar.gz: 85848da20e2f7639183f4cefc2095294f183f3217927b8ed573ba307ed122871549f1a5409d3369e767a896f8a64c18af598e30fbf10bc33de3918e546e2c6dd

data/.travis.yml

@@ -3,6 +3,7 @@ before_install: gem install bundler
 cache: bundler
 rvm:
   - ruby-head
+  - 3.0
   - 2.7
   - 2.6
   - 2.5

data/CHANGES.md

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

data/Gemfile

@@ -1,5 +1,4 @@
 source "https://rubygems.org"
 gemspec
 
-gem "benchmark-ips"
 gem "minitest-line"

data/lib/trailblazer/context.rb

@@ -18,16 +18,16 @@ module Trailblazer
     module_function
 
     def for_circuit(wrapped_options, mutable_options, (_, flow_options), **)
-      build(wrapped_options, mutable_options, flow_options.fetch(:context_options))
+      build(wrapped_options, mutable_options, **flow_options.fetch(:context_options))
     end
 
     def build(wrapped_options, mutable_options, container_class:, **context_options)
-      container_class.new(wrapped_options, mutable_options, context_options)
+      container_class.new(wrapped_options, mutable_options, **context_options)
     end
   end
 
   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) ))
+    Context.build(wrapped_options, mutable_options, **defaults.merge( Hash(context_options) ))
   end
 end

data/lib/trailblazer/context/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   module Context
-    VERSION = "0.3.3"
+    VERSION = "0.4.0"
   end
 end

data/lib/trailblazer/option.rb

@@ -3,75 +3,45 @@ module Trailblazer
     # A call implementation invoking `proc.(*args)` and plainly forwarding all arguments.
     # Override this for your own step strategy (see KW#call!).
     # @private
-    def self.call!(proc, *args, &block)
-      proc.(*args, &block)
+    def self.call!(proc, *args, keyword_arguments: {}, **, &block)
+      # {**keyword_arguments} gets removed automatically if it's an empty hash.
+      # DISCUSS: is this a good practice?
+      proc.(*args, **keyword_arguments, &block)
     end
 
     # 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, **, &block)
-      call!(proc, *args, &block)
+    def self.evaluate_callable(proc, *args, **options, &block)
+      call!(proc, *args, **options, &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."), **, &block)
-      call!(exec_context.method(proc), *args, &block)
+    def self.evaluate_method(proc, *args, exec_context: raise("No :exec_context given."), **options, &block)
+      call!(exec_context.method(proc), *args, **options, &block)
     end
 
     # Generic builder for a callable "option".
     # @param call_implementation [Class, Module] implements the process of calling the proc
     #   while passing arguments/options to it in a specific style (e.g. kw args, step interface).
     # @return [Proc] when called, this proc will evaluate its option (at run-time).
-    def self.build(call_implementation, proc)
+    def self.build(proc)
       if proc.is_a? Symbol
-        ->(*args, &block) { call_implementation.evaluate_method(proc, *args, &block) }
+        ->(*args, **kws, &block) { Option.evaluate_method(proc, *args, **kws, &block) }
       else
-        ->(*args, &block) { call_implementation.evaluate_callable(proc, *args, &block) }
+        ->(*args, **kws, &block) {
+          Option.evaluate_callable(proc, *args, **kws, &block) }
       end
     end
 
-    # Returns a {Proc} that, when called, invokes the `proc` argument with keyword arguments.
-    # This is known as "step (call) interface".
-    #
-    # This is commonly used by `Operation::step` to wrap the argument and make it
-    # callable in the circuit.
-    #
-    #   my_proc = ->(options, **kws) { options["i got called"] = true }
-    #   task    = Trailblazer::Option::KW(my_proc)
-    #   task.(options = {})
-    #   options["i got called"] #=> true
-    #
-    # Alternatively, you can pass a symbol and an `:exec_context`.
-    #
-    #   my_proc = :some_method
-    #   task    = Trailblazer::Option::KW(my_proc)
-    #
-    #   class A
-    #     def some_method(options, **kws)
-    #       options["i got called"] = true
-    #     end
-    #   end
-    #
-    #   task.(options = {}, exec_context: A.new)
-    #   options["i got called"] #=> true
     def self.KW(proc)
-      Option.build(KW, proc)
-    end
-
-    # TODO: It would be cool if call! was typed and had `options SymbolizedHash` or something.
-    class KW < Option
-      # A different call implementation that calls `proc` with a "step interface".
-      #   your_code.(options, **options)
-      # @private
-      def self.call!(proc, options, *)
-        proc.(options, **options.to_hash) # Step interface: (options, **)
-      end
+      raise "The `Option::KW()` method has been removed in trailblazer-context-0.4.
+Please use `Option(task, keyword_arguments: {...})` instead. Check https://trailblazer.to/2.1/docs/trailblazer.html#trailblazer-context-option"
     end
   end
   # @note This might go to trailblazer-args along with `Context` at some point.
   def self.Option(proc)
-    Option.build(Option, proc)
+    Option.build(proc)
   end
 end

data/test/context_test.rb

@@ -250,7 +250,7 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
     immutable = { model: Object }
     options   = { container_class: MyContainer, replica_class: Trailblazer::Context::Store::IndifferentAccess }
 
-    ctx = Trailblazer::Context.build(immutable, {}, options)
+    ctx = Trailblazer::Context.build(immutable, {}, **options)
     _(ctx.class).must_equal(MyContainer)
     _(ctx.inspect).must_equal("#<MyContainer wrapped=#{immutable} mutable={}>")
 
@@ -277,7 +277,7 @@ class ContextWithIndifferentAccessTest < Minitest::Spec
     immutable = { model: Object }
     options   = { container_class: Trailblazer::Context::Container, replica_class: MyReplica }
 
-    ctx = Trailblazer::Context.build(immutable, {}, options)
+    ctx = Trailblazer::Context.build(immutable, {}, **options)
     ctx[:integer] = Integer
 
     _(ctx[:integer]).must_equal(Integer)

data/test/option_test.rb

@@ -8,6 +8,22 @@ class OptionTest < Minitest::Spec
     _(keywords.inspect).must_equal %({:a=>2, :b=>3})
   end
 
+  # it "what" do
+  #   ctx = {params: 1}
+  #   tmp_options = {constant: Object, model: Module}
+
+  #   builder = Class.new do
+  #     def builder(ctx, constant:, model:, **)
+  #       raise model.inspect
+  #     end
+  #   end.new
+
+  #   circuit_options = {exec_context: builder}
+
+  #   # Trailblazer::Option(:builder, ).(ctx, tmp_options, **circuit_options.merge(keyword_arguments: tmp_options))  # calls {def default_contract!(options, constant:, model:, **)}
+  #   Trailblazer::Option(:builder, ).(ctx, **circuit_options.merge(keyword_arguments: tmp_options))  # calls {def default_contract!(options, constant:, model:, **)}
+  # end
+
   describe "positional and kws" do
     class Step
       def with_positional_and_keywords(options, a: nil, **more_options, &block)
@@ -38,13 +54,13 @@ class OptionTest < Minitest::Spec
 
         # positional = { a: 1 }
         # keywords   = { a: 2, b: 3 }
-        assert_result option.(positional, keywords, exec_context: step)
+        assert_result option.(positional, keyword_arguments: keywords, exec_context: step)
       end
 
       it "allows passing a block, too" do
         step = Step.new
 
-        assert_result option.(positional, keywords, {exec_context: step}, &block), block
+        assert_result option.(positional, keyword_arguments: keywords, exec_context: step, &block), block
       end
     end
 
@@ -52,15 +68,15 @@ class OptionTest < Minitest::Spec
       let(:option) { Trailblazer::Option(WITH_POSITIONAL_AND_KEYWORDS) }
 
       it "-> {} lambda" do
-        assert_result option.(positional, keywords, {})
+        assert_result option.(positional, **{keyword_arguments: keywords})
       end
 
       it "allows passing a block, too" do
-        assert_result option.(positional, keywords, {}, &block), block
+        assert_result option.(positional, **{keyword_arguments: keywords}, &block), block
       end
 
       it "doesn't mind :exec_context" do
-        assert_result option.(positional, keywords, exec_context: "bogus")
+        assert_result option.(positional, keyword_arguments: keywords, exec_context: "bogus")
       end
     end
 
@@ -68,21 +84,27 @@ class OptionTest < Minitest::Spec
       let(:option) { Trailblazer::Option(WithPositionalAndKeywords) }
 
       it "passes through all args" do
-        assert_result option.(positional, keywords, exec_context: nil)
+        assert_result option.(positional, keyword_arguments: keywords, exec_context: nil)
       end
 
       it "allows passing a block, too" do
-        assert_result option.(positional, keywords, {exec_context: nil}, &block), block
+        assert_result option.(positional, keyword_arguments: keywords, exec_context: nil, &block), block
       end
     end
   end
 
   describe "positionals" do
     def assert_result_pos(result)
-      _(result).must_equal([1, 2, [3, 4]])
-      _(positionals).must_equal [1, 2, 3, 4]
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0")
+        _(result).must_equal([1, 2, [3, 4]])
+        _(positionals).must_equal [1, 2, 3, 4]
+      else
+        _(result).must_equal([1, 2, [3, 4, {}]])
+        _(positionals).must_equal [1, 2, 3, 4]
+      end
     end
 
+    # In Ruby < 3.0, {*args} will grab both positionals and keyword arguments.
     class Step
       def with_positionals(a, b, *args)
         [a, b, args]
@@ -122,65 +144,4 @@ class OptionTest < Minitest::Spec
     end
   end
 
-  describe "Option::KW" do
-    def assert_result_kws(result)
-      _(result).must_equal([{a: 1, b: 2, c: 3}, 1, 2, {c: 3}])
-    end
-
-    class Step
-      def with_kws(options, a: nil, b: nil, **rest)
-        [options, a, b, rest]
-      end
-    end
-
-    module Task
-      def self.with_kws(options, a: nil, b: nil, **rest)
-        [options, a, b, rest]
-      end
-    end
-
-    WITH_KWS = ->(options, a: nil, b: nil, **rest) do
-      [options, a, b, rest]
-    end
-
-    class WithKWs
-      def self.call(options, a: nil, b: nil, **rest)
-        [options, a, b, rest]
-      end
-    end
-
-    let(:options) { {a: 1, b: 2, c: 3} }
-
-    it ":method" do
-      step = Step.new
-
-      option = Trailblazer::Option::KW(:with_kws)
-
-      assert_result_kws option.(options, exec_context: step)
-    end
-
-    it "Method instance" do
-      option = Trailblazer::Option::KW(Task.method(:with_kws))
-
-      assert_result_kws option.(options, {})
-    end
-
-    it "-> {} lambda" do
-      option = Trailblazer::Option::KW(WITH_KWS)
-
-      assert_result_kws option.(options, {})
-    end
-
-    it "lambda ignores :exec_context" do
-      option = Trailblazer::Option::KW(WITH_KWS)
-
-      assert_result_kws option.(options, exec_context: "something")
-    end
-
-    it "callable" do
-      option = Trailblazer::Option::KW(WithKWs)
-
-      assert_result_kws option.(options, {})
-    end
-  end
 end

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|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-context
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-02-23 00:00:00.000000000 Z
+date: 2021-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -96,7 +96,7 @@ files:
 - test/option_test.rb
 - test/test_helper.rb
 - trailblazer-context.gemspec
-homepage: http://trailblazer.to/gems/workflow
+homepage: https://trailblazer.to/
 licenses:
 - MIT
 metadata: {}