cure 0.1.2 → 0.4.0

data/lib/cure/helpers/string.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# This code is by Ivan Black - available here:
+# https://stackoverflow.com/questions/1489183/how-can-i-use-ruby-to-colorize-the-text-output-to-a-terminal
+
+class String
+  def black
+    "\e[30m#{self}\e[0m"
+  end
+
+  def red
+    "\e[31m#{self}\e[0m"
+  end
+
+  def green
+    "\e[32m#{self}\e[0m"
+  end
+
+  def brown
+    "\e[33m#{self}\e[0m"
+  end
+
+  def blue
+    "\e[34m#{self}\e[0m"
+  end
+
+  def magenta
+    "\e[35m#{self}\e[0m"
+  end
+
+  def cyan
+    "\e[36m#{self}\e[0m"
+  end
+
+  def gray
+    "\e[37m#{self}\e[0m"
+  end
+
+  def bold
+    "\e[1m#{self}\e[22m"
+  end
+
+  def italic
+    "\e[3m#{self}\e[23m"
+  end
+
+  def underline
+    "\e[4m#{self}\e[24m"
+  end
+
+  def blink
+    "\e[5m#{self}\e[25m"
+  end
+end

data/lib/cure/launcher.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "cure/transformation/candidate"
+require "cure/transformation/transform"
+require "cure/coordinator"
+require "cure/database"
+require "cure/planner"
+require "cure/config"
+
+require "json"
+
+module Cure
+  class Launcher
+    include Database
+    include Configuration
+    include Helpers::FileHelpers
+
+    # @return [Cure::Coordinator]
+    attr_accessor :coordinator
+
+    def initialize(coordinator: Coordinator.new, planner: Planner.new)
+      @coordinator = coordinator
+      @planner = planner
+      @validated = false
+      @csv_files = []
+    end
+
+    # This will only support single file CSV processing, and is deprecated now
+    #
+    # @param [Symbol] type
+    # @param [Object] obj
+    # @param [TrueClass,FalseClass] print_query_plan
+    # @return [void]
+    # @deprecated
+    def process(type, obj, print_query_plan: true)
+      @csv_files << Cure::Configuration::CsvFileProxy.load_file(type, obj, "_default")
+      run_export(print_query_plan: print_query_plan)
+    end
+
+    def run_export(print_query_plan: true)
+      setup
+
+      raise "Not initialized" unless @validated
+
+      query_plan if print_query_plan
+      @coordinator.process
+    end
+
+    # -- Builder opts start
+
+    # @param [Symbol] type
+    # @param [Object] obj
+    # @return [Cure::Main]
+    def with_csv_file(type, obj, ref_name: nil)
+      if ref_name.nil?
+        ref_name = @csv_files.length.zero? ? "_default" : "_default_#{@csv_files.length}"
+      end
+
+      @csv_files << Cure::Configuration::CsvFileProxy.load_file(type, obj, ref_name)
+      self
+    end
+
+    # @return [Cure::Main]
+    def with_config(&block)
+      raise "No block given to config" unless block
+
+      dsl = Dsl::DslHandler.init(&block)
+      @template = dsl.generate
+
+      load_csv_from_config
+
+      self
+    end
+
+    # @return [Cure::Main]
+    def with_config_file(file_location)
+      contents = read_file(file_location.to_s)
+
+      dsl = Dsl::DslHandler.init_from_content(contents, "cure")
+      @template = dsl.generate
+
+      load_csv_from_config
+
+      self
+    end
+
+    # -- Builder end
+
+    # @return [Cure::Main]
+    def setup
+      raise "CSV File(s) are required" if @csv_files.empty?
+      raise "Template is required" unless @template
+
+      config = create_config(@csv_files, @template)
+      register_config(config)
+
+      init_database
+      init_history
+
+      @validated = true
+      self
+    end
+
+    # @return [void]
+    def query_plan
+      raise "Not initialized" unless @validated
+
+      @planner.process
+    end
+
+    private
+
+    def load_csv_from_config
+      return unless @template.source_files.has_candidates?
+
+      @template.source_files.candidates.each do |source|
+        with_csv_file(source.type, source.value, ref_name: source.ref_name)
+      end
+    end
+
+    def init_history
+      Cure::History::HistoryCache.instance.reset
+    end
+  end
+end

data/lib/cure/log.rb

@@ -4,6 +4,13 @@ require "cure"
 
 module Cure
   module Log
+    # @param [String] _message
+    def log_trace(_message)
+      # Ruby default logger doesnt have trace, so my version
+      # is to just uncomment it when you need it for now.
+      # Cure.logger.trace(message)
+    end
+
     # @param [String] message
     def log_debug(message)
       Cure.logger.debug(message)

data/lib/cure/planner.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "cure/log"
+require "cure/config"
+require "cure/helpers/string"
+
+require "artii"
+
+module Cure
+  class Planner
+    include Configuration
+    include Log
+
+    def process
+      print_starter
+      print_extract_plan
+      print_build_plan
+      print_transformations_plan
+      print_ender
+    end
+
+    def print_starter # rubocop:disable Metrics/AbcSize
+      a = Artii::Base.new({font: "isometric1"})
+      puts a.asciify("C u r e")
+      puts "\nIf you require assistance, please read:"
+      puts "https://github.com/williamthom-as/cure/tree/main/docs\n"
+      puts ""
+      log_info "_______________________________________________"
+      print_spacer
+      log_info "Cure Execution Plan".bold.underline
+      log_info ""
+      log_info "Source file location: #{config.source_files.map(&:description).join(",")}"
+      log_info "Template file descriptor below"
+
+      print_spacer
+    end
+
+    def print_ender
+      log_info "_______________________________________________"
+      print_spacer
+    end
+
+    def print_extract_plan # rubocop:disable Metrics/AbcSize
+      print_title "Extract"
+      named_ranges = config.template.extraction.named_ranges
+      variables = config.template.extraction.variables
+
+      if named_ranges.empty?
+        print_empty(named_ranges, "If you wanted to add a named range, please read docs/extraction.md")
+      else
+        log_info("[#{named_ranges.length}] named ranges specified")
+        named_ranges.each do |nr|
+          log_info "-- #{nr.name} will extract values from #{nr.section}"
+        end
+      end
+
+      print_spacer
+
+      if variables.empty?
+        print_empty("variables")
+      else
+        log_info("[#{variables.length}] variables specified")
+        variables.each do |v|
+          log_info "-- #{v.name} will extract from #{v.location}"
+        end
+      end
+
+      print_spacer
+    end
+
+    def print_build_plan
+      print_title "Build"
+      candidates = config.template.builder.candidates
+
+      if candidates.empty?
+        print_empty("Build")
+      else
+        candidates.each do |c|
+          log_info "-- #{c.column || "Multiple columns>"} from #{c.named_range} will be changed with #{c.action}"
+        end
+      end
+
+      print_spacer
+    end
+
+    def print_transformations_plan # rubocop:disable Metrics/AbcSize,Metrics/PerceivedComplexity
+      print_title "Transforms"
+      candidates = config.template.transformations.candidates
+      placeholders = config.template.transformations.placeholders
+
+      if candidates.empty?
+        print_empty("Transforms")
+      else
+        candidates.each do |c|
+          log_info "-- #{c.column} from #{c.named_range} will be changed with #{c.translations.size} translation"
+          c.translations.each do |tr|
+            log_info "\t\t> #{"Replacement".bold} [#{tr.strategy.class}]: #{tr.strategy.describe}"
+            log_info "\t\t> #{"Generator".bold} [#{tr.generator.class}]: #{tr.generator.describe}"
+          end
+        end
+      end
+
+      print_spacer
+
+      if placeholders.nil? || placeholders.empty?
+        print_empty("Placeholders")
+      else
+        log_info "-- Variables"
+        placeholders.each do |k, v|
+          log_info "\t\t> #{k} => #{v}"
+        end
+      end
+
+      print_spacer
+    end
+
+    private
+
+    # @param [String] title
+    def print_title(title)
+      log_info title.bold.underline
+      print_spacer
+    end
+
+    # @param [String] descriptor
+    # @param [String,nil] remedy
+    def print_empty(descriptor, remedy=nil)
+      log_info "No #{descriptor} specified.".italic
+      log_info "[Remedy: #{remedy}]" unless remedy.nil?
+    end
+
+    def print_spacer
+      log_info ""
+    end
+  end
+end

data/lib/cure/strategy/append_strategy.rb

@@ -19,6 +19,10 @@ module Cure
       def _replace_value(source_value, generated_value)
         source_value + generated_value
       end
+
+      def _describe
+        "Append generated value to the end of source value"
+      end
     end
   end
 end

data/lib/cure/strategy/base_strategy.rb

@@ -2,47 +2,10 @@
 
 require "singleton"
 require "cure/validators"
+require "cure/strategy/history/history_cache"
 
 module Cure
   module Strategy
-    # Singleton Strategy for storing data across all processes
-    module History
-      # @return [Hash]
-      def history
-        HistoryCache.instance.history_cache
-      end
-
-      # @return [String]
-      def retrieve_history(source_value)
-        history[source_value] unless source_value.nil? || source_value == ""
-      end
-
-      # @param [String] source_value
-      # @param [String] value
-      def store_history(source_value, value)
-        history[source_value] = value unless source_value.nil? || source_value == ""
-      end
-
-      def reset_history
-        HistoryCache.instance.reset
-      end
-      alias clear_history reset_history
-
-      class HistoryCache
-        include Singleton
-
-        attr_reader :history_cache
-
-        def initialize
-          @history_cache = {}
-        end
-
-        def reset
-          @history_cache = {}
-        end
-      end
-    end
-
     class BaseStrategy
       include History
 
@@ -57,17 +20,18 @@ module Cure
       end
 
       # @param [String] source_value
+      # @param [Transformation::RowCtx,nil] row_ctx
       # @param [Generator::BaseGenerator] generator
       # @return [String]
       #
       # This will retrieve the (partial) value, then generate a new replacement.
-      def extract(source_value, generator)
+      def extract(source_value, row_ctx, generator)
         extracted_value = _retrieve_value(source_value)
-
         existing = retrieve_history(extracted_value)
-        return _replace_value(source_value, existing) if existing
 
-        generated_value = generator.generate(source_value)&.to_s
+        return _replace_value(source_value, existing) if existing && !@params.force_replace
+
+        generated_value = generator.generate(source_value, row_ctx)&.to_s
         value = _replace_value(source_value, generated_value)
 
         store_history(extracted_value, generated_value)
@@ -75,6 +39,10 @@ module Cure
         value
       end
 
+      def describe
+        _describe
+      end
+
       private
 
       def replace_partial_record
@@ -99,6 +67,10 @@ module Cure
       def _replace_value(_source_value, _generated_value)
         raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
       end
+
+      def _describe
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
     end
 
     class BaseStrategyParams
@@ -108,11 +80,14 @@ module Cure
       # Additional details needed to make substitution.
       # @return [Hash]
       attr_accessor :options
-      attr_accessor :replace_partial
+      attr_accessor :replace_partial, :force_replace
 
       def initialize(options={})
-        @replace_partial = options["replace_partial"] || "false"
+        @replace_partial = options[:replace_partial] || false
+        @force_replace = options[:force_replace] || false
         @options = options
+
+        validate_params
       end
 
       def validate_params

data/lib/cure/strategy/contain_strategy.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "cure/strategy/base_strategy"
+
+module Cure
+  module Strategy
+    class ContainStrategy < BaseStrategy
+      # Additional details needed to make substitution.
+      # @return [ContainStrategyParams]
+      attr_accessor :params
+
+      def initialize(options)
+        super(ContainStrategyParams.new(options))
+      end
+
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        return unless source_value.include?(@params.match)
+
+        @params.match
+      end
+
+      # @param [String] source_value
+      # @param [String] generated_value
+      # @return [String]
+      def _replace_value(source_value, generated_value)
+        return unless source_value.include?(@params.match)
+
+        source_value.gsub(@params.match, generated_value)
+      end
+
+      def _describe
+        "Replacing matched value on '#{@params.match}') " \
+        "[Note: If the value does not include '#{@params.match}', no substitution is made.]"
+      end
+    end
+
+    class ContainStrategyParams < BaseStrategyParams
+      attr_reader :match
+
+      validates :match, validator: :presence
+
+      def initialize(options=nil)
+        @match = options[:match]
+        # valid?
+
+        super(options)
+      end
+    end
+  end
+end

data/lib/cure/strategy/end_with_strategy.rb

@@ -30,6 +30,12 @@ module Cure
         generated_value + @params.match
         # generated_value + source_value.reverse.chomp(@options["match"].reverse).reverse
       end
+
+      def _describe
+        "End with replacement will look for '#{@params.match}'. " \
+        "It will do a #{replace_partial_record ? "partial" : "full"} replacement. " \
+        "[Note: If the value does not include '#{@params.match}', no substitution is made.]"
+      end
     end
 
     class EndWithStrategyParams < BaseStrategyParams
@@ -38,7 +44,7 @@ module Cure
       validates :match
 
       def initialize(options=nil)
-        @match = options["match"]
+        @match = options[:match]
         super(options)
       end
     end

data/lib/cure/strategy/full_strategy.rb

@@ -19,6 +19,10 @@ module Cure
       def _replace_value(_source_value, generated_value)
         generated_value
       end
+
+      def _describe
+        "Full replacement of source value with generated value."
+      end
     end
   end
 end

data/lib/cure/strategy/history/history_cache.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "cure/database"
+
+# Singleton Strategy for storing data across all processes
+
+module Cure
+  module History
+
+    # @return [HistoryCache]
+    def history
+      HistoryCache.instance
+    end
+
+    # @return [String]
+    def retrieve_history(source_value)
+      history.search(source_value) unless source_value.nil? || source_value == ""
+    end
+
+    # @param [String] source_value
+    # @param [String] value
+    def store_history(source_value, value)
+      unless source_value.nil? || source_value == ""
+        history.insert(source_value, value)
+      end
+    end
+
+    def reset_history
+      history.reset
+    end
+    alias clear_history reset_history
+
+    class HistoryCache
+      include Database
+      include Singleton
+
+      attr_accessor :count
+
+      def initialize
+        @count = 0
+
+        init_cache
+      end
+
+      # @return [String]
+      def search(source_value, _named_range: nil, _column: nil)
+        database_service.find_translation(source_value)
+      end
+
+      def insert(source_value, value, named_range: nil, column: nil)
+        @count += 1
+
+        database_service.insert_row(:translations, [
+          @count, source_value, value, named_range, column
+        ])
+      end
+
+      def all_values
+        database_service.all_translations
+      end
+
+      def reset
+        @count = 0
+        if database_service.table_exist?(:translations)
+          database_service.truncate_table(:translations)
+        else
+          init_cache
+        end
+      end
+
+      def table_count
+        database_service.table_count(:translations)
+      end
+
+      def init_cache
+        return if database_service.table_exist?(:translations)
+
+        database_service.create_table(:translations, %w[source_value value named_range column])
+      end
+    end
+  end
+end

data/lib/cure/strategy/imports.rb

@@ -8,3 +8,5 @@ require "cure/strategy/regex_strategy"
 require "cure/strategy/split_strategy"
 require "cure/strategy/start_with_strategy"
 require "cure/strategy/append_strategy"
+require "cure/strategy/prepend_strategy"
+require "cure/strategy/contain_strategy"

data/lib/cure/strategy/match_strategy.rb

@@ -23,10 +23,15 @@ module Cure
       # @param [String] generated_value
       # @return [String]
       def _replace_value(source_value, generated_value)
-        return unless source_value.include? @params.match
+        return source_value unless source_value.include? @params.match
 
         source_value.gsub(@params.match, generated_value)
       end
+
+      def _describe
+        "Match replacement will look for the presence of '#{@params.match}', and replace that value. " \
+        "[Note: If the value does not include '#{@params.match}', no substitution is made.]"
+      end
     end
 
     class MatchStrategyParams < BaseStrategyParams
@@ -35,7 +40,7 @@ module Cure
       validates :match
 
       def initialize(options=nil)
-        @match = options["match"]
+        @match = options[:match]
         super(options)
       end
     end

data/lib/cure/strategy/prepend_strategy.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "cure/strategy/base_strategy"
+
+module Cure
+  module Strategy
+    class PrependStrategy < BaseStrategy
+      private
+
+      # @param [String] source_value
+      # @return [String]
+      def _retrieve_value(source_value)
+        source_value
+      end
+
+      # @param [String] source_value
+      # @param [String] generated_value
+      # @return [String]
+      def _replace_value(source_value, generated_value)
+        generated_value + source_value
+      end
+
+      def _describe
+        "Prepend generated value to the end of source value"
+      end
+    end
+  end
+end

data/lib/cure/strategy/regex_strategy.rb

@@ -33,6 +33,12 @@ module Cure
 
         source_value.gsub(m[1], generated_value)
       end
+
+      def _describe
+        "Matching on '#{@params.regex_cg}'. " \
+        "[Note: If the regex does not match, or has no capture group, no substitution is made.]"
+      end
+
     end
 
     class RegexStrategyParams < BaseStrategyParams
@@ -41,7 +47,7 @@ module Cure
       validates :regex_cg
 
       def initialize(options=nil)
-        @regex_cg = options["regex_cg"]
+        @regex_cg = options[:regex_cg]
         super(options)
       end
     end