cure 0.1.1 → 0.4.0

data/lib/cure/generator/character_generator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+
+module Cure
+  module Generator
+    class CharacterGenerator < BaseGenerator
+
+      def initialize(options=nil)
+        super(options)
+      end
+
+      private
+
+      # @param [Object] source_value
+      # @param [RowCtx] _row_ctx
+      def _generate(source_value, _row_ctx)
+        arr = build_options.map(&:to_a).flatten
+        (0...length(source_value&.length || 5)).map { arr[rand(arr.length)] }.join
+      end
+
+      def build_options
+        return [("a".."z"), ("A".."Z"), (0..9)] unless @options.key?(:types)
+
+        type_array = @options[:types]
+
+        arr = []
+        arr << ("a".."z") if type_array.include? "lowercase"
+        arr << ("A".."Z") if type_array.include? "uppercase"
+        arr << (0..9) if type_array.include? "number"
+        arr << ("!".."+") if type_array.include? "symbol"
+        arr
+      end
+
+      def _describe
+        "Will create a random list of #{@options[:types]} " \
+        "with as many characters as the source string."
+      end
+    end
+  end
+end

data/lib/cure/generator/erb_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+require "erb"
+
+module Cure
+  module Generator
+    class ErbGenerator < BaseGenerator
+      private
+
+      # @param [Cure::Transformation::RowCtx] _source_value
+      # @param [RowCtx] row_ctx
+      def _generate(_source_value, row_ctx)
+        template = @options.fetch(:template, nil)
+        ERB.new(template).result_with_hash(row_ctx.row)
+      end
+
+      def _describe; end
+    end
+  end
+end

data/lib/cure/generator/eval_generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+
+module Cure
+  module Generator
+    class EvalGenerator < BaseGenerator
+      private
+
+      # @param [Object] _source_value
+      # @param [Transformation::RowCtx] _row_ctx
+      # This will be changed with expression evaluator
+      def _generate(_source_value, _row_ctx)
+        eval_str = extract_property("eval", nil)
+        result = nil
+        with_safe do
+          result = eval(eval_str) # rubocop:disable Security/Eval
+        end
+
+        result
+      rescue StandardError => e
+        raise "Cannot eval statement #{extract_property("eval", nil)} [#{e.message}]"
+      end
+
+      def with_safe(&_block)
+        $SAFE = 1
+        yield
+        $SAFE = 0
+      end
+
+      def _describe; end
+    end
+  end
+end

data/lib/cure/generator/faker_generator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+require "faker"
+
+module Cure
+  module Generator
+    class FakerGenerator < BaseGenerator
+      private
+
+      # @param [Object] _source_value
+      # @param [RowCtx] _row_ctx
+      def _generate(_source_value, _row_ctx)
+        mod_code = extract_property("module", nil)
+        mod = Faker.const_get(mod_code)
+
+        raise "No Faker module found for [#{mod_code}]" unless mod
+
+        meth_code = extract_property("method", nil)&.to_sym
+        raise "No Faker module found for [#{meth_code}]" unless mod.methods.include?(meth_code)
+
+        mod.send(meth_code)
+      end
+
+      def _describe
+        "Will create a Faker value from [#{extract_property("module", nil)}::" \
+        "#{extract_property("method", nil)}]"
+      end
+    end
+  end
+end

data/lib/cure/generator/guid_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+
+module Cure
+  module Generator
+    class GuidGenerator < BaseGenerator
+      private
+
+      # @param [Object] _source_value
+      # @param [RowCtx] _row_ctx
+      def _generate(_source_value, _row_ctx)
+        SecureRandom.uuid.to_s.slice(0, @options.fetch(:length, 36))
+      end
+
+      def _describe
+        "Will create a random GUID."
+      end
+    end
+  end
+end

data/lib/cure/generator/hex_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+
+module Cure
+  module Generator
+    class HexGenerator < BaseGenerator
+      private
+
+      # @param [Object] _source_value
+      # @param [RowCtx] _row_ctx
+      def _generate(_source_value, _row_ctx)
+        1.upto(length(rand(0..9))).map { rand(0..15).to_s(16) }.join("")
+      end
+
+      def _describe
+        "Will create a random list of hex values matching the length of the source string."
+      end
+    end
+  end
+end

data/lib/cure/generator/imports.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+require "cure/generator/hex_generator"
+require "cure/generator/case_generator"
+require "cure/generator/character_generator"
+require "cure/generator/faker_generator"
+require "cure/generator/guid_generator"
+require "cure/generator/number_generator"
+require "cure/generator/placeholder_generator"
+require "cure/generator/redact_generator"
+require "cure/generator/variable_generator"
+require "cure/generator/eval_generator"
+require "cure/generator/erb_generator"
+require "cure/generator/proc_generator"
+require "cure/generator/static_generator"

data/lib/cure/generator/number_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+
+module Cure
+  module Generator
+    class NumberGenerator < BaseGenerator
+      private
+
+      # @param [Object] _source_value
+      # @param [RowCtx] _row_ctx
+      def _generate(_source_value, _row_ctx)
+        1.upto(length(rand(0..9))).map { rand(1..9) }.join("").to_i
+      end
+
+      def _describe
+        "Will create a random list of numbers matching the length of the source string."
+      end
+    end
+  end
+end

data/lib/cure/generator/placeholder_generator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+require "cure/config"
+
+module Cure
+  module Generator
+    class PlaceholderGenerator < BaseGenerator
+      include Cure::Configuration
+
+      private
+
+      # @param [Object] _source_value
+      # @param [RowCtx] _row_ctx
+      def _generate(_source_value, _row_ctx)
+        value = config.placeholders[property_name]
+        value || raise("Missing placeholder value. Available candidates: [#{config.placeholders.keys.join(", ")}]")
+      end
+
+      def _describe
+        "Will look up placeholders using '#{property_name}'. " \
+        "[Set as '#{config.placeholders[property_name]}']"
+      end
+    end
+  end
+end

data/lib/cure/generator/proc_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+require "erb"
+
+module Cure
+  module Generator
+    class ProcGenerator < BaseGenerator
+      private
+
+      # @param [Cure::Transformation::RowCtx] source_value
+      # @param [RowCtx] row_ctx
+      def _generate(source_value, row_ctx)
+        proc = @options.fetch(:execute, nil)
+        proc.call(source_value, row_ctx)
+      end
+
+      def _describe; end
+    end
+  end
+end

data/lib/cure/generator/redact_generator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+
+module Cure
+  module Generator
+    class RedactGenerator < BaseGenerator
+      private
+
+      # @param [object] source_value
+      # @param [RowCtx] _row_ctx
+      def _generate(source_value, _row_ctx)
+        1.upto(length(source_value&.length || 5)).map { @options.fetch(:character, "x") }.join("")
+      end
+
+      def _describe
+        "Will replace the length of the source string with X."
+      end
+
+    end
+  end
+end

data/lib/cure/generator/static_generator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+
+module Cure
+  module Generator
+    class StaticGenerator < BaseGenerator
+      private
+
+      # @param [Object] _source_value
+      # @param [RowCtx] _row_ctx
+      def _generate(_source_value, _row_ctx)
+        @options.fetch(:value, nil)
+      end
+
+      def _describe
+        "Will return the defined value [#{@options.fetch(:value, nil)}]"
+      end
+    end
+  end
+end

data/lib/cure/generator/variable_generator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+require "cure/config"
+require "cure/database"
+
+module Cure
+  module Generator
+    class VariableGenerator < BaseGenerator
+      include Database
+
+      private
+
+      # @param [object] _source_value
+      # @param [RowCtx] _row_ctx
+      def _generate(_source_value, _row_ctx)
+        value = database_service.find_variable(property_name)
+        value || raise("Missing placeholder value [#{property_name}]. Please check you are defining it correctly.")
+      end
+
+      def _describe
+        "Will look up the variables defined using '#{property_name}'."
+      end
+    end
+  end
+end

data/lib/cure/helpers/file_helpers.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+
+module Cure
+  module Helpers
+    module FileHelpers
+      def with_file(path, extension, &block)
+        dir = File.dirname(path)
+
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        path = "#{path}.#{extension}"
+        File.open(path, "w", &block)
+      end
+
+      def clean_dir(path)
+        dir = File.file?(path) ? File.dirname(path) : path
+
+        FileUtils.remove_dir(dir) if File.directory?(dir)
+      end
+
+      def read_file(file_location)
+        result = file_location.start_with?("/") ? file_location : Pathname.new(file_location)
+        # result = file_location.start_with?("/") ? file_location : File.join(File.dirname(__FILE__), file_location)
+
+        raise "No file found at [#{file_location}]" unless File.exist? result.to_s
+
+        File.read(result)
+      end
+
+      def open_file(file_location)
+        result = file_location.start_with?("/") ? file_location : Pathname.new(file_location)
+
+        raise "No file found at [#{file_location}]" unless File.exist? result.to_s
+
+        File.open(result)
+      end
+
+      def with_temp_dir(temp_dir, &_block)
+        return unless block_given?
+
+        clean_dir(temp_dir)
+        yield
+        clean_dir(temp_dir)
+      end
+    end
+  end
+end

data/lib/cure/helpers/object_helpers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "cure"
+require "json"
+
+module Cure
+  module Helpers
+    module ObjectHelpers
+      def class_exists?(klass_name)
+        klass = Module.const_get(klass_name)
+        klass.is_a?(Class)
+      rescue NameError
+        false
+      end
+    end
+  end
+end

data/lib/cure/helpers/perf_helpers.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "benchmark"
+
+module Cure
+  module Helpers
+    # This module uses some code sourced from here:
+    # https://torrocus.com/blog/different-ways-to-processing-large-csv-file-in-ruby/
+    module PerfHelpers
+      def print_memory_usage(process_name="default")
+        cmd = "ps -o rss= -p #{Process.pid}"
+        before_mem = `#{cmd}`.to_i
+        # before_gc = GC.stat(:total_allocated_objects)
+
+        yield
+        after_mem = `#{cmd}`.to_i
+        # after_gc = GC.stat(:total_allocated_objects)
+
+        log_info "Total Memory Usage [#{process_name}]: #{((after_mem - before_mem) / 1024.0).round(2)} MB"
+        # log_info "Total GC Objects Freed [#{process_name}]: #{after_gc - before_gc}"
+      end
+
+      def print_time_spent(process_name="default", &block)
+        time = Benchmark.realtime(&block)
+        log_info "Total Processing Time [#{process_name}]: #{time.round(2)}"
+      end
+    end
+  end
+end

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)
@@ -20,10 +27,10 @@ module Cure
     end
 
     # @param [String] message
-    # @param [Exception/Nil] ex
-    def log_error(message, ex=nil)
+    # @param [Exception/Nil] exception
+    def log_error(message, exception=nil)
       Cure.logger.error(message)
-      Cure.logger.error(ex.backtrace.join("\n")) unless ex.nil?
+      Cure.logger.error(exception.backtrace.join("\n")) unless exception.nil?
     end
   end
 end