csv_party 0.0.1.pre9 → 1.0.0.rc4

data/lib/csv_party.rb

@@ -1,309 +1,79 @@
-require 'csv'
 require 'bigdecimal'
+require 'csv'
 require 'ostruct'
+require 'csv_party/configuration'
+require 'csv_party/dsl'
+require 'csv_party/data_preparer'
+require 'csv_party/errors'
+require 'csv_party/row'
+require 'csv_party/runner'
 
-class CSVParty
-  attr_accessor :columns, :row_importer, :importer, :error_processor,
-                :dependencies
-
-  attr_reader :imported_rows, :skipped_rows, :aborted_rows,
-              :abort_message
-
-  def initialize(csv_path, options = {})
-    initialize_import_settings
-    initialize_counters_and_statuses
-    initialize_dependencies(options)
-
-    @headers = CSV.new(File.open(csv_path), options).shift
-    options[:headers] = true
-    @csv = CSV.new(File.open(csv_path), options)
-
-    raise_unless_named_parsers_are_valid
-    raise_unless_csv_has_all_headers
-  end
-
-  def import!
-    if importer
-      instance_exec(&importer)
-    else
-      import_rows!
-    end
-  rescue AbortedImportError => error
-    @aborted = true
-    @abort_message = error.message
-  end
-
-  def import_rows!
-    loop do
-      begin
-        row = @csv.shift
-        break unless row
-        import_row!(row)
-        imported_rows << @csv.lineno
-      rescue SkippedRowError
-        skipped_rows << @csv.lineno
-        next
-      rescue AbortedImportError => error
-        raise AbortedImportError, error.message
-      rescue StandardError => error
-        process_error(error, @csv.lineno + 1)
-        aborted_rows << @csv.lineno
-        next
-      end
-    end
-  end
-
-  def self.column(column, options, &block)
-    raise_if_duplicate_column(column)
-    raise_if_missing_header(column, options)
-
-    options = {
-      blanks_as_nil: (options[:as] == :raw ? false : true),
-      as: :string
-    }.merge(options)
-
-    parser = if block_given?
-               block
-             else
-               "#{options[:as]}_parser".to_sym
-             end
-
-    columns[column] = {
-      header: options[:header],
-      parser: parser,
-      blanks_as_nil: options[:blanks_as_nil]
-    }
-  end
-
-  def self.rows(&block)
-    @row_importer = block
-  end
-
-  def self.import(&block)
-    @importer = block
-  end
-
-  def self.errors(&block)
-    @error_processor = block
-  end
-
-  def self.depends_on(*args)
-    args.each do |arg|
-      dependencies << arg
-      attr_accessor arg
-    end
-  end
+module CSVParty
+  DATA_OPTIONS = [:path, :file, :content].freeze
+  CSV_OPTIONS = CSV::DEFAULT_OPTIONS.keys.push(:encoding).freeze
 
-  def self.dependencies
-    @dependencies ||= []
+  def self.included(base)
+    base.extend DSL
   end
 
-  def self.columns
-    @columns ||= {}
-  end
-
-  def self.row_importer
-    @row_importer ||= nil
-  end
+  attr_reader :skipped_rows, :aborted_rows, :error_rows
+  attr_accessor :aborted, :abort_message
 
-  def self.importer
-    @importer ||= nil
+  def initialize(options = {})
+    self.config = self.class.config
+    raise_unless_all_options_are_recognized!(options)
+    self.csv = DataPreparer.new(options).prepare
+    assign_dependencies_if_present(options)
   end
 
-  def self.error_processor
-    @error_processor ||= nil
+  def import!
+    @skipped_rows = []
+    @aborted_rows = []
+    @error_rows = []
+    @aborted = false
+    self.runner = Runner.new(csv, config, self)
+    runner.import!
   end
 
   def aborted?
     @aborted
   end
 
-  def self.raise_if_duplicate_column(name)
-    return unless columns.has_key?(name)
-
-    raise DuplicateColumnError, "A column named :#{name} has already been \
-              defined, choose a different name"
+  def present_columns
+    runner.present_columns
   end
-  private_class_method :raise_if_duplicate_column
-
-  def self.raise_if_missing_header(name, options)
-    return if options.has_key?(:header)
 
-    raise MissingHeaderError, "A header must be specified for #{name}"
+  def missing_columns
+    runner.missing_columns
   end
-  private_class_method :raise_if_missing_header
 
   private
 
-  def import_row!(row)
-    parsed_row = parse_row(row)
-    instance_exec(parsed_row, &row_importer)
-  end
-
-  def parse_row(row)
-    unparsed_row = OpenStruct.new
-    columns.each do |column, options|
-      header = options[:header]
-      unparsed_row[column] = row[header]
-    end
-
-    parsed_row = OpenStruct.new
-    columns.each do |column, options|
-      value = row[options[:header]]
-      parsed_row[column] = parse_column(
-        value,
-        options[:parser],
-        options[:blanks_as_nil]
-      )
-    end
-
-    parsed_row[:unparsed] = unparsed_row
-    parsed_row[:csv_string] = row.to_csv
-
-    return parsed_row
-  end
-
-  def parse_column(value, parser, blanks_as_nil)
-    if blanks_as_nil && is_blank?(value)
-      nil
-    elsif parser.is_a? Symbol
-      send(parser, value)
-    else
-      instance_exec(value, &parser)
-    end
-  end
-
-  def process_error(error, line_number)
-    instance_exec(error, line_number, &error_processor)
-  end
-
-  def skip_row
-    raise SkippedRowError
-  end
-
-  def abort_row(message)
-    raise AbortedRowError, message
-  end
-
-  def abort_import(message)
-    raise AbortedImportError, message
-  end
-
-  def is_blank?(value)
-    value.nil? || value.strip.empty?
-  end
-
-  def raw_parser(value)
-    value
-  end
-
-  def string_parser(value)
-    value.to_s.strip
-  end
+  attr_accessor :runner, :config, :csv
 
-  def boolean_parser(value)
-    %w[1 t true].include? value.to_s.strip.downcase
-  end
-
-  def integer_parser(value)
-    value.to_i
-  end
-
-  def decimal_parser(value)
-    cleaned_value = value.to_s.strip.gsub(/[^0-9.]/, '')
-    BigDecimal.new(cleaned_value)
-  end
-
-  def named_parsers
-    (private_methods + methods).grep(/_parser$/)
-  end
-
-  def columns_with_named_parsers
-    columns.select { |_name, options| options[:parser].is_a? Symbol }
-  end
-
-  # This error has to be raised at runtime because, when the class body
-  # is being executed, the parser methods won't be available unless
-  # they are defined above the column definitions in the class body
-  def raise_unless_named_parsers_are_valid
-    columns_with_named_parsers.each do |name, options|
-      parser = options[:parser]
-      next if named_parsers.include? parser
-
-      parser = parser.to_s.gsub('_parser', '')
-      parsers = named_parsers
-                .map { |p| p.to_s.gsub('_parser', '') }
-                .join(', :')
-      raise UnknownParserError,
-            "You're trying to use the :#{parser} parser for the :#{name} \
-            column, but it doesn't exist. Available parsers are: :#{parsers}."
+  def raise_unless_all_options_are_recognized!(options)
+    unrecognized_options = options.keys.reject do |option|
+      valid_options.include? option
     end
-  end
+    return if unrecognized_options.empty?
 
-  def defined_headers
-    columns.map { |_name, options| options[:header] }
+    raise UnrecognizedOptionsError.new(unrecognized_options,
+                                       DATA_OPTIONS,
+                                       CSV_OPTIONS,
+                                       config.dependencies)
   end
 
-  def raise_unless_csv_has_all_headers
-    missing_columns = defined_headers - @headers
-    return if missing_columns.empty?
+  def assign_dependencies_if_present(options)
+    return unless config.dependencies.any?
 
-    columns = missing_columns.join("', '")
-    raise MissingColumnError,
-          "CSV file is missing column(s) with header(s) '#{columns}'. \
-              File has these headers: #{@headers.join(', ')}."
-  end
-
-  def initialize_import_settings
-    @columns = self.class.columns
-    @row_importer = self.class.row_importer
-    @importer = self.class.importer
-    @error_processor = self.class.error_processor
-    @dependencies = self.class.dependencies
-  end
-
-  def initialize_counters_and_statuses
-    @imported_rows = []
-    @skipped_rows = []
-    @aborted_rows = []
-    @aborted = false
-  end
-
-  def initialize_dependencies(options)
-    dependencies.each do |dependency|
+    config.dependencies.each do |dependency|
       if options.has_key? dependency
         send("#{dependency}=", options.delete(dependency))
-      else
-        raise MissingDependencyError,
-              <<-MESSAGE
-This importer depends on #{dependency}, but you didn't include it.
-Here's how you do that: #{self.class.name}.new('path/to/csv', #{dependency}: #{dependency})
-              MESSAGE
       end
     end
   end
-end
 
-class UnknownParserError < ArgumentError
-end
-
-class MissingHeaderError < ArgumentError
-end
-
-class DuplicateColumnError < ArgumentError
-end
-
-class MissingColumnError < ArgumentError
-end
-
-class MissingDependencyError < ArgumentError
-end
-
-class SkippedRowError < RuntimeError
-end
-
-class AbortedRowError < RuntimeError
-end
-
-class AbortedImportError < RuntimeError
+  def valid_options
+    DATA_OPTIONS + CSV_OPTIONS + config.dependencies
+  end
 end

data/lib/csv_party/configuration.rb

@@ -0,0 +1,82 @@
+module CSVParty
+  class Configuration
+    attr_accessor :row_importer, :file_importer, :error_handler,
+                  :skipped_row_handler, :aborted_row_handler
+
+    attr_reader :columns, :dependencies
+
+    def initialize
+      @columns = {}
+      @dependencies = []
+    end
+
+    def add_column(column, options = {}, &block)
+      raise_if_duplicate_column(column)
+      raise_if_reserved_column_name(column)
+
+      options = {
+        header: column_regex(column),
+        as: :string,
+        format: nil,
+        intercept_blanks: (options[:as] != :raw)
+      }.merge(options)
+
+      parser = if block_given?
+                 block
+               else
+                 "parse_#{options[:as]}".to_sym
+               end
+
+      columns[column] = {
+        header: options[:header],
+        parser: parser,
+        format: options[:format],
+        intercept_blanks: options[:intercept_blanks]
+      }
+    end
+
+    def add_dependency(*args)
+      args.each do |arg|
+        dependencies << arg
+      end
+    end
+
+    def columns_with_named_parsers
+      columns.select { |_name, options| options[:parser].is_a? Symbol }
+    end
+
+    def columns_with_regex_headers
+      columns.select { |_name, options| options[:header].is_a? Regexp }
+    end
+
+    def required_columns
+      columns.map { |_name, options| options[:header] }
+    end
+
+    private
+
+    def column_regex(column)
+      column = Regexp.escape(column.to_s)
+      underscored_or_whitespaced = "#{column}|#{column.tr('_', ' ')}"
+      /\A\s*#{underscored_or_whitespaced}\s*\z/i
+    end
+
+    def raise_if_duplicate_column(name)
+      return unless columns.has_key?(name)
+
+      raise DuplicateColumnError.new(name)
+    end
+
+    RESERVED_COLUMN_NAMES = [:unparsed,
+                             :csv_string,
+                             :row_number,
+                             :skip_message,
+                             :abort_message].freeze
+
+    def raise_if_reserved_column_name(column)
+      return unless RESERVED_COLUMN_NAMES.include? column
+
+      raise ReservedColumnNameError.new(RESERVED_COLUMN_NAMES)
+    end
+  end
+end

data/lib/csv_party/data_preparer.rb

@@ -0,0 +1,45 @@
+module CSVParty
+  class DataPreparer
+    def initialize(options)
+      @options = options
+    end
+
+    def prepare
+      raise_unless_csv_is_present!
+
+      data = if @options.has_key?(:path)
+               open_csv_path(@options[:path])
+             elsif @options.has_key?(:file)
+               @options[:file]
+             elsif @options.has_key?(:content)
+               @options[:content]
+             end
+      options = extract_csv_options.merge(headers: true)
+      CSV.new(data, options)
+    end
+
+    private
+
+    def open_csv_path(path)
+      raise NonexistentCSVFileError.new(path) unless File.file?(path)
+
+      if @options.has_key?(:encoding)
+        File.open(path, "r:#{@options[:encoding]}")
+      else
+        File.open(path)
+      end
+    end
+
+    def extract_csv_options
+      @options.select do |option, _value|
+        CSV_OPTIONS.include?(option)
+      end
+    end
+
+    def raise_unless_csv_is_present!
+      return if DATA_OPTIONS.any? { |option| @options.has_key?(option) }
+
+      raise MissingCSVError.new(self)
+    end
+  end
+end