cure 0.1.1 → 0.4.0

data/lib/cure/strategy/start_with_strategy.rb

@@ -0,0 +1,53 @@
+# 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
+
+      def _describe
+        "Start 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 StartWithStrategyParams < BaseStrategyParams
+      attr_reader :match
+
+      validates :match
+
+      def initialize(options=nil)
+        @match = options[:match]
+        super(options)
+      end
+    end
+  end
+end

data/lib/cure/transformation/candidate.rb

@@ -1,86 +1,97 @@
 # frozen_string_literal: true
 
-require "cure/object_helpers"
-require "cure/strategy/base"
-require "cure/generator/base"
+require "cure/helpers/object_helpers"
+require "cure/strategy/imports"
+require "cure/generator/imports"
+require "cure/extract/extractor"
 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 Helpers::ObjectHelpers
       include Log
 
+      # Named range that column exists in
+      # @return [String]
+      attr_reader :named_range
+
       # Lookup column name for CSV.
       # @return [String]
-      attr_accessor :column
+      attr_reader :column
 
       # What sort of data needs to be generated.
       # @return [List<Translation>]
       attr_reader :translations
 
+      # @return [Translation]
       attr_reader :no_match_translation
 
-      # @param [String] source_value
-      # @return [String]
+      attr_reader :ignore_empty
+
+      def initialize(column, named_range: Cure::Extraction.default_named_range, options: {})
+        @column = column
+        @named_range = named_range
+        @ignore_empty = options.fetch(:ignore_empty, false)
+
+        @translations = []
+        @no_match_translation = nil
+      end
+
+      # @param [String, Nil] source_value
+      # @param [RowCtx] row_ctx
+      # @return [String,nil]
       # Transforms the existing value
-      def perform(source_value)
-        # log_debug("Performing substitution for [#{@column}] with [#{@translations.length}] translations")
+      def perform(source_value, row_ctx)
         value = source_value
 
         @translations.each do |translation|
-          temp = translation.extract(value)
+          temp = translation.extract(value, row_ctx)
           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}]")
+        if value == source_value && @no_match_translation
+          log_trace("No translation made for #{value} [#{source_value}]")
+          value = @no_match_translation.extract(source_value, row_ctx)
+          log_trace("Translated to #{value} from [#{source_value}]")
         end
 
         value
       end
 
-      def translations=(opts)
-        @translations = opts.map { |o| Translation.new.from_hash(o) }
+      def with_translations(translations)
+        @translations = translations
+        self
       end
 
-      def no_match_translation=(opts)
-        @no_match_translation = Translation.new.from_hash(opts)
+      def with_no_match_translation(no_match_translation)
+        @no_match_translation = no_match_translation
+        self
       end
     end
 
     class Translation
-      include ObjectHelpers
+      include Helpers::ObjectHelpers
 
       # What sort of replacement is done, full/random/lookup/partial.
-      # @return [Strategy::Base]
+      # @return [Strategy::BaseStrategy]
       attr_reader :strategy
 
       # What sort of data needs to be generated.
-      # @return [Generator::Base]
+      # @return [Generator::BaseGenerator]
       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"] || {})
+      def initialize(strategy, generator)
+        @strategy = strategy
+        @generator = generator
       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"] || {})
+      # @param [String] source_value
+      # @return [String]
+      def extract(source_value, row_ctx)
+        @strategy.extract(source_value, row_ctx, @generator)
       end
     end
   end
 end
-

data/lib/cure/transformation/transform.rb

@@ -1,14 +1,19 @@
 # frozen_string_literal: true
 
 require "cure/log"
-require "cure/file_helpers"
+require "cure/helpers/file_helpers"
+require "cure/config"
+require "cure/extract/extractor"
+
 require "rcsv"
 
 module Cure
   module Transformation
+    # Operational file for conducting transforms
     class Transform
       include Log
-      include FileHelpers
+      include Helpers::FileHelpers
+      include Configuration
 
       # @return [Array<Candidate>]
       attr_accessor :candidates
@@ -18,87 +23,40 @@ module Cure
         @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
+      # @param [Hash] row
+      # @return [Hash]
+      def transform(row)
+        original_row = row.dup
 
-        ctx
-      end
+        @candidates.each do |candidate|
+          column = candidate.column.to_sym
 
-      private
+          next unless row.key?(column)
 
-      # @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?
+          existing_value = row[column]
+          next if existing_value.nil? && candidate.ignore_empty
 
-        Rcsv.parse(file_contents, opts) do |row|
-          ctx.row_count += 1
-          yield row
+          new_value = candidate.perform(existing_value, RowCtx.new(row, original_row: original_row)) # transform value
+          row[column] = new_value
         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
+        remove_system_columns(row)
+      end
 
+      def remove_system_columns(row)
+        row.delete(:_id)
         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
+    # This class looks useless, but it isn't. It exists purely to give a hook to add
+    # more stuff to a strategy in the future without the method signature changing
+    class RowCtx
+      attr_accessor :row, :original_row
 
-      def add_transformed_row(row)
-        @transformed_rows << row
+      def initialize(row, original_row: nil)
+        @row = row
+        @original_row = original_row
       end
     end
   end

data/lib/cure/validator/base_rule.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "cure/log"
+require "cure/config"
+require "cure/database"
+require "cure/helpers/file_helpers"
+require "cure/extract/extractor"
+
+require "rcsv"
+
+module Cure
+  module Validator
+    class BaseRule
+
+      def initialize(named_range, column, options)
+        @named_range = named_range
+        @column = column
+        @options = options
+      end
+
+      def process(_value)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+
+      def to_s
+        "Base Rule"
+      end
+    end
+
+    class NotNullRule < BaseRule
+      def process(value)
+        !value.nil?
+      end
+
+      def to_s
+        "Not null"
+      end
+    end
+
+    class LengthRule < BaseRule
+      def process(value)
+        return true if value.nil?
+        return true unless value.respond_to? :size
+
+        length = value.size
+        length >= min && length <= max
+      end
+
+      def to_s
+        "Length [Min: #{min}, Max: #{max}]"
+      end
+
+      def min
+        @min || @options.fetch(:max, 0)
+      end
+
+      def max
+        @max || @options.fetch(:max, 99_999)
+      end
+    end
+
+    class CustomRule < BaseRule
+      def process(value)
+        return true if value.nil?
+
+        custom_proc.call(value)
+      end
+
+      def to_s
+        "Custom"
+      end
+
+      def custom_proc
+        @options.fetch(:proc, proc { |_x| false })
+      end
+    end
+  end
+end

data/lib/cure/validator/candidate.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "cure/helpers/object_helpers"
+require "cure/validator/base_rule"
+require "cure/log"
+
+module Cure
+  module Validator
+    class Candidate
+      include Helpers::ObjectHelpers
+      include Log
+
+      # Named range that column exists in
+      # @return [String]
+      attr_reader :named_range
+
+      # Lookup column name for CSV.
+      # @return [String]
+      attr_reader :column
+
+      # # What sort of data needs to be generated.
+      # # @return [Array<Cure::Validator::BaseRule>]
+      attr_reader :rules
+
+      DEFAULT_OPTIONS = {
+        fail_on_error: false
+      }.freeze
+
+      def initialize(column, named_range, options={})
+        @column = column
+        @named_range = named_range || "_default"
+        @options = DEFAULT_OPTIONS.merge(options)
+        @rules = []
+      end
+
+      def perform(value)
+        result = @rules.filter_map do |rule|
+          rule.process(value) ? nil : "#{rule} failed -> [#{@column}][#{value}]"
+        end
+
+        raise "Validation failed:\n#{result.join("\n")}" if @options[:fail_on_error] && !result.empty?
+
+        result
+      end
+
+      def with_rule(method_name, options={})
+        klass_name = "Cure::Validator::#{method_name.to_s.split("_").map(&:capitalize).join}Rule"
+        raise "#{method_name} is not valid" unless class_exists?(klass_name)
+
+        @rules << Kernel.const_get(klass_name).new(@named_range, @column, options)
+      end
+    end
+  end
+end

data/lib/cure/validator/manager.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Cure
+  module Export
+    class Manager
+
+      # @param [Array<Cure::Validator::BaseRule>] candidates
+      attr_reader :validators
+
+      def initialize(named_range, validators)
+        @named_range = named_range
+        @validators = validators
+      end
+
+      # @param [Hash] row
+      def process_row(row)
+
+      end
+    end
+  end
+end

data/lib/cure/validators.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Cure
+  module Validators
+    # Should be an array, we can have multiple validators for the same obj
+    @validators = {}
+
+    class << self
+      attr_accessor :validators
+
+      # @param [String] prop
+      # @param [Object] options
+      def register_validator(caller, prop, options)
+        @validators[caller] = [] unless @validators.has_key? caller
+        @validators[caller] << {prop: "@#{prop}".to_sym, options:}
+      end
+
+      # @return [TrueClass, FalseClass]
+      def validate(zelf) # rubocop:disable Metrics/AbcSize
+        return true unless @validators.has_key? zelf.class
+
+        variables = instance_variables_hash(zelf)
+        @validators[zelf.class].all? do |k|
+          options = k[:options]
+          return true if options.empty? # No validator, no need to run.
+
+          validator_prop = options[:validator]
+          proc = case validator_prop
+                 when Symbol
+                   common_validators.fetch(validator_prop, proc { |_x| false })
+                 # when Proc
+                 #   validator_prop
+                 else
+                   proc { |_x| false }
+                 end
+
+          property = variables[k[:prop]]
+          proc.call(property)
+        end
+      end
+
+      # @param [Object] zelf
+      # @return [Hash]
+      def instance_variables_hash(zelf)
+        zelf.instance_variables.each_with_object({}) do |attribute, hash|
+          hash[attribute] = zelf.instance_variable_get(attribute)
+        end
+      end
+
+      def common_validators
+        {
+          presence: proc { |current_val| !current_val.nil? }
+        }
+      end
+    end
+
+    def validates(property, options={})
+      Validators.register_validator(self, property, options)
+    end
+
+    module Helpers
+      def valid?(suppress_error: false)
+        status = Validators.validate(self)
+        return true if status
+        return false if suppress_error
+
+        raise "Object is invalid"
+      end
+    end
+  end
+end

data/lib/cure/version.rb

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

data/lib/cure.rb

@@ -1,26 +1,39 @@
 # frozen_string_literal: true
 
+require "logger"
 require "cure/log"
+require "cure/launcher"
 require "cure/config"
 require "cure/version"
-
-require "cure/file_helpers"
+require "cure/dsl/template"
+require "cure/strategy/imports"
+require "cure/generator/imports"
 require "cure/transformation/transform"
-
-require "cure/main"
-
-require "logger"
+require "cure/helpers/file_helpers"
 
 module Cure
   class << self
     attr_writer :logger
 
+    attr_reader :config
+
     def logger
       @logger ||= Logger.new($stdout).tap do |log|
         log.progname = name
+        log.formatter = proc do |severity, _datetime, _progname, msg|
+          "[#{severity}] #{msg}\n"
+        end
       end
     end
 
+    def init(&block)
+      launcher = Cure::Launcher.new
+      launcher.with_config(&block)
+    end
 
+    def init_from_file(file_path)
+      launcher = Cure::Launcher.new
+      launcher.with_config_file(file_path)
+    end
   end
 end

data/templates/dsl_example.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+sources do
+  csv :pathname, Pathname.new("spec/cure/e2e/input/simple_names.csv"), ref_name: "names"
+  csv :pathname, Pathname.new("spec/cure/e2e/input/simple_ages.csv"), ref_name: "ages"
+end
+
+extract do
+  named_range name: "section_1", at: "B2:G6"
+  named_range name: "section_2", at: "B18:G20", headers: "B2:G2"
+
+  variable name: "new_field", location: "A16"
+  variable name: "new_field_2", location: "B16"
+end
+
+query do
+  with named_range: "section_1", query: <<-SQL
+    SELECT * FROM section_1
+  SQL
+
+  with named_range: "section_2", query: <<-SQL
+    SELECT * FROM section_2
+  SQL
+end
+
+build do
+  candidate column: "new_column", named_range: "section_1" do
+    add options: {}
+  end
+end
+
+transform do
+  candidate column: "new_column", named_range: "section_1" do
+    with_translation { replace("full").with("variable", name: "new_field") }
+  end
+
+  candidate column: "new_column", named_range: "section_2" do
+    with_translation { replace("full").with("variable", name: "new_field") }
+  end
+
+  placeholders({key: "value", key2: "value2"})
+end
+
+export do
+  terminal named_range: "section_1", title: "Exported", limit_rows: 5
+  csv named_range: "section_1", file: "/tmp/cure/section_1.csv"
+  csv named_range: "section_2", file: "/tmp/cure/section_2.csv"
+end

data/templates/empty_template.rb

@@ -0,0 +1,31 @@
+metadata do
+  # ...
+end
+
+sources do
+  # ...
+end
+
+extract do
+  # ...
+end
+
+validate do
+  # ...
+end
+
+build do
+  # ...
+end
+
+query do
+  # ...
+end
+
+transform do
+  # ...
+end
+
+export do
+  # ...
+end