eco-helpers 0.9.2 → 0.9.3

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

@@ -1,32 +1,14 @@
 module Eco
   module API
-    module UseCases
-      class UseCase
-        TYPES = [:import, :filter, :transform, :sync, :export]
-        ALL_PARAMS = [:input, :people, :session, :options]
-        TYPE_PARAMS = {
-          import:    [:input, :session],
-          filter:    [:people, :session, :options],
-          transform: [:people, :session],
-          export:    [:people, :session, :options]
-        }
-
-        class << self
-          def valid_type?(type)
-            TYPES.include?(type)
-          end
-
-          def type_params(type)
-            raise "Invalid type '#{type.to_s}'" if !valid_type?(type)
-            TYPE_PARAMS[type]
-          end
-        end
+    class UseCases
+      class UseCase < BaseCase
+        @types = [:import, :filter, :transform, :sync, :export]
 
         attr_reader :name, :type, :times_launched
         attr_reader :options
 
         def initialize(name, type:, root:, &block)
-          raise "Undefined usecase type #{type}, when creating '#{name}'. Please, use any of #{TYPES}" unless self.class.valid_type?(type)
+          raise InvalidType.new("Invalid type for '#{name}'.", type: type, types: self.class.types) unless self.class.valid_type?(type)
 
           self.root = root
           @callback = block
@@ -36,28 +18,33 @@ module Eco
         end
 
         def chainer
-          # TODO: root is a UseGroup that will not point to this new case.
+          # 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)
-          raise "Root should be a UseGroup. Given: #{value}" if !value.is_a?(UseGroup)
+          raise "Root should be a Eco::API::UseCases. Given: #{value.class}" if !value.is_a?(Eco::API::UseCases)
           @root = value
         end
 
-        def launch(input: nil, people: nil, session:, options: {})
-          @options = options
-          data = UseCaseIO.new(usecase: self, input: input, people: people, session: session, options: options)
-
-          data.output = @callback.call(data.params)
-          @times_launched += 1
-
-          data_model = {
-            self => {
-              io: data
-            }
-          }
+        # Actual launch of the usecase
+        # @param io [Eco::API::UseCases::BaseIO] an input/output helper with the necessary parameters.
+        # @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 [Eco::API:Session] :session
+        # @option kargs [Hash] :options hash with symbol keys (i.e. behaviour modifiers, cli trackers, filters, etc.)
+        def launch(io: nil, **kargs)
+          params = io&.params(keyed: true) || {}
+          kargs  = params.merge(kargs).merge(usecase: self)
+
+          UseCaseIO.new(**kargs).tap do |uio|
+            @options = uio.options
+            uio.session.logger.debug("#{self.class}: going to process '#{name}'")
+            uio.output = @callback.call(*uio.params)
+            @times_launched += 1
+          end
         end
 
         protected

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

@@ -1,10 +1,12 @@
 module Eco
   module API
-    module UseCases
+    class UseCases
       class UseCaseChain < UseCase
         MAX_CHAINS   = 70
         @@num_chains = 0
 
+        @types  = [:import, :filter, :transform, :sync, :export]
+
         def initialize(name = nil, type: nil, root:, usecase: nil, &block)
           if usecase
             raise "Expected Eco::API::UseCases::UseCase. Given #{usecase.class}" if !usecase.is_a?(Eco::API::UseCases::UseCase)
@@ -19,7 +21,7 @@ module Eco
         end
 
         def root=(value)
-          raise "You cannot change root UseGroup once the chains have been resolved" if @resolved_chains
+          raise "You cannot change root Eco::API::UseCases once the chains have been resolved" if @resolved_chains
           super(value)
         end
 
@@ -43,9 +45,15 @@ module Eco
           end
         end
 
-        def launch(input: nil, people: nil, session:, options: {})
-          data_model = super(input: input, people: people, session: session, options: options)
-          launch_chain(data_model)
+        # @see Eco::API::UseCases::UseCase#launch
+        def launch(io: nil, **kargs)
+          super(io: io, **kargs).tap do |uio|
+            next if resolved_chains.empty?
+
+            resolved_chains.each do |usecase|
+              uio = usecase.launch(io: uio.chain(usecase: usecase))
+            end
+          end
         end
 
         def chain(usecase = nil)
@@ -67,7 +75,7 @@ module Eco
 
         def resolved_chains(use_group = nil)
           return @resolved_chains if @resolved_chains
-          raise "Only UseGroup object can resolve chains. Given: #{use_group} " if use_group && !use_group.is_a?(UseGroup)
+          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|
@@ -78,24 +86,6 @@ module Eco
           end
         end
 
-        private
-
-        def launch_chain(data_model)
-          return data_model if resolved_chains.empty?
-
-          data_model.tap do |dm|
-            dm[self][:chains] ||= {}
-
-            resolved_chains.each do |usecase|
-              # chained cases use same params as parent case (out of simplicity)
-              data_chain = dm[self][:io].chain(usecase: usecase)
-              keyed_data = data_chain.params(keyed: true)
-              keyed_data.delete(:usecase)
-              dm[self][:chains].merge(usecase.launch(keyed_data))
-            end
-          end
-        end
-
       end
 
     end

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

@@ -1,45 +1,25 @@
 module Eco
   module API
-    module UseCases
-      class UseCaseIO
-        TYPES      = [:import, :filter, :transform, :sync, :export]
-        ALL_PARAMS = [:input, :people, :session, :options]
-        TYPE_PARAMS = {
-          import:    [:input, :session],
-          filter:    [:people, :session, :options],
-          transform: [:people, :session],
-          export:    [:people, :session, :options]
-        }
+    class UseCases
+      class UseCaseIO < BaseIO
+        @types  = [:import, :filter, :transform, :sync, :export]
 
         attr_reader :usecase
-        attr_reader :input, :people, :session, :options
-        attr_accessor :output
 
-        class << self
-          def valid_type?(type)
-            TYPES.include?(type)
-          end
-
-          def type_params(type)
-            raise "Invalid type '#{type.to_s}'" if !valid_type?(type)
-            TYPE_PARAMS[type]
-          end
-        end
-
-        def initialize(input: nil, people: nil, session:, options: {}, usecase:)
+        def initialize(usecase:, **kargs)
           self.usecase = usecase
-          @output      = nil
-
-          validate_args(input: input, people: people, session: session, options: options)
+          super(**kargs)
+        end
 
-          @input       = input
-          @people      = people
-          @session     = session
-          @options     = options
+        # @see Eco::API::UseCases::BaseIO
+        # @param usecase [Eco::API::UseCases::UseCase] target usecase
+        # @return [Eco::API::UseCases::UseCaseIO]
+        def new(usecase:, **kargs)
+          super(**kargs.merge(usecase: usecase))
         end
 
         def usecase=(value)
-          raise "It should be a UseCase. Given: #{value}" if !value.is_a?(UseCase)
+          raise "It should be a Eco::API::UseCases::UseCase. Given: #{value}" if !value.is_a?(Eco::API::UseCases::UseCase)
           @usecase = value
         end
 
@@ -47,17 +27,18 @@ module Eco
           @usecase.type
         end
 
-        def params(input: nil, people: nil, session: nil, options: {}, keyed: false)
-          opts      = @options.merge(options&.dup || {})
-          input   ||= @input
-          people  ||= @people
-          session ||= @session
+        def type=(value)
+          raise "Can't modify type depends on the usecase linked to this IO object"
+        end
 
-          kargs = {}
-          kargs.merge!(input:    input)  if input_required?
-          kargs.merge!(people:  people)  if people_required?
-          kargs.merge!(session: session, options: opts, usecase: usecase)
-          keyed ? kargs : kargs.values
+        def params(keyed: false)
+          super(keyed: keyed).tap do |res|
+            if keyed
+              res.merge!(usecase: usecase)
+            else
+              res.push(usecase)
+            end
+          end
         end
 
         def chain(usecase:)
@@ -76,39 +57,6 @@ module Eco
           end
           self.class.new(kargs)
         end
-
-        protected
-
-        private
-
-        def validate_args(input:, people:, session:, options:)
-          case
-          when !session.is_a?(Eco::API::Session)
-            raise "A UseCase needs a Session object. Given: #{session}"
-          when input_required? && !input
-            raise "UseCase of type '#{type}' requires a valid input. None given"
-          when people_required? && !people.is_a?(Eco::API::Organization::People)
-            raise "UseCase of type '#{type}' requires a People object. Given: #{people}"
-          when !options || (options && !options.is_a?(Hash))
-            raise "To inject dependencies via ':options' it should be a Hash object. Given: #{options}"
-          when options_required? && !options
-            raise "UseCase of type '#{type}' requires a Hash ':options' object."
-          end
-          true
-        end
-
-        def input_required?
-          [:import, :sync].include?(type)
-        end
-
-        def people_required?
-          [:filter, :transform, :sync, :export].include?(type)
-        end
-
-        def options_required?
-          [:filter].include?(type)
-        end
-
       end
 
     end

data/lib/eco/assets.rb

@@ -1,5 +1,3 @@
-require 'ecoportal/api'
-
 module Eco
   class Assets
 
@@ -7,23 +5,16 @@ module Eco
 
     def initialize
       @active_config = :default
+      @cli      = Eco::CLI.new
+      @cli_init = false
     end
 
     def session(key: active_config, update_active: true)
       config(key: key, update_active: update_active).session.tap do |session|
         yield(session) if block_given?
       end
-      #sessions[key] ||= Eco::API::Session.new(config(key: key, update_active: update_active))
-      #sessions[key].tap do |session|
-      #  yield(session) if block_given?
-      #end
     end
 
-    #def sessions
-    #  @sessions ||= {}
-    #end
-
-
     def config(key: active_config, update_active: true)
       configs[:default] ||= Eco::API::Session::Config.new(key)
       unless configs.key?(key)
@@ -39,6 +30,15 @@ module Eco
     def configs
       @configs ||= {}
     end
+
+    def cli
+      unless @cli_init
+        @cli_init = true
+        #pp "going to load default cli config..."
+        require_relative('cli/config/default')
+      end
+      @cli
+    end
   end
 end
 

data/lib/eco/cli.rb

@@ -1,5 +1,42 @@
 module Eco
   class CLI
+
+    def initialize
+      @config = nil
+    end
+
+    def args
+      ARGV
+    end
+
+    def options
+      @options ||= {}
+    end
+
+    def config
+      @config ||= Eco::CLI::Config.new(cli: self)
+      @config.tap do |cnf|
+        yield(cnf) if block_given?
+      end
+    end
+
+    def workflow
+      @workflow ||= Eco::CLI::Workflow.new(cli: self)
+    end
+
+    def run(session:)
+      io = Eco::API::UseCases::BaseIO.new(session: session, options: options)
+      io = io.new(options: config.options_set.process(io: io))
+
+      session.workflow(io: io) do |wf, io|
+        io = wf.run(:load, io: io)
+        io = wf.run(:usecases, io: io)
+        io = wf.run(:launch_jobs, io: io)
+        io = wf.run(:post_launch, io: io)
+        io = wf.run(:end, io: io)
+      end
+    end
+
   end
 end
 

data/lib/eco/cli/config.rb

@@ -2,9 +2,71 @@ module Eco
   class CLI
     class Config
 
+      attr_reader :cli
+
+      def initialize(cli:)
+        @cli = cli
+      end
+
+      def options
+        cli.options
+      end
+
+      def args
+        cli.args
+      end
+
+      def options_set
+        @opions_set ||= Eco::CLI::Config::OptionsSet.new(core_config: self)
+        @opions_set.tap do |opts_set|
+          yield(opts_set, options) if block_given?
+        end
+      end
+
+      def input(default_option: nil)
+        @input ||= Eco::CLI::Config::Input.new(core_config: self, default_option: default_option)
+        if block_given?
+          @input.define(&Proc.new)
+          self
+        else
+          @input
+        end
+      end
+
+      def people(io: nil)
+        if block_given?
+          @people_load = Proc.new
+          self
+        else
+          raise "There is no definition on how to load people" unless instance_variable_defined?(:@people_load) && @people_load
+          unless io && 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: :import)
+          @people_load.call(*io.params)
+        end
+      end
+
+      def people_filters
+        @people_filters ||= Eco::CLI::Config::PeopleFilters.new(core_config: self)
+        @people_filters.tap do |filters|
+          yield(filters) if block_given?
+        end
+      end
+
+      def usecases
+        @usecases ||= Eco::CLI::Config::UseCases.new(core_config: self)
+        @usecases.tap do |cases|
+          yield(cases) if block_given?
+        end
+      end
 
     end
   end
 end
 
-require_relative 'config/options'
+require_relative 'config/options_set'
+require_relative 'config/input'
+require_relative 'config/people_filters'
+require_relative 'config/use_cases'