topographer 0.0.7 → 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f03c6ff70ebbd6f7dcb8c6b4d72deb2de304aee0
+  data.tar.gz: 22c2fd768c6c4d17586b46f0755d4ee56590fe6c
+SHA512:
+  metadata.gz: 0c51ad3208acba7412522563cb4d1693c4de97fe30f9e392ca07bddbc3832a050bbb2dd96a8c48313e5025beda6ad50c132c4f310053050d17985c010f884e6b
+  data.tar.gz: a307fa166260f5dc6e8e44b6099fe5842b4e477bb941922ed0f44f92b8e4fca2c619e2c3d24d861655bca0477fe99ae2fbc372381d85a3b8f13172c9fac062b6

data/lib/topographer/exceptions.rb

@@ -1,4 +1,6 @@
-class Topographer::InvalidMappingError < StandardError; end
-class Topographer::InvalidStructureError < Topographer::InvalidMappingError; end
-class Topographer::MappingFailure < Topographer::InvalidMappingError; end
+module Topographer
+  class InvalidMappingError < StandardError; end
+  class InvalidStructureError < Topographer::InvalidMappingError; end
+  class MappingFailure < Topographer::InvalidMappingError; end
+end
 

data/lib/topographer/importer.rb

@@ -17,17 +17,21 @@ class Topographer::Importer
     importer.logger
   end
 
-  def initialize(input, import_class, strategy_class, logger, options = {})
+  # @param mapping_generator  [#get_mapper] the object responsible for deciding which mapping to use for the strategy
+  # @param strategy either a Class that inherits from Topographer::Importer::Strategy::Base or an instance of a strategy
+  def initialize(input, mapping_generator, strategy, logger, options = {})
     @logger = logger
     @fatal_errors = []
 
     dry_run = options.fetch(:dry_run, false)
     ignore_unmapped_columns = options.fetch(:ignore_unmapped_columns, false)
 
-    mapper = import_class.get_mapper(strategy_class)
+    strategy_class = strategy.is_a?(Class) ? strategy : strategy.class
+
+    mapper = mapping_generator.get_mapper(strategy_class)
 
     if importable?(input, mapper, ignore_unmapped_columns)
-      strategy = strategy_class.new(mapper)
+      strategy = setup_strategy(mapper, strategy, strategy_class)
       strategy.dry_run = dry_run
       import_data(strategy, input, mapper.model_class.name)
     else
@@ -35,6 +39,14 @@ class Topographer::Importer
     end
   end
 
+  def setup_strategy(mapper, strategy, strategy_class)
+    if strategy == strategy_class
+      strategy_class.new(mapper) # supports legacy code
+    else
+      strategy.mapper = mapper
+      strategy
+    end
+  end
 
   def import_data(strategy, input, import_class)
     input.each do |data|
@@ -52,11 +64,15 @@ class Topographer::Importer
     end
   end
 
-  def invalid_header_message(mapper)
-    'Invalid Input Header - Missing Columns: ' +
-      mapper.missing_columns.join(', ') +
-      ' Invalid Columns: ' +
-      mapper.bad_columns.join(', ')
+  def invalid_header_message(mapper, ignore_unmapped_columns = false)
+    error = 'Invalid Input Header -'
+    if mapper.missing_columns.any?
+      error << " Missing Columns: #{mapper.missing_columns.join(', ')}"
+    end
+    if mapper.bad_columns.any? && !ignore_unmapped_columns
+      error << " Invalid Columns: #{mapper.bad_columns.join(', ')}"
+    end
+    error
   end
 
   def importable?(input, mapper, ignore_unmapped_columns)
@@ -72,7 +88,7 @@ class Topographer::Importer
   def valid_header?(input, mapper, ignore_unmapped_columns)
     valid = mapper.input_structure_valid?(input.get_header, ignore_unmapped_columns: ignore_unmapped_columns)
 
-    fatal_errors << invalid_header_message(mapper) unless valid
+    fatal_errors << invalid_header_message(mapper, ignore_unmapped_columns) unless valid
 
     valid
   end

data/lib/topographer/importer/helpers.rb

@@ -1,18 +1,24 @@
-module Topographer::Importer::Helpers
-  require_relative 'helpers/write_log_to_csv'
+require_relative 'helpers/write_log_to_csv'
 
-  def boolify(word)
-    return nil if word.nil?
+module Topographer
+  class Importer
+    module Helpers
 
-    case word.downcase
-    when 'yes'
-      true
-    when 'no'
-      false
-    when 'true'
-      true
-    when 'false'
-      false
+      def boolify(word)
+        return nil if word.nil?
+
+        case word.downcase
+          when 'yes'
+            true
+          when 'no'
+            false
+          when 'true'
+            true
+          when 'false'
+            false
+        end
+      end
     end
   end
 end
+

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

@@ -1,85 +1,93 @@
 require 'singleton'
 require 'csv'
-class Topographer::Importer::Helpers::WriteLogToCSV
-  include Singleton
 
-  def initialize
+module Topographer
+  class Importer
+    module Helpers
+      class WriteLogToCSV
+        include Singleton
 
-  end
+        def initialize
+
+        end
 
-  def write_log_to_csv(log, output_file_path, options = {})
-    @log = log
-    @write_all = options.fetch(:write_all, true)
-    CSV.open(output_file_path, 'wb') do |csv_file|
-      csv_file << get_detail_header
-      csv_file << get_details
-      csv_file << get_log_header if @log.entries?
-      @log.all_entries.each do |entry|
-        if entry.failure? || @write_all
+        def write_log_to_csv(log, output_file_path, options = {})
+          @log = log
+          @write_all = options.fetch(:write_all, true)
+          CSV.open(output_file_path, 'wb') do |csv_file|
+            csv_file << get_detail_header
+            csv_file << get_details
+            csv_file << get_log_header if @log.entries?
+            @log.all_entries.each do |entry|
+              if entry.failure? || @write_all
 
-          csv_file << format_log_entry(entry)
+                csv_file << format_log_entry(entry)
+              end
+            end
+          end
         end
-      end
-    end
-  end
 
-  private
+        private
 
-    def get_detail_header
-      if @write_all
-        ['Fatal Errors', 'Total Imports', 'Successful Imports', 'Failed Imports']
-      else
-        ['Fatal Errors', 'Failed Imports']
-      end
-    end
+        def get_detail_header
+          if @write_all
+            ['Fatal Errors', 'Total Imports', 'Successful Imports', 'Failed Imports']
+          else
+            ['Fatal Errors', 'Failed Imports']
+          end
+        end
 
-    def get_details
-      details = []
-      details << ((@log.fatal_error?) ? @log.fatal_errors.size : 'None')
-      if @write_all
-        details << @log.total_imports
-        details << @log.successful_imports
-      end
-      details << @log.failed_imports
-    end
+        def get_details
+          details = []
+          details << ((@log.fatal_error?) ? @log.fatal_errors.size : 'None')
+          if @write_all
+            details << @log.total_imports
+            details << @log.successful_imports
+          end
+          details << @log.failed_imports
+        end
 
-    def get_log_header
-      header = []
-      header << 'Input Identifier'
-      header << 'Source Identifier'
-      header << 'Model Class'
-      header << 'Timestamp'
-      header << 'Status'
-      header << 'Message'
-      header << 'Details'
-    end
+        def get_log_header
+          header = []
+          header << 'Input Identifier'
+          header << 'Source Identifier'
+          header << 'Model Class'
+          header << 'Timestamp'
+          header << 'Status'
+          header << 'Message'
+          header << 'Details'
+        end
 
-    def format_log_entry(log_entry)
-      entry = []
-      entry << log_entry.input_identifier
-      entry << log_entry.source_identifier
-      entry << log_entry.model_name
-      entry << log_entry.timestamp.strftime('%F - %T:%L')
-      entry << ((log_entry.success?) ? 'Success' : 'Failure')
-      entry << log_entry.message
-      entry << format_log_entry_details(log_entry.details)
-    end
+        def format_log_entry(log_entry)
+          entry = []
+          entry << log_entry.input_identifier
+          entry << log_entry.source_identifier
+          entry << log_entry.model_name
+          entry << log_entry.timestamp.strftime('%F - %T:%L')
+          entry << ((log_entry.success?) ? 'Success' : 'Failure')
+          entry << log_entry.message
+          entry << format_log_entry_details(log_entry.details)
+        end
 
-    def format_log_entry_details(details)
-      if details
-        formatted_details = []
-        details.keys.each do |key|
-          detail_string = ''
-          detail_messages = Array(details[key])
-          if detail_messages.any?
-            detail_string << key.to_s.capitalize << ': '
-            detail_string << detail_messages.join(', ')
+        def format_log_entry_details(details)
+          if details
+            formatted_details = []
+            details.keys.each do |key|
+              detail_string = ''
+              detail_messages = Array(details[key])
+              if detail_messages.any?
+                detail_string << key.to_s.capitalize << ': '
+                detail_string << detail_messages.join(', ')
+              end
+              formatted_details << detail_string unless detail_string.empty?
+            end
+            formatted_details.join("; ")
+          else
+            ''
           end
-          formatted_details << detail_string unless detail_string.empty?
         end
-        formatted_details.join("; ")
-      else
-        ''
       end
     end
+  end
 end
+

data/lib/topographer/importer/importable.rb

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

data/lib/topographer/importer/input.rb

@@ -1,5 +1,12 @@
-class Topographer::Importer::Input
-  require_relative 'input/source_data'
-  require_relative 'input/base'
-  require_relative 'input/roo'
+require_relative 'input/source_data'
+require_relative 'input/base'
+require_relative 'input/roo'
+require_relative 'input/delimited_spreadsheet'
+
+module Topographer
+  class Importer
+    module Input
+
+    end
+  end
 end

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

@@ -1,21 +1,27 @@
-class Topographer::Importer::Input::Base
-  def get_header
-    raise NotImplementedError
-  end
+module Topographer
+  class Importer
+    module Input
+      class Base
+        def get_header
+          raise NotImplementedError
+        end
 
-  def input_identifier
-    raise NotImplementedError
-  end
+        def input_identifier
+          raise NotImplementedError
+        end
 
-  def each
-    raise NotImplementedError
-  end
+        def each
+          raise NotImplementedError
+        end
 
-  def importable?
-    true
-  end
+        def importable?
+          true
+        end
 
-  def failure_message
-    ''
+        def failure_message
+          ''
+        end
+      end
+    end
   end
 end

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

@@ -0,0 +1,55 @@
+module Topographer
+  class Importer
+    module Input
+      class DelimitedSpreadsheet < Topographer::Importer::Input::Base
+        include Enumerable
+
+        # Creates a new DelimitedSpreadsheet input wrapper.  NOTE: Since Topographer relies on headers
+        # to map from input to output columns, you should enable header parsing in the CSV object passed in
+        #
+        # NOTE: the CSV used to construct this object should have the :return_headers flag set or the first
+        # row of data will be lost!
+        #
+        # @param name [String] the name of the delimited file being dealt with (e.g. My Data File 1)
+        # @param spreadsheet [CSV] the spreadsheet object to be parsed
+        def initialize(name, spreadsheet)
+          @sheet = spreadsheet
+          @name = name
+        end
+
+        # Returns the headers in the CSV file, or if header parsing is not enabled, an empty array
+        #
+        # @return [Array<String>] the headers in the file
+        def get_header
+          unless @header
+            if @sheet.headers === true
+              @sheet.shift
+            elsif @sheet.headers.nil?
+              @header = []
+            end
+            @header ||= @sheet.headers
+          end
+
+          @header
+        end
+
+        def input_identifier
+          @name
+        end
+
+        def each
+          @sheet.each_with_index do |data, index|
+            row_number = index + 2
+            source_identifier = "Row: #{row_number}"
+
+
+              yield Topographer::Importer::Input::SourceData.new(
+                source_identifier,
+                data.to_h
+              )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,33 +1,40 @@
-class Topographer::Importer::Input::Roo < Topographer::Importer::Input::Base
-  include Enumerable
+module Topographer
+  class Importer
+    module Input
+      class Roo < Topographer::Importer::Input::Base
+        include Enumerable
 
-  def initialize(roo_sheet, header_row=1, data_row=2)
-    @sheet = roo_sheet
-    @header = @sheet.row(header_row).map(&:strip)
-    @start_data_row = data_row
-    @end_data_row = @sheet.last_row
-  end
+        def initialize(roo_sheet, header_row=1, data_row=2)
+          @sheet = roo_sheet
+          @header = @sheet.row(header_row).map(&:strip)
+          @start_data_row = data_row
+          @end_data_row = @sheet.last_row
+        end
 
-  def get_header
-    @header
-  end
+        def get_header
+          @header
+        end
 
-  def input_identifier
-    #This is apparently how you get the name of the sheet...this makes me sad
-    @sheet.default_sheet
-  end
+        def input_identifier
+          #This is apparently how you get the name of the sheet...this makes me sad
+          @sheet.default_sheet
+        end
 
-  def each
-    @start_data_row.upto @end_data_row do |row_number|
-      data = @sheet.row(row_number)
-      source_identifier = "Row: #{row_number}"
+        def each
+          @start_data_row.upto @end_data_row do |row_number|
+            data = @sheet.row(row_number)
+            source_identifier = "Row: #{row_number}"
 
-      if data.reject{ |column| column.blank? }.any?
-        yield Topographer::Importer::Input::SourceData.new(
-          source_identifier,
-          Hash[@header.zip(data)]
-        )
+            if data.reject{ |column| column.blank? }.any?
+              yield Topographer::Importer::Input::SourceData.new(
+                source_identifier,
+                Hash[@header.zip(data)]
+              )
+            end
+          end
+        end
       end
+
     end
   end
 end