topographer 0.0.1

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

@@ -0,0 +1,34 @@
+class Importer::Logger::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 source_identifier
+    @import_status.input_identifier
+  end
+
+  def message
+    @import_status.message
+  end
+
+  def timestamp
+    @import_status.timestamp
+  end
+
+  def details
+    @import_status.errors
+  end
+
+  def success?
+    !failure?
+  end
+
+  def failure?
+    @import_status.errors?
+  end
+end

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

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

data/lib/Topographer/importer/mapper.rb

@@ -0,0 +1,161 @@
+class Importer::Mapper
+  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'
+
+  attr_reader :bad_columns, :missing_columns, :model_class, :key_fields
+
+  def self.build_mapper(model_class)
+    mapper = self.new(model_class)
+    yield mapper
+
+    mapper
+  end
+
+  def initialize(model_class)
+    @required_mappings = {}
+    @optional_mappings = {}
+    @ignored_mappings = {}
+    @validation_mappings = {}
+    @default_values = {}
+    @key_fields = []
+    @model_class = model_class
+  end
+
+  def required_columns
+    @required_mappings.values.flat_map(&:input_columns)
+  end
+
+  def optional_columns
+    @optional_mappings.values.flat_map(&:input_columns)
+  end
+
+  def ignored_columns
+    @ignored_mappings.values.flat_map(&:input_columns)
+  end
+
+  def validation_columns
+    @validation_mappings.values.flat_map(&:input_columns)
+  end
+
+  def default_fields
+    @default_values.keys
+  end
+
+  def input_columns
+    required_columns + optional_columns + validation_columns
+  end
+
+  def required_input_columns
+    required_columns + validation_columns
+  end
+
+  def output_fields
+    (@required_mappings.merge(@optional_mappings).merge(@default_values)).values.map(&:output_field)
+  end
+
+  def required_mapping(input_columns, output_field, &mapping_behavior)
+    validate_unique_mapping(input_columns, output_field)
+    @required_mappings[output_field] = FieldMapping.new(true, input_columns, output_field, &mapping_behavior)
+  end
+
+  def optional_mapping(input_columns, output_field, &mapping_behavior)
+    validate_unique_mapping(input_columns, output_field)
+    @optional_mappings[output_field] = FieldMapping.new(false, input_columns, output_field, &mapping_behavior)
+  end
+
+  def validation_field(name, input_columns, &mapping_behavior)
+    validate_unique_validation_name(name)
+    @validation_mappings[name] = ValidationFieldMapping.new(name, input_columns, &mapping_behavior)
+  end
+
+  def default_value(output_field, &mapping_behavior)
+    validate_unique_mapping([], output_field)
+    @default_values[output_field] = DefaultFieldMapping.new(output_field, &mapping_behavior)
+  end
+
+  def key_field(output_field)
+    validate_key_field(output_field)
+    @key_fields << output_field
+  end
+
+  def ignored_column(input_column)
+    validate_unique_column_mapping_type(input_column, ignored: true)
+    @ignored_mappings[input_column] = IgnoredFieldMapping.new(input_column)
+  end
+
+  def input_structure_valid?(input_columns)
+    @bad_columns ||= input_columns - mapped_input_columns
+    @missing_columns ||= required_input_columns - input_columns
+    @bad_columns.empty? && @missing_columns.empty?
+  end
+
+  def map_input(source_data)
+    mapping_result = Result.new(source_data.source_identifier)
+
+    @validation_mappings.values.each do |validation_field_mapping|
+      validation_field_mapping.process_input(source_data.data, mapping_result)
+    end
+
+    output_fields.each do |output_field|
+      field_mapping = mappings[output_field]
+      field_mapping.process_input(source_data.data, mapping_result)
+    end
+
+    mapping_result
+  end
+
+  private
+    def mapped_input_columns
+      required_columns + optional_columns + ignored_columns + validation_columns
+    end
+
+    def mappings
+      @required_mappings.merge(@optional_mappings).merge(@ignored_mappings).merge(@default_values)
+    end
+
+    def non_ignored_columns
+      @required_mappings.merge(@optional_mappings)
+    end
+
+    def validate_key_field(field)
+      if field.is_a?(Array)
+        raise Topographer::InvalidMappingError, 'One to many mapping is not supported'
+      elsif @key_fields.include?(field)
+        raise Topographer::InvalidMappingError, "Field `#{field}` has already been included as a key"
+      end
+    end
+
+    def validate_unique_mapping(input_columns, output_field)
+      if(output_field.is_a?(Array))
+        raise Topographer::InvalidMappingError, 'One to many mapping is not supported'
+      end
+      validate_unique_column_mapping_type(input_columns)
+      validate_unique_output_mapping(output_field)
+    end
+
+    def validate_unique_column_mapping_type(mapping_input_columns, options = {})
+      ignored = options.fetch(:ignored, false)
+      mapping_input_columns = Array(mapping_input_columns)
+      mapping_input_columns.each do |col|
+        if ignored && ((input_columns + ignored_columns).include?(col))
+          raise Topographer::InvalidMappingError, 'Input column already mapped to an output column.'
+        elsif(ignored_columns.include?(col))
+          raise Topographer::InvalidMappingError, 'Input column already ignored.'
+        end
+      end
+    end
+
+    def validate_unique_output_mapping(output_field)
+      if output_fields.include?(output_field)
+        raise Topographer::InvalidMappingError, 'Output column already mapped.'
+      end
+    end
+
+    def validate_unique_validation_name(name)
+      raise Topographer::InvalidMappingError, "A validation already exists with the name `#{name}`" if @validation_mappings.has_key?(name)
+    end
+
+end

data/lib/Topographer/importer/mapper/default_field_mapping.rb

@@ -0,0 +1,22 @@
+class Importer::Mapper::DefaultFieldMapping < Importer::Mapper::FieldMapping
+
+  def initialize(output_column, &output_block)
+    unless block_given?
+      raise Topographer::InvalidMappingError, 'Static fields must have an output block'
+    end
+    @output_field = output_column
+    @output_block = output_block
+  end
+
+  def process_input(_, result)
+    @output_data = @output_block.()
+    result.add_data(@output_field, @output_data)
+  rescue => exception
+    result.add_error(@output_field, exception.message)
+  end
+
+  def required?
+    true
+  end
+
+end

data/lib/Topographer/importer/mapper/field_mapping.rb

@@ -0,0 +1,55 @@
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/object/blank'
+class Importer::Mapper::FieldMapping
+  attr_reader :input_columns, :output_field
+
+  def initialize(required, input_columns, output_field, &mapping_behavior)
+    @required = required
+    @input_columns = Array(input_columns)
+    @output_field = output_field
+    @mapping_behavior = mapping_behavior
+    @invalid_keys = []
+  end
+
+  def process_input(input, result)
+    mapping_input = input.slice(*input_columns)
+    @invalid_keys = get_invalid_keys(mapping_input)
+    data = (@invalid_keys.any?) ? nil : apply_mapping(mapping_input)
+    if !data.nil?
+      result.add_data(output_field, data)
+    elsif required?
+      result.add_error(output_field, invalid_input_error)
+    end
+
+  rescue => exception
+    result.add_error(output_field, exception.message)
+
+  end
+
+  def required?
+    @required
+  end
+
+  private
+
+  def apply_mapping(mapping_input)
+    if @mapping_behavior
+      @mapping_behavior.(mapping_input)
+    else
+      (mapping_input.size > 1) ? mapping_input.values.join(', ') : mapping_input.values.first
+    end
+  end
+
+  def invalid_input_error
+    "Missing required input(s): `#{@invalid_keys.join(", ")}` for `#{@output_field}`"
+  end
+
+  def get_invalid_keys(input)
+    missing_columns = @input_columns - input.keys
+    #reject input that is not blank or the value `false`
+    #this allows boolean inputs for required fields
+    missing_data = @required ? input.reject{|k,v| !v.blank? || v == false }.keys : []
+    missing_columns + missing_data
+  end
+
+end

data/lib/Topographer/importer/mapper/ignored_field_mapping.rb

@@ -0,0 +1,10 @@
+class Importer::Mapper::IgnoredFieldMapping < Importer::Mapper::FieldMapping
+  def initialize(input_columns)
+    @input_columns = input_columns
+    @output_field = nil
+  end
+
+  def required?
+    false
+  end
+end

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

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

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

@@ -0,0 +1,36 @@
+class Importer::Mapper::ValidationFieldMapping < 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 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)
+
+  end
+
+  def required?
+    true
+  end
+
+  private
+    def get_invalid_keys(input)
+      @input_columns - input.keys
+    end
+end

data/lib/Topographer/importer/strategy.rb

@@ -0,0 +1,7 @@
+module 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'
+end

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

@@ -0,0 +1,42 @@
+class Importer::Strategy::Base
+
+  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 = 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

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

@@ -0,0 +1,50 @@
+class Importer::Strategy::CreateOrUpdateRecord < Importer::Strategy::Base
+
+  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)
+
+    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)
+
+    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)
+
+    status
+  end
+
+
+  def success_message
+    @success_message
+  end
+
+  def failure_message
+    @failure_message
+  end
+
+  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
+
+end