eco-helpers 3.0.21 → 3.0.23

data/lib/eco/api/usecases/use_case.rb

@@ -2,18 +2,18 @@ module Eco
   module API
     class UseCases
       class UseCase < BaseCase
-        @types = BaseCase.types
+        require_relative 'use_case/chainer'
+        include Chainer
 
-        attr_reader :name, :type, :times_launched
+        attr_reader :name, :type, :model
         attr_reader :options
+        attr_reader :times_launched
 
-        def initialize(name, type:, root:, &block)
-          invalid_type_err = InvalidType.new(
-            "Invalid type for '#{name}'.",
-            type:  type,
-            types: self.class.types
-          )
-          raise invalid_type_err unless self.class.valid_type?(type)
+        def initialize(name, type:, root:, model: nil, &block)
+          validate_type!(type, msg: "Invalid type for '#{name}'.")
+
+          model ||= self.class.type_to_default_model(type)
+          validate_model!(model, msg: "Invalid model for '#{name}'.")
 
           super()
 
@@ -21,6 +21,7 @@ module Eco
           @callback       = block
           @name           = name
           @type           = type
+          @model          = model
           @times_launched = 0
         end
 
@@ -30,12 +31,6 @@ module Eco
           callback_self
         end
 
-        def chainer
-          # @todo: root is a Eco::API::UseCases that will not point to this new case.
-          # => Moreover, the name and type will be the same as self
-          Eco::API::UseCases::UseCaseChain.new(usecase: self, root: @root)
-        end
-
         def root=(value)
           msg = "Root should be a Eco::API::UseCases. Given: #{value.class}"
           raise ArgumentError, msg unless value.is_a?(Eco::API::UseCases)
@@ -48,7 +43,9 @@ module Eco
         # @param kargs [Hash] hash with symbol keys.
         # @option kargs [Eco::API::Common::People::Entries, Eco::API::Organization::People] :input
         #   the input data of reference.
-        # @option kargs [Eco::API::Organization::People] :people object.
+        # @option kargs [Variant] :data object.
+        #     @option kargs [Eco::API::Organization::People] :people object.
+        #     @option kargs [Eco::API::Organization::Contractors] :contractors object.
         # @option kargs [Eco::API:Session] :session
         # @option kargs [Hash] :options hash with symbol keys (i.e. behaviour modifiers, cli trackers, filters, etc.)
         # @return [Eco::API::UseCases::UseCaseIO] an io with the result in output
@@ -94,19 +91,31 @@ module Eco
         def set_session_n_options(uio) # rubocop:disable Naming/AccessorMethodName
           return false unless callback_from_loader?
 
-          opts          = uio.options || @options
-          sess          = uio.session
-          peo           = uio.people
-          ent           = uio.input
+          opts = uio.options || @options
+          sess = uio.session
+          dt   = uio.data
+          ent  = uio.input
+
+          mdl  = model
+
           use_case_self = self
 
           callback_self.instance_eval do
             @session = sess
             @options = opts
 
-            if peo
-              @people = peo
-              singleton_class.attr_reader(:people) unless respond_to?(:people)
+            if dt
+              @data = dt
+              singleton_class.attr_reader(:data) unless respond_to?(:data)
+
+              case mdl
+              when :people
+                @people = dt
+                singleton_class.attr_reader(:people) unless respond_to?(:people)
+              when :contractors
+                @contractors = dt
+                singleton_class.attr_reader(:contractors) unless respond_to?(:contractors)
+              end
             end
 
             if ent # entries/input

data/lib/eco/api/usecases/use_case_chain/chaining.rb

@@ -0,0 +1,88 @@
+class Eco::API::UseCases::UseCaseChain
+  module Chaining
+    MAX_CHAINS   = 70
+    @@num_chains = 0
+
+    def use(preserve_chains: false, recursive: false)
+      UseCase.new(
+        @name,
+        type:  @type,
+        model: @model,
+        root:  @root,
+        &@case
+      ).tap do |newcase|
+        next unless preserve_chains
+
+        chain_use = {preserve_chains: recursive, recursive: recursive}
+
+        @chains = @chains.map do |usecase|
+          if usecase.respond_to?(:call)
+            proc do |usegroup|
+              usecase = usecase.call(usegroup)
+              usecase.use(**chain_use).chain_to(newcase)
+              usecase
+            end
+          elsif usecase.is_a?(UseCase)
+            usecase.use(**chain_use).chain_to(newcase)
+            usecase
+          end
+        end
+      end
+    end
+
+    def chain(usecase = nil, &block)
+      @@num_chains += 1
+
+      msg  = "Reached maximum number of chained use cases (#{MAX_CHAINS}). "
+      msg << "Looks like a recursive cyclic chain 'use'"
+      raise msg if @@num_chains >= MAX_CHAINS
+
+      msg = "A UseCase can only be chained with another UseCase"
+      raise msg if usecase && !usecase.is_a?(UseCase)
+
+      msg = "Missuse. Please use either parameter or block but not both"
+      raise msg if block_given? && usecase
+
+      usecase = block if block_given?
+      @chains.push(usecase)
+      self
+    end
+
+    protected
+
+    def chain_to(usecase)
+      msg = "A UseCase can only be chained with another UseCase"
+      raise msg if usecase && !usecase.is_a?(UseCase)
+
+      usecase.chain(self)
+    end
+
+    def resolved_chains(use_group = nil)
+      return @resolved_chains if @resolved_chains
+
+      msg  = "Only Eco::API::UseCases object can contain resolved chains. "
+      msg << "Given: #{use_group.class}"
+      raise msg if use_group && !use_group.is_a?(Eco::API::UseCases)
+
+      use_group ||= @root
+      @resolved_chains = @chains.map do |usecase|
+        usecase = usecase.call(use_group) if usecase.respond_to?(:call)
+
+        msg = "A UseCase can only be chained with another UseCase"
+        raise msg if usecase && !usecase.is_a?(UseCase)
+
+        usecase.resolved_chains(use_group) if usecase.respond_to?(:resolved_chains)
+        usecase
+      end
+    end
+
+    # INSTANCE METHODS
+
+    private
+
+    def reset_chains!
+      @chains = []
+      @resolved_chains = nil
+    end
+  end
+end

data/lib/eco/api/usecases/use_case_chain.rb

@@ -3,46 +3,31 @@ module Eco
     class UseCases
       # Class that enables to chain multiple UseCase
       class UseCaseChain < UseCase
-        @types       = UseCase.types
-        MAX_CHAINS   = 70
-        @@num_chains = 0
+        require_relative 'use_case_chain/chaining'
+        include Chaining
 
-        def initialize(name = nil, type: nil, root:, usecase: nil, &block)
+        def initialize(name = nil, root:, type: nil, model: nil, usecase: nil, &block)
           if usecase
-            raise "Expected Eco::API::UseCases::UseCase. Given #{usecase.class}" if !usecase.is_a?(Eco::API::UseCases::UseCase)
-            type = usecase.type
-            name = usecase.name
-            block = usecase.callback unless block
+            msg  = "Expected Eco::API::UseCases::UseCase. "
+            msg << "Given #{usecase.class}"
+            raise msg unless usecase.is_a?(Eco::API::UseCases::UseCase)
+
+            type    = usecase.type
+            name    = usecase.name
+            block ||= usecase.callback
           end
 
-          super(name, type: type, root: root, &block)
-          @chains   = []
-          @resolved_chains = nil
+          super(name, type: type, model: model, root: root, &block)
+
+          reset_chains!
         end
 
         def root=(value)
-          raise "You cannot change root Eco::API::UseCases once the chains have been resolved" if @resolved_chains
-          super(value)
-        end
+          return super unless @resolved_chains # rubocop:disable Lint/ReturnInVoidContext
 
-        def use(preserve_chains: false, recursive: false)
-          UseCase.new(@name, type: @type, root: @root, &@case).tap do |newcase|
-            if preserve_chains
-              chain_use = {preserve_chains: recursive, recursive: recursive}
-              @chains = @chains.map do |usecase|
-                if usecase.respond_to? :call
-                  Proc.new do |usegroup|
-                    usecase = usecase.call(usegroup)
-                    usecase.use(chain_use).chain_to(newcase)
-                    usecase
-                  end
-                elsif usecase.is_a?(UseCase)
-                  usecase.use(chain_use).chain_to(newcase)
-                  usecase
-                end
-              end
-            end
-          end
+          msg = "You cannot change root Eco::API::UseCases "
+          msg << "once the chains have been resolved"
+          raise msg
         end
 
         # @see Eco::API::UseCases::UseCase#launch
@@ -55,36 +40,6 @@ module Eco
             end
           end
         end
-
-        def chain(usecase = nil, &block)
-          @@num_chains += 1
-          raise "Reached maximum number of chained use cases (#{MAX_CHAINS}). Looks like a recursive cyclic chain 'use'" if @@num_chains >= MAX_CHAINS
-          raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
-          raise "Missuse. Please use either parameter or block but not both" if block_given? && usecase
-          usecase = block_given?? block : usecase
-          @chains.push(usecase)
-          self
-        end
-
-        protected
-
-        def chain_to(usecase)
-          raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
-          usecase.chain(self)
-        end
-
-        def resolved_chains(use_group = nil)
-          return @resolved_chains if @resolved_chains
-          raise "Only Eco::API::UseCases object can contain resolved chains. Given: #{use_group.class} " if use_group && !use_group.is_a?(Eco::API::UseCases)
-
-          use_group = use_group || @root
-          @resolved_chains = @chains.map do |usecase|
-            usecase = usecase.call(use_group)  if usecase.respond_to?(:call)
-            raise "A UseCase can only be chained with another UseCase" if usecase && !usecase.is_a?(UseCase)
-            usecase.resolved_chains(use_group) if usecase.respond_to?(:resolved_chains)
-            usecase
-          end
-        end
       end
     end
   end

data/lib/eco/api/usecases/use_case_io/chain.rb

@@ -0,0 +1,24 @@
+class Eco::API::UseCases::UseCaseIO
+  module Chain
+    def chain(usecase:)
+      msg = "It should be a Eco::API::UseCases::UseCase. Given: #{usecase.class}"
+      raise ArgumentError, msg unless usecase.is_a?(Eco::API::UseCases::UseCase)
+
+      #aux_io = self.class.new(input: input, data: data, session: session, options: options, usecase: usecase)
+      #kargs  = aux_io.params(keyed: true)
+      kargs = params(keyed: true, all: true).merge(usecase: usecase)
+      kargs.delete(:job)
+
+      case type
+      when :import
+        kargs[:input] = output
+      when :filter
+        kargs[:data] = output
+      when :transform, :sync, :export, :error_handler, :other
+        # no redirections => should it redirect the input?
+      end
+
+      self.class.new(**kargs)
+    end
+  end
+end

data/lib/eco/api/usecases/use_case_io.rb

@@ -7,7 +7,8 @@ module Eco
       #  - provides a helper to `chain` InputOutput between usecases
       # @attr_reader usecase [Eco::API::UseCases::UseCase] the usecase this InputOuput is linked to
       class UseCaseIO < BaseIO
-        @types  = BaseIO.types
+        require_relative 'use_case_io/chain'
+        include Chain
 
         attr_reader :usecase
 
@@ -31,17 +32,28 @@ module Eco
 
         # @param value [Eco::API::UseCases::UseCase] the usecase this InputOuput should be linked to
         def usecase=(value)
-          raise "It should be a Eco::API::UseCases::UseCase. Given: #{value}" if !value.is_a?(Eco::API::UseCases::UseCase)
+          msg = "It should be a Eco::API::UseCases::UseCase. Given: #{value}"
+          raise ArgumentError, msg unless value.is_a?(Eco::API::UseCases::UseCase)
+
           @usecase = value
         end
 
         # @return [Symbol] the `type` of the UseCase this InputOuput is linked to
         def type
-          @usecase.type
+          usecase.type
+        end
+
+        # @return [Symbol] the `model` of the UseCase this InputOuput is linked to
+        def model
+          usecase.model
+        end
+
+        def type=(_value)
+          raise "Can't modify type: depends on the usecase linked to this IO object"
         end
 
-        def type=(value)
-          raise "Can't modify type depends on the usecase linked to this IO object"
+        def model=(_value)
+          raise "Can't modify model: depends on the usecase linked to this IO object"
         end
 
         # @see Eco::API::UseCases::BaseIO#params
@@ -57,23 +69,6 @@ module Eco
             end
           end
         end
-
-        def chain(usecase:)
-          raise "It should be a UseCase. Given: #{usecase}" if !usecase.is_a?(UseCase)
-          #aux_io = self.class.new(input: input, people: people, session: session, options: options, usecase: usecase)
-          #kargs  = aux_io.params(keyed: true)
-          kargs  = params(keyed: true, all: true).merge(usecase: usecase)
-          kargs.delete(:job)
-          case self.type
-          when :import
-            kargs[:input]  = output
-          when :filter
-            kargs[:people] = output
-          when :transform, :sync, :export, :error_handler, :other
-            # no redirections => should it redirect the input?
-          end
-          self.class.new(**kargs)
-        end
       end
     end
   end

data/lib/eco/api/usecases.rb

@@ -42,6 +42,7 @@ module Eco
 
       def each(&block)
         return to_enum(:each) unless block
+
         items.each(&block)
       end
 
@@ -59,8 +60,14 @@ module Eco
       end
 
       # @return [Eco::API::UseCases::UseCase] the `name` usecase of type `type` with the defined `block`.
-      def define(name, type:, &block)
-        Eco::API::UseCases::UseCase.new(name, type: type, root: self, &block).tap do |usecase|
+      def define(name, type:, model: nil, &block)
+        Eco::API::UseCases::UseCase.new(
+          name,
+          type:  type,
+          model: model,
+          root:  self,
+          &block
+        ).tap do |usecase|
           add(usecase)
         end
       end
@@ -69,11 +76,12 @@ module Eco
       # @param usecase [Eco::API::UseCases::UseCase] the usecase to be added.
       def add(usecase)
         msg = "Expected Eco::API::UseCases::UseCase object. Given: #{usecase.class}"
-        raise ArgumentError, msg if !usecase || !usecase.is_a?(Eco::API::UseCases::UseCase)
+        raise ArgumentError, msg unless usecase.is_a?(Eco::API::UseCases::UseCase)
 
         name = usecase.name
         type = usecase.type
         puts "Warning: overriding '#{type}' case #{name}" if self.defined?(name, type: type)
+
         to_h[key(name, type)] = usecase
         @cache_init = false
         usecase
@@ -107,7 +115,7 @@ module Eco
       end
 
       def types(name)
-        return nil unless name?(name)
+        return unless name?(name)
 
         by_name[name].map(&:type)
       end
@@ -168,8 +176,9 @@ require_relative 'usecases/use_case_chain'
 require_relative 'usecases/base_io'
 require_relative 'usecases/use_case_io'
 require_relative 'usecases/cli'
-require_relative 'usecases/default_cases'
 require_relative 'usecases/graphql'
+require_relative 'usecases/default'
+require_relative 'usecases/samples'
+require_relative 'usecases/default_cases' # legacy
 require_relative 'usecases/ooze_samples'
 require_relative 'usecases/ooze_cases'
-require_relative 'usecases/default'

data/lib/eco/assets.rb

@@ -32,7 +32,7 @@ module Eco
       @configs ||= {}
     end
 
-    def cli(&block)
+    def cli
       unless @cli_init
         @cli_init = true
         require_relative('cli_default')

data/lib/eco/cli/config/filters/people_filters.rb

@@ -3,23 +3,24 @@ module Eco
     class Config
       class Filters
         class PeopleFilters < Eco::CLI::Config::Filters
-
           def help(refine: nil)
             refinement = refine.is_a?(String)? " (containing: '#{refine}')" : ""
             super("The following are the available filters on people#{refinement}:", refine: refine)
           end
 
           def process(io:)
-            unless io && io.is_a?(Eco::API::UseCases::BaseIO)
+            unless io.is_a?(Eco::API::UseCases::BaseIO)
               raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
             end
 
             io = io.new(type: :transform)
+
             @filters.each do |arg, callback|
-              if SCR.get_arg(arg)
-                io = io.new(people: callback.call(*io.params))
-              end
+              next unless SCR.get_arg(arg)
+
+              io = io.new(data: callback.call(*io.params))
             end
+
             io.people
           end
         end

data/lib/eco/cli/config/input.rb

@@ -17,8 +17,12 @@ module Eco
 
         def define(option: nil, &block)
           option ||= default_option
-          raise "Missing option to identify the input (no default defined)" unless !!option
-          raise "Missing block to define the input obtention process" unless block
+
+          msg = "Missing option to identify the input (no default defined)"
+          raise ArgumentError, msg unless option
+
+          msg = "Missing block to define the input obtention process"
+          raise ArgumentError, msg unless block_given?
 
           @callbacks[option] = block
         end

data/lib/eco/cli/config/use_cases.rb

@@ -57,7 +57,7 @@ module Eco
         # @param desc [String] description of the case.
         # @param case_name [String, nil] the name of the usecase as defined.
         def add(option_case, type, desc = nil, case_name: nil, &callback)
-          Eco::API::UseCases::UseCase.validate_type(type)
+          Eco::API::UseCases::UseCase.validate_type!(type)
 
           unless block_given?
             raise "You must specify a valid 'case_name' when no block is provided" unless case_name
@@ -154,7 +154,9 @@ module Eco
         def validate_io!(io)
           return if io.is_a?(Eco::API::UseCases::BaseIO)
 
-          raise ArgumentError, "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
+          msg  = "You need to provide Eco::API::UseCases::BaseIO object. "
+          msg << "Given: #{io.class}"
+          raise ArgumentError, msg
         end
       end
     end

data/lib/eco/cli_default/people_filters.rb

@@ -111,6 +111,7 @@ ASSETS.cli.config do |cnf| # rubocop:disable Metrics/BlockLength
         session.log(:info) {
           "Filtered #{filtered.count} people out of #{people.count} total"
         }
+
         people.newFrom filtered
       end
     end