eco-helpers 2.0.26 → 2.0.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 722e1dc695f9d9fae5fbceca8a2269f4836393ee4dc50fc0f850e43fefc88789
-  data.tar.gz: bc34444cdf33bff51895fa5ed6bb7a89b89074e5bd11852c0a1a4f4bf6bcc574
+  metadata.gz: 144eb5a5b4c0069c07c1af3bac6c23c43b975643f45b8b7d8e5edd05daa8defd
+  data.tar.gz: 6f2c5e8f1744380cb543d11087b3d5bbab822697e876c21c8a4ca1984ea5f3a9
 SHA512:
-  metadata.gz: 9a18aaa7abf012872f21209907909f1c309ddb530586bc9e27d595ace57377c3c4dba2b0a7bacc902e160cf2f51d4171a5de3e0536b6eda4dff7d018307744ca
-  data.tar.gz: efcaa1832677c0cf13d5dfb0ba6a3abaa8bff3fec4e1d2639b2b832358a1e51b849e594da64827bed096eb4f8f03a5664a6a8245c58128acf3478eaf0e94d38a
+  metadata.gz: 8bb382dbc126f15308cdd51f3ec8d520a154450080388e329243102e0fa2c4d9dcbba395ec91f59ea645ea734f222a5af8fe25a1000a39b2474aba2c89a725dd
+  data.tar.gz: 11874a475a744e673e8741777079d54081c0b6be855a609cf7ed6e8a032f29c6e074cefe7e8a94d57944d70be4b8bebbcb5d6a7ff81e25d6e2798ce4259779b1

data/CHANGELOG.md

@@ -1,7 +1,25 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.0.26] - 2021-06-xx
+## [2.0.27] - 2021-06-xx
+
+### Added
+
+### Changed
+  -  Parent class `Eco::API::UseCases::DefaultCases::ToCsvCase` shouldn't know header maps necessary for `Eco::API::UseCases::DefaultCases::ToCsvDetailedCase`
+    * Moved related header maps to `ToCsvDetailedCase`
+
+### Fixed
+  - `--help` should work fine now
+  - Attribute parsers that depended on indirect parser attributes were **not** included
+    - **changed** a couple of classes
+      - `Eco::API::Common::People::PersonEntryAttributeMapper`, where methods should receive `data` to re-scope if the data is available (most specifically `#internal_attrs`)
+      - `Eco::API::Common::People::PersonEntry`, where when setting the final values on `Person`, it should include any internal attribute that is present in the `final_entry` (the result of all the parsing process)
+  - `Eco::API::Common::People::DefaultParsers::CSVParser`
+    - indirect attributes that depended on other indirect attributes would show as missing even if they were active
+      - i.e. `name` depends on `first-name` & `surname`, **AND** `details-name` depends on `name`
+
+## [2.0.26] - 2021-06-25
 
 ### Added
   - `Eco::API::MicroCases#set_supervisor`, tries to keep in sync the `#subordinates` **count** of previous and new supervisor

data/lib/eco/api/common/people/default_parsers/csv_parser.rb

@@ -70,20 +70,14 @@ class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Lo
   end
 
   def missing_headers(headers)
-    hint = headers & all_internal_attrs
-    hext = headers - hint
-    int_head = hint + hext.map {|e| fields_mapper.to_internal(e)}.compact
-    known_as_int = known_headers.select do |e|
-      i = fields_mapper.to_internal(e)
-      int_head.include?(i)
-    end
+    int_head = internal_present_or_active(headers)
     ext  = headers.select do |e|
       i = fields_mapper.to_internal(e)
       int_head.include?(i)
     end
-    ext_present = known_as_int | ext
+    ext_present = known_headers_present(int_head) | ext
     ext_miss    = known_headers - ext_present
-    #int_miss  = ext_miss.map {|ext| fields_mapper.to_internal(ext)}
+
     ext_miss.each_with_object({}) do |ext, missing|
       next unless int = fields_mapper.to_internal(ext)
       if all_internal_attrs.include?(int)
@@ -91,7 +85,10 @@ class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Lo
         missing[:direct] << ext
       end
       related_attrs_requirements = required_attrs.values.select do |req|
-        req.dependant?(int) && !int_head.include?(req.attr)
+        dep       = req.dependant?(int)
+        affects   = dep && !int_head.include?(int)
+        in_header = int_head.include?(req.attr)
+        affects || (dep && !in_header)
       end
       next if related_attrs_requirements.empty?
       missing[:indirect] ||= {}
@@ -106,6 +103,41 @@ class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Lo
     end
   end
 
+  def known_headers_present(headers_internal)
+    @known_internal ||= known_headers.select do |ext|
+      int = fields_mapper.to_internal(ext)
+      headers_internal.include?(int)
+    end
+  end
+
+  def internal_present_or_active(headers, inactive_requirements = {})
+    hint = headers & all_internal_attrs
+    hext = headers - hint
+    int_present = hint + hext.map {|e| fields_mapper.to_internal(e)}.compact
+
+    update_inactive = Proc.new do
+      inactive_requirements.dup.each do |attr, req|
+        if req.active?(*int_present)
+          inactive_requirements.delete(attr)
+          int_present << attr
+          update_inactive.call
+        end
+      end
+    end
+
+    required_attrs.values.each do |req|
+      next if int_present.include?(req)
+      if req.active?(*int_present)
+        inactive_requirements.delete(req.attr)
+        int_present << req.attr
+        update_inactive.call
+      else
+        inactive_requirements[req.attr] = req
+      end
+    end
+    int_present
+  end
+
   def known_headers
     @known_headers ||= fields_mapper.list(:external).compact
   end
@@ -121,7 +153,11 @@ class Eco::API::Common::People::DefaultParsers::CSVParser < Eco::API::Common::Lo
   end
 
   def all_internal_attrs
-    person_parser.all_attrs(include_defined_parsers: true)
+    @all_internal_attrs ||= [].tap do |int_attrs|
+      known_int_attrs  = person_parser.all_attrs(include_defined_parsers: true)
+      known_int_attrs |= fields_mapper.list(:internal).compact
+      int_attrs.concat(known_int_attrs)
+    end
   end
 
   def person_parser

data/lib/eco/api/common/people/person_entry.rb

@@ -188,7 +188,7 @@ module Eco
           # @param person [Ecoportal::API::V1::Person] the person we want to set the core values to.
           # @param exclude [String, Array<String>] core attributes that should not be set/changed to the person.
           def set_core(person, exclude: nil)
-            scoped_attrs = @emap.core_attrs - into_a(exclude)
+            scoped_attrs = @emap.core_attrs(@final_entry) - into_a(exclude)
             @final_entry.slice(*scoped_attrs).each do |attr, value|
               begin
                 set_part(person, attr, value)
@@ -210,7 +210,7 @@ module Eco
           # @param exclude [String, Array<String>] account properties that should not be set/changed to the person.
           def set_account(person, exclude: nil)
             person.account = {} if !person.account
-            scoped_attrs = @emap.account_attrs - into_a(exclude)
+            scoped_attrs = @emap.account_attrs(@final_entry) - into_a(exclude)
             @final_entry.slice(*scoped_attrs).each do |attr, value|
               set_part(person.account, attr, value)
             end
@@ -224,7 +224,7 @@ module Eco
           # @param exclude [String, Array<String>] schema field attributes that should not be set/changed to the person.
           def set_details(person, exclude: nil)
             person.add_details(@person_parser.schema) if !person.details || !person.details.schema_id
-            scoped_attrs = @emap.details_attrs - into_a(exclude)
+            scoped_attrs = @emap.details_attrs(@final_entry) - into_a(exclude)
             @final_entry.slice(*scoped_attrs).each do |attr, value|
               set_part(person.details, attr, value)
             end
@@ -326,12 +326,13 @@ module Eco
           # @param internal_entry [Hash] the entry with the **internal** _attribute_ names and values but the **external** types.
           # @return [Hash] the `parsed entry` with the **internal** final attributes names, values and types.
           def _final_parsing(internal_entry)
-            core_account      = @emap.account_attrs + @emap.core_attrs
-            core_account_hash = internal_entry.slice(*core_account).each_with_object({}) do |(attr, value), hash|
+            core_account_attrs = @emap.account_attrs(internal_entry) + @emap.core_attrs(internal_entry)
+            core_account_hash  = internal_entry.slice(*core_account_attrs).each_with_object({}) do |(attr, value), hash|
               hash[attr]  = _parse_type(attr, value)
             end
 
-            details_hash      = internal_entry.slice(*@emap.details_attrs).each_with_object({}) do |(attr, value), hash|
+            details_attrs     = @emap.details_attrs(internal_entry)
+            details_hash      = internal_entry.slice(*details_attrs).each_with_object({}) do |(attr, value), hash|
               hash[attr] = _parse_type(attr, value, schema: @person_parser.schema)
             end
 

data/lib/eco/api/common/people/person_entry_attribute_mapper.rb

@@ -3,18 +3,11 @@ module Eco
     module Common
       module People
 
-        # @attr_reader core_attrs [Array<String>] core attributes that are present in the person entry.
-        # @attr_reader details_attrs [Array<String>] schema details attributes that are present in the person entry.
-        # @attr_reader account_attrs [Array<String>] account attributes that are present in the person entry.
-        # @attr_reader all_model_attrs [Array<String>] all the attrs that are present in the person entry.
-        # @attr_reader internal_attrs [Array<String>] all the internally named attributes that the person entry has.
-        # @attr_reader aliased_attrs [Array<String>] only those internal attributes present in the person entry that have an internal/external name mapping.
         # @attr_reader direct_attrs [Array<String>] only those internal attributes present in the person entry that do **not** have an internal/external name mapping.
         class PersonEntryAttributeMapper
           @@cached_warnings = {}
 
-          attr_reader :core_attrs, :details_attrs, :account_attrs, :all_model_attrs
-          attr_reader :internal_attrs, :aliased_attrs, :direct_attrs
+          attr_reader :aliased_attrs, :direct_attrs
 
           # Helper class tied to `PersonEntry` that allows to track which attributes of a person entry are present
           # and how they should be mapped between internal and external names if applicable.
@@ -38,17 +31,64 @@ module Eco
 
             if parsing?
               @external_entry   = data
-              init_attr_trackers
             else  # SERIALIZING
               @person          = data
-              @internal_attrs  = @person_parser.all_model_attrs
-              @aliased_attrs   = @attr_map.list(:internal)
             end
+          end
 
-            @core_attrs    = @person_parser.target_attrs_core(@internal_attrs)
-            @details_attrs = @person_parser.target_attrs_details(@internal_attrs)
-            @account_attrs = @person_parser.target_attrs_account(@internal_attrs)
-            @all_model_attrs = @core_attrs | @account_attrs | @details_attrs
+          # @return [Array<String>] only those internal attributes present in the person entry that have an internal/external name mapping.
+          def aliased_attrs
+            return @aliased_attrs unless !@aliased_attrs
+            if parsing?
+              init_attr_trackers
+            else
+              @aliased_attrs = @attr_map.list(:internal)
+            end
+            @aliased_attrs
+          end
+
+          # @return [Array<String>] all the internally named attributes that the person entry has.
+          def internal_attrs(data = nil)
+            return @internal_attrs unless data || !@internal_attrs
+            if parsing?
+              init_attr_trackers unless @internal_attrs
+              if data
+                return data.keys & @person_parser.all_model_attrs
+              end
+            else
+              @internal_attrs = @person_parser.all_model_attrs
+            end
+            @internal_attrs
+          end
+
+
+          # @return [Array<String>] all the attrs that are present in the person entry.
+          def all_model_attrs(data = nil)
+            core_attrs(data) | account_attrs(data) | details_attrs(data)
+          end
+
+          # @return [Array<String>] core attributes that are present in the person entry.
+          def core_attrs(data = nil)
+            return @core_attrs unless data || !@core_attrs
+            @person_parser.target_attrs_core(internal_attrs(data)).tap do |core_attrs|
+              @core_attrs ||= core_attrs
+            end
+          end
+
+          # @return [Array<String>] schema details attributes that are present in the person entry.
+          def details_attrs(data = nil)
+            return @details_attrs unless data || !@core_attrs
+            @person_parser.target_attrs_details(internal_attrs(data)).tap do |details_attrs|
+              @details_attrs ||= details_attrs
+            end
+          end
+
+          # @return [Array<String>] account attributes that are present in the person entry.
+          def account_attrs(data = nil)
+            return @account_attrs unless data || !@account_attrs
+            @person_parser.target_attrs_account(internal_attrs(data)).tap do |account_attrs|
+              @account_attrs ||= account_attrs
+            end
           end
 
           # To know if currently the object is in parse or serialize mode.
@@ -151,7 +191,6 @@ module Eco
             def_unlinked      = @person_parser.undefined_model_attrs.select { |attr| !to_external(attr) }
             # (def) those with parser or alias:
             def_linked        = def_all_attrs - def_unlinked
-
             # (data) data attributes (actual attributes of the entry)
             data_attrs        = attributes(@external_entry)
             # (data) attributes of the data that come directly as internal attribute names

data/lib/eco/api/usecases/default_cases/to_csv_case.rb

@@ -125,43 +125,7 @@ class Eco::API::UseCases::DefaultCases::ToCsvCase < Eco::API::Common::Loaders::U
       "id"                 => "ecoPortal ID",
       "external_id"        => "Reference ID (ext_id)",
       "login_provider_ids" => "Login Methods",
-      "landing_page_id"    => "Landing Page ID",
-      "show_sidebar"       => "(pref) Sidebar Open?",
-      "show_shortcuts"     => "(pref) Link to Registers?",
-      "show_coming_soon"   => "(pref) Coming Soon List?",
-      "show_recently_visited_forms" => "(pref) Recently Visited Forms List?",
-      "show_tasks"         => "(pref) Tasks List?",
-      "show_task_bubbles"  => "(pref) Task Count Bubbles",
-      "kiosk_enabled"      => "Kiosk User?",
-      "freemium"           => "Freemium User?",
-      "files"              => "(able) on Files",
-      "reports"            => "(able) on Report Structures",
-      "data"               => "(able) on Data (hours, datasets)",
-      "organization"       => "(able) on Organization Config",
-      "pages"              => "(able) on Page/Entries",
-      "page_editor"        => "(able) page Editor Level",
-      "registers"          => "(able) on Registers",
-      "tasks"              => "(able) on Tasks",
-      "person_core"        => "(able) on People",
-      "person_core_create" => "(able) Create People?",
-      "person_core_edit"   => "(able) Edit People?",
-      "person_details"     => "(able) on People Schema Details",
-      "person_account"     => "(able) on Users",
-      "person_abilities"   => "(able) on Users' Abilities",
-      "custom_files"              => "(min) on Files",
-      "custom_reports"            => "(min) on Report Structures",
-      "custom_data"               => "(min) on Data (hours, datasets)",
-      "custom_organization"       => "(min) on Organization Config",
-      "custom_pages"              => "(min) on Page/Entries",
-      "custom_page_editor"        => "(min) page Editor Level",
-      "custom_registers"          => "(min) on Registers",
-      "custom_tasks"              => "(min) on Tasks",
-      "custom_person_core"        => "(min) on People",
-      "custom_person_core_create" => "(min) Create People?",
-      "custom_person_core_edit"   => "(min) Edit People?",
-      "custom_person_details"     => "(min) on People Schema Details",
-      "custom_person_account"     => "(min) on Users",
-      "custom_person_abilities"   => "(min) on Users' Abilities"
+      "landing_page_id"    => "Landing Page ID"
     }
   end
 

data/lib/eco/api/usecases/default_cases/to_csv_detailed_case.rb

@@ -75,4 +75,46 @@ class Eco::API::UseCases::DefaultCases::ToCsvDetailedCase < Eco::API::UseCases::
     ]
   end
 
+  def nice_header_maps
+    @nice_header_maps ||= super.merge({
+      "landing_page_id"    => "Landing Page ID",
+      "show_sidebar"       => "(pref) Sidebar Open?",
+      "show_shortcuts"     => "(pref) Link to Registers?",
+      "show_coming_soon"   => "(pref) Coming Soon List?",
+      "show_recently_visited_forms" => "(pref) Recently Visited Forms List?",
+      "show_tasks"         => "(pref) Tasks List?",
+      "show_task_bubbles"  => "(pref) Task Count Bubbles",
+      "kiosk_enabled"      => "Kiosk User?",
+      "freemium"           => "Freemium User?",
+      "files"              => "(able) on Files",
+      "reports"            => "(able) on Report Structures",
+      "data"               => "(able) on Data (hours, datasets)",
+      "organization"       => "(able) on Organization Config",
+      "pages"              => "(able) on Page/Entries",
+      "page_editor"        => "(able) page Editor Level",
+      "registers"          => "(able) on Registers",
+      "tasks"              => "(able) on Tasks",
+      "person_core"        => "(able) on People",
+      "person_core_create" => "(able) Create People?",
+      "person_core_edit"   => "(able) Edit People?",
+      "person_details"     => "(able) on People Schema Details",
+      "person_account"     => "(able) on Users",
+      "person_abilities"   => "(able) on Users' Abilities",
+      "custom_files"              => "(min) on Files",
+      "custom_reports"            => "(min) on Report Structures",
+      "custom_data"               => "(min) on Data (hours, datasets)",
+      "custom_organization"       => "(min) on Organization Config",
+      "custom_pages"              => "(min) on Page/Entries",
+      "custom_page_editor"        => "(min) page Editor Level",
+      "custom_registers"          => "(min) on Registers",
+      "custom_tasks"              => "(min) on Tasks",
+      "custom_person_core"        => "(min) on People",
+      "custom_person_core_create" => "(min) Create People?",
+      "custom_person_core_edit"   => "(min) Edit People?",
+      "custom_person_details"     => "(min) on People Schema Details",
+      "custom_person_account"     => "(min) on Users",
+      "custom_person_abilities"   => "(min) on Users' Abilities"
+    })
+  end
+
 end

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

@@ -2,7 +2,12 @@ ASSETS.cli.config do |cnf|
   cnf.options_set do |options_set, options|
     options_set.add("--help", "Offers a HELP") do |options, sesssion|
       conf   = ASSETS.cli.config
-      active = Proc.new {|opt| SCR.get_arg(opt) && SCR.get_arg(opt, with_param: true)}
+      active = Proc.new do |opt|
+        if there = SCR.get_arg(opt)
+          refine = SCR.get_arg(opt, with_param: true)
+        end
+        refine || there
+      end
 
       if hpf = active.call("-filters")
         puts conf.people_filters.help(refine: hpf)

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

@@ -18,7 +18,7 @@ module Eco
           [msg].yield_self do |lines|
             max_len = keys_max_len(@filters.keys)
             @filters.keys.sort.select do |key|
-              refine.is_a?(String) && key.include?(refine)
+              !refine.is_a?(String) || key.include?(refine)
             end.each do |key|
               lines << help_line(key, @description[key], max_len)
             end

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

@@ -25,7 +25,7 @@ module Eco
               str_indent = is_general ? "" : " " * indent
               lines << help_line(namespace, "", max_len) unless is_general
               options_set(namespace).select do |arg, option|
-                refine.is_a?(String) && option.name.include?(refine)
+                !refine.is_a?(String) || option.name.include?(refine)
               end.each do |arg, option|
                 lines << help_line(" " * indent + "#{option.name}", option.description, max_len)
               end

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

@@ -34,7 +34,7 @@ module Eco
           ["The following are the available use cases#{refinement}:"].yield_self do |lines|
             max_len = keys_max_len(@linked_cases.keys)
             @linked_cases.keys.sort.select do |key|
-              refine.is_a?(String) && key.include?(refine)
+              !refine.is_a?(String) || key.include?(refine)
             end.each do |option_case|
               lines << help_line(option_case, @linked_cases[option_case].description, max_len)
             end

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "2.0.26"
+  VERSION = "2.0.27"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.0.26
+  version: 2.0.27
 platform: ruby
 authors:
 - Oscar Segura