trailblazer-macro 2.1.7 → 2.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b94581daf3c1a0afeea2d8a3d9f470393b15fbfe57fe01dc29c5d1f247beb7c
-  data.tar.gz: dff368470d21d9fb0f9522bf610ef1e62b51eebf59f9c41f371298d12d11b8e5
+  metadata.gz: 34955a47d4c5d006819242d4d9a13ce658a3473afe0d7f6b4570374dbff557c0
+  data.tar.gz: 4f8fb6b8ba5c8bcc3db19ac977507675550c0defa2be95b771c77914644837b6
 SHA512:
-  metadata.gz: 0a2547701dec5fd643a229313dfeab1d047b1b469208ba54c950cf6f496ef07aa950e6674fb96221fea898dcaff8329f2f3d2ff1f9bec7fa0b758599a96e6329
-  data.tar.gz: a0fb745ffb5a9a313764a08972f5271f66e2f07c097759bd5cccb0521b1f80cf72eadaf3c71ae1dc5abdc8bd311abf0aabf6aed4dbea728328a9c590249d9e24
+  metadata.gz: 71cc088d718a756171fd402d12dfb3b55d817e87356ea13088871dbc539085b92af36f57b7e7e43c817181aac9b73c580f8e69208b96deec43c59f551df742f9
+  data.tar.gz: c400ba9542fd36400b6ebb0bffc142f3a51212a33b48504b527fdd35b15a5060a95d9c8735a9f146e2f259906568515a7199e9eae7087a3ad3a5b59cbb6a0374

data/.github/workflows/ci.yml

@@ -6,7 +6,7 @@ jobs:
       fail-fast: false
       matrix:
         # Due to https://github.com/actions/runner/issues/849, we have to use quotes for '3.0'
-        ruby: [2.5, 2.6, 2.7, '3.0', head, jruby, jruby-head]
+        ruby: [2.5, 2.6, 2.7, '3.0', "3.1", head, jruby]
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2

data/CHANGES.md

@@ -1,3 +1,22 @@
+# 2.1.11
+
+* In `Nested()`, we no longer use `Railway::End::Success` and `Railway::End::Failure` as static outputs but
+  simply use `Railway`'s default termini objects.
+* Use `dsl`'s new `Inject()` API instead of a overriding `:inject` in `Model()` and `Policy()`.
+
+# 2.1.10
+
+* Yanked, pushed accidentially.
+
+# 2.1.9
+
+* Allow omitting `:params` when calling the operation by defaulting it to `{}` in `Model()`.
+* Use `dsl-linear` 0.5.0 and above, which allows removing `Inject()` uses.
+
+# 2.1.8
+
+Yanked due to inconsistency.
+
 # 2.1.7
 
 * Improve `Nested()` warning message.

data/README.md

@@ -2,7 +2,7 @@
 All common Macro's for Trailblazer::Operation, will come here
 
 ## TODO
-Describe the following Macro's:
+Describe the following Macros:
 - Nested
 - Rescue
 - Wrap

data/lib/trailblazer/macro/guard.rb

@@ -8,7 +8,6 @@ module Trailblazer::Macro
       def self.build(callable)
         option = Trailblazer::Option(callable)
 
-        # this gets wrapped in a Operation::Result object.
         ->((ctx, *), **circuit_args) do
           Trailblazer::Operation::Result.new(!!option.call(ctx, keyword_arguments: ctx.to_hash, **circuit_args), {})
         end

data/lib/trailblazer/macro/model.rb

@@ -1,54 +1,60 @@
-module Trailblazer::Macro
+module Trailblazer
+  module Macro
 
-  Linear = Trailblazer::Activity::DSL::Linear
+    def self.Model(model_class = nil, action = :new, find_by_key = :id, id: 'model.build', not_found_terminus: false)
+      task = Activity::TaskBuilder::Binary(Model.new)
 
-  def self.Model(model_class, action = nil, find_by_key = nil, id: 'model.build', not_found_terminus: false)
-    task = Trailblazer::Activity::TaskBuilder::Binary(Model.new)
+      injections = {
+        Activity::Railway.Inject() => [:params], # pass-through {:params} if it's in ctx.
 
-    injection = Trailblazer::Activity::TaskWrap::Inject::Defaults::Extension(
-      :"model.class"          => model_class,
-      :"model.action"         => action,
-      :"model.find_by_key"    => find_by_key
-    )
+        # defaulting as per Inject() API.
+        Activity::Railway.Inject() => {
+          :"model.class"          => ->(*) { model_class },
+          :"model.action"         => ->(*) { action },
+          :"model.find_by_key"    => ->(*) { find_by_key },
+        }
+      }
 
-    options = { task: task, id: id, extensions: [injection] }
-    options = options.merge(Linear::Output(:failure) => Linear::End(:not_found)) if not_found_terminus
+      options = {task: task, id: id}.merge(injections)
 
-    options
-  end
+      options = options.merge(Activity::Railway.Output(:failure) => Activity::Railway.End(:not_found)) if not_found_terminus
 
-  class Model
-    def call(options, params: nil,  **)
-      builder                 = Model::Builder.new
-      options[:model]         = model = builder.call(options, params)
-      options[:"result.model"] = result = Trailblazer::Operation::Result.new(!model.nil?, {})
-
-      result.success?
+      options
     end
 
-    class Builder
-      def call(options, params)
-        action        = options[:"model.action"] || :new
-        model_class   = options[:"model.class"]
-        find_by_key   = options[:"model.find_by_key"] || :id
-        action        = :pass_through unless %i[new find_by].include?(action)
-
-        send("#{action}!", model_class, params, options[:"model.action"], find_by_key)
-      end
-
-      def new!(model_class, params, *)
-        model_class.new
-      end
+    class Model
+      def call(ctx, params: {}, **)
+        builder                 = Model::Builder.new
+        ctx[:model]         = model = builder.call(ctx, params)
+        ctx[:"result.model"] = result = Operation::Result.new(!model.nil?, {})
 
-      # Doesn't throw an exception and will return false to divert to Left.
-      def find_by!(model_class, params, action, find_by_key, *)
-        model_class.find_by(find_by_key.to_sym => params[find_by_key])
+        result.success?
       end
 
-      # Call any method on the model class and pass find_by_key, for example find(params[:id]).
-      def pass_through!(model_class, params, action, find_by_key, *)
-        model_class.send(action, params[find_by_key])
+      class Builder
+        def call(ctx, params)
+          action        = ctx[:"model.action"]
+          model_class   = ctx[:"model.class"]
+          find_by_key   = ctx[:"model.find_by_key"]
+          action        = :pass_through unless %i[new find_by].include?(action)
+
+          send("#{action}!", model_class, params, ctx[:"model.action"], find_by_key)
+        end
+
+        def new!(model_class, params, *)
+          model_class.new
+        end
+
+        # Doesn't throw an exception and will return false to divert to Left.
+        def find_by!(model_class, params, action, find_by_key, *)
+          model_class.find_by(find_by_key.to_sym => params[find_by_key])
+        end
+
+        # Call any method on the model class and pass find_by_key, for example find(params[:id]).
+        def pass_through!(model_class, params, action, find_by_key, *)
+          model_class.send(action, params[find_by_key])
+        end
       end
     end
-  end
+  end # Macro
 end

data/lib/trailblazer/macro/nested.rb

@@ -9,24 +9,26 @@ module Trailblazer
              "Using the `Nested()` macro with operations and activities is deprecated. " \
              "Replace `Nested(#{callable})` with `Subprocess(#{callable})`."
 
-        return Nested.operation_class.Subprocess(callable)
+        return Activity::Railway.Subprocess(callable)
       end
 
-      # dynamic
-      task = Nested::Dynamic.new(callable, auto_wire: auto_wire)
+      task, outputs, compute_legacy_return_signal = Nested.Dynamic(callable, auto_wire: auto_wire)
 
       merge = [
-        [Activity::TaskWrap::Pipeline.method(:insert_before), "task_wrap.call_task", ["Nested.compute_nested_activity", task.method(:compute_nested_activity)]],
-        [Activity::TaskWrap::Pipeline.method(:insert_after),  "task_wrap.call_task", ["Nested.compute_return_signal", task.method(:compute_return_signal)]],
+        [task, id: "Nested.compute_nested_activity", prepend: "task_wrap.call_task"],
       ]
 
-      task_wrap_extension = Activity::TaskWrap::Extension(merge: merge)
+      if compute_legacy_return_signal
+        merge << [compute_legacy_return_signal, id: "Nested.compute_return_signal", append: "task_wrap.call_task"]
+      end
+
+      task_wrap_extension = Activity::TaskWrap::Extension::WrapStatic.new(extension: Activity::TaskWrap::Extension(*merge))
 
       {
         task:       task,
         id:         id,
         extensions: [task_wrap_extension],
-        outputs:    task.outputs,
+        outputs:    outputs,
       }
     end
 
@@ -45,57 +47,64 @@ module Trailblazer
       # by passing their list to {:auto_wire} option.
       #
       # step Nested(:compute_nested, auto_wire: [Create, Update])
-      class Dynamic
-        STATIC_OUTPUTS = {
-          :success => Activity::Output(Activity::Railway::End::Success.new(semantic: :success), :success),
-          :failure => Activity::Output(Activity::Railway::End::Failure.new(semantic: :failure), :failure),
-        }
-
-        def initialize(nested_activity_decider, auto_wire: [])
-          @nested_activity_decider  = Trailblazer::Option(nested_activity_decider)
-          @known_activities         = Array(auto_wire)
-          @outputs                  = compute_task_outputs
+      def self.Dynamic(nested_activity_decider, auto_wire:)
+        if auto_wire.empty?
+          is_legacy = true # no auto_wire means we need to compute the legacy return signal.
+          auto_wire = [Class.new(Activity::Railway)]
         end
 
-        attr_reader :outputs
+        outputs = outputs_for(auto_wire)
+        task    = Dynamic.new(nested_activity_decider)
+        compute_legacy_return_signal = Dynamic::ComputeLegacyReturnSignal.new(outputs) if is_legacy
+
+        return task, outputs, compute_legacy_return_signal
+      end
+
+      # Go through the list of all possible nested activities and compile the total sum of possible outputs.
+      # FIXME: WHAT IF WE HAVE TWO IDENTICALLY NAMED OUTPUTS?
+      # @private
+      def self.outputs_for(activities)
+        activities.map do |activity|
+          Activity::Railway.Subprocess(activity)[:outputs]
+        end.inject(:merge)
+      end
+
+      class Dynamic
+        def initialize(nested_activity_decider)
+          @nested_activity_decider = Trailblazer::Option(nested_activity_decider)
+        end
 
         # TaskWrap step.
-        def compute_nested_activity(wrap_ctx, original_args)
+        def call(wrap_ctx, original_args)
           (ctx, _), original_circuit_options = original_args
 
           # TODO: evaluate the option to get the actual "object" to call.
           activity = @nested_activity_decider.(ctx, keyword_arguments: ctx.to_hash, **original_circuit_options)
 
           # Overwrite :task so task_wrap.call_task will call this activity.
-          # This is a trick so we don't have to repeat logic from #call_task here.
+          # This is a taskWrap trick so we don't have to repeat logic from #call_task here.
           wrap_ctx[:task] = activity
 
           return wrap_ctx, original_args
         end
 
-        def compute_return_signal(wrap_ctx, original_args)
-          # NOOP when @known_activities are present as all possible signals have been registered already.
-          if @known_activities.empty?
-            # Translate the genuine nested signal to the generic Dynamic end (success/failure, only).
-            # Note that here we lose information about what specific event was emitted.
-            wrap_ctx[:return_signal] = wrap_ctx[:return_signal].kind_of?(Activity::Railway::End::Success) ?
-              @outputs[:success].signal : @outputs[:failure].signal
+        # TODO: remove me when we make {:auto_wire} mandatory.
+        class ComputeLegacyReturnSignal
+          SUCCESS_SEMANTICS = [:success, :pass_fast] # TODO: make this injectable/or get it from operation.
+
+          def initialize(outputs)
+            @outputs = outputs # not needed for auto_wire!
           end
 
-          return wrap_ctx, original_args
-        end
+          def call(wrap_ctx, original_args)
+            actual_semantic  = wrap_ctx[:return_signal].to_h[:semantic]
+            applied_semantic = SUCCESS_SEMANTICS.include?(actual_semantic) ? :success : :failure
 
-        private def compute_task_outputs
-          # If :auto_wire is empty, we map outputs to :success and :failure only, for backward compatibility.
-          # This is what {Nested} in 2.0 used to do, where the outcome could only be true/false (or success/failure).
-          return STATIC_OUTPUTS if @known_activities.empty?
+            wrap_ctx[:return_signal] = @outputs.fetch(applied_semantic).signal
 
-          # Merge activity#outputs from all given auto_wirable activities to wire up for this dynamic task.
-          @known_activities.map do |activity|
-            # TODO: Replace this when it's helper gets added.
-            Hash[activity.to_h[:outputs].collect{ |output| [output.semantic, output] }]
-          end.inject(:merge)
-        end
+            return wrap_ctx, original_args
+          end
+        end # ComputeLegacyReturnSignal
       end
     end
   end

data/lib/trailblazer/macro/policy.rb

@@ -8,35 +8,38 @@ module Trailblazer::Macro
         @path = path
       end
 
-      # incoming low-level {Task API}.
+      # incoming low-level {circuit interface}.
       # outgoing Task::Binary API.
-      def call((options, flow_options), **circuit_options)
-        condition = options[@path] # this allows dependency injection.
-        result    = condition.([options, flow_options], **circuit_options)
+      #
+      # Retrieve the injectable {condition}, execute it and interpret its {Result} object.
+      def call((ctx, flow_options), **circuit_options)
+        condition = ctx[@path] # this allows dependency injection.
+        result    = condition.([ctx, flow_options], **circuit_options)
 
-        options[:"policy.#{@name}"]        = result[:policy] # assign the policy as a skill.
-        options[:"result.policy.#{@name}"] = result
+        ctx[:"policy.#{@name}"]        = result[:policy] # assign the policy as a ctx variable.
+        ctx[:"result.policy.#{@name}"] = result
 
         # flow control
-        signal = result.success? ? Trailblazer::Activity::Right : Trailblazer::Activity::Left # since we & this, it's only executed OnRight and the return boolean decides the direction, input is passed straight through.
+        signal = result.success? ? Trailblazer::Activity::Right : Trailblazer::Activity::Left
 
-        return signal, [options, flow_options]
+        return signal, [ctx, flow_options]
       end
     end
 
-    # Adds the `yield` result to the pipe and treats it like a
+    # Adds the `yield` result to the Railway and treats it like a
     # policy-compatible  object at runtime.
-    def self.step(condition, options, &block)
-      name = options[:name]
+    def self.step(condition, name: nil, &block)
       path = :"policy.#{name}.eval"
-
       task = Eval.new(name: name, path: path)
 
-      injection = Trailblazer::Activity::TaskWrap::Inject::Defaults::Extension(
-        path => condition
-      )
+      injections = {
+        Trailblazer::Activity::Railway.Inject() => {
+          # :"policy.default.eval"
+          path => ->(*) { condition }
+        }
+      }
 
-      {task: task, id: path, extensions: [injection]}
+      {task: task, id: path}.merge(injections)
     end
   end
 end

data/lib/trailblazer/macro/version.rb

@@ -1,7 +1,7 @@
 module Trailblazer
   module Version
     module Macro
-      VERSION = "2.1.7"
+      VERSION = "2.1.11"
     end
   end
 end

data/lib/trailblazer/macro.rb

@@ -1,5 +1,4 @@
 require "forwardable"
-require "trailblazer/activity"
 require "trailblazer/activity/dsl/linear"
 require "trailblazer/operation" # TODO: remove this dependency
 
@@ -17,12 +16,13 @@ module Trailblazer
 
   # All macros sit in the {Trailblazer::Macro} namespace, where we forward calls from
   # operations and activities to.
+
   module Activity::DSL::Linear::Helper
-    Policy = Trailblazer::Macro::Policy
+    Constants::Policy = Trailblazer::Macro::Policy
 
-    module ClassMethods
-      extend Forwardable
-      def_delegators Trailblazer::Macro, :Model, :Nested, :Wrap, :Rescue
-    end # ClassMethods
+    # Extending the {Linear::Helper} namespace is the canonical way to import
+    # macros into Railway, FastTrack, Operation, etc.
+    extend Forwardable
+    def_delegators Trailblazer::Macro, :Model, :Nested, :Wrap, :Rescue
   end # Helper
 end

data/test/docs/model_test.rb

@@ -21,6 +21,17 @@ class DocsModelTest < Minitest::Spec
   end
   #:op end
 
+
+  it "defaults {:params} to empty hash when not passed" do
+    result = Create.({})
+    assert_equal true, result.success?
+    assert_equal %{#<struct DocsModelTest::Song id=nil, title=nil>}, result[:model].inspect
+
+    result = Update.({})
+    assert_equal false, result.success?
+    assert_equal "nil", result[:model].inspect
+  end
+
   it do
     #:create
     result = Create.(params: {})
@@ -126,13 +137,38 @@ class DocsModelTest < Minitest::Spec
     class Hit < Song
     end
 
+    #:di-model-class
     result = Create.(params: {}, :"model.class" => Hit)
+    #:di-model-class end
 
     result[:model].inspect.must_equal %{#<struct DocsModelTest::Hit id=nil, title=nil>}
 
   # inject all variables
-    result = Create.(params: {title: "Olympia"}, "model.class": Hit, "model.action": :find_by, "model.find_by_key": :title)
+    #:di-all
+    result = Create.(
+      params:               {title: "Olympia"}, # some random variable.
+      "model.class":        Hit,
+      "model.action":       :find_by,
+      "model.find_by_key": :title
+    )
+    #:di-all end
 
     result[:model].inspect.must_equal %{#<struct DocsModelTest::Hit id=2, title="Olympia">}
+
+  # use empty Model() and inject {model.class} and {model.action}
+    module A
+      #:op-model-empty
+      class Create < Trailblazer::Operation
+        step Model()
+        # ..
+      end
+      #:op-model-empty end
+    end # A
+
+    result = A::Create.(params: {}, :"model.class" => Hit)
+
+    result[:model].inspect.must_equal %{#<struct DocsModelTest::Hit id=nil, title=nil>}
+
+
   end
 end

data/test/docs/nested_test.rb

@@ -151,7 +151,8 @@ class NestedInput < Minitest::Spec
       end
       #:nested-with-pass-fast end
 
-      # pass fast
+      #= {#save} is still called because the {End.pass_fast} terminus is automatically wired to
+      #= the success "output" of Nested().
       create.(seq: []).inspect(:seq).must_equal %{<Result:true [[:create, :just_pass_fast, :save]] >}
     end
   end
@@ -159,15 +160,16 @@ class NestedInput < Minitest::Spec
   it "Nested(:method, auto_wire: *activities) with :pass_fast => End()" do
     module E
       class JsonValidate < Trailblazer::Operation
-        step :validate, Output(:success) => End(:json_validate)
-        include T.def_steps(:validate)
+        step :validate, Output(:failure) => End(:invalid_json)
+        step :save
+        include T.def_steps(:validate, :save)
       end
 
       #:nested-with-auto-wire
       class Create < Trailblazer::Operation
         step :create
         step Nested(:compute_nested, auto_wire: [Validate, JsonValidate]),
-          Output(:json_validate) => End(:jsoned)
+          Output(:invalid_json) => End(:jsoned)
 
         #~meths
         def compute_nested(ctx, what:, **)
@@ -179,10 +181,36 @@ class NestedInput < Minitest::Spec
       end
       #:nested-with-auto-wire end
 
-      result = Create.(seq: [], what: JsonValidate)
+
+    #@ nested {JsonValidate} ends on {End.success}
+      result = Create.(seq: [], what: JsonValidate, validate: true)
+
+      result.inspect(:seq).must_equal %{<Result:true [[:create, :validate, :save]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
+
+    #@ nested {JsonValidate} ends on {End.invalid_json} because validate fails.
+      result = Create.(seq: [], what: JsonValidate, validate: false)
 
       result.inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
       result.event.inspect.must_equal %{#<Trailblazer::Activity::End semantic=:jsoned>}
+
+    #@ nested {JsonValidate} ends on {End.failure} because save fails.
+      result = Create.(seq: [], what: JsonValidate, save: false)
+
+      result.inspect(:seq).must_equal %{<Result:false [[:create, :validate, :save]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+
+    #@ nested {Validate} ends on {End.failure} because validate fails.
+      result = Create.(seq: [], what: Validate, validate: false)
+
+      result.inspect(:seq).must_equal %{<Result:false [[:create, :validate]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+
+    #@ nested {Validate} ends on {End.success}.
+      result = Create.(seq: [], what: Validate)
+
+      result.inspect(:seq).must_equal %{<Result:true [[:create, :validate]] >}
+      result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
     end
   end
 end

data/test/operation/nested_test.rb

@@ -49,6 +49,28 @@ class NestedTest < Minitest::Spec
     result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
   end
 
+  #@ unit test
+  # TODO: make me a non-Operation test.
+  it "allows using multiple Nested() per operation" do
+    create = Class.new(Trailblazer::Operation) do
+      def compute_nested(ctx, what:, **)
+        what
+      end
+
+      step Nested(:compute_nested)
+      step Nested(:compute_nested), id: :compute_nested_again
+    end
+
+    #@ we want both Nested executed
+    result = create.(seq: [], what: SignIn)
+    result.inspect(:seq).must_equal %{<Result:true [[:c, :c]] >}
+    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Success semantic=:success>}
+
+    result = create.wtf?(seq: [], what: SignUp)
+    result.inspect(:seq).must_equal %{<Result:false [[:b]] >}
+    result.event.inspect.must_equal %{#<Trailblazer::Activity::Railway::End::Failure semantic=:failure>}
+  end
+
   it "raises RuntimeError if dynamically nested activities with custom output are not auto wired" do
     exception = assert_raises RuntimeError do
       Class.new(Trailblazer::Operation) do

data/trailblazer-macro.gemspec

@@ -25,8 +25,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "roar"
   spec.add_development_dependency "trailblazer-developer"
 
-  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 0.4.0", "< 0.5.0"
-  spec.add_dependency "trailblazer-operation", ">= 0.7.0" # TODO: this dependency will be removed.
+  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 1.0.0", "< 1.1.0"
+  spec.add_dependency "trailblazer-operation", ">= 0.8.0" # TODO: this dependency will be removed. currently needed for tests?!
 
   spec.required_ruby_version = ">= 2.2.0"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-macro
 version: !ruby/object:Gem::Version
-  version: 2.1.7
+  version: 2.1.11
 platform: ruby
 authors:
 - Nick Sutterer
 - Marc Tich
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-09 00:00:00.000000000 Z
+date: 2022-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,34 +101,34 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 1.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: 1.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: trailblazer-operation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.7.0
+        version: 0.8.0
 description: Macros for Trailblazer's operation
 email:
 - apotonick@gmail.com
@@ -173,7 +173,7 @@ homepage: http://trailblazer.to
 licenses:
 - LGPL-3.0
 metadata: {}
-post_install_message:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -188,8 +188,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
-signing_key:
+rubygems_version: 3.2.3
+signing_key: 
 specification_version: 4
 summary: 'Macros for Trailblazer''s operation: Policy, Wrap, Rescue and more.'
 test_files: