topographer 0.0.7 → 0.0.8

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

@@ -1,22 +1,28 @@
-class Topographer::Importer::Mapper::DefaultFieldMapping < Topographer::Importer::Mapper::FieldMapping
+module Topographer
+  class Importer
+    class Mapper
+      class DefaultFieldMapping < Topographer::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 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 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
+        def required?
+          true
+        end
 
+      end
+    end
+  end
 end

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

@@ -1,55 +1,62 @@
 require 'active_support/core_ext/hash'
 require 'active_support/core_ext/object/blank'
-class Topographer::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
+module Topographer
+  class Importer
+    class Mapper
+      class 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
     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

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

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

@@ -1,46 +1,59 @@
-class Topographer::Importer::Mapper::MapperBuilder
-  include Topographer::Importer::Mapper::MappingColumns
-  include Topographer::Importer::Mapper::MappingValidator
-
-  attr_reader :required_mappings, :optional_mappings, :ignored_mappings,
-              :validation_mappings, :default_values, :key_fields
-
-  def initialize
-    @required_mappings = {}
-    @optional_mappings = {}
-    @ignored_mappings = {}
-    @validation_mappings = {}
-    @default_values = {}
-    @key_fields = []
-  end
-
-  def required_mapping(input_columns, output_field, &mapping_behavior)
-    validate_unique_mapping(input_columns, output_field)
-    @required_mappings[output_field] = Topographer::Importer::Mapper::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] = Topographer::Importer::Mapper::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] = Topographer::Importer::Mapper::ValidationFieldMapping.new(name, input_columns, &mapping_behavior)
-  end
-
-  def default_value(output_field, &mapping_behavior)
-    validate_unique_mapping([], output_field)
-    @default_values[output_field] = Topographer::Importer::Mapper::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] = Topographer::Importer::Mapper::IgnoredFieldMapping.new(input_column)
+module Topographer
+  class Importer
+    class Mapper
+      class MapperBuilder
+        include Topographer::Importer::Mapper::MappingColumns
+        include Topographer::Importer::Mapper::MappingValidator
+
+        attr_reader :required_mappings, :optional_mappings, :ignored_mappings,
+          :validation_mappings, :default_values, :key_fields, :field_mappings
+
+        def initialize
+          @required_mappings = {}
+          @optional_mappings = {}
+          @ignored_mappings = {}
+          @validation_mappings = {}
+          @default_values = {}
+          @key_fields = []
+          @field_mappings = {}
+        end
+
+        def required_mapping(input_columns, output_field, &mapping_behavior)
+          validate_unique_mapping(input_columns, output_field)
+          mapping = Topographer::Importer::Mapper::FieldMapping.new(true, input_columns, output_field, &mapping_behavior)
+          @required_mappings[output_field] = mapping
+          @field_mappings[output_field] = mapping
+        end
+
+        def optional_mapping(input_columns, output_field, &mapping_behavior)
+          validate_unique_mapping(input_columns, output_field)
+          mapping = Topographer::Importer::Mapper::FieldMapping.new(false, input_columns, output_field, &mapping_behavior)
+          @optional_mappings[output_field] = mapping
+          @field_mappings[output_field] = mapping
+        end
+
+        def validation_field(name, input_columns, &mapping_behavior)
+          validate_unique_validation_name(name)
+          @validation_mappings[name] = Topographer::Importer::Mapper::ValidationFieldMapping.new(name, input_columns, &mapping_behavior)
+        end
+
+        def default_value(output_field, &mapping_behavior)
+          validate_unique_mapping([], output_field)
+          mapping = Topographer::Importer::Mapper::DefaultFieldMapping.new(output_field, &mapping_behavior)
+          @default_values[output_field] = mapping
+          @field_mappings[output_field] = mapping
+        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] = Topographer::Importer::Mapper::IgnoredFieldMapping.new(input_column)
+        end
+      end
+    end
   end
 end

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

@@ -1,46 +1,53 @@
-module Topographer::Importer::Mapper::MappingColumns
-  def output_fields
-    (required_mappings.merge(optional_mappings).merge(default_values)).values.map(&:output_field)
-  end
-
-  def required_input_columns
-    (required_mapping_columns + validation_mapping_columns).uniq
-  end
-
-  def input_columns
-    (required_mapping_columns + optional_mapping_columns + validation_mapping_columns).uniq
-  end
-
-  def default_fields
-    default_values.keys
-  end
-
-  def validation_mapping_columns
-    validation_mappings.values.flat_map(&:input_columns)
-  end
-
-  def ignored_mapping_columns
-    ignored_mappings.values.flat_map(&:input_columns)
-  end
-
-  def optional_mapping_columns
-    optional_mappings.values.flat_map(&:input_columns)
-  end
-
-  def required_mapping_columns
-    required_mappings.values.flat_map(&:input_columns)
-  end
-
-  private
-    def mapped_input_columns
-      required_mapping_columns + optional_mapping_columns + ignored_mapping_columns + validation_mapping_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)
+module Topographer
+  class Importer
+    class Mapper
+      module MappingColumns
+        def output_fields
+          (required_mappings.merge(optional_mappings).merge(default_values)).values.map(&:output_field)
+        end
+
+        def required_input_columns
+          (required_mapping_columns + validation_mapping_columns).uniq
+        end
+
+        def input_columns
+          (required_mapping_columns + optional_mapping_columns + validation_mapping_columns).uniq
+        end
+
+        def default_fields
+          default_values.keys
+        end
+
+        def validation_mapping_columns
+          validation_mappings.values.flat_map(&:input_columns)
+        end
+
+        def ignored_mapping_columns
+          ignored_mappings.values.flat_map(&:input_columns)
+        end
+
+        def optional_mapping_columns
+          optional_mappings.values.flat_map(&:input_columns)
+        end
+
+        def required_mapping_columns
+          required_mappings.values.flat_map(&:input_columns)
+        end
+
+        private
+        def mapped_input_columns
+          required_mapping_columns + optional_mapping_columns + ignored_mapping_columns + validation_mapping_columns
+        end
+
+        def mappings
+          @field_mappings
+        end
+
+        def non_ignored_columns
+          required_mappings.merge(optional_mappings)
+        end
+      end
     end
+  end
 end
+

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

@@ -1,40 +1,47 @@
-module Topographer::Importer::Mapper::MappingValidator
+module Topographer
+  class Importer
+    class Mapper
+      module MappingValidator
 
-  def validate_unique_validation_name(name)
-    raise Topographer::InvalidMappingError, "A validation already exists with the name `#{name}`" if validation_mappings.has_key?(name)
-  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
 
-  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_output_mapping(output_field)
+          if output_fields.include?(output_field)
+            raise Topographer::InvalidMappingError, 'Output column already mapped.'
+          end
+        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_mapping_columns).include?(col))
-        raise Topographer::InvalidMappingError, 'Input column already mapped to an output column.'
-      elsif (ignored_mapping_columns.include?(col))
-        raise Topographer::InvalidMappingError, 'Input column already ignored.'
-      end
-    end
-  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_mapping_columns).include?(col))
+              raise Topographer::InvalidMappingError, 'Input column already mapped to an output column.'
+            elsif (ignored_mapping_columns.include?(col))
+              raise Topographer::InvalidMappingError, 'Input column already ignored.'
+            end
+          end
+        end
 
-  def validate_unique_mapping(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(mapping_input_columns)
-    validate_unique_output_mapping(output_field)
-  end
+        def validate_unique_mapping(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(mapping_input_columns)
+          validate_unique_output_mapping(output_field)
+        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"
+        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
+      end
     end
   end
 end
+