eco-helpers 2.5.2 → 2.5.4

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

@@ -7,5 +7,7 @@ module Eco
   end
 end
 
-require_relative 'graphql/base'
 require_relative 'graphql/helpers'
+require_relative 'graphql/utils'
+require_relative 'graphql/base'
+require_relative 'graphql/samples'

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

@@ -5,7 +5,6 @@ class Eco::API::UseCases::OozeCases::ExportRegisterCase < Eco::API::UseCases::Oo
   batch_size 5
 
   def main(session, options, usecase)
-
     super(session, options, usecase) do
       # Save the File
       CSV.open(filename, "w") do |csv|

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

@@ -5,7 +5,6 @@ class Eco::API::UseCases::OozeSamples::OozeBaseCase < Eco::API::Common::Loaders:
 
   include Eco::API::UseCases::OozeSamples::Helpers
 
-  attr_reader :session, :options, :usecase
   attr_reader :target
 
   SAVE_PATCH = "ooze_patch_update.json"
@@ -14,7 +13,6 @@ class Eco::API::UseCases::OozeSamples::OozeBaseCase < Eco::API::Common::Loaders:
   def main(session, options, usecase)
     options[:end_get] = false
     raise "You need to inherit from this class ('#{self.class}') and call super with a block" unless block_given?
-    @session = session; @options = options; @usecase = usecase
     @target  = nil
     yield
   end

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

@@ -40,11 +40,9 @@ class Eco::API::UseCases::OozeSamples::RegisterMigrationCase < Eco::API::UseCase
 
   include Eco::API::UseCases::OozeSamples::HelpersMigration
 
-  attr_reader :session, :options
   attr_reader :csv
 
   def main(session, options, usecase, &block)
-    @session = session; @options = options
     if options[:dry_run]
       @csv = []
       super(session, options, usecase, &block)

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

@@ -75,10 +75,10 @@ module Eco
           return false unless callback_from_loader?
           use_case_self = self
           callback_self.instance_eval do
-            next unless self.is_a?(Eco::API::Common::Loaders::CaseBase)
-            # `self` is the use case itself (when used the Loader)
             @session = session
             @options = options
+            # `self` is the use case itself (when used the Loader)
+            next unless self.is_a?(Eco::API::Common::Loaders::CaseBase)
             @usecase = use_case_self
           end
           true

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

@@ -1,8 +1,7 @@
 ASSETS.cli.config do |config|
   ASSETS.config.workflow do |wf|
-
-    io = nil
-    rescued = false
+    io                = nil
+    rescued           = false
     cases_with_input  = nil
     cases_with_output = nil
 
@@ -183,6 +182,5 @@ ASSETS.cli.config do |config|
       end
       io
     end
-
   end
 end

data/lib/eco/cli/scripting/args_helpers.rb

@@ -2,7 +2,6 @@ module Eco
   class CLI
     class Scripting
       module ArgsHelpers
-
         # @return [Array<String] the command line arguments.
         def argv
           @argv || ARGV
@@ -91,7 +90,6 @@ module Eco
         def file_exists?(filename)
           File.exists?(filename) || File.exists?(File.expand_path(filename))
         end
-
       end
     end
   end

data/lib/eco/csv/table.rb

@@ -11,6 +11,25 @@ module Eco
         end
       end
 
+      # It ensures blank strings are set to `nil`
+      # @note assumes there are no repeated header names
+      # @return [Eco::CSV::Table]
+      def nil_blank_cells!
+        self.each do |row|
+          row.dup.each do |header, value|
+            value       = value.to_s.strip
+            row[header] = value.empty?? nil : value
+          end
+        end
+        self
+      end
+
+      # A new table from `self` where blank strings are have been set to `nil`
+      # @return [Eco::CSV::Table]
+      def nil_blank_cells
+        self.class.new(self).nil_blank_cells!
+      end
+
       # @return [Hash] where keys are the groups and the values a `Eco::CSV::Table`
       def group_by(&block)
         rows.group_by(&block).transform_values do |rows|
@@ -111,11 +130,29 @@ module Eco
       end
 
       # Adds a new column at the end
+      # @note by default it adds it to the end.
       # @param header_name [String] header of the new column
+      # @param pos [Integer] index where to add the column (i.e. `0` for first)
       # @return [Eco::CSV::Table] with a new empty column
-      def add_column(header_name)
+      def add_column(header_name, pos: -1)
+        header_name = header_name.to_s.strip
+        raise ArgumentError, "header_name can't be blank" if header_name.empty?
         new_col = Array.new(length).unshift(header_name)
-        columns_to_table(columns.push(new_col))
+        columns_to_table(columns.insert(pos, new_col))
+      end
+
+      # @note by default it adds as a first column
+
+      # @param header_name [String] header of the new column
+      # @param pos [Integer] index where to add the column (i.e. `-1` for last)
+      # @return [Eco::CSV::Table] with a new column named `name` with the row number
+      def add_index_column(header_name = 'idx', pos: 0)
+        header_name = header_name.to_s.strip
+        add_column(header_name, pos: pos).tap do |table|
+          table.each.with_index do |row, idx|
+            row[header_name] = idx + 2
+          end
+        end
       end
 
       # @return [Array<::CSV::Row>]
@@ -221,7 +258,6 @@ module Eco
           raise "Input type not supported. Given: #{data.class}"
         end
       end
-
     end
   end
 end

data/lib/eco/data/files/helpers.rb

@@ -75,11 +75,11 @@ module Eco
           Dir.exist?(path) || Dir.exist?(File.expand_path(path))
         end
 
-        def timestamp(timestamp_pattern = DEFAULT_TIMESTAMP_PATTERN)
-          Time.now.strftime(timestamp_pattern)
+        def timestamp(timestamp_pattern = DEFAULT_TIMESTAMP_PATTERN, date = Time.now)
+          date.strftime(timestamp_pattern)
         end
 
-        def timestamp_file(filename, timestamp_pattern = DEFAULT_TIMESTAMP_PATTERN)
+        def timestamp_file(filename, timestamp_pattern =DEFAULT_TIMESTAMP_PATTERN)
           file_pattern = Eco::Data::Files::FilePattern.new(filename)
           file_pattern.resolve(start: timestamp(timestamp_pattern) + '_')
         end
@@ -119,6 +119,7 @@ module Eco
       end
 
       class << self
+        include Files::InstanceMethods
         include Files::ClassMethods
       end
     end

data/lib/eco/data/hashes/array_diff.rb

@@ -3,46 +3,16 @@ module Eco
     module Hashes
       class ArrayDiff
         extend Eco::Language::Models::ClassHelpers
+        # We can change the `DiffResult` class (items)
+        class_resolver :diff_result_class, "Eco::Data::Hash::DiffResult"
 
-        class << self
-          def key(value = nil)
-            return @key unless value
-            @key = value.to_s
-          end
-
-          def key?
-            !!@key
-          end
-
-          def compare(*attrs)
-            compared_attrs.push(*attrs.map(&:to_s)).uniq!
-          end
-
-          def case_sensitive(value = nil)
-            @case_sensitive = false unless instance_variable_defined?(:@case_sensitive)
-            return @case_sensitive unless value
-            @case_sensitive = !!value
-          end
-
-          def case_sensitive?
-            !!@case_sensitive
-          end
-
-          def compared_attrs
-            @compared_attrs ||= []
-            @compared_attrs
-          end
-        end
+        include Eco::Language::AuxiliarLogger
 
         attr_reader :source1, :source2
         attr_reader :src_h1,  :src_h2
-        attr_reader :logger
-
-        class_resolver :diff_result_class, "Eco::Data::Hash::DiffResult"
 
-        def initialize(source1, source2, logger: ::Logger.new(IO::NULL), **kargs)
-          @logger  = logger
-          @options = kargs
+        def initialize(source1, source2, logger: nil)
+          @logger  = logger if logger
           @source1 = source1
           @source2 = source2
           @src_h1  = by_key(source1)
@@ -66,14 +36,11 @@ module Eco
           !diffs.empty?
         end
 
+        # All the items that contain the diff of a node.
+        # @return [Array<Eco::Data::Hash::DiffResult>]
         def source_results
           @source_results ||= paired_sources.each_with_object([]) do |(src1, src2), res|
-            args = {
-              key:            key,
-              compare:        compared_attrs,
-              case_sensitive: case_sensitive?
-            }
-            res << diff_result_class.new(src1, src2, **args)
+            res << diff_result_class.new(src1, src2)
           end
         end
 
@@ -84,40 +51,29 @@ module Eco
         #   - It also ensures they are in their Hash form (with string keys)
         #   - This will merge entries of the same source that hold the same `key` attr value (latest wins)
         def paired_sources
-          keys1 = src_h1.keys; keys2 = src_h2.keys
+          keys1    = src_h1.keys
+          keys2    = src_h2.keys
           all_keys = keys1 | keys2
           all_keys.map {|key| [src_h1[key], src_h2[key]]}
         end
 
+        # @return [String] the `key` attribute of `diff_result_class`
         def key
-          @key ||= options_or(:key) do
-            self.class.key
-          end.tap do |k|
-            raise "missing main key attr to pair records. Given: #{k}" unless k.is_a?(String)
+          diff_result_class.key.tap do |k|
+            raise "#{diff_result_class}: missing main key attr to pair records. Given: #{k}" unless k.is_a?(String)
           end
         end
 
         def case_sensitive?
-          @case_sensitive ||= options_or(:case_sensitive) { self.class.case_sensitive? }
+          diff_result_class.case_sensitive?
         end
 
         def compared_attrs
-          @compared_attrs ||= options_or(:compared_attrs) do
-            self.class.compared_attrs
-          end.yield_self do |attrs|
-            raise "compared_attrs should be an array" unless attrs.is_a?(Array)
-            attrs.map(&:to_s)
-          end
+          diff_result_class.compared_attrs.map(&:to_s)
         end
 
         private
 
-        def options_or(opt)
-          opt = opt.to_sym
-          return @options[opt] if @options.key?(opt)
-          yield
-        end
-
         def symbolize_keys(hash)
           hash.each_with_object({}) do |(k, v), h|
             h[k.to_sym] = v
@@ -149,11 +105,15 @@ module Eco
             when Hash, Array, ::CSV::Row
               Eco::CSV::Table.new(content).to_array_of_hashes
             else
-              logger.error("Input content 'Array' of '#{sample.class}' is not supported.")
+              log(:error) {
+                "Input content 'Array' of '#{sample.class}' is not supported."
+              }
               exit(1)
             end
           else
-            logger.error("Could not obtain any data out content: '#{content.class}'")
+            log(:error) {
+              "Could not obtain any data out content: '#{content.class}'"
+            }
             exit(1)
           end
         end

data/lib/eco/data/hashes/diff_meta.rb

@@ -0,0 +1,52 @@
+module Eco
+  module Data
+    module Hashes
+      module DiffMeta
+        class << self
+          def included(base)
+            super(base)
+            base.extend ClassMethods
+          end
+        end
+
+        module ClassMethods
+          # @param value [String, NilClass]
+          # @return [String] the attribute that is key of the node diff elements.
+          def key(value = nil)
+            return @key unless value
+            @key = value.to_s
+          end
+
+          # @return [Boolean] is there a `key` attribute defined?
+          def key?
+            !!@key
+          end
+
+          # @param attrs [Array<Symbol>, Array<String>]
+          # @return [Array<String>] the comparable attributes
+          def compare(*attrs)
+            compared_attrs.push(*attrs.map(&:to_s)).uniq!
+            compared_attrs
+          end
+
+          # Whether or not the diff calc of a node should be done case sensitive or insensitive.
+          def case_sensitive(value = nil)
+            @case_sensitive = false unless instance_variable_defined?(:@case_sensitive)
+            return @case_sensitive unless value
+            @case_sensitive = !!value
+          end
+
+          # @return [Boolean] are comparisons of values done case sensitive?
+          def case_sensitive?
+            !!@case_sensitive
+          end
+
+          # @return [Array<String>] the comparable attributes
+          def compared_attrs
+            @compared_attrs ||= []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/data/hashes/diff_result.rb

@@ -2,20 +2,32 @@ module Eco
   module Data
     module Hashes
       class DiffResult
+        extend Eco::Language::Models::ClassHelpers
+        include Eco::Data::Hashes::DiffMeta
+
+        inheritable_class_vars :key, :compared_attrs, :case_sensitive
 
-        attr_reader :key
         attr_reader :src1, :src2
 
-        # @param [Array<String>, sym]
-        #   - `:all` compares the matching attrs between both hashes only
-        def initialize(src1, src2, key:, compare: :all, case_sensitive: false)
-          @key     = key
-          @compare = compare
-          @case_sensitive = case_sensitive
+        def initialize(src1, src2)
           @src1 = src1
           @src2 = src2
         end
 
+        def key
+          self.class.key
+        end
+
+        def case_sensitive?
+          self.class.case_sensitive?
+        end
+
+        def dup(src1: nil, src2: nil)
+          src1 ||= self.src1
+          src2 ||= self.src2
+          self.class.new(src1.dup, src2.dup)
+        end
+
         def new?
           !src1 && !!src2
         end
@@ -28,35 +40,39 @@ module Eco
           !new? && !del? && diff?
         end
 
+        # @note `diff_attrs` may not include the `key` attribute
+        #   This is always included via `new?` (new key value) and `del?` (missing key value)
+        # @return [Boolean] was there any change?
         def diff?
           new? || del? || !diff_attrs.empty?
         end
 
-        # Is the key attr value changing?
+        # Is the `key` attr value changing?
         def key?
           !(new? || del?) && diff_attr?(key)
         end
 
+        # Is `attr` part of the attributes that change?
         def diff_attr?(attr)
           return true if new?
           return true if del?
           diff_attrs.include?(attr.to_s)
         end
 
+        # @return [Value] the current value of `attr` (in `src2`)
         def attr(attr)
           return nil unless src2
           src2[attr.to_s]
         end
 
+        # @return [Value] the previous value of `attr` (in `src1`)
         def attr_prev(attr)
           return nil unless src1
           src1[attr.to_s]
         end
 
-        def previous(attr)
-          src1 && src1[attr.to_s]
-        end
-
+        # @note the `key` attribute will always be added (even if there's no change)
+        # @return [Hash] hash with the differences as per `src2`
         def diff_hash
           target_attrs = [key] | compared_attrs
           return src2.slice(*target_attrs) if new?
@@ -64,12 +80,14 @@ module Eco
           src2.slice(key, *diff_attrs)
         end
 
+        # @return [Array<Symbol>] hash with the differences as per `src2`
         def diff_attrs
           @diff_attrs ||= comparable_attrs.each_with_object([]) do |attr, out|
             out << attr unless eq?(src1[attr], src2[attr])
           end
         end
 
+        # @return [Boolean] whether `val1` is equal to `val2`
         def eq?(val1, val2)
           return true  if val1 == val2
           return false if case_sensitive?
@@ -77,25 +95,18 @@ module Eco
           val1.upcase == val2.upcase
         end
 
-        def case_sensitive?
-          !!@case_sensitive
-        end
-
+        # @note when is `new?` or to be deleted (`del?`), it returns empty array.
+        # @return [Array<String>] the set of attributes that are comparable in this instance.
         def comparable_attrs
           return [] if new? || del?
           compared_attrs
         end
 
+        # @return [Array<String>] the set of attributes that are comparable in this class.
         def compared_attrs
-          return @compared_attrs if instance_variable_defined?(:@compared_attrs)
-          @compared_attrs = \
-            if @compare == :all
-              src1.keys & src2.keys
-            elsif @compare.is_a?(Array)
-              @compare.map(&:to_s)
-            else
-              raise "Expecting 'compare' to be sym (:all) or Array<String>. Given: #{@compare.class}"
-            end
+          comp_attrs = self.class.compared_attrs.map(&:to_s).uniq
+          return comp_attrs unless comp_attrs.empty?
+          (src1&.keys || []) & (src2&.keys || [])
         end
       end
     end

data/lib/eco/data/hashes.rb

@@ -5,5 +5,6 @@ module Eco
   end
 end
 
+require_relative 'hashes/diff_meta'
 require_relative 'hashes/diff_result'
 require_relative 'hashes/array_diff'

data/lib/eco/data/locations/convert.rb

@@ -0,0 +1,92 @@
+module Eco::Data::Locations
+  module Convert
+    include Eco::Language::AuxiliarLogger
+
+    # Helper to open a csv
+    # @note this is a shortcut helper.
+    # @param filename [String] the csv file.
+    # @return [Eco::CSV::Table]
+    def csv_from(filename, encoding: 'utf-8')
+      raise ArgumentError, "Expecting String filename. Given: #{filename.class}" unless filename.is_a?(String)
+      raise "Missing #{filename}" unless File.exists?(filename)
+      Eco::CSV.read(filename, encoding: encoding)
+    rescue CSV::MalformedCSVError => e
+      if match = e.message.match(/line (?<line>\d+)/i)
+        log(:error) {"An encoding problem was found on line #{match[:line]}"}
+      end
+      raise
+    end
+
+    # Generic converter/helper to generate the csv data export for a hierarchical csv tree
+    # @note The steps of usage would be:
+    #   1. First **treeify** your input (i.e. `Eco::API::Organization::TagTree#as_json`,
+    #     or `treeify(nodes)`
+    # @param hash_nodes [Array<Hash>] a hierarchical tree of Hash nodes, nested via `nodes`
+    # @return [CSV::Table] ready to be made a hierarchical csv tree (i.e. out.to_csv)
+    def hash_tree_to_tree_csv(hash_nodes, out: [], done_ids: [], repeated_ids: [], level: 0)
+      lev  = level + 1
+      base = empty_array(level)
+
+      hash_nodes.each_with_object(out) do |node, out|
+        if done_ids.include?(id = node["id"])
+          repeated_ids << id
+        else
+          has_offspring = (children = node["nodes"]) && !children.empty?
+          done_ids << id
+          out      << (base.dup << node["id"])
+          hash_tree_to_tree_csv(node["nodes"], out: out, done_ids: done_ids, repeated_ids: repeated_ids, level: lev)
+        end
+      end.tap do |out|
+        if level == 0
+          report_repeated_node_ids(repeated_ids)
+          return Eco::CSV::Table.new(normalize_arrays(out))
+        end
+      end
+    end
+
+    # It normalizes the size of the arrays to the max size among the arrays
+    # @param rows [Array<Array>] where arrays may not have the same length
+    # @return [Array<Array>] where arrays have all the same length
+    def normalize_arrays(rows)
+      max_row = rows.max {|a, b| a.length <=> b.length}
+      holder  = empty_array(max_row.length)
+      rows.map do |row|
+        row.dup.concat(holder[0..-(row.length+1)])
+      end
+    end
+
+    # @param count [Integer] number of possitions of the new array
+    # @return [Array<NilClass>] with `count` positions.
+    def empty_array(count)
+      Array.new(count, nil)
+    end
+
+    # @note
+    #   1. Initially it has as many keys as levels `count`
+    #   2. It serves the purpose to track the lastest seen node
+    #     for a given level, during a loop.
+    # @return [Hash] with integer level counts as keys and
+    #   nodes as values.
+    def empty_level_tracker_hash(count = 11)
+      Array(1..count).zip(empty_array(count)).to_h
+    end
+
+    # It logs a message from `yield` and appends a `pretty_inspect` on object.
+    # @note it only works where `object` is `Enumberable`
+    def log_pretty_inspect(object, lev = :info)
+      return unless object.is_a?(Enumerable)
+      return if object.empty?
+      msg  = ''
+      msg << "#{yield(object)}\n" if block_given?
+      msg << object.pretty_inspect
+      log(lev) { msg }
+    end
+
+    # Prints a common message
+    def report_repeated_node_ids(repeated)
+      log_pretty_inspect(repeated, :warn) do
+        "There were #{repeated.length} repeated node ids. Only one included. These excluded:"
+      end
+    end
+  end
+end

data/lib/eco/data/locations/dsl.rb

@@ -0,0 +1,35 @@
+module Eco::Data::Locations
+  # It allows to create your own helper
+  # @example of usage:
+  #     module LocHelp
+  #       include Eco::Data::Locations::DSL
+  #     end
+  #
+  #     nodes_list = LocHelp.csv_nodes_from(csv_list_filename)
+  #     csv_tree   = LocHelp.nodes_to_csv_tree(nodes_list)
+  #     File.open(output_filename, 'w') { |fd| fd.write(csv_tree.to_csv) }
+  #
+  # @example of usage:
+  #     class Foo
+  #       include Eco::Data::Locations::DSL
+  #
+  #       def csv_tree_to_csv_list(csv_tree_filename)
+  #         csv_list = nodes_to_csv_list(csv_nodes_from(csv_tree_filename))
+  #         File.open(output_filename, 'w') { |fd| fd.write(csv_list.to_csv) }
+  #       end
+  #
+  #       def live_tree_to_csv_tree(org_tagtree)
+  #         File.open(output_filename, 'w') { |fd| fd.write(csv_tree(org_tagtree).to_csv) }
+  #       end
+  #     end
+  #
+  module DSL
+    class << self
+      def included(base)
+        super(base)
+        base.extend Eco::Data::Locations::NodeBase::Builder
+        base.send :include, Eco::Data::Locations::NodeBase::Builder
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Eco::Data::Locations::NodeBase
+  module Builder
+    include Eco::Data::Locations::NodeBase::Parsing
+    include Eco::Data::Locations::NodeBase::Serial
+    include Eco::Data::Locations::NodeBase::CsvConvert
+    include Eco::Data::Locations::NodeBase::Treeify
+
+    # @param data [CSV::Table, NodeBase, Array<NodeBase>]
+    # @return [NodeBase::Class] the Node class we can use.
+    def node_class(data)
+      case data
+      when ::CSV::Table
+        return Eco::Data::Locations::NodePlain if Eco::Data::Locations::NodePlain.csv_matches_format?(csv)
+        return Eco::Data::Locations::NodeLevel if Eco::Data::Locations::NodeLevel.csv_matches_format?(csv)
+      when Array
+        return nil unless sample = data.first
+        node_class(sample)
+      when Eco::Data::Locations::NodeBase
+        return nil unless data.class < Eco::Data::Locations::NodeBase
+        data.class
+      else
+        raise ArgumentError, "Expecting CSV::Table. Given: #{csv.class}" unless csv.is_a?(::CSV::Table)
+      end
+    end
+  end
+end