eco-helpers 3.0.30 → 3.0.32

data/lib/eco/api/organization/people/similarity.rb

@@ -1,287 +1,289 @@
-module API
-  module Organization
-    class People
-      # Class to find out duplicates in the People Manager
-      #
-      # @attr_writer attribute [String, Proc, nil] the target attribute to be read.
-      class Similarity < Eco::API::Organization::People
-        include Eco::Data::FuzzyMatch
-
-        # @!group Config
-        # @return [String, Proc, nil] the target attribute to be read.
-        attr_writer :attribute
-
-        def attribute
-          @attribute ||= :name
-        end
+module Eco
+  module API
+    module Organization
+      class People
+        # Class to find out duplicates in the People Manager
+        #
+        # @attr_writer attribute [String, Proc, nil] the target attribute to be read.
+        class Similarity < Eco::API::Organization::People
+          include Eco::Data::FuzzyMatch
+
+          # @!group Config
+          # @return [String, Proc, nil] the target attribute to be read.
+          attr_writer :attribute
+
+          def attribute
+            @attribute ||= :name
+          end
 
-        # Returns the target value to analyse
-        # @param person [Ecoportal::API::V1::Person]
-        def item_value(item)
-          return attribute.call(item) if attribute.is_a?(Proc)
+          # Returns the target value to analyse
+          # @param person [Ecoportal::API::V1::Person]
+          def item_value(item)
+            return attribute.call(item) if attribute.is_a?(Proc)
 
-          attr = attribute.to_sym
-          item.send(attr) if item.respond_to?(attr)
-        end
+            attr = attribute.to_sym
+            item.send(attr) if item.respond_to?(attr)
+          end
 
-        # Define the order or relevant of per user matches
-        # @param values[Array<Symbol>] the algorithms' results it should
-        #   be ordered by:
-        #   * Possible values: `:dice`, `:levenshtein`, `:jaro_winkler`,
-        #     `:ngrams`, `:words_ngrams`, `:chars_position`
-        attr_writer :order
+          # Define the order or relevant of per user matches
+          # @param values[Array<Symbol>] the algorithms' results it should
+          #   be ordered by:
+          #   * Possible values: `:dice`, `:levenshtein`, `:jaro_winkler`,
+          #     `:ngrams`, `:words_ngrams`, `:chars_position`
+          attr_writer :order
 
-        def order
-          @order ||= %i[words_ngrams dice]
-        end
+          def order
+            @order ||= %i[words_ngrams dice]
+          end
 
-        # Define the order or relevant of per user matches
-        # @param value [Float] the threshold that all of the algorithms should comply with
-        attr_writer :threshold
+          # Define the order or relevant of per user matches
+          # @param value [Float] the threshold that all of the algorithms should comply with
+          attr_writer :threshold
 
-        def threshold
-          @threshold ||= 0.15
-        end
+          def threshold
+            @threshold ||= 0.15
+          end
 
-        # Generates a new object with same config but different base `data`.
-        # @return [Eco::API::Organization::People::Similarity]
-        def newFrom(data) # rubocop:disable Naming/MethodName
-          super(data).tap do |simil|
-            simil.threshold = threshold
-            simil.order     = order
-            simil.attribute = attribute
+          # Generates a new object with same config but different base `data`.
+          # @return [Eco::API::Organization::People::Similarity]
+          def newFrom(data) # rubocop:disable Naming/MethodName
+            super(data).tap do |simil|
+              simil.threshold = threshold
+              simil.order     = order
+              simil.attribute = attribute
+            end
           end
-        end
 
-        # @!endgroup
+          # @!endgroup
 
-        # @!group Searchers
+          # @!group Searchers
 
-        # It gathers those that have the same `email`
-        # @return [Hash] where `keys` are `email`s and `values` an `Array<Person>`
-        def repeated_emails
-          init_caches
-          @by_email.select do |_email, people|
-            people.count > 1
+          # It gathers those that have the same `email`
+          # @return [Hash] where `keys` are `email`s and `values` an `Array<Person>`
+          def repeated_emails
+            init_caches
+            @by_email.select do |_email, people|
+              people.count > 1
+            end
           end
-        end
 
-        # It returns all people with no name
-        # @return [Eco::API::Organization::People::Similarity]
-        def unnamed
-          select do |person|
-            person.name.to_s.strip.length < 2
-          end.then do |results|
-            newFrom(results)
+          # It returns all people with no name
+          # @return [Eco::API::Organization::People::Similarity]
+          def unnamed
+            select do |person|
+              person.name.to_s.strip.length < 2
+            end.then do |results|
+              newFrom(results)
+            end
           end
-        end
 
-        # It returns all people with no name
-        # @return [Eco::API::Organization::People::Similarity]
-        def named
-          reject do |person|
-            person.name.to_s.strip.length < 2
-          end.then do |results|
-            newFrom(results)
+          # It returns all people with no name
+          # @return [Eco::API::Organization::People::Similarity]
+          def named
+            reject do |person|
+              person.name.to_s.strip.length < 2
+            end.then do |results|
+              newFrom(results)
+            end
           end
-        end
 
-        # It returns all the entries with `attribute` empty
-        # @return [Eco::API::Organization::People::Similarity]
-        def blank_attribute
-          select do |person|
-            item_value(person).to_s.strip.length < 2
-          end.then do |results|
-            newFrom(results)
+          # It returns all the entries with `attribute` empty
+          # @return [Eco::API::Organization::People::Similarity]
+          def blank_attribute
+            select do |person|
+              item_value(person).to_s.strip.length < 2
+            end.then do |results|
+              newFrom(results)
+            end
           end
-        end
 
-        # It returns all the entries with `attribute` **n0t** empty
-        # @return [Eco::API::Organization::People::Similarity]
-        def attribute_present
-          reject do |person|
-            item_value(person).to_s.strip.length < 2
-          end.then do |results|
-            newFrom(results)
+          # It returns all the entries with `attribute` **n0t** empty
+          # @return [Eco::API::Organization::People::Similarity]
+          def attribute_present
+            reject do |person|
+              item_value(person).to_s.strip.length < 2
+            end.then do |results|
+              newFrom(results)
+            end
           end
-        end
 
-        # @!endgroup
-
-        # @!group Analisys starters
-
-        # Analyses People bases on `options`
-        # @param needle_read [Proc, Symbol] when the value to
-        #   read from `needle` object is different to the `:read` (`attribute`).
-        #   This allows to for example, facet `needle.name` (needle_read)
-        #     against `haystack_item.details[alt_id]` (read).
-        # @param keep_empty [Boolean] to indicate if it should get
-        #   rid of people with no results (based on threshold)
-        # @return [Hash] where the _keys_ are the people `id`s and
-        #   the _values_ the `Eco::Data::FuzzyMatch::Results`
-        def analyse(needle_read: nil, keep_empty: false, **options)
-          options = { read: attribute }.merge(options)
-          total   = count
-          i       = 1
-
-          each_with_object({}) do |person, results|
-            needle_str = needle_read ? item_string(person, needle_read) : nil
-            results[person.id] = find_all_with_score(person, needle_str: needle_str, **options)
-
-            print_progress('Analysed', total, i)
-            i += 1
-          end.then do |analysed|
-            analysed = clean_empty(analysed) unless keep_empty
-            #puts "... #{analysed.count} results after cleaning empty"
-            analysed
+          # @!endgroup
+
+          # @!group Analisys starters
+
+          # Analyses People bases on `options`
+          # @param needle_read [Proc, Symbol] when the value to
+          #   read from `needle` object is different to the `:read` (`attribute`).
+          #   This allows to for example, facet `needle.name` (needle_read)
+          #     against `haystack_item.details[alt_id]` (read).
+          # @param keep_empty [Boolean] to indicate if it should get
+          #   rid of people with no results (based on threshold)
+          # @return [Hash] where the _keys_ are the people `id`s and
+          #   the _values_ the `Eco::Data::FuzzyMatch::Results`
+          def analyse(needle_read: nil, keep_empty: false, **options)
+            options = { read: attribute }.merge(options)
+            total   = count
+            i       = 1
+
+            each_with_object({}) do |person, results|
+              needle_str = needle_read ? item_string(person, needle_read) : nil
+              results[person.id] = find_all_with_score(person, needle_str: needle_str, **options)
+
+              print_progress('Analysed', total, i)
+              i += 1
+            end.then do |analysed|
+              analysed = clean_empty(analysed) unless keep_empty
+              #puts "... #{analysed.count} results after cleaning empty"
+              analysed
+            end
           end
-        end
 
-        # @!endgroup
+          # @!endgroup
 
-        # @!group Results Treatment
+          # @!group Results Treatment
 
-        # Gets a new instance object of this class, with only people in results
-        # @param analysed [Hash] where the _keys_ are the people `id`s and _values_ the `Eco::Data::FuzzyMatch::Results`
-        # @return [Eco::API::Organization::People::Similarity]
-        def newSimilarity(analysed) # rubocop:disable Naming/MethodName
-          newFrom(people_in_results(analysed))
-        end
+          # Gets a new instance object of this class, with only people in results
+          # @param analysed [Hash] where the _keys_ are the people `id`s and _values_ the `Eco::Data::FuzzyMatch::Results`
+          # @return [Eco::API::Organization::People::Similarity]
+          def newSimilarity(analysed) # rubocop:disable Naming/MethodName
+            newFrom(people_in_results(analysed))
+          end
 
-        def people_in_results(analysed)
-          analysed.each_with_object([]) do |(id, results), people|
-            # spot related
-            results.each_with_object([self[id]]) do |result, related|
-              related << result.match
-            end.each do |person|
-              next if people.include?(person)
+          def people_in_results(analysed)
+            analysed.each_with_object([]) do |(id, results), people|
+              # spot related
+              results.each_with_object([self[id]]) do |result, related|
+                related << result.match
+              end.each do |person|
+                next if people.include?(person)
 
-              people << person
+                people << person
+              end
             end
           end
-        end
 
-        # Removes from results those that do not have similar entries
-        def clean_empty(analysed)
-          analysed.reject do |_id, results|
-            results.empty?
+          # Removes from results those that do not have similar entries
+          def clean_empty(analysed)
+            analysed.reject do |_id, results|
+              results.empty?
+            end
           end
-        end
 
-        # Helper to do some treatment fo the results
-        # @param analysed [Hash] where the _keys_ are the people `id`s and _values_ the `Eco::Data::FuzzyMatch::Results`
-        # @return [Hash] where the _keys_ are the people `id`s and _values_ the `Eco::Data::FuzzyMatch::Results`
-        def with_analysed(analysed, keep_empty: false)
-          analysed.each_with_object({}) do |(id, results), reanalysed|
-            reanalysed[id] = yield(self[id], results)
-          end.then do |reanalysed|
-            reanalysed = clean_empty(reanalysed) unless keep_empty
-            reanalysed
-          end.tap do |out|
-            puts "with_analysed... returns #{out.count} records"
+          # Helper to do some treatment fo the results
+          # @param analysed [Hash] where the _keys_ are the people `id`s and _values_ the `Eco::Data::FuzzyMatch::Results`
+          # @return [Hash] where the _keys_ are the people `id`s and _values_ the `Eco::Data::FuzzyMatch::Results`
+          def with_analysed(analysed, keep_empty: false)
+            analysed.each_with_object({}) do |(id, results), reanalysed|
+              reanalysed[id] = yield(self[id], results)
+            end.then do |reanalysed|
+              reanalysed = clean_empty(reanalysed) unless keep_empty
+              reanalysed
+            end.tap do |out|
+              puts "with_analysed... returns #{out.count} records"
+            end
           end
-        end
 
-        # Launches a reanalyis on `analysed` based on `options`
-        # @param analysed [Hash] where the _keys_ are the people `id`s and the _values_ the `Eco::Data::FuzzyMatch::Results`
-        def rearrange(analysed, **options)
-          with_analysed(analysed) do |person, results|
-            results.relevant_results(**options)
+          # Launches a reanalyis on `analysed` based on `options`
+          # @param analysed [Hash] where the _keys_ are the people `id`s and the _values_ the `Eco::Data::FuzzyMatch::Results`
+          def rearrange(analysed, **options)
+            with_analysed(analysed) do |person, results|
+              results.relevant_results(**options)
+            end
           end
-        end
 
-        # Reanalyses by using a block to treat the needle and item values
-        def reanalyse(analysed, msg: 'Reanalysing', **options, &block)
-          options = { read: attribute }.merge(options)
-          total   = analysed.count
-          i       = 1
+          # Reanalyses by using a block to treat the needle and item values
+          def reanalyse(analysed, msg: 'Reanalysing', **options, &block)
+            options = { read: attribute }.merge(options)
+            total   = analysed.count
+            i       = 1
 
-          with_analysed(analysed) do |_person, results|
-            print_progress(msg, total, i)
-            i += 1
-            recalculate_results(results, &block)
+            with_analysed(analysed) do |_person, results|
+              print_progress(msg, total, i)
+              i += 1
+              recalculate_results(results, &block)
+            end
           end
-        end
 
-        # Renalyses by ignoring matching words between the `needle` and those found in `results`
-        def ignore_matching_words(analysed, **options)
-          prompt = 'Reanalysing by ignoring matching words'
+          # Renalyses by ignoring matching words between the `needle` and those found in `results`
+          def ignore_matching_words(analysed, **options)
+            prompt = 'Reanalysing by ignoring matching words'
 
-          reanalyse(analysed, msg: prompt, **options) do |needle_str, item_str, _needle, _item|
-            self.class.remove_matching_words(needle_str, item_str)
+            reanalyse(analysed, msg: prompt, **options) do |needle_str, item_str, _needle, _item|
+              self.class.remove_matching_words(needle_str, item_str)
+            end
           end
-        end
 
-        # Renalyses by ignoring matching words between the `needle` and those found in `results`
-        def ignore_matching_words_old(analysed, **options)
-          options = { read: attribute }.merge(options)
-          total   = analysed.count
-          i       = 1
+          # Renalyses by ignoring matching words between the `needle` and those found in `results`
+          def ignore_matching_words_old(analysed, **options)
+            options = { read: attribute }.merge(options)
+            total   = analysed.count
+            i       = 1
 
-          with_analysed(analysed) do |person, results|
-            print_progress('Reanalysing by ignoring matching words', total, i)
-            i += 1
-            ignore_same_words_score(results, **options)
+            with_analysed(analysed) do |person, results|
+              print_progress('Reanalysing by ignoring matching words', total, i)
+              i += 1
+              ignore_same_words_score(results, **options)
+            end
           end
-        end
 
-        # @!endgroup
+          # @!endgroup
 
-        # @!group Reporting Helpers
+          # @!group Reporting Helpers
 
-        # @return [String] well structured text
-        def report(analysed, format: :txt)
-          case format
-          when :txt
-            analysed.each_with_object('') do |(id, results), out|
-              out << "#{self[id].identify}:\n  "
-              out << results.results.map(&:print).join("\n  ")
-              out << "\n"
+          # @return [String] well structured text
+          def report(analysed, format: :txt)
+            case format
+            when :txt
+              analysed.each_with_object('') do |(id, results), out|
+                out << "#{self[id].identify}:\n  "
+                out << results.results.map(&:print).join("\n  ")
+                out << "\n"
+              end
             end
           end
-        end
 
-        # @note
-        #   1. Unless `:analysed` is provided, it launches an analysis cutting with Jaro Winker min 0.5
-        #   2. It then re-sorts and cuts based on `options`
-        # @return [Hash] where the _keys_ are the people `id`s and the _values_ the `Eco::Data::FuzzyMatch::Results`
-        def print_analysis(**options)
-          analysed   = options[:analysed]
-          analysed ||= results_with_false_positives.analyse(**options)
+          # @note
+          #   1. Unless `:analysed` is provided, it launches an analysis cutting with Jaro Winker min 0.5
+          #   2. It then re-sorts and cuts based on `options`
+          # @return [Hash] where the _keys_ are the people `id`s and the _values_ the `Eco::Data::FuzzyMatch::Results`
+          def print_analysis(**options)
+            analysed   = options[:analysed]
+            analysed ||= results_with_false_positives.analyse(**options)
 
-          analysed.each_with_object({}) do |(id, results), out|
-            puts report(analysed)
+            analysed.each_with_object({}) do |(id, results), out|
+              puts report(analysed)
+            end
           end
-        end
-        # @!endgroup
+          # @!endgroup
 
-        protected
+          protected
 
-        def on_change
-          remove_instance_variable(@fuzzy_match)
-          super
-        end
+          def on_change
+            remove_instance_variable(@fuzzy_match)
+            super
+          end
 
-        private
+          private
 
-        def print_progress(msg, total, num)
-          return  unless total > 10
-          puts '' unless num > 1
+          def print_progress(msg, total, num)
+            return  unless total > 10
+            puts '' unless num > 1
 
-          @print_msg_len ||= 0
-          percent = (100 * num.to_f / total).round(1)
-          msg     = "  #{msg}: #{percent}% (#{num} of #{total})\r"
-          @print_msg_len = msg.length unless @print_msg_len > msg.length
+            @print_msg_len ||= 0
+            percent = (100 * num.to_f / total).round(1)
+            msg     = "  #{msg}: #{percent}% (#{num} of #{total})\r"
+            @print_msg_len = msg.length unless @print_msg_len > msg.length
 
-          print msg
-          $stdout.flush
+            print msg
+            $stdout.flush
 
-          return unless percent > 99.9
+            return unless percent > 99.9
 
-          sleep(0.2)
-          print "#{' ' * @print_msg_len}\r"
-          $stdout.flush
-          nil
+            sleep(0.2)
+            print "#{' ' * @print_msg_len}\r"
+            $stdout.flush
+            nil
+          end
         end
       end
     end

data/lib/eco/api/organization/people.rb

@@ -127,6 +127,7 @@ module Eco
           id          = attr_value(object, 'id')
           external_id = attr_value(object, 'external_id')
           email       = attr_value(object, 'email')
+
           person(id: id, external_id: external_id, email: email, strict: strict)
         end
         # @!endgroup

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

@@ -506,6 +506,7 @@ module Eco
             dir       = config.people.requests_folder
             filename  = name.split(' ').join('-').gsub(/[=\\\/><,"-]+/, '_') # rubocop:disable Style/RedundantArgument
             file      = File.join(dir, "#{type}_data_#{filename}#{dry_run}.json")
+
             file_manager.save_json(requests, file, :timestamp)
           end
 

data/lib/eco/api/usecases/cli/dsl.rb

@@ -5,7 +5,6 @@ module Eco
         module DSL
           # Links the usecase to the Cli via `arg_case`
           def apply!(arg_case = cli_name)
-
             # puts "Debug: (#{self}) Tried to call again cli.apply! on '#{arg_case}'"
             return self if applied?(arg_case)
 

data/lib/eco/api/usecases/cli/option.rb

@@ -10,7 +10,7 @@ class Eco::API::UseCases::Cli
     end
 
     def dup(name: self.name, desc: self.desc, &block)
-      self.class.new(name, desc, &(block || callback))
+      self.class.new(name, desc, &(block || callback)) # rubocop:disable Style/RedundantParentheses
     end
 
     def link_case(cli_config_case)

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

@@ -1,10 +1,10 @@
 class Eco::API::UseCases::DefaultCases::CreateCase < Eco::API::Common::Loaders::UseCase
-  name "create"
+  name 'create'
   type :sync
 
   def main(entries, people, session, options, usecase)
-    creation = session.new_job("main", "create",  :create, usecase)
-    supers   = session.new_job("post", "supers",  :update, usecase, :core)
+    creation = session.new_job('main', 'create',  :create, usecase)
+    supers   = session.new_job('post', 'supers',  :update, usecase, :core)
 
     micro.with_each_starter(entries, people, options, log_present: true, append_created: append_created) do |entry, person|
       creation.add(person)

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

@@ -1,8 +1,8 @@
 class Eco::API::UseCases::DefaultCases::DeleteSyncCase < Eco::API::UseCases::DefaultCases::DeleteTransCase
-  name "delete"
+  name 'delete'
   type :sync
 
-  def main(entries, people, session, options, usecase)
+  def main(entries, *_args)
     found = micro.with_each_present(entries, people, options, log_starter: true)
     delete(found)
   end

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

@@ -1,13 +1,13 @@
 class Eco::API::UseCases::DefaultCases::DeleteTransCase < Eco::API::Common::Loaders::UseCase
-  name "delete"
+  name 'delete'
   type :transform
 
   def delete(people)
-    delete   = session.new_job("main", "delete", :delete, usecase)
+    delete = session.new_job('main', 'delete', :delete, usecase)
     people.each {|person| delete.add(person)}
   end
 
-  def main(people, session, options, usecase)
+  def main(*_args)
     delete(people)
   end
 end

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

@@ -1,5 +1,5 @@
 class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::UseCase
-  name "hris"
+  name 'hris'
   type :sync
 
   attr_reader :creation, :update, :supers, :leavers
@@ -7,10 +7,10 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
   def main(entries, people, session, options, usecase)
     require_only_one_schema!
     micro     = session.micro
-    @leavers  = session.new_job("pre", "leavers",  :update, usecase, :account)
-    @creation = session.new_job("main", "create",  :create, usecase)
-    @update   = session.new_job("main", "update",  :update, usecase)
-    @supers   = session.new_job("post", "supers",  :update, usecase, :core)
+    @leavers  = session.new_job('pre', 'leavers', :update, usecase, :account)
+    @creation = session.new_job('main', 'create', :create, usecase)
+    @update   = session.new_job('main', 'update', :update, usecase)
+    @supers   = session.new_job('post', 'supers', :update, usecase, :core)
 
     micro.with_each_leaver(entries, people, options) do |person|
       leavers.add(person, &method(:leavers_callback))
@@ -18,6 +18,7 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
 
     micro.with_each(entries, people, options, append_created: append_created) do |entry, person|
       person.new? ? creation.add(person) : update.add(person)
+
       micro.set_core_with_supervisor(entry, person, people, supers, options)
       entry.set_details(person) unless options.dig(:exclude, :details)
       micro.set_account(entry, person, options)
@@ -45,10 +46,10 @@ class Eco::API::UseCases::DefaultCases::HrisCase < Eco::API::Common::Loaders::Us
 
     msg  = "There are #{other_people.length} people in schemas other than #{active_schema.name}."
     msg << " Please, use the filter option '-schema-id SchemaName' for the 'hris' case"
-    msg << " to only include those of that schema in the current update."
-    msg << " The HRIS case identifies people that are not in the file as leavers"
-    msg << " (as it will remove the account of all the people of other schemas"
-    msg << " if they are not in the input file)."
+    msg << ' to only include those of that schema in the current update.'
+    msg << ' The HRIS case identifies people that are not in the file as leavers'
+    msg << ' (as it will remove the account of all the people of other schemas'
+    msg << ' if they are not in the input file).'
     msg << "\n For example: -schema-id '#{active_schema.name.downcase}'"
     log(:error) { msg }
     raise msg