topographer 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 0f240a307703861f83b040a054ad1f89ae397823
-  data.tar.gz: 3fab2dc9130cd3507b2f7fccb169ab1082847b38
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjI0NDZhMDEyMDhkNzA0NzA4MTczMjBjYzY3NWZkMzQxODBmYzBjNg==
+  data.tar.gz: !binary |-
+    OTI1MzZhMWU2NTZhOTllOTE2Nzg4ZjMyZTVmMmU5MDQzMWU3ZmI1Ng==
 SHA512:
-  metadata.gz: f5a4c37297d5ee4c31f125b39e371067b2b78bff094a4052a3e48c690a6969ade6cc752542652a7bcc37ca4eca76d115bc1eeab41cecec4b6e154bfc794c174e
-  data.tar.gz: 6f18ca76a190026fc57a216ede46e51d2354df44de0b8c6270c1b224e230b712a2151af4aec806b0b5c54a33d86b2fd26be6e2dd8fcb2186eaf56830e58764bb
+  metadata.gz: !binary |-
+    YzczMzllN2M3YTc3ZTc2M2E3YTY2NmJjMjU0YmNkODdhN2ViZDY5MGEzYjg3
+    MTU1YTVkZmIwYjUwM2UyNWNhMjAzMTdiMjc2ZmIwZTZiMWE5OWU1MGU1OTk5
+    ZDYyNWUyNTNjMjYzNzhkYzM4N2FiNjU4OWYyMWY0NzViNGMzNjM=
+  data.tar.gz: !binary |-
+    MjExOTg5NGM5OWYzZDhkYzM1NzBlM2RmMTY5N2JiNDRmNmJkNDUyZDhhOTll
+    YTcwMWYyYmVkMjg5M2RkZTkwN2IwMjg5OWQ5N2I4MzhiNTEwZDQ3ZWVmNTEw
+    ODViNDYxMjA4NDFhODIyMTI3OWY0YzAyYTFmY2I1YjE2YmVlZDI=

data/lib/Topographer/importer/helpers/write_log_to_csv.rb

@@ -1,6 +1,6 @@
 require 'singleton'
 require 'csv'
-class Importer::Helpers::WriteLogToCSV
+class Topographer::Importer::Helpers::WriteLogToCSV
   include Singleton
 
   def initialize

data/lib/Topographer/importer/helpers.rb

@@ -1,4 +1,4 @@
-module Importer::Helpers
+module Topographer::Importer::Helpers
   require_relative 'helpers/write_log_to_csv'
 
   def boolify(word)

data/lib/Topographer/importer/importable.rb

@@ -1,4 +1,4 @@
-module Importer::Importable
+module Topographer::Importer::Importable
   def get_mapper(strategy)
     raise NotImplementedError
   end

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

@@ -1,4 +1,4 @@
-class Importer::Input::Base
+class Topographer::Importer::Input::Base
   def get_header
     raise NotImplementedError
   end

data/lib/Topographer/importer/input/roo.rb

@@ -1,4 +1,4 @@
-class Importer::Input::Roo < Importer::Input::Base
+class Topographer::Importer::Input::Roo < Topographer::Importer::Input::Base
   include Enumerable
 
   def initialize(roo_sheet, header_row=1, data_row=2)
@@ -21,7 +21,7 @@ class Importer::Input::Roo < Importer::Input::Base
     @start_data_row.upto @end_data_row do |row_number|
       data = @sheet.row(row_number)
       source_identifier = "Row: #{row_number}"
-      yield Importer::Input::SourceData.new(source_identifier,
+      yield Topographer::Importer::Input::SourceData.new(source_identifier,
                                             Hash[@header.zip(data)])
     end
   end

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

@@ -1,4 +1,4 @@
-class Importer::Input::SourceData
+class Topographer::Importer::Input::SourceData
   attr_reader :source_identifier, :data
 
   def initialize(source_identifier, data)

data/lib/Topographer/importer/input.rb

@@ -1,4 +1,4 @@
-class Importer::Input
+class Topographer::Importer::Input
   require_relative 'input/source_data'
   require_relative 'input/base'
   require_relative 'input/roo'

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

@@ -1,4 +1,4 @@
-class Importer::Logger::Base
+class Topographer::Importer::Logger::Base
 
   attr_reader :fatal_errors
 
@@ -31,7 +31,7 @@ class Importer::Logger::Base
   end
 
   def log_fatal(source, message)
-    @fatal_errors << Importer::Logger::FatalErrorEntry.new(source, message)
+    @fatal_errors << Topographer::Importer::Logger::FatalErrorEntry.new(source, message)
   end
 
   def successful_imports

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

@@ -1,4 +1,4 @@
-class Importer::Logger::FatalErrorEntry < Importer::Logger::LogEntry
+class Topographer::Importer::Logger::FatalErrorEntry < Topographer::Importer::Logger::LogEntry
   attr_reader :message, :timestamp, :model_name
 
   def initialize(input_identifier, message)

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

@@ -1,4 +1,4 @@
-class Importer::Logger::LogEntry
+class Topographer::Importer::Logger::LogEntry
   attr_reader :input_identifier,
               :model_name
 

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

@@ -1,4 +1,4 @@
-class Importer::Logger::Simple < Importer::Logger::Base
+class Topographer::Importer::Logger::Simple < Topographer::Importer::Logger::Base
 
   attr_reader :successes, :failures
 

data/lib/Topographer/importer/logger.rb

@@ -1,4 +1,4 @@
-class Importer::Logger
+class Topographer::Importer::Logger
   require_relative 'logger/base'
   require_relative 'logger/simple'
   require_relative 'logger/file'

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

@@ -1,4 +1,4 @@
-class Importer::Mapper::DefaultFieldMapping < Importer::Mapper::FieldMapping
+class Topographer::Importer::Mapper::DefaultFieldMapping < Topographer::Importer::Mapper::FieldMapping
 
   def initialize(output_column, &output_block)
     unless block_given?

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

@@ -1,6 +1,6 @@
 require 'active_support/core_ext/hash'
 require 'active_support/core_ext/object/blank'
-class Importer::Mapper::FieldMapping
+class Topographer::Importer::Mapper::FieldMapping
   attr_reader :input_columns, :output_field
 
   def initialize(required, input_columns, output_field, &mapping_behavior)

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

@@ -1,4 +1,4 @@
-class Importer::Mapper::IgnoredFieldMapping < Importer::Mapper::FieldMapping
+class Topographer::Importer::Mapper::IgnoredFieldMapping < Topographer::Importer::Mapper::FieldMapping
   def initialize(input_columns)
     @input_columns = input_columns
     @output_field = nil

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

@@ -1,4 +1,4 @@
-class Importer::Mapper::Result
+class Topographer::Importer::Mapper::Result
   attr_reader :data, :errors, :source_identifier
 
   def initialize(source_identifier)

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

@@ -1,4 +1,4 @@
-class Importer::Mapper::ValidationFieldMapping < Importer::Mapper::FieldMapping
+class Topographer::Importer::Mapper::ValidationFieldMapping < Topographer::Importer::Mapper::FieldMapping
   attr_reader :name
 
   def initialize(name, input_columns, &validation_block)

data/lib/Topographer/importer/mapper.rb

@@ -1,4 +1,4 @@
-class Importer::Mapper
+class Topographer::Importer::Mapper
   require_relative 'mapper/field_mapping'
   require_relative 'mapper/ignored_field_mapping'
   require_relative 'mapper/validation_field_mapping'

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

@@ -1,4 +1,4 @@
-class Importer::Strategy::Base
+class Topographer::Importer::Strategy::Base
 
   attr_reader :mapper
   attr_accessor :dry_run
@@ -27,7 +27,7 @@ class Importer::Strategy::Base
   private
 
     def get_import_status(mapping_result, new_model_errors)
-      status = Importer::Strategy::ImportStatus.new(mapping_result.source_identifier)
+      status = Topographer::Importer::Strategy::ImportStatus.new(mapping_result.source_identifier)
       mapping_result.errors.values.each do |error|
         status.add_error(:mapping, error)
       end

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

@@ -1,4 +1,4 @@
-class Importer::Strategy::CreateOrUpdateRecord < Importer::Strategy::Base
+class Topographer::Importer::Strategy::CreateOrUpdateRecord < Topographer::Importer::Strategy::Base
 
   def import_record (source_data)
     mapping_result = mapper.map_input(source_data)

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

@@ -1,4 +1,4 @@
-class Importer::Strategy::ImportNewRecord < Importer::Strategy::Base
+class Topographer::Importer::Strategy::ImportNewRecord < Topographer::Importer::Strategy::Base
 
   def import_record (source_data)
     mapping_result = mapper.map_input(source_data)

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

@@ -1,4 +1,4 @@
-class Importer::Strategy::ImportStatus
+class Topographer::Importer::Strategy::ImportStatus
   attr_reader :errors, :input_identifier, :timestamp
   attr_accessor :message
 

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

@@ -1,4 +1,4 @@
-class Importer::Strategy::UpdateRecord < Importer::Strategy::Base
+class Topographer::Importer::Strategy::UpdateRecord < Topographer::Importer::Strategy::Base
 
   def import_record (source_data)
     mapping_result = mapper.map_input(source_data)

data/lib/Topographer/importer/strategy.rb

@@ -1,4 +1,4 @@
-module Importer::Strategy
+module Topographer::Importer::Strategy
   require_relative 'strategy/base'
   require_relative 'strategy/import_new_record'
   require_relative 'strategy/update_record'

data/lib/Topographer/importer.rb

@@ -1,4 +1,4 @@
-class Importer
+class Topographer::Importer
   require_relative 'importer/mapper'
   require_relative 'importer/strategy'
   require_relative 'importer/importable'

data/lib/Topographer/version.rb

@@ -1,3 +1,3 @@
 module Topographer
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/Cartographer/importer/helpers/write_log_to_csv_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
-describe Importer::Helpers::WriteLogToCSV do
+describe Topographer::Importer::Helpers::WriteLogToCSV do
   let(:successful_entry) do
-    status = Importer::Strategy::ImportStatus.new('test-input')
+    status = Topographer::Importer::Strategy::ImportStatus.new('test-input')
     status.set_timestamp
-    Importer::Logger::LogEntry.new('test-input', 'TestModel', status)
+    Topographer::Importer::Logger::LogEntry.new('test-input', 'TestModel', status)
   end
   let(:failed_entry) do
-    status = Importer::Strategy::ImportStatus.new('test-input')
+    status = Topographer::Importer::Strategy::ImportStatus.new('test-input')
     status.set_timestamp
     (1+rand(6)).times do |n|
       status.add_error(:mapping, "Test error #{n}")
     end
-    Importer::Logger::LogEntry.new('test-input', 'TestModel', status)
+    Topographer::Importer::Logger::LogEntry.new('test-input', 'TestModel', status)
   end
   let(:fatal_error) do
-    Importer::Logger::FatalErrorEntry.new('test-input', 'FATAL ERROR')
+    Topographer::Importer::Logger::FatalErrorEntry.new('test-input', 'FATAL ERROR')
   end
   let(:successes) do
     successes = []
@@ -57,13 +57,13 @@ describe Importer::Helpers::WriteLogToCSV do
       file = double('file')
       CSV.should_receive(:open).with('fake_file_path', 'wb').and_yield(file)
       file.should_receive(:<<).exactly(12).times
-      Importer::Helpers::WriteLogToCSV.instance.write_log_to_csv(logger, 'fake_file_path', write_all: true)
+      Topographer::Importer::Helpers::WriteLogToCSV.instance.write_log_to_csv(logger, 'fake_file_path', write_all: true)
     end
     it 'should only write failures and fatal errors if write_all is false' do
       file = double('file')
       CSV.should_receive(:open).with('fake_file_path', 'wb').and_yield(file)
       file.should_receive(:<<).exactly(10).times
-      Importer::Helpers::WriteLogToCSV.instance.write_log_to_csv(logger, 'fake_file_path', write_all: false)
+      Topographer::Importer::Helpers::WriteLogToCSV.instance.write_log_to_csv(logger, 'fake_file_path', write_all: false)
     end
   end
 end

data/spec/Cartographer/importer/helpers_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 class TestImportable
-  extend Importer::Helpers
+  extend Topographer::Importer::Helpers
 end
 
-describe Importer::Helpers do
+describe Topographer::Importer::Helpers do
   describe ".boolify" do
     it "returns true if given 'Yes'" do
       expect(TestImportable.boolify('Yes')).to eql true

data/spec/Cartographer/importer/importable_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
 class TestImportable
-  extend Importer::Importable
+  extend Topographer::Importer::Importable
 end
 
-describe Importer::Importable do
+describe Topographer::Importer::Importable do
   describe "#get_mapper" do
     it 'should raise NotImplementedError' do
       expect { TestImportable.get_mapper(nil) }.to raise_error(NotImplementedError)

data/spec/Cartographer/importer/importer_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'ostruct'
 
 class MockImportable < OpenStruct
-  include Importer::Importable
+  include Topographer::Importer::Importable
 
   def self.create(params)
     self.new(params)
@@ -21,7 +21,7 @@ class MockImportable < OpenStruct
   def self.get_mapper(strategy_class)
     case
     when  strategy_class == HashImportStrategy
-      Importer::Mapper.build_mapper(MockImportable) do |mapping|
+      Topographer::Importer::Mapper.build_mapper(MockImportable) do |mapping|
         mapping.required_mapping 'Field1', 'field_1'
         mapping.required_mapping 'Field2', 'field_2'
         mapping.optional_mapping 'Field3', 'field_3'
@@ -32,7 +32,7 @@ class MockImportable < OpenStruct
 
 end
 
-class HashImportStrategy < Importer::Strategy::Base
+class HashImportStrategy < Topographer::Importer::Strategy::Base
   attr_reader :imported_data
 
   def initialize(mapper)
@@ -71,14 +71,14 @@ class MockInput
   end
 
   def each
-    yield Importer::Input::SourceData.new('1', {'Field1' => 'datum1', 'Field2' => 'datum2'})
-    yield Importer::Input::SourceData.new('2', {'Field1' => 'datum2', 'Field2' => 'datum2', 'Field3' => 'datum3'})
-    yield Importer::Input::SourceData.new('3', {'Field1' => 'datum3', 'Field2' => 'invalid value!!!!1ONE'})  #I am INVALID!!!
-    yield Importer::Input::SourceData.new('4', {'Field1' => 'datum4', 'Field2' => 'datum2', 'Field3' => 'datum3', 'IgnoredField' => 'ignore me'})
+    yield Topographer::Importer::Input::SourceData.new('1', {'Field1' => 'datum1', 'Field2' => 'datum2'})
+    yield Topographer::Importer::Input::SourceData.new('2', {'Field1' => 'datum2', 'Field2' => 'datum2', 'Field3' => 'datum3'})
+    yield Topographer::Importer::Input::SourceData.new('3', {'Field1' => 'datum3', 'Field2' => 'invalid value!!!!1ONE'})  #I am INVALID!!!
+    yield Topographer::Importer::Input::SourceData.new('4', {'Field1' => 'datum4', 'Field2' => 'datum2', 'Field3' => 'datum3', 'IgnoredField' => 'ignore me'})
   end
 end
 
-describe Importer do
+describe Topographer::Importer do
   let(:input) { MockInput.new }
   let(:model_class) { MockImportable }
   let(:strategy_class) { HashImportStrategy }
@@ -87,8 +87,8 @@ describe Importer do
            get_header: ['BadCol1', 'BadCol2', 'Field1', 'Field3'],
            input_identifier: 'Test'
   end
-  let(:simple_logger) { Importer::Logger::Simple.new }
-  let(:import_log) { Importer.import_data(input, model_class, strategy_class, simple_logger) }
+  let(:simple_logger) { Topographer::Importer::Logger::Simple.new }
+  let(:import_log) { Topographer::Importer.import_data(input, model_class, strategy_class, simple_logger) }
 
   describe '.import_data' do
     it 'returns a logger instance' do
@@ -109,7 +109,7 @@ describe Importer do
     end
 
     it 'does not import data with an invalid header' do
-      import_log = Importer.import_data(bad_input, model_class, strategy_class, simple_logger)
+      import_log = Topographer::Importer.import_data(bad_input, model_class, strategy_class, simple_logger)
       expect(import_log.errors?).to be_true
       expect(import_log.fatal_error?).to be_true
       expect(import_log.fatal_errors.first.message).
@@ -118,7 +118,7 @@ describe Importer do
   end
   describe '.build_mapper' do
     it 'returns a mapper with the defined mappings' do
-      mapper = Importer.build_mapper(MockImportable) do |mapping|
+      mapper = Topographer::Importer.build_mapper(MockImportable) do |mapping|
           mapping.required_mapping 'Field1', 'field_1'
           mapping.required_mapping 'Field2', 'field_2'
           mapping.optional_mapping 'Field3', 'field_3'

data/spec/Cartographer/importer/logger/base_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Importer::Logger::Base do
-  let(:logger){Importer::Logger::Base.new}
+describe Topographer::Importer::Logger::Base do
+  let(:logger){Topographer::Importer::Logger::Base.new}
   describe '#log_fatal' do
     it 'should log a fatal error' do
       logger.log_fatal('test input', 'Fatal Error')
-      expect(logger.fatal_errors.first).to be_a Importer::Logger::LogEntry
+      expect(logger.fatal_errors.first).to be_a Topographer::Importer::Logger::LogEntry
       expect(logger.fatal_errors.first)
     end
   end

data/spec/Cartographer/importer/logger/fatal_error_entry_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Importer::Logger::FatalErrorEntry do
-  let(:entry) { Importer::Logger::FatalErrorEntry.new('test-input', 'failure message') }
+describe Topographer::Importer::Logger::FatalErrorEntry do
+  let(:entry) { Topographer::Importer::Logger::FatalErrorEntry.new('test-input', 'failure message') }
   describe '#failure?' do
     it 'should return true' do
       expect(entry.failure?).to be_true

data/spec/Cartographer/importer/logger/simple_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe Importer::Logger::Simple do
+describe Topographer::Importer::Logger::Simple do
 
   let(:logger) do
-    Importer::Logger::Simple.new
+    Topographer::Importer::Logger::Simple.new
   end
 
   describe '#log_success' do

data/spec/Cartographer/importer/mapper/default_field_mapping_spec.rb

@@ -1,22 +1,22 @@
 require 'spec_helper'
 
-describe Importer::Mapper::DefaultFieldMapping do
+describe Topographer::Importer::Mapper::DefaultFieldMapping do
   let(:static_mapping) do
-    Importer::Mapper::DefaultFieldMapping.new('field1') do
+    Topographer::Importer::Mapper::DefaultFieldMapping.new('field1') do
       10+5
     end
   end
   let(:failed_static_mapping) do
-    Importer::Mapper::DefaultFieldMapping.new('field1') do
+    Topographer::Importer::Mapper::DefaultFieldMapping.new('field1') do
       raise 'FAILURE'
     end
   end
 
-  let(:result) { Importer::Mapper::Result.new('test') }
-  let(:result2) { Importer::Mapper::Result.new('test') }
+  let(:result) { Topographer::Importer::Mapper::Result.new('test') }
+  let(:result2) { Topographer::Importer::Mapper::Result.new('test') }
   describe '#initialize' do
     it 'should not create a static mapping without a behavior block' do
-      expect { Importer::Mapper::DefaultFieldMapping.new('broken mapping') }.
+      expect { Topographer::Importer::Mapper::DefaultFieldMapping.new('broken mapping') }.
           to raise_error(Topographer::InvalidMappingError)
     end
   end
@@ -32,7 +32,7 @@ describe Importer::Mapper::DefaultFieldMapping do
       expect(result.errors.values).to include('FAILURE')
     end
     it 'should not rescue Exceptions that do not inherit from standard error' do
-      mapper = Importer::Mapper::DefaultFieldMapping.new('output_column') do
+      mapper = Topographer::Importer::Mapper::DefaultFieldMapping.new('output_column') do
         raise Exception, 'Field1 MUST BE 4'
       end
       expect{ mapper.process_input({'field1' => false}, result) }.to raise_error(Exception)

data/spec/Cartographer/importer/mapper/field_mapping_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
 
-describe Importer::Mapper::FieldMapping do
-  let(:required_simple_mapping) { Importer::Mapper::FieldMapping.new(true, ['field1'], 'output_column') }
+describe Topographer::Importer::Mapper::FieldMapping do
+  let(:required_simple_mapping) { Topographer::Importer::Mapper::FieldMapping.new(true, ['field1'], 'output_column') }
   let(:required_simple_mapping_with_validation) do
-    Importer::Mapper::FieldMapping.new(true, ['field1'], 'output_column') do |input|
+    Topographer::Importer::Mapper::FieldMapping.new(true, ['field1'], 'output_column') do |input|
       if input['field1'] != 4
         raise 'Field1 MUST BE 4'
       end
     end
   end
   let(:required_complex_mapping) do
-    Importer::Mapper::FieldMapping.new(true, ['field1', 'field2', 'field3'], 'output_column') do |input|
+    Topographer::Importer::Mapper::FieldMapping.new(true, ['field1', 'field2', 'field3'], 'output_column') do |input|
       if input['field1'] != 4
         raise 'Field1 MUST BE 4'
       end
       input.values.flatten.inject(0) {|sum, x| sum+x}
     end
   end
-  let(:optional_simple_mapping) { Importer::Mapper::FieldMapping.new(false, 'field1', 'output_column') }
+  let(:optional_simple_mapping) { Topographer::Importer::Mapper::FieldMapping.new(false, 'field1', 'output_column') }
   let(:optional_complex_mapping) do
-    Importer::Mapper::FieldMapping.new(false, ['field1', 'field2', 'field3'], 'output_column') do |input|
+    Topographer::Importer::Mapper::FieldMapping.new(false, ['field1', 'field2', 'field3'], 'output_column') do |input|
       if input['field1'] != 4
         raise 'Field1 MUST BE 4'
       end
@@ -32,7 +32,7 @@ describe Importer::Mapper::FieldMapping do
   let(:invalid_complex_input) do
     {'field1' => 3, 'field2' => 4, 'field3' => 5}
   end
-  let(:result) { Importer::Mapper::Result.new('test') }
+  let(:result) { Topographer::Importer::Mapper::Result.new('test') }
   describe '#process_input' do
     context 'required mappings' do
       it 'maps required simple mappings when input is valid' do
@@ -116,7 +116,7 @@ describe Importer::Mapper::FieldMapping do
       expect(result.data['output_column']).to eql(false)
     end
     it 'should not rescue Exceptions that do not inherit from standard error' do
-      mapper = Importer::Mapper::FieldMapping.new(true, 'field1', 'output_column') do |input|
+      mapper = Topographer::Importer::Mapper::FieldMapping.new(true, 'field1', 'output_column') do |input|
         raise Exception, 'Field1 MUST BE 4'
       end
       expect{ mapper.process_input({'field1' => false}, result) }.to raise_error(Exception)

data/spec/Cartographer/importer/mapper/validation_field_mapping_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Importer::Mapper::ValidationFieldMapping do
+describe Topographer::Importer::Mapper::ValidationFieldMapping do
   let(:validation_mapping) do
-    Importer::Mapper::ValidationFieldMapping.new('test mapping', ['field1', 'field2', 'field3']) do |input|
+    Topographer::Importer::Mapper::ValidationFieldMapping.new('test mapping', ['field1', 'field2', 'field3']) do |input|
       sum = input.values.flatten.inject(0) {|sum, x| sum+x}
       raise 'Sum must be 15' if sum != 15
     end
@@ -13,10 +13,10 @@ describe Importer::Mapper::ValidationFieldMapping do
   let(:invalid_input) do
     {'field1' => 3, 'field2' => 4, 'field3' => 5}
   end
-  let(:result) { Importer::Mapper::Result.new('test') }
+  let(:result) { Topographer::Importer::Mapper::Result.new('test') }
   describe '#initialize' do
     it 'should not create a validation mapping without a behavior block' do
-      expect { Importer::Mapper::ValidationFieldMapping.new('test mapping', ['field1', 'field2', 'field3']) }.
+      expect { Topographer::Importer::Mapper::ValidationFieldMapping.new('test mapping', ['field1', 'field2', 'field3']) }.
         to raise_error(Topographer::InvalidMappingError)
     end
   end
@@ -32,7 +32,7 @@ describe Importer::Mapper::ValidationFieldMapping do
       expect(result.errors.values).to include('Sum must be 15')
     end
     it 'should not rescue Exceptions that do not inherit from standard error' do
-      mapper = Importer::Mapper::ValidationFieldMapping.new('test mapping', ['field1', 'field2', 'field3']) do |input|
+      mapper = Topographer::Importer::Mapper::ValidationFieldMapping.new('test mapping', ['field1', 'field2', 'field3']) do |input|
         sum = input.values.flatten.inject(0) {|sum, x| sum+x}
         raise Exception, 'Sum must be 15' if sum != 15
       end

data/spec/Cartographer/importer/mapper_spec.rb

@@ -1,24 +1,24 @@
 require 'spec_helper'
 
-describe Importer::Mapper do
+describe Topographer::Importer::Mapper do
   describe '.build_mapper' do
     describe 'required mappings' do
       it 'can require a one to one field mapping' do
-        mapper = Importer::Mapper.build_mapper(Object) do |m|
+        mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.required_mapping 'Field1', 'field_1'
         end
         mapper.required_columns.should include("Field1")
         mapper.output_fields.should include('field_1')
       end
       it 'can require a many to one field mapping' do
-        mapper = Importer::Mapper.build_mapper(Object) do |m|
+        mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.required_mapping ['Field1', 'Field2'], 'field_1'
         end
         mapper.required_columns.should include("Field1", "Field2")
         mapper.output_fields.should include('field_1')
       end
       it 'cannot require a one to many field mapping' do
-        expect { mapper = Importer::Mapper.build_mapper(Object) do |m|
+        expect { mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.required_mapping 'Field1', ['field_1', 'field_2']
         end
         }.to raise_error(Topographer::InvalidMappingError)
@@ -26,21 +26,21 @@ describe Importer::Mapper do
     end
     describe 'optional mappings' do
       it 'can create an optional one to one field mapping' do
-        mapper = Importer::Mapper.build_mapper(Object) do |m|
+        mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.optional_mapping 'Field1', 'field_1'
         end
         mapper.optional_columns.should include("Field1")
         mapper.output_fields.should include('field_1')
       end
       it 'can create an optional many to one field mapping' do
-        mapper = Importer::Mapper.build_mapper(Object) do |m|
+        mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.optional_mapping ['Field1', 'Field2'], 'field_1'
         end
         mapper.optional_columns.should include("Field1", "Field2")
         mapper.output_fields.should include('field_1')
       end
       it 'cannot create an optional one to many field mapping' do
-        expect { mapper = Importer::Mapper.build_mapper(Object) do |m|
+        expect { mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.optional_mapping 'Field1', ['field_1', 'field_2']
         end
         }.to raise_error(Topographer::InvalidMappingError)
@@ -48,7 +48,7 @@ describe Importer::Mapper do
     end
     describe 'ignored mappings' do
       it 'can ignore a column' do
-        mapper = Importer::Mapper.build_mapper(Object) do |m|
+        mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.ignored_column 'Field1'
         end
         mapper.ignored_columns.should include('Field1')
@@ -56,21 +56,21 @@ describe Importer::Mapper do
       end
 
       it 'raises an error when adding a mapping whose output is already an output of another mapping' do
-        expect { Importer::Mapper.build_mapper(Object) do |m|
+        expect { Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.optional_mapping 'Field1', 'field_1'
           m.required_mapping 'Field2', 'field_1'
         end }.to raise_error(Topographer::InvalidMappingError)
       end
 
       it 'raises an error when adding a ignored column, which is already an input of another mapping' do
-        expect { Importer::Mapper.build_mapper(Object) do |m|
+        expect { Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.optional_mapping 'Field1', 'field_1'
           m.ignored_column 'Field1'
         end }.to raise_error(Topographer::InvalidMappingError)
       end
 
       it 'raises an error when adding a mapped column which has already been ignored' do
-        expect { Importer::Mapper.build_mapper(Object) do |m|
+        expect { Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.ignored_column 'Field1'
           m.optional_mapping 'Field1', 'field_1'
         end }.to raise_error(Topographer::InvalidMappingError)
@@ -79,7 +79,7 @@ describe Importer::Mapper do
 
     describe 'validation mappings' do
       it 'can create a single column validation' do
-        mapper = Importer::Mapper.build_mapper(Object) do |m|
+        mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.validation_field 'Field 1 Validation', 'Field1' do |input|
             raise 'No Input' unless input
           end
@@ -88,7 +88,7 @@ describe Importer::Mapper do
         expect(mapper.output_fields.empty?).to be_true
       end
       it 'can create a multicolumn validation' do
-        mapper = Importer::Mapper.build_mapper(Object) do |m|
+        mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.validation_field 'Multicolumn Validation', ['Field1', 'Field2'] do |input|
             raise 'No Input' unless input
           end
@@ -98,7 +98,7 @@ describe Importer::Mapper do
       end
       it 'raises an error if a validation name is repeated' do
         expect {
-          mapper = Importer::Mapper.build_mapper(Object) do |m|
+          mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
             m.validation_field 'Field 1 Validation', 'Field1' do |input|
               raise 'No Input' unless input
             end
@@ -110,7 +110,7 @@ describe Importer::Mapper do
 
     describe 'static mappings' do
       it 'can create a static mapping' do
-        mapper = Importer::Mapper.build_mapper(Object) do |m|
+        mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.default_value 'Field1' do
             34
           end
@@ -119,14 +119,14 @@ describe Importer::Mapper do
         expect(mapper.output_fields).to eql(['Field1'])
       end
       it 'cannot create a static mapping to many columns' do
-        expect { mapper = Importer::Mapper.build_mapper(Object) do |m|
+        expect { mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.default_value ['Field1', 'Field2'] do
             34
           end
         end }.to raise_error(Topographer::InvalidMappingError)
       end
       it 'cannot add a static mapping to a field that has already been mapped' do
-        expect { mapper = Importer::Mapper.build_mapper(Object) do |m|
+        expect { mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
           m.required_mapping 'Field1', 'field1'
           m.default_value 'field1' do
             34
@@ -136,7 +136,7 @@ describe Importer::Mapper do
     end
 
     it 'associates the model class with the mapper instance' do
-      mapper = Importer::Mapper.build_mapper(Object) do |m|
+      mapper = Topographer::Importer::Mapper.build_mapper(Object) do |m|
         m.ignored_column 'Field1'
         m.optional_mapping 'Field2', 'field_1'
       end
@@ -145,7 +145,7 @@ describe Importer::Mapper do
   end
 
   describe '#key_field' do
-    let(:mapper) { Importer::Mapper.new(Object) }
+    let(:mapper) { Topographer::Importer::Mapper.new(Object) }
     it 'should add a key field to the list of key fields' do
       mapper.key_field 'Field1'
       expect(mapper.key_fields).to eql(['Field1'])
@@ -165,7 +165,7 @@ describe Importer::Mapper do
 
   describe '#input_structure_valid?' do
     let(:mapper) do
-      Importer::Mapper.build_mapper(Object) do |m|
+      Topographer::Importer::Mapper.build_mapper(Object) do |m|
         m.required_mapping 'Field1', 'field1'
         m.required_mapping 'Field2', 'field_4'
         m.optional_mapping 'Field3', 'field_6'
@@ -203,7 +203,7 @@ describe Importer::Mapper do
 
   describe '#bad_columns' do
     let(:mapper) do
-      Importer::Mapper.build_mapper(Object) do |m|
+      Topographer::Importer::Mapper.build_mapper(Object) do |m|
         m.required_mapping 'Field1', 'field1'
         m.required_mapping 'Field2', 'field_4'
         m.validation_field('test validation 2', 'Field2') { |input| raise 'FAILURE' if !input }
@@ -222,7 +222,7 @@ describe Importer::Mapper do
 
   describe '#missing_columns' do
     let(:mapper) do
-      Importer::Mapper.build_mapper(Object) do |m|
+      Topographer::Importer::Mapper.build_mapper(Object) do |m|
         m.required_mapping 'Field1', 'field1'
         m.required_mapping 'Field2', 'field_4'
         m.optional_mapping 'Field3', 'field_6'
@@ -240,7 +240,7 @@ describe Importer::Mapper do
 
   describe '#map_input' do
     let(:mapper) do
-      Importer::Mapper.build_mapper(Object) do |m|
+      Topographer::Importer::Mapper.build_mapper(Object) do |m|
         m.required_mapping 'Field1', 'field_1'
         m.required_mapping ['Field1', 'Field2'], 'field_2'
         m.validation_field('Field2 Validation', 'Field2') { |input| raise 'FAILURE' if input['Field2'] != 'datum2'}

data/spec/Cartographer/importer/strategy/base_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Importer::Strategy::Base do
+describe Topographer::Importer::Strategy::Base do
   let(:mapper) do
     double('Mapper')
   end
-  let(:strategy) { Importer::Strategy::Base.new(mapper) }
+  let(:strategy) { Topographer::Importer::Strategy::Base.new(mapper) }
   let(:status) do
     double 'Status',
            errors?: false
@@ -15,7 +15,7 @@ describe Importer::Strategy::Base do
   end
   describe '#initialize' do
     it 'creates a new Strategy instance with the given mapper' do
-      strategy = Importer::Strategy::Base.new(mapper)
+      strategy = Topographer::Importer::Strategy::Base.new(mapper)
       strategy.instance_variable_get(:@mapper).should be(mapper)
     end
   end

data/spec/Cartographer/importer/strategy/create_or_update_record_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 require 'ostruct'
 require_relative 'mapped_model'
 
-describe Importer::Strategy::CreateOrUpdateRecord do
+describe Topographer::Importer::Strategy::CreateOrUpdateRecord do
 
-  let(:strategy) { Importer::Strategy::CreateOrUpdateRecord.new(MappedModel.get_mapper) }
+  let(:strategy) { Topographer::Importer::Strategy::CreateOrUpdateRecord.new(MappedModel.get_mapper) }
   let(:input) do
     double 'Data',
            source_identifier: 'record',
@@ -20,7 +20,7 @@ describe Importer::Strategy::CreateOrUpdateRecord do
 
   describe '#import_record' do
     it 'should return an ImportStatus object' do
-      expect(strategy.import_record(input)).to be_a Importer::Strategy::ImportStatus
+      expect(strategy.import_record(input)).to be_a Topographer::Importer::Strategy::ImportStatus
     end
     it 'should import a record from valid input' do
       MappedModel.any_instance.should_receive(:save).once

data/spec/Cartographer/importer/strategy/import_new_records_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'ostruct'
 require_relative 'mapped_model'
 
-describe Importer::Strategy::ImportNewRecord do
+describe Topographer::Importer::Strategy::ImportNewRecord do
   let(:valid_status) do
     double 'Result',
            source_identifier: 'row1',
@@ -22,7 +22,7 @@ describe Importer::Strategy::ImportNewRecord do
     double('Mapper', map_input: valid_status, model_class: MappedModel)
   end
 
-  let(:strategy) { Importer::Strategy::ImportNewRecord.new(MappedModel.get_mapper) }
+  let(:strategy) { Topographer::Importer::Strategy::ImportNewRecord.new(MappedModel.get_mapper) }
   let(:input) do
     double 'Data',
            source_identifier: 'record',
@@ -32,14 +32,14 @@ describe Importer::Strategy::ImportNewRecord do
 
   describe '#initialize' do
     it 'creates a new Strategy instance with the given mapper' do
-      strategy = Importer::Strategy::ImportNewRecord.new(mapper)
+      strategy = Topographer::Importer::Strategy::ImportNewRecord.new(mapper)
       strategy.instance_variable_get(:@mapper).should be(mapper)
     end
   end
 
   describe '#import_record' do
     it 'should return an ImportStatus object' do
-      expect(strategy.import_record(input)).to be_a Importer::Strategy::ImportStatus
+      expect(strategy.import_record(input)).to be_a Topographer::Importer::Strategy::ImportStatus
     end
     it 'should import a record from valid input' do
       MappedModel.any_instance.should_receive(:save).once
@@ -48,7 +48,7 @@ describe Importer::Strategy::ImportNewRecord do
     end
     it 'should not import a record from invalid input' do
       mapper.stub(:map_input).and_return(invalid_result)
-      strategy = Importer::Strategy::ImportNewRecord.new(mapper)
+      strategy = Topographer::Importer::Strategy::ImportNewRecord.new(mapper)
       MappedModel.any_instance.should_not_receive(:save)
       import_status = strategy.import_record(input)
       expect(import_status.errors?).to be true

data/spec/Cartographer/importer/strategy/import_status_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Importer::Strategy::ImportStatus do
-  let(:status) {Importer::Strategy::ImportStatus.new('row1')}
+describe Topographer::Importer::Strategy::ImportStatus do
+  let(:status) {Topographer::Importer::Strategy::ImportStatus.new('row1')}
   describe '#add_error' do
     it 'should add errors' do
       status.add_error(:validation, 'ERROR')

data/spec/Cartographer/importer/strategy/mapped_model.rb

@@ -22,7 +22,7 @@ class MappedModel < OpenStruct
   end
 
   def self.get_mapper
-    Importer::Mapper.build_mapper(MappedModel) do |mapping|
+    Topographer::Importer::Mapper.build_mapper(MappedModel) do |mapping|
       mapping.required_mapping 'Field1', 'field_1'
       mapping.required_mapping 'Field2', 'field_2'
       mapping.optional_mapping 'Field3', 'field_3'

data/spec/Cartographer/importer/strategy/update_record_spec.rb

@@ -2,9 +2,9 @@ require 'spec_helper'
 require 'ostruct'
 require_relative 'mapped_model'
 
-describe Importer::Strategy::UpdateRecord do
+describe Topographer::Importer::Strategy::UpdateRecord do
 
-  let(:strategy) { Importer::Strategy::UpdateRecord.new(MappedModel.get_mapper) }
+  let(:strategy) { Topographer::Importer::Strategy::UpdateRecord.new(MappedModel.get_mapper) }
   let(:input) do
     double 'Data',
            source_identifier: 'record',
@@ -19,7 +19,7 @@ describe Importer::Strategy::UpdateRecord do
 
   describe '#import_record' do
     it 'should return an ImportStatus object' do
-      expect(strategy.import_record(input)).to be_a Importer::Strategy::ImportStatus
+      expect(strategy.import_record(input)).to be_a Topographer::Importer::Strategy::ImportStatus
     end
     it 'should import a record from valid input' do
       MappedModel.any_instance.should_receive(:save).once

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: topographer
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Mike Simpson
@@ -15,14 +15,14 @@ dependencies:
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
@@ -43,28 +43,28 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: Topographer enables importing of models from various input sources.
@@ -139,17 +139,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.11
+rubygems_version: 2.1.10
 signing_key: 
 specification_version: 4
 summary: Topographer allows the mapping of columnar input data to fields for active
@@ -173,3 +173,4 @@ test_files:
 - spec/Cartographer/importer/strategy/mapped_model.rb
 - spec/Cartographer/importer/strategy/update_record_spec.rb
 - spec/spec_helper.rb
+has_rdoc: