eco-helpers 2.5.5 → 2.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d241b7bc57bd81e9b3a6b1d71ecab5f7530b7b6df176301adc21584722f2b247
-  data.tar.gz: a8beafa1e6cd1e3425291121c55b78fe144f155021ab149148fcc6ce35569984
+  metadata.gz: 712a817db8970559d9d45923531ff092edc4eed7a6f937a51251ab7510b21e48
+  data.tar.gz: c00d489419212cfcb52de588b5b066c789e558e5d38b508e3946a3ba90d1a774
 SHA512:
-  metadata.gz: 2bad589998061077bac0f6adb500fdbb9402b77578da68bf43a84f83101a2bf862213acb00707a363f5583c47ec94a876c367360c562043865e573232b272c4c
-  data.tar.gz: 7c33f358f5cbb7ab0b3118d7b0b20e86a9f686f2e1f49216e23bea5ab504ca4bb0bbb2eeab8bb37daf0d11b997af0160212ff7ab2d1fe382fa05a6b354529f48
+  metadata.gz: 32e7c9cf3d1bb894e7402e7ee162cd823db5c79fe9853ac9a5d6856442b8b09334b1515e0fb61a87d301255f070a0567cf8424828b53db5e9b6cb831f0627159
+  data.tar.gz: e9db4bcaf310a3d77967497f05fb9bab8e8e76c2c328ba3c1a33a02d2c8df8cc730cde8f2534145d9d1d5774a88c83b5647151ee7cd0494babf7b031271a1c7f

data/CHANGELOG.md

@@ -1,12 +1,38 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.5.6] - 2023-08-xx
+## [2.5.8] - 2023-08-xx
 
 ### Added
 ### Changed
 ### Fixed
 
+## [2.5.7] - 2023-08-15
+
+### Added
+  - `Eco::API::Session::Config#tagtree_id=` allows to define a target structure id
+    - This is for `live` retrieval of tagtree on people sync processes
+    - It only makes sense if graphql credentials are configured
+
+## [2.5.6] - 2023-08-14
+
+### Changed
+  - `Eco::API::Session::Config::Tagtree#live_tree` remove memmoize tree: it now always trigger a query to the back-end
+    - Better messaging to know what's going on.
+
+### Fixed
+  - `Eco::API::Session#live_tree` was not forwarding target structure id `id`
+  - `Eco::Data::Locations::NodeLevel#override_lower_levels`
+    - By **default** should only override empty upper levels
+  - `Eco::Data::Locations::NodeLevel::Cleaner`
+    - `#tidy_nodes` when **gap** (merged parent) identified, `level` is still correct
+  - `Eco::Data::Locations::NodeLevel`
+    - `#nodes_from_csv` correctly identify parent with big gaps
+    - This fix ensures a correct normalization
+  - `Eco::API::UseCases::GraphQL::Samples::Location::Command::Result`
+    - **Batch remap tags** _built_ requires full path to keep from-filter specificity
+    - This change also wraps into a new class the remap tags table.
+
 ## [2.5.5] - 2023-08-03
 
 ### Added

data/eco-helpers.gemspec

@@ -32,7 +32,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'ecoportal-api', '>= 0.9.4', '< 0.10'
   spec.add_dependency 'ecoportal-api-v2', '>= 1.1.3', '< 1.2'
-  spec.add_dependency 'ecoportal-api-graphql', '>= 0.3.9', '< 0.4'
+  spec.add_dependency 'ecoportal-api-graphql', '>= 0.3.10', '< 0.4'
   spec.add_dependency 'aws-sdk-s3',    '>= 1.83.0', '< 2'
   spec.add_dependency 'aws-sdk-ses',   '>= 1.36.0', '< 2'
   spec.add_dependency 'dotenv',        '>= 2.7.6',  '< 3'

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

@@ -6,23 +6,26 @@ module Eco
           class MissingTagtree < StandardError
           end
 
-          attr_key :file
+          attr_key :file, :structure_id
 
           # @param include_archived [Boolean] whether or not it should include archived nodes.
           # @return [Eco::API::Organization::TagTree]
           def scope_tree(enviro: nil, include_archived: true, raise_on_missing: true)
             return @tagtree if instance_variable_defined?(:@tagtree) && @tagtree.enviro == enviro
-            if tree_file = self.file
-              if (tree = file_manager.load_json(tree_file)) && !tree.empty?
-                @tagtree  = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
-              end
-            end
 
             kargs = {
               enviro:               enviro,
               includeArchivedNodes: include_archived
             }
 
+            if tree_file = self.file
+              if (tree = file_manager.load_json(tree_file)) && !tree.empty?
+                @tagtree = Eco::API::Organization::TagTree.new(tree, enviro: enviro)
+              end
+            elsif self.structure_id
+              kargs.merge(id: self.structure_id)
+            end
+
             @tagtree ||= live_tree(**kargs).tap do |tree|
               unless tree && !tree.empty?
                 msg = "Could not find a local or live locations structure."
@@ -34,7 +37,14 @@ module Eco
           # Among all the locations structures it selects the one with more location nodes
           # If `id` is provided, it only retrieves this locations structure.
           def live_tree(id: nil, enviro: nil, include_archived: false, **kargs, &block)
-            return @live_tree if instance_variable_defined?(:@live_tree) && @live_tree.enviro == enviro
+            existing_cache   = !!@live_tree
+            first_load       = !existing_cache
+
+            target_change    = existing_cache && id     && @live_tree.id != id
+            enviro_change    = existing_cache && enviro && @live_tree.enviro != enviro
+
+            switching_target = existing_cache && (target_change || enviro_change)
+            refresh_cache    = existing_cache && !switching_target
 
             kargs = {
               enviro:               enviro,
@@ -45,7 +55,6 @@ module Eco
               args       = { id: id }.merge(kargs)
               @live_tree = live_tree_get(**args, &block)
             else
-              kargs
               trees      = live_trees(**kargs, &block)
               @live_tree = trees.reject do |tree|
                 tree.empty?
@@ -54,8 +63,16 @@ module Eco
               end
             end.tap do |tree|
               if tree
-                msg = "Using LIVE LOCATIONS Structure: '#{tree.name}' (#{tree.count} nodes)"
-                session_logger.info(msg)
+                msg = "LIVE LOCATIONS Structure (#{tree.id}): '#{tree.name}' (#{tree.count} nodes)"
+                if first_load
+                  session_logger.info("Using #{msg}")
+                elsif switching_target
+                  session_logger.info("Switched to #{msg}")
+                else # refresh_cache
+                  session_logger.debug("Reloading #{msg}")
+                end
+              else
+                session_logger.info "Could not retrive live tree (#{id})"
               end
             end
           end
@@ -74,6 +91,7 @@ module Eco
             }.merge(kargs)
 
             return nil unless tree = graphql.currentOrganization.locationStructure(**kargs, &block)
+
             args = { enviro: enviro, id: tree.id, name: tree.name }
             Eco::API::Organization::TagTree.new(tree.treeify, **args)
           end

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

@@ -234,6 +234,10 @@ module Eco
           tagtree_config.file = file
         end
 
+        def tagtree_id=(value)
+          tagtree_config.structure_id = value
+        end
+
         # It uses the `tagtree.json` file and in its absence, if `graphql` enabled, the largest `life_tagtree`
         # @note it does NOT include archived nodes by default.
         #   - This is for legacy (most usecases don't)
@@ -250,11 +254,7 @@ module Eco
         # @note it requires graphql connection configuration parameters
         # @return [Eco::API::Organization::TagTree]
         def live_tree(id: nil, enviro: nil, **kargs, &block)
-          if id
-            tagtree_config.live_tree_get(id: id, enviro: enviro, **kargs, &block)
-          else
-            tagtree_config.live_tree(enviro: enviro, **kargs, &block)
-          end
+          tagtree_config.live_tree(id: id, enviro: enviro, **kargs, &block)
         end
 
         # @return [Eco::API::Organization::PolicyGroups]

data/lib/eco/api/session.rb

@@ -46,7 +46,7 @@ module Eco
 
       # @see Eco::API::Session::Config#live_tree
       def live_tree(id: nil, include_archived: false, **kargs, &block)
-        config.live_tree(id: nil, include_archived: include_archived, enviro: enviro, **kargs, &block)
+        config.live_tree(id: id, include_archived: include_archived, enviro: enviro, **kargs, &block)
       end
 
       # @see Eco::API::Session::Config#schemas

data/lib/eco/api/usecases/graphql/helpers/location/tags_remap/tags_map.rb

@@ -0,0 +1,66 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location
+  class TagsRemap
+    class TagsMap
+      attr_reader :from, :to
+
+      def initialize(from, to)
+        @from = TagsSet.new(from)
+        @to   = TagsSet.new(to)
+      end
+
+      def to_csv_row
+        [from.to_s, to.to_s]
+      end
+
+      # @note to create a stable sort we assume `self` is a sorted element
+      def <=>(other)
+        return -1 if maps?   && !other.maps?
+        return  1 if !maps?  && other.maps?
+        return -1 if rename? && other.move?
+        return  1 if move?   && other.rename?
+        return -1 if rename? && other.rename?
+        # both are being moved (specific/long mappings first)
+        return  1 if from.subset_of?(other.from)
+        return -1 if from.superset_of?(other.from)
+        return -1 if (from & other.from).empty?
+        return -1 if from.length >= other.from.length
+        return  1 if from.length <  other.from.length
+        -1
+      end
+
+      # @note to create a stable sort we assume `self` is a sorted element
+      def goes_before?(other)
+        (self <=> other) == -1
+      end
+
+      # @note to create a stable sort we assume `self` is a sorted element
+      def goes_after?(other)
+        (self <=> other) == 1
+      end
+
+      def both?(&block)
+        [from, to].all?(&block)
+      end
+
+      def any?(&block)
+        [from, to].any?(&block)
+      end
+
+      def maps?
+        return false if any?(&:empty?)
+        return false if from == to
+        true
+      end
+
+      def rename?
+        return false unless maps?
+        both? {|set| set.length == 1}
+      end
+
+      def move?
+        return false unless maps?
+        !rename?
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/location/tags_remap/tags_set.rb

@@ -0,0 +1,95 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location
+  class TagsRemap
+    class TagsSet
+      class << self
+        def attr_compare(*attrs)
+          attrs.each do |attr|
+            meth = "#{attr}".to_sym
+            define_method meth do |value|
+              set.send(meth, to_set(value))
+            end
+          end
+        end
+        def attr_operate(*attrs)
+          attrs.each do |attr|
+            meth = "#{attr}".to_sym
+            define_method meth do |value|
+              self.class.new(set.send(meth, to_set(value)))
+            end
+          end
+        end
+      end
+
+      COMPARE_METHODS = %i[< <= == > >=].freeze
+      OPERATE_METHIDS = %i[& + - ^].freeze
+
+      attr_compare *COMPARE_METHODS
+      attr_operate *OPERATE_METHIDS
+
+      attr_reader :tags, :set
+
+      def initialize(tags)
+        @ini_tags = value_to_a(tags)
+        @set      = to_set(tags)
+      end
+
+      def length
+        set.length
+      end
+
+      def tags
+        ini_tags.compact.map(&:upcase)
+      end
+
+      def to_a
+        tags
+      end
+
+      def to_s
+        tags.join('|')
+      end
+      
+      def empty?
+        set.empty?
+      end
+
+      def include?(value)
+        value = value.to_s.strip
+        return false if value.empty?
+        set.include?(value)
+      end
+
+      def include_any?(value)
+        value.to_a.any? {|tag| self.include?(tag)}
+      end
+
+      def subset_of?(value)
+        set.subset?(to_set(value))
+      end
+
+      def superset_of?(value)
+        set.superset?(to_set(value))
+      end
+
+      protected
+
+      def ini_tags
+        @ini_tags
+      end
+
+      private
+
+      def value_to_a(value)
+        return value.ini_tags.dup if value.is_a?(self.class)
+        return value.dup          if value.is_a?(Array)
+        return value.to_a         if value.is_a?(Set)
+        raise ArgumentError, "Expecting #{self.class}, Set or Array. Given: #{value.class}"
+      end
+
+      def to_set(value)
+        values = value_to_a(value)
+        Set.new.merge(values.compact.map(&:upcase))
+      end
+    end
+  end
+end

data/lib/eco/api/usecases/graphql/helpers/location/tags_remap.rb

@@ -0,0 +1,88 @@
+module Eco::API::UseCases::GraphQL::Helpers::Location
+  class TagsRemap
+    def self.correct_pair?(pair)
+      correct_pair = pair.is_a?(Array)
+      correct_pair && pair.length == 2
+    end
+
+    attr_reader :src_maps
+    attr_reader :from, :to
+
+    def each(&block)
+      return to_enum(:each) unless block
+      src_maps.each(&block)
+    end
+
+    def to_csv(filename)
+      CSV.open(filename, "w") do |fd|
+        fd << ["src_tags", "dst_tags"]
+        each do |tags_map|
+          fd << tags_map.to_csv_row
+        end
+      end
+    end
+
+    def to_s
+      "".tap do |str|
+        each.map do |tags_map|
+          from, to = tags_map.to_csv_row
+          str << " • from: #{from}\n"
+          str << "   • to: #{to}\n"
+        end
+      end
+    end
+
+    # Sorts the maps in the correct order
+    # @note it assumes that:
+    #   1. renames go before moving nodes
+    #   2. moving nodes does not include a rename
+    #   3. moving nodes includes all the path on both, source and destination tags
+    # @note DISABLED: the order should be that in what the operations happened!
+    #   An important thing is that all the path is always included in the mappings.
+    #   * The only way that this would work is to apply upper (previous) tags_maps
+    #   to subsequent ones. But the order should still be kept!
+    # def sorted_maps
+    #   [].tap do |sorted|
+    #     src_maps.each do |curr_map|
+    #       pos = nil
+    #       sorted.each_with_index.reverse_each do |prev_map, idx|
+    #         pos = idx + 1 if prev_map.goes_before?(curr_map)
+    #         break if pos
+    #       end
+    #       sorted.insert(pos || 0, curr_map)
+    #     end
+    #   end
+    # end
+
+    def empty?
+      src_maps.empty?
+    end
+
+    def <<(pair)
+      raise ArgumentError, "Expecting pair of Array in Array. Given: #{pair}" unless self.class.correct_pair?(pair)
+      add(*pair)
+    end
+
+    def add(from, to)
+      raise ArgumentError, "Expecting Array. Given: #{from.class}" unless from.is_a?(Array)
+      raise ArgumentError, "Expecting Array. Given: #{to.class}"   unless to.is_a?(Array)
+      new_src TagsMap.new(from, to)
+    end
+
+    private
+
+    attr_reader :src_maps
+    attr_reader :from_key, :to_key
+
+    def new_src(tags_map)
+      src_maps << tags_map
+    end
+
+    def src_maps
+      @src_maps ||= []
+    end
+  end
+end
+
+require_relative 'tags_remap/tags_map'
+require_relative 'tags_remap/tags_set'

data/lib/eco/api/usecases/graphql/helpers/location.rb

@@ -4,4 +4,5 @@ module Eco::API::UseCases::GraphQL::Helpers
 end
 
 require_relative 'location/base'
+require_relative 'location/tags_remap'
 require_relative 'location/command'

data/lib/eco/api/usecases/graphql/samples/location/command/results.rb

@@ -18,6 +18,10 @@ class Eco::API::UseCases::GraphQL::Samples::Location
       Eco::API::UseCases::GraphQL::Helpers::Location::Command::Results
     end
 
+    def tags_remap_class
+      Eco::API::UseCases::GraphQL::Helpers::Location::TagsRemap
+    end
+
     # Capture results
     def results
       @results ||= {}
@@ -26,7 +30,7 @@ class Eco::API::UseCases::GraphQL::Samples::Location
     # The maps of tags to be used in batch remap tags
     # @return [Array<Array>] source/destination pairs of `Array<String>`
     def tags_remap_table
-      @tags_remap_table ||= []
+      @tags_remap_table ||= tags_remap_class.new
     end
 
     # Errors tracking/logging.
@@ -87,17 +91,17 @@ class Eco::API::UseCases::GraphQL::Samples::Location
           node_id, parent_id = result.command_input_data.values_at(:nodeId, :parentId)
           prev_node = previous_tree.node(node_id)
           curr_node = current_tree.node(node_id)
-          lost_tags = prev_node.path - curr_node.path
-          new_tags  = curr_node.path - prev_node.path
+          prev_path = prev_node.path.reverse
+          new_path  = curr_node.path.reverse
 
           curr_parent = curr_node.parent.top? ? nil : curr_node.parent
           unless curr_parent&.id == parent_id
-            msg  = "Node '#{node_id}' was moved uner '#{parent_id}', "
+            msg  = "Node '#{node_id}' was moved under '#{parent_id}', "
             msg << "but in current structure has parent '#{curr_parent&.id}'"
             log(:warn) { msg }
           end
 
-          tags_remap_table << [lost_tags.unshift(node_id), new_tags.unshift(node_id)]
+          tags_remap_table << [prev_path, new_path]
         end
       end
     end
@@ -108,8 +112,8 @@ class Eco::API::UseCases::GraphQL::Samples::Location
       timestamp_file(filename).tap do |file|
         CSV.open(file, 'w') do |csv|
           csv << ["source_tags", "destination_tags"]
-          tags_remap_table.each do |(src_tags, dst_tags)|
-            csv << [src_tags.join('|'), dst_tags.join('|')]
+          tags_remap_table.each do |tags_remap|
+            csv << tags_remap.to_csv_row
           end
         end
         log(:info) { "Generated file '#{file}'" }

data/lib/eco/data/locations/node_level/cleaner.rb

@@ -28,10 +28,11 @@ class Eco::Data::Locations::NodeLevel
             msg << "\n  Adding missing upper level(s): " + missing_nodes.map(&:raw_tag).pretty_inspect
             log(:info) { msg }
 
-            out.push(*tidy_nodes(missing_nodes, prev_level: prev_level, main: false))
-            # puts node.actual_level
-            # pp node.tags_array
-            level = prev_level + 1
+            # The very top missing node (first in list) should be checked against prev_level
+            # alongside any descendants in missing_nodes (when gap 2+)
+            tidied_nodes = tidy_nodes(missing_nodes, prev_level: prev_level, main: false)
+            out.push(*tidied_nodes)
+            #level = prev_level + 1 # <= we are actually on level and filled in the gaps
           end
           out       << node
           done_ids  << node_id
@@ -44,6 +45,8 @@ class Eco::Data::Locations::NodeLevel
     end
 
     # Sets the `parentId` property.
+    # Although with normalized nodes parents are self-contained
+    # we use this method
     def fill_in_parents(nodes)
       nodes.tap do |nodes|
         prev_nodes = empty_level_tracker_hash(11)

data/lib/eco/data/locations/node_level/parsing.rb

@@ -31,7 +31,13 @@ class Eco::Data::Locations::NodeLevel
       prev_level = nil
       prev_node  = nil
       prev_nodes = empty_level_tracker_hash(11)
-
+      prev_node_get = proc do |raw_level|
+        prev = nil
+        (1..raw_level).to_a.reverse.each do |lev|
+          prev ||= prev_nodes[lev]
+        end
+        prev
+      end
       # Convert to Eco::CSV::Table for a fresh start
       csv = Eco::CSV.parse(csv.to_csv).nil_blank_cells.add_index_column(:row_num)
 
@@ -42,10 +48,12 @@ class Eco::Data::Locations::NodeLevel
 
         # If node is nested in prev_node or is a sibling thereof
         if prev_node.raw_level <= node.raw_level
-          # Make sure parent is among upper level tags
+          # Make sure upper level tags are there (including parent)
+          # This normalizes input to all upper level tags always filled in
+          # which allows to node#actual_level to work
           node.set_high_levels(prev_node)
         else
-          if parent_node = prev_nodes[node.raw_level - 1]
+          if parent_node = prev_node_get[node.raw_level - 1]
             node.set_high_levels(parent_node)
           elsif node.raw_level == 1
             # It is expected not to have parent (as it's top level tag)

data/lib/eco/data/locations/node_level.rb

@@ -47,6 +47,13 @@ module Eco::Data::Locations
       tags_array.index(raw_tag) + 1
     end
 
+    def raw_prev_empty_level
+      tags_array[0..raw_level-1].each_with_index.reverse_each do |value, idx|
+        return idx + 1 unless value
+      end
+      nil
+    end
+
     def tag_idx
       tags_array.index(raw_tag)
     end
@@ -106,6 +113,7 @@ module Eco::Data::Locations
       true
     end
 
+    # Cleanses deepest tags
     def override_upper_levels(src_tags_array, from_level: self.raw_level + 1)
       target_lev  = Array(from_level..tag_attrs_count)
       target_tags = src_tags_array[level_to_idx(from_level)..level_to_idx(tag_attrs_count)]
@@ -115,7 +123,9 @@ module Eco::Data::Locations
       self
     end
 
-    def override_lower_levels(src_tags_array, to_level: self.raw_level - 1)
+    # Ensures parent is among the upper level tags
+    def override_lower_levels(src_tags_array, to_level: self.raw_prev_empty_level)
+      return self unless to_level
       target_lev  = Array(1..to_level)
       target_tags = src_tags_array[level_to_idx(1)..level_to_idx(to_level)]
       target_lev.zip(target_tags).each do |(n, tag)|

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "2.5.5"
+  VERSION = "2.5.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.5.5
+  version: 2.5.7
 platform: ruby
 authors:
 - Oscar Segura
@@ -156,7 +156,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.9
+        version: 0.3.10
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.4'
@@ -166,7 +166,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.9
+        version: 0.3.10
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.4'
@@ -598,6 +598,9 @@ files:
 - lib/eco/api/usecases/graphql/helpers/location/command.rb
 - lib/eco/api/usecases/graphql/helpers/location/command/result.rb
 - lib/eco/api/usecases/graphql/helpers/location/command/results.rb
+- lib/eco/api/usecases/graphql/helpers/location/tags_remap.rb
+- lib/eco/api/usecases/graphql/helpers/location/tags_remap/tags_map.rb
+- lib/eco/api/usecases/graphql/helpers/location/tags_remap/tags_set.rb
 - lib/eco/api/usecases/graphql/samples.rb
 - lib/eco/api/usecases/graphql/samples/location.rb
 - lib/eco/api/usecases/graphql/samples/location/command.rb