ni 0.1.0 → 0.1.1

data/lib/ni/expressions_language_engine/processor.rb

@@ -0,0 +1,4 @@
+module Ni::ExpressionsLanguageEngine
+  class Processor
+  end
+end

data/lib/ni/expressions_language_engine/tokenizer.rb

@@ -0,0 +1,4 @@
+module Ni::ExpressionsLanguageEngine
+  class Tokenizer
+  end
+end

data/lib/ni/flows/base.rb

@@ -0,0 +1,7 @@
+module Ni::Flows
+  class Base
+    def call
+      raise 'Not Implemented'
+    end
+  end
+end

data/lib/ni/flows/branch_interactor.rb

@@ -0,0 +1,65 @@
+module Ni::Flows
+  class BranchInteractor < Base
+    include Ni::Flows::Utils::HandleWait
+
+    attr_accessor :interactor_klass, :action, :condition
+
+    def initialize(top_level_interactor_klass, args, options, &block)
+      if options[:when].blank? || !options[:when].is_a?(Proc)
+        raise "Can't build brunch without a condition"
+      else
+        self.condition = options[:when]
+      end
+
+      if args.size == 2
+        interactor_klass, action = args
+      else
+        id_or_interactor = args.first
+        action = :perform
+        
+        if id_or_interactor.is_a?(Symbol)          
+          interactor_klass = build_anonymous_interactor(top_level_interactor_klass, id_or_interactor, &block)
+        else
+          interactor_klass = id_or_interactor
+        end
+      end
+
+      self.interactor_klass, self.action = interactor_klass, action
+    end
+
+    def call(context, params={})
+      return unless self.condition.call(context)
+        
+      run(context, params)
+    end
+
+    def call_for_wait_continue(context, params={})
+      call(context, params)
+    end
+
+    def handle_current_wait?(context, name)
+      self.condition.call(context) && super
+    end
+
+    private    
+
+    def run(context, params={})
+      interactor_klass.public_send(action, context, params)
+    end
+
+    def build_anonymous_interactor(top_level_interactor_klass, id, &block)
+      unless block_given?
+        raise "Can't build a branch without a block given"
+      end
+
+      klass = Class.new
+      klass.include Ni::Main
+      klass.unique_id id
+      klass.copy_storage_and_metadata_repository(top_level_interactor_klass)
+
+      klass.instance_eval &block
+
+      klass
+    end
+  end
+end

data/lib/ni/flows/inline_interactor.rb

@@ -0,0 +1,23 @@
+module Ni::Flows
+  class InlineInteractor < Base
+    include Ni::Flows::Utils::HandleWait
+
+    attr_accessor :interactor_klass, :action, :on_cancel, :on_failure, :on_terminate
+
+    def initialize(interactor_klass, action, options={})
+      self.on_cancel = options[:on_cancel]
+      self.on_failure = options[:on_failure]
+      self.on_terminate = options[:on_terminate]
+
+      self.interactor_klass, self.action = interactor_klass, action
+    end
+
+    def call(context, params={})
+      interactor_klass.public_send(action, context, params)
+    end  
+
+    def call_for_wait_continue(context, params={})
+      call(context, params)
+    end
+  end
+end

data/lib/ni/flows/isolated_inline_interactor.rb

@@ -0,0 +1,21 @@
+module Ni::Flows
+  class IsolatedInlineInteractor < Base
+    attr_accessor :interactor_klass, :action, :receive_list, :provide_list
+
+    def initialize(interactor_klass, action, options={})
+      self.interactor_klass, self.action = interactor_klass, action
+      self.receive_list, self.provide_list = Array(options[:receive]), Array(options[:provide])
+    end
+
+    def call(context)
+      isolated_context = Ni::Context.new(nil, action)
+      isolated_context.assign_data!(context.slice(*receive_list))
+
+      result = interactor_klass.public_send(action, isolated_context)
+
+      provide_list.each do |param_name|
+        context[param_name] = result.context[param_name]
+      end
+    end
+  end
+end

data/lib/ni/flows/utils/handle_wait.rb

@@ -0,0 +1,22 @@
+module Ni::Flows::Utils
+  module HandleWait
+    def handle_current_wait?(context, name)
+      interactor_klass.units_by_interface(:waited_for_name?).any? { |unit| unit.waited_for_name?(name) } ||
+      check_all_subtree_for_wait(context, name, interactor_klass.units_by_interface(:handle_current_wait?))        
+    end
+
+    def call_for_wait_continue(context, params={})
+      raise "Not implemented"
+    end
+
+    private
+
+    def check_all_subtree_for_wait(context, name, units)
+      units.any? do |unit| 
+        next_level_units = unit.interactor_klass.units_by_interface(:handle_current_wait?)
+        
+        unit.handle_current_wait?(context, name) || (next_level_units.any? && check_all_subtree_for_wait(context, name, next_level_units) )
+      end 
+    end
+  end
+end

data/lib/ni/flows/wait_for_condition.rb

@@ -0,0 +1,128 @@
+module Ni::Flows
+  class WaitForCondition
+    SKIP = :skip
+    WAIT = :wait
+    COMPLETED = :completed
+
+    METADATA_REPOSITORY_KEY = 'multiple_wait_for'
+
+    attr_accessor :condition, :timer, :wait_id
+
+    def initialize(condition, interactor_klass, options={})
+      self.timer = options[:timer]
+
+      condition = condition.interactor_id! if condition.is_a?(Class)
+
+      self.condition = condition
+    end
+
+    def waited_for_name?(name)
+      case condition
+      when Symbol # wait_for(:some_unique_name)
+        self.condition == name             
+      when Class #wait_for(OtherInteractor)
+        self.condition.interactor_id! == name        
+      when Hash  #wait_for(:main_key => [:name, SomeClass, [:name, -> (ctx) { ctx.a == 1 }]])
+        self.condition.values
+          .flatten
+          .select { |item| item.is_a?(Symbol) || item.is_a?(Class) }
+          .map { |item| item.is_a?(Class) ? item.interactor_id! : item }
+          .include?(name) 
+      else 
+        raise "Wrong WaitFor options"  
+      end 
+    end
+
+    def wait_or_continue(check, context, metadata_repository_klass)
+      if condition.is_a?(Symbol)
+        single_condition(check)
+      elsif condition.is_a?(Hash)
+        multiple_condition(check, context, metadata_repository_klass)
+      else
+        raise "Condition format doesn't recognized"
+      end 
+    end  
+
+    def setup_timer!(context, metadata_repository_klass)
+      return unless self.timer.present?
+
+      datetime_proc, timer_klass, timer_action = self.timer
+      datetime = datetime_proc.call
+      timer_action ||= :perform
+
+      unique_timer_id = "#{self.wait_id}-#{context.system_uid}"
+
+      metadata_repository_klass.setup_timer!(unique_timer_id, datetime, timer_klass.name, timer_action.to_s, contex.system_uid)
+    end
+
+    def clear_timer!(context, metadata_repository_klass)
+      return unless self.timer.present?
+
+      unique_timer_id = "#{self.wait_id}-#{context.system_uid}"
+      
+      metadata_repository_klass.clear_timer!(unique_timer_id)
+    end
+
+    private
+
+    def single_condition(check)
+      condition == check ? COMPLETED : SKIP
+    end
+    
+    def multiple_condition(check, context, metadata_repository)
+      unless metadata_repository.present?
+        raise "Multiple waits expects the metadata repository definition"
+      end  
+
+      global_name = condition.keys.first
+      conditions_list = condition.values.first
+
+      conditions_names = conditions_list.flatten.select { |name| name.is_a?(Symbol) }
+
+      unless conditions_names.include?(check)
+        return SKIP
+      end
+
+      passed_cheks = []
+
+      metadata = metadata_repository.fetch(context.system_uid, METADATA_REPOSITORY_KEY) 
+      if metadata.present?
+        passed_cheks += metadata.map(&:to_sym)
+      end
+      
+      conditions_list.each do |checked_condition|
+        if checked_condition.is_a?(Symbol)
+          if checked_condition == check
+            passed_cheks << check
+            break
+          else
+            next
+          end    
+        elsif checked_condition.is_a?(Array) && checked_condition.first.is_a?(Symbol) && checked_condition.last.is_a?(Proc)
+          name, callback = checked_condition
+
+          if name == check
+            passed_cheks << check if context.current_interactor.instance_exec(context, &callback)            
+            break
+          else
+            next  
+          end  
+        else
+          raise "Multiple waits can contain only symbols or arrays with symbol and proc"
+        end      
+      end
+
+      unless passed_cheks.present?
+        return WAIT
+      end
+
+      metadata_repository.store(context.system_uid, METADATA_REPOSITORY_KEY, passed_cheks) 
+
+      if (conditions_names - passed_cheks).empty?
+        COMPLETED
+      else
+        WAIT  
+      end  
+    end  
+  end
+end

data/lib/ni/help.rb

@@ -0,0 +1,69 @@
+#require 'colorize'
+
+module Ni
+  module Help
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def help(action=:perform, indent=0)
+        disp = -> (str) { puts '' * indent + str }
+
+        disp "#{'Interactor'.bold} #{('='*15).bold}> #{self.class.name.colorize(:blue)} <#{('='*15).bold} "
+        disp "#{'Description'.bold}: #{self.class.description}"
+        disp "#{'Pefrormed Action'.bold}: #{action.to_s.colorize(:green)} - #{self.class.defined_actions[:action].description.to_s.colorize(:green)}"
+
+        disp ''
+
+        if self.respond_to?(:select_contracts_for_action, true)
+          disp 'Input parameters:'.bold
+          select_contracts_for_action(self.class.pop_contracts, action).each do |name, contract|
+            disp "#{name.to_s.bold.yellow} - #{contract[:description] || 'No description'}"
+          end
+          disp ''
+
+          disp 'Mutated parameters:'.bold
+          select_contracts_for_action(self.class.mutate_contracts, action).each do |name, contract|
+            disp "#{name.to_s.bold.yellow} - #{contract[:description] || 'No description'}"
+          end
+          disp ''
+
+          disp 'Output parameters:'.bold
+          select_contracts_for_action(self.class.push_contracts, action).each do |name, contract|
+            disp "#{name.to_s.bold.yellow} - #{contract[:description] || 'No description'}"
+          end
+          disp ''
+        end
+
+        defined_actions[name].units.each do |unit|
+          if unit.is_a?(Proc)
+            disp 'Proc body, can not read'
+          elsif unit.is_a?(Array)
+            disp 'Call another interator in chain'
+            unit.first.help(unit.last, (indent + 1) * 2)
+          elsif unit.is_a?(Symbol)
+            disp "Call method #{unit}. Source can't be read"
+          else
+            disp 'Call another interator in chain'
+            unit.help(:perform, (indent + 1) * 2)
+          end
+        end
+      end
+
+      def desc(description)
+        @__ni_desription = description
+      end
+
+      def description
+        @__ni_desription
+      end
+
+      def title(title=nil)
+        @__ni_title ||= title
+      end
+
+      def title!
+        @__ni_title || raise("The title is required for #{self.name}")
+      end
+    end
+  end
+end

data/lib/ni/main.rb

@@ -0,0 +1,319 @@
+module Ni
+  module Main  
+    extend ActiveSupport::Concern
+
+    include Ni::Params
+    include Ni::StoragesConfig
+    include Ni::Help
+
+    module ModuleMethods
+      def register_unique_interactor(id, interactor_klass)
+        @unique_ids_map ||= {}
+
+        # ruby has a strange behaviour here while comparing classes. 
+        # Think it's an Rails autoload issue, but should compare the class names
+        if @unique_ids_map[id].present? 
+          if interactor_klass.name.present? && @unique_ids_map[id].name != interactor_klass.name
+            raise "Try to register new interactor with the existing ID: #{id}"        
+          end  
+        end
+        
+        @unique_ids_map[id] = interactor_klass
+      end  
+    end
+
+    extend ModuleMethods
+
+
+    included do
+      attr_accessor :context
+
+      delegate :success?, :valid?, :can_perform_next_step?, :errors, to: :context
+
+      def failure?
+        !success?
+      end
+
+      def initialize
+        self.class.define_actions! if need_to_define_actions?
+      end
+
+      def need_to_define_actions?
+        self.class.defined_actions.present? &&
+        self.class.defined_actions.keys.map(&:first).any? { |name| !respond_to?(name) }
+      end
+
+      def returned_values(name)
+        keys = self.class.action_by_name(name)&.returned_values.presence ||
+          self.select_contracts_for_action(self.class.provide_contracts, name)&.keys
+
+        Array(keys).map { |key| context.raw_get(key) }
+      end
+
+      def safe_context(action)
+        context.within_interactor self, action do
+          ensure_received_params(action)
+          result = yield
+          ensure_provided_params(action)
+
+          result
+        end
+      end
+
+      def handle_exceptions(action_exceptions)
+        yield
+
+        nil
+      rescue Exception => ex
+        _, rescue_callback = action_exceptions.find { |(rescue_list, _)| rescue_list.include?(ex.class) }
+
+        rescue_callback ||= begin
+          callbacks_array = action_exceptions.find do |(rescue_list, _)|
+            rescue_list.any? { |exception_class| ex.class <= exception_class }
+          end
+          callbacks_array&.last
+        end
+
+        raise ex unless rescue_callback.present?
+
+        [rescue_callback, ex]
+      end
+
+      def before_action(action_name)
+        # Can be defined in ancestors
+      end
+      
+      def after_action(action_name)
+        # Can be defined in ancestors
+      end 
+
+      def on_success(action_name)
+        # Can be defined in ancestors
+      end
+
+      def on_cancel(action_name)
+        # Can be defined in ancestors
+      end
+      
+      def on_terminate(action_name)
+        # Can be defined in ancestors
+      end  
+
+      def on_failure(action_name)
+        # Can be defined in ancestors
+      end
+
+      def on_context_restored(action_name)
+        # Can be defined in ancestors
+      end
+
+      def on_checking_continue_signal(unit)
+        # Can be defined in ancestors
+      end
+
+      def on_continue_signal_checked(unit, wait_cheking_result)
+        # Can be defined in ancestors
+      end
+    end
+
+    module ClassMethods
+      def unique_id(id=nil)
+        @unique_interactor_id = id
+        Ni::Main.register_unique_interactor(interactor_id, self)
+      end  
+
+      # without specified ID will use class name
+      def interactor_id
+        @unique_interactor_id || name
+      end  
+
+      def interactor_id!
+        @unique_interactor_id || raise("The #{self.name} requires an explicit definition of the unique id")
+      end
+
+      def action(*args, &block)
+        self.defined_actions ||= {}
+
+        name, description = args
+        description ||= 'No description'
+
+        ActionChain.new(self, name, description, &block)
+      ensure
+        unless respond_to?(name)
+          define_singleton_method name do |*args, **params|
+            context = args.first
+
+            perform_custom(name, context, params)
+          end
+        end
+      end
+
+      attr_accessor :defined_actions
+
+      def perform(*args, **params)
+        context = args.first
+
+        perform_custom(:perform, context, params)
+      end
+
+      def perform_custom(*args, **params)
+        object = self.new
+
+        name, context = args
+
+        system_uid = params.delete(:system_uid)
+        wait_completed_for = params.delete(:wait_completed_for)
+
+        context ||= Ni::Context.new(object, name, system_uid)
+        context.continue_from!(wait_completed_for) if wait_completed_for.present?
+        context.assign_data!(params)
+        context.assign_current_interactor!(object)
+
+        object.context = context
+        object.public_send(name)
+
+        Ni::Result.new object.context.resultify!, object.returned_values(name)
+      end
+
+      def define_actions!
+        defined_actions.keys.map(&:first).each { |name| define_action!(name) }
+      end
+
+      def define_action!(name)
+        raise 'Action not described' unless action_by_name(name).present?
+
+        action_units = action_by_name(name).units
+        action_failure_callback = action_by_name(name).failure_callback
+        action_exceptions = action_by_name(name).rescues
+
+        define_method name do
+          if context.should_be_restored?
+            unless self.class.context_storage_klass.present? && self.class.metadata_repository_klass.present?
+              raise "Storages was not configured"
+            end
+            
+            self.class.context_storage_klass.new(context, self.class.metadata_repository_klass).fetch  
+            on_context_restored(name)
+          end
+
+          before_action(name)
+
+          action_units.each do |unit|
+            return if context.execution_halted?
+            return if context.chain_skipped?
+            
+            if context.wait_for_execution?
+              # Send to other interactor chain
+              if unit.respond_to?(:handle_current_wait?) && unit.handle_current_wait?(context, context.continue_from)
+                rescue_callback, ex = safe_context name do
+                  handle_exceptions action_exceptions do
+                    unit.call_for_wait_continue(self.context, wait_completed_for: context.continue_from, system_uid: context.system_uid)                    
+                  end                  
+                end  
+                next unless rescue_callback.present?
+              elsif unit.is_a?(Ni::Flows::WaitForCondition)
+                
+                on_checking_continue_signal(unit)
+                wait_cheking_result = unit.wait_or_continue(context.continue_from, context, self.class.metadata_repository_klass)
+                on_continue_signal_checked(unit, wait_cheking_result)
+                
+                case wait_cheking_result
+                when Ni::Flows::WaitForCondition::SKIP                    
+                  next
+                when Ni::Flows::WaitForCondition::WAIT
+                  return
+                when Ni::Flows::WaitForCondition::COMPLETED
+                  context.wait_completed!
+                  unit.clear_timer!(context, self.class.metadata_repository_klass)
+                  next                   
+                end    
+              else  
+                next
+              end    
+            end              
+
+
+            # This can't be replaced with if ... else
+            # The wait checking hooks can change the context so need to ensure if block can be performed
+            # And from other side the performing block is also able to change context and terminate execution
+            if can_perform_next_step?              
+              # Previous step could send flow to existing chain
+              rescue_callback, ex = safe_context name do
+                handle_exceptions action_exceptions do
+                  if unit.is_a?(Proc)
+                    instance_eval(&unit)
+                  elsif unit.is_a?(Symbol)
+                    send(unit)
+                  elsif unit.is_a?(String)      
+                    unit.to_s.split('.').reduce(self) {|memo, name| memo.send(name) }
+                  elsif unit.kind_of?(Ni::Flows::Base)
+                    unit.call(self.context)
+                  elsif unit.kind_of?(Ni::Flows::WaitForCondition)
+                    if self.class.context_storage_klass.present? && self.class.metadata_repository_klass.present?
+                      self.class.context_storage_klass.new(context, self.class.metadata_repository_klass).store  
+                    else
+                      raise "WaitFor require a store and metadata repository"
+                    end
+
+                    unit.setup_timer!(context, self.class.metadata_repository_klass)
+                    context.halt_execution!
+                    
+                    return
+                  end
+                end
+              end
+
+              if rescue_callback.present?
+                instance_exec(ex, &rescue_callback)
+
+                context.failure!
+              end
+            end
+
+            unless can_perform_next_step?
+              instance_eval(&action_failure_callback) if context.failed? && action_failure_callback.present?
+              
+              {
+                :failed?     => :on_failure,
+                :canceled?   => :on_cancel,
+                :terminated? => :on_terminate
+              }.each do |predicate, callback|
+                if context.public_send(predicate)                  
+                  if unit.respond_to?(callback) && unit.public_send(callback).present?
+                    if unit.public_send(callback).is_a?(Proc)
+                      instance_exec(&unit.public_send(callback))                      
+                    end
+                    
+                    if unit.public_send(callback).is_a?(Class)
+                      unit.public_send(callback).perform(context)
+                    end
+                  end                    
+  
+                  self.public_send(callback, name)
+                end   
+              end                
+
+              after_action(name)
+              return
+            end
+          end
+
+          after_action(name)
+          on_success(name)
+        end
+      end
+
+      def action_by_name(name)
+        return nil unless defined_actions.present?
+
+        action = defined_actions.find { |(action_name, _), _| action_name == name }
+
+        Array(action).last
+      end
+
+      def units_by_interface(interface)
+        defined_actions.values.map(&:units).flatten.select { |u| u.respond_to?(interface) }
+      end  
+    end
+  end
+end