topographer 0.0.7 → 0.0.8

data/lib/topographer/importer/input/source_data.rb

@@ -1,12 +1,18 @@
-class Topographer::Importer::Input::SourceData
-  attr_reader :source_identifier, :data
+module Topographer
+  class Importer
+    module Input
+      class SourceData
+        attr_reader :source_identifier, :data
 
-  def initialize(source_identifier, data)
-    @source_identifier = source_identifier
-    @data = data
-  end
+        def initialize(source_identifier, data)
+          @source_identifier = source_identifier
+          @data = data
+        end
 
-  def empty?
-    @data.empty?
+        def empty?
+          @data.empty?
+        end
+      end
+    end
   end
 end

data/lib/topographer/importer/logger.rb

@@ -1,8 +1,12 @@
-class Topographer::Importer::Logger
-  require_relative 'logger/base'
-  require_relative 'logger/simple'
-  require_relative 'logger/file'
-  require_relative 'logger/log_entry'
-  require_relative 'logger/fatal_error_entry'
+require_relative 'logger/base'
+require_relative 'logger/simple'
+require_relative 'logger/file'
+require_relative 'logger/log_entry'
+require_relative 'logger/fatal_error_entry'
 
+module Topographer
+  class Importer
+    module Logger
+    end
+  end
 end

data/lib/topographer/importer/logger/base.rb

@@ -1,69 +1,78 @@
-class Topographer::Importer::Logger::Base
-
-  attr_reader :fatal_errors
-
-  def initialize
-    @fatal_errors = []
-  end
-
-  def successes
-    raise NotImplementedError
-  end
-
-  def failures
-    raise NotImplementedError
-  end
-
-  def log_import(log_entry)
-    if log_entry.success?
-      log_success(log_entry)
-    else
-      log_failure(log_entry)
+module Topographer
+  class Importer
+    module Logger
+      class Base
+
+        attr_reader :fatal_errors
+
+        def initialize
+          @fatal_errors = []
+        end
+
+        def successes
+          raise NotImplementedError
+        end
+
+        def failures
+          raise NotImplementedError
+        end
+
+        def log_import(log_entry)
+          if log_entry.success?
+            log_success(log_entry)
+          else
+            log_failure(log_entry)
+          end
+        end
+
+        def log_success(log_entry)
+          raise NotImplementedError
+        end
+
+        def log_failure(log_entry)
+          raise NotImplementedError
+        end
+
+        def log_fatal(source, message)
+          @fatal_errors << Topographer::Importer::Logger::FatalErrorEntry.new(source, message)
+        end
+
+        def successful_imports
+          raise NotImplementedError
+        end
+
+        def failed_imports
+          raise NotImplementedError
+        end
+
+        def entries?
+          total_imports > 0
+        end
+
+        def total_imports
+          (successful_imports + failed_imports)
+        end
+
+        def all_entries
+          (successes + failures + fatal_errors).sort { |a, b| a.timestamp <=> b.timestamp }
+        end
+
+        def errors?
+          fatal_error? || failed_imports > 0
+        end
+
+        def success?
+          !errors?
+        end
+
+        def fatal_error?
+          @fatal_errors.any?
+        end
+
+        def save
+          raise NotImplementedError
+        end
+      end
     end
   end
-
-  def log_success(log_entry)
-    raise NotImplementedError
-  end
-
-  def log_failure(log_entry)
-    raise NotImplementedError
-  end
-
-  def log_fatal(source, message)
-    @fatal_errors << Topographer::Importer::Logger::FatalErrorEntry.new(source, message)
-  end
-
-  def successful_imports
-    raise NotImplementedError
-  end
-
-  def failed_imports
-    raise NotImplementedError
-  end
-
-  def entries?
-    total_imports > 0
-  end
-
-  def total_imports
-    (successful_imports + failed_imports)
-  end
-
-  def all_entries
-    (successes + failures + fatal_errors).sort {|a, b| a.timestamp <=> b.timestamp}
-  end
-
-  def errors?
-    fatal_error? || failed_imports > 0
-  end
-
-  def fatal_error?
-    @fatal_errors.any?
-  end
-
-  def save
-    raise NotImplementedError
-  end
-
 end

data/lib/topographer/importer/logger/fatal_error_entry.rb

@@ -1,19 +1,25 @@
-class Topographer::Importer::Logger::FatalErrorEntry < Topographer::Importer::Logger::LogEntry
-  attr_reader :message, :timestamp, :model_name
+module Topographer
+  class Importer
+    module Logger
+      class FatalErrorEntry < Topographer::Importer::Logger::LogEntry
+        attr_reader :message, :timestamp, :model_name
 
-  def initialize(input_identifier, message)
-    @timestamp = DateTime.now
-    @input_identifier = input_identifier
-    @model_name = 'N/A'
-    @message = message
-  end
-  def source_identifier
-    'import failure'
-  end
-  def details
-    {}
-  end
-  def failure?
-    true
+        def initialize(input_identifier, message)
+          @timestamp = DateTime.now
+          @input_identifier = input_identifier
+          @model_name = 'N/A'
+          @message = message
+        end
+        def source_identifier
+          'import failure'
+        end
+        def details
+          {}
+        end
+        def failure?
+          true
+        end
+      end
+    end
   end
 end

data/lib/topographer/importer/logger/log_entry.rb

@@ -1,34 +1,40 @@
-class Topographer::Importer::Logger::LogEntry
-  attr_reader :input_identifier,
-              :model_name
+module Topographer
+  class Importer
+    module Logger
+      class LogEntry
+        attr_reader :input_identifier,
+          :model_name
 
-  def initialize(input_identifier, model_name, import_status)
-    @input_identifier = input_identifier
-    @model_name = model_name
-    @import_status = import_status
-  end
+        def initialize(input_identifier, model_name, import_status)
+          @input_identifier = input_identifier
+          @model_name = model_name
+          @import_status = import_status
+        end
 
-  def source_identifier
-    @import_status.input_identifier
-  end
+        def source_identifier
+          @import_status.input_identifier
+        end
 
-  def message
-    @import_status.message
-  end
+        def message
+          @import_status.message
+        end
 
-  def timestamp
-    @import_status.timestamp
-  end
+        def timestamp
+          @import_status.timestamp
+        end
 
-  def details
-    @import_status.errors
-  end
+        def details
+          @import_status.errors
+        end
 
-  def success?
-    !failure?
-  end
+        def success?
+          !failure?
+        end
 
-  def failure?
-    @import_status.errors?
+        def failure?
+          @import_status.errors?
+        end
+      end
+    end
   end
 end

data/lib/topographer/importer/logger/simple.rb

@@ -1,27 +1,33 @@
-class Topographer::Importer::Logger::Simple < Topographer::Importer::Logger::Base
+module Topographer
+  class Importer
+    module Logger
+      class Simple < Topographer::Importer::Logger::Base
 
-  attr_reader :successes, :failures
+        attr_reader :successes, :failures
 
-  def initialize
-    @successes = []
-    @failures = []
-    super
-  end
+        def initialize
+          @successes = []
+          @failures = []
+          super
+        end
 
-  def log_success(message)
-    @successes << message
-  end
+        def log_success(message)
+          @successes << message
+        end
 
-  def log_failure(message)
-    @failures << message
-  end
+        def log_failure(message)
+          @failures << message
+        end
 
-  def successful_imports
-    @successes.size
-  end
+        def successful_imports
+          @successes.size
+        end
 
-  def failed_imports
-    @failures.size
-  end
+        def failed_imports
+          @failures.size
+        end
 
+      end
+    end
+  end
 end

data/lib/topographer/importer/mapper.rb

@@ -1,68 +1,73 @@
-class Topographer::Importer::Mapper
-  require_relative 'mapper/mapping_validator'
-  require_relative 'mapper/mapping_columns'
-  require_relative 'mapper/mapper_builder'
-  require_relative 'mapper/field_mapping'
-  require_relative 'mapper/ignored_field_mapping'
-  require_relative 'mapper/validation_field_mapping'
-  require_relative 'mapper/default_field_mapping'
-  require_relative 'mapper/result'
+require_relative 'mapper/mapping_validator'
+require_relative 'mapper/mapping_columns'
+require_relative 'mapper/mapper_builder'
+require_relative 'mapper/field_mapping'
+require_relative 'mapper/ignored_field_mapping'
+require_relative 'mapper/validation_field_mapping'
+require_relative 'mapper/default_field_mapping'
+require_relative 'mapper/result'
 
-  include Topographer::Importer::Mapper::MappingColumns
+module Topographer
+  class Importer
+    class Mapper
 
-  attr_reader :required_mappings, :optional_mappings, :ignored_mappings, :validation_mappings,
-              :default_values, :key_fields, :bad_columns, :missing_columns, :model_class, :key_fields
+      include Topographer::Importer::Mapper::MappingColumns
 
-  def self.build_mapper(model_class)
-    mapper_builder = MapperBuilder.new()
-    yield mapper_builder
+      attr_reader :required_mappings, :optional_mappings, :ignored_mappings, :validation_mappings,
+        :default_values, :key_fields, :bad_columns, :missing_columns, :model_class, :key_fields
 
-    new(mapper_builder, model_class)
-  end
+      def self.build_mapper(model_class)
+        mapper_builder = MapperBuilder.new()
+        yield mapper_builder
 
-  def initialize(mapper_builder, model_class)
-    @required_mappings = mapper_builder.required_mappings
-    @optional_mappings = mapper_builder.optional_mappings
-    @ignored_mappings = mapper_builder.ignored_mappings
-    @validation_mappings = mapper_builder.validation_mappings
-    @default_values = mapper_builder.default_values
-    @key_fields = mapper_builder.key_fields
-    @model_class = model_class
-  end
+        new(mapper_builder, model_class)
+      end
 
-  def input_structure_valid?(input_columns, options={})
-    ignore_unmapped_columns = options.fetch(:ignore_unmapped_columns, false)
-    @bad_columns ||= input_columns - mapped_input_columns
-    @missing_columns ||= required_input_columns - input_columns
+      def initialize(mapper_builder, model_class)
+        @required_mappings = mapper_builder.required_mappings
+        @optional_mappings = mapper_builder.optional_mappings
+        @ignored_mappings = mapper_builder.ignored_mappings
+        @validation_mappings = mapper_builder.validation_mappings
+        @default_values = mapper_builder.default_values
+        @key_fields = mapper_builder.key_fields
+        @field_mappings = mapper_builder.field_mappings
+        @model_class = model_class
+      end
 
-    if ignore_unmapped_columns
-      @missing_columns.empty?
-    else
-      @bad_columns.empty? && @missing_columns.empty?
-    end
-  end
+      def input_structure_valid?(input_columns, options={})
+        ignore_unmapped_columns = options.fetch(:ignore_unmapped_columns, false)
+        @bad_columns ||= input_columns - mapped_input_columns
+        @missing_columns ||= required_input_columns - input_columns
 
-  def map_input(source_data)
-    mapping_result = Result.new(source_data.source_identifier)
+        if ignore_unmapped_columns
+          @missing_columns.empty?
+        else
+          @bad_columns.empty? && @missing_columns.empty?
+        end
+      end
 
-    if source_data.empty?
-      handle_no_data(mapping_result)
-    else
-      @validation_mappings.values.each do |validation_field_mapping|
-        validation_field_mapping.process_input(source_data.data, mapping_result)
+      def map_input(source_data)
+        mapping_result = Result.new(source_data.source_identifier)
+
+        if source_data.empty?
+          handle_no_data(mapping_result)
+        else
+          @validation_mappings.values.each do |validation_field_mapping|
+            validation_field_mapping.process_input(source_data.data, mapping_result)
+          end
+
+          mappings.each do |_output_field, field_mapping|
+            field_mapping.process_input(source_data.data, mapping_result)
+          end
+        end
+
+        mapping_result
       end
 
-      output_fields.each do |output_field|
-        field_mapping = mappings[output_field]
-        field_mapping.process_input(source_data.data, mapping_result)
+      private
+      def handle_no_data(mapping_result)
+        mapping_result.add_error('EmptyRow', 'Unable to import empty row.')
       end
     end
-
-    mapping_result
   end
-
-  private
-    def handle_no_data(mapping_result)
-      mapping_result.add_error('EmptyRow', 'Unable to import empty row.')
-    end
 end