flows 0.4.0 → 0.5.0

data/lib/flows/util/inheritable_singleton_vars/isolation_strategy.rb

@@ -16,25 +16,38 @@ module Flows
         VAR_MAP_VAR_NAME = :@inheritable_vars_with_isolation
 
         # @api private
-        module InheritanceCallback
-          def inherited(child_class)
-            IsolationStrategy.migrate(self, child_class)
+        module Migrator
+          def self.call(from, to)
+            parent_var_map = from.instance_variable_get(VAR_MAP_VAR_NAME)
+            child_var_map = to.instance_variable_get(VAR_MAP_VAR_NAME) || {}
 
-            super
-          end
+            to.instance_variable_set(VAR_MAP_VAR_NAME, child_var_map.merge(parent_var_map))
 
-          def included(child_mod)
-            IsolationStrategy.migrate(self, child_mod)
+            parent_var_map.each do |name, value_proc|
+              to.instance_variable_set(name, value_proc.call)
+            end
+          end
+        end
 
-            child_mod.singleton_class.prepend InheritanceCallback
+        # @api private
+        module Injector
+          def included(mod)
+            Migrator.call(self, mod)
+            mod.singleton_class.prepend Injector
 
             super
           end
 
-          def extended(child_mod)
-            IsolationStrategy.migrate(self, child_mod)
+          def extended(mod)
+            Migrator.call(self, mod)
+            mod.singleton_class.prepend Injector
+
+            super
+          end
 
-            child_mod.singleton_class.prepend InheritanceCallback
+          def inherited(mod)
+            Migrator.call(self, mod)
+            mod.singleton_class.prepend Injector
 
             super
           end
@@ -43,60 +56,34 @@ module Flows
         class << self
           # Applies behaviour and defaults for singleton variables.
           #
-          # @note Variable names should look like `:@var` or `'@var'`.
-          #
-          # @param klass [Class] target class.
-          # @param attrs_with_default [Hash<Symbol, String => Proc>] keys are variable names,
-          #   values are procs or lambdas which return default values.
-          #
           # @example
           #   class MyClass
-          #     Flows::Util::InheritableSingletonVars::IsolationStrategy.call(
-          #       self,
+          #     SingletonVarsSetup = Flows::Util::InheritableSingletonVars::IsolationStrategy.make_module(
           #       :@my_list => -> { [] }
           #     )
+          #
+          #     include SingletonVarsSetup
           #   end
-          def call(klass, attrs_with_default = {})
-            init_variables_with_default_values(klass, attrs_with_default)
-
-            var_defaults = attrs_with_default
-            add_variables_to_store(klass, var_defaults)
-
-            inject_inheritance_hook(klass)
-          end
-
-          # Moves variables between modules
           #
-          # @api private
-          def migrate(from_mod, to_mod)
-            new_var_map = from_mod.instance_variable_get(VAR_MAP_VAR_NAME).dup
-
-            to_mod.instance_variable_set(VAR_MAP_VAR_NAME, new_var_map)
-
-            new_var_map.each do |name, default_value_proc|
-              to_mod.instance_variable_set(name, default_value_proc.call)
+          # @note Variable names should look like `:@var` or `'@var'`.
+          #
+          # @param vars_with_default [Hash<Symbol, String => Proc>] keys are variable names,
+          #   values are procs or lambdas which return default values.
+          def make_module(vars_with_default = {})
+            Module.new.tap do |mod|
+              mod.instance_variable_set(VAR_MAP_VAR_NAME, vars_with_default.dup)
+              init_vars(mod, vars_with_default)
+              mod.extend Injector
             end
           end
 
           private
 
-          def init_variables_with_default_values(klass, attrs_with_default)
-            attrs_with_default.each do |name, default_value_proc|
-              klass.instance_variable_set(name, default_value_proc.call)
+          def init_vars(mod, vars_with_default)
+            vars_with_default.each do |name, value_proc|
+              mod.instance_variable_set(name, value_proc.call)
             end
           end
-
-          def add_variables_to_store(klass, var_defaults)
-            store = klass.instance_variable_get(VAR_MAP_VAR_NAME) || {}
-            next_store = store.merge(var_defaults)
-
-            klass.instance_variable_set(VAR_MAP_VAR_NAME, next_store)
-          end
-
-          def inject_inheritance_hook(klass)
-            singleton = klass.singleton_class
-            singleton.prepend(InheritanceCallback) unless singleton.is_a?(InheritanceCallback)
-          end
         end
       end
     end

data/lib/flows/util/inheritable_singleton_vars.rb

@@ -41,30 +41,37 @@ module Flows
     # Each strategy here is using following way of injecting into yours abstract classes:
     #
     #     class BaseSomething
-    #       Flows::Util::InheritableSingletonVars::SomeStrategy.call(
-    #         self,
-    #         **rest_of_the_options_here
+    #       SingletonVarsSetup = Flows::Util::InheritableSingletonVars::SomeStrategy.make_module(
+    #         **options_here
     #       )
+    #
+    #       include SingeltonVarsSetup # extend also will work
     #     end
     #
     # In case of extensions and mixins:
     #
     #     module MyExtension
-    #       def self.extended(mod)
-    #         Flows::Util::InheritableSingletonVars::SomeStrategy.call(
-    #           mod,
-    #           **rest_of_the_options_here
-    #         )
-    #       end
+    #       SingletonVarsSetup = Flows::Util::InheritableSingletonVars::SomeStrategy.make_module(
+    #         **options_here
+    #       )
+    #
+    #       include SingeltonVarsSetup # extend also will work
+    #     end
+    #
+    #     class SomethingA
+    #       extend MyExtension
     #     end
     #
     #     module MyMixin
-    #       def self.included(mod)
-    #         Flows::Util::InheritableSingletonVars::SomeStrategy.call(
-    #           mod,
-    #           **rest_of_the_options_here
-    #         )
-    #       end
+    #       SingletonVarsSetup = Flows::Util::InheritableSingletonVars::SomeStrategy.make_module(
+    #         **options_here
+    #       )
+    #
+    #       include SingeltonVarsSetup # extend also will work
+    #     end
+    #
+    #     class SomethingB
+    #       include MyMixin
     #     end
     #
     # Moreover, you can use multiple strategies in the same class.

data/lib/flows/util/prepend_to_class.rb

@@ -78,7 +78,7 @@ module Flows
     #     module HasData
     #       attr_reader :data
     #
-    #       module InitializePatch
+    #       InitializePatch = Flows::Util::PrependToClass.make_module do
     #         def initialize(*args, **kwargs, &block)
     #           @data = kwargs[:data]
     #
@@ -92,7 +92,7 @@ module Flows
     #         end
     #       end
     #
-    #       Flows::Util::PrependToClass.call(self, InitializePatch)
+    #       include InitializePatch
     #     end
     #
     #     module Stuff
@@ -113,20 +113,54 @@ module Flows
     #
     #     x.data
     #     # => 'data'
+    #
+    #     x.greeting
+    #     # => 'hello'
+    #
+    # @note this solution is designed to patch `include` behaviour and
+    #   has no effect on `extend`.
     module PrependToClass
       class << self
-        # When `mod` is included into class in any way `module_to_prepend`
-        # will be prepended to the class.
+        # Allows to prepend some module to class when
+        # host module included into class.
+        #
+        # Under the hood two modules are created:
+        #
+        # * "to prepend" module made from provided block
+        # * "container" module which will be returned by this method
+        #
+        # When you include "container" module into your module `Mod`
+        # you're enabling the following behaviour:
+        #
+        # * when `Mod` included into class - "to prepend" module will be prepended to class
+        # * when `Mod` is included into some module `Mod2` - `Mod2` also will
+        #   prepend "to prepend" module when included into class.
+        # * you can include `Mod` into `Mod2`, then include `Mod2` into `Mod3` -
+        #   desribed behavior works for include chain of any length.
         #
-        # @param mod [Module] host module
-        # @param module_to_prepend [Module] module to be prepended to a class
-        def call(mod, module_to_prepend)
-          mod.singleton_class.prepend injector(module_to_prepend)
+        # Moreover, this behaviour also works with `extend`, not only `include`.
+        #
+        # @yield body for module which will be prepended
+        # @return [Module] module to be included or extended into your module
+        def make_module(&module_body)
+          Module.new.tap do |mod|
+            to_prepend_mod = Module.new(&module_body)
+            mod.const_set(:ToPrepend, to_prepend_mod)
+
+            set_injector_mod(mod, to_prepend_mod)
+          end
         end
 
         private
 
-        def injector(module_to_prepend)
+        def set_injector_mod(mod, module_to_prepend)
+          injector = make_injector_mod(module_to_prepend)
+
+          mod.const_set(:Injector, injector)
+          mod.singleton_class.prepend(injector)
+        end
+
+        def make_injector_mod(module_to_prepend)
           Module.new.tap do |injector|
             injector.define_method(:included) do |target_mod|
               if target_mod.class == Class

data/lib/flows/version.rb

@@ -1,3 +1,3 @@
 module Flows
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.5.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flows
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Roman Kolesnev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-04-21 00:00:00.000000000 Z
+date: 2020-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -433,6 +433,7 @@ files:
 - bin/errors
 - bin/errors_cli/contract_error_demo.rb
 - bin/errors_cli/di_error_demo.rb
+- bin/errors_cli/flow_error_demo.rb
 - bin/errors_cli/flows_router_error_demo.rb
 - bin/errors_cli/oc_error_demo.rb
 - bin/errors_cli/railway_error_demo.rb
@@ -460,6 +461,7 @@ files:
 - lib/flows/contract/transformer.rb
 - lib/flows/contract/tuple.rb
 - lib/flows/flow.rb
+- lib/flows/flow/errors.rb
 - lib/flows/flow/node.rb
 - lib/flows/flow/router.rb
 - lib/flows/flow/router/custom.rb
@@ -476,6 +478,17 @@ files:
 - lib/flows/plugin/output_contract/dsl.rb
 - lib/flows/plugin/output_contract/errors.rb
 - lib/flows/plugin/output_contract/wrapper.rb
+- lib/flows/plugin/profiler.rb
+- lib/flows/plugin/profiler/injector.rb
+- lib/flows/plugin/profiler/report.rb
+- lib/flows/plugin/profiler/report/events.rb
+- lib/flows/plugin/profiler/report/flat.rb
+- lib/flows/plugin/profiler/report/flat/method_report.rb
+- lib/flows/plugin/profiler/report/raw.rb
+- lib/flows/plugin/profiler/report/tree.rb
+- lib/flows/plugin/profiler/report/tree/calculated_node.rb
+- lib/flows/plugin/profiler/report/tree/node.rb
+- lib/flows/plugin/profiler/wrapper.rb
 - lib/flows/railway.rb
 - lib/flows/railway/dsl.rb
 - lib/flows/railway/errors.rb
@@ -489,12 +502,15 @@ files:
 - lib/flows/result/ok.rb
 - lib/flows/shared_context_pipeline.rb
 - lib/flows/shared_context_pipeline/dsl.rb
+- lib/flows/shared_context_pipeline/dsl/callbacks.rb
+- lib/flows/shared_context_pipeline/dsl/tracks.rb
 - lib/flows/shared_context_pipeline/errors.rb
 - lib/flows/shared_context_pipeline/mutation_step.rb
 - lib/flows/shared_context_pipeline/router_definition.rb
 - lib/flows/shared_context_pipeline/step.rb
 - lib/flows/shared_context_pipeline/track.rb
 - lib/flows/shared_context_pipeline/track_list.rb
+- lib/flows/shared_context_pipeline/wrap.rb
 - lib/flows/util.rb
 - lib/flows/util/inheritable_singleton_vars.rb
 - lib/flows/util/inheritable_singleton_vars/dup_strategy.rb