eco-helpers 3.0.24 → 3.0.26

data/lib/eco/api/usecases/lib/file_pattern.rb

@@ -0,0 +1,39 @@
+module Eco::API::UseCases::Lib
+  module FilePattern
+    class WrongConst < ArgumentError; end
+
+    CONST_REFERRAL = /^(?:::)?(?:[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*)$/
+
+    attr_reader :options
+
+    private
+
+    # Can't pass this via CLI option, as it breaks the regular expression
+    def file_pattern(required: true)
+      fpc = file_pattern_const
+      return fpc if fpc
+      return     unless required
+
+      msg  = "(#{self.class}) You should redefine the file_pattern function "
+      msg << 'as a RegEx expression that matches the target remote file'
+      raise WrongConst, msg
+    end
+
+    def file_pattern_const
+      if (fpc = options.dig(:sftp, :file_pattern_const))
+        msg = "(#{self.class}) Invalid file pattern const referral: #{fpc}"
+        raise WrongConst, msg unless fpc.match(CONST_REFERRAL)
+
+        begin
+          self.eval(fpc)
+        rescue NameError
+          self.class.const_get(fpc)
+        end
+      elsif self.class.const_defined?(:FILE_PATTERN)
+        self.class::FILE_PATTERN
+      end
+    rescue NameError
+      raise WrongConst, "(#{self.class}) Unknown constant: #{fpc}"
+    end
+  end
+end

data/lib/eco/api/usecases/lib/sftp.rb

@@ -0,0 +1,175 @@
+module Eco::API::UseCases::Lib
+  module Sftp
+    class UnspecifiedRemoteFolder < ArgumentError; end
+
+    include Eco::Language::AuxiliarLogger
+
+    attr_reader :session, :options
+
+    private
+
+    def upload(local_file, subfolder: remote_subfolder, gid: sftp_group_id)
+      sftp_session.upload(
+        local_file,
+        remote_folder: remote_folder(subfolder),
+        gid:           gid
+      )
+    end
+    alias_method :sftp_upload, :upload
+
+    def sftp_group_id
+      if (group_id = options.dig(:sftp, :group))
+        group_id
+      elsif self.class.const_defined?(:SFTP_GROUP)
+        self.class.const_get(:SFTP_GROUP)
+      elsif self.class.const_defined?(:GROUP_ID)
+        self.class.const_get(:GROUP_ID)
+      end
+    end
+
+    def sftp_download_files(
+      subfolder:    remote_subfolder,
+      pattern:      nil,
+      local_folder: self.local_folder,
+      &block
+    )
+      remote_files = with_remote_files(subfolder: subfolder, pattern: pattern)
+      return [] if remote_files.empty?
+
+      file_names = remote_files.map {|file| to_remote_path(file.name, subfolder: subfolder)}
+
+      log(:info) {
+        msg  = "Getting the following files into the local folder '#{local_folder}':\n"
+        msg << '  * '
+        msg << file_names.join("\n  * ")
+        msg
+      }
+
+      sftp.download(file_names, local_folder: local_folder, &block)
+    end
+
+    def sftp_move_file(source, dest)
+      sftp.move(source, dest, 0x0001) do |response|
+        if response.ok?
+          log(:info) { "#{source}\n  -to-> #{dest}"    }
+        else
+          log(:info) { "Could not move file #{source}" }
+        end
+      end
+    end
+
+    def sftp_archive_file!(filename, folder: 'Archive')
+      basename       = File.basename(filename)
+      remote_file    = to_remote_path(basename)
+      archive_folder = to_remote_path(folder)
+      archived_file  = "#{archive_folder}/#{basename}"
+
+      sftp_move_file(remote_file, archived_file)
+    end
+
+    def remove_local_n_remote_file(file)
+      full_path = File.expand_path(file)
+      filename  = File.basename(full_path)
+
+      if File.exist?(full_path)
+        File.delete(full_path).tap do
+          log(:info) { "Deleted file '#{full_path}'" }
+        end
+      end
+
+      sftp_archive_file!(filename)
+    end
+
+    def ensure_remote_empty(subfolder: remote_subfolder, pattern: nil)
+      files = with_remote_files(subfolder: subfolder, pattern: pattern)
+      return if files.empty?
+
+      msg  = "There are still files in the remote folder that will be deleted: '#{subfolder}':\n"
+      msg << '  * '
+      str  = files.map(&:longname).join("\n  * ")
+      str << "\n"
+      msg << str
+
+      session.prompt_user(
+        'Do you want to proceed to delete? (Y/n):',
+        explanation: msg,
+        default:     'Y',
+        timeout:     3
+      ) do |response|
+        next unless response.upcase.start_with?('Y')
+
+        files.each do |file|
+          remote_full_path = to_remote_path(file.name, subfolder: subfolder)
+          res              = sftp_session.remove(remote_full_path)
+          log(:info) {
+            "Deleted remote file: '#{remote_full_path}' (#{res})"
+          }
+        end
+      end
+    end
+
+    def local_folder
+      if (local_dir = options.dig(:sftp, :local_folder))
+        local_dir
+      elsif self.class.const_defined?(:LOCAL_FOLDER)
+        self.class::LOCAL_FOLDER
+      else
+        '.'
+      end
+    end
+
+    def to_remote_path(file, subfolder: remote_subfolder)
+      [remote_folder(subfolder), file].join('/')
+    end
+
+    # `remote_target_folder` overrides `sftp_config.remote_folder` as well as `remote_subfolder`
+    # `remote_folder` overrides `sftp_config.remote_folder` but NOT `remote_subfolder`
+    def remote_folder(subfolder = remote_subfolder)
+      rm_tf = options.dig(:sftp, :remote_target_folder)
+      return rm_tf if rm_tf
+
+      rm_fd = options.dig(:sftp, :remote_folder) || sftp_config.remote_folder
+      [rm_fd, subfolder].compact.join('/')
+    end
+
+    def remote_subfolder(required: true)
+      remote_subdir   = options.dig(:sftp, :remote_subfolder)
+      remote_subdir ||= self.class::REMOTE_FOLDER    if self.class.const_defined?(:REMOTE_FOLDER)
+      remote_subdir ||= self.class::REMOTE_SUBFOLDER if self.class.const_defined?(:REMOTE_SUBFOLDER)
+      return remote_subdir if remote_subdir
+      return               unless required
+
+      msg  = "(#{self.class}) You should redefine #remote_subfolder or REMOTE_FOLDER"
+      msg << 'as the folder where the target file sits. Ex: IN/Personnel'
+      raise UnspecifiedRemoteFolder, msg
+    end
+
+    # @param subfolder [String] the subfolder.
+    def with_remote_files(subfolder: remote_subfolder, pattern: nil)
+      sftp.files(remote_folder(subfolder), pattern: pattern).each do |remote_file|
+        yield(remote_file) if block_given?
+      end
+    rescue ArgumentError
+      raise
+    rescue ::Net::SFTP::StatusException => err
+      log(:error) {
+        msg  = "(#{self.class}) There was an error trying to access "
+        msg << "the remote folder '#{subfolder}': #{err}"
+        msg
+      }
+      []
+    end
+
+    def sftp_config
+      session.config.sftp
+    end
+
+    def sftp_session
+      sftp.sftp_session
+    end
+
+    def sftp
+      session.sftp
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Eco
+  module API
+    class UseCases
+      module Lib
+      end
+    end
+  end
+end
+
+require_relative 'lib/error_handling'
+require_relative 'lib/sftp'
+require_relative 'lib/file_pattern'

data/lib/eco/api/usecases/ooze_samples/helpers/rescuable.rb

@@ -29,7 +29,7 @@ module Eco
                   else res.start_with?("C")
                     log(:warn) {
                       msg  = "Script resumed after error..."
-                      msg << "\n  • #{reference}"
+                      msg << "\n  * #{reference}"
                     }
                     nil
                   end

data/lib/eco/api/usecases/ooze_samples/helpers_migration/typed_fields_pairing.rb

@@ -46,7 +46,7 @@ class Eco::API::UseCases::OozeSamples
         end
         return nil if src_filtered.empty?
         msg << src_filtered.map do |src_fld|
-          "  • #{object_reference(src_fld)}"
+          "  * #{object_reference(src_fld)}"
         end.join("\n")
       end
 
@@ -60,7 +60,7 @@ class Eco::API::UseCases::OozeSamples
         end
         return nil if dst_filtered.empty?
         msg << dst_filtered.map do |dst_fld|
-          "  • #{object_reference(dst_fld)}"
+          "  * #{object_reference(dst_fld)}"
         end.join("\n")
       end
 
@@ -76,9 +76,9 @@ class Eco::API::UseCases::OozeSamples
                 dst_exclude_ximport && ximport?(dst_fld)
               end
               next if dst_filtered.empty?
-              msg_flds << "  • #{object_reference(src_fld)}\n"
+              msg_flds << "  * #{object_reference(src_fld)}\n"
               msg_flds << dst_filtered.map do |dst_fld|
-                "    • #{object_reference(dst_fld)}"
+                "    * #{object_reference(dst_fld)}"
               end.compact.join("\n")
             end
           end

data/lib/eco/api/usecases/ooze_samples/register_update_case.rb

@@ -108,8 +108,8 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
       msg = "Something is wrong. Native case 'RegisterUpdateCase' is "
       if (elem != object) && dirty?(elem)
         msg << "trying to queue different objects with same page id:\n"
-        msg << " • already queued (changes will go): #{object_reference(elem)}\n"
-        msg << " • tried to queue (lost changes): #{object_reference(object)}"
+        msg << " * already queued (changes will go): #{object_reference(elem)}\n"
+        msg << " * tried to queue (lost changes): #{object_reference(object)}"
         log(:warn) { msg }
       end
     else
@@ -234,13 +234,13 @@ class Eco::API::UseCases::OozeSamples::RegisterUpdateCase < Eco::API::UseCases::
   def kpis_message
     msg  = []
     msg << "Run end:"
-    msg << "  • Search results: #{total_search_oozes}"
-    msg << "  • Duplicated search results #{dupped_search_oozes}"
-    msg << "  • Retrieved a total of #{retrieved_oozes}"
-    msg << "  • Could not get #{non_retrieved_oozes} oozes."
-    msg << "  • Updated #{updated_oozes} oozes (attempted: #{attempted_ooze_updates})."
+    msg << "  * Search results: #{total_search_oozes}"
+    msg << "  * Duplicated search results #{dupped_search_oozes}"
+    msg << "  * Retrieved a total of #{retrieved_oozes}"
+    msg << "  * Could not get #{non_retrieved_oozes} oozes."
+    msg << "  * Updated #{updated_oozes} oozes (attempted: #{attempted_ooze_updates})."
     msg << "    - Failed update on #{failed_update_oozes} oozes."
-    msg << "  • Created #{created_oozes} oozes (out of: #{ooze_create_attempts})."
+    msg << "  * Created #{created_oozes} oozes (out of: #{ooze_create_attempts})."
     msg.join("\n")
   end
 

data/lib/eco/api/usecases/samples/drivers/sftp_sample.rb

@@ -1,13 +1,12 @@
 # rubocop:disable Naming/AccessorMethodName
 class Eco::API::UseCases::Samples::Drivers::Sftp < Eco::API::Common::Loaders::UseCase
-  class WrongConst < ArgumentError; end
-  class MissRemoteFolder < ArgumentError; end
-
   require_relative 'cli/sftp_cli'
+
   name 'sftp'
   type :other
 
-  CONST_REFERRAL = /^(?:::)?(?:[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*)$/
+  include Eco::API::UseCases::Lib::Sftp
+  include Eco::API::UseCases::Lib::FilePattern
 
   def main(session, options, _usecase)
     options[:end_get] = false
@@ -27,81 +26,13 @@ class Eco::API::UseCases::Samples::Drivers::Sftp < Eco::API::Common::Loaders::Us
 
   private
 
-  # Can't pass this via CLI option, as it breaks the regular expression
-  def file_pattern(require: true)
-    fpc = file_pattern_const
-    return fpc if fpc
-    return     unless require
-
-    msg  = "(#{self.class}) You should redefine the file_pattern function "
-    msg << 'as a RegEx expression that matches the target remote file'
-    raise WrongConst, msg
-  end
-
-  def file_pattern_const
-    if (fpc = options.dig(:sftp, :file_pattern_const))
-      raise WrongConst, "(#{self.class}) Invalid file pattern const referral: #{fpc}" unless fpc.match(CONST_REFERRAL)
-
-      begin
-        self.eval(fpc)
-      rescue NameError
-        self.class.const_get(fpc)
-      end
-    end
-  rescue NameError
-    raise WrongConst, "(#{self.class}) Unknown constant: #{fpc}"
-  end
-
-  # Ex: '/IN/Personnel'
-  def remote_subfolder(require: true)
-    rm_sf = options.dig(:sftp, :remote_subfolder)
-
-    return rm_sf if rm_sf
-    return unless require
-
-    msg  = "(#{self.class}) You should redefine remote_subfolder "
-    msg << 'as the folder where the target file sits. Ex: /IN/Personnel'
-    raise MissRemoteFolder, msg
-  end
-
-  # `remote_target_folder` overrides `sftp_config.remote_folder` as well as `remote_subfolder`
-  # `remote_folder` overrides `sftp_config.remote_folder` but NOT `remote_subfolder`
-  def remote_folder
-    rm_tf   = options.dig(:sftp, :remote_target_folder)
-    rm_fd   = options.dig(:sftp, :remote_folder) || sftp_config.remote_folder
-    rm_tf || [rm_fd, remote_subfolder].compact.join('/')
-  end
-
-  def to_remote_path(file)
-    [remote_folder, file].compact.join('/')
-  end
-
-  def local_folder
-    options.dig(:sftp, :local_folder) || '.'
-  end
-
-  def with_remote_files(folder: remote_folder, pattern: file_pattern)
-    sftp.files(folder, pattern: pattern).each do |remote_file|
-      yield(remote_file) if block_given?
-    end
-  rescue ArgumentError
-    raise
-  rescue ::Net::SFTP::StatusException => err
-    log(:error) {
-      msg  = "(#{self.class}) There was an error trying to access "
-      msg << "the remote folder '#{remote_folder}': #{err}"
-      msg
-    }
-    []
-  end
-
   def list_folder
     puts "Listing remote folder: '#{remote_folder}' (host: #{sftp.host}):"
-    with_remote_files {|file| puts file.longname}
+    with_remote_files(pattern: file_pattern) {|file| puts file.longname}
   end
 
   def get_files
-    with_remote_files.tap do |files|
+    with_remote_files(pattern: file_pattern).tap do |files|
       next if files.empty?
 
       file_names = files.map {|file| to_remote_path(file.name)}
@@ -114,7 +45,7 @@ class Eco::API::UseCases::Samples::Drivers::Sftp < Eco::API::Common::Loaders::Us
   end
 
   def get_last
-    with_remote_files.last.tap do |file|
+    with_remote_files(pattern: file_pattern).last.tap do |file|
       next unless file
 
       file_name = to_remote_path(file.name)
@@ -125,10 +56,10 @@ class Eco::API::UseCases::Samples::Drivers::Sftp < Eco::API::Common::Loaders::Us
   end
 
   def archive_files
-    with_remote_files do |file|
+    with_remote_files(pattern: file_pattern) do |file|
       source = to_remote_path(file.name) # should probably be file.longname
       dest   = to_remote_path("#{archive_subfolder}/#{file.name}")
-      move_file(source, dest)
+      sftp_move_file(source, dest)
     end.tap do |files|
       next if files.empty?
 
@@ -136,27 +67,9 @@ class Eco::API::UseCases::Samples::Drivers::Sftp < Eco::API::Common::Loaders::Us
     end
   end
 
-  def move_file(source, dest)
-    sftp.move(source, dest, 0x0001) do |response|
-      if response.ok?
-        puts "#{source}\n  -to-> #{dest}"
-      else
-        puts "Could not move file #{source}"
-      end
-    end
-  end
-
   def archive_subfolder
     'Archive'
   end
-
-  def sftp_config
-    session.config.sftp
-  end
-
-  def sftp
-    session.sftp
-  end
 end
 
 # rubocop:enable Naming/AccessorMethodName

data/lib/eco/api/usecases/samples/drivers/url_pull_sample.rb

@@ -1,6 +1,5 @@
 class Eco::API::UseCases::Samples::Drivers::UrlPull < Eco::API::Common::Loaders::UseCase
   class WrongConst < ArgumentError; end
-  # class MissRemoteFolder < ArgumentError; end
 
   require_relative 'cli/url_pull_cli'
   name 'url-pull'

data/lib/eco/api/usecases/samples.rb

@@ -8,4 +8,3 @@ module Eco
 end
 
 require_relative 'samples/drivers'
-

data/lib/eco/api/usecases.rb

@@ -176,6 +176,7 @@ require_relative 'usecases/use_case_chain'
 require_relative 'usecases/base_io'
 require_relative 'usecases/use_case_io'
 require_relative 'usecases/cli'
+require_relative 'usecases/lib'
 require_relative 'usecases/graphql'
 require_relative 'usecases/default'
 require_relative 'usecases/samples'

data/lib/eco/data/locations/node_base/tag_validations.rb

@@ -17,11 +17,11 @@ module Eco::Data::Locations::NodeBase
         if partial != str
           invalid_chars = identify_invalid_characters(str)
           log(:warn) {
-            "• #{ref}Invalid characters _#{invalid_chars}_ <<_removed_: '#{str}' :_converted_>> '#{result}'"
+            "* #{ref}Invalid characters _#{invalid_chars}_ <<_removed_: '#{str}' :_converted_>> '#{result}'"
           }
         elsif blanks_x2
           log(:warn) {
-            "• #{ref}Double blanks removed: '#{str}' :_converted_>> '#{result}'"
+            "* #{ref}Double blanks removed: '#{str}' :_converted_>> '#{result}'"
           }
         end
         invalid_warned!(str)

data/lib/eco/data/locations/node_base/treeify.rb

@@ -141,8 +141,8 @@ module Eco::Data::Locations::NodeBase
         msg = []
         msg << "BUG in this library (open issue with maintainers)."
         msg << "There were no skipped nodes nor missin referred parents, and yet:"
-        msg << "  • the tree nodes count: #{done_ids.count} ..."
-        msg << "  • doesn't match the original nodes count: #{nodes.count}"
+        msg << "  * the tree nodes count: #{done_ids.count} ..."
+        msg << "  * doesn't match the original nodes count: #{nodes.count}"
         raise msg.join("\n")
       end
 
@@ -151,11 +151,11 @@ module Eco::Data::Locations::NodeBase
 
         msg = []
         msg << "There are #{unlinked_parent_ids.count} referred parent_id's NOT linked to the root:"
-        msg << "  • total_nodes: #{nodes.count}"
-        msg << "  • tracked_nodes: #{tracked_nodes.count}"
-        msg << "  • untracked_nodes: #{untracked_nodes.count}"
-        msg << "  • unlinked_parents: #{unlinked_parent_ids.count}"
-        msg << "  • skipped (repeated) nodes: #{skipped.count}#{str_skipped}" unless skipped.empty?
+        msg << "  * total_nodes: #{nodes.count}"
+        msg << "  * tracked_nodes: #{tracked_nodes.count}"
+        msg << "  * untracked_nodes: #{untracked_nodes.count}"
+        msg << "  * unlinked_parents: #{unlinked_parent_ids.count}"
+        msg << "  * skipped (repeated) nodes: #{skipped.count}#{str_skipped}" unless skipped.empty?
         warns << msg.join("\n")
 
         unlinked_nodes   = nodes - skipped
@@ -182,16 +182,16 @@ module Eco::Data::Locations::NodeBase
 
         msg = []
         msg << "After treeifying via the unlinked_parents:"
-        msg << "  • total_nodes: #{nodes.count}"
-        msg << "  • tracked_nodes: #{tracked_nodes.count}"
-        msg << "  • untracked_nodes: #{untracked_nodes.count}"
-        msg << "  • missing_parents: #{str_unlinked_parents}"
-        msg << "  • skipped in this step: #{residual_skipped.count}#{str_skipped}" unless residual_skipped.empty?
+        msg << "  * total_nodes: #{nodes.count}"
+        msg << "  * tracked_nodes: #{tracked_nodes.count}"
+        msg << "  * untracked_nodes: #{untracked_nodes.count}"
+        msg << "  * missing_parents: #{str_unlinked_parents}"
+        msg << "  * skipped in this step: #{residual_skipped.count}#{str_skipped}" unless residual_skipped.empty?
         warns << msg.join("\n")
       end
 
       str_skipped = (skipped.count < 15 ? " => #{skipped.map(&:id).join(', ')}" : '')
-      warns << "  • total skipped (repeated) nodes: #{skipped.count}!!#{str_skipped}" unless skipped.empty?
+      warns << "  * total skipped (repeated) nodes: #{skipped.count}!!#{str_skipped}" unless skipped.empty?
       nil
     end
 
@@ -205,7 +205,7 @@ module Eco::Data::Locations::NodeBase
       parent_ids         = parents.keys & node_ids
       missing_parent_ids = parents.keys - parent_ids
       missing_parents    = parents.slice(*missing_parent_ids)
-      warns             << "  • missing_parents: #{missing_parents.count}"
+      warns             << "  * missing_parents: #{missing_parents.count}"
 
       nil_parent_nodes = missing_parents.each_with_object([]) do |(_id, nds), mem|
         nds.each {|node| node.parent_id = nil}
@@ -285,7 +285,7 @@ module Eco::Data::Locations::NodeBase
       if (prev_parent || prev_level) && node_dup # && !done_node
         str  = "Integrity issue in Treeify. "
         str << "A Node with tracked level or parent should be present in done_ids, but it isn't."
-        str << "\n • #{node_str}."
+        str << "\n * #{node_str}."
         raise str
       end
       # From here on, do NOT expect `node_dup` where `node` has tracked `parent` or `level`.
@@ -300,7 +300,7 @@ module Eco::Data::Locations::NodeBase
       if lev_dup && (multi_parent || !done_node || done_node.tracked_level != lev)
         str  = "Integrity issue in Treeify. "
         str << "A Node with ID already in level_ids should have same tracked_level as current level."
-        str << "\n • #{node_str}."
+        str << "\n * #{node_str}."
         raise str
       end
       # From here on, do NOT expect `lev_up` where there isn't `done_node` or it has different level or parent.
@@ -325,7 +325,7 @@ module Eco::Data::Locations::NodeBase
       unless cyclic || double_up
         str  = "Integrity issue in Treeify. "
         str << "Skipping is only applicable to double_ups or cyclic nodes."
-        str << "\n • #{node_str}."
+        str << "\n * #{node_str}."
         raise str
       end
 

data/lib/eco/data/locations/node_diff/nodes_diff.rb

@@ -73,35 +73,35 @@ class Eco::Data::Locations::NodeDiff
 
       msg << "Identified #{diffs.count} differences #{comp}:"
       msg << when_present(insert) do |count|
-        "  • #{count} nodes to insert"
+        "  * #{count} nodes to insert"
       end
 
       msg << when_present(update) do |count|
-        "  • #{count} nodes to update"
+        "  * #{count} nodes to update"
       end
 
       msg << when_present(unarchive) do |count|
-        "    • #{count} nodes to unarchive (includes ancestors of target nodes)"
+        "    * #{count} nodes to unarchive (includes ancestors of target nodes)"
       end
 
       msg << when_present(id) do |count|
-        "    • #{count} nodes to change id\n"
+        "    * #{count} nodes to change id\n"
       end
 
       msg << when_present(name) do |count|
-        "    • #{count} nodes to change name"
+        "    * #{count} nodes to change name"
       end
 
       msg << when_present(classifications) do |count|
-        "    • #{count} nodes to change classifications"
+        "    * #{count} nodes to change classifications"
       end
 
       msg << when_present(move) do |count|
-        "    • #{count} nodes to move"
+        "    * #{count} nodes to move"
       end
 
       msg << when_present(archive) do |count|
-        "  • #{count} nodes to archive"
+        "  * #{count} nodes to archive"
       end
 
       msg.compact.join("\n")

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

@@ -11,7 +11,7 @@ class Eco::Data::Locations::NodeLevel
     #   3. It covers the gap if present by decoupling merged parent(s) from the same node (see node.decouple)
     #   4. Then, it delegates the filling in of parents to `fill_in_parents` function.
     # @return [Array<NodeLevel>] child to parent relationships solved and no double-ups.
-    def tidy_nodes(nodes, prev_node: nil, main: true)
+    def tidy_nodes(nodes, prev_node: nil, main: true) # rubocop:disable Metrics/AbcSize
       reset_trackers! if main
 
       prev_level = prev_node&.actual_level || 0
@@ -30,13 +30,16 @@ class Eco::Data::Locations::NodeLevel
             msg = "(Row: #{node.row_num}) ID/Tag '#{node.id}' (lev #{level}) jumps #{gap} level(s) (expected #{prev_level + 1})."
             #puts "  " + node.tags_array.pretty_inspect
             missing_nodes = node.decouple(gap)
-            msg << "\n  Adding missing upper node(s): " + missing_nodes.map(&:raw_tag).pretty_inspect
+            msg << "\n  Adding missing upper node(s): "
+            msg << missing_nodes.map(&:raw_tag).pretty_inspect
+
             log(:debug) { msg }
             # 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_node: prev_node, main: false)
             out.push(*tidied_nodes)
           end
+
           out       << node
           done_ids  << node.id
           prev_node  = node
@@ -53,21 +56,23 @@ class Eco::Data::Locations::NodeLevel
     # Although with normalized nodes parents are self-contained
     # we use this method
     def fill_in_parents(nodes)
-      nodes.tap do |nodes|
+      nodes.tap do
         prev_nodes = empty_level_tracker_hash(11)
         nodes.each do |node|
           expected_parent_id = node.clean_parent_id&.upcase
-          msg  = "Expecting node '#{node.id}' to have parent: '#{expected_parent_id}'\n"
-          if parent_node = prev_nodes[node.actual_level - 1]
+          msg = "Expecting node '#{node.id}' to have parent: '#{expected_parent_id}'\n"
+          if (parent_node = prev_nodes[node.actual_level - 1])
             node.parentId = parent_node.id
-            log(:warn) {
-              msg + " • We got '#{parent_node.id}' instead"
-            } unless expected_parent_id == node.parentId
+            unless expected_parent_id == node.parentId
+              log(:warn) {
+                msg + " * We got '#{parent_node.id}' instead"
+              }
+            end
           elsif node.actual_level == 1
             # expected to not have parent
           else
             log(:warn) {
-              msg + "but we did not get parent."
+              "#{msg} but we did not get parent."
             }
           end
           prev_nodes[node.actual_level] = node