eco-helpers 1.3.13 → 1.3.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b59fa190429f792010af645ab28370ef0132ad17fafca035a363722736ab01e
-  data.tar.gz: c35a11ee4935356f1a93a008b63b520bd0809ef3a3d12d2b71e5329eb9f721f8
+  metadata.gz: 01ec2727fdeee5bc360e417faefdafdb8bf69078cecc17ead881047e8df17cd2
+  data.tar.gz: 67e46501f166224248d6d92e6607cddcbce3806dbd05f41e485d0ca2139f1105
 SHA512:
-  metadata.gz: e9d7f407038348bfb98bc8c1cf127d73108f3e90b92d3cd267f8c1868a1fad5810226506e4112f7c87d9deb6775af2d7ad94bb27dfd4c6c2ea2885b28f7b6c76
-  data.tar.gz: 90c6d245f2eb3fbfa1729765cf7629792eadbd33b84c58333aaac6a7e6a81d395fa150c4ff9c240c24403976c25d471d510441b849159aeaf67a593c19258db1
+  metadata.gz: cd26851249e2c8557f9da3399f72292cb46a2c12db530f12e3da2a88120dc08a6e0a6ee053527b91685cd60e532d2bbd76e156f1fc803dc6bf2c1246a21fac27
+  data.tar.gz: 4f199963c86259bb5a210dca09aa1af2b83c9489308afd200986d6d5c13f32d3479fb2eeaad19c397882359dd3ef16892dc7449860879e2a71fdbf8f73e34943

data/CHANGELOG.md

@@ -1,6 +1,15 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [1.3.14] - 2020-06-10
+
+### Added
+  - `Eco::API::Common::People::SupervisorHelpers` now has its methods as class methods
+### Changed
+  - upgraded `ecoportal-api` gem dependency to minimum version `0.5.6`
+### Fixed
+
+
 ## [1.3.13] - 2020-05-29
 
 ### Added

data/eco-helpers.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "yard",      "~> 0.9", ">= 0.9.18"
   s.add_development_dependency "redcarpet", "~> 3.5", ">= 3.5.0"
 
-  s.add_dependency 'ecoportal-api', '~> 0.5',  '>= 0.5.5'
+  s.add_dependency 'ecoportal-api', '~> 0.5',  '>= 0.5.6'
   s.add_dependency 'aws-sdk-s3',    '~> 1.30', '>= 1.30.1'
   s.add_dependency 'aws-sdk-ses',   '~> 1.14', '>= 1.14.0'
   s.add_dependency 'dotenv',        '~> 2.6',  '>= 2.6.0'

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

@@ -7,134 +7,144 @@ module Eco
         #   * `external_id`
         #   * `id`
         module SupervisorHelpers
+          def self.included(base)
+            base.send(:include, ClassMethods)
+          end
 
-          # Reorders as follows:
-          #   1. supervisors, people with no supervisor or where their supervisor not present
-          #   2. 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|
-              [].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)
-                  supervisors_first ? sout.unshift(sup) : sout.push(sup)
-                  out.concat(sout)
+          module ClassMethods
+            # Reorders as follows:
+            #   1. supervisors, people with no supervisor or where their supervisor not present
+            #   2. 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|
+                [].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)
+                    supervisors_first ? sout.unshift(sup) : sout.push(sup)
+                    out.concat(sout)
+                  end
                 end
               end
-            end
 
-            roam.call(supervisors_tree(values))
-          end
+              roam.call(supervisors_tree(values))
+            end
 
-          def tree_to_str(tree, lev: 0)
-            raise "Required Hash tree structure. Given: #{tree.class}" unless tree.is_a?(Hash)
-            "".tap do |str|
-              tree.each do |entry, subtree|
-                str << "#{"  " * lev}+-- #{entry.id || entry.external_id}\n"
-                str << tree_to_str(subtree, lev: lev + 1) unless !subtree || subtree.empty?
+            def tree_to_str(tree, lev: 0)
+              raise "Required Hash tree structure. Given: #{tree.class}" unless tree.is_a?(Hash)
+              "".tap do |str|
+                tree.each do |entry, subtree|
+                  str << "#{"  " * lev}+-- #{entry.id || entry.external_id}\n"
+                  str << tree_to_str(subtree, lev: lev + 1) unless !subtree || subtree.empty?
+                end
               end
             end
-          end
 
-          def print_tree(tree, lev: 0)
-            puts tree_to_str(tree)
-          end
+            def print_tree(tree, lev: 0)
+              puts tree_to_str(tree)
+            end
 
-          # Generates a `Hash` tree structure, where:
-          #   * **keys** are nodes
-          #   * **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)
-            raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
-            return {} unless values && values.is_a?(Enumerable)
-            idx = get_super_indexes(values)
-
-            processed = []
-            subtree = Proc.new do |entry, level, toptree|
-              if processed.include?(entry)
-                next {} unless toptree.key?(entry) && level > 0
-                # needs to be moved as a child
-                subnodes = toptree.delete(entry)
-                processed.delete(entry)
-              end
+            # Generates a `Hash` tree structure, where:
+            #   * **keys** are nodes
+            #   * **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)
+              raise "Expected non hash Enumerable. Given: #{values.class}" if values.is_a?(Hash)
+              return {} unless values && values.is_a?(Enumerable)
+              idx = get_super_indexes(values)
+
+              processed = []
+              subtree = Proc.new do |entry, level, toptree|
+                if processed.include?(entry)
+                  next {} unless toptree.key?(entry) && level > 0
+                  # needs to be moved as a child
+                  subnodes = toptree.delete(entry)
+                  processed.delete(entry)
+                end
 
-              subnodes ||= {}.tap do |tree|
-                subs = idx[:subordinates].call(entry)
-                processed.push(entry)
-                next nil unless subs && !subs.empty?
-                subs.each do |sub|
-                  sub_tree = subtree.call(sub, level + 1, toptree)
-                  tree.merge!(sub_tree)
+                subnodes ||= {}.tap do |tree|
+                  subs = idx[:subordinates].call(entry)
+                  processed.push(entry)
+                  next nil unless subs && !subs.empty?
+                  subs.each do |sub|
+                    sub_tree = subtree.call(sub, level + 1, toptree)
+                    tree.merge!(sub_tree)
+                  end
                 end
-              end
 
-              {entry => subnodes}
-            end
+                {entry => subnodes}
+              end
 
-            {}.tap do |tree|
-              idx[:by_sup].keys.each do |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))
+              {}.tap do |tree|
+                idx[:by_sup].keys.each do |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
                   end
                 end
               end
             end
-          end
 
-          private
-
-          def get_super_indexes(values)
-            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|
-                  by_s[nil] = by_sup.delete(nil) if by_sup.key?(nil)
-                  by_s.merge!(by_sup)
+            private
+
+            def get_super_indexes(values)
+              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|
+                    by_s[nil] = by_sup.delete(nil) if by_sup.key?(nil)
+                    by_s.merge!(by_sup)
+                  end
                 end
-              end
 
-              indexes[:supers] = {}.tap do |sups|
-                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|
-                  id && indexes[:by_sup].key?(id)
-                end.tap {|found| sups.merge!(found)}
-              end
+                indexes[:supers] = {}.tap do |sups|
+                  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|
+                    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])
-              end
+                indexes[:is_super]     = Proc.new do |entry|
+                  !!(indexes[:supers][entry.id] || indexes[:supers][entry.external_id])
+                end
 
-              indexes[:subordinates] = Proc.new 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
+                indexes[:subordinates] = Proc.new 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
+                  end
+                  subs
                 end
-                subs
               end
+
             end
 
           end
 
+          class << self
+            include SupervisorHelpers::ClassMethods
+          end
+
         end
       end
     end

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "1.3.13"
+  VERSION = "1.3.14"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 1.3.13
+  version: 1.3.14
 platform: ruby
 authors:
 - Oscar Segura
@@ -107,7 +107,7 @@ dependencies:
         version: '0.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.5
+        version: 0.5.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -117,7 +117,7 @@ dependencies:
         version: '0.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.5
+        version: 0.5.6
 - !ruby/object:Gem::Dependency
   name: aws-sdk-s3
   requirement: !ruby/object:Gem::Requirement