eco-helpers 1.1.8 → 1.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8bb65fa77866287c89c165a152c4ae1be166ba503c84bc82b5cd0bc4f170959
-  data.tar.gz: f929153851479707bc1cad9a44842976c278905dad9068ebeeedce82be5151c9
+  metadata.gz: f7f4931954cedd399ca4fc599e4e8b1e1d3f1b4502123f06063160aed254d70c
+  data.tar.gz: 1fc36250ebe32d93d03e59d06773a55995e831e55317b3e71ed7fc3193d3565a
 SHA512:
-  metadata.gz: fbacc11118acf97dbc8cc8d17505ae5c436c59b4ebb68e50fcf10e388ce8212b6a520c3b81aea6c705fba67ce112ee6850b1d4421da07c20da5f3a16e1929f07
-  data.tar.gz: '0087ea49d27a64fe48736231f6a65cac4c1ac65308ff5f17232e4d5a3928170ba9d7b758f6ea991766a0bf9d3c61e9a75d42c151c4f3dd6da63d55d7d7ce0b9b'
+  metadata.gz: b1519bd960047cba719b9ff5556374b4653fde6f96c666a9369b874bf1eaaa24f8737e69ed05f70c770932432e8832c3a69c9042a63e3c9add6ffc35b2c97584
+  data.tar.gz: 52a15098f25c0ebe4ce696356110d33fd79244a1bf9f2edbcf67a29fe5998a87a95f444adbe5e8a8c403907b8b2e9e08ef12d9bf6aa80ecb7b8cac61984c8e8f

data/lib/eco/api/common.rb

@@ -7,5 +7,6 @@ end
 
 require_relative 'common/version_patches'
 require_relative 'common/class_helpers'
+require_relative 'common/class_hierarchy'
 require_relative 'common/people'
 require_relative 'common/session'

data/lib/eco/api/common/class_helpers.rb

@@ -27,6 +27,38 @@ module Eco
             end
         end
 
+        # Helper to normalize `key` into a correct `ruby` **constant name**
+        # @param key [String, Symbol] to be normalized
+        # @return [String] a correct constant name
+        def to_constant(key)
+          str_name = key.to_s.strip.split(/[\-\_ ]/i).compact.map do |str|
+            str.slice(0).upcase + str.slice(1..-1).downcase
+          end.join("")
+        end
+
+        # If the class for `name` exists, it returns it. Otherwise it generates it.
+        # @param name [String, Symbol] the name of the new class
+        # @param inherits [Class] the parent class to _inherit_ from
+        # @param parent_space [String] parent namespace of the generated class, if not given: `self`
+        # @yield [child_class] configure the new class
+        # @yieldparam child_class [Class] the new class
+        # @return [Class] the new generated class
+        def new_class(name, inherits:, parent_space: nil)
+          name            = name.to_sym.freeze
+          class_name      = to_constant(name)
+          parent_space    = parent_space ? resolve_class(parent_space) : self
+          full_class_name = "#{parent_space}::#{class_name}"
+
+          unless target_class = resolve_class(full_class_name, exception: false)
+            target_class = Class.new(inherits)
+            parent_space.const_set class_name, target_class
+          end
+
+          target_class.tap do |klass|
+            yield(klass) if block_given?
+          end
+        end
+
       end
     end
   end

data/lib/eco/api/common/class_hierarchy.rb

@@ -0,0 +1,48 @@
+module Eco
+  module API
+    module Common
+      # Helpers for dynammic generation of classes based on a hierarchical model
+      # @attr_reader model [Hash, nil] the `model` of the current `class`
+      module ClassHierarchy
+        include Eco::API::Common::ClassHelpers
+
+        attr_reader :model
+
+        # @param value [Hash, Enumerable, String, Symbol, nil] unparsed model to be assigned to the `class`
+        def model=(value)
+          @model = parse_model(value)
+        end
+
+        # @return [Array<String>] the `keys` of the current class' `model`
+        def model_attrs
+          (model && model.keys) || []
+        end
+
+        # Thanks to this step the format on the declaration of the model is flexible
+        # @param value [Hash, Enumerable, String, Symbol, nil]
+        # @return [Hash, nil] where keys are `Symbol` s
+        def parse_model(model)
+          case model
+          when String
+            return parse_model(model.to_sym)
+          when Symbol
+            return {model => nil}
+          when Hash
+            return model.each_with_object({}) do |(k,v), hash|
+              hash[k.to_sym] = v
+            end
+          when Enumerable
+            return model.each_with_object({}) do |sub, hash|
+              hash.merge!(parse_model(sub))
+            end
+          when NilClass
+            return nil
+          else
+            raise "Incorrect model declaration, allowed String, Symbol, Hash and Enumerable. Given: #{model.class}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/eco/api/organization/presets_reference.json

@@ -0,0 +1,42 @@
+{
+  "read_only" : {
+    "files": "browse",
+    "data": "view",
+    "reports": "view",
+    "organization": null,
+    "people": null,
+    "pages": "view",
+    "page_editor": null,
+    "registers": "view"
+  },
+  "forms" : {
+    "files": "browse",
+    "data": "view",
+    "reports": "view",
+    "organization": null,
+    "people": "attach",
+    "pages": "create",
+    "page_editor": "basic",
+    "registers": "view"
+  },
+  "editor" : {
+    "files": "browse",
+    "data": "update",
+    "reports": "edit",
+    "organization": "view",
+    "people": "view",
+    "pages": "create",
+    "page_editor": "intermediate",
+    "registers": "view"
+  },
+  "administrator" : {
+    "files": "administrate",
+    "data": "administrate",
+    "reports": "administrate",
+    "organization": "administrate",
+    "people": "edit",
+    "pages": "administrate",
+    "page_editor": "advanced",
+    "registers": "dashboard"
+  }
+}

data/lib/eco/api/session/batch/base_policy.rb

@@ -19,73 +19,20 @@ module Eco
         # @attr_reader max [Integer] `max` **allowed**  number of occurrences of the property
         # @attr_reader min [Integer] `min` **required** number of occurrences of the property
         class BasePolicy
-          extend Eco::API::Common::ClassHelpers
+          extend Eco::API::Common::ClassHierarchy
 
-          # @attr_reader model [Hash, nil] the `model` of the current `class`
           class << self
-            attr_reader :model
-
-            # @param value [Hash, Enumerable, String, Symbol, nil] unparsed model to be assigned to the `class`
-            def model=(value)
-              @model = parse_model(value)
-            end
-
-            # @return [Array<String>] the `keys` of the current class' `model`
-            def model_attrs
-              (model && model.keys) || []
-            end
-
-            # Helper to normalize `key` into a correct `ruby` **constant name**
-            # @param key [String, Symbol] to be normalized
-            # @return [String] a correct constant name
-            def titleize(key)
-              str_name = key.to_s.strip.split(/[\-\_ ]/i).compact.map do |str|
-                str.slice(0).upcase + str.slice(1..-1).downcase
-              end.join("")
-            end
 
             # If the class for `key` exists, it returns it. Otherwise it generates it.
             # @note for this to work, `key` should be one of the submodels of the current class' `model`
             # @return [Eco::API::Session::Batch::BasePolicy] or subclass thereof
             def policy_class(key)
               key             = key.to_sym.freeze
-              class_name      = titleize(key)
-              full_class_name = "#{self}::#{class_name}"
-
-              unless target_class = resolve_class(full_class_name, exception: false)
-                submodel = model[key]
-                target_class = Class.new(self) do |klass|
-                  klass.model = submodel
-                  policy_attrs *klass.model_attrs
-                end
+              class_name      = to_constant(key)
 
-                self.const_set class_name, target_class
-              end
-
-              target_class
-            end
-
-            # Thanks to this step the format on the declaration of the model is flexible
-            # @param value [Hash, Enumerable, String, Symbol, nil]
-            # @return [Hash, nil] where keys are `Symbol` s
-            def parse_model(model)
-              case model
-              when String
-                return parse_model(model.to_sym)
-              when Symbol
-                return {model => nil}
-              when Hash
-                return model.each_with_object({}) do |(k,v), hash|
-                  hash[k.to_sym] = v
-                end
-              when Enumerable
-                return model.each_with_object({}) do |sub, hash|
-                  hash.merge!(parse_model(sub))
-                end
-              when NilClass
-                return nil
-              else
-                raise "Incorrect model declaration, allowed String, Symbol, Hash and Enumerable. Given: #{model.class}"
+              new_class(class_name, inherits: Eco::API::Session::Batch::BasePolicy) do |klass|
+                klass.model = model[key]
+                klass.policy_attrs *klass.model_attrs
               end
             end
 
@@ -99,7 +46,6 @@ module Eco
                 var    = "@#{method}".freeze
 
                 define_method(method) do |&block|
-
                   unless policy = self[attr]
                     klass  = self.class.policy_class(attr)
                     policy = self[attr] = klass.new(attr, _parent: self)

data/lib/eco/api/session/config/workflow.rb

@@ -3,54 +3,40 @@ module Eco
     class Session
       class Config
         class Workflow
-          extend Eco::API::Common::ClassHelpers
-
-          @workflow = {
-            options:     nil,
-            load:        {input: nil, people: {get: nil, filter: nil}, filter: nil},
-            usecases:    nil,
-            launch_jobs: nil,
-            post_launch: {usecases: nil, launch_jobs: nil},
-            end:         nil,
-            close:       nil
-          }
+          extend Eco::API::Common::ClassHierarchy
+
+          WORKFLOW_MODEL = [
+            :options,
+            {load: [:input, {people: [:get, :filter]}, :filter]},
+            :usecases, :launch_jobs,
+            {post_launch: [:usecases, :launch_jobs]},
+            :end, :close
+          ]
 
           class << self
             def stages
-              @stages ||= (@workflow || {}).keys
+              model_attrs
             end
 
-            def validate_stage(stage)
-              "Unknown Workflow stage '#{stage}'. Should be any of #{stages}" unless stages.include?(stage)
+            def model
+              super || {}
             end
 
-            def titleize(key)
-              str_name = key.to_s.strip.split(/[\-\_ ]/i).compact.map do |str|
-                str.slice(0).upcase + str.slice(1..-1).downcase
-              end.join("")
+            def validate_stage(stage)
+              "Unknown Workflow stage '#{stage}'. Should be any of #{stages}" unless stages.include?(stage)
             end
 
-            def get_model(key)
-              raise "Expected Symbol. Given: #{key.class}" unless key.is_a?(Symbol)
-              workflow = @workflow[key]
-              raise "Expected Hash. Given #{model.class}" unless !workflow || workflow.is_a?(Hash)
-
-              class_name      = titleize(key.to_s)
-              full_class_name = "#{self}::#{class_name}"
+            def workflow_class(key)
+              class_name = to_constant(key.to_s)
 
-              if target_class = resolve_class(full_class_name, exception: false)
-              else
-                target_class  = Class.new(Eco::API::Session::Config::Workflow) do
-                  @workflow = workflow
-                end
-                self.const_set class_name, target_class
+              new_class(class_name, inherits: Eco::API::Session::Config::Workflow) do |klass|
+                klass.model = model[key]
               end
-
-              target_class
             end
 
           end
 
+          self.model = WORKFLOW_MODEL
           attr_reader :config
           attr_reader :name
 
@@ -201,6 +187,7 @@ module Eco
           # @param key [Symbol, nil] cases:
           #   - if `key` is not provided, it targets the _current stage_
           #   - if `key` is provided, it targets the specific _sub-stage_
+          # @param io [Eco::API::UseCases::BaseIO] the input/output object
           # @yield [stage_workflow, io] if a `block` is provided, see `note`
           # @yieldparam stage_workflow [Eco::API::Session::Config::Workflow] the _target stage_ referred by `key`
           # @yieldparam io [Eco::API::UseCases::BaseIO] the input/output object carried througout all the _workflow_
@@ -273,7 +260,7 @@ module Eco
 
           def stage(key)
             self.class.validate_stage(key)
-            @stages[key] ||= self.class.get_model(key).new(key, _parent: self, config: config)
+            @stages[key] ||= self.class.workflow_class(key).new(key, _parent: self, config: config)
           end
 
         end

data/lib/eco/cli/config.rb

@@ -43,7 +43,7 @@ module Eco
             raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
           end
 
-          io = io.new(type: :import)
+          io = io.new(type: :import, input: io.input || [])
           @people_load.call(*io.params)
         end
       end

data/lib/eco/cli/config/default/options.rb

@@ -1,9 +1,20 @@
 ASSETS.cli.config do |cnf|
   cnf.options_set do |options_set, options|
 
-    options_set.add(["-dry-run", "-simulate"]) do |options|
+    options_set.add("-entries-from") do |options, session|
+      options.deep_merge!(input: {entries_from: true})
+    end
+
+    options_set.add("-get-people") do |options, session|
+      options.deep_merge!(people: {
+        get: {from: :remote, type: :full}
+      })
+    end
+
+    options_set.add(["-dry-run", "-simulate"]) do |options, session|
       options[:dry_run]  = true
       options[:simulate] = true
+      session.config.dry_run!
     end
 
     options_set.add("-skip-batch-policy") do |options|

data/lib/eco/cli/config/default/workflow.rb

@@ -4,7 +4,7 @@ ASSETS.cli.config do |config|
     io = nil
     # default rescue
     wf.rescue do |exception, io|
-      #io.session.logger.error(exception.patch_full_message)
+      io.session.logger.error(exception.patch_full_message)
       wf.run(:close, io: io)
       io
     end
@@ -14,15 +14,37 @@ ASSETS.cli.config do |config|
     end
 
     wf.for(:load) do |wf_load|
+      active_cases = nil
+
       wf_load.on(:input) do |wf_input, io|
-        io = io.new(input:   config.input.get(io: io))
+        active_cases     = config.usecases.active(io: io)
+
+        cases_with_input = active_cases.select do |usecase, data|
+          io.class.input_required?(usecase.type)
+        end
+
+        next io unless (!io.input || io.input.empty?) && !cases_with_input.empty?
+
+        if io.options.dig(:input, :entries_from)
+          io = io.new(input: config.input.get(io: io))
+        else
+          opt_case = cases_with_input.values.first[:option]
+          io = io.new(input: config.input.get(io: io, option: opt_case))
+        end
+        io
       end
 
       wf_load.on(:people) do |wf_people, io|
+        cases_with_people = active_cases.select do |usecase, data|
+          io.class.people_required?(usecase.type)
+        end
+        get_people = io.options.dig(:people, :get, :from) == :remote
+        next io unless !cases_with_people.empty? || get_people
         io = io.new(people:  config.people(io: io))
       end
 
       wf_load.on(:filter) do |wf_filter, io|
+        next io unless io.people && !io.people.empty?
         io = io.new(people:  config.people_filters.process(io: io))
       end
     end

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

@@ -24,7 +24,7 @@ module Eco
           end
 
           @options_set.each do |arg, callback|
-            callback.call(io.options) if SCR.get_arg(arg)
+            callback.call(io.options, io.session) if SCR.get_arg(arg)
           end
           io.options
         end

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

@@ -7,9 +7,13 @@ module Eco
 
         def initialize(core_config:)
           @core_config  = core_config
-          @linked_cases = {}
+          @linked_opt_cases = {}
         end
 
+        # Integrates a usecase to the command line
+        # @param option_case [String] the command line option to invoke the usecase
+        # @param type [Symbol] the type of usecase
+        # @param case_name [String, nil] the name of the usecase as defined
         def add(option_case, type, case_name: nil)
           Eco::API::UseCases::UseCase.validate_type(type)
           unless callback = block_given?? Proc.new : nil
@@ -17,68 +21,83 @@ module Eco
             raise "'case_name' expected to be a String. Given: #{case_name.class}" unless case_name.is_a?(String)
           end
 
-          @linked_cases[option_case] = {
+          @linked_opt_cases[option_case] = {
             type => {
               casename: case_name,
               callback: callback
             }
           }
+
           self
         end
 
-        def process(io:)
-          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
-            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
-          end
+        # Scopes/identifies which usecases are being invoked from the command line
+        # @param io [Eco::API::UseCases::BaseIO] the input/output object
+        # @return [Hash] where keys are cases and values a `Hash` with `option` String and `callback`
+        def active(io:)
+          return @active_cases unless !@active_cases
+          @active_cases = {}.tap do |opt_cases|
+            @linked_opt_cases.each do |option_case, types|
+              types.each do |type, data|
+                if SCR.get_arg(option_case)
+                  usecase = nil
+                  if case_name = data[:casename]
+                    usecase = io.session.usecases.case(case_name, type: type)
+                  end
 
-          processed = false
-          @linked_cases.each do |option, types|
-            types.each do |type, data|
-              if SCR.get_arg(option)
-                processed = true
-                io        = solve_io(io: io, type: type, option: option)
-
-                usecase = nil
-                if case_name = data[:casename]
-                  usecase = io.session.usecases.case(case_name, type: type)
-                end
+                  if callback = data[:callback]
+                    unless usecase
+                      # identify usecase
+                      usecase = callback.call(*io.params)
+                      unless usecase.is_a?(Eco::API::UseCases::UseCase)
+                        msg  = "When adding a usecase, without specifying 'case_name:', "
+                        msg += "the block that integrates usecase for cli option '#{option_case}'"
+                        msg += " must return an Eco::API::UseCases::UseCase object. It returns #{usecase.class}"
+                        raise msg
+                      end
+                    end
+                  end
 
-                if callback = data[:callback]
                   if usecase
-                    callback.call(*io.params)
-                  else
-                    usecase = callback.call(*io.params)
-                    unless usecase.is_a?(Eco::API::UseCases::UseCase)
-                      msg  = "When adding a usecase, without specifying 'case_name:', "
-                      msg += "the block that integrates usecase for cli option '#{option}'"
-                      msg += " must return an Eco::API::UseCases::UseCase object. It returns #{usecase.class}"
-                      raise msg
-                    end
+                    opt_cases[usecase] = {
+                        option:   option_case,
+                        callback: data[:callback]
+                    }
                   end
-                end
 
-                usecase.launch(io: io)
+                end
               end
             end
+
           end
-          processed
         end
 
-        private
+        def process(io:)
+          unless io && io.is_a?(Eco::API::UseCases::BaseIO)
+            raise "You need to provide Eco::API::UseCases::BaseIO object. Given: #{io.class}"
+          end
 
-        def solve_io(io:, type:, option:)
-          params = io.params(keyed: true).merge(type: type)
+          processed = false
+          active(io: io).each do |usecase, data|
+            raise "Something went wrong when scoping active cases" unless data
 
-          if (!io.people || io.people.empty?) && io.class.people_required?(type)
-            params.merge!(people: core_config.people(io: io))
-          end
+            processed = true
 
-          if (!io.input || io.input.empty?) && io.class.input_required?(type)
-            input = core_config.input.get(io: io, option: option)
-            params.merge!(input: input)
-          end
+            params    = io.params(keyed: true).merge(type: usecase.type)
+
+            #if (!io.people || io.people.empty?) && io.class.people_required?(type)
+            #  params.merge!(people: core_config.people(io: io))
+            #end
 
-          io.new(**params)
+            io.new(**params)
+
+            if callback = data[:callback]
+              callback.call(*io.params)
+            end
+
+            usecase.launch(io: io)
+          end
+          processed
         end
 
       end

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "1.1.8"
+  VERSION = "1.2.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 1.2.1
 platform: ruby
 authors:
 - Oscar Segura
@@ -216,6 +216,7 @@ files:
 - lib/eco/api.rb
 - lib/eco/api/common.rb
 - lib/eco/api/common/class_helpers.rb
+- lib/eco/api/common/class_hierarchy.rb
 - lib/eco/api/common/people.rb
 - lib/eco/api/common/people/base_parser.rb
 - lib/eco/api/common/people/default_parsers.rb
@@ -262,6 +263,7 @@ files:
 - lib/eco/api/organization/preferences.rb
 - lib/eco/api/organization/preferences_reference.json
 - lib/eco/api/organization/presets_factory.rb
+- lib/eco/api/organization/presets_reference.json
 - lib/eco/api/organization/presets_values.json
 - lib/eco/api/organization/tag_tree.rb
 - lib/eco/api/policies.rb
@@ -381,7 +383,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: eco-helpers to manage people api cases