darlingtonia 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f8a94f2f8efae78fd25e95e947a1290759dc552
-  data.tar.gz: b2c3f7bdbb8f1047620b1d2a12fda977c76c5242
+  metadata.gz: 4d2846b9bcfda0f77bed4980b06ffebeea86fa2d
+  data.tar.gz: 5768f600be72e578ef9969e84d1d71d3e5160c06
 SHA512:
-  metadata.gz: c33bd4225faab6259e72e4cd74cbb24bca5a7c8592fe61c2ea290bfd03922f2a3b80cead1c3db1f89fc033fee04868130459f841e2a2669a174ecc28f76a532a
-  data.tar.gz: ad7b5de36a1dafdfde876647713fc582218a3f9e7eca49385375751572785e0200209ca502425769d3cb88adcff134e1c56a8876a77c44432dc13bceedadf4f9
+  metadata.gz: 1565987780f909a9ba63b872c68da62a6f782c46d5363930b188a7c64e63bc323e1cdbfb1d54274291b6a6dfea046a6a87d672648d7a11d6a707dafb25e11db8
+  data.tar.gz: ddae5b051da31ee14317e09b5c36597cd3ec6ad550d6ddd1585ac4d30ba77dccae2cbbbcf0deb8cf6d790bf6a37be87c46f9a766502423603e8609b27b1beb00

data/.rubocop.yml

@@ -4,6 +4,10 @@ inherit_gem:
 AllCops:
   TargetRubyVersion: 2.3
 
+Lint/HandleExceptions:
+  Exclude:
+    - 'spec/**/*'
+
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/*'

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+0.2.0 - Wed Jan 17, 2018
+------------------------
+
+Error & info streams.
+
+  - Extend `Parser` subclasses to define `DEFAULT_VALIDATORS` to hard code
+    a default validator list.
+  - Support streaming errors from `Validator` to an error stream (`#<<`).
+  - Add configuration at `Darlingtonia.config` to set `default_error_stream`.
+  - Introduce `MetadataMapper` as a base `Mapper` class.
+  - Add error stream for `RuntimeError` to `RecordImporter`.
+  - Add error stream handling for `Ldp::HTTPError` and `Faraday::Connection`
+    errors to `RecordImporter`.
+  - Add `info_stream`, `default_info_stream` (`#<<`) and notifications for
+    before/after record import.
+  - Improve validator documentation.
+  - Add `TitleValidator` to validate presence of titles in parsed
+    `InputRecord`s.
+
 0.1.1 - Fri Jan 12, 2018
 ------------------------
 

data/README.md

@@ -3,6 +3,26 @@ Darlingtonia
 
 Object import for Hyrax.
 
+Usage
+-----
+
+In your project's `Gemfile`, add: `gem 'darlingtonia', '~> 0.1'`, then do `bundle install`.
+
+
+This software is primarily intended for use in a [Hyrax](https://github.com/samvera/hyrax) project.
+However, its dependency on `hyrax` is kept strictly optional so most of its code can be reused to
+good effect elsewhere.
+
+To do a basic Hyrax import, first ensure that a [work type is registered](http://www.rubydoc.info/github/samvera/hyrax/Hyrax/Configuration#register_curation_concern-instance_method)
+with your `Hyrax` application. You need to provide a `Parser` (out of the box, we support simple CSV
+import with `CsvParser`).
+
+```ruby
+parser = Darlingtonia::CsvParser.new(file: File.open('path/to/import.csv'))
+
+Darlingtonia::Importer.new(parser: parser).import
+```
+
 Development
 -----------
 
@@ -11,5 +31,5 @@ git clone https://github.com/curationexperts/darlingtonia
 cd darlingtonia
 
 bundle install
-bundle exec rspec
+bundle exec rake ci
 ```

data/lib/darlingtonia.rb

@@ -3,9 +3,46 @@
 require 'active_fedora'
 
 ##
-# Bulk object import for Hyrax
+# Bulk object import for Hyrax.
+#
+# @example A basic configuration
+#   Darlingtonia.config do |config|
+#     # error streams must respond to `#<<`
+#     config.default_error_stream = MyErrorStream.new
+#   end
+#
 module Darlingtonia
+  ##
+  # @yield the current configuration
+  # @yieldparam config [Darlingtonia::Configuration]
+  #
+  # @return [Darlingtonia::Configuration] the current configuration
+  def config
+    yield @configuration if block_given?
+    @configuration
+  end
+  module_function :config
+
+  ##
+  # Module-wide options for `Darlingtonia`.
+  class Configuration
+    ##
+    # @!attribute [rw] default_error_stream
+    #   @return [#<<]
+    # @!attribute [rw] default_info_stream
+    #   @return [#<<]
+    attr_accessor :default_error_stream, :default_info_stream
+
+    def initialize
+      self.default_error_stream = STDOUT
+      self.default_info_stream  = STDOUT
+    end
+  end
+
+  @configuration = Configuration.new
+
   require 'darlingtonia/version'
+  require 'darlingtonia/metadata_mapper'
   require 'darlingtonia/hash_mapper'
 
   require 'darlingtonia/importer'
@@ -13,9 +50,10 @@ module Darlingtonia
 
   require 'darlingtonia/input_record'
 
-  require 'darlingtonia/parser'
-  require 'darlingtonia/parsers/csv_parser'
-
   require 'darlingtonia/validator'
   require 'darlingtonia/validators/csv_format_validator'
+  require 'darlingtonia/validators/title_validator'
+
+  require 'darlingtonia/parser'
+  require 'darlingtonia/parsers/csv_parser'
 end

data/lib/darlingtonia/hash_mapper.rb

@@ -5,12 +5,22 @@ module Darlingtonia
   # A generic metadata mapper for input records
   #
   # Maps from hash accessor syntax (`['title']`) to method call dot syntax (`.title`)
-  class HashMapper
-    ##
-    # @!attribute [r] meadata
-    #   @return [Hash<String, String>]
-    attr_reader :metadata
-
+  #
+  # The fields provided by this mapper are dynamically determined by the fields
+  # available in the provided metadata hash.
+  #
+  # All field values are given as multi-valued arrays.
+  #
+  # @example
+  #   mapper = HashMapper.new
+  #   mapper.fields # => []
+  #
+  #   mapper.metadata = { title: 'Comet in Moominland', author: 'Tove Jansson' }
+  #   mapper.fields # => [:title, :author]
+  #   mapper.title  # => ['Comet in Moominland']
+  #   mapper.author # => ['Tove Jansson']
+  #
+  class HashMapper < MetadataMapper
     ##
     # @param meta [#to_h]
     # @return [Hash<String, String>]
@@ -18,14 +28,6 @@ module Darlingtonia
       @metadata = meta.to_h
     end
 
-    ##
-    # @param name [Symbol]
-    #
-    # @return [Boolean]
-    def field?(name)
-      fields.include?(name)
-    end
-
     ##
     # @return [Enumerable<Symbol>] The fields the mapper can process
     def fields
@@ -33,13 +35,10 @@ module Darlingtonia
       metadata.keys.map(&:to_sym)
     end
 
-    def method_missing(method_name, *args, &block)
-      return Array(metadata[method_name.to_s]) if fields.include?(method_name)
-      super
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      field?(method_name) || super
+    ##
+    # @see MetadataMapper#map_field
+    def map_field(name)
+      Array(metadata[name.to_s])
     end
   end
 end

data/lib/darlingtonia/metadata_mapper.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Darlingtonia
+  ##
+  # A null/base mapper that maps no fields.
+  #
+  # Real mapper implementations need to provide `#fields`, enumerating over
+  # `Symbols` that represent the fields on the target object (e.g. an
+  # `ActiveFedora::Base`/`Hyrax::WorkBehavior`) that the mapper can handle.
+  # For each field in `#fields`, the mapper must respond to a matching method
+  # (i.e. `:title` => `#title`), and return the value(s) that should be set to
+  # the target's attributes upon mapping.
+  #
+  # To ease the implementation of field methods, this base class provides
+  # a `#method_missing` that forwards missing method names to a `#map_field`
+  # method. `#map_field` can be implemented to provide a generalized field
+  # mapping when a common pattern will be used for many methods. Callers should
+  # avoid relying on this protected method directly, since mappers may implement
+  # individual field methods in any other way (e.g. `def title; end`) to route
+  # around `#map_field`. Implementations are also free to override
+  # `#method_missing` if desired.
+  #
+  # Mappers generally operate over some input `#metadata`. Example metadata
+  # types that mappers could be implemented over include `Hash`, `CSV`, `XML`,
+  # `RDF::Graph`, etc...; mappers are free to interpret or ignore the contents
+  # of their underlying metadata data structures at their leisure. Values for
+  # fields are /usually/ derived from the `#metadata`, but can also be generated
+  # from complex logic or even hard-coded.
+  #
+  # @example Using a MetadataMapper
+  #   mapper = MyMapper.new
+  #   mapper.metadata = some_metadata_object
+  #   mapper.fields # => [:title, :author, :description]
+  #
+  #   mapper.title # => 'Some Title'
+  #
+  #   mapper.fields.map { |field| mapper.send(field) }
+  #
+  #
+  # @see ImportRecord#attributes for the canonical usage of a `MetadataMapper`.
+  # @see HashMapper for an example implementation with dynamically generated
+  #   fields
+  class MetadataMapper
+    ##
+    # @!attribute [rw] metadata
+    #   @return [Object]
+    attr_accessor :metadata
+
+    ##
+    # @param name [Symbol]
+    #
+    # @return [Boolean]
+    def field?(name)
+      fields.include?(name)
+    end
+
+    ##
+    # @return [Enumerable<Symbol>] The fields the mapper can process
+    def fields
+      []
+    end
+
+    def method_missing(method_name, *args, &block)
+      return map_field(method_name) if fields.include?(method_name)
+      super
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      field?(method_name) || super
+    end
+
+    protected
+
+      ##
+      # @private
+      #
+      # @param name [Symbol]
+      #
+      # @return [Object]
+      def map_field(_name)
+        raise NotImplementedError
+      end
+  end
+end

data/lib/darlingtonia/parser.rb

@@ -2,13 +2,39 @@
 
 module Darlingtonia
   ##
-  # A generic parser
+  # A generic parser.
   #
-  # @example
+  # `Parser` implementations provide a stream of `InputRecord`s, derived from an
+  # input object (`file`), through `Parser#records`. This method should be
+  # implemented efficiently for repeated access, generating records lazily if
+  # possible, and caching if appropriate.
+  #
+  # Input validation is handled by an array of `#validators`, which are run in
+  # sequence when `#validate` (or `#validate!`) is called. Errors caught in
+  # validation are accessible via `#errors`, and inputs generating errors result
+  # in `#valid? # => false`.
+  #
+  # A factory method `.for` is provided, and each implementation should
+  # provides a `.match?(**)` which returns `true` if the options passed
+  # indicate the parser can handle the given input. Parsers are checked for
+  # `#match?` in the reverse of load order (i.e. the most recently loaded
+  # `Parser` classes are given precedence).
+  #
+  # @example Getting a parser for a file input
   #   file = File.open('path/to/import/manifest.csv')
   #
   #   Parser.for(file: file).records
   #
+  # @example Validating a parser
+  #   parser = Parser.for(file: invalid_input)
+  #
+  #   parser.valid?   # => true (always true before validation)
+  #   parser.validate # => false
+  #   parser.valid?   # => false
+  #   parser.errors   # => an array of Validation::Error-like structs
+  #
+  #   parser.validate! # ValidationError
+  #
   # rubocop:disable Style/ClassVars
   class Parser
     DEFAULT_VALIDATORS = [].freeze
@@ -29,7 +55,7 @@ module Darlingtonia
     def initialize(file:, **_opts)
       self.file     = file
       @errors       = []
-      @validators ||= []
+      @validators ||= self.class::DEFAULT_VALIDATORS
 
       yield self if block_given?
     end
@@ -77,13 +103,13 @@ module Darlingtonia
     end
 
     ##
-    # @return [Boolean] true if the
+    # @return [Boolean] true if the file input is valid
     def valid?
       errors.empty?
     end
 
     ##
-    # @return [Boolean]
+    # @return [Boolean] true if the file input is valid
     def validate
       validators.each_with_object(errors) do |validator, errs|
         errs.concat(validator.validate(parser: self))
@@ -93,7 +119,8 @@ module Darlingtonia
     end
 
     ##
-    # @return [true]
+    # @return [true] always true, unless an error is raised.
+    #
     # @raise [ValidationError] if the file to parse is invalid
     def validate!
       validate || raise(ValidationError)

data/lib/darlingtonia/parsers/csv_parser.rb

@@ -4,8 +4,16 @@ require 'csv'
 
 module Darlingtonia
   ##
-  # A parser for CSV files
+  # A parser for CSV files. A single `InputRecord` is returned for each row
+  # parsed from the input.
+  #
+  # Validates the format of the CSV, generating a single error the file is
+  # malformed. This error gives the line number and a message for the first
+  # badly formatted row.
+  #
+  # @see CsvFormatValidator
   class CsvParser < Parser
+    DEFAULT_VALIDATORS = [CsvFormatValidator.new].freeze
     EXTENSION = '.csv'
 
     class << self

data/lib/darlingtonia/record_importer.rb

@@ -2,12 +2,32 @@
 
 module Darlingtonia
   class RecordImporter
+    ##
+    # @!attribute [rw] error_stream
+    #   @return [#<<]
+    # @!attribute [rw] info_stream
+    #   @return [#<<]
+    attr_accessor :error_stream, :info_stream
+
+    ##
+    # @param error_stream [#<<]
+    def initialize(error_stream: Darlingtonia.config.default_error_stream,
+                   info_stream: Darlingtonia.config.default_info_stream)
+      self.error_stream = error_stream
+      self.info_stream  = info_stream
+    end
+
     ##
     # @param record [ImportRecord]
     #
     # @return [void]
     def import(record:)
-      import_type.create(record.attributes)
+      create_for(record: record)
+    rescue Faraday::ConnectionFailed, Ldp::HttpError => e
+      error_stream << e
+    rescue RuntimeError => e
+      error_stream << e
+      raise e
     end
 
     def import_type
@@ -16,5 +36,16 @@ module Darlingtonia
 
       Hyrax.config.curation_concerns.first
     end
+
+    private
+
+      def create_for(record:)
+        info_stream << 'Creating record: ' \
+                       "#{record.respond_to?(:title) ? record.title : record}."
+
+        created = import_type.create(record.attributes)
+
+        info_stream << "Record created at: #{created.id}"
+      end
   end
 end

data/lib/darlingtonia/validator.rb

@@ -4,6 +4,19 @@ module Darlingtonia
   ##
   # @abstract A null validator; always returns an empty error collection
   #
+  # Validators are used to ensure the correctness of input to a parser. Each
+  # validator must respond to `#validate` and return a collection of errors
+  # found during validation. If the input is valid, this collection must be
+  # empty. Otherwise, it contains any number of `Validator::Error` structs
+  # which should be sent to the `#error_stream` by the validator.
+  #
+  # The validation process accepts an entire `Parser` and is free to inspect
+  # the input `#file` content, or view its individual `#records`.
+  #
+  # The base class provides infrastructure for the key behavior, relying on a
+  # private `#run_validation` method to provide the core behavior. In most cases
+  # implementers will want to simply override this method.
+  #
   # @example validating a parser
   #   validator = MyValidator.new
   #   validator.validate(parser: myParser)
@@ -16,19 +29,66 @@ module Darlingtonia
   #                   description: '...'
   #                   lineno: 37>
   #
+  # @example Implementing a custom Validator and using it in a Parser
+  #   # Validator checks that the title, when downcased is equal to `moomin`
+  #   class TitleIsMoominValidator
+  #     def run_validation(parser:)
+  #       parser.records.each_with_object([]) do |record, errors|
+  #         errors << Error.new(self, :title_is_not_moomin) unless
+  #           title_is_moomin?(record)
+  #       end
+  #     end
+  #
+  #     def title_is_moomin?(record)
+  #       return false unless record.respond_to?(:title)
+  #       return true if record.title.downcase == 'moomin
+  #       true
+  #     end
+  #   end
+  #
+  #   parser = MyParser.new(some_content)
+  #   parser.validations << TitleIsMoominvalidator.new
+  #   parser.validate
+  #   parser.valid? # => false (unless all the records match the title)
+  #
+  # @see Parser#validate
   class Validator
-    Error = Struct.new(:validator, :name, :description, :lineno)
+    Error = Struct.new(:validator, :name, :description, :lineno) do
+      def to_s
+        "#{name}: #{description} (#{validator})"
+      end
+    end
 
     ##
-    # @param parser       [Parser]
-    # @param error_stream [#add]
+    # @!attribute [rw] error_stream
+    #   @return [#<<]
+    attr_accessor :error_stream
+
+    ##
+    # @param error_stream [#<<]
+    def initialize(error_stream: Darlingtonia.config.default_error_stream)
+      self.error_stream = error_stream
+    end
+
+    ##
+    # @param parser [Parser]
     #
     # @return [Enumerator<Error>] a collection of errors found in validation
-    #
-    # rubocop:disable Lint/UnusedMethodArgument
-    def validate(parser:, **)
-      []
+    def validate(parser:)
+      run_validation(parser: parser).tap do |errors|
+        errors.map { |error| error_stream << error }
+      end
     end
     # rubocop:enable Lint/UnusedMethodArgument
+
+    private
+
+      ##
+      # @return [Enumerator<Error>]
+      #
+      # rubocop:disable Lint/UnusedMethodArgument
+      def run_validation(parser:)
+        [].to_enum
+      end
   end
 end

data/lib/darlingtonia/validators/csv_format_validator.rb

@@ -12,8 +12,10 @@ module Darlingtonia
   # @see http://ruby-doc.org/stdlib-2.0.0/libdoc/csv/rdoc/CSV/MalformedCSVError.html
   class CsvFormatValidator < Validator
     ##
+    # @private
+    #
     # @see Validator#validate
-    def validate(parser:, **)
+    def run_validation(parser:, **)
       return [] if CSV.parse(parser.file.read)
     rescue CSV::MalformedCSVError => e
       [Error.new(self.class, e.class, e.message)]

data/lib/darlingtonia/validators/title_validator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Darlingtonia
+  class TitleValidator < Validator
+    ##
+    # @private
+    #
+    # @see Validator#validate
+    def run_validation(parser:, **)
+      parser.records.each_with_object([]) do |record, errors|
+        titles = record.respond_to?(:title) ? record.title : []
+
+        errors << error_for(record: record) if Array(titles).empty?
+      end
+    end
+
+    protected
+
+      ##
+      # @private
+      # @param record [InputRecord]
+      #
+      # @return [Error]
+      def error_for(record:)
+        Error.new(self,
+                  :missing_title,
+                  "Title is required; got #{record.mapper.metadata}")
+      end
+  end
+end

data/lib/darlingtonia/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Darlingtonia
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/spec/darlingtonia/csv_format_validator_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 
 describe Darlingtonia::CsvFormatValidator do
-  subject(:validator)  { described_class.new }
+  subject(:validator)  { described_class.new(error_stream: []) }
   let(:invalid_parser) { Darlingtonia::CsvParser.new(file: invalid_file) }
   let(:invalid_file)   { File.open('spec/fixtures/bad_example.csv') }
 

data/spec/darlingtonia/csv_parser_spec.rb

@@ -46,4 +46,18 @@ EOS
       expect(parser.records.map(&:date)).to contain_exactly(['1945'], ['1946'])
     end
   end
+
+  describe '#validate' do
+    it 'is valid' do
+      expect(parser.validate).to be_truthy
+    end
+
+    context 'with invalid file' do
+      let(:file) { File.open('spec/fixtures/bad_example.csv') }
+
+      it 'is invalid' do
+        expect(parser.validate).to be_falsey
+      end
+    end
+  end
 end

data/spec/darlingtonia/parser_spec.rb

@@ -17,7 +17,7 @@ describe Darlingtonia::Parser do
       before(:context) do
         ##
         # An importer that matches all types
-        class FakeParser < described_class
+        class MyFakeParser < described_class
           class << self
             def match?(**_opts)
               true
@@ -25,11 +25,11 @@ describe Darlingtonia::Parser do
           end
         end
 
-        class NestedParser < FakeParser; end
+        class NestedParser < MyFakeParser; end
       end
 
       after(:context) do
-        Object.send(:remove_const, :FakeParser)
+        Object.send(:remove_const, :MyFakeParser)
         Object.send(:remove_const, :NestedParser)
       end
 

data/spec/darlingtonia/record_importer_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darlingtonia::RecordImporter, :clean do
+  subject(:importer) do
+    described_class.new(error_stream: error_stream, info_stream: info_stream)
+  end
+
+  let(:error_stream) { [] }
+  let(:info_stream)  { [] }
+  let(:record)       { Darlingtonia::InputRecord.new }
+
+  it 'raises an error when no work type exists' do
+    expect { importer.import(record: record) }
+      .to raise_error 'No curation_concern found for import'
+  end
+
+  context 'with a registered work type' do
+    include_context 'with a work type'
+
+    it 'creates a work for record' do
+      expect { importer.import(record: record) }
+        .to change { Work.count }
+        .by 1
+    end
+
+    it 'writes to the info stream before and after create' do
+      expect { importer.import(record: record) }
+        .to change { info_stream }
+        .to contain_exactly(/^Creating record/, /^Record created/)
+    end
+
+    context 'when input record errors with LDP errors' do
+      let(:ldp_error) { Ldp::PreconditionFailed }
+
+      before { allow(record).to receive(:attributes).and_raise(ldp_error) }
+
+      it 'writes errors to the error stream (no reraise!)' do
+        expect { importer.import(record: record) }
+          .to change { error_stream }
+          .to contain_exactly(an_instance_of(ldp_error))
+      end
+    end
+
+    context 'when input record errors unexpectedly' do
+      let(:custom_error) { Class.new(RuntimeError) }
+
+      before { allow(record).to receive(:attributes).and_raise(custom_error) }
+
+      it 'writes errors to the error stream' do
+        expect { begin; importer.import(record: record); rescue; end }
+          .to change { error_stream }
+          .to contain_exactly(an_instance_of(custom_error))
+      end
+
+      it 'reraises error' do
+        expect { importer.import(record: record) }.to raise_error(custom_error)
+      end
+    end
+  end
+end

data/spec/darlingtonia/title_validator_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darlingtonia::TitleValidator do
+  subject(:validator) { described_class.new(error_stream: []) }
+
+  let(:invalid_parser) do
+    FakeParser.new(file: [{ 'title' => 'moomin' }, {}, {}])
+  end
+
+  it_behaves_like 'a Darlingtonia::Validator' do
+    let(:valid_parser) { FakeParser.new(file: [{ 'title' => 'moomin' }]) }
+  end
+
+  describe '#validate' do
+    it 'populates errors for records with missing titles' do
+      expect(validator.validate(parser: invalid_parser))
+        .to contain_exactly(an_instance_of(described_class::Error),
+                            an_instance_of(described_class::Error))
+    end
+  end
+end

data/spec/darlingtonia/validator_spec.rb

@@ -3,5 +3,7 @@
 require 'spec_helper'
 
 describe Darlingtonia::Validator do
-  it_behaves_like 'a Darlingtonia::Validator'
+  it_behaves_like 'a Darlingtonia::Validator' do
+    let(:valid_parser) { :any }
+  end
 end

data/spec/darlingtonia_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Darlingtonia do
+  describe '#config' do
+    it 'can set a default error stream' do
+      stream = []
+
+      expect { described_class.config { |c| c.default_error_stream = stream } }
+        .to change { described_class.config.default_error_stream }
+        .from(STDOUT)
+        .to(stream)
+    end
+
+    it 'can set a default info stream' do
+      stream = []
+
+      expect { described_class.config { |c| c.default_info_stream = stream } }
+        .to change { described_class.config.default_info_stream }
+        .from(STDOUT)
+        .to(stream)
+    end
+  end
+end

data/spec/integration/import_csv_spec.rb

@@ -2,37 +2,26 @@
 
 require 'spec_helper'
 
-describe 'importing a csv batch' do
+describe 'importing a csv batch', :clean do
   subject(:importer) { Darlingtonia::Importer.new(parser: parser) }
   let(:parser)       { Darlingtonia::CsvParser.new(file: file) }
   let(:file)         { File.open('spec/fixtures/example.csv') }
 
-  # A work type must be defined for the default `RecordImporter` to save objects
-  before do
-    class Work < ActiveFedora::Base
-      property :title,       predicate: ::RDF::URI('http://example.com/title')
-      property :description, predicate: ::RDF::URI('http://example.com/description')
-    end
-
-    module Hyrax
-      def self.config
-        Config.new
-      end
+  include_context 'with a work type'
 
-      class Config
-        def curation_concerns
-          [Work]
-        end
-      end
-    end
+  it 'creates a record for each CSV line' do
+    expect { importer.import }.to change { Work.count }.to 3
   end
 
-  after do
-    Object.send(:remove_const, :Hyrax)
-    Object.send(:remove_const, :Work)
-  end
+  describe 'validation' do
+    context 'with invalid CSV' do
+      let(:file) { File.open('spec/fixtures/bad_example.csv') }
 
-  it 'creates a record for each CSV line' do
-    expect { importer.import }.to change { Work.count }.to 3
+      it 'outputs invalid file notice to error stream' do
+        expect { parser.validate }
+          .to output(/^CSV::MalformedCSVError.*line 2/)
+          .to_stdout_from_any_process
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ require 'pry' unless ENV['CI']
 ENV['environment'] ||= 'test'
 
 require 'bundler/setup'
+require 'active_fedora/cleaner'
 require 'darlingtonia'
 
 Dir['./spec/support/**/*.rb'].each { |f| require f }
@@ -11,4 +12,6 @@ Dir['./spec/support/**/*.rb'].each { |f| require f }
 RSpec.configure do |config|
   config.filter_run focus: true
   config.run_all_when_everything_filtered = true
+
+  config.before(:each, clean: true) { ActiveFedora::Cleaner.clean! }
 end

data/spec/support/shared_contexts/with_work_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+shared_context 'with a work type' do
+  # A work type must be defined for the default `RecordImporter` to save objects
+  before do
+    class Work < ActiveFedora::Base
+      property :title,       predicate: ::RDF::URI('http://example.com/title')
+      property :description, predicate: ::RDF::URI('http://example.com/description')
+    end
+
+    module Hyrax
+      def self.config
+        Config.new
+      end
+
+      class Config
+        def curation_concerns
+          [Work]
+        end
+      end
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Hyrax) if defined?(Hyrax)
+    Object.send(:remove_const, :Work)  if defined?(Work)
+  end
+end

data/spec/support/shared_examples/a_validator.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 shared_examples 'a Darlingtonia::Validator' do
-  subject(:validator) { described_class.new }
+  subject(:validator) { described_class.new(error_stream: error_stream) }
+  let(:error_stream)  { [] }
 
   define :be_a_validator_error do # |expected|
     match { false } # { |actual| some_condition }
@@ -15,13 +16,13 @@ shared_examples 'a Darlingtonia::Validator' do
     end
 
     it 'gives an empty error collection for a valid parser' do
-      expect(validator.validate(parser: valid_parser)).to be_empty if
+      expect(validator.validate(parser: valid_parser)).not_to be_any if
         defined?(valid_parser)
     end
 
     context 'for an invalid parser' do
       it 'gives an non-empty error collection' do
-        expect(validator.validate(parser: invalid_parser)).not_to be_empty if
+        expect(validator.validate(parser: invalid_parser)).to be_any if
           defined?(invalid_parser)
       end
 
@@ -32,6 +33,14 @@ shared_examples 'a Darlingtonia::Validator' do
           expect(error).to be_a_validator_error
         end
       end
+
+      it 'writes errors to the error stream' do
+        if defined?(invalid_parser)
+          expect { validator.validate(parser: invalid_parser) }
+            .to change { error_stream }
+            .to include(an_instance_of(Darlingtonia::Validator::Error))
+        end
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: darlingtonia
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Tom Johnson
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-12 00:00:00.000000000 Z
+date: 2018-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active-fedora
@@ -148,11 +148,13 @@ files:
 - lib/darlingtonia/hash_mapper.rb
 - lib/darlingtonia/importer.rb
 - lib/darlingtonia/input_record.rb
+- lib/darlingtonia/metadata_mapper.rb
 - lib/darlingtonia/parser.rb
 - lib/darlingtonia/parsers/csv_parser.rb
 - lib/darlingtonia/record_importer.rb
 - lib/darlingtonia/validator.rb
 - lib/darlingtonia/validators/csv_format_validator.rb
+- lib/darlingtonia/validators/title_validator.rb
 - lib/darlingtonia/version.rb
 - spec/darlingtonia/csv_format_validator_spec.rb
 - spec/darlingtonia/csv_parser_spec.rb
@@ -160,13 +162,17 @@ files:
 - spec/darlingtonia/importer_spec.rb
 - spec/darlingtonia/input_record_spec.rb
 - spec/darlingtonia/parser_spec.rb
+- spec/darlingtonia/record_importer_spec.rb
+- spec/darlingtonia/title_validator_spec.rb
 - spec/darlingtonia/validator_spec.rb
 - spec/darlingtonia/version_spec.rb
+- spec/darlingtonia_spec.rb
 - spec/fixtures/bad_example.csv
 - spec/fixtures/example.csv
 - spec/integration/import_csv_spec.rb
 - spec/spec_helper.rb
 - spec/support/fakes/fake_parser.rb
+- spec/support/shared_contexts/with_work_type.rb
 - spec/support/shared_examples/a_mapper.rb
 - spec/support/shared_examples/a_parser.rb
 - spec/support/shared_examples/a_validator.rb