parxer 0.1.1

data/lib/parxer/formatters/boolean_formatter.rb

@@ -0,0 +1,14 @@
+module Parxer
+  module Formatter
+    class Boolean < Base
+      TRUE_OPTIONS = ["true", "t", "1", "1.0"]
+      FALSE_OPTIONS = ["false", "f", "0", "0.0"]
+
+      def format_value(v)
+        return true if TRUE_OPTIONS.include?(v)
+        return false if FALSE_OPTIONS.include?(v)
+        nil
+      end
+    end
+  end
+end

data/lib/parxer/formatters/custom_formatter.rb

@@ -0,0 +1,13 @@
+module Parxer
+  module Formatter
+    class Custom < Base
+      def format_value(_v)
+        if !config[:formatter_proc].is_a?(Proc)
+          raise Parxer::FormatterError.new("'formatter_proc' needs to be a Proc")
+        end
+
+        instance_eval(&config[:formatter_proc])
+      end
+    end
+  end
+end

data/lib/parxer/formatters/number_formatter.rb

@@ -0,0 +1,25 @@
+module Parxer
+  module Formatter
+    class Number < Base
+      def format_value(v)
+        v = integer? ? v.to_i : v.to_f
+        v = v.round(round) if round?
+        v
+      end
+
+      private
+
+      def integer?
+        !!config[:integer]
+      end
+
+      def round?
+        !integer? && !!config[:round]
+      end
+
+      def round
+        config[:round].to_s.to_i
+      end
+    end
+  end
+end

data/lib/parxer/formatters/rut_formatter.rb

@@ -0,0 +1,33 @@
+module Parxer
+  module Formatter
+    class Rut < Base
+      def format_value(rut)
+        rut = clean_rut(rut)
+        return nil if rut.empty?
+        return rut if clean_rut?
+        format_rut(rut)
+      end
+
+      def clean_rut(rut)
+        rut.scan(/(\d|k)/i).flatten.join("").upcase
+      end
+
+      def format_rut(rut)
+        last_digit = rut[-1]
+        digits = rut[0...-1].split("").reverse
+        result = []
+
+        digits.each_with_index do |number, idx|
+          result << "." if !idx.zero? && (idx % 3).zero?
+          result << number
+        end
+
+        result.reverse.join("") + "-" + last_digit
+      end
+
+      def clean_rut?
+        !!config[:clean]
+      end
+    end
+  end
+end

data/lib/parxer/formatters/string_formatter.rb

@@ -0,0 +1,9 @@
+module Parxer
+  module Formatter
+    class String < Base
+      def format_value(v)
+        v
+      end
+    end
+  end
+end

data/lib/parxer/parsers/base_parser.rb

@@ -0,0 +1,80 @@
+module Parxer
+  class BaseParser
+    include Parxer::InheritedResource
+    include Parxer::ParserConfig
+    include Parxer::ParserAttributes
+    include Parxer::ParserValidator
+    include Parxer::ParserFormatter
+    include Parxer::ParserCallback
+    include Parxer::Dsl
+
+    attr_reader :file, :value, :attribute, :row, :prev_row
+
+    validate_file(:file_presence)
+
+    def run(file)
+      @file = file
+      return unless validate_file
+      row_class = Parxer::RowBuilder.build(attribute_ids)
+      Enumerator.new do |enum|
+        for_each_raw_row do |raw_row, idx|
+          @row = row_class.new(idx: idx)
+          parse_row(raw_row)
+          enum << row
+          @prev_row = row
+        end
+      end
+    end
+
+    def raw_rows
+      raise Parxer::ParserError.new("not implemented")
+    end
+
+    def extract_raw_attr_value(value)
+      value
+    end
+
+    def header
+      @header ||= raw_rows.first
+    end
+
+    def rows_count
+      raw_rows.count
+    end
+
+    def file_extension
+      ext = File.extname(file.to_s).delete(".")
+      return if ext.blank?
+      ext.to_sym
+    end
+
+    private
+
+    def parse_row(raw_row)
+      raw_row.each do |attribute_name, value|
+        @value = row.send("#{attribute_name}=", value)
+        @attribute = find_attribute(attribute_name)
+        format_attribute_value if validate_row_attribute
+      end
+
+      validate_row
+      after_parse_row
+    end
+
+    def for_each_raw_row
+      raw_rows.each_with_index do |raw_row, idx|
+        next if idx.zero?
+        yield(raw_row_to_hash(raw_row), idx + 1)
+      end
+    end
+
+    def raw_row_to_hash(raw_row)
+      pos = 0
+      attributes.inject({}) do |memo, column|
+        memo[column.id.to_sym] = extract_raw_attr_value(raw_row[pos])
+        pos += 1
+        memo
+      end
+    end
+  end
+end

data/lib/parxer/parsers/concerns/attributes.rb

@@ -0,0 +1,25 @@
+module Parxer
+  module ParserAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      def attribute_ids
+        attributes.map(&:id)
+      end
+
+      def attributes
+        @attributes ||= inherited_collection(self, :attributes, Parxer::Attributes)
+      end
+
+      def find_attribute(attribute_name)
+        attributes.find_attribute(attribute_name)
+      end
+    end
+
+    class_methods do
+      def attributes
+        @attributes ||= Parxer::Attributes.new
+      end
+    end
+  end
+end

data/lib/parxer/parsers/concerns/callback.rb

@@ -0,0 +1,24 @@
+module Parxer
+  module ParserCallback
+    extend ActiveSupport::Concern
+
+    included do
+      def parser_callbacks
+        @parser_callbacks ||= inherited_collection(self, :parser_callbacks, Parxer::Callbacks)
+      end
+
+      def after_parse_row
+        parser_callbacks.by_type(:after_parse_row).each do |callback|
+          callback.context = self
+          callback.run
+        end
+      end
+    end
+
+    class_methods do
+      def parser_callbacks
+        @parser_callbacks ||= Parxer::Callbacks.new
+      end
+    end
+  end
+end

data/lib/parxer/parsers/concerns/config.rb

@@ -0,0 +1,23 @@
+module Parxer
+  module ParserConfig
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :parser_config
+
+      def parser_config
+        @parser_config ||= inherited_hash(self, :parser_config)
+      end
+    end
+
+    class_methods do
+      def parser_config
+        @parser_config ||= {}
+      end
+
+      def add_config_option(key, value)
+        parser_config[key.to_sym] = value
+      end
+    end
+  end
+end

data/lib/parxer/parsers/concerns/formatter.rb

@@ -0,0 +1,14 @@
+module Parxer
+  module ParserFormatter
+    extend ActiveSupport::Concern
+
+    included do
+      def format_attribute_value
+        formatter = attribute.formatter
+        return unless formatter
+        formatter.context = self
+        row.send("#{attribute.id}=", formatter.apply)
+      end
+    end
+  end
+end

data/lib/parxer/parsers/concerns/validator.rb

@@ -0,0 +1,75 @@
+module Parxer
+  module ParserValidator
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :file_error
+
+      def file_validators
+        @file_validators ||= inherited_collection(self, :file_validators, Parxer::Validators)
+      end
+
+      def row_validators
+        @row_validators ||= inherited_collection(self, :row_validators, Parxer::Validators)
+      end
+
+      def valid_file?
+        !file_error
+      end
+
+      def validate_file
+        file_validators.each do |validator|
+          validator.context = self
+          next if !valid_file? || validator.validate
+          @file_error = validator.id
+        end
+
+        valid_file?
+      end
+
+      def validate_row
+        row_validators.each do |validator|
+          validator.context = self
+          next if !validate_row?(validator) || validator.validate
+          row.add_error(:base, validator.id)
+        end
+
+        !row.errors?
+      end
+
+      def validate_row?(validator)
+        attrs = validator.config[:if_valid]
+        return !row.errors? if attrs.blank?
+        attrs.select { |a| row.attribute_error?(a) }.none?
+      end
+
+      def validate_row_attribute
+        attribute.validators.each do |validator|
+          validator.context = self
+          next if row.attribute_error?(attribute.id) || validator.validate
+          row.add_error(attribute.id, validator.id)
+        end
+
+        !row.attribute_error?(attribute.id)
+      end
+    end
+
+    class_methods do
+      def file_validators
+        @file_validators ||= Parxer::Validators.new
+      end
+
+      def add_validator(validator_name, config, &block)
+        file_validators.add_validator(validator_name, config, &block)
+      end
+
+      def row_validators
+        @row_validators ||= Parxer::Validators.new
+      end
+
+      def add_row_validator(validator_name, config, &block)
+        row_validators.add_validator(validator_name, config, &block)
+      end
+    end
+  end
+end

data/lib/parxer/parsers/csv_parser.rb

@@ -0,0 +1,13 @@
+module Parxer
+  class CsvParser < Parxer::BaseParser
+    validate_file(:file_format, allowed_extensions: [:csv])
+
+    def raw_rows
+      csv
+    end
+
+    def csv
+      @csv ||= Roo::CSV.new(file, csv_options: parser_config)
+    end
+  end
+end

data/lib/parxer/parsers/xls_parser.rb

@@ -0,0 +1,21 @@
+module Parxer
+  class XlsParser < Parxer::BaseParser
+    validate_file(:file_format, allowed_extensions: [:xls, :xlsx])
+
+    def raw_rows
+      worksheet
+    end
+
+    def extract_raw_attr_value(value)
+      value.is_a?(Spreadsheet::Formula) ? value.value : value
+    end
+
+    def worksheet
+      @worksheet ||= workbook.sheet(0)
+    end
+
+    def workbook
+      @workbook ||= Roo::Spreadsheet.open(file, parser_config)
+    end
+  end
+end

data/lib/parxer/utils/context.rb

@@ -0,0 +1,26 @@
+module Parxer
+  module Context
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :context
+
+      def context
+        raise Parxer::ContextError.new("'context' method not implemented") unless @context
+        @context
+      end
+
+      def method_missing(method_name, *arguments, &block)
+        if context.respond_to?(method_name)
+          return context.send(method_name, *arguments, &block)
+        end
+
+        super
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        context.respond_to?(method_name) || super
+      end
+    end
+  end
+end

data/lib/parxer/utils/errors.rb

@@ -0,0 +1,10 @@
+class Parxer::Error < RuntimeError; end
+class Parxer::ParserError < Parxer::Error; end
+class Parxer::RowError < Parxer::Error; end
+class Parxer::ValidatorError < Parxer::Error; end
+class Parxer::XlsDslError < Parxer::Error; end
+class Parxer::AttributesError < Parxer::Error; end
+class Parxer::FormatterError < Parxer::Error; end
+class Parxer::ContextError < Parxer::Error; end
+class Parxer::DslError < Parxer::Error; end
+class Parxer::CallbacksError < Parxer::Error; end

data/lib/parxer/utils/formatter_builder.rb

@@ -0,0 +1,16 @@
+module Parxer
+  class FormatterBuilder
+    def self.build(formatter_name, config = {}, &block)
+      formatter_class = infer_formatter_class(formatter_name)
+      config[:formatter_proc] = block if formatter_class == Parxer::Formatter::Custom
+      formatter_class.new(config)
+    end
+
+    def self.infer_formatter_class(formatter_name)
+      return Parxer::Formatter::Custom if formatter_name.blank?
+      "Parxer::Formatter::#{formatter_name.to_s.camelize}".constantize
+    rescue NameError
+      Parxer::Formatter::Custom
+    end
+  end
+end

data/lib/parxer/utils/inherited_resource.rb

@@ -0,0 +1,35 @@
+module Parxer
+  module InheritedResource
+    def inherited_collection(object, method_name, collection_class)
+      result = collection_class.new
+
+      for_each_ancestor_with_method(object, method_name) do |collection|
+        collection.each { |item| result << item }
+      end
+
+      result
+    end
+
+    def inherited_hash(object, method_name)
+      result = {}
+
+      for_each_ancestor_with_method(object, method_name) do |hash|
+        result.merge!(hash)
+      end
+
+      result
+    end
+
+    def for_each_ancestor_with_method(object, method_name, &block)
+      object_ancestors(object).each do |klass|
+        next unless klass.respond_to?(method_name)
+        block.call(klass.send(method_name))
+      end
+    end
+
+    def object_ancestors(object)
+      klass = object.is_a?(Class) ? object : object.class
+      klass.ancestors.grep(Class).reverse
+    end
+  end
+end