topographer 0.0.7 → 0.0.8

data/lib/topographer/importer/mapper/result.rb

@@ -1,21 +1,27 @@
-class Topographer::Importer::Mapper::Result
-  attr_reader :data, :errors, :source_identifier
+module Topographer
+  class Importer
+    class Mapper
+      class Result
+        attr_reader :data, :errors, :source_identifier
 
-  def initialize(source_identifier)
-    @source_identifier = source_identifier
-    @data = {}
-    @errors = {}
-  end
+        def initialize(source_identifier)
+          @source_identifier = source_identifier
+          @data = {}
+          @errors = {}
+        end
 
-  def add_data (key, value)
-    @data[key] = value
-  end
+        def add_data (key, value)
+          @data[key] = value
+        end
 
-  def add_error (key, value)
-    @errors[key] = value
-  end
+        def add_error (key, value)
+          @errors[key] = value
+        end
 
-  def errors?
-    errors.any?
+        def errors?
+          errors.any?
+        end
+      end
+    end
   end
 end

data/lib/topographer/importer/mapper/validation_field_mapping.rb

@@ -1,36 +1,43 @@
-class Topographer::Importer::Mapper::ValidationFieldMapping < Topographer::Importer::Mapper::FieldMapping
-  attr_reader :name
+module Topographer
+  class Importer
+    class Mapper
+      class ValidationFieldMapping < Topographer::Importer::Mapper::FieldMapping
+        attr_reader :name
 
-  def initialize(name, input_columns, &validation_block)
-    unless block_given?
-      raise Topographer::InvalidMappingError, 'Validation fields must have a behavior block'
-    end
-    @name = name
-    @input_columns = Array(input_columns)
-    @validation_block = validation_block
-    @output_field = nil
-  end
+        def initialize(name, input_columns, &validation_block)
+          unless block_given?
+            raise Topographer::InvalidMappingError, 'Validation fields must have a behavior block'
+          end
+          @name = name
+          @input_columns = Array(input_columns)
+          @validation_block = validation_block
+          @output_field = nil
+        end
 
-  def process_input(input, result)
-    mapping_input = input.slice(*input_columns)
-    @invalid_keys = get_invalid_keys(mapping_input)
-    if @invalid_keys.blank?
-      @validation_block.(mapping_input)
-    else
-      result.add_error(name, invalid_input_error)
-    end
+        def process_input(input, result)
+          mapping_input = input.slice(*input_columns)
+          @invalid_keys = get_invalid_keys(mapping_input)
+          if @invalid_keys.blank?
+            @validation_block.(mapping_input)
+          else
+            result.add_error(name, invalid_input_error)
+          end
 
-  rescue => exception
-    result.add_error(name, exception.message)
+        rescue => exception
+          result.add_error(name, exception.message)
 
-  end
+        end
 
-  def required?
-    true
-  end
+        def required?
+          true
+        end
+
+        private
 
-  private
-    def get_invalid_keys(input)
-      @input_columns - input.keys
+        def get_invalid_keys(input)
+          @input_columns - input.keys
+        end
+      end
     end
+  end
 end

data/lib/topographer/importer/strategy.rb

@@ -1,7 +1,13 @@
-module Topographer::Importer::Strategy
-  require_relative 'strategy/base'
-  require_relative 'strategy/import_new_record'
-  require_relative 'strategy/update_record'
-  require_relative 'strategy/create_or_update_record'
-  require_relative 'strategy/import_status'
+require_relative 'strategy/base'
+require_relative 'strategy/import_new_record'
+require_relative 'strategy/update_record'
+require_relative 'strategy/create_or_update_record'
+require_relative 'strategy/import_status'
+
+module Topographer
+  class Importer
+    module Strategy
+
+    end
+  end
 end

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

@@ -1,42 +1,47 @@
-class Topographer::Importer::Strategy::Base
+module Topographer
+  class Importer
+    module Strategy
+      class Base
+
+        attr_accessor :dry_run, :mapper
+
+        def initialize(mapper)
+          @mapper = mapper
+          @dry_run = false
+        end
+
+        def import_record (record_input)
+          raise NotImplementedError
+        end
+
+        def success_message
+          'Imported'
+        end
+
+        def failure_message
+          'Unable to import'
+        end
+
+        def should_persist_import?(status)
+          (@dry_run || status.errors?) ? false : true
+        end
+
+        private
+
+        def get_import_status(mapping_result, new_model_errors)
+          status = Topographer::Importer::Strategy::ImportStatus.new(mapping_result.source_identifier)
+          mapping_result.errors.values.each do |error|
+            status.add_error(:mapping, error)
+          end
+          new_model_errors.each do |error|
+            status.add_error(:validation, error)
+          end
+          status.message = (status.errors?) ? failure_message : success_message
+          status.set_timestamp
+          status
+        end
 
-  attr_reader :mapper
-  attr_accessor :dry_run
-
-  def initialize(mapper)
-    @mapper = mapper
-    @dry_run = false
-  end
-
-  def import_record (record_input)
-    raise NotImplementedError
-  end
-
-  def success_message
-    'Imported'
-  end
-
-  def failure_message
-    'Unable to import'
-  end
-
-  def should_persist_import?(status)
-    (@dry_run || status.errors?) ? false : true
-  end
-
-  private
-
-    def get_import_status(mapping_result, new_model_errors)
-      status = Topographer::Importer::Strategy::ImportStatus.new(mapping_result.source_identifier)
-      mapping_result.errors.values.each do |error|
-        status.add_error(:mapping, error)
       end
-      new_model_errors.each do |error|
-        status.add_error(:validation, error)
-      end
-      status.message = (status.errors?) ? failure_message : success_message
-      status.set_timestamp
-      status
     end
-
+  end
 end

data/lib/topographer/importer/strategy/create_or_update_record.rb

@@ -1,50 +1,55 @@
-class Topographer::Importer::Strategy::CreateOrUpdateRecord < Topographer::Importer::Strategy::Base
+module Topographer
+  class Importer
+    module Strategy
+      class CreateOrUpdateRecord < Topographer::Importer::Strategy::Base
 
-  def import_record (source_data)
-    mapping_result = mapper.map_input(source_data)
+        def import_record (source_data)
+          mapping_result = mapper.map_input(source_data)
 
-    search_params = mapping_result.data.slice(*mapper.key_fields)
-    model_instances = mapper.model_class.where(search_params)
+          search_params = mapping_result.data.slice(*mapper.key_fields)
+          model_instances = mapper.model_class.where(search_params)
 
-    if model_instances.any?
-      model_instance = model_instances.first
-    else
-      model_instance = mapper.model_class.new(search_params)
-    end
+          if model_instances.any?
+            model_instance = model_instances.first
+          else
+            model_instance = mapper.model_class.new(search_params)
+          end
 
-    generate_messages(model_instance, search_params)
+          generate_messages(model_instance, search_params)
 
-    model_instance.attributes = mapping_result.data
-    model_instance.valid?
+          model_instance.attributes = mapping_result.data
+          model_instance.valid?
 
-    model_errors = model_instance.errors.full_messages
-    status = get_import_status(mapping_result, model_errors)
+          model_errors = model_instance.errors.full_messages
+          status = get_import_status(mapping_result, model_errors)
 
-    model_instance.save if should_persist_import?(status)
+          model_instance.save if should_persist_import?(status)
 
-    status
-  end
+          status
+        end
 
+        def success_message
+          @success_message
+        end
 
-  def success_message
-    @success_message
-  end
+        def failure_message
+          @failure_message
+        end
 
-  def failure_message
-    @failure_message
-  end
+        private
 
-  private
+        def generate_messages(model_instance, search_params)
+          if model_instance.new_record?
+            @success_message = 'Imported record'
+            @failure_message = 'Import failed'
+          else
+            params_string = search_params.map { |k, v| "#{k}: #{v}" }.join(', ')
+            @success_message = "Updated record matching `#{params_string}`"
+            @failure_message = "Update failed for record matching `#{params_string}`"
+          end
+        end
 
-    def generate_messages(model_instance, search_params)
-      if model_instance.new_record?
-        @success_message = 'Imported record'
-        @failure_message = 'Import failed'
-      else
-        params_string = search_params.map{|k, v| "#{k}: #{v}"}.join(', ')
-        @success_message = "Updated record matching `#{params_string}`"
-        @failure_message = "Update failed for record matching `#{params_string}`"
       end
     end
-
+  end
 end

data/lib/topographer/importer/strategy/import_new_record.rb

@@ -1,17 +1,23 @@
-class Topographer::Importer::Strategy::ImportNewRecord < Topographer::Importer::Strategy::Base
+module Topographer
+  class Importer
+    module Strategy
+      class ImportNewRecord < Topographer::Importer::Strategy::Base
 
-  def import_record (source_data)
-    mapping_result = mapper.map_input(source_data)
-    new_model = mapper.model_class.new(mapping_result.data)
-    new_model.valid?
-    model_errors = new_model.errors.full_messages
-    status = get_import_status(mapping_result, model_errors)
+        def import_record (source_data)
+          mapping_result = mapper.map_input(source_data)
+          new_model = mapper.model_class.new(mapping_result.data)
+          new_model.valid?
+          model_errors = new_model.errors.full_messages
+          status = get_import_status(mapping_result, model_errors)
 
-    new_model.save if should_persist_import?(status)
+          new_model.save if should_persist_import?(status)
 
-    status
-  end
+          status
+        end
 
+      end
+    end
+  end
 end
 
 

data/lib/topographer/importer/strategy/import_status.rb

@@ -1,28 +1,35 @@
-class Topographer::Importer::Strategy::ImportStatus
-  attr_reader :errors, :input_identifier, :timestamp
-  attr_accessor :message
+module Topographer
+  class Importer
+    module Strategy
+      class ImportStatus
+        attr_reader :errors, :input_identifier, :timestamp
+        attr_accessor :message
 
-  def initialize(input_identifier)
-    @input_identifier = input_identifier
-    @errors = {mapping: [],
-               validation: []}
+        def initialize(input_identifier)
+          @input_identifier = input_identifier
+          @errors = {mapping: [],
+            validation: []}
 
-  end
+        end
 
-  def set_timestamp
-    @timestamp ||= DateTime.now
-  end
+        def set_timestamp
+          @timestamp ||= DateTime.now
+        end
 
-  def add_error(error_source, error)
-    errors[error_source] << error
-  end
+        def add_error(error_source, error)
+          errors[error_source] << error
+        end
 
-  def error_count
-    errors.values.flatten.length
-  end
+        def error_count
+          errors.values.flatten.length
+        end
 
-  def errors?
-    errors.values.flatten.any?
-  end
+        def errors?
+          errors.values.flatten.any?
+        end
+
+      end
 
+    end
+  end
 end

data/lib/topographer/importer/strategy/update_record.rb

@@ -1,33 +1,37 @@
-class Topographer::Importer::Strategy::UpdateRecord < Topographer::Importer::Strategy::Base
+module Topographer
+  class Importer
+    module Strategy
+      class UpdateRecord < Topographer::Importer::Strategy::Base
 
-  def import_record (source_data)
-    mapping_result = mapper.map_input(source_data)
+        def import_record (source_data)
+          mapping_result = mapper.map_input(source_data)
 
-    search_params = mapping_result.data.slice(*mapper.key_fields)
-    model_instance = mapper.model_class.where(search_params).first
+          search_params = mapping_result.data.slice(*mapper.key_fields)
+          model_instance = mapper.model_class.where(search_params).first
 
-    if model_instance
-      model_instance.attributes = mapping_result.data
-      model_instance.valid?
-      model_errors = model_instance.errors.full_messages
-      status = get_import_status(mapping_result, model_errors)
+          if model_instance
+            model_instance.attributes = mapping_result.data
+            model_instance.valid?
+            model_errors = model_instance.errors.full_messages
+            status = get_import_status(mapping_result, model_errors)
 
-      model_instance.save if should_persist_import?(status)
-    else
-      status = get_import_status(mapping_result, ["Record not found with params: #{search_params.to_yaml}"])
-    end
+            model_instance.save if should_persist_import?(status)
+          else
+            status = get_import_status(mapping_result, ["Record not found with params: #{search_params.to_yaml}"])
+          end
 
-    status
-  end
+          status
+        end
 
-  def success_message
-    'Updated'
-  end
+        def success_message
+          'Updated'
+        end
 
-  def failure_message
-    'Unable to update from import'
-  end
+        def failure_message
+          'Unable to update from import'
+        end
 
+      end
+    end
+  end
 end
-
-