flows 0.4.0 → 0.5.0

data/lib/flows/plugin/profiler/report.rb

@@ -0,0 +1,48 @@
+require_relative 'report/events'
+require_relative 'report/raw'
+require_relative 'report/tree'
+require_relative 'report/flat'
+
+module Flows
+  module Plugin
+    module Profiler
+      # Base class for {Profiler} reports.
+      #
+      # @!method to_s
+      #   @abstract
+      #   @return [String] human-readable representation.
+      class Report
+        # @return [Array<Array>] raw profiler events
+        attr_reader :raw_data
+
+        def initialize
+          @raw_data = []
+        end
+
+        # Add event to profile report.
+        #
+        # @param event_type [:started, :finished] event type
+        # @param klass [Class] class where called method is placed
+        # @param method_type [:instance, :singleton] method type
+        # @param method_name [Symbol] name of the called method
+        # @param data [nil, Float] event data, time represented as
+        #   a Float microseconds value.
+        def add(*args)
+          raw_data << args
+        end
+
+        # @return [Array<Event>] array of events
+        def events
+          raw_data.map do |raw_event|
+            klass = case raw_event.first
+                    when :started then StartEvent
+                    when :finished then FinishEvent
+                    end
+
+            klass.new(*raw_event[1..-1])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin/profiler/wrapper.rb

@@ -0,0 +1,53 @@
+module Flows
+  module Plugin
+    module Profiler
+      # @api private
+      module Wrapper
+        class << self
+          def make_instance_wrapper(method_name) # rubocop:disable Metrics/MethodLength
+            Module.new.tap do |mod|
+              mod.define_method(method_name) do |*args, &block| # rubocop:disable Metrics/MethodLength
+                thread = Thread.current
+                klass = self.class
+
+                return super(*args, &block) unless thread[THREAD_VAR_FLAG]
+
+                report = thread[THREAD_VAR_REPORT]
+                report.add(:started, klass, :instance, method_name, nil)
+
+                before = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_microsecond)
+                super(*args, &block)
+              ensure
+                if before
+                  after = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_microsecond)
+                  report.add(:finished, klass, :instance, method_name, after - before)
+                end
+              end
+            end
+          end
+
+          def make_singleton_wrapper(method_name) # rubocop:disable Metrics/MethodLength
+            Module.new.tap do |mod|
+              mod.define_method(method_name) do |*args, &block| # rubocop:disable Metrics/MethodLength
+                thread = Thread.current
+
+                return super(*args, &block) unless thread[THREAD_VAR_FLAG]
+
+                report = thread[THREAD_VAR_REPORT]
+                report.add(:started, self, :singleton, method_name, nil)
+
+                before = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_microsecond)
+                super(*args, &block)
+              ensure
+                if before
+                  after = Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_microsecond)
+                  report.add(:finished, self, :singleton, method_name, after - before)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin/profiler.rb

@@ -0,0 +1,114 @@
+require_relative 'profiler/report'
+require_relative 'profiler/injector'
+require_relative 'profiler/wrapper'
+
+module Flows
+  module Plugin
+    # Allows to record execution count and time of particular method on class or singleton class.
+    #
+    # Recorded data can be displayed in a different ways.
+    # See {Profiler::Report} implementations for possible options.
+    #
+    # To do a measurement you have call your classes inside {.profile} block.
+    #
+    # @note even without calling {.profile} using this module has some performance
+    #   impact. Don't left this module used in production environments.
+    #
+    # @example
+    #     class MyClass
+    #       CallProfiler = Flows::Plugin::Profiler.for_method(:call)
+    #       include CallProfiler
+    #
+    #       def call(a, b)
+    #         # some work here
+    #       end
+    #     end
+    #
+    #     class AnotherClass
+    #       CallProfiler = Flows::Plugin::Profiler.for_method(:perform)
+    #       extend CallProfiler
+    #
+    #       def self.perform(x)
+    #         MyClass.new.call(x, x)
+    #       end
+    #     end
+    #
+    #     last_result = Flows::Plugin::Profiler.profile do
+    #       AnotherClass.perform(2)
+    #       AnotherClass.perform(6)
+    #     end
+    #
+    #     Profiler.last_report.to_a
+    #     # => [
+    #     #   [:started,  AnotherClass, :singleton, :perform, nil],
+    #     #   [:started,  MyClass,      :instance,  :call,    nil],
+    #     #   [:finished, MyClass,      :instance,  :call,    7.3],
+    #     #   [:finished, AnotherClass, :singleton, :perform, 10.5],
+    #     #   [:started,  AnotherClass, :singleton, :perform, nil],
+    #     #   [:started,  MyClass,      :instance,  :call,    nil],
+    #     #   [:finished, MyClass,      :instance,  :call,    8.8],
+    #     #   [:finished, AnotherClass, :singleton, :perform, 14.2]
+    #     # ]
+    module Profiler
+      THREAD_VAR_FLAG = :flows_profiler_flag
+      THREAD_VAR_REPORT = :flows_profiler_report
+
+      class << self
+        # Generates profiler module for a particular method.
+        #
+        # Use `include` for instance methods and `extend` for singleton ones.
+        #
+        # @param method_name [Symbol] method to wrap with profiling.
+        # @return [Module] module to include or extend.
+        def for_method(method_name)
+          Module.new.tap do |mod|
+            injector_mod = Injector.make_module(method_name)
+            mod.const_set(:Injector, injector_mod)
+            mod.extend injector_mod
+          end
+        end
+
+        # Profiles a block execution.
+        #
+        # @param report [Report, Symbol]
+        #   desired {Report} to be used.
+        #   In case of symbol `:some_name` the `Flows::Plugin::Profiler::Report::SomeName.new` will be used.
+        # @yield code to profile
+        # @return block result
+        def profile(report = :raw)
+          thread = Thread.current
+
+          thread[THREAD_VAR_FLAG] = true
+          thread[THREAD_VAR_REPORT] = make_report(report)
+
+          yield
+        ensure
+          thread[THREAD_VAR_FLAG] = false
+        end
+
+        # Resets thread-local variables used for reporting.
+        def reset
+          thread = Thread.current
+          thread[THREAD_VAR_FLAG] = false
+          thread[THREAD_VAR_REPORT] = nil
+        end
+
+        # @return [Report, nil] last generated report if some.
+        def last_report
+          Thread.current[THREAD_VAR_REPORT]
+        end
+
+        private
+
+        def make_report(report_or_sym)
+          case report_or_sym
+          when Report then report_or_sym
+          when Symbol
+            const_name = report_or_sym.to_s.split('_').map(&:capitalize).join
+            Report.const_get(const_name).new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/flows/plugin.rb

@@ -11,3 +11,4 @@ end
 require_relative 'plugin/dependency_injector'
 require_relative 'plugin/implicit_init'
 require_relative 'plugin/output_contract'
+require_relative 'plugin/profiler'

data/lib/flows/railway/dsl.rb

@@ -4,11 +4,12 @@ module Flows
     module DSL
       attr_reader :steps
 
-      Flows::Util::InheritableSingletonVars::DupStrategy.call(
-        self,
+      SingletonVarsSetup = Flows::Util::InheritableSingletonVars::DupStrategy.make_module(
         '@steps' => StepList.new
       )
 
+      include SingletonVarsSetup
+
       def step(name, lambda = nil)
         steps.add(name: name, lambda: lambda)
       end

data/lib/flows/result/do.rb

@@ -124,6 +124,12 @@ module Flows
     module Do
       MOD_VAR_NAME = :@flows_result_module_for_do
 
+      SingletonVarsSetup = ::Flows::Util::InheritableSingletonVars::IsolationStrategy.make_module(
+        MOD_VAR_NAME => -> { Module.new }
+      )
+
+      include SingletonVarsSetup
+
       # Utility functions for Flows::Result::Do.
       #
       # Isolated location prevents polluting user classes with unnecessary methods.
@@ -156,14 +162,6 @@ module Flows
         end
       end
 
-      # @api private
-      def self.extended(mod)
-        ::Flows::Util::InheritableSingletonVars::IsolationStrategy.call(
-          mod,
-          MOD_VAR_NAME => -> { Module.new }
-        )
-      end
-
       def do_notation(method_name)
         prepended_mod = Util.fetch_and_prepend_module(self)
 

data/lib/flows/shared_context_pipeline/dsl/callbacks.rb

@@ -0,0 +1,38 @@
+module Flows
+  class SharedContextPipeline
+    module DSL
+      # @api private
+      module Callbacks
+        SingletonVarsSetup = Flows::Util::InheritableSingletonVars::DupStrategy.make_module(
+          '@before_all_callbacks' => [],
+          '@after_all_callbacks' => [],
+          '@before_each_callbacks' => [],
+          '@after_each_callbacks' => []
+        )
+
+        include SingletonVarsSetup
+
+        attr_reader :before_all_callbacks
+        attr_reader :after_all_callbacks
+        attr_reader :before_each_callbacks
+        attr_reader :after_each_callbacks
+
+        def before_all(&callback)
+          before_all_callbacks << callback
+        end
+
+        def after_all(&callback)
+          after_all_callbacks << callback
+        end
+
+        def before_each(&callback)
+          before_each_callbacks << callback
+        end
+
+        def after_each(&callback)
+          after_each_callbacks << callback
+        end
+      end
+    end
+  end
+end

data/lib/flows/shared_context_pipeline/dsl/tracks.rb

@@ -0,0 +1,52 @@
+module Flows
+  class SharedContextPipeline
+    module DSL
+      # @api private
+      module Tracks
+        DEFAULT_ROUTER_DEF = RouterDefinition.new(
+          Flows::Result::Ok => :next,
+          Flows::Result::Err => :end
+        )
+
+        SingletonVarsSetup = Flows::Util::InheritableSingletonVars::DupStrategy.make_module(
+          '@tracks' => TrackList.new
+        )
+
+        include SingletonVarsSetup
+
+        attr_reader :tracks
+
+        def step(name, router_def = DEFAULT_ROUTER_DEF, &lambda)
+          tracks.add_step(
+            Step.new(name: name, lambda: lambda, router_def: router_def)
+          )
+        end
+
+        def mut_step(name, router_def = DEFAULT_ROUTER_DEF, &lambda)
+          tracks.add_step(
+            MutationStep.new(name: name, lambda: lambda, router_def: router_def)
+          )
+        end
+
+        def wrap(name, router_def = DEFAULT_ROUTER_DEF, &tracks_definitions)
+          tracks.add_step(
+            Wrap.new(method_name: name, router_def: router_def, &tracks_definitions)
+          )
+        end
+
+        def track(name, &block)
+          track_before = tracks.current_track
+
+          tracks.switch_track(name)
+          instance_exec(&block)
+          tracks.switch_track(track_before)
+        end
+
+        # :reek:UtilityFunction is allowed here
+        def routes(routes_def)
+          RouterDefinition.new(routes_def)
+        end
+      end
+    end
+  end
+end

data/lib/flows/shared_context_pipeline/dsl.rb

@@ -1,63 +1,12 @@
+require_relative 'dsl/tracks'
+require_relative 'dsl/callbacks'
+
 module Flows
   class SharedContextPipeline
     # @api private
     module DSL
-      attr_reader :tracks
-      attr_reader :before_all_callbacks
-      attr_reader :after_all_callbacks
-      attr_reader :before_each_callbacks
-      attr_reader :after_each_callbacks
-
-      DEFAULT_ROUTER_DEF = RouterDefinition.new(
-        Flows::Result::Ok => :next,
-        Flows::Result::Err => :end
-      )
-
-      Flows::Util::InheritableSingletonVars::DupStrategy.call(
-        self,
-        '@tracks' => TrackList.new,
-        '@before_all_callbacks' => [],
-        '@after_all_callbacks' => [],
-        '@before_each_callbacks' => [],
-        '@after_each_callbacks' => []
-      )
-
-      def step(name, router_def = DEFAULT_ROUTER_DEF, &lambda)
-        tracks.add_step(name: name, lambda: lambda, router_def: router_def)
-      end
-
-      def mut_step(name, router_def = DEFAULT_ROUTER_DEF, &lambda)
-        tracks.add_mutation_step(name: name, lambda: lambda, router_def: router_def)
-      end
-
-      def track(name, &block)
-        track_before = tracks.current_track
-
-        tracks.switch_track(name)
-        instance_exec(&block)
-        tracks.switch_track(track_before)
-      end
-
-      # :reek:UtilityFunction is allowed here
-      def routes(routes_def)
-        RouterDefinition.new(routes_def)
-      end
-
-      def before_all(&callback)
-        before_all_callbacks << callback
-      end
-
-      def after_all(&callback)
-        after_all_callbacks << callback
-      end
-
-      def before_each(&callback)
-        before_each_callbacks << callback
-      end
-
-      def after_each(&callback)
-        after_each_callbacks << callback
-      end
+      include Tracks
+      include Callbacks
     end
   end
 end

data/lib/flows/shared_context_pipeline/mutation_step.rb

@@ -1,28 +1,26 @@
 module Flows
   class SharedContextPipeline
     EMPTY_HASH = {}.freeze
-    EMPTY_OK = Flows::Result::Ok.new(nil).freeze
-    EMPTY_ERR = Flows::Result::Err.new(nil).freeze
+    EMPTY_OK = Flows::Result::Ok.new({}.freeze).freeze
+    EMPTY_ERR = Flows::Result::Err.new({}.freeze).freeze
 
     # @api private
     class MutationStep < Step
-      NODE_PREPROCESSOR = lambda do |_input, context, meta|
-        context[:last_step] = meta[:name]
-
+      NODE_PREPROCESSOR = lambda do |_input, context, node_meta|
         context[:class].before_each_callbacks.each do |callback|
-          callback.call(context[:class], meta[:name], context[:data])
+          callback.call(context[:class], node_meta[:name], context[:data], context[:meta])
         end
 
         [[context[:data]], EMPTY_HASH]
       end
 
-      NODE_POSTPROCESSOR = lambda do |output, context, meta|
+      NODE_POSTPROCESSOR = lambda do |output, context, node_meta|
         case output
         when Flows::Result then output
         else output ? EMPTY_OK : EMPTY_ERR
         end.tap do |result|
           context[:class].after_each_callbacks.each do |callback|
-            callback.call(context[:class], meta[:name], context[:data], result)
+            callback.call(context[:class], node_meta[:name], result, context[:data], context[:meta])
           end
         end
       end