verifly 0.2.0.1 → 0.3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7171d204c82a0f84dd0b8780dda21a0c527687e1
-  data.tar.gz: cec080bcb1b9e2e38a3dd3434f8f18c498293f64
+SHA256:
+  metadata.gz: ef4ba187f3fbc61190750de9fe19bf780c8a17e980b5efe4658c748ab1578fc7
+  data.tar.gz: a879d55708639831374f646889db8b8385d769737b378906183776f49cafdd53
 SHA512:
-  metadata.gz: 3f8f1bcaf78681238fd4935cc831e4b5716aa937fe92caafffb4aa1762837d0091da69a891d4b33ce25126a40d3193cacb930a23e7c9ec1adf33dbfb2b73b850
-  data.tar.gz: 2ede721d805ba64742b50743b16952609e6c82529d0a634f82bf32b7152660becd766c687147e9ae369aa8e02211cb12b80a4da7284d950abdd147ad8f6a2fea
+  metadata.gz: 12191c302d7adf9081af6ccb818a20439ae387a5509b85f7e80d7457689669975ca78fc3ac4e4971a21c85664dede77c9a9744bd783bd73d124fcf675a1e1ffb
+  data.tar.gz: 7b28d9b3c44a3a8453c0eaeecea85eee02e9275a1d4db308afb0ec977cd2c30e039ab2ec959003509f5f41cac4b76eafb5d97b3404f7744eed6f429908136952

data/README.md

@@ -1,5 +1,5 @@
 # Verifly v0.2
-[![Build Status](https://travis-ci.org/umbrellio/verifly.svg?branch=master)](https://travis-ci.org/umbrellio/verifly)
+[![Build Status](https://travis-ci.org/umbrellio/verifly.svg?branch=master)](https://travis-ci.org/umbrellio/verifly)[![Coverage Status](https://coveralls.io/repos/github/umbrellio/verifly/badge.svg)](https://coveralls.io/github/umbrellio/verifly)
 
 This gem provides an api to run sequential checks like
 'ActiveModel::Validations' do, but with generic messages instead of errors.

data/lib/verifly.rb

@@ -4,10 +4,12 @@
 # important one, while others depend on it.
 # See README.md or in-code documentation for more info.
 module Verifly
-  autoload :VERSION, 'verifly/version'
+  autoload :VERSION, "verifly/version"
 
-  autoload :Applicator, 'verifly/applicator'
-  autoload :ApplicatorWithOptions, 'verifly/applicator_with_options'
-  autoload :ClassBuilder, 'verifly/class_builder'
-  autoload :Verifier, 'verifly/verifier'
+  autoload :Applicator, "verifly/applicator"
+  autoload :ApplicatorWithOptions, "verifly/applicator_with_options"
+  autoload :ClassBuilder, "verifly/class_builder"
+  autoload :DependentCallbacks, "verifly/dependent_callbacks"
+  autoload :HasLogger, "verifly/has_logger"
+  autoload :Verifier, "verifly/verifier"
 end

data/lib/verifly/applicator.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Verifly
-  # @abstract implement `#call`
+  # @abstract implement `#call`, `#source` and `#source_location`
   # Applies "applicable" objects to given bindings
   # (applicable objects are named based on their use,
   # currently any object is applicable).
@@ -14,8 +14,8 @@ module Verifly
     # Proxy is used when applicable itself is an instance of Applicator.
     # It just delegates #call method to applicable
     # @example
-    #   Applicator.call(Applicator.build(:foo), binding_, context)
-    #   # => Applicator.call(:foo, binding_, context)
+    #   Applicator.call(Applicator.build(:foo), binding_, *context)
+    #   # => Applicator.call(:foo, binding_, *context)
     class Proxy < self
       # @param applicable [Applicator]
       # @return Proxy if applicable is an instance of Applicator
@@ -27,8 +27,20 @@ module Verifly
       # @param binding_ [#instance_exec] target to apply applicable
       # @param context additional info to send it to applicable
       # @return application result
-      def call(binding_, context)
-        applicable.call(binding_, context)
+      def call(binding_, *context)
+        applicable.call(binding_, *context)
+      end
+
+      # @param binding_ [#instance_exec] binding to find relative source
+      # @return [[String, Integer]?] (file, line) location of calblack source (if exists)
+      def source_location(binding_)
+        applicable.source_location(binding_)
+      end
+
+      # @param binding_ [#instance_exec] binding to find relative source
+      # @return [String?] callback (not it's defenition) source code
+      def source(binding_)
+        applicable.source(binding_)
       end
     end
 
@@ -51,25 +63,45 @@ module Verifly
       # @param binding_ [#instance_exec] target to apply applicable to
       # @param context additional info to send to applicable
       # @return application result
-      def call(binding_, context)
+      def call(binding_, *context)
         if binding_.is_a?(Binding)
-          call_on_binding(binding_, context)
+          call_on_binding(binding_, *context)
         else
-          invoke_lambda(binding_.method(applicable), binding_, context)
+          invoke_lambda(binding_.method(applicable), binding_, *context)
         end
       end
 
+      # @param binding_ [#instance_exec] binding to find relative source
+      # @return [[String, Integer]] (file, line) location of calblack source (if exists)
+      # @raise [NameError] if method does not exist on binding_
+      def source_location(binding_)
+        binding_method(binding_).method(applicable).source_location
+      end
+
+      # @param binding_ [#instance_exec] binding to find relative source
+      # @return [String] relative method source defenition
+      # @raise [NameError] if method does not exist on binding_
+      def source(binding_)
+        binding_method(binding_).method(applicable).source
+      end
+
+      # @param binding_ [#instance_exec] binding to find relative source
+      # @return [Method] method, extracted from binding
+      def binding_method(binding_)
+        binding_.is_a?(Binding) ? binding_.receiver : binding_
+      end
+
       private
 
       # When Binding is a target, we have to respect both methods and variables
       # @param binding_ [Binding] target to apply applicable to
       # @param context additional info to send to applicable
       # @return application result
-      def call_on_binding(binding_, context)
-        if binding_.receiver.respond_to?(applicable)
-          invoke_lambda(binding_.receiver.method(applicable), binding_, context)
-        else
+      def call_on_binding(binding_, *context)
+        if binding_.local_variable_defined?(applicable)
           binding_.local_variable_get(applicable)
+        else
+          invoke_lambda(binding_.receiver.method(applicable), binding_, *context)
         end
       end
     end
@@ -77,7 +109,7 @@ module Verifly
     # InstanceEvaluator is used for strings. It works like instance_eval or
     # Binding#eval depending on binding_ class
     # @example
-    #   Applicator.call('foo if context[:foo]', binding_, context)
+    #   Applicator.call('foo if context[:foo]', binding_, *context)
     #   # => foo if context[:foo]
     class InstanceEvaluator < self
       # @param applicable [String]
@@ -90,7 +122,7 @@ module Verifly
       # @param binding_ [#instance_exec] target to apply applicable to
       # @param context additional info to send to applicable
       # @return application result
-      def call(binding_, context)
+      def call(binding_, *context)
         if binding_.is_a?(Binding)
           binding_ = binding_.dup
           binding_.local_variable_set(:context, context)
@@ -100,6 +132,17 @@ module Verifly
         end
       end
 
+      # Source location is not available
+      # @return [nil]
+      def source_location(*); end
+
+      # @return [String] exactly it's defenition
+      def source(*)
+        applicable
+      end
+
+      private
+
       # @return [String, Integer]
       #   file and line where `Applicator.call` was called
       def caller_line
@@ -113,7 +156,7 @@ module Verifly
     # ProcApplicatior is used when #to_proc is available.
     # It works not only with procs, but also with hashes etc
     # @example with a proc
-    #   Applicator.call(-> { foo }, binding_, context) # => foo
+    #   Applicator.call(-> { foo }, binding_, *context) # => foo
     # @example with a hash
     #   Applicator.call(Hash[foo: true], binding_, :foo) # => true
     #   Applicator.call(Hash[foo: true], binding_, :bar) # => nil
@@ -128,19 +171,38 @@ module Verifly
       # @param binding_ [#instance_exec] target to apply applicable to
       # @param context additional info to send to applicable
       # @return application result
-      def call(binding_, context)
-        invoke_lambda(applicable.to_proc, binding_, context)
+      def call(binding_, *context)
+        invoke_lambda(applicable.to_proc, binding_, *context)
+      end
+
+      # @return [String, Integer] Proc#source_location
+      def source_location(*)
+        applicable.to_proc.source_location
+      end
+
+      # @return [String] Proc#source
+      def source(*)
+        applicable.to_proc.source
       end
     end
 
     # Quoter is used when there is no other way to apply applicatable.
     # @example
-    #   Applicator.call(true, binding_, context) # => true
+    #   Applicator.call(true, binding_, *context) # => true
     class Quoter < self
       # @return applicable without changes
       def call(*)
         applicable
       end
+
+      # No source location available
+      # @return [nil]
+      def source_location(*); end
+
+      # @return [String] quoted value's inspect
+      def source
+        applicable.inpsect
+      end
     end
 
     extend ClassBuilder::Mixin
@@ -151,7 +213,6 @@ module Verifly
     attr_accessor :applicable
 
     # Applies applicable on binding_ with context
-    # @todo add @see #initialize when its todo is done
     # @param applicable [applicable]
     #   see examples in definitions of subclasses
     # @param binding_ [#instance_exec]
@@ -161,8 +222,8 @@ module Verifly
     #   geneneric data you want to pass to applicable function.
     #   If applicable cannot accept params, context will not be sent
     # @return application result
-    def self.call(applicable, binding_, context)
-      build(applicable).call(binding_, context)
+    def self.call(applicable, binding_, *context)
+      build(applicable).call(binding_, *context)
     end
 
     # Always use build instead of new
@@ -180,13 +241,23 @@ module Verifly
       applicable == other.applicable
     end
 
-    # @!method call(binding_, context)
+    # @!method call(binding_, *context)
     #   @abstract
     #   Applies applicable on binding_ with context
     #   @param binding_ [#instance_exec] binding to be used for applying
     #   @param context param that will be passed if requested
     #   @return application result
 
+    # @!method source_location(binding_)
+    #   @abstract
+    #   @param binding_ [#instance_exec] binding to find relative source
+    #   @return [[String, Integer]?] (file, line) location of calblack source (if exists)
+
+    # @!method source(binding_)
+    #   @abstract
+    #   @param binding_ [#instance_exec] binding to find relative source
+    #   @return [String?] callback (not it's defenition) source code
+
     private
 
     # invokes lambda respecting its arity
@@ -194,11 +265,11 @@ module Verifly
     # @param binding_ [#instance_exec] binding_ would be used in application
     # @param context param would be passed if lambda arity > 0
     # @return invocation result
-    def invoke_lambda(lambda, binding_, context)
+    def invoke_lambda(lambda, binding_, *context)
       if lambda.arity.zero?
         binding_.instance_exec(&lambda)
       else
-        binding_.instance_exec(context, &lambda)
+        binding_.instance_exec(*context, &lambda)
       end
     end
   end

data/lib/verifly/applicator_with_options.rb

@@ -24,9 +24,7 @@ module Verifly
     # @raise [ArgumentError] if there is more than two arguments and block
     # @raise [ArgumentError] if there is zero arguments and no block
     def initialize(*args, &block)
-      action, options, *rest = block ? [block, *args] : args
-      options ||= {}
-      raise ArgumentError unless action && rest.empty?
+      action, options = normalize_options(*args, &block)
 
       self.action = Applicator.build(action)
       self.if_condition = Applicator.build(options.fetch(:if, true))
@@ -41,10 +39,20 @@ module Verifly
     #   generic context to apply (see Applicator)
     # @return main action application result
     # @return [nil] if condition checks failed
-    def call(binding_, context)
-      return unless if_condition.call(binding_, context)
-      return if unless_condition.call(binding_, context)
-      action.call(binding_, context)
+    def call(binding_, *context)
+      return unless if_condition.call(binding_, *context)
+      return if unless_condition.call(binding_, *context)
+      action.call(binding_, *context)
+    end
+
+    private
+
+    def normalize_options(*args, &block)
+      action, options, *rest = block ? [block, *args] : args
+      options ||= {}
+      raise ArgumentError unless action && rest.empty?
+
+      [action, options]
     end
   end
 end

data/lib/verifly/class_builder.rb

@@ -4,18 +4,18 @@ module Verifly
   # ClassBuilder is similar to Uber::Builder, but it
   # allows child classes to decide whether they will be used.
   # I find it much more object-oriented
-  # @attr klasses [Array(Class)]
+  # @attr klasses [[Class]]
   #   classes to iterate during search of most suitable
   class ClassBuilder
     # Mixin provides useful methods to integrate into builder subsystem.
     # Feel free to override or just never include it.
-    # @attr_writer [Array(Class)] buildable_classes
+    # @attr_writer [[Class]] buildable_classes
     #   Array of classes which will be checked if they
     #   suite constructor arguments. Order matters
     module Mixin
       # Array of classes which will be checked if they
       # suite constructor arguments. Order matters
-      # @param klasses [Array(Class)]
+      # @param klasses [[Class]]
       def buildable_classes=(klasses)
         @class_builder = ClassBuilder.new(klasses).freeze
       end
@@ -40,7 +40,7 @@ module Verifly
 
     attr_accessor :klasses
 
-    # @param klasses [Array(Classes)]
+    # @param klasses [[Class]]
     def initialize(klasses)
       self.klasses = klasses
     end

data/lib/verifly/dependent_callbacks.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Verifly
+  # DependentCallbacks interface is similar to ActiveSupport::Callbacks, but it has few differences
+  #
+  # 1) `extend` it, not `include`
+  #
+  # 2) Use `.callback_groups` do tefine callbacks instead of define_callbacks
+  #
+  # 3) Better define callbacks in separate module, wich should extend DependentCallbacks::Storage
+  #
+  # 4) Use merge_callbacks_from(Module) instead of including it
+  #
+  # 5) There is no run_callbacks method.
+  #
+  # You can either use self.class.dependent_callbacks.invoke(group, *context) {}
+  # or use .export_callbacks_to(:active_support) / .export_callbacks_to(:wrap_method)
+  module DependentCallbacks
+    autoload :Callback, "verifly/dependent_callbacks/callback"
+    autoload :CallbackGroup, "verifly/dependent_callbacks/callback_group"
+    autoload :Invoker, "verifly/dependent_callbacks/invoker"
+    autoload :Service, "verifly/dependent_callbacks/service"
+    autoload :Storage, "verifly/dependent_callbacks/storage"
+
+    extend HasLogger
+    include Storage
+
+    # @api stdlib
+    # Allows children to inherit callbacks from parent
+    # @param [Class] child
+    def inherited(child)
+      super
+
+      child.instance_exec(dependent_callbacks_service) do |service|
+        @dependent_callbacks_service = Service.new(service)
+      end
+    end
+
+    # Exports callbacks to another callback system / something like that
+    # @param [:active_support, :wrap_method] target
+    #   Target selection.
+    #   * :active_support exports each group to correspoding
+    #     ActiveSupport callback (via set_callback)
+    #   * :wrap_method defines / redefines methods, named same as each group.
+    #     If method was defined, on it's call callbacks would run around its previous defenition.
+    #     If not, callbacks would run around nothing
+    # @param groups [[Symbol]] arra of groups to export. Defaults to all groups
+    def export_callbacks_to(target, groups: nil)
+      (groups || dependent_callbacks_service.group_names).each do |group|
+        case target
+        when :active_support then _export_callback_group_to_active_support(group)
+        when :action_controller then _export_callback_group_to_action_controller(group)
+        when :wrap_method then _export_callback_group_to_method_wapper(group)
+        else
+          raise "#{target.inspect} export target unavailable. " \
+                "available targets are :active_support, :action_controller, :wrap_method"
+        end
+      end
+    end
+
+    private
+
+    # Exports callbacks to ActiveSupport
+    # @see export_callbacks_to
+    # @param group [Symbol] name of group
+    def _export_callback_group_to_active_support(group)
+      exports_name = :"__verifly_dependent_callbacks_exports_#{group}"
+
+      define_method(exports_name) do |*context, &block|
+        self.class.dependent_callbacks_service.invoke(group) do |invoker|
+          invoker.context = context
+          invoker.inner_block = block
+          invoker.run(self)
+        end
+      end
+
+      private(exports_name)
+      set_callback(group, :around, exports_name)
+    end
+
+    # Exports callbacks to ActionController::Base
+    # @see export_callbacks_to
+    # @param group [Symbol] name of group
+    def _export_callback_group_to_action_controller(group)
+      raise unless group == :action
+
+      around_action do |request, sequence|
+        self.class.dependent_callbacks_service.invoke(group) do |invoker|
+          invoker.context << request
+          invoker.inner_block = sequence
+          invoker.break_if { response_body }
+          invoker.run(self)
+        end
+      end
+    end
+
+    # Exports callbacks to methods
+    # @see export_callbacks_to
+    # @param group [Symbol] name of group
+    def _export_callback_group_to_method_wapper(group)
+      instance_method = instance_method(group) rescue nil
+
+      define_method(group) do |*args, &block|
+        self.class.dependent_callbacks_service.invoke(group) do |invoker|
+          invoker.around { instance_method&.bind(self)&.call(*args, &block) }
+          invoker.context = args
+          invoker.run(self)
+        end
+      end
+    end
+  end
+end

data/lib/verifly/dependent_callbacks/callback.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Verifly
+  module DependentCallbacks
+    # ApplicatorWithOptions improved to handle everything needed in DependentCallbacks
+    # @attr name [Symbol?] callback name
+    # @attr position [:before, :after, :around] callback position
+    # @attr before [[Symbol]] names of calblacks before which this is
+    # @attr after [[Symbol]] names of calblacks after which this is
+    class Callback < ApplicatorWithOptions
+      # Available positions of calblack: before, after or around action
+      POSITIONS = %i[before after around].freeze
+
+      attr_accessor :name, :position, :before, :after
+
+      # @!method initialize(position, action = block, options = {}, &block)
+      # @see ApplicatorWithOptions#initialize
+      # @param position [:before, :after, :around] position
+      # @param action [applicable] main action
+      # @option options [applicable] :if
+      #   main action is only applied if this evaluates to truthy value
+      # @option options [applicable] :unless
+      #   main action is only applied if this evaluates to falsey value
+      # @option options [Symbol] :name
+      #   name override for callback. By default, name is taken from applicable if it is a symbol
+      #   or set to nil. This option allows to use named applicables like proc
+      # @option options [[Symbol]] :insert_before
+      #   array of callback names which should be sequenced after current.
+      #   Note, that if position == :after, sequence would go backwards
+      # @option options [[Symbol]] :require
+      #   array of callback names which should be sequenced before current.
+      # @raise [ArgumentError] if there is more than three arguments and block
+      # @raise [ArgumentError] if there is one argument and no block
+      def initialize(position, *args, &block)
+        super(*args, &block)
+
+        action, options = normalize_options(*args, &block)
+
+        self.name = options.fetch(:name) { action if action.is_a?(Symbol) }
+
+        self.position = position
+        raise "#{position} should be one of #{POSITIONS}" unless POSITIONS.include?(position)
+
+        self.before = Array(options.fetch(:insert_before, []))
+        self.after = Array(options.fetch(:require, []))
+      end
+
+      # Converts callback to nice table in dot label format
+      # @param [#instance_exec] binding_
+      # @return [String] graphviz LabelHTML
+      def to_dot_label(binding_)
+        template_path = File.expand_path("callback.dothtml.erb", __dir__)
+        erb = ERB.new(File.read(template_path))
+        erb.filename = template_path
+        erb.result(binding)
+      end
+    end
+  end
+end

data/lib/verifly/dependent_callbacks/callback_group.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "tsort"
+
+module Verifly
+  module DependentCallbacks
+    # Handles callbacks with same 'group' option, allowing to do sequential invokation of them
+    # @attr name [Symbol] name of callback group
+    # @attr index [{Symbol => Callback}] index for named callback lookup
+    # @attr list [[Callback]] all callbacks
+    class CallbackGroup
+      # Implements topoplogy sorting of callbacks.
+      # As far as CallbackGroup is designed to store Callbacks, it is unable to link them into
+      # graph immediately . Service can do it, because if some callbacks are missing on
+      # compilation stage, there should be an error
+      # @see http://ruby-doc.org/stdlib-2.3.4/libdoc/tsort/rdoc/TSort.html
+      # @attr dependencies [{ Callback => Callback }] dependency graph
+      class TSortService
+        include TSort
+
+        attr_accessor :dependencies
+
+        # @param callback_group [CallbackGroup] group to be tsorted
+        # @return [[Callback]] tsorted callbacks array (aka sequence)
+        def self.call(callback_group)
+          new(callback_group).tsort
+        end
+
+        # @param callback_group [CallbackGroup] group to be tsorted
+        def initialize(callback_group)
+          self.dependencies = Hash.new { |h, k| h[k] = Set[] }
+
+          callback_group.list.each do |callback|
+            dependencies[callback] ||= []
+
+            callback.before.each do |key|
+              dependencies[callback_group.index.fetch(key)] << callback
+            end
+
+            callback.after.each do |key|
+              dependencies[callback] << callback_group.index.fetch(key)
+            end
+          end
+        end
+
+        private
+
+        # @api stdlib
+        # @see TSort
+        def tsort_each_node(&block)
+          dependencies.keys.each(&block)
+        end
+
+        # @api stdlib
+        # @see TSort
+        def tsort_each_child(node, &block)
+          dependencies[node].each(&block)
+        end
+      end
+
+      attr_accessor :index, :list, :name
+
+      # @param name [Symbol] name of callback group
+      # @yield self if block given
+      def initialize(name)
+        self.name = name
+        self.index = {}
+        self.list = []
+
+        yield(self) if block_given?
+      end
+
+      # Adds callback to list and index, reset sequence
+      # @param callback [Callback] new callback
+      def add_callback(callback)
+        list << callback
+        index[callback.name] = callback if callback.name
+
+        @sequence = nil
+      end
+
+      # Merges with another group
+      # @param other [CallbackGroup]
+      # @raise if group names differ
+      def merge(other)
+        raise "Only groups with one name could be merged" unless name == other.name
+
+        [*list, *other.list].each_with_object(CallbackGroup.new(name)) do |callback, group|
+          group.add_callback(callback)
+        end
+      end
+
+      # Memoizes tsorted graph
+      # @return [[Callback]]
+      def sequence
+        @sequence ||= TSortService.call(self)
+      end
+
+      # Digest change forces recompilation of callback group in service
+      # @return [Numeric]
+      def digest
+        [name, list].hash
+      end
+
+      # Renders graphviz dot-representation of callback group
+      # @return graphviz dot
+      def to_dot(binding_)
+        template_path = File.expand_path("callback_group.dot.erb", __dir__)
+        erb = ERB.new(File.read(template_path))
+        erb.filename = template_path
+        erb.result(binding)
+      end
+    end
+  end
+end

data/lib/verifly/dependent_callbacks/invoker.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "benchmark"
+
+module Verifly
+  module DependentCallbacks
+    # Simple service to invoke callback groups
+    # @example simple invokation
+    #   def invoke_callbacks
+    #     Invoker.new(group) do |invoker|
+    #       invoker.around {}
+    #       invoker.run(self)
+    #     end
+    #   end
+    # @see DependentCallbacks#export_callbacks_to
+    # @!attribute flat_sequence
+    #   @return [[Callback]] tsorted callbacks
+    # @!attribute context
+    #   @return [[Object]] invokation context. It would be passed to all applicators
+    # @!attribute inner_block
+    #   @return [Proc] block in the middle of middleware
+    # @!visibility private
+    # @!attribute break_if_proc
+    #   @note does not affect 'after' callbacks
+    #   @return [Proc] if this block evaluate to truthy, sequence would be halted.
+    # @!attribute binding_
+    #   @return [#instance_exec] binding_ to evaluate on
+    class Invoker
+      attr_accessor :flat_sequence, :context, :inner_block
+
+      # @param callback_group [CallbackGroup]
+      # @yield self if block given
+      def initialize(callback_group)
+        self.flat_sequence = callback_group.sequence
+        self.context = []
+        self.break_if_proc = proc { false }
+        yield(self) if block_given?
+      end
+
+      # @yield in the middle of middleware, setting inner_block attribute
+      # @see inner_block
+      def around(&block)
+        self.inner_block = block
+      end
+
+      # @yield between callbacks halting chain if evaluated to true
+      # @see break_if_proc
+      def break_if(&block)
+        self.break_if_proc = block
+      end
+
+      # Sets binding_, reduces callbacks into big proc and evaluates it
+      # @param binding_ [#instance_exec] binding_ to be evaluated on
+      # @return inner_block call result
+      def run(binding_)
+        self.binding_ = binding_
+        result = nil
+        block_with_result_extractor = -> { result = inner_block&.call }
+
+        log!(:info, "Started chain processing")
+
+        sequence =
+          flat_sequence.reverse_each.reduce(block_with_result_extractor) do |sequence, callback|
+            -> { call_callback(callback, sequence) }
+          end
+
+        sequence.call
+        result
+      end
+
+      private
+
+      attr_accessor :break_if_proc, :binding_
+
+      # Invokes callback in context of invoker
+      # @param callback [Callback] current callbacks
+      # @param sequence [Proc] already built sequence of callbacks
+      def call_callback(callback, sequence)
+        log!(:debug, "Invokation", callback: callback)
+
+        case callback.position
+        when :before then call_callback_before(callback, sequence)
+        when :after then call_callback_after(callback, sequence)
+        when :around then call_callback_around(callback, sequence)
+        end
+
+        nil
+      end
+
+      # Invokes before_<name> callbacks
+      # @param callback [Callback] current callbacks
+      # @param sequence [Proc] already built sequence of callbacks
+      def call_callback_before(callback, sequence)
+        call_with_time_report!(callback, binding_, *context)
+
+        if break_if_proc.call(*context)
+          log!(:warn, "Chain halted", callback: callback)
+        else
+          sequence.call
+        end
+      end
+
+      # Invokes after_<name> callbacks
+      # @param callback [Callback] current callbacks
+      # @param sequence [Proc] already built sequence of callbacks
+      def call_callback_after(callback, sequence)
+        sequence.call
+        call_with_time_report!(callback, binding_, *context)
+      end
+
+      # Invokes around_<name> callbacks
+      # @param callback [Callback] current callbacks
+      # @param sequence [Proc] already built sequence of callbacks
+      def call_callback_around(callback, sequence)
+        inner_executed = false
+        inner = lambda do
+          inner_executed = true
+          if break_if_proc.call(*context)
+            log!(:warn, "Chain halted", callback: callback)
+          else
+            sequence.call
+          end
+        end
+
+        call_with_time_report!(callback, binding_, inner, *context)
+
+        unless inner_executed
+          log!(:warn, "Chain halted (sequential block not called)", callback: callback)
+        end
+      end
+
+      # Logger interface to decorate messages. Uses DependentCallbacks.logger
+      # @param severity [:debug, :info, :warn, :error, :fatal] severity level
+      # @param message [String] message
+      # @param callback [Callback?] callback to get extra context
+      def log!(severity, message, callback: nil)
+        DependentCallbacks.logger.public_send(severity, "Verifly::DependentCallbacks::Invoker") do
+          if callback
+            <<~TXT.squish if callback
+              #{message} callback #{callback.name || "(anonymous)"}
+                         in #{callback.action.source_location(binding_)&.join(':')}
+            TXT
+          else
+            message
+          end
+        end
+      end
+
+      def call_with_time_report!(callback, *args) # :nodoc:
+        return callback.call(*args) unless DependentCallbacks.logger.info?
+        time_in_ms = Benchmark.realtime { callback.call(*args) } * 1000
+        log!(:info, "Run in #{time_in_ms.round(1)}ms", callback: callback)
+      end
+    end
+  end
+end

data/lib/verifly/dependent_callbacks/service.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Verifly
+  module DependentCallbacks
+    # A service to store all callbacks info and delegate methods fom DSLs
+    # @attr groups [Symbol => CallbackGroup] groups index
+    # @attr parents [[Service]] parents in service inheritance system
+    class Service
+      attr_accessor :groups, :parents
+
+      # @param parents [[Service]] is filled in by the parent
+      def initialize(*parents)
+        self.parents = parents
+        self.groups = Hash.new { |h, k| h[k] = CallbackGroup.new(k) }
+      end
+
+      # Merges another service into this
+      # @param other [Service]
+      def merge!(other)
+        parents << other
+      end
+
+      # Adds callback into matching group
+      # @see Callback#initialize
+      # @param position [:before, :after, :around]
+      # @param group [Symbol] group name
+      # @param args callback args
+      def add_callback(position, group, *args, &block)
+        groups[group].add_callback(Callback.new(position, *args, &block))
+      end
+
+      def invoke(group_name)
+        invoker = Invoker.new(compiled_group(group_name))
+        yield(invoker)
+      end
+
+      # @return [[Symbol]] names of all groups stored inside itself or parents
+      def group_names
+        [groups.keys, *parents.map(&:group_names)].flatten.uniq
+      end
+
+      # Compiles callback group from itself and parents callback groups.
+      # If nothing changed, cached value taken
+      # @param group_name [Symbol] group name
+      # @return [CallbackGroup] callback group joined from all relative callback groups
+      def compiled_group(group_name)
+        @compiled_groups_cache ||= Hash.new { |h, k| h[k] = {} }
+        cache_entry = @compiled_groups_cache[group_name]
+        return cache_entry[:group] if cache_entry[:digest] == digest
+
+        cache_entry[:digest] = digest
+        cache_entry[:group] = parents.map { |parent| parent.compiled_group(group_name) }
+                                     .reduce(groups[group_name], &:merge)
+      end
+
+      # Digest change forces recompilation of compiled_group
+      # @return [Numeric]
+      def digest
+        [
+          *parents.map(&:digest),
+          *groups.map { |k, v| [k, v.digest].join },
+        ].hash
+      end
+
+      # Exprorts selected group to graphiz .dot format
+      def to_dot(group, binding_)
+        compiled_group(group).to_dot(binding_)
+      end
+    end
+  end
+end

data/lib/verifly/dependent_callbacks/storage.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Verifly
+  module DependentCallbacks
+    # Subset of DependentCallbacks dsl methods, which could be used in callbacks storage
+    module Storage
+      # Declares callback groups with given names. This creates before_ after_ and around_
+      # signleton methods for each group given
+      # @see Service#add_callback
+      # @param groups [[Symbol]]
+      def callback_groups(*groups)
+        groups.each do |group|
+          dependent_callbacks_service.groups[group] # Creates an empty group
+
+          %i[before after around].each do |position|
+            define_singleton_method("#{position}_#{group}") do |*args, &block|
+              dependent_callbacks_service.add_callback(position, group, *args, &block)
+            end
+          end
+        end
+      end
+
+      # Merges all callbacks from given storage
+      # @param storage [Module { extend Storage }]
+      def merge_callbacks_from(storage)
+        include(storage)
+        dependent_callbacks_service.merge!(storage.dependent_callbacks_service)
+      end
+
+      # @return [Service] associated with current Class / Module
+      def dependent_callbacks_service
+        @dependent_callbacks_service ||= Service.new
+      end
+    end
+  end
+end

data/lib/verifly/has_logger.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Verifly
+  # Mixin with logger attr_accessor and default value for it
+  # @!attribute logger
+  #   @return [::Logger] logger to be used within target module
+  module HasLogger
+    # Does nothing, provides ::Logger api
+    class NullLogger < ::Logger
+      # @api stdlib
+      def initialize
+        super(nil)
+      end
+
+      # @api stdlib
+      # Logs nothing
+      def add(*); end
+    end
+
+    attr_writer :logger
+
+    def logger
+      @logger ||= NullLogger.new
+    end
+  end
+end

data/lib/verifly/verifier.rb

@@ -11,7 +11,7 @@ module Verifly
   #   Array with all messages yielded by the verifier
   class Verifier
     autoload :ApplicatorWithOptionsBuilder,
-             'verifly/verifier/applicator_with_options_builder'
+             "verifly/verifier/applicator_with_options_builder"
 
     attr_accessor :model, :messages
 
@@ -65,7 +65,7 @@ module Verifly
       end
     end
 
-    # @return [Array(ApplicatorWithOptions)]
+    # @return [[ApplicatorWithOptions]]
     #   List of applicators, bound by .verify
     def self.bound_applicators
       @bound_applicators ||= []

data/lib/verifly/version.rb

@@ -8,5 +8,5 @@ module Verifly
   # * a stands for public api changes
   # * b stands for private api changes
   # * c stands for patch changes (not touching public or private api)
-  VERSION = '0.2.0.1'
+  VERSION = "0.3.1.0"
 end

metadata

@@ -1,157 +1,171 @@
 --- !ruby/object:Gem::Specification
 name: verifly
 version: !ruby/object:Gem::Version
-  version: 0.2.0.1
+  version: 0.3.1.0
 platform: ruby
 authors:
 - Alexander Smirnov
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-04-10 00:00:00.000000000 Z
+date: 2020-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: launchy
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.5'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.48'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.48'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.8
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.8
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: launchy
+  name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '2.4'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.19
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.19
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-rspec
+  name: actionpack
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.15'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec-its
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-config-umbrellio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 'An api to run sequential checks like ''ActiveModel::Validations'' do,
-  but with generic messages instead of errors. See more info at [http://www.rubydoc.info/gems/verifly/0.2.0.1] '
+  but with generic messages instead of errors. See more info at https://www.rubydoc.info/gems/verifly/0.3.1.0 '
 email:
 - begdory4@gmail.com
 executables: []
@@ -163,6 +177,13 @@ files:
 - lib/verifly/applicator.rb
 - lib/verifly/applicator_with_options.rb
 - lib/verifly/class_builder.rb
+- lib/verifly/dependent_callbacks.rb
+- lib/verifly/dependent_callbacks/callback.rb
+- lib/verifly/dependent_callbacks/callback_group.rb
+- lib/verifly/dependent_callbacks/invoker.rb
+- lib/verifly/dependent_callbacks/service.rb
+- lib/verifly/dependent_callbacks/storage.rb
+- lib/verifly/has_logger.rb
 - lib/verifly/verifier.rb
 - lib/verifly/version.rb
 homepage: https://github.com/umbrellio/verifly
@@ -170,24 +191,23 @@ licenses:
 - MIT
 metadata:
   yard.run: yri
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - "~>"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '2.3'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
-summary: See more info at [http://www.rubydoc.info/gems/verifly/0.2.0.1]
+summary: See more info at https://www.rubydoc.info/gems/verifly/0.3.1.0
 test_files: []