cure 0.1.1 → 0.4.0

data/lib/cure/dsl/builder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "cure/builder/base_builder"
+require "cure/builder/candidate"
+
+module Cure
+  module Dsl
+    class Builder
+
+      attr_reader :candidates
+
+      def initialize
+        @candidates = []
+      end
+
+      # @param [String,nil] column
+      # @param [String] named_range
+      # @param [Proc] block
+      def candidate(column: nil, named_range: "_default", &block)
+        candidate = Cure::Builder::Candidate.new(column, named_range)
+        @candidates << candidate
+        candidate.instance_exec(&block)
+      end
+    end
+  end
+end

data/lib/cure/dsl/exporters.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "cure/export/base_processor"
+require "cure/extract/named_range"
+
+module Cure
+  module Dsl
+    class Exporters
+
+      attr_reader :processors
+
+      def initialize
+        @processors = []
+      end
+
+      # @param [String,Symbol] _method_name
+      # @param [TrueClass,FalseClass] _include_private
+      # @return [TrueClass]
+      def respond_to_missing?(_method_name, _include_private=false)
+        true
+      end
+
+      # @param [Symbol] method_name
+      # @return [Cure::Export::BaseBuilder]
+      def method_missing(method_name, **args)
+        klass_name = "Cure::Export::#{method_name.to_s.split("_").map(&:capitalize).join("")}Processor"
+        raise "#{method_name} is not valid" unless class_exists?(klass_name)
+
+        @processors << Kernel.const_get(klass_name).new(
+          args[:named_range] || "_default",
+          args || {}
+        )
+      end
+
+      # @param [String] klass_name
+      # @return [TrueClass,FalseClass]
+      def class_exists?(klass_name)
+        klass = Module.const_get(klass_name)
+        klass.is_a?(Class)
+      rescue NameError
+        false
+      end
+    end
+  end
+end

data/lib/cure/dsl/extraction.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "cure/extract/named_range"
+require "cure/extract/variable"
+
+module Cure
+  module Dsl
+    class Extraction
+
+      attr_reader :named_ranges, :variables, :sample_rows
+
+      def initialize
+        @named_ranges = []
+        @variables = []
+      end
+
+      def named_range(name:, at: -1, headers: nil, ref_name: nil, placeholder: false, &block)
+        named_range = Extract::NamedRange.new(name, at,
+          headers: headers,
+          ref_name: ref_name,
+          placeholder: placeholder
+        )
+
+        if block_given?
+          named_range.filter.instance_eval(&block)
+        end
+
+        @named_ranges << named_range
+      end
+
+      def variable(name:, at:, ref_name: nil)
+        @variables << Cure::Extract::Variable.new(name, at, ref_name: ref_name)
+      end
+
+      def sample(rows: nil)
+        @sample_rows = rows
+      end
+
+      # @param [String] ref_name
+      # @return [Array]
+      def required_named_ranges(ref_name: "_default")
+        # This now needs to take support multiple files. We don't want named ranges
+        # for different files
+        return @named_ranges if ref_name == "default"
+
+        @named_ranges.select { |nr| nr.ref_name == ref_name && nr.placeholder == false }
+      end
+
+      # @param [String] ref_name
+      # @return [Array]
+      def required_variables(ref_name: "_default")
+        # This now needs to take support multiple files. We don't want named ranges
+        # for different files
+        return @variables if ref_name == "_default"
+
+        @variables.select { |v| v.ref_name == ref_name }
+      end
+    end
+  end
+end

data/lib/cure/dsl/metadata.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cure
+  module Dsl
+    class Metadata
+
+      attr_reader :_name, :_version, :_comments, :_additional
+
+      def initialize
+        @_name = nil
+        @_version = nil
+        @_comments = nil
+        @_additional = {}
+      end
+
+      def name(name)
+        @_name = name
+      end
+
+      def version(version)
+        @_version = version
+      end
+
+      def comments(comments)
+        @_comments = comments
+      end
+
+      def additional(data: {})
+        @_additional = data
+      end
+    end
+  end
+end

data/lib/cure/dsl/queries.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "cure/builder/base_builder"
+require "cure/builder/candidate"
+
+module Cure
+  module Dsl
+    class Queries
+
+      attr_reader :candidates
+
+      def initialize
+        @candidates = []
+      end
+
+      def with(query:, named_range: "_default")
+        candidate = Query.new(named_range.to_sym, query)
+        @candidates << candidate
+      end
+
+      def find(named_range)
+        @candidates.find { |candidate| candidate.named_range.to_sym == named_range.to_sym }
+      end
+
+      class Query
+        attr_reader :named_range, :query
+
+        def initialize(named_range, query)
+          @named_range = named_range
+          @query = query
+        end
+      end
+
+    end
+  end
+end

data/lib/cure/dsl/source_files.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "cure/builder/base_builder"
+require "cure/builder/candidate"
+
+module Cure
+  module Dsl
+    class SourceFiles
+
+      attr_reader :candidates
+
+      def initialize
+        @candidates = []
+      end
+
+      def csv(type, value, ref_name: nil)
+        candidate = SourceFile.new(type, value, ref_name)
+        @candidates << candidate
+      end
+
+      def has_candidates?
+        @candidates.length.positive?
+      end
+
+      class SourceFile
+        attr_accessor :type, :value, :ref_name
+
+        def initialize(type, value, ref_name)
+          @type = type
+          @value = value
+          @ref_name = ref_name
+        end
+      end
+    end
+  end
+end

data/lib/cure/dsl/template.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "cure/log"
+require "cure/dsl/extraction"
+require "cure/dsl/builder"
+require "cure/dsl/validator"
+require "cure/dsl/transformations"
+require "cure/dsl/exporters"
+require "cure/dsl/queries"
+require "cure/dsl/metadata"
+require "cure/dsl/source_files"
+
+module Cure
+  module Dsl
+    class DslHandler
+      include Log
+      def self.init(&block)
+        DslHandler.new(block)
+      end
+
+      def self.init_from_content(dsl_source, identifier, line_number=1)
+        proc = Binding.get.eval(<<-SOURCE, identifier, line_number)
+          Proc.new do
+            #{dsl_source}
+          end
+        SOURCE
+
+        DslHandler.new(proc)
+      end
+
+      def initialize(proc)
+        @proc = proc
+      end
+
+      def generate(instance_variables={})
+        dsl = Template.new
+        instance_variables.each do |name, value|
+          dsl.instance_variable_set("@#{name}", value)
+        end
+
+        dsl.instance_eval(&@proc)
+        dsl
+
+      rescue StandardError => e
+        log_error "Error parsing DSL: #{e.message}"
+
+        # Raise specific error in future.
+        raise e
+      end
+    end
+
+    module Binding
+      # @return [Object] Empty object for binding purposes
+      def self.get
+        binding
+      end
+    end
+
+    class Template
+
+      # @return [Dsl::Extraction]
+      attr_reader :extraction
+
+      # @return [Dsl::Builder]
+      attr_reader :builder
+
+      # @return [Dsl::Validator]
+      attr_reader :validator
+
+      # @return [Dsl::Transformations]
+      attr_reader :transformations
+
+      # @return [Dsl::Exporters]
+      attr_reader :exporters
+
+      # @return [Dsl::Queries]
+      attr_reader :queries
+
+      # @return [Dsl::Metadata]
+      attr_reader :meta_data
+
+      # @return [Dsl::SourceFiles]
+      attr_reader :source_files
+
+      def initialize
+        @source_files = SourceFiles.new
+        @extraction = Extraction.new
+        @builder = Builder.new
+        @validator = Validator.new
+        @transformations = Transformations.new
+        @exporters = Exporters.new
+        @queries = Queries.new
+        @meta_data = Metadata.new
+      end
+
+      private
+
+      def sources(&block)
+        @source_files.instance_exec(&block)
+      end
+
+      def extract(&block)
+        @extraction.instance_exec(&block)
+      end
+
+      def query(&block)
+        @queries.instance_exec(&block)
+      end
+
+      def build(&block)
+        @builder.instance_exec(&block)
+      end
+
+      def validate(&block)
+        @validator.instance_exec(&block)
+      end
+
+      def transform(&block)
+        @transformations.instance_exec(&block)
+      end
+
+      def metadata(&block)
+        @meta_data.instance_exec(&block)
+      end
+
+      def export(&block)
+        @exporters.instance_exec(&block)
+      end
+    end
+  end
+end

data/lib/cure/dsl/transformations.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require "cure/strategy/imports"
+require "cure/generator/imports"
+require "cure/transformation/candidate"
+
+module Cure
+  module Dsl
+    class Transformations
+
+      attr_reader :candidates, :placeholders
+
+      def initialize
+        @candidates = []
+        @placeholders = []
+      end
+
+      def candidate(column:, named_range: "_default", options: {}, &block)
+        candidate = Candidate.new(column, named_range: named_range)
+        candidate.instance_exec(&block)
+
+        @candidates << Transformation::Candidate
+                       .new(candidate.column, named_range: candidate.named_range, options: options)
+                       .with_translations(candidate.translations)
+                       .with_no_match_translation(candidate.no_match_translation)
+      end
+
+      def place_holders(hash)
+        @placeholders = hash
+      end
+
+      class Candidate
+
+        attr_reader :column, :named_range, :ref, :translations, :no_match_translation
+
+        def initialize(column, named_range:, ref: "_default")
+          @column = column
+          @named_range = named_range
+          @ref = ref
+
+          @translations = []
+          @no_match_translation = nil
+        end
+
+        def with_translation(&block)
+          translation = Translation.new
+          translation.instance_exec(&block)
+
+          @translations << Transformation::Translation.new(
+            translation.strategy,
+            translation.generator
+          )
+        end
+
+        def if_no_match(&block)
+          no_match_translation = Translation.new
+          no_match_translation.instance_exec(&block)
+
+          @no_match_translation = Transformation::Translation.new(
+            no_match_translation.strategy,
+            no_match_translation.generator
+          )
+        end
+      end
+
+      class Translation
+
+        attr_reader :strategy, :generator
+
+        def replace(name, **options)
+          klass_name = "Cure::Strategy::#{name.to_s.capitalize}Strategy"
+          raise "#{name} is not valid" unless class_exists?(klass_name)
+
+          @strategy = Kernel.const_get(klass_name).new(options)
+          self
+        end
+
+        def with(name, **options)
+          klass_name = "Cure::Generator::#{name.to_s.capitalize}Generator"
+          raise "#{name} is not valid" unless class_exists?(klass_name)
+
+          @generator = Kernel.const_get(klass_name).new(options)
+          self
+        end
+
+        def class_exists?(klass_name)
+          klass = Module.const_get(klass_name)
+          klass.is_a?(Class)
+        rescue NameError
+          false
+        end
+      end
+    end
+  end
+end

data/lib/cure/dsl/validator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "cure/validator/candidate"
+
+module Cure
+  module Dsl
+    class Validator
+
+      attr_reader :candidates
+
+      def initialize
+        @candidates = []
+      end
+
+      def candidate(column: nil, named_range: "_default", options: {}, &block)
+        candidate = Cure::Validator::Candidate.new(column, named_range, options)
+        @candidates << candidate
+        candidate.instance_exec(&block)
+      end
+    end
+  end
+end

data/lib/cure/export/base_processor.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "csv"
+require "cure/log"
+require "cure/helpers/file_helpers"
+
+module Cure
+  module Export
+    class BaseProcessor
+      include Log
+
+      attr_reader :named_range
+
+      def initialize(named_range, opts)
+        @named_range = named_range
+        @opts = opts
+        @limit_rows = opts.fetch(:limit_rows, nil)
+
+        @processed = 0
+      end
+
+      # @param [Hash]
+      def process_row(row)
+        process(row) unless @limit_rows && @limit_rows <= @processed
+
+        @processed += 1
+      end
+
+      # @param [Hash]
+      def process(_row)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+
+      def setup
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+
+      def cleanup
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+    end
+
+    require "terminal-table"
+
+    class TerminalProcessor < BaseProcessor
+
+      attr_reader :table, :limit_rows, :processed
+
+      def process(row)
+        @table.headings = row.keys if @processed.zero?
+        @table.add_row(row.values)
+      end
+
+      def setup
+        # Markdown mode
+        Terminal::Table::Style.defaults = {
+          border_top: false,
+          border_bottom: false,
+          border_x: "-",
+          border_y: "|",
+          border_i: "|"
+        }
+
+        log_info "Exporting [#{@named_range}] to terminal."
+        @table = Terminal::Table.new(title: @opts[:title] || "<No Title Set>")
+      end
+
+      def cleanup
+        puts @table
+      end
+    end
+
+    class CsvProcessor < BaseProcessor
+      include Helpers::FileHelpers
+
+      attr_reader :csv_file
+
+      def process(row)
+        @csv_file.write(row.keys.to_csv) if @processed.zero?
+        @csv_file.write(row.values.to_csv)
+      end
+
+      def setup
+        log_info "Exporting [#{@named_range}] to CSV..."
+
+        output_dir = @opts[:directory]
+        file_name = @opts[:file_name]
+
+        log_info("Exporting file to [#{output_dir}/#{file_name}]")
+        # file_name = "#{file_name}-#{Time.now.utc.strftime("%Y-%m-%dT%H:%M:%S%-z")}"
+
+        path = "#{output_dir}/#{file_name}"
+
+        # clean_dir(output_dir)
+
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        path = "#{path}.csv"
+        @csv_file = File.open(path, "w")
+        @processed = 0
+      end
+
+      def cleanup
+      ensure
+        log_info File.basename(@csv_file)
+        @csv_file.close
+      end
+    end
+
+    class ChunkCsvProcessor < BaseProcessor
+      include Helpers::FileHelpers
+
+      attr_reader :current_csv_file,
+                  :file_name_prefix,
+                  :directory,
+                  :chunk_size,
+                  :include_headers,
+                  :row_count
+
+      def process(row)
+        chunked_file_handler do |csv_file|
+          if @processed.zero? || (@processed % @chunk_size).zero? || (@processed % @chunk_size).zero?
+            csv_file.write(row.keys.to_csv)
+          end
+
+          csv_file.write(row.values.to_csv)
+        end
+      end
+
+      def setup
+        log_info "Exporting [#{@named_range}] to CSV..."
+
+        extract_opts
+
+        log_info("Exporting file to [#{@output_dir}/#{@file_name_prefix}]")
+
+        clean_dir(@output_dir)
+
+        dir = File.dirname("#{@output_dir}/#{@file_name_prefix}")
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        @processed = 0
+        @current_chunk = 0
+      end
+
+      def cleanup
+      ensure
+        @current_csv_file.close
+      end
+
+      def extract_opts
+        # TODO: Add offset? pick a slice?
+        @output_dir = @opts[:directory]
+        @file_name_prefix = @opts[:file_name_prefix]
+        @directory = @opts[:directory]
+        @chunk_size = @opts[:chunk_size]
+        @include_headers = @opts.fetch(:include_headers, true)
+      end
+
+      def chunked_file_handler(&block)
+        raise "No block" unless block
+
+        if @processed.zero? || (@processed % @chunk_size).zero?
+          @current_csv_file&.close
+
+          @current_chunk += 1
+          log_info "Writing file to #{current_file_path}"
+          @current_csv_file = File.open(current_file_path, "w")
+        end
+
+        yield @current_csv_file
+      end
+
+      def current_file_path
+        "#{@output_dir}/#{@current_chunk}-#{@file_name_prefix}.csv"
+      end
+    end
+
+    class YieldRowProcessor < BaseProcessor
+      attr_reader :proc
+
+      def process_row(row)
+        @proc.call(row)
+      end
+
+      def setup
+        @proc = @opts.fetch(:proc)
+      end
+
+      def cleanup; end
+    end
+  end
+end

data/lib/cure/export/manager.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Cure
+  module Export
+    class Manager
+
+      # @param [Array<Cure::Export::BaseProcessor>] candidates
+      attr_reader :processors
+
+      def initialize(named_range, processors)
+        @named_range = named_range
+        @processors = processors
+      end
+
+      def with_processors
+        @processors.each(&:setup)
+
+        yield @processors
+
+        @processors.each(&:cleanup)
+      end
+    end
+  end
+end