pal_tool 0.2.1

data/lib/pal/operation/exporter.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "pal"
+require "pal/configuration"
+require "pal/common/local_file_utils"
+require "pal/common/safe_hash_parse"
+require "pal/common/object_helpers"
+
+module Pal
+  module Operation
+    # Probably a bad name, its really a processor that calls an export impl - w
+    class Exporter
+      include Log
+      include ObjectHelpers
+
+      # @return [Array<Pal::Operation::BaseExportHandler>]
+      attr_reader :export_types
+
+      # @return [Array<String>]
+      attr_accessor :properties
+
+      # @return [Actions]
+      attr_reader :actions
+
+      # @param [Pal::Operation::ProcessorContext] ctx
+      # @return [Array, Hash]
+      def perform_export(ctx)
+        log_info("About to extract required data defined in #{ctx.candidates.size} rows")
+        extracted_rows, extracted_columns = extract(ctx, @properties)
+
+        if @actions&.processable?
+          log_info("Actions have been defined, going off to extract.")
+          extracted_rows, extracted_columns = @actions.process(extracted_rows, extracted_columns)
+        end
+
+        @export_types.each do |t|
+          log_info("Exporting for [#{t.class}] triggered ...")
+          t.run_export(extracted_rows, extracted_columns)
+          log_info("... export for [#{t.class}] completed")
+        end
+
+        [extracted_rows, extracted_columns]
+      end
+
+      private
+
+      # @param [Array<String>] properties
+      # @return [Array]
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def extract(ctx, properties)
+        all_columns = ctx.column_headers.keys
+
+        properties = all_columns if properties.nil? || properties.empty?
+
+        extractable_properties = {}
+        properties.each do |property|
+          unless all_columns.include? property
+            log_warn("[#{property}] not found in column headers.")
+            next
+          end
+
+          extractable_properties[property] = ctx.column_headers[property]
+        end
+
+        extracted_rows = ctx.candidates.map do |row|
+          extractable_properties.map do |key, value_idx|
+            value = row[value_idx]
+            value ? ctx.cast(key, value) : "<Missing>"
+          end
+        end
+
+        new_extractable_properties = {}
+        extractable_properties.keys.each_with_index do |key, idx|
+          new_extractable_properties[key] = idx
+        end
+
+        [extracted_rows, new_extractable_properties]
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def actions=(opts)
+        @actions = Pal::Operation::Actions.new.from_hash(opts)
+      end
+
+      # @return [Array<Pal::Operation::BaseExportHandler>]
+      def types=(types_conf)
+        @export_types = types_conf.map do |type_conf|
+          name = type_conf["name"]
+          settings = type_conf["settings"]
+
+          clazz_name = "Pal::Operation::#{name.to_s.capitalize}ExporterImpl"
+          Kernel.const_get(clazz_name).new(settings)
+        end
+      end
+    end
+
+    module FileExportable
+      # @param [String] file_path
+      # @param [String] contents
+      # @param [String] file_extension
+      def write_to_file(file_path, file_name, file_extension, contents)
+        file_location = "#{file_path}/#{file_name || Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S%-z")}"
+        Pal::Common::LocalFileUtils.with_file(file_location, file_extension) do |file|
+          file.write(contents)
+        end
+      end
+    end
+
+    class BaseExportHandler
+      include Pal::Configuration
+      include Pal::Log
+
+      # @return [Hash] settings
+      attr_accessor :settings
+
+      # @param [Hash] settings
+      def initialize(settings)
+        @settings = settings
+      end
+
+      # @param [Array] rows
+      # @param [Hash] columns
+      # Extract values, call export.
+      def run_export(rows, columns)
+        if rows.empty?
+          Pal.logger.warn("No results were found, will not export.")
+          return
+        end
+
+        _export(rows, columns)
+      end
+
+      protected
+
+      # @abstract
+      # @param [Array] _rows
+      # @param [Hash] _columns
+      def _export(_rows, _columns)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+    end
+
+    class CsvExporterImpl < BaseExportHandler
+      include FileExportable
+
+      # @param [Array] rows
+      # @param [Hash] column_headers
+      def _export(rows, column_headers)
+        file_contents = []
+        file_contents << column_headers.keys.join(",")
+
+        rows.each do |row|
+          file_contents << row.join(",")
+        end
+
+        write_to_file(
+          @settings["output_dir"], @settings["file_name"] || "pal", "csv", file_contents.join("\n")
+        )
+      end
+    end
+
+    require "terminal-table"
+
+    class TableExporterImpl < BaseExportHandler
+      # @param [Array] rows
+      # @param [Hash] column_headers
+      def _export(rows, column_headers)
+        title = @settings["title"] || "<No Title Set>"
+        style = @settings["style"] || {}
+
+        table = Terminal::Table.new(title: title, headings: column_headers.keys, rows: rows, style: style)
+        puts table
+      end
+    end
+    # do json exporter
+  end
+end

data/lib/pal/operation/filter_evaluator.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require "json"
+require "pal/common/object_helpers"
+require "pal/common/safe_hash_parse"
+
+module Pal
+  module Operation
+    # Filter evaluator runs the filter processes to identify candidates
+    class FilterEvaluator
+      # @return [Rule]
+      attr_reader :rule
+
+      def initialize(filters)
+        @rule = RuleFactory.from_hash(filters)
+      end
+
+      # @param [Array] row
+      # @param [Hash] column_headers
+      # @return [Boolean]
+      def test_property(row, column_headers)
+        return true if @rule.nil?
+
+        eval_ctx = EvaluationContext.new(row, column_headers)
+        @rule.evaluate(eval_ctx)
+      end
+    end
+
+    # Class to manage the rules provided
+    class RuleFactory
+      # @param [Hash] rule_hash
+      # @return [Rule]
+      # rubocop:disable Metrics/AbcSize
+      def self.from_hash(rule_hash)
+        return nil if rule_hash.nil? || rule_hash.keys.empty?
+
+        if rule_hash.key?("condition")
+          condition = rule_hash.fetch("condition")
+          rules = RuleFactory.from_group_rules(rule_hash)
+
+          return AndGroupRule.new(rules) if condition.casecmp("and").zero?
+          return OrGroupRule.new(rules) if condition.casecmp("or").zero?
+
+          raise "Invalid condition [#{condition}] passed."
+        end
+
+        return OperatorRule.new(rule_hash) if rule_hash.key?("operator")
+
+        raise "Hash is malformed."
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      # @return [Array<Rule>]
+      def self.from_group_rules(group_rule)
+        rules = group_rule.fetch("rules", [])
+
+        rules.map do |rule_hash|
+          from_hash(rule_hash)
+        end
+      end
+    end
+
+    class Rule
+      def evaluate(eval_ctx)
+        _evaluate(eval_ctx)
+      end
+
+      private
+
+      # @abstract
+      def _evaluate(_eval_ctx)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+    end
+
+    class GroupRule < Rule
+      # @return [Array<Rule>]
+      attr_reader :rule_group
+
+      # @param [Array<Rule>] rule_group
+      def initialize(rule_group)
+        @rule_group = rule_group
+        super()
+      end
+    end
+
+    class AndGroupRule < GroupRule
+      private
+
+      def _evaluate(eval_ctx)
+        @rule_group.all? do |rule|
+          rule.evaluate(eval_ctx)
+        end
+      end
+    end
+
+    class OrGroupRule < GroupRule
+      private
+
+      def _evaluate(eval_ctx)
+        @rule_group.any? do |rule|
+          rule.evaluate(eval_ctx)
+        end
+      end
+    end
+
+    class OperatorRule < Rule
+      # @return [String]
+      attr_reader :operator, :field
+
+      # @return [Object]
+      attr_reader :comparison_value
+
+      # @return [Symbol]
+      attr_reader :type
+
+      def initialize(rule_hash)
+        super()
+        @field = rule_hash.fetch("field")
+        @type = rule_hash.fetch("type").to_sym
+        @operator = rule_hash.fetch("operator").to_sym
+        @comparison_value = rule_hash.fetch("value")
+      end
+
+      # @param [EvaluationContext] eval_ctx
+      # @return [Boolean]
+      def _evaluate(eval_ctx)
+        operator_candidates = get_operators_for_type(@type)
+
+        property = eval_ctx.get_value(@field)
+        return false unless property
+
+        proc = operator_candidates.fetch(@operator, proc do |_x, _y|
+          raise "Invalid operator given - [#{@operator}]. Valid candidates are [#{operator_candidates.keys.join(", ")}]"
+        end)
+
+        converted_comparison = convert_property(@type, @comparison_value)
+        converted_property = convert_property(@type, property)
+
+        proc.call(converted_property, converted_comparison)
+      end
+
+      # @param [Symbol] type
+      # @return [Hash{Symbol->Proc}]
+      def get_operators_for_type(type)
+        case type
+        when :string
+          string_operators
+        when :number
+          number_operators
+        when :date
+          date_operators
+        when :json
+          json_operators
+        else
+          raise "Missing filter operator for [#{type}], valid candidates: [string, number, tag, date]"
+        end
+      end
+
+      # @param [Symbol] type
+      # @return [Object]
+      def convert_property(type, prop)
+        case type
+        when :string
+          prop.to_s
+        when :number
+          prop.is_a?(Array) ? prop : prop.to_f
+        when :json
+          prop
+        when :date
+          Date.parse(prop)
+        else
+          raise "Missing property operator for [#{type}], valid candidates: [string, number, json, date]"
+        end
+      end
+
+      private
+
+      # rubocop:disable Metrics/AbcSize
+      # @return [Hash{Symbol->Proc}]
+      def string_operators
+        {
+          equal: proc { |x, y| x == y },
+          not_equal: proc { |x, y| x != y },
+          begins_with: proc { |x, y| x.start_with?(y) },
+          not_begins_with: proc { |x, y| !x.start_with?(y) },
+          ends_with: proc { |x, y| x.end_with?(y) },
+          not_ends_with: proc { |x, y| !x.end_with?(y) },
+          contains: proc { |x, y| x.include?(y) },
+          not_contains: proc { |x, y| !x.include?(y) },
+          is_empty: proc { |x, _y| x.empty? },
+          is_not_empty: proc { |x, _y| !x.empty? }
+        }
+      end
+
+      # @return [Hash{Symbol->Proc}]
+      def number_operators
+        {
+          equal: proc { |x, y| x == y },
+          not_equal: proc { |x, y| x != y },
+          less: proc { |x, y| x < y },
+          less_or_equal: proc { |x, y| x <= y },
+          greater: proc { |x, y| x > y },
+          greater_or_equal: proc { |x, y| x >= y },
+          between: proc { |x, y| y.is_a?(Array) ? x.between?(y.first, y.last) : false },
+          not_between: proc { |x, y| y.is_a?(Array) ? !x.between?(y.first, y.last) : false }
+        }
+      end
+      alias date_operators number_operators
+
+      # @return [Hash{Symbol->Proc}]
+      def json_operators
+        {
+          key_equal: proc do |x, y|
+            !SafeHashParse.extract_from_json(x, y).empty?
+          end,
+          key_not_equal: proc do |x, y|
+            SafeHashParse.extract_from_json(x, y).empty?
+          end,
+          value_equal: proc do |x, y|
+            SafeHashParse.all_values_from_json(x).include?(y)
+          end,
+          value_not_equal: proc do |x, y|
+            !SafeHashParse.all_values_from_json(x).include?(y)
+          end,
+          jpath: proc do |x, y|
+            path, value = y.split("=")
+            SafeHashParse.extract_from_json(x, path).include?(value)
+          end
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+    end
+
+    class EvaluationContext
+      attr_accessor :row, :column_headers
+
+      def initialize(row, column_headers)
+        @row = row
+        @column_headers = column_headers
+      end
+
+      def get_value(key)
+        idx = @column_headers.fetch(key, -1)
+        idx.zero? || idx.positive? ? @row[idx] : nil
+      end
+    end
+  end
+end

data/lib/pal/operation/processor_context.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Pal
+  module Operation
+    class ProcessorContext
+      attr_accessor :total_row_count, :current_file_row_count, :candidates, :column_headers, :column_type_definitions
+
+      def initialize
+        @total_row_count = 0
+        @current_file_row_count = 0
+        @candidates = []
+        @column_headers = {}
+      end
+
+      # @param [Array<String>] row
+      def extract_column_headers(row)
+        row.each_with_index { |column, idx| @column_headers[column] = idx }
+      end
+
+      def add_candidate(row)
+        @candidates << row
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def cast(column_header, value)
+        return value unless @column_type_definitions&.key?(column_header)
+
+        case @column_type_definitions[column_header]["data_type"]
+        when "string"
+          value.to_s
+        when "decimal"
+          value.to_f
+        when "integer"
+          value.to_i
+        when "date_time"
+          DateTime.parse(value)
+        when "date"
+          Date.parse(value)
+        when nil
+          value
+        else
+          value
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+  end
+end