cure 0.1.1

data/lib/cure/generator/base.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Cure
+  module Generator
+    class Base
+      # @return [Hash]
+      attr_accessor :options
+
+      def initialize(options={})
+        @options = options
+      end
+
+      # @param [Object/Nil] source_value
+      # @return [String]
+      def generate(source_value=nil)
+        translated = _generate(source_value)
+        translated = "#{prefix}#{translated}" if prefix
+        translated = "#{translated}#{suffix}" if suffix
+        translated
+      end
+
+      private
+
+      # @param [Object/Nil] _source_value
+      # @return [String]
+      def _generate(_source_value)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+
+      def prefix(default=nil)
+        extract_property("prefix", default)
+      end
+
+      def suffix(default=nil)
+        extract_property("suffix", default)
+      end
+
+      def length(default=nil)
+        extract_property("length", default)
+      end
+
+      def property_name(default=nil)
+        extract_property("name", default)
+      end
+
+      def extract_property(property, default_val)
+        @options.fetch(property, default_val)
+      end
+    end
+
+    class HexGenerator < Base
+      private
+
+      # @param [Object] _source_value
+      def _generate(_source_value)
+        1.upto(length(rand(0..9))).map { rand(0..15).to_s(16) }.join("")
+      end
+    end
+
+    class NumberGenerator < Base
+      private
+
+      # @param [Object] _source_value
+      def _generate(_source_value)
+        1.upto(length(rand(0..9))).map { rand(1..9) }.join("").to_i
+      end
+    end
+
+    class RedactGenerator < Base
+      private
+
+      # @param [Object] source_value
+      def _generate(source_value)
+        1.upto(length(source_value&.length || 5)).map { "X" }.join("")
+      end
+    end
+
+    class PlaceholderGenerator < Base
+      include Configuration
+
+      private
+
+      # @param [Object] _source_value
+      def _generate(_source_value)
+        value = config.placeholders[property_name]
+        value || raise("Missing placeholder value. Available candidates: [#{config.placeholders.join(", ")}]")
+      end
+    end
+
+    require "securerandom"
+
+    class GuidGenerator < Base
+      private
+
+      # @param [Object] _source_value
+      def _generate(_source_value)
+        SecureRandom.uuid.to_s
+      end
+    end
+
+    require "faker"
+
+    class FakerGenerator < Base
+      private
+
+      # @param [Object] _source_value
+      def _generate(_source_value)
+        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
+    end
+
+    class CharacterGenerator < Base
+
+      def initialize(options=nil)
+        super(options)
+      end
+
+      private
+
+      # @param [Object] source_value
+      def _generate(source_value)
+        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
+    end
+  end
+end

data/lib/cure/log.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "cure"
+
+module Cure
+  module Log
+    # @param [String] message
+    def log_debug(message)
+      Cure.logger.debug(message)
+    end
+
+    # @param [String] message
+    def log_info(message)
+      Cure.logger.info(message)
+    end
+
+    # @param [String] message
+    def log_warn(message)
+      Cure.logger.warn(message)
+    end
+
+    # @param [String] message
+    # @param [Exception/Nil] ex
+    def log_error(message, ex=nil)
+      Cure.logger.error(message)
+      Cure.logger.error(ex.backtrace.join("\n")) unless ex.nil?
+    end
+  end
+end

data/lib/cure/main.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "cure"
+require "json"
+require "cure/transformation/candidate"
+require "cure/transformation/transform"
+require "cure/export/exporter"
+
+module Cure
+
+  class Main
+    include Configuration
+    include FileHelpers
+
+    # @return [Cure::Main]
+    def self.init(template_file, csv_file, output_dir)
+      # Run all init stuff here.
+      main = Main.new
+      main.setup(template_file, csv_file, output_dir)
+
+      main
+    end
+
+    # @return [Cure::Transformation::Transform]
+    attr_accessor :transformer
+
+    # @return [Boolean]
+    attr_reader :is_initialised
+
+    def initialize
+      @is_initialised = false
+    end
+
+    def run
+      raise "Not init" unless @transformer
+
+      ctx = build_ctx
+      export(ctx)
+    end
+
+    # @return [Cure::Transform::TransformContext]
+    def build_ctx
+      @transformer.extract_from_file(config.source_file_location)
+    end
+
+    def setup(template_file, csv_file, output_dir)
+      config = create_config(csv_file, JSON.parse(read_file(template_file)), output_dir)
+      register_config(config)
+
+      candidates = config.template["candidates"].map { |c| Cure::Transformation::Candidate.new.from_json(c) }
+
+      @transformer = Cure::Transformation::Transform.new(candidates)
+      @is_initialised = true
+    end
+
+    private
+
+    # @param [Cure::Transform::TransformContext] ctx
+    def export(ctx)
+      Cure::Export::Exporter.export_ctx(ctx, config.output_dir, "csv_file")
+    end
+  end
+end

data/lib/cure/object_helpers.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "cure"
+require "json"
+
+module Cure
+  module ObjectHelpers
+    def attributes=(hash)
+      hash.each do |key, value|
+        send("#{key}=", value)
+      rescue NoMethodError
+        Cure.logger.warn("Error deserializing object: No property for #{key}")
+      end
+    end
+
+    def from_json(json)
+      return from_hash(json) if json.is_a?(Hash) # Just a guard in case serialisation is done
+
+      from_hash(JSON.parse(json))
+    end
+
+    def from_hash(hash)
+      self.attributes = hash
+      self
+    end
+  end
+end

data/lib/cure/strategy/base.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+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 Base
+      include History
+
+      # Additional details needed to make substitution.
+      # @return [Hash]
+      attr_accessor :options
+
+      def initialize(options)
+        @options = options
+      end
+
+      # @param [String] source_value
+      # @param [Generator::Base] generator
+      # @return [String]
+      #
+      # This will retrieve the (partial) value, then generate a new replacement.
+      def extract(source_value, 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
+        value = _replace_value(source_value, generated_value)
+
+        store_history(extracted_value, generated_value)
+
+        value
+      end
+
+      private
+
+      # @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 replace_partial_record
+        replace_partial = @options["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
+    end
+
+    class FullStrategy < Base
+      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
+    end
+
+    class RegexStrategy < Base
+      # gsub catchment group
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        m = /#{@options["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 = /#{@options["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
+    end
+
+    class MatchStrategy < Base
+      # gsub catchment group
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        @options["match"] || nil if source_value.include? @options["match"]
+      end
+
+      # @param [String] source_value
+      # @param [String] generated_value
+      # @return [String]
+      def _replace_value(source_value, generated_value)
+        return unless source_value.include? @options["match"]
+
+        source_value.gsub(@options["match"], generated_value)
+      end
+    end
+
+    class StartWithStrategy < Base
+      # gsub catchment group
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        @options["match"] || nil if source_value.start_with? @options["match"]
+      end
+
+      # @param [String] source_value
+      # @param [String] generated_value
+      # @return [String]
+      def _replace_value(source_value, generated_value)
+        return unless source_value.start_with? @options["match"]
+
+        return generated_value unless replace_partial_record
+
+        @options["match"] + generated_value
+        # source_value.chomp(@options["match"]) + generated_value
+      end
+    end
+
+    class EndWithStrategy < Base
+      # gsub catchment group
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        @options["match"] || nil if source_value.end_with? @options["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? @options["match"]
+
+        return generated_value unless replace_partial_record
+
+        generated_value + @options["match"]
+        # generated_value + source_value.reverse.chomp(@options["match"].reverse).reverse
+      end
+    end
+
+    class SplitStrategy < Base
+      # @param [String] source_value
+      def _retrieve_value(source_value)
+        split_token = @options["token"]
+
+        return unless source_value.include?(split_token)
+
+        result_arr = source_value.split(split_token)
+        result_arr[@options["index"]]
+      end
+
+      # @param [String] source_value
+      # @param [String] generated_value
+      # @return [String]
+      def _replace_value(source_value, generated_value)
+        split_token = @options["token"]
+
+        return unless source_value.include?(split_token)
+
+        result_arr = source_value.split(split_token)
+        result_arr[@options["index"]] = generated_value if value?(result_arr[@options["index"]])
+        result_arr.join(split_token)
+      end
+    end
+  end
+end

data/lib/cure/transformation/candidate.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "cure/object_helpers"
+require "cure/strategy/base"
+require "cure/generator/base"
+require "cure/log"
+
+module Cure
+  module Transformation
+    # Per row, we will have a candidate for each transformation that needs to be made
+    class Candidate
+      include ObjectHelpers
+      include Log
+
+      # Lookup column name for CSV.
+      # @return [String]
+      attr_accessor :column
+
+      # What sort of data needs to be generated.
+      # @return [List<Translation>]
+      attr_reader :translations
+
+      attr_reader :no_match_translation
+
+      # @param [String] source_value
+      # @return [String]
+      # Transforms the existing value
+      def perform(source_value)
+        # log_debug("Performing substitution for [#{@column}] with [#{@translations.length}] translations")
+        value = source_value
+
+        @translations.each do |translation|
+          temp = translation.extract(value)
+          value = temp if temp
+        end
+
+        if value == source_value
+          log_debug("No translation made for #{value} [#{source_value}]")
+          value = @no_match_translation&.extract(source_value)
+          log_debug("Translated to #{value} from [#{source_value}]")
+        end
+
+        value
+      end
+
+      def translations=(opts)
+        @translations = opts.map { |o| Translation.new.from_hash(o) }
+      end
+
+      def no_match_translation=(opts)
+        @no_match_translation = Translation.new.from_hash(opts)
+      end
+    end
+
+    class Translation
+      include ObjectHelpers
+
+      # What sort of replacement is done, full/random/lookup/partial.
+      # @return [Strategy::Base]
+      attr_reader :strategy
+
+      # What sort of data needs to be generated.
+      # @return [Generator::Base]
+      attr_reader :generator
+
+      # @param [String] source_value
+      # @return [String]
+      def extract(source_value)
+        @strategy.extract(source_value, @generator)
+      end
+
+      # @param [Hash] opts
+      def strategy=(opts)
+        clazz_name = "Cure::Strategy::#{opts["name"].to_s.capitalize}Strategy"
+        @strategy = Kernel.const_get(clazz_name).new(opts["options"] || {})
+      end
+
+      # @param [Hash] opts
+      def generator=(opts)
+        clazz_name = "Cure::Generator::#{opts["name"].to_s.capitalize}Generator"
+        @generator = Kernel.const_get(clazz_name).new(opts["options"] || {})
+      end
+    end
+  end
+end
+

data/lib/cure/transformation/transform.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "cure/log"
+require "cure/file_helpers"
+require "rcsv"
+
+module Cure
+  module Transformation
+    class Transform
+      include Log
+      include FileHelpers
+
+      # @return [Array<Candidate>]
+      attr_accessor :candidates
+
+      # @param [Array<Candidate>] candidates
+      def initialize(candidates)
+        @candidates = candidates
+      end
+
+      # @param [String] csv_file_location
+      # @return [TransformContext]
+      def extract_from_file(csv_file_location)
+        file_contents = read_file(csv_file_location)
+        extract_from_contents(file_contents)
+      end
+
+      # @param [String] file_contents
+      # @return [TransformContext]
+      def extract_from_contents(file_contents)
+        ctx = TransformContext.new
+        parse_content(ctx, file_contents, header: :none) do |row|
+          if ctx.row_count == 1
+            ctx.extract_column_headers(row)
+            next
+          end
+
+          row = transform(ctx.column_headers, row)
+          ctx.add_transformed_row(row)
+        end
+
+        ctx
+      end
+
+      private
+
+      # @param [TransformContext] ctx
+      # @param [String] file_contents
+      # @param [Proc] _block
+      # @param [Hash] opts
+      # @yield [Array] row
+      # @yield [TransformContext] ctx
+      # @return [TransformContext]
+      def parse_content(ctx, file_contents, opts={}, &_block)
+        return nil unless block_given?
+
+        Rcsv.parse(file_contents, opts) do |row|
+          ctx.row_count += 1
+          yield row
+        end
+      end
+
+      # @param [Hash] column_headers
+      # @param [Array] row
+      # @return [Array]
+      def transform(column_headers, row)
+        @candidates.each do |candidate|
+          column_idx = column_headers[candidate.column]
+          next unless column_idx
+
+          existing_value = row[column_idx]
+          next unless existing_value
+
+          new_value = candidate.perform(existing_value) # transform value
+          row[column_idx] = new_value
+        end
+
+        row
+      end
+    end
+
+    class TransformContext
+      include FileHelpers
+
+      attr_accessor :row_count,
+                    :transformed_rows,
+                    :column_headers
+
+      def initialize
+        @row_count = 0
+        @transformed_rows = []
+        @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_transformed_row(row)
+        @transformed_rows << row
+      end
+    end
+  end
+end

data/lib/cure/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Cure
+  VERSION = "0.1.1"
+end