cure 0.1.1 → 0.1.2

data/lib/cure/template/dispatch.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cure
+  # This name sucks, it is just an exporter
+  class Dispatch
+
+    # @param [Array<Hash>] named_ranges
+    attr_accessor :named_ranges
+
+    def initialize
+      @named_ranges = [default]
+    end
+
+    # @param [Array<String>] hash
+    # @return [Cure::Dispatch]
+    def self.from_hash(hash)
+      this = Cure::Dispatch.new
+      this.named_ranges = hash["sections"] if hash.key?("sections")
+      this
+    end
+
+    def default
+      {
+        "named_range" => "default",
+        "file_name" => "cure-export",
+        "type" => "csv"
+      }
+    end
+  end
+end

data/lib/cure/template/extraction.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Cure
+  class Extraction
+    # @param [Array<Hash>] named_ranges
+    attr_accessor :named_ranges
+
+    # @param [Array<Hash>] named_ranges
+    attr_accessor :variables
+
+    def initialize
+      @named_ranges = [{
+        "name" => "default",
+        "section" => -1
+      }]
+
+      @variables = []
+    end
+
+    # @param [Hash] hash
+    # @return [Cure::Extraction]
+    def self.from_hash(hash)
+      this = Cure::Extraction.new
+      this.named_ranges.push(*hash["named_ranges"])
+      this.variables.push(*hash["variables"])
+      this
+    end
+
+    # We only need to get the named ranges where the candidates have specified
+    # interest in them.
+    #
+    # @param [Array] candidate_nrs
+    # @return [Array]
+    def required_named_ranges(candidate_nrs)
+      @named_ranges.select { |nr| candidate_nrs.include?(nr["name"]) }
+    end
+  end
+end

data/lib/cure/template/template.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "cure/template/transformations"
+require "cure/template/extraction"
+require "cure/template/dispatch"
+
+module Cure
+  class Template
+    # @param [Cure::Transformations] transformations
+    attr_accessor :transformations
+
+    # @param [Cure::Extraction] extraction
+    attr_accessor :extraction
+
+    # @param [Cure::Dispatch] dispatch
+    attr_accessor :dispatch
+
+    # @param [Hash] hash
+    # @return [Cure::Template]
+    def self.from_hash(hash)
+      this = Cure::Template.new
+      this.transformations = Cure::Transformations.from_hash(hash.fetch("transformations", {}))
+      this.extraction = Cure::Extraction.from_hash(hash.fetch("extraction", {}))
+      this.dispatch = Cure::Dispatch.from_hash(hash.fetch("dispatch", {}))
+      this
+    end
+  end
+end

data/lib/cure/template/transformations.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Cure
+  class Transformations
+    # @param [Array<Transformation::Candidate>] candidates
+    attr_accessor :candidates
+
+    # @param [Array<Hash>] placeholders
+    # TODO: make class Placeholder
+    attr_accessor :placeholders
+
+    def initialize
+      @candidates = []
+      @placeholders = {}
+    end
+
+    # @param [Hash] hash
+    # @return [Cure::Transformations]
+    def self.from_hash(hash)
+      this = Cure::Transformations.new
+      this.candidates = hash["candidates"].map { |c| Cure::Transformation::Candidate.new.from_json(c) }
+      this.placeholders = hash["placeholders"]
+      this
+    end
+  end
+end

data/lib/cure/transformation/candidate.rb

@@ -1,17 +1,21 @@
 # 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/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_accessor :named_range
+
       # Lookup column name for CSV.
       # @return [String]
       attr_accessor :column
@@ -20,8 +24,14 @@ module Cure
       # @return [List<Translation>]
       attr_reader :translations
 
+      # @return [Translation]
       attr_reader :no_match_translation
 
+      def initialize
+        @translations = []
+        @named_range = "default"
+      end
+
       # @param [String] source_value
       # @return [String]
       # Transforms the existing value
@@ -43,24 +53,26 @@ module Cure
         value
       end
 
+      # @param [Hash] opts
       def translations=(opts)
         @translations = opts.map { |o| Translation.new.from_hash(o) }
       end
 
+      # @param [Hash] opts
       def no_match_translation=(opts)
         @no_match_translation = Translation.new.from_hash(opts)
       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
@@ -72,7 +84,9 @@ module Cure
       # @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"] || {})
+        strategy = Kernel.const_get(clazz_name).new(opts["options"] || {})
+
+        @strategy = strategy
       end
 
       # @param [Hash] opts
@@ -80,7 +94,7 @@ module Cure
         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

@@ -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,53 +23,34 @@ 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
+      # @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
+
+            if ctx.row_count == 1
+              ctx.extract_column_headers(row)
+              next
+            end
+
+            row = transform(section["name"], ctx.column_headers, row)
+            ctx.add_transformed_row(row)
           end
 
-          row = transform(ctx.column_headers, row)
-          ctx.add_transformed_row(row)
+          hash[section["name"]] = ctx
         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|
+      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
 
@@ -77,10 +63,16 @@ module Cure
 
         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 }
+      end
     end
 
-    class TransformContext
-      include FileHelpers
+    class TransformResult
+      include Helpers::FileHelpers
 
       attr_accessor :row_count,
                     :transformed_rows,

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: 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.1.2"
 end

data/lib/cure.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require "cure/log"
+require "cure/main"
 require "cure/config"
 require "cure/version"
+require "cure/helpers/file_helpers"
 
-require "cure/file_helpers"
+require "cure/template/template"
 require "cure/transformation/transform"
 
-require "cure/main"
-
 require "logger"
 
 module Cure
@@ -21,6 +21,11 @@ module Cure
       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)
+    end
   end
 end