eco-helpers 2.5.8 → 2.5.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28c284a7c27d048f79b4f3b08b7c5fabca039fe1c3840809c7b608b024ba666b
-  data.tar.gz: 42218a8878c3b3ffb937c4bc66d0b8227ba8b44771e7047a4bb6bf2fdbcf34e7
+  metadata.gz: 1f78310ad18a148ef707c1735932215754c047041fd3a1539a1434a9d213427d
+  data.tar.gz: 8d795944674e2cb2148a796ca1c1aa0817f342c5ffb9228ef22a99fe3cc39179
 SHA512:
-  metadata.gz: 0a7f9160a34384831722dc1552d50dd70fb039df2110f675c9e9083143e59f33263669b532c3f000d3a12d09568f95b9c7933a5e89175b6870595cb6f55c98bb
-  data.tar.gz: 5ba00795fc3cded86e5fe820385355153dfa51ab4ddac0e84a8a00cdd01d1db66ddf238c0ad0debae0ae107f584324f5ca941453ff79b9d1e8f7d52009046b83
+  metadata.gz: 88cbb36569c4683decb9210d9db4ed2da2e205c8d06f170707b15cb9085fa111d39407eefd495211022129c4532172fd69bebe266123ab9a10c4663f2c83a940
+  data.tar.gz: 49795a3e5c994e1d0a74f46257865062501ed0b400fba66a9de1e81c6b3826a3a7f71ebd2e46df48a0d13577cafc677d23e7b60ff9768a42229f18bec4cce703

data/.gitignore

@@ -18,3 +18,4 @@ Gemfile.lock
 # rspec failure tracking
 .rspec_status
 scratch.rb
+.byebug_history

data/CHANGELOG.md

@@ -1,12 +1,51 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
-## [2.5.9] - 2023-08-xx
+## [2.5.10] - 2023-09-xx
 
 ### Added
 ### Changed
 ### Fixed
 
+## [2.5.9] - 2023-09-01
+
+The input **csv** of trees could come very compacted, which had unintended consequences.
+  - This is a fix to this scenario.
+
+### Added
+  - `Eco::Data::Locations::NodeLevel#raw_latest_consecutive_top_empty_level`
+    - To scope the missing ancestors (up to what level)
+  - `Eco::API::UseCases::DefaultCases::Samples::Sftp`
+    - Options for `remote_subfolder`, `remote_target_folder` and `remote_folder`
+  - `Eco::API::Organization::People#updated_or_created` **method**
+    - Scoping all people that have been updated as part of the current session.
+    - Note that it includes also those that are hris excluded.
+  - **Improvement** on `Eco::API::Common::Loaders::Base`
+    - Should be able to call `log(:level) { "Some message" }`
+
+### Changed
+  - `Eco::Data::Locations::NodeLevel`
+    - **removed** `#merge!` and `#override_upper_levels`
+    - `#override_lower_levels` **renamed** to `#update_lower_levels`
+  - `Eco::API::UseCases::DefaultCases::CsvToTree` use case
+    - Moved to work with `Eco::Data::Locations::DSL`
+    - **Removed** helpers double-ups.
+  - Default workflow `on(:report)`: implementation of `-processed-people-to-csv`
+    - It now only includes people created or updated as part of the current session.
+  - **Improvement**: `Eco::API::Common::Loaders::Parser` made `serializer` method **not required**
+    - This aims to use the default serializer definition
+    - Made **inheritable** `parsing_phase` and `serializing_phase`
+
+### Fixed
+  - `Eco::Data::Locations::NodeLevel#update_lower_levels`
+    - To use `#raw_latest_consecutive_top_empty_level`
+    - Compact from first filled in `tags_array` onwards (preserve empty tags at the beginning for clean validation)
+  - `Eco::Data::Locations::NodeLevel::Cleaner`
+    - `#tidy_nodes` **gap** calculation is scoped against previous node (common ancestors)
+    - `#fill_in_parents` to give feedback on unexpected parental relationship
+  - `Eco::API::UseCases::DefaultCases::Samples::Sftp`
+    - Prevent double slashed paths
+
 ## [2.5.8] - 2023-08-28
 
 ### Changed

data/eco-helpers.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "yard",      ">= 0.9.26", "< 1"
   spec.add_development_dependency "redcarpet", ">= 3.5.1",  "< 4"
 
-  spec.add_dependency 'ecoportal-api', '>= 0.9.4', '< 0.10'
+  spec.add_dependency 'ecoportal-api', '>= 0.9.5', '< 0.10'
   spec.add_dependency 'ecoportal-api-v2', '>= 1.1.3', '< 1.2'
   spec.add_dependency 'ecoportal-api-graphql', '>= 0.3.10', '< 0.4'
   spec.add_dependency 'aws-sdk-s3',    '>= 1.83.0', '< 2'

data/lib/eco/api/common/loaders/base.rb

@@ -4,6 +4,7 @@ module Eco
       module Loaders
         class Base
           extend Eco::API::Common::ClassHelpers
+          include Eco::Language::AuxiliarLogger
 
           class << self
             # Sort order
@@ -47,10 +48,6 @@ module Eco
             session.config
           end
 
-          def logger
-            session.logger
-          end
-
           def micro
             session.micro
           end

data/lib/eco/api/common/loaders/parser.rb

@@ -101,10 +101,9 @@ module Eco
                 keys = []
               end
             end
-
           end
 
-          inheritable_class_vars :attribute
+          inheritable_class_vars :attribute, :parsing_phase, :serializing_phase
 
           def initialize(person_parser)
             raise "Expected Eco::API::Common::People::PersonParser. Given #{policies.class}" unless person_parser.is_a?(Eco::API::Common::People::PersonParser)
@@ -127,9 +126,9 @@ module Eco
           #   - when `:final`: it will receive a `Hash` with the **internal values** and **types**.
           #   - when `:person`: it will receive the `person` object.
           # @param deps [Hash] the merged dependencies (default to the class object and when calling the parser).
-          def seralizer(data, deps)
-            raise "You should implement this method"
-          end
+          # def serializer(data, deps)
+          #   raise "You should implement this method"
+          # end
 
           # @return [String, Symbol] the field/attribute or type this parser is linked to.
           def attribute
@@ -147,6 +146,7 @@ module Eco
           end
 
           def _define_serializer(attr_parser)
+            return unless respond_to?(:serializer, true)
             attr_parser.def_serializer(self.class.serializing_phase, &self.method(:serializer))
           end
         end

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

@@ -80,6 +80,15 @@ module Eco
           account_present(false)
         end
 
+        # Returns the people that are being or have been updated and/or created.
+        def updated_or_created
+          select do |person|
+            !person.as_update(:total).empty?
+          end.yield_self do |persons|
+            newFrom persons
+          end
+        end
+
         def supervisors
           sup_ids = self.ids & self.supervisor_ids
           sup_ids.map do |id|

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

@@ -74,7 +74,7 @@ module Eco
             session:  self.session,
             options:  self.options,
             validate: true
-          }.merge(kargs)
+          }
           self.class.new(**default.merge(kargs))
         end
 

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

@@ -2,27 +2,36 @@ class Eco::API::UseCases::DefaultCases::CsvToTree < Eco::API::Common::Loaders::U
   name "csv-to-tree"
   type :other
 
+  include Eco::Data::Locations::DSL
+
   TIME_FORMAT = '%Y%m%dT%H%M%S'
 
   def main(session, options, usecase)
     options[:end_get] = false
-    tree_struct = Helper.treeify(Helper.csv_nodes(input_file))
+    tree_struct = org_tree(input_csv)
 
     File.open(output_file, "w") do |fd|
-      json = tree_struct.to_json
-      fd <<  json
+      fd << tree_struct.as_json.to_json
     end
     logger.info("Saved structure in '#{output_file}'")
   end
 
   private
 
+  def output_file
+    @output_file ||= "#{active_enviro}_tree_#{timestamp}.json"
+  end
+
+  def input_csv
+    @input_csv ||= Eco::CSV.read(input_file, encoding: input_encoding)
+  end
+
   def input_file
     @input_file   ||= options.dig(:source, :file)
   end
 
-  def output_file
-    @output_file ||= "#{active_enviro}_tree_#{timestamp}.json"
+  def input_encoding
+    options.dig(:input, :file, :encoding) || 'utf-8'
   end
 
   def timestamp(date = Time.now)
@@ -33,8 +42,3 @@ class Eco::API::UseCases::DefaultCases::CsvToTree < Eco::API::Common::Loaders::U
     config.active_enviro
   end
 end
-
-require_relative 'csv_to_tree_case/node'
-require_relative 'csv_to_tree_case/nodes_cleaner'
-require_relative 'csv_to_tree_case/treeify'
-require_relative 'csv_to_tree_case/helper'

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

@@ -2,10 +2,9 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
   name "sftp-sample"
   type :other
 
-  attr_reader :session, :options
+  CONST_REFERRAL = /^(?:::)?(?:[A-Z][a-zA-Z0-9_]*(?:::[A-Z][a-zA-Z0-9_]*)*)$/
 
   def main(session, options, usecase)
-    @session = session; @options = options
     options[:end_get] = false
     raise "The SFTP is not configured" unless session.sftp?
     case options.dig(:sftp, :command)
@@ -22,17 +21,41 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
 
   private
 
+  # Can't pass this via CLI option, as it breaks the regular expression
   def file_pattern
+    fpc = file_pattern_const
+    return fpc if fpc
     raise "You should redefine the file_pattern function as a RegEx expression that matches the target remote file"
   end
 
+  def file_pattern_const
+    if fpc = options.dig(:sftp, :file_pattern_const)
+      raise "Invalid file pattern const referral: #{fpc}" unless fpc.match(CONST_REFERRAL)
+      self.eval(fpc)
+    end
+  end
+
   # Ex: "/IN/Personnel"
   def remote_subfolder
+    rm_sf = options.dig(:sftp, :remote_subfolder)
+    return rm_sf if rm_sf
     raise "You should redefine remote_subfolder as the folder where the target file sits. Ex: /IN/Personnel"
   end
 
-  def archive_subfolder
-    "Archive"
+  # `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 || File.join(rm_fd, remote_subfolder)
+  end
+
+  def to_remote_path(file)
+    File.join(remote_folder, file)
+  end
+
+  def local_folder
+    options.dig(:sftp, :local_folder) || "."
   end
 
   def with_remote_files
@@ -92,16 +115,8 @@ class Eco::API::UseCases::DefaultCases::Samples::Sftp < Eco::API::Common::Loader
     end
   end
 
-  def to_remote_path(file)
-    remote_folder + "/" + file
-  end
-
-  def local_folder
-    options.dig(:sftp, :local_folder) || "."
-  end
-
-  def remote_folder
-    @remote_folder ||= sftp_config.remote_folder + remote_subfolder
+  def archive_subfolder
+    "Archive"
   end
 
   def sftp_config

data/lib/eco/cli/config/default/workflow.rb

@@ -153,14 +153,16 @@ ASSETS.cli.config do |config|
     end
 
     wf.on(:report) do |wf_report, io|
-      if file = io.options.dig(:report, :people, :csv)
-        io.options.deep_merge!(export: {
-          options: {internal_names: true, nice_header: true, split_schemas: true},
-          file: {name: file, format: :csv}
-        })
-        io = io.session.process_case("to-csv", io: io, type: :export)
+      io.tap do |_io|
+        if file = io.options.dig(:report, :people, :csv)
+          io.options.deep_merge!(export: {
+            options: {internal_names: true, nice_header: true, split_schemas: true},
+            file: {name: file, format: :csv}
+          })
+          aux_io = io.new(people: io.people.updated_or_created)
+          io.session.process_case("to-csv", io: aux_io, type: :export)
+        end
       end
-      io
     end
 
     wf.on(:end) do |wf_end, io|

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

@@ -6,10 +6,11 @@ module Eco::Data::Locations::NodeBase
     VALID_TAG_CHARS    = /[#{ALLOWED_CHARACTERS}]+/
     DOUBLE_BLANKS      = /\s\s+/
 
-    def clean_id(str)
+    def clean_id(str, notify: true)
       blanks_x2 = has_double_blanks?(str)
       partial   = replace_not_allowed(str)
       remove_double_blanks(partial).tap do |result|
+        next unless notify
         next if invalid_warned?
         if partial != str
           invalid_chars = identify_invalid_characters(str)

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

@@ -22,6 +22,10 @@ module Eco::Data::Locations
       self.send(sym.to_sym)
     end
 
+    def attr?(sym)
+      !attr(sym).to_s.strip.empty?
+    end
+
     def set_attrs(**kargs)
       kargs.each {|attr, value| set_attr(attr, value)}
       self

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

@@ -11,36 +11,41 @@ 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_level: 0, main: true)
+    def tidy_nodes(nodes, prev_node: nil, main: true)
       reset_trackers! if main
+
+      prev_level = prev_node&.actual_level || 0
+
       nodes.each_with_object([]) do |node, out|
-        node_id = node.id
-        if done_ids.include?(node_id)
-          repeated_ids << "#{node_id} (level: #{node.level})"
+        if done_ids.include?(node.id)
+          row_str = node.row_num ? " - (row: #{node.row_num})" : ''
+          repeated_ids << "#{node.id} (level: #{node.level})#{row_str}"
         else
           level = node.actual_level
-          if level > prev_level + 1
-            gap = level - (prev_level + 1)
-            msg = "(Row: #{node.row_num}) ID/Tag '#{node_id}' (lev #{level}) jumps #{gap} level(s) (expected #{prev_level + 1})."
+          common_level   = node.common_level_with(prev_node)
+          common_level ||= prev_level
+          gap            = level - (common_level + 1)
+
+          unless gap < 1
+            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 level(s): " + missing_nodes.map(&:raw_tag).pretty_inspect
-            log(:info) { msg }
-
+            msg << "\n  Adding missing upper node(s): " + 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_level: prev_level, main: false)
+            tidied_nodes = tidy_nodes(missing_nodes, prev_node: prev_node, 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
-          prev_level = level
+          done_ids  << node.id
+          prev_node  = node
+        end
+      end.tap do |out|
+        if main
+          report_repeated_node_ids(repeated_ids)
+          fill_in_parents(out)
         end
-      end.yield_self do |out|
-        report_repeated_node_ids(repeated_ids) if main
-        fill_in_parents(out)
       end
     end
 
@@ -51,10 +56,21 @@ class Eco::Data::Locations::NodeLevel
       nodes.tap do |nodes|
         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]
             node.parentId = parent_node.id
+            log(:warn) {
+              msg + " • We got '#{parent_node.id}' instead"
+            } unless expected_parent_id == node.parentId
+          elsif node.actual_level == 1
+            # expected to not have parent
+          else
+            log(:warn) {
+              msg + "but we did not get parent."
+            }
           end
-          prev_nodes[node.raw_level] = node
+          prev_nodes[node.actual_level] = node
         end
       end
     end

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

@@ -30,17 +30,11 @@ 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)
 
+      first = true
       nodes = csv.each_with_object([]) do |row, out|
         row_num, *values = row.fields
         node = node_class.new(row_num, *values)
@@ -53,16 +47,15 @@ class Eco::Data::Locations::NodeLevel
           # which allows to node#actual_level to work
           node.set_high_levels(prev_node)
         else
-          if parent_node = prev_node_get[node.raw_level - 1]
-            node.set_high_levels(parent_node)
-          elsif node.raw_level == 1
+          if node.raw_level == 1
             # It is expected not to have parent (as it's top level tag)
+          elsif prev_node
+            node.set_high_levels(prev_node)
           else
             raise "Node '#{node.raw_tag}' (#{node.row_num} row) doesn't have parent"
           end
         end
         out << node
-        prev_nodes[node.raw_level] = node
         prev_node = node
       end
       tidy_nodes(nodes)

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

@@ -54,6 +54,42 @@ module Eco::Data::Locations
       nil
     end
 
+    def raw_prev_empty_level?
+      lev = raw_prev_empty_level
+      lev && lev > 0
+    end
+
+    def raw_latest_consecutive_top_empty_level
+      tags_array[0..raw_level-1].each_with_index do |value, idx|
+        return idx if value
+      end
+      nil
+    end
+
+    # Requires that all upper levels (lower positions) are filled-in
+    def common_level_with(other)
+      return nil unless other
+      otags_array = other.tags_array.compact
+      stags_array = tags_array.compact
+      raise "Missing lower levels for #{other.id}: #{other.tags_array.pretty_inspect}" unless other.highest_levels_set?
+      raise "Missing lower levels for #{self.id}: #{tags_array.pretty_inspect}"        unless highest_levels_set?
+      otags_array.zip(stags_array).each_with_index do |(otag, stag), idx|
+        next if otag&.upcase&.strip == stag&.upcase&.strip
+        return nil if idx == 0
+        return idx # previous idx, which means prev_idx + 1 (so idx itself)
+      end
+      actual_level
+    end
+
+    # Second last id in tags_array
+    def raw_parent_id
+      tags_array.compact[-2]
+    end
+
+    def clean_parent_id
+      clean_tags_array.compact[-2]
+    end
+
     def tag_idx
       tags_array.index(raw_tag)
     end
@@ -68,33 +104,50 @@ module Eco::Data::Locations
       tary.index(nil) || tary.length + 1
     end
 
+    def copy
+      super.tap do |dup|
+        dup.highest_levels_set!
+      end
+    end
+
     # We got a missing level that is compacted in one row
     # Here we get the missing intermediate levels
     # This is done from upper to lower level to ensure processing order
     # It skips last one, as that is this object already
+    # @note for each one in the gap, creates a copy and clears deepest levels thereof
     def decouple(num = 1)
       with_info = filled_idxs
       # must be the last among filled_idxs, so let's use it to verify
       unless with_info.last == tag_idx
+        # This can only happen when there are repeated nodes
         raise "Review this (row #{row_num}; '#{raw_tag}'): tag_idx is #{tag_idx}, while last filled idx is #{with_info.last}"
       end
-      len = with_info.length
+      len         = with_info.length
       target_idxs = with_info[len-(num+1)..-2]
       target_idxs.map do |idx|
-        self.copy.tap do |dup|
+        copy.tap do |dup|
           dup.clear_level(idx_to_level(idx + 1))
         end
       end
     end
 
-    def merge!(node)
-      override_upper_levels(node.tags_array)
+    def highest_levels_set?
+      return true if raw_level == 1
+      return true unless raw_prev_empty_level?
+      !!@highest_levels_set
     end
 
-    def set_high_levels(node)
-      override_lower_levels(node.tags_array)
+    def highest_levels_set!
+      @highest_levels_set = true
     end
 
+    # Sets ancestors
+    def set_high_levels(node, override: false, compact: true)
+      update_lower_levels(node.tags_array, override: override)
+      self
+    end
+
+    # Clears the deepest levels, from level `i` onwards
     def clear_level(i)
       case i
       when Enumerable
@@ -113,23 +166,17 @@ 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)]
-      target_lev.zip(target_tags).each do |(n, tag)|
-        set_attr("l#{n}", tag)
-      end
-      self
-    end
-
     # Ensures parent is among the upper level tags
-    def override_lower_levels(src_tags_array, to_level: self.raw_prev_empty_level)
+    # It actually ensures all ancestors are there
+    # @param override [Boolean] `false` will only override upmost top consecutive empty levels.
+    def update_lower_levels(src_tags_array, to_level: self.raw_latest_consecutive_top_empty_level, override: false)
+      highest_levels_set!
       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)|
-        set_attr("l#{n}", tag)
+        attr_lev = "l#{n}"
+        set_attr(attr_lev, tag) # unless attr?(attr_lev) && !override
       end
       self
     end
@@ -152,6 +199,12 @@ module Eco::Data::Locations
       actual_level > empty_idx
     end
 
+    def clean_tags_array
+      tags_array.map do |tg|
+        clean_id(tg, notify: false)
+      end
+    end
+
     def tags_array
       values_at(*TAGS_ATTRS)
     end

data/lib/eco/language/models/parser_serializer.rb

@@ -6,7 +6,7 @@ module Eco
       class ParserSerializer
         attr_reader :attr
 
-        # Parser/seralizer.
+        # Parser/serializer.
         # @param attr [String, Symbol] name of the parsed/serialized.
         # @param dependencies [Hash] provisioning of _**default dependencies**_ that will be required when calling back to the
         #   parsing or serializing functions.

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "2.5.8"
+  VERSION = "2.5.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.5.8
+  version: 2.5.9
 platform: ruby
 authors:
 - Oscar Segura
@@ -116,7 +116,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.4
+        version: 0.9.5
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.10'
@@ -126,7 +126,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.4
+        version: 0.9.5
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.10'
@@ -555,10 +555,6 @@ files:
 - lib/eco/api/usecases/default_cases/create_details_with_supervisor_case.rb
 - lib/eco/api/usecases/default_cases/create_tag_paths_case.rb
 - lib/eco/api/usecases/default_cases/csv_to_tree_case.rb
-- lib/eco/api/usecases/default_cases/csv_to_tree_case/helper.rb
-- lib/eco/api/usecases/default_cases/csv_to_tree_case/node.rb
-- lib/eco/api/usecases/default_cases/csv_to_tree_case/nodes_cleaner.rb
-- lib/eco/api/usecases/default_cases/csv_to_tree_case/treeify.rb
 - lib/eco/api/usecases/default_cases/delete_sync_case.rb
 - lib/eco/api/usecases/default_cases/delete_trans_case.rb
 - lib/eco/api/usecases/default_cases/email_as_id_case.rb

data/lib/eco/api/usecases/default_cases/csv_to_tree_case/helper.rb

@@ -1,99 +0,0 @@
-class Eco::API::UseCases::DefaultCases::CsvToTree
-  module Helper
-    extend NodesCleaner
-    extend Treeify
-
-    class << self
-      def csv_from(filename)
-        raise "Missing #{filename}" unless File.exists?(filename)
-        result = csv_from_file(filename)
-        if result.is_a?(Integer)
-          puts "An encoding problem was found on line #{result}"
-          result = csv_from_content(filename)
-        end
-        result
-      end
-
-      def nodes_from_csv(csv)
-        i = 1; prev_level = nil; prev_node = nil; prev_nodes = Array(1..11).zip(Array.new(11, nil)).to_h
-        nodes = csv.each_with_object([]) do |row, out|
-          values = row.fields.map do |value|
-            value = value.to_s.strip
-            value.empty?? nil : value
-          end
-          i += 1
-          node = Node.new(i, *values)
-          prev_node ||= node
-
-          # 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
-            node.set_high_levels(prev_node)
-          else
-            if parent_node = prev_nodes[node.raw_level - 1]
-              node.set_high_levels(parent_node)
-            elsif node.raw_level == 1
-              # It is expected not to have parent
-              #puts "Node '#{node.raw_tag}' doesn't have parent, but it's top level tag"
-            else
-              raise "Node '#{node.raw_tag}' (#{node.row_num} row) doesn't have parent"
-            end
-          end
-          out << node
-          prev_nodes[node.raw_level] = node
-          prev_node = node
-        end
-        tidy_nodes(nodes)
-      end
-
-      def csv_nodes(filename)
-        nodes_from_csv(csv_from(filename))
-      end
-
-      private
-
-      def csv_from_content(filename)
-        CSV.parse(file_content(filename), headers: true)
-      end
-
-      def file_content(filename)
-        coding = encoding(filename)
-        coding = (coding != "utf-8")? "#{coding}|utf-8": coding
-        if content = File.read(filename, encoding: coding)
-          content.scrub do |bytes|
-            '<' + bytes.unpack('H*')[0] + '>'
-          end
-        end
-      end
-
-      def csv_from_file(filename)
-        coding = encoding(filename)
-        coding = (coding != "utf-8")? "#{coding}|utf-8": coding
-        CSV.read(filename, headers: true, encoding: coding)
-      rescue CSV::MalformedCSVError => e
-        if line = e.message.match(/line (?<line>\d+)/i)[:line]
-          return line.to_i
-        else
-          raise
-        end
-      end
-
-      def has_bom?(path)
-        return false if !path || file_empty?(path)
-        File.open(path, "rb") do |f|
-          bytes = f.read(3)
-          return bytes.unpack("C*") == [239, 187, 191]
-        end
-      end
-
-      def encoding(path)
-        has_bom?(path) ? "bom" : "utf-8"
-      end
-
-      def file_empty?(path)
-        return true if !File.file?(path)
-        File.zero?(path)
-      end
-    end
-  end
-end

data/lib/eco/api/usecases/default_cases/csv_to_tree_case/node.rb

@@ -1,221 +0,0 @@
-class Eco::API::UseCases::DefaultCases::CsvToTree
-  class Node < Struct.new(:row_num, :l1, :l2, :l3, :l4, :l5, :l6, :l7, :l8, :l9, :l10, :l11)
-    TAGS_ATTRS         = [:l1, :l2, :l3, :l4, :l5, :l6, :l7, :l8, :l9, :l10, :l11]
-    ADDITIONAL_ATTRS   = [:row_num]
-    ALL_ATTRS          = ADDITIONAL_ATTRS + TAGS_ATTRS
-    ALLOWED_CHARACTERS = "A-Za-z0-9 &_'\/.-"
-    VALID_TAG_REGEX    = /^[#{ALLOWED_CHARACTERS}]+$/
-    INVALID_TAG_REGEX  = /[^#{ALLOWED_CHARACTERS}]+/
-    VALID_TAG_CHARS    = /[#{ALLOWED_CHARACTERS}]+/
-    DOUBLE_BLANKS      = /\s\s+/
-
-    attr_accessor :parentId
-
-    def nodeId
-      id
-    end
-
-    def id
-      tag.upcase
-    end
-
-    def name
-      tag
-    end
-
-    def tag
-      raw_tag.yield_self do |str|
-        blanks_x2 = has_double_blanks?(str)
-        partial   = replace_not_allowed(str)
-        remove_double_blanks(partial).tap do |result|
-          next if invalid_warned?
-          if partial != str
-            invalid_chars = identify_invalid_characters(str)
-            puts "• (Row: #{self.row_num}) Invalid characters _#{invalid_chars}_ (removed): '#{str}' (converted to '#{result}')"
-          elsif blanks_x2
-            puts "• (Row: #{self.row_num}) Double blanks (removed): '#{str}' (converted to '#{result}')"
-          end
-          invalid_warned!
-        end
-      end
-    end
-
-    def invalid_warned?
-      @invalid_warned ||= false
-    end
-
-    def invalid_warned!
-      @invalid_warned = true
-    end
-
-    def raw_tag
-      values_at(*TAGS_ATTRS.reverse).compact.first
-    end
-
-    def level
-      actual_level
-    end
-
-    def actual_level
-      tags_array.compact.length
-    end
-
-    def raw_level
-      tags_array.index(raw_tag) + 1
-    end
-
-    def tag_idx
-      tags_array.index(raw_tag)
-    end
-
-    def previous_idx
-      idx = tag_idx - 1
-      idx < 0 ? nil : idx
-    end
-
-    def empty_idx
-      tary = tags_array
-      tary.index(nil) || tary.length + 1
-    end
-
-    def copy
-      self.class.new.set_attrs(**self.to_h)
-    end
-
-    # We got a missing level that is compacted in one row
-    # Here we get the missing intermediate levels
-    # This is done from upper to lower level to ensure processing order
-    # It skips last one, as that is this object already
-    def decouple(num = 1)
-      with_info = filled_idxs
-      # must be the last among filled_idxs, so let's use it to verify
-      unless with_info.last == tag_idx
-        raise "Review this (row #{row_num}; '#{raw_tag}'): tag_idx is #{tag_idx}, while last filled idx is #{with_info.last}"
-      end
-      len = with_info.length
-      target_idxs = with_info[len-(num+1)..-2]
-      target_idxs.map do |idx|
-        self.copy.tap do |dup|
-          dup.clear_level(idx_to_level(idx + 1))
-        end
-      end
-    end
-
-    def merge!(node)
-      override_upper_levels(node.tags_array)
-    end
-
-    def set_high_levels(node)
-      override_lower_levels(node.tags_array)
-    end
-
-    def clear_level(i)
-      case i
-      when Enumerable
-        target = i.to_a
-      when Integer
-        return false unless i >= 1 && i <= tag_attrs_count
-        target = Array(i..tag_attrs_count)
-      else
-        return false
-      end
-      return false if target.empty?
-      target.each do |n|
-        #puts "clearing 'l#{n}': #{attr("l#{n}")}"
-        set_attr("l#{n}", nil)
-      end
-      true
-    end
-
-    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)]
-      target_lev.zip(target_tags).each do |(n, tag)|
-        set_attr("l#{n}", tag)
-      end
-      self
-    end
-
-    def override_lower_levels(src_tags_array, to_level: self.raw_level - 1)
-      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)|
-        set_attr("l#{n}", tag)
-      end
-      self
-    end
-
-    def idx_to_level(x)
-      x + 1
-    end
-
-    def level_to_idx(x)
-      x - 1
-    end
-
-    def filled_idxs
-      tags_array.each_with_index.with_object([]) do |(t, i), o|
-        o << i if t
-      end
-    end
-
-    def blanks_between?
-      actual_level > empty_idx
-    end
-
-    def tags_array
-      values_at(*TAGS_ATTRS)
-    end
-
-    def values_at(*attrs)
-      attrs.map {|a| attr(a)}
-    end
-
-    def to_h(*attrs)
-      attrs = ALL_ATTRS if attrs.empty?
-      attrs.zip(values_at(*attrs)).to_h
-    end
-
-    def slice(*attrs)
-      return {} if attrs.empty?
-      to_h(*attrs)
-    end
-
-    def set_attrs(**kargs)
-      kargs.each {|attr, value| set_attr(attr, value)}
-      self
-    end
-
-    def set_attr(attr, value)
-      self.send("#{attr}=", value)
-    end
-
-    def attr(sym)
-      self.send(sym.to_sym)
-    end
-
-    def tag_attrs_count
-      TAGS_ATTRS.length
-    end
-
-    def has_double_blanks?(str)
-      return false if str.nil?
-      str.match(DOUBLE_BLANKS)
-    end
-
-    def remove_double_blanks(str)
-      return nil if str.nil?
-      str.gsub(DOUBLE_BLANKS, ' ').strip
-    end
-
-    def replace_not_allowed(str)
-      return nil if str.nil?
-      return str if str.match(VALID_TAG_REGEX)
-      str.gsub(INVALID_TAG_REGEX, ' ')
-    end
-
-    def identify_invalid_characters(str)
-      str.gsub(VALID_TAG_CHARS, '')
-    end
-  end
-end

data/lib/eco/api/usecases/default_cases/csv_to_tree_case/nodes_cleaner.rb

@@ -1,73 +0,0 @@
-class Eco::API::UseCases::DefaultCases::CsvToTree
-  module NodesCleaner
-    def repeated_tags
-      @repeated_tags ||= []
-    end
-
-    def done_tags
-      @done_tags ||= []
-    end
-
-    def fill_in_parents(nodes)
-      nodes.tap do |nodes|
-        prev_nodes = Array(1..11).zip(Array.new(11, nil)).to_h
-        nodes.each do |node|
-          if parent_node = prev_nodes[node.actual_level - 1]
-            node.parentId = parent_node.id
-          end
-          prev_nodes[node.raw_level] = node
-        end
-      end
-    end
-
-    def tidy_nodes(nodes, prev_level: 0, main: true)
-      out = nodes.each_with_object([]) do |node, out|
-        if done_tags.include?(tag = node.tag)
-          repeated_tags << "#{tag} (level: #{node.level})"
-        else
-          level = node.actual_level
-          if level > prev_level + 1
-            gap = level - (prev_level + 1)
-            puts "(Row: #{node.row_num}) Tag '#{tag}' (lev #{level}) jumps #{gap} level(s) (expected #{prev_level + 1})."
-            #puts "  " + node.tags_array.pretty_inspect
-            missing_nodes = node.decouple(gap)
-            puts "  Adding missing upper level(s): " + missing_nodes.map(&:raw_tag).pretty_inspect
-            out.push(*tidy_nodes(missing_nodes, prev_level: prev_level, main: false))
-            # puts node.actual_level
-            # pp node.tags_array
-            level = prev_level + 1
-          end
-          out       << node
-          done_tags << tag
-          prev_level = level
-        end
-      end
-      if main
-        unless repeated_tags.empty?
-          puts "There were #{repeated_tags.length} repeated tags. Only one included. These excluded:"
-          pp repeated_tags
-        end
-      end
-      fill_in_parents(out)
-    end
-
-    def to_rows(nodes, prev_level: 0, main: true)
-      out = tidy_nodes(nodes).each_with_object([]) do |node, out|
-        tag   = node.tag
-        level = node.actual_level
-        out   << (row = Array.new(level, nil))
-        row[-1..-1] = [tag.upcase]
-        prev_level = level
-      end
-      if main
-        # Normalize length
-        max_row = out.max {|a, b| a.length <=> b.length}
-        holder  = Array.new(max_row.length, nil)
-        out = out.map do |row|
-          row.dup.concat(holder)[0..max_row.length-1]
-        end
-      end
-      out
-    end
-  end
-end

data/lib/eco/api/usecases/default_cases/csv_to_tree_case/treeify.rb

@@ -1,33 +0,0 @@
-class Eco::API::UseCases::DefaultCases::CsvToTree
-  module Treeify
-    def treeify(nodes, &block)
-      get_children(nil, parents_hash(nodes), &block)
-    end
-
-    private
-
-    def parents_hash(nodes)
-      nodes.each_with_object({}) do |node, parents|
-        (parents[node.parentId] ||= []).push(node)
-      end
-    end
-
-    def get_children(node_id, parents, &block)
-      (parents[node_id] ||= []).each_with_object([]) do |child, results|
-        node_hash = {
-          "id"    => child.id,
-          "name"  => child.name
-        }
-
-        if block_given?
-          yield_hash = yield(child)
-          node_hash.merge(yield_hash) if yield_hash.is_a?(Hash)
-        end
-        
-        results << node_hash.merge({
-          "nodes" => get_children(child.id, parents, &block).compact
-        })
-      end
-    end
-  end
-end