eco-helpers 2.5.4 → 2.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 444bec4cd18402a38eff718340932ca7d72c9959b865805964b0ec9787d94636
-  data.tar.gz: 97291544f70b525781d81f168ffc86c1d960151e53535a540ac1b7824b9eaf28
+  metadata.gz: ed268fb73bb35106da813f51a7b9469d0ee0fe167cee520ac44f98fed22c622b
+  data.tar.gz: c6b6e0f72037f2a1dac9313293317a78a4d25c52568c7577f88efdafb37d7994
 SHA512:
-  metadata.gz: 02360de987395d801aa1b1fb659dd4b6011c317a21058be33c3283b3a2856c69db519baf6eb85a022f7a2c7c4e826861b108c2cf09aefad3ca57b32d53b45c72
-  data.tar.gz: 402c880d701446c072f6534d4df35b2a104704dc79480e37e5033101df63a8b10baa25257911af1cc84994efe05744b15c608798dbc1637ad268811ca2d7d926
+  metadata.gz: 21d9f1703574866e548daa22f1e196b237a8415fb750fe53bb6c4cd63e5fa90002a9e2d5f90e5f3aaca769f639e6d9c02f40b0e7a7a123a15965af41bff91828
+  data.tar.gz: a02e32a2945f0e4e7a5780e340e8ef400e434d00f2cf44d9969d8573bf84e94c5d35c4c0319e205e351837dc016eb9e389759db3d2291ceab493943af597170b

data/CHANGELOG.md

@@ -1,12 +1,45 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.5.5] - 2023-07-xx
+## [2.5.7] - 2023-08-xx
 
 ### Added
 ### Changed
 ### Fixed
 
+## [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
+  - `Eco::API::Organization::TagTree` - **added/improved methods**
+    - `#as_json` new parameter `max_depth:` to be able to cut the tree
+    - `#active_tree` new method to exclude archived nodes.
+    - `#truncate` new method to obtain a tree cut to `max_depth:`
+  - `Eco::API::Session::Config::Tagtree`: **exposed** `include_archived:` (a.k.a. `inludeArchivedNodes`).
+    - This change states that `session.tagtree` does not retrieve archived nodes by default, while `session.live_tree` does retrieve archived nodes.
+    - This change required an update on the `ecoportal-api-graphql` **gem**
+
+### Fixed
+  - `Eco::API::Organization::TagTree#path` - dups the result (rather than exposing the internal path array)
+
 ## [2.5.4] - 2023-07-27
 
 ### 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.8', '< 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/common/people/person_entry.rb

@@ -523,7 +523,6 @@ module Eco
             call_order = parsing? ? [ext, mad, int, fin] : [fin, int, mad, ext]
             call_order.each {|proc| proc.call}
           end
-
         end
       end
     end

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

@@ -76,9 +76,23 @@ module Eco
           @archived
         end
 
+        def active?
+          !archived?
+        end
+
         # @return [Eco::API::Organization::TagTree]
         def dup
-          self.class.new(as_json)
+          self.class.new(as_json, name: name, id: id)
+        end
+
+        # @return [Eco::API::Organization::TagTree] with **non** `archived` nodes only
+        def active_tree
+          self.class.new(as_json(include_archived: false), name: name, id: id)
+        end
+
+        # @return [Eco::API::Organization::TagTree] with nodes up to `max_depth`
+        def truncate(max_depth: total_depth)
+          self.class.new(as_json(max_depth: max_depth), name: name, id: id)
         end
 
         # Iterate through all the nodes of this tree
@@ -161,11 +175,26 @@ module Eco
         # Returns a tree of Hashes form nested via `nodes` (or just a list of hash nodes)
         # @yield [node_json, node] block for custom output json model
         # @yiledreturn [Hash] the custom json model.
-        # @include_children [Boolean] whether it should return a tree hash or just a list of hash nodes.
+        # @param include_children [Boolean] whether it should return a tree hash or just a list of hash nodes.
+        # @param include_archived [Boolean] whether it should include archived nodes.
+        # @param max_depth [Boolean] up to what level `depth` nodes should be included.
         # @return [Array[Hash]] where `Hash` is a `node` (i.e. `{"tag" => TAG, "nodes": Array[Hash]}`)
-        def as_json(include_children: true, &block)
-          return [] if top? && !include_children
-          children_json = nodes.map {|nd| nd.as_json(include_children: true, &block)} if include_children
+        def as_json(include_children: true, include_archived: true, max_depth: total_depth, &block)
+          max_depth ||= total_depth
+          return nil if max_depth < depth
+          return []  if top? && !include_children
+          return nil if archived? && !include_archived
+
+          if include_children
+            child_nodes   = nodes
+            child_nodes   = child_nodes.select(&:active?) unless include_archived
+            kargs         = {
+              include_children: include_children,
+              include_archived: include_archived,
+              max_depth:        max_depth
+            }
+            children_json = child_nodes.map {|nd| nd.as_json(**kargs, &block)}.compact
+          end
 
           if top?
             children_json
@@ -287,8 +316,8 @@ module Eco
         # @param key [String] tag to find the path to.
         # @return [Array<String>]
         def path(key = nil)
-          return @path if !key
-          @hash_paths[key.upcase]
+          return @path.dup if !key
+          @hash_paths[key.upcase].dup
         end
 
         # Helper to assign tags to a person account.

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

@@ -3,18 +3,31 @@ module Eco
     class Session
       class Config
         class TagTree < BaseConfig
+          class MissingTagtree < StandardError
+          end
+
           attr_key :file
 
-          def scope_tree(enviro: nil)
+          # @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
-            @tagtree ||= live_tree(enviro: enviro).tap do |tree|
+
+            kargs = {
+              enviro:               enviro,
+              includeArchivedNodes: include_archived
+            }
+
+            @tagtree ||= live_tree(**kargs).tap do |tree|
               unless tree && !tree.empty?
-                raise "Could not find a locations structure."
+                msg = "Could not find a local or live locations structure."
+                raise MissingTagtree, msg
               end
             end
           end
@@ -22,14 +35,25 @@ 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,
+              includeArchivedNodes: include_archived
+            }.merge(kargs)
+
             if id
-              args       = {id: id, enviro: enviro, include_archived: include_archived}.merge(kargs)
+              args       = { id: id }.merge(kargs)
               @live_tree = live_tree_get(**args, &block)
             else
-              # note that `include_archived` nodes is NOT the same as including archived structures
-              # => In `live_tree` the paramter refers to nodes
-              trees      = live_trees(enviro: enviro, &block)
+              trees      = live_trees(**kargs, &block)
               @live_tree = trees.reject do |tree|
                 tree.empty?
               end.max do |a,b|
@@ -37,34 +61,50 @@ 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
 
           # Gets a single locations structure
           # @note it does not memoize
+          # @param include_archived [Boolean] whether or not to include archived **nodes**
+          # @return [Eco::API::Organization::TagTree, NilClass]
           def live_tree_get(id: nil, enviro: nil, include_archived: false, **kargs, &block)
             return nil unless apis.active_api.version_available?(:graphql)
             return nil unless graphql = apis.api(version: :graphql)
-            #kargs = { includeArchived: include_archived }.merge(kargs).slice(:includeArchived)
-            # For now, this endpoint only accepts `id` as a parameter. It is pending to
-            # expose further parameters via query
-            return nil unless tree = graphql.currentOrganization.locationStructure(id: id, &block)
+
+            kargs = {
+              id:                   id,
+              includeArchivedNodes: include_archived
+            }.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
 
           # Retrieves all the location structures of the organisation
+          # @param include_archived [Boolean] whether or not to include archived **nodes**
+          # @return [Array<Eco::API::Organization::TagTree>]
           def live_trees(enviro: nil, include_archived: false, **kargs, &block)
             [].tap do |eco_trees|
               next unless apis.active_api.version_available?(:graphql)
               next unless graphql = apis.api(version: :graphql)
+
               kargs = {
-                includeArchived:    include_archived,
-                includeUnpublished: false
-              }.merge(kargs).slice(:includeArchived, :includeUnpublished)
+                includeArchivedNodes: include_archived
+              }.merge(kargs)
 
               next unless trees = graphql.currentOrganization.locationStructures(**kargs, &block)
               trees.each do |tree|

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

@@ -235,20 +235,22 @@ module Eco
         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)
+        # @param include_archived [Boolean] whether or not it should include archived nodes.
         # @return [Eco::API::Organization::TagTree]
-        def tagtree(enviro: nil)
-          @tagtree ||= tagtree_config.scope_tree(enviro: enviro)
+        def tagtree(enviro: nil, include_archived: false, raise_on_missing: true)
+          kargs = {
+            enviro: enviro, include_archived: include_archived, raise_on_missing: raise_on_missing
+          }
+          @tagtree ||= tagtree_config.scope_tree(**kargs)
         end
 
         # It obtains the first of the live tagtree in the org
         # @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/default_cases/reinvite_trans_case.rb

@@ -12,9 +12,9 @@ class Eco::API::UseCases::DefaultCases::ReinviteTransCase < Eco::API::Common::Lo
     invite   = session.new_job("main", "invite", :update, usecase, :account)
     users.each do |person|
       if force_invite?
-        person.account.send_invites = true
-      else
         person.account.force_send_invites = true
+      else
+        person.account.send_invites = true
       end
       invite.add(person)
     end

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

@@ -68,7 +68,7 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
       msg << "nor options(:source, :structure_id). "
       msg << "Infering active locations structure."
       log(:warn) { msg }
-      if self.current_tree = session.live_tree
+      if self.current_tree = session_live_tree
         @target_structure_id = current_tree.id
       end
     end
@@ -81,7 +81,13 @@ module Eco::API::UseCases::GraphQL::Helpers::Location
       tree_init = current_tree
       target_id = target_structure_id
       return current_tree if current_tree != tree_init
-      self.current_tree = session.live_tree(id: target_id, include_archived: true)
+      self.current_tree = session_live_tree(id: target_id)
+    end
+
+    # Unique access point to retrieve the live tree
+    # @note ensures archived nodes are retrieved.
+    def session_live_tree(id: nil)
+      session.live_tree(id: id, include_archived: true)
     end
   end
 end

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.4"
+  VERSION = "2.5.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.5.4
+  version: 2.5.6
 platform: ruby
 authors:
 - Oscar Segura
@@ -156,7 +156,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.8
+        version: 0.3.10
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.4'
@@ -166,7 +166,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.8
+        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