cure 0.1.1 → 0.1.2

data/lib/cure/generator/placeholder_generator.rb

@@ -0,0 +1,20 @@
+# 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
+      def _generate(_source_value)
+        value = config.placeholders[property_name]
+        value || raise("Missing placeholder value. Available candidates: [#{config.placeholders.keys.join(", ")}]")
+      end
+    end
+  end
+end

data/lib/cure/generator/redact_generator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+
+module Cure
+  module Generator
+    class RedactGenerator < BaseGenerator
+      private
+
+      # @param [Object] source_value
+      def _generate(source_value)
+        1.upto(length(source_value&.length || 5)).map { "X" }.join("")
+      end
+    end
+  end
+end

data/lib/cure/generator/variable_generator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "cure/generator/base_generator"
+require "cure/config"
+
+module Cure
+  module Generator
+    class VariableGenerator < BaseGenerator
+      include Cure::Configuration
+
+      private
+
+      # @param [Object] _source_value
+      def _generate(_source_value)
+        value = config.variables[property_name]
+        value || raise("Missing placeholder value. Available candidates: [#{config.variables.keys.join(", ")}]")
+      end
+    end
+  end
+end

data/lib/cure/helpers/file_helpers.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+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 : File.join(File.dirname(__FILE__), file_location)
+
+        raise "No file found at [#{file_location}]" unless File.exist? result
+
+        File.read(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,29 @@
+# frozen_string_literal: true
+
+require "cure"
+require "json"
+
+module Cure
+  module Helpers
+    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
+end

data/lib/cure/log.rb

@@ -20,10 +20,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

data/lib/cure/main.rb

@@ -1,63 +1,72 @@
 # frozen_string_literal: true
 
-require "cure"
-require "json"
+require "cure/template/template"
 require "cure/transformation/candidate"
 require "cure/transformation/transform"
 require "cure/export/exporter"
+require "cure/coordinator"
 
-module Cure
+require "cure"
+require "json"
 
+module Cure
   class Main
     include Configuration
-    include FileHelpers
+    include Helpers::FileHelpers
 
+    # @param [String] template_file_loc
+    # @param [String] csv_file_loc
+    # @param [String] output_dir
     # @return [Cure::Main]
-    def self.init(template_file, csv_file, output_dir)
+    def self.init_from_file(template_file_loc, csv_file_loc, output_dir)
       # Run all init stuff here.
+      # Run validator?
+
       main = Main.new
-      main.setup(template_file, csv_file, output_dir)
+      template_hash = JSON.parse(main.read_file(template_file_loc))
+      template = Template.from_hash(template_hash)
+      main.setup(csv_file_loc, template, output_dir)
+      main
+    end
 
+    # @param [Hash] template_hash
+    # @param [String] csv_file_loc
+    # @param [String] output_dir
+    # @return [Cure::Main]
+    def self.init_from_hash(template_hash, csv_file_loc, output_dir)
+      # Run all init stuff here.
+      # Run validator?
+
+      main = Main.new
+      template = Template.from_hash(template_hash)
+      main.setup(csv_file_loc, template, output_dir)
       main
     end
 
-    # @return [Cure::Transformation::Transform]
-    attr_accessor :transformer
+    # @return [Cure::Coordinator]
+    attr_accessor :coordinator
 
     # @return [Boolean]
     attr_reader :is_initialised
 
     def initialize
       @is_initialised = false
+      @coordinator = Coordinator.new
     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)
+    def run_export
+      @coordinator.process
     end
 
-    def setup(template_file, csv_file, output_dir)
-      config = create_config(csv_file, JSON.parse(read_file(template_file)), output_dir)
+    # @param [String] csv_file_location
+    # @param [Cure::Template] template
+    # @param [String] output_dir
+    # @return [Cure::Main]
+    def setup(csv_file_location, template, output_dir)
+      config = create_config(csv_file_location, template, 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")
+      self
     end
   end
 end

data/lib/cure/strategy/append_strategy.rb

@@ -0,0 +1,24 @@
+# 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
+    end
+  end
+end

data/lib/cure/strategy/base_strategy.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "cure/validators"
+
+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
+
+      # 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 [Generator::BaseGenerator] 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
+
+      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
+    end
+
+    class BaseStrategyParams
+      include Validators::Helpers
+      extend Validators
+
+      # Additional details needed to make substitution.
+      # @return [Hash]
+      attr_accessor :options
+      attr_accessor :replace_partial
+
+      def initialize(options={})
+        @replace_partial = options["replace_partial"] || "false"
+        @options = options
+      end
+
+      def validate_params
+        valid?
+      end
+    end
+  end
+end

data/lib/cure/strategy/end_with_strategy.rb

@@ -0,0 +1,46 @@
+# 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
+    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,24 @@
+# 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
+    end
+  end
+end

data/lib/cure/strategy/imports.rb

@@ -0,0 +1,10 @@
+# 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"

data/lib/cure/strategy/match_strategy.rb

@@ -0,0 +1,43 @@
+# 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 unless source_value.include? @params.match
+
+        source_value.gsub(@params.match, generated_value)
+      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/regex_strategy.rb

@@ -0,0 +1,49 @@
+# 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
+    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,53 @@
+# 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
+    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

data/lib/cure/strategy/start_with_strategy.rb

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