cure 0.1.2 → 0.4.0

data/lib/cure/database.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "sequel"
+require "sqlite3"
+require "singleton"
+
+require "cure/config"
+
+module Cure
+  module Database
+    def database_service
+      database = DatabaseSource.instance.database_service
+      return database if database
+
+      init_database
+
+      DatabaseSource.instance.database_service
+    end
+
+    def init_database
+      DatabaseSource.instance.init_database
+    end
+  end
+
+  class DatabaseSource
+    include Singleton
+
+    attr_reader :database_service
+
+    def init_database
+      @database_service = DatabaseService.new
+    end
+  end
+
+  class DatabaseService
+    include Cure::Configuration
+
+    # @return [Sequel::SQLite::Database]
+    attr_reader :database
+
+    def initialize
+      @database = init_database
+      setup_db
+    end
+
+    def setup_db
+      # Load this from config defined by user?
+      @database.execute <<-SQL
+        PRAGMA journal_mode = OFF;
+        PRAGMA synchronous = 0;
+        PRAGMA cache_size = 1000000;
+        PRAGMA locking_mode = EXCLUSIVE;
+        PRAGMA temp_store = MEMORY;
+      SQL
+    end
+
+    # App Service calls
+    def find_variable(property_name)
+      @database.from(:variables).where(name: property_name).get(:value)
+    end
+
+    def find_translation(source_value)
+      @database.from(:translations).where(source_value: source_value).get(:value)
+    end
+
+    def all_translations
+      @database.from(:translations).all
+    end
+
+    # @param [Symbol,String] tbl_name
+    # @param [Array] columns
+    def create_table(tbl_name, columns, auto_increment: true)
+      tbl_name = tbl_name.to_sym if tbl_name.class != Symbol
+
+      @database.create_table tbl_name do
+        primary_key :_id, auto_increment: auto_increment
+        columns.each do |col_name|
+          column col_name.to_sym, String
+        end
+      end
+    end
+
+    # @param [Symbol,String] tbl_name
+    def truncate_table(tbl_name)
+      @database[tbl_name.to_sym].truncate
+    end
+
+    # @param [Symbol,String] tbl_name
+    def table_count(tbl_name)
+      @database[tbl_name.to_sym].count
+    end
+
+    def with_transaction(&block)
+      @database.transaction({}, &block)
+    end
+
+    # @param [Symbol,String] tbl_name
+    # @return [TrueClass, FalseClass]
+    def table_exist?(tbl_name)
+      tbl_name = tbl_name.to_sym if tbl_name.class != Symbol
+
+      @database.table_exists?(tbl_name)
+    end
+    alias table_exists? table_exist?
+
+    # @param [Symbol,String] tbl_name
+    # @param [Array<String>] row
+    def insert_row(tbl_name, row)
+      @database[tbl_name.to_sym].insert(row)
+    end
+
+    # @param [Symbol,String] tbl_name
+    # @param [Array<String>] rows
+    def insert_batched_rows(tbl_name, rows)
+      @database[tbl_name.to_sym].import(@database[tbl_name.to_sym].columns, rows)
+    end
+
+    def add_column(tbl_name, new_column, default: "")
+      tbl_name = tbl_name.to_sym if tbl_name.class != Symbol
+      new_column = new_column.to_sym if new_column.class != Symbol
+
+      @database.add_column(tbl_name, new_column, String, default: default)
+    end
+
+    def remove_column(tbl_name, remove_column)
+      tbl_name = tbl_name.to_sym if tbl_name.class != Symbol
+      remove_column = remove_column.to_sym if remove_column.class != Symbol
+
+      @database.drop_column tbl_name, remove_column
+    end
+
+    def list_columns(tbl_name)
+      @database[tbl_name.to_sym].columns
+    end
+
+    def rename_column(tbl_name, old_column, new_column)
+      tbl_name = tbl_name.to_sym if tbl_name.class != Symbol
+      old_column = old_column.to_sym if old_column.class != Symbol
+      new_column = new_column.to_sym if new_column.class != Symbol
+
+      @database.rename_column tbl_name, old_column, new_column
+    end
+
+    def copy_column(tbl_name, from_column, to_column)
+      tbl_name = tbl_name.to_sym if tbl_name.class != Symbol
+      from_column = from_column.to_sym if from_column.class != Symbol
+      to_column = to_column.to_sym if to_column.class != Symbol
+
+      add_column tbl_name, to_column
+      run("UPDATE #{tbl_name} SET #{to_column} = #{from_column}")
+    end
+
+    def run(query, opts={})
+      @database.run(query, opts)
+    end
+
+    # Can we decouple query from named range? Probably more difficult
+    # than it seems. But would be nice to create two queries that doesn't
+    # require two tables (named ranges).
+    def with_paged_result(tbl_name, chunk_size: 100, &block)
+      raise "No block given" unless block
+
+      query = config.template.queries.find(tbl_name)
+      if query
+        @database[query.query].order(:_id).paged_each(rows_per_fetch: chunk_size, &block)
+      else
+        @database[tbl_name.to_sym].order(:_id).paged_each(rows_per_fetch: chunk_size, &block)
+      end
+    end
+
+    def list_tables
+      tbl_arr = @database.tables
+      tbl_arr.delete(:variables)
+
+      if tbl_arr.include?(:translations)
+        tbl_arr.delete(:translations)
+        tbl_arr.push(:translations)
+      end
+
+      tbl_arr
+    end
+
+    private
+
+    def init_database
+      # Build from config
+      # This must clean the database if its not in memory
+      Sequel.connect("sqlite:/")
+    end
+  end
+end

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