supervisor_helpers.rb in eco-helpers-2.7.0

- old
+ new

@@ -16,33 +16,35 @@
             #   1. supervisors, people with no supervisor or where their supervisor not present
             #   2. subordinates
             # @return [Array<PersonEntry>] `values` sorted by supervisors/subordinates
             def sort_by_supervisors(values, supervisors_first: true)
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
-              return [] unless values && values.is_a?(Enumerable)
-              roam = Proc.new do |tree|
+              return [] unless values.is_a?(Enumerable)
+              roam = proc do |tree|
                 [].tap do |out|
                   sub_outs = tree.empty?? [] : tree.map {|sup, subtree| roam.call(subtree)}
+
                   tree.each do |sup, subtree|
-                    sout = subtree.empty?? [] :roam.call(subtree)
+                    sout = subtree.empty?? [] : roam.call(subtree)
                     supervisors_first ? sout.unshift(sup) : sout.push(sup)
                     out.concat(sout)
                   end
                 end
               end
 
               roam.call(supervisors_tree(values))
             end
 
             # Identifies all the cyclic supervisor chains
-            # @note as `supervisors_tree` will have any entry involved in a cycle at the top, it just checks all the top entries against their offspring
+            # @note as `supervisors_tree` will have any entry involved in a cycle at the top,
+            #   it just checks all the top entries against their offspring
             # @return [Array<Array>] the sets of entries that are cyclic
             def identify_cyclic_chains(values)
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
-              return [] unless values && values.is_a?(Enumerable)
+              return [] unless values.is_a?(Enumerable)
 
-              identify  = Proc.new do |top_sup, offspring, chain = [top_sup]|
+              identify  = proc do |top_sup, offspring, chain = [top_sup]|
                 next [] if offspring.empty?
                 offspring.each_with_object([]) do |(sup, subordinates), set|
                   break set unless set.empty?
                   if top_sup.supervisor_id == sup.id
                     set.concat(chain, [sup])
@@ -78,19 +80,19 @@
             #   * **values** are `Hash` subtree structures of `key` subordinates
             # @note it is resilient to cyclic supervisors (it will just add the last at the top)
             # @param values [Enumerable<Object>] of objects with methods:
             #  `id`, `external_id` and `supervisor_id`
             # @return [Hash] the tree structure
-            def supervisors_tree(values)
+            def supervisors_tree(values) # rubocop:disable Metrics/AbcSize
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
-              return {} unless values && values.is_a?(Enumerable)
+              return {} unless values.is_a?(Enumerable)
               idx = get_super_indexes(values)
 
               processed = []
-              subtree = Proc.new do |entry, level, toptree|
+              subtree = proc do |entry, level, toptree|
                 if processed.include?(entry)
-                  next {} unless toptree.key?(entry) && level > 0
+                  next {} unless toptree.key?(entry) && level.positive?
                   # needs to be moved as a child
                   subnodes = toptree.delete(entry)
                   processed.delete(entry)
                 end
 
@@ -107,11 +109,11 @@
                 {entry => subnodes}
               end
 
               {}.tap do |tree|
                 idx[:by_sup].keys.each do |sup_id|
-                  if sup = idx[:supers][sup_id]
+                  if (sup = idx[:supers][sup_id])
                     tree.merge!(subtree.call(sup, 0, tree))
                   else
                     idx[:by_sup][sup_id].each do |sub|
                       tree.merge!(subtree.call(sub, 0, tree))
                     end
@@ -120,59 +122,56 @@
               end
             end
 
             private
 
-            def get_super_indexes(values)
+            def get_super_indexes(values) # rubocop:disable Metrics/AbcSize
               raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
               {}.tap do |indexes|
                 indexes[:by_id]  = values.map do |e|
                   e.id && [e.id, e]
                 end.compact.to_h
                 indexes[:by_ext] = values.map do |e|
                   e.external_id && [e.external_id, e]
                 end.compact.to_h
 
                 indexes[:by_sup] = {}.tap do |by_s|
-                  values.group_by do |e|
-                    e.supervisor_id
-                  end.tap do |by_sup|
+                  values.group_by(&:supervisor_id).tap do |by_sup|
                     by_s[nil] = by_sup.delete(nil) if by_sup.key?(nil)
                     by_s.merge!(by_sup)
                   end
                 end
 
                 indexes[:supers] = {}.tap do |sups|
-                  indexes[:by_ext].select do |ext, e|
+                  indexes[:by_ext].select do |ext, _e|
                     ext && indexes[:by_sup].key?(ext)
                   end.tap {|found| sups.merge!(found)}
-                  indexes[:by_id].select do |id, e|
+                  indexes[:by_id].select do |id, _e|
                     id && indexes[:by_sup].key?(id)
                   end.tap {|found| sups.merge!(found)}
                 end
 
-                indexes[:is_super]     = Proc.new do |entry|
-                  !!(indexes[:supers][entry.id] || indexes[:supers][entry.external_id])
+                indexes[:is_super] = proc do |entry|
+                  is = indexes[:supers][entry.id] || indexes[:supers][entry.external_id]
+                  !is.nil?
                 end
 
-                indexes[:subordinates] = Proc.new do |entry|
+                indexes[:subordinates] = proc do |entry|
                   subs = nil
-                  if sup = indexes[:supers][entry.id] || indexes[:supers][entry.external_id]
-                    subs ||= indexes[:by_sup][sup.id]          unless !sup.id
-                    subs ||= indexes[:by_sup][sup.external_id] unless !sup.external_id
+                  sup  = indexes[:supers][entry.id] || indexes[:supers][entry.external_id]
+                  if sup
+                    subs ||= indexes[:by_sup][sup.id]          if sup.id
+                    subs ||= indexes[:by_sup][sup.external_id] if sup.external_id
                   end
                   subs
                 end
               end
-
             end
-
           end
 
           class << self
             include SupervisorHelpers::ClassMethods
           end
-
         end
       end
     end
   end
 end