eco-helpers 2.5.1 → 2.5.3

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

@@ -0,0 +1,74 @@
+class Eco::Data::Locations::NodeLevel
+  module Cleaner
+    include Eco::Language::AuxiliarLogger
+    include Eco::Data::Locations::Convert
+
+    # Prevents repeated node ids/tags, decouples merged levels,
+    # covers gaps (jumping multiple levels)
+    # @note
+    #   1. It first discards node ids/tags that have been already pulled (discard repeated)
+    #   2. For non repeated, it identifies if there's a gap (jump of multiple levels)
+    #   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)
+      reset_trackers! if main
+      nodes.each_with_object([]) do |node, out|
+        node_id = node.id
+        if done_ids.include?(node_id)
+          repeated_ids << "#{node_id} (level: #{node.level})"
+        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})."
+            #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 }
+
+            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_ids  << node_id
+          prev_level = level
+        end
+      end.yield_self do |out|
+        report_repeated_node_ids(repeated_ids) if main
+        fill_in_parents(out)
+      end
+    end
+
+    # Sets the `parentId` property.
+    def fill_in_parents(nodes)
+      nodes.tap do |nodes|
+        prev_nodes = empty_level_tracker_hash(11)
+        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
+
+    # Tracker helper (those repeated)
+    def repeated_ids
+      @repeated_ids ||= []
+    end
+
+    # Tracker helper (those done)
+    def done_ids
+      @done_ids ||= []
+    end
+
+    def reset_trackers!
+      @done_ids     = []
+      @repeated_ids = []
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+class Eco::Data::Locations::NodeLevel
+  module Parsing
+    include Eco::Data::Locations::NodeLevel::Cleaner
+    include Eco::Data::Locations::Convert
+
+    attr_writer :node_class
+
+    def node_class
+      @node_class ||= Eco::Data::Locations::NodeLevel
+    end
+
+    # It evaluates as an opposite to `NodePlain`
+    # @note there are only two accepted input csv formats.
+    #   The expected header of `NodePlain` is predictable,
+    #   but the header of `NodeLevel` is not.
+    # @param [CSV::Table]
+    # @return [Boolean] whether or not it's worthy trying to parse with `NodeLevel`.
+    def csv_matches_format?(csv)
+      return false unless csv.is_a?(::CSV::Table)
+      !Eco::Data::Locations::NodePlain.csv_matches_format?(csv)
+    end
+
+    # @note
+    #   1. It ensures basic data integrity when builing the nodes in the first screening
+    #   2. It then delegates the tidy up to a cleaner function (see `tidy_nodes`)
+    # @param `csv` [CSV::Table]
+    # @return [Array<NodeLevel>]
+    def nodes_from_csv(csv)
+      raise ArgumentError, "Expecting CSV::Table. Given: #{csv.class}" unless csv.is_a?(::CSV::Table)
+
+      prev_level = nil
+      prev_node  = nil
+      prev_nodes = empty_level_tracker_hash(11)
+
+      # Convert to Eco::CSV::Table for a fresh start
+      csv = Eco::CSV.parse(csv.to_csv).nil_blank_cells.add_index_column(:row_num)
+
+      nodes = csv.each_with_object([]) do |row, out|
+        row_num, *values = row.fields
+        node = node_class.new(row_num, *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 (as 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
+  end
+end

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

@@ -0,0 +1,37 @@
+class Eco::Data::Locations::NodeLevel
+  module Serial
+    include Eco::Data::Locations::NodeLevel::Cleaner
+    include Eco::Data::Locations::Convert
+
+    attr_writer :serializer
+
+    # @return [Proc] the serializer to be used.
+    def serializer
+      @serializer ||= proc do |node|
+        raise "Expecting NodeLevel. Given: #{node.class}" unless node.is_a?(Eco::Data::Locations::NodeLevel)
+        keys = %w[row_num id name]
+        keys.zip(node.values_at(*keys)).to_h.tap do |out|
+          out['parent_id'] = node.parentId
+        end
+      end
+    end
+
+    # Transforms `nodes` into a **hierarchical** csv tree.
+    # @note
+    #   1. `tidy_nodes` is called out of consistency. For example,
+    #     it might be that the parents are not set. After this call,
+    #     all the integrity issues have been warned.
+    #   2. `NodeBase` has this same class method. This one was kept
+    #     to preserve its indepenence towards treeify.
+    # @return [CSV::Table] ready to dump into a hierarhical **csv** (columns are tree levels)
+    def nodes_to_csv_tree(nodes)
+      tidy_nodes(nodes).each_with_object([]) do |node, out|
+        out         << (row = empty_array(node.actual_level))
+        # replace last item with `node.id`
+        row[-1..-1]  = [node.id]
+      end.tap do |out|
+        return Eco::CSV::Table.new(normalize_arrays(out))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+module Eco::Data::Locations
+  NODE_LEVEL_ATTRS = %i[row_num l1 l2 l3 l4 l5 l6 l7 l8 l9 l10 l11]
+  NodeLevelStruct  = Struct.new(*NODE_LEVEL_ATTRS)
+  # Class to treat input csv in a form of levels, where each column is one level,
+  # and children are placed in higher columns right below the parent.
+  class NodeLevel < NodeLevelStruct
+    include Eco::Data::Locations::NodeBase
+
+    require_relative 'node_level/cleaner'
+    require_relative 'node_level/parsing'
+    require_relative 'node_level/serial'
+    require_relative 'node_level/builder'
+    extend Eco::Data::Locations::NodeLevel::Builder
+
+    ALL_ATTRS          = NODE_LEVEL_ATTRS
+    ADDITIONAL_ATTRS   = %i[row_num]
+    TAGS_ATTRS         = ALL_ATTRS - ADDITIONAL_ATTRS
+
+    attr_accessor :parentId
+
+    def nodeId
+      id
+    end
+
+    def id
+      tag.upcase
+    end
+
+    def name
+      tag
+    end
+
+    def tag
+      clean_id(raw_tag)
+    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
+
+    # 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 |(tg, ix), out|
+        out << ix if tg
+      end
+    end
+
+    def blanks_between?
+      actual_level > empty_idx
+    end
+
+    def tags_array
+      values_at(*TAGS_ATTRS)
+    end
+
+    def tag_attrs_count
+      TAGS_ATTRS.length
+    end
+  end
+end

data/lib/eco/data/locations/node_plain/builder.rb

@@ -0,0 +1,6 @@
+class Eco::Data::Locations::NodePlain
+  module Builder
+    include Eco::Data::Locations::NodePlain::Parsing
+    include Eco::Data::Locations::NodePlain::Serial
+  end
+end

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

@@ -0,0 +1,36 @@
+class Eco::Data::Locations::NodePlain
+  module Parsing
+    attr_writer :node_class
+
+    def node_class
+      @node_class ||= Eco::Data::Locations::NodePlain
+    end
+
+    # Subset of property names expected to be among the headers
+    def basic_headers
+      @expected_headers ||= %w[id name parent_id]
+    end
+
+    # Checks if the `basic_headers` to process as `NodePlain` are present.
+    # @param [CSV::Table]
+    # @return [Boolean] whether or not it's worthy trying to parse with `NodePlain`.
+    def csv_matches_format?(csv)
+      return false unless csv.is_a?(::CSV::Table)
+      (basic_headers & csv.headers) == basic_headers
+    end
+
+    # It builds each NodePlain from the input csv.
+    # @param `csv` [CSV::Table]
+    # @return [Array<NodePlain>]
+    def nodes_from_csv(csv)
+      raise ArgumentError, "Expecting CSV::Table. Given: #{csv.class}" unless csv.is_a?(::CSV::Table)
+      # Convert to Eco::CSV::Table for a fresh start
+      csv     = Eco::CSV.parse(csv.to_csv).nil_blank_cells.add_index_column(:row_num)
+      headers = node_class::ALL_ATTRS.map(&:to_s)
+      csv.each_with_object([]) do |row, out|
+        row_num, *values = row.values_at(*headers)
+        out << node_class.new(row_num, *values)
+      end
+    end
+  end
+end

data/lib/eco/data/locations/node_plain/serial.rb

@@ -0,0 +1,14 @@
+class Eco::Data::Locations::NodePlain
+  module Serial
+    attr_writer :serializer
+
+    # @return [Proc] the serializer to be used.
+    def serializer
+      @serializer ||= proc do |node|
+        raise "Expecting NodePlain. Given: #{node.class}" unless node.is_a?(Eco::Data::Locations::NodePlain)
+        keys = Eco::Data::Locations::NodePlain::NODE_PLAIN_ATTRS
+        node.to_h(*keys)
+      end
+    end
+  end
+end

data/lib/eco/data/locations/node_plain.rb

@@ -0,0 +1,34 @@
+module Eco::Data::Locations
+  NODE_PLAIN_ATTRS = %i[row_num id name parent_id weight archived archive_token]
+  NodePlainStruct  = Struct.new(*NODE_PLAIN_ATTRS)
+  # Class to treat input csv in a form of a list of nodes, where parent is specified.
+  class NodePlain < NodePlainStruct
+    include Eco::Data::Locations::NodeBase
+
+    require_relative 'node_plain/parsing'
+    require_relative 'node_plain/serial'
+    require_relative 'node_plain/builder'
+    extend Eco::Data::Locations::NodePlain::Builder
+
+    ALL_ATTRS          = NODE_PLAIN_ATTRS
+    ADDITIONAL_ATTRS   = %i[row_num]
+    PROP_ATTRS         = ALL_ATTRS - ADDITIONAL_ATTRS
+
+    def id
+      clean_id(super)
+    end
+
+    def name
+      super || self.id
+    end
+
+    def parentId
+      self.parent_id
+    end
+
+    # backwards compatibility
+    def tag
+      id
+    end
+  end
+end

data/lib/eco/data/locations.rb

@@ -0,0 +1,12 @@
+module Eco
+  module Data
+    module Locations
+    end
+  end
+end
+
+require_relative 'locations/convert'
+require_relative 'locations/node_base'
+require_relative 'locations/node_plain'
+require_relative 'locations/node_level'
+require_relative 'locations/dsl'

data/lib/eco/data.rb

@@ -7,3 +7,4 @@ require_relative 'data/files'
 require_relative 'data/mapper'
 require_relative 'data/fuzzy_match'
 require_relative 'data/hashes'
+require_relative 'data/locations'

data/lib/eco/language/auxiliar_logger.rb

@@ -3,6 +3,9 @@ module Eco
     # Some modules/classes use logger, but they may not be connected to session.
     # This prevents errors with this.
     module AuxiliarLogger
+      attr_writer :logger
+
+      # Provides either an available logger or a basic one
       def logger
         if defined?(super)
           super
@@ -11,9 +14,14 @@ module Eco
         elsif instance_variable_defined?(:@session)
           @session.logger
         else
-          @logger ||= ::Logger.new(IO::NULL)
+          @logger ||= Eco::Language::BasicLogger.new
         end
       end
+
+      # Shortcut to logger.
+      def log(level, &block)
+        logger.send(level, &block) if logger
+      end
     end
   end
 end

data/lib/eco/language/basic_logger.rb

@@ -0,0 +1,74 @@
+module Eco
+  module Language
+    # Basic logger to format messaging to console
+    class BasicLogger
+      class << self
+        def forward(*meths)
+          meths.each do |meth|
+            define_method(meth) do |*args, **kargs, &block|
+              forward(meth, *args, **kargs, &block)
+            end
+          end
+        end
+      end
+
+      TIMESTAMP_PATTERN = '%Y-%m-%dT%H:%M:%S'.freeze
+      LOG_LEVELS = %i[unknown fatal error warn info debug].freeze
+      METHODS    = %i[<< close add].freeze
+
+      attr_writer :timestamp
+      attr_reader :level
+
+      forward *LOG_LEVELS, *METHODS
+
+      def initialize(level: ::Logger::INFO, timestamp: false)
+        @level             = level
+        self.timestamp     = timestamp
+        loggers[:console]  = ::Logger.new(STDOUT).tap do |logger|
+          logger.formatter = format_proc(console: true)
+          logger.level     = level
+        end
+      end
+
+      def timestamp?
+        @timestamp
+      end
+
+      def level=(value)
+        loggers[:console].level = value
+      end
+
+      private
+
+      def forward(meth, *args, &block)
+        loggers.each do |_key, logger|
+          logger.send(meth, *args, &block)
+        end
+      end
+
+      def loggers
+        @loggers ||= {}
+      end
+
+      def console_timestamp(datetime)
+        return nil unless timestamp?
+        timestamp(datetime)
+      end
+
+      def timestamp(datetime)
+        return nil unless datetime
+        str_date = datetime.strftime(self.class::TIMESTAMP_PATTERN)
+        "#{str_date} > "
+      end
+
+      def format_proc(console: true, &block)
+        proc do |severity, datetime, progname, msg|
+          str_stamp     = console ? console_timestamp(datetime) : timestamp(datetime)
+          "#{severity.to_s[0]}: #{str_stamp}#{msg}\n".tap do |formatted_msg|
+            block.call(severity, datetime, msg, formatted_msg) if block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/language.rb

@@ -4,10 +4,11 @@ module Eco
 end
 
 require_relative 'language/models'
+require_relative 'language/auxiliar_logger'
+require_relative 'language/basic_logger'
 require_relative 'language/curry'
 require_relative 'language/hash_transform_modifier'
 require_relative 'language/hash_transform'
 require_relative 'language/values_at'
 require_relative 'language/match_modifier'
 require_relative 'language/match'
-require_relative 'language/auxiliar_logger'

data/lib/eco/version.rb

@@ -1,3 +1,3 @@
 module Eco
-  VERSION = "2.5.1"
+  VERSION = "2.5.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eco-helpers
 version: !ruby/object:Gem::Version
-  version: 2.5.1
+  version: 2.5.3
 platform: ruby
 authors:
 - Oscar Segura
@@ -136,7 +136,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.2
+        version: 1.1.3
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.2'
@@ -146,7 +146,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.2
+        version: 1.1.3
     - - "<"
       - !ruby/object:Gem::Version
         version: '1.2'
@@ -156,7 +156,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.7
+        version: 0.3.8
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.4'
@@ -166,7 +166,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.7
+        version: 0.3.8
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.4'
@@ -566,7 +566,6 @@ files:
 - lib/eco/api/usecases/default_cases/hris_case.rb
 - lib/eco/api/usecases/default_cases/new_email_case.rb
 - lib/eco/api/usecases/default_cases/new_id_case.rb
-- lib/eco/api/usecases/default_cases/new_id_case0.rb
 - lib/eco/api/usecases/default_cases/org_data_convert_case.rb
 - lib/eco/api/usecases/default_cases/refresh_case.rb
 - lib/eco/api/usecases/default_cases/reinvite_sync_case.rb
@@ -592,8 +591,18 @@ files:
 - lib/eco/api/usecases/graphql.rb
 - lib/eco/api/usecases/graphql/base.rb
 - lib/eco/api/usecases/graphql/helpers.rb
-- lib/eco/api/usecases/graphql/helpers/locations.rb
-- lib/eco/api/usecases/graphql/helpers/locations/commands.rb
+- lib/eco/api/usecases/graphql/helpers/base.rb
+- lib/eco/api/usecases/graphql/helpers/location.rb
+- lib/eco/api/usecases/graphql/helpers/location/base.rb
+- 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/samples.rb
+- lib/eco/api/usecases/graphql/samples/location.rb
+- lib/eco/api/usecases/graphql/samples/location/command.rb
+- lib/eco/api/usecases/graphql/samples/location/command/dsl.rb
+- lib/eco/api/usecases/graphql/samples/location/command/results.rb
+- lib/eco/api/usecases/graphql/samples/location/dsl.rb
 - lib/eco/api/usecases/ooze_cases.rb
 - lib/eco/api/usecases/ooze_cases/export_register_case.rb
 - lib/eco/api/usecases/ooze_samples.rb
@@ -662,9 +671,29 @@ files:
 - lib/eco/data/hashes.rb
 - lib/eco/data/hashes/array_diff.rb
 - lib/eco/data/hashes/diff_result.rb
+- lib/eco/data/locations.rb
+- lib/eco/data/locations/convert.rb
+- lib/eco/data/locations/dsl.rb
+- lib/eco/data/locations/node_base.rb
+- lib/eco/data/locations/node_base/builder.rb
+- lib/eco/data/locations/node_base/csv_convert.rb
+- lib/eco/data/locations/node_base/parsing.rb
+- lib/eco/data/locations/node_base/serial.rb
+- lib/eco/data/locations/node_base/tag_validations.rb
+- lib/eco/data/locations/node_base/treeify.rb
+- lib/eco/data/locations/node_level.rb
+- lib/eco/data/locations/node_level/builder.rb
+- lib/eco/data/locations/node_level/cleaner.rb
+- lib/eco/data/locations/node_level/parsing.rb
+- lib/eco/data/locations/node_level/serial.rb
+- lib/eco/data/locations/node_plain.rb
+- lib/eco/data/locations/node_plain/builder.rb
+- lib/eco/data/locations/node_plain/parsing.rb
+- lib/eco/data/locations/node_plain/serial.rb
 - lib/eco/data/mapper.rb
 - lib/eco/language.rb
 - lib/eco/language/auxiliar_logger.rb
+- lib/eco/language/basic_logger.rb
 - lib/eco/language/curry.rb
 - lib/eco/language/hash_transform.rb
 - lib/eco/language/hash_transform_modifier.rb

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

@@ -1,14 +0,0 @@
-class Eco::API::UseCases::DefaultCases::NewIdCase < Eco::API::Common::Loaders::UseCase
-  name "new-id"
-  type :sync
-
-  def main(entries, people, session, options, usecase)
-    micro    = session.micro
-    update   = session.new_job("main", "update", :update, usecase, :core)
-    micro.with_each_present(entries, people, options, log_starter: true) do |entry, person|
-      update.add(person)
-      person.external_id = entry.external_id
-    end
-  end
-
-end

data/lib/eco/api/usecases/graphql/helpers/locations/commands.rb

@@ -1,4 +0,0 @@
-module Eco::API::UseCases::GraphQL::Helpers::Locations
-  class Commands
-  end
-end