ni 0.1.0 → 0.1.1

data/lib/ni/params.rb

@@ -0,0 +1,109 @@
+module Ni
+  module Params
+    extend ActiveSupport::Concern
+
+    class Mapper
+      CONFIG_MAP = {
+        String => :description,
+        Hash   => :options,
+        Proc   => :contract,
+        Symbol => :method_contract
+      }
+
+      def self.perform(args)
+        args.each_with_object({}) do |next_arg, acc|
+          option = CONFIG_MAP[next_arg.class]
+
+          fail 'unknown argument' unless option.present?
+
+          acc[option] = next_arg
+        end
+      end
+    end
+
+    included do
+      def allow_to_read?(action, name)
+        receive_contracts = select_contracts_for_action(self.class.receive_contracts, action)
+        mutate_contracts  = select_contracts_for_action(self.class.mutate_contracts, action)
+        provide_contracts = select_contracts_for_action(self.class.provide_contracts, action)
+
+        return true if receive_contracts.blank? && mutate_contracts.blank? && provide_contracts.blank?
+
+        receive_contracts.keys.include?(name) ||
+        mutate_contracts.keys.include?(name)
+      end
+
+      def allow_to_write?(action, name)
+        receive_contracts = select_contracts_for_action(self.class.receive_contracts, action)
+        mutate_contracts  = select_contracts_for_action(self.class.mutate_contracts, action)
+        provide_contracts = select_contracts_for_action(self.class.provide_contracts, action)
+
+        return true if receive_contracts.blank? && mutate_contracts.blank? && provide_contracts.blank?
+
+        provide_contracts.keys.include?(name) ||
+        mutate_contracts.keys.include?(name)
+      end
+
+      protected
+
+      def ensure_received_params(action=DEFAULT_ACTION)
+        ensure_contracts self.class.receive_contracts, action
+        ensure_contracts self.class.mutate_contracts, action
+      end
+
+      def ensure_provided_params(action=DEFAULT_ACTION)
+        ensure_contracts self.class.provide_contracts, action
+      end
+
+      def ensure_contracts(contracts, action)
+        select_contracts_for_action(contracts, action).each do |param, contract|
+          value = context.raw_get(param)
+
+          if contract[:contract].present?
+            unless contract[:contract].call(value)
+              fail "Value of `#{param}` doesn't match to contract"
+            end
+          end
+
+          if contract[:method_contract].present?
+            unless value.respond_to?(contract[:method_contract], true)
+              fail "Value of `#{param}` doesn't respond to contract method :#{contract[:method_contract]}"
+            end
+
+            unless value.send(contract[:method_contract])
+              fail "Value of `#{param}` doesn't match to contract :#{contract[:method_contract]}"
+            end
+          end
+        end
+      end
+
+      def select_contracts_for_action(contracts, action)
+        (contracts || {}).select do |_, contract|
+          contract.dig(:options, :for).blank? || contract.dig(:options, :for) == action
+        end
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :receive_contracts, :provide_contracts, :mutate_contracts
+
+      def receive(*args)
+        @receive_contracts ||= {}
+        name = args.shift
+        @receive_contracts[name] = Mapper.perform(args)
+      end
+
+      def provide(*args)
+        @provide_contracts ||= {}
+        name = args.shift
+        @provide_contracts[name] = Mapper.perform(args)
+      end
+
+      def mutate(*args)
+        @mutate_contracts ||= {}
+        name = args.shift
+        @mutate_contracts[name] = Mapper.perform(args)
+      end
+    end
+  end
+end

data/lib/ni/result.rb

@@ -0,0 +1,15 @@
+module Ni
+  class Result
+    attr_reader :context
+
+    delegate :success?, :valid?, :errors, to: :context
+
+    def initialize(context, args=[])
+      @context, @args = context, args
+    end
+
+    def to_ary
+      [self] + @args
+    end
+  end
+end

data/lib/ni/storages/active_record_metadata_repository.rb

@@ -0,0 +1,51 @@
+module Ni
+  module Storages
+    if defined?(ActiveRecord)
+      class ActiveRecordMetadataRepository < ActiveRecord::Base
+         self.table_name = "ni_metadata"
+
+         TIMER_KEY = 'timer'.freeze
+
+         def self.store(uid, key, data)
+           record = self.where(uid: uid, key: key).first_or_initialize
+           record.update(data: data.to_json) 
+         end
+
+         def self.fetch(uid, key)
+           record = self.where(uid: uid, key: key).first
+
+           if record.present?
+             JSON.parse(record.data, symbolize_names: true)
+           else
+             {}  
+           end  
+         end 
+
+         def self.setup_timer!(timer_id, datetime, timer_klass_name, timer_action, system_uid)
+           data = [timer_klass_name, timer_action, system_uid].to_json
+           self.create!(uid: timer_id, key: TIMER_KEY, run_timer_at: datetime, data: data)
+         end
+
+         def self.clear_timer!(timer_id)
+           self.where(uid: timer_id, key: TIMER_KEY).delete_all
+         end
+
+         def self.fetch_timers
+           self.where(key: TIMER_KEY).where("run_timer_at < ?", Time.now).map do |record|
+             [record.uid] + JSON.parse(record.data) 
+           end 
+         end
+      end
+    else
+      class ActiveRecordMetadataRepository
+        def self.store(uid, key, data)
+          raise "ActiveRecord not found"
+        end
+
+        def self.fetch(uid, key)
+          raise "ActiveRecord not found"
+        end
+      end
+    end  
+  end
+end

data/lib/ni/storages/default.rb

@@ -0,0 +1,147 @@
+module Ni
+  module Storages
+    class Default
+      METADATA_REPOSITORY_KEY = 'store_state'
+
+      def initialize(context, metadata_repository_klass)
+        @context, @metadata_repository_klass = context, metadata_repository_klass
+
+        @storages_map = {}
+
+        setup_custom_storages
+
+        if defined?(ActiveRecord) && !skip_default_storages?
+          register_storage :active_record_record, {
+            match: ActiveRecord::Base,
+            store: -> (record) { record.save!; [record.class.name, record.id] },
+            fetch: -> (data)   { data.first.constantize.find(data.last) }
+          }
+
+          register_storage :active_record_collection, {
+            match: -> (value) do 
+              value.respond_to?(:each) && 
+              value.all? { |element| element.is_a?(ActiveRecord::Base) } &&
+              value.all? { |element| element.class == value.first.class }
+            end,
+            store: -> (records) do
+              records.each(&:save!)
+              [records.first.class.name] + records.map(&:id)
+            end,
+            fetch: -> (data) do
+              klass = data.shift.constantize
+              klass.where(id: data)
+            end    
+          }
+        end
+
+        unless skip_default_storages?
+          register_storage :true_value, {
+            match: TrueClass,
+            store: -> (value)  { nil },
+            fetch: -> (data)   { true }
+          }
+
+          register_storage :false_value, {
+            match: FalseClass,
+            store: -> (value)  { nil },
+            fetch: -> (data)   { false }
+          }
+
+          register_storage :string_value, {
+            match: String,
+            store: -> (value)  { value },
+            fetch: -> (data)   { data  }
+          }
+
+          register_storage :integer_value, {
+            match: Integer,
+            store: -> (value)  { value },
+            fetch: -> (data)   { data.to_i }
+          }
+
+          register_storage :float_value, {
+            match: Float,
+            store: -> (value)  { value },
+            fetch: -> (data)   { data.to_f }
+          }
+
+          register_storage :symbol_value, {
+            match: Symbol,
+            store: -> (value)  { value },
+            fetch: -> (data)   { data.to_sym }
+          }
+
+          register_storage :nil_value, {
+            match: NilClass,
+            store: -> (value)  { nil },
+            fetch: -> (data)   { nil }
+          }
+        end
+      end
+
+      def store
+        fetch_data = {}
+
+        @context.each do |name, value|
+          known_storage, config = @storages_map.find do |storage_name, cfg|
+            match = cfg[:match]
+
+            (match.is_a?(Class)  && value.is_a?(match)) ||
+            (match.is_a?(String) && value.is_a?(match.constantize)) ||
+            (match.is_a?(Proc)   && match.call(value))
+          end
+
+          if respond_to?(:"store_#{name}")
+            fetch_data[name] = { known_storage: nil, data: public_send(:"store_#{name}", value) }
+          elsif known_storage.present?
+            known_logic = config[:store]
+
+            if known_logic.is_a?(Proc)  
+              fetch_data[name] = { known_storage: known_storage, data: known_logic.call(value) }
+            else
+              raise "Storage logic type is not supported"
+            end    
+          else
+            raise "Logic for storing #{name} was not defined"  
+          end
+        end
+
+        @metadata_repository_klass.store(@context.system_uid, METADATA_REPOSITORY_KEY, fetch_data)
+      end
+
+      def fetch
+        fetch_data = @metadata_repository_klass.fetch(@context.system_uid, METADATA_REPOSITORY_KEY)
+
+        fetch_data.each do |name, data|
+          next if @context.has_key?(name) # do not restore an existing value. E.g. it can be provided on process launch
+
+          if respond_to?(:"store_#{name}")
+            @context.raw_set(name, public_send(:"fetch_#{name}", data[:data]))
+          elsif data[:known_storage].present?
+            if @storages_map[data[:known_storage].to_sym].present?
+              @context.raw_set(name, @storages_map[data[:known_storage].to_sym][:fetch].call(data[:data]))
+            else
+              raise "Storage is not known"
+            end    
+          else
+            raise "Doesn't know how to fetch #{name}"
+          end
+        end  
+      end
+
+      private
+
+      def skip_default_storages?
+        false
+      end
+
+      def setup_custom_storages
+        # can be defined for custom storages
+      end
+
+      def register_storage(name, config)
+        @storages_map[name] ||= config
+      end  
+    end
+  end
+end

data/lib/ni/storages_config.rb

@@ -0,0 +1,31 @@
+module Ni
+  module StoragesConfig
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      cattr_accessor :context_storage_klass, :metadata_repository_klass
+
+      def storage(klass)
+        self.context_storage_klass = klass
+      end
+      
+      def metadata_repository(klass)
+        self.metadata_repository_klass = klass
+      end
+
+      def copy_storage_and_metadata_repository(interactor_klass)
+        unless self.context_storage_klass.present?
+          if interactor_klass.context_storage_klass.present?
+            storage interactor_klass.context_storage_klass
+          end
+        end
+
+        unless self.metadata_repository_klass.present?
+          if interactor_klass.metadata_repository_klass.present?
+            metadata_repository interactor_klass.metadata_repository_klass
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ni/tools/timers.rb

@@ -0,0 +1,24 @@
+module Ni::Tools
+  class Timers
+    def self.fetch_and_run(metadata_repository_klass, exceptions_logger=nil)
+      current_timers = metadata_repository_klass.fetch_timers
+      exceptions = []
+
+      current_timers.each do |data|
+        id, klass_name, action, system_uid = data
+
+        begin
+          klass_name.constantize.public_send(action, system_uid: system_uid)
+        rescue Exception => e
+          exceptions << e
+        ensure
+          metadata_repository_klass.clear_timer!(id)
+        end  
+      end
+
+      if exceptions_logger.present? && exceptions.present?
+        exceptions.each { |e| exceptions_logger.log(e) }
+      end  
+    end
+  end
+end

data/lib/ni/version.rb

@@ -1,3 +1,3 @@
 module Ni
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/ni.gemspec

@@ -29,9 +29,7 @@ Gem::Specification.new do |spec|
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  end
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|coverage)/}) }
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ni
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - KnightWhosayNi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-19 00:00:00.000000000 Z
+date: 2019-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,12 +64,31 @@ files:
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - lib/ni.rb
+- lib/ni/action_chain.rb
+- lib/ni/context.rb
+- lib/ni/expressions_language_engine/processor.rb
+- lib/ni/expressions_language_engine/tokenizer.rb
+- lib/ni/flows/base.rb
+- lib/ni/flows/branch_interactor.rb
+- lib/ni/flows/inline_interactor.rb
+- lib/ni/flows/isolated_inline_interactor.rb
+- lib/ni/flows/utils/handle_wait.rb
+- lib/ni/flows/wait_for_condition.rb
+- lib/ni/help.rb
+- lib/ni/main.rb
+- lib/ni/params.rb
+- lib/ni/result.rb
+- lib/ni/storages/active_record_metadata_repository.rb
+- lib/ni/storages/default.rb
+- lib/ni/storages_config.rb
+- lib/ni/tools/timers.rb
 - lib/ni/version.rb
 - ni.gemspec
 homepage: https://github.com/trueknightwhosayni/ni