cure 0.1.2 → 0.4.0

data/lib/cure/strategy/split_strategy.rb

@@ -33,6 +33,11 @@ module Cure
         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
@@ -42,9 +47,9 @@ module Cure
       validates :index, validator: :presence
 
       def initialize(options=nil)
-        @token = options["token"]
-        @index = options["index"]
-        valid?
+        @token = options[:token]
+        @index = options[:index]
+        # valid?
 
         super(options)
       end

data/lib/cure/strategy/start_with_strategy.rb

@@ -31,6 +31,12 @@ module Cure
 
         @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
@@ -39,7 +45,7 @@ module Cure
       validates :match
 
       def initialize(options=nil)
-        @match = options["match"]
+        @match = options[:match]
         super(options)
       end
     end

data/lib/cure/transformation/candidate.rb

@@ -3,6 +3,7 @@
 require "cure/helpers/object_helpers"
 require "cure/strategy/imports"
 require "cure/generator/imports"
+require "cure/extract/extractor"
 require "cure/log"
 
 module Cure
@@ -14,11 +15,11 @@ module Cure
 
       # Named range that column exists in
       # @return [String]
-      attr_accessor :named_range
+      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>]
@@ -27,40 +28,46 @@ module Cure
       # @return [Translation]
       attr_reader :no_match_translation
 
-      def initialize
+      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 = []
-        @named_range = "default"
+        @no_match_translation = nil
       end
 
-      # @param [String] source_value
-      # @return [String]
+      # @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
 
-      # @param [Hash] opts
-      def translations=(opts)
-        @translations = opts.map { |o| Translation.new.from_hash(o) }
+      def with_translations(translations)
+        @translations = translations
+        self
       end
 
-      # @param [Hash] opts
-      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
 
@@ -75,26 +82,16 @@ module Cure
       # @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

@@ -23,74 +23,40 @@ module Cure
         @candidates = candidates
       end
 
-      # @param [ParsedCSV] parsed_content
-      # @return [Hash<String,TransformResult>] # make this transformation results?
-      def transform_content(parsed_content)
-        parsed_content.content.each_with_object({}) do |section, hash|
-          ctx = TransformResult.new
-          section["rows"].each do |row|
-            ctx.row_count += 1
+      # @param [Hash] row
+      # @return [Hash]
+      def transform(row)
+        original_row = row.dup
 
-            if ctx.row_count == 1
-              ctx.extract_column_headers(row)
-              next
-            end
+        @candidates.each do |candidate|
+          column = candidate.column.to_sym
 
-            row = transform(section["name"], ctx.column_headers, row)
-            ctx.add_transformed_row(row)
-          end
+          next unless row.key?(column)
 
-          hash[section["name"]] = ctx
-        end
-      end
-
-      private
-
-      # @param [Hash] column_headers
-      # @param [Array] row
-      # @return [Array]
-      def transform(named_range, column_headers, row)
-        candidates_for_named_range(named_range).each do |candidate|
-          column_idx = column_headers[candidate.column]
-          next unless column_idx
+          existing_value = row[column]
+          next if existing_value.nil? && candidate.ignore_empty
 
-          existing_value = row[column_idx]
-          next unless existing_value
-
-          new_value = candidate.perform(existing_value) # transform value
-          row[column_idx] = new_value
+          new_value = candidate.perform(existing_value, RowCtx.new(row, original_row: original_row)) # transform value
+          row[column] = new_value
         end
 
-        row
+        remove_system_columns(row)
       end
 
-      # @param [String] named_range
-      # @return [Array<Cure::Transformation::Candidate>]
-      def candidates_for_named_range(named_range)
-        @candidates.select { |c| c.named_range == named_range }
+      def remove_system_columns(row)
+        row.delete(:_id)
+        row
       end
     end
 
-    class TransformResult
-      include Helpers::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

@@ -12,7 +12,7 @@ module Cure
       # @param [Object] options
       def register_validator(caller, prop, options)
         @validators[caller] = [] unless @validators.has_key? caller
-        @validators[caller] << {prop: "@#{prop}".to_sym, options: options}
+        @validators[caller] << {prop: "@#{prop}".to_sym, options:}
       end
 
       # @return [TrueClass, FalseClass]
@@ -28,8 +28,8 @@ module Cure
           proc = case validator_prop
                  when Symbol
                    common_validators.fetch(validator_prop, proc { |_x| false })
-                 when Proc
-                   validator_prop
+                 # when Proc
+                 #   validator_prop
                  else
                    proc { |_x| false }
                  end

data/lib/cure/version.rb

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

data/lib/cure.rb

@@ -1,31 +1,39 @@
 # frozen_string_literal: true
 
+require "logger"
 require "cure/log"
-require "cure/main"
+require "cure/launcher"
 require "cure/config"
 require "cure/version"
-require "cure/helpers/file_helpers"
-
-require "cure/template/template"
+require "cure/dsl/template"
+require "cure/strategy/imports"
+require "cure/generator/imports"
 require "cure/transformation/transform"
-
-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
 
-    # @param [String] csv_file_location
-    # @param [Hash] template
-    # @return [File] output_file
-    def process(template, csv_file_location, output_dir)
-      # Main.init_from_hash(template, csv_file_location, output_dir)
+    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