cure 0.1.1 → 0.4.0

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "cure/strategy/base_strategy"
+
+module Cure
+  module Strategy
+    class AppendStrategy < 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)
+        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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "cure/validators"
+require "cure/strategy/history/history_cache"
+
+module Cure
+  module Strategy
+    class BaseStrategy
+      include History
+
+      # Additional details needed to make substitution.
+      # @return [BaseStrategyParams]
+      attr_accessor :params
+
+      def initialize(params)
+        # Is there a better way to do this? If its a base, we take a {}, if super
+        # defines it, we just use that instance.
+        @params = params.is_a?(Hash) ? BaseStrategyParams.new(params) : params
+      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, row_ctx, generator)
+        extracted_value = _retrieve_value(source_value)
+        existing = retrieve_history(extracted_value)
+
+        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)
+
+        value
+      end
+
+      def describe
+        _describe
+      end
+
+      private
+
+      def replace_partial_record
+        replace_partial = @params.replace_partial
+        return replace_partial || false unless replace_partial.instance_of?(String)
+
+        (replace_partial || "true").to_s == "true"
+      end
+
+      def value?(value)
+        !value.nil? && value != ""
+      end
+
+      # @param [String] _source_value
+      def _retrieve_value(_source_value)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+
+      # @param [String] _source_value
+      # @param [String] _generated_value
+      # @return [String]
+      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
+      include Validators::Helpers
+      extend Validators
+
+      # Additional details needed to make substitution.
+      # @return [Hash]
+      attr_accessor :options
+      attr_accessor :replace_partial, :force_replace
+
+      def initialize(options={})
+        @replace_partial = options[:replace_partial] || false
+        @force_replace = options[:force_replace] || false
+        @options = options
+
+        validate_params
+      end
+
+      def validate_params
+        valid?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "cure/strategy/base_strategy"
+
+module Cure
+  module Strategy
+    class EndWithStrategy < BaseStrategy
+      # Additional details needed to make substitution.
+      # @return [EndWithStrategyParams]
+      attr_accessor :params
+
+      def initialize(options)
+        super(EndWithStrategyParams.new(options))
+      end
+
+      # gsub catchment group
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        @params.match || nil if source_value.end_with? @params.match
+      end
+
+      # @param [String] source_value
+      # @param [String] generated_value
+      # @return [String]
+      def _replace_value(source_value, generated_value)
+        return unless source_value.end_with? @params.match
+
+        return generated_value unless replace_partial_record
+
+        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
+      attr_reader :match
+
+      validates :match
+
+      def initialize(options=nil)
+        @match = options[:match]
+        super(options)
+      end
+    end
+  end
+end

data/lib/cure/strategy/full_strategy.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "cure/strategy/base_strategy"
+
+module Cure
+  module Strategy
+    class FullStrategy < 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
+      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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "cure/strategy/base_strategy"
+require "cure/strategy/end_with_strategy"
+require "cure/strategy/full_strategy"
+require "cure/strategy/match_strategy"
+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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "cure/strategy/base_strategy"
+
+module Cure
+  module Strategy
+    class MatchStrategy < BaseStrategy
+      # Additional details needed to make substitution.
+      # @return [MatchStrategyParams]
+      attr_accessor :params
+
+      def initialize(options)
+        super(MatchStrategyParams.new(options))
+      end
+
+      # gsub catchment group
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        @params.match || nil if source_value.include? @params.match
+      end
+
+      # @param [String] source_value
+      # @param [String] generated_value
+      # @return [String]
+      def _replace_value(source_value, generated_value)
+        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
+      attr_reader :match
+
+      validates :match
+
+      def initialize(options=nil)
+        @match = options[:match]
+        super(options)
+      end
+    end
+  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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "cure/strategy/base_strategy"
+
+module Cure
+  module Strategy
+    class RegexStrategy < BaseStrategy
+      # Additional details needed to make substitution.
+      # @return [RegexStrategyParams]
+      attr_accessor :params
+
+      def initialize(options)
+        super(RegexStrategyParams.new(options))
+      end
+
+      # gsub catchment group
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        m = /#{@params.regex_cg}/.match(source_value)
+        return unless m.instance_of?(MatchData) && (!m[1].nil? && m[1] != "")
+
+        m[1]
+      end
+
+      # @param [String] source_value
+      # @param [String] generated_value
+      # @return [String]
+      def _replace_value(source_value, generated_value)
+        m = /#{@params.regex_cg}/.match(source_value)
+        return unless m.instance_of?(MatchData) && (!m[1].nil? && m[1] != "")
+
+        generated_value unless replace_partial_record
+
+        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
+      attr_reader :regex_cg
+
+      validates :regex_cg
+
+      def initialize(options=nil)
+        @regex_cg = options[:regex_cg]
+        super(options)
+      end
+    end
+  end
+end

data/lib/cure/strategy/split_strategy.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "cure/strategy/base_strategy"
+
+module Cure
+  module Strategy
+    class SplitStrategy < BaseStrategy
+      # Additional details needed to make substitution.
+      # @return [SplitStrategyParams]
+      attr_accessor :params
+
+      def initialize(options)
+        super(SplitStrategyParams.new(options))
+      end
+
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        return unless source_value.include?(@params.token)
+
+        result_arr = source_value.split(@params.token)
+        result_arr[@params.index]
+      end
+
+      # @param [String] source_value
+      # @param [String] generated_value
+      # @return [String]
+      def _replace_value(source_value, generated_value)
+        split_token = @params.token
+
+        return unless source_value.include?(split_token)
+
+        result_arr = source_value.split(split_token)
+        result_arr[@params.index] = generated_value if value?(result_arr[@params.index])
+        result_arr.join(split_token)
+      end
+
+      def _describe
+        "Splitting on '#{@params.token}', at index #{@params.index}) " \
+        "[Note: If the value does not include '#{@params.token}', no substitution is made.]"
+      end
+    end
+
+    class SplitStrategyParams < BaseStrategyParams
+      attr_reader :token, :index
+
+      validates :token, validator: :presence
+      validates :index, validator: :presence
+
+      def initialize(options=nil)
+        @token = options[:token]
+        @index = options[:index]
+        # valid?
+
+        super(options)
+      end
+    end
+  end
+end