krikri 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 01b6a4cc31b96735f4e2ec59fd2b9ee25c2cc88f
-  data.tar.gz: 06fa312088255ba9ed484c007d7bde50597b788b
+  metadata.gz: 21d519147fe5ef3a3c3d26eaf8f0c9924b8208da
+  data.tar.gz: 1fca577cbdf76e6a9aeb680c5659bc0db268633f
 SHA512:
-  metadata.gz: 7c00770e89b37703c31c100fc589889acaf6c1fa42c1b20c340478a0c6d23b6330f016dad2b42220ab5f06b6342bb82b9bc2d698b9243de446dd6b782500522c
-  data.tar.gz: ec6a06a36f84bd9e626013574f91a4b026af267e9e5a8c123ea16fe1574f5d97036ae472f43ca0083b81c198cf02d8aaed8c9344df3054033c2341a2a69e2058
+  metadata.gz: 126f351593488204a37b83749da26849b69c3e41b60571f3b473db5422349fb96c3ffec6674926882c694d54b536758aee86475540ea98a78a45432c927ac2af
+  data.tar.gz: c61cae684f9ae1a2b350bf008e70d7598c7407a15b411acadb7d716b5879fc96afc2a891b0689aca8ad6579f19d0310cd12f253adcdbbce9e829cd05a20e354e

data/app/models/krikri/activity.rb

@@ -42,12 +42,30 @@ module Krikri
     # is passed an instance of the agent, and a URI representing this Activity.
     def run
       if block_given?
+        update_attribute(:end_time, nil) if ended?
         set_start_time
-        yield agent_instance, rdf_subject
-        set_end_time
+        begin
+          yield agent_instance, rdf_subject
+        rescue => e
+          Rails.logger.error("Error performing Activity: #{id}\n" \
+                             "#{e.message}\n#{e.backtrace}")
+          raise e
+        ensure
+          set_end_time
+        end
       end
     end
 
+    ##
+    # Indicates whether the activity has ended. Does not distinguish between
+    # successful and failed completion states.
+    #
+    # @return [Boolean] `true` if the activity has been marked as ended,
+    #   else `false`
+    def ended?
+      !self.end_time.nil?
+    end
+
     ##
     # Instantiates and returns an instance of the Agent class with the values in
     # opts.

data/lib/krikri/harvester.rb

@@ -102,7 +102,14 @@ module Krikri
     # @return [Boolean]
     def run(activity_uri = nil)
       log :info, 'harvest is running'
-      records.each { |rec| rec.save(activity_uri) }
+      records.each do |rec|
+        begin
+          rec.save(activity_uri)
+        rescue => e
+          log :error, "Error harvesting record:\n#{rec.content}\n\twith message:\n#{e.message}"
+          next
+        end
+      end
       log :info, 'harvest is done'
       true
     end

data/lib/krikri/mapper.rb

@@ -34,13 +34,14 @@ module Krikri
     #
     # @param name [Symbol] a unique name for the mapper in the registry.
     # @param opts [Hash] options to pass to the mapping instance, options are:
-    #   :class
+    #   :class, :parser, and :parser_args
     # @yield A block passed through to the mapping instance containing the
     #   mapping in the language specified by MappingDSL
     def define(name, opts = {}, &block)
       klass = opts.fetch(:class, DPLA::MAP::Aggregation)
       parser = opts.fetch(:parser, Krikri::XmlParser)
-      map = Krikri::Mapping.new(klass, parser)
+      parser_args = opts.fetch(:parser_args, nil)
+      map = Krikri::Mapping.new(klass, parser, *parser_args)
       map.instance_eval(&block) if block_given?
       Registry.register!(name, map)
     end
@@ -57,7 +58,14 @@ module Krikri
     # @see Mapping
     def map(name, records)
       records = Array(records) unless records.is_a? Enumerable
-      records.map { |rec| Registry.get(name).process_record(rec) }
+      records.map do |rec|
+        begin
+          Registry.get(name).process_record(rec)
+        rescue => e
+          Rails.logger.error("Error processing mapping for #{rec.rdf_subject}" \
+                             "\n#{e.message}\n#{e.backtrace}")
+        end
+      end
     end
 
     ##
@@ -80,10 +88,15 @@ module Krikri
 
       def run(activity_uri = nil)
         Krikri::Mapper.map(name, records).each do |rec|
-          rec.mint_id! if rec.node?
-          rec << RDF::Statement(rec, RDF::PROV.wasGeneratedBy, activity_uri) if
-            activity_uri
-          rec.save
+          begin
+            rec.mint_id! if rec.node?
+            rec << RDF::Statement(rec, RDF::PROV.wasGeneratedBy, activity_uri) if
+              activity_uri
+            rec.save
+          rescue => e
+            Rails.logger.error("Error saving record: #{rec.rdf_subject}\n" \
+                               "#{e.message}\n#{e.backtrace}")
+          end
         end
       end
 

data/lib/krikri/mapping.rb

@@ -10,14 +10,19 @@ module Krikri
   class Mapping
     include MappingDSL
 
-    attr_reader :klass, :parser
+    attr_reader :klass, :parser, :parser_args
 
     ##
     # @param klass [Class] The model class to build in the mapping process.
     # @param parser [Class] The parser class with which to process resources.
-    def initialize(klass = DPLA::MAP::Aggregation, parser = Krikri::XmlParser)
+    # @param parser_args [Array] The arguments to pass to the parser when
+    #   processing records.
+    def initialize(klass = DPLA::MAP::Aggregation,
+                   parser = Krikri::XmlParser,
+                   *parser_args)
       @klass = klass
       @parser = parser
+      @parser_args = parser_args
     end
 
     ##
@@ -27,7 +32,7 @@ module Krikri
     def process_record(record)
       mapped_record = klass.new
       properties.each do |prop|
-        prop.to_proc.call(mapped_record, parser.parse(record))
+        prop.to_proc.call(mapped_record, parser.parse(record, *@parser_args))
       end
       mapped_record
     end

data/lib/krikri/mapping_dsl/rdf_subjects.rb

@@ -13,7 +13,9 @@ module Krikri::MappingDSL
         value = @value
         lambda do |target, record|
           value = value.call(record) if value.respond_to? :call
-          raise "URI must be set to a single value; got #{value}" if
+          return target.rdf_subject if Array(value).empty?
+          raise "Error mapping #{record}, #{target}\t" \
+                "URI must be set to a single value; got #{value}" if
             Array(value).count != 1
           value = value.first if value.is_a? Enumerable
           return target.send(setter, value) unless block

data/lib/krikri/parser.rb

@@ -20,10 +20,12 @@ module Krikri
     # Instantiates a parser object to wrap the record. Returns the record
     # as is if it is already parsed.
     #
-    # @param record the record to parse
+    # @param record [Krikri::OriginalRecord, Krikri::Parser] the record to parse
+    # @param args [Array, nil] the arguments to pass to the parser instance,
+    #   if any
     # @return [Krikri::Parser] a parsed record object
-    def self.parse(record)
-      record.is_a?(Krikri::Parser) ? record : new(record)
+    def self.parse(record, *args)
+      record.is_a?(Krikri::Parser) ? record : new(record, *args)
     end
 
     ##

data/lib/krikri/version.rb

@@ -1,3 +1,3 @@
 module Krikri
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/spec/lib/krikri/harvester_spec.rb

@@ -17,4 +17,25 @@ describe Krikri::Harvester do
     end
   end
 
+  describe '#run' do
+    let(:records) { [double, double] }
+
+    before do
+      allow(subject).to receive(:records).and_return(records)
+    end
+
+    context 'when save fails' do
+      it 'logs error' do
+        records.each do |rec|
+          allow(rec).to receive(:save)
+                         .and_raise(StandardError.new('my message'))
+          allow(rec).to receive(:content).and_return 'content'
+        end
+        message =
+          "Error harvesting record:\ncontent\n\twith message:\nmy message"
+        expect(Rails.logger).to receive(:error).with(message).twice
+        subject.run
+      end
+    end
+  end
 end

data/spec/lib/krikri/mapper_agent_spec.rb

@@ -20,23 +20,44 @@ describe Krikri::Mapper::Agent do
       allow(record_double).to receive(:node?).and_return(true)
       allow(record_double).to receive(:mint_id!)
       allow(record_double).to receive(:save)
-      expect(Krikri::Mapper).to receive(:map).with(mapping_name, subject.records)
-        .and_return(records)
     end
 
-    it 'calls mapper' do
-      subject.run
+    context 'with errors thrown' do
+      before do
+        allow(record_double).to receive(:node?).and_raise(StandardError.new)
+        allow(record_double).to receive(:rdf_subject).and_return('123')
+        allow(Krikri::Mapper).to receive(:map).and_return(records)
+      end
+
+      it 'logs errors' do
+        expect(Rails.logger).to receive(:error)
+                                 .with(start_with('Error saving record: 123'))
+                                 .exactly(3).times
+        subject.run(activity_uri)
+      end
     end
 
-    it 'sets generator' do
-      records.each do |rec|
-        statement = double
-        allow(RDF).to receive(:Statement)
-          .with(rec, RDF::PROV.wasGeneratedBy, activity_uri)
-          .and_return(statement)
-        expect(rec).to receive(:<<).with(statement)
+    context 'with mapped records returned' do
+      before do
+        expect(Krikri::Mapper).to receive(:map)
+                                   .with(mapping_name, subject.records)
+                                   .and_return(records)
+      end
+
+      it 'calls mapper' do
+        subject.run
+      end
+
+      it 'sets generator' do
+        records.each do |rec|
+          statement = double
+          allow(RDF).to receive(:Statement)
+                         .with(rec, RDF::PROV.wasGeneratedBy, activity_uri)
+                         .and_return(statement)
+          expect(rec).to receive(:<<).with(statement)
+        end
+        subject.run(activity_uri)
       end
-      subject.run(activity_uri)
     end
   end
 

data/spec/lib/krikri/mapper_spec.rb

@@ -40,6 +40,20 @@ describe Krikri::Mapper do
       Krikri::Mapper.define(:klass_map, class: klass)
     end
 
+    it 'passes parser to mapping' do
+      parser = Class.new
+      expect(Krikri::Mapping).to receive(:new)
+        .with(DPLA::MAP::Aggregation, parser).once
+      Krikri::Mapper.define(:klass_map, parser: parser)
+    end
+
+    it 'passes parser_args to mapping' do
+      args = [1,2,3]
+      expect(Krikri::Mapping).to receive(:new)
+        .with(DPLA::MAP::Aggregation, Krikri::XmlParser, *args).once
+      Krikri::Mapper.define(:klass_map, parser_args: args)
+    end
+
     it 'hits DSL methods' do
       expect_any_instance_of(Krikri::Mapping).to receive(:dsl_method_1)
         .with(:arg1, :arg2)
@@ -76,20 +90,40 @@ describe Krikri::Mapper do
     end
 
     context 'with multiple records' do
-      before do
-        records.each do |rec|
-          expect(mapping).to receive(:process_record).with(rec)
-            .and_return(:mapped_record).ordered
-        end
-      end
-
       let(:records) do
         [record.clone, record.clone, record.clone]
       end
 
-      it 'returns a list of items returned by mapping' do
-        expect(Krikri::Mapper.map(:my_map_2, records))
-          .to contain_exactly(:mapped_record, :mapped_record, :mapped_record)
+      context 'with no errors' do
+        before do
+          records.each do |rec|
+            expect(mapping).to receive(:process_record).with(rec)
+                                .and_return(:mapped_record).ordered
+          end
+        end
+
+        it 'returns a list of items returned by mapping' do
+          expect(Krikri::Mapper.map(:my_map_2, records))
+            .to contain_exactly(:mapped_record, :mapped_record, :mapped_record)
+        end
+      end
+
+      context 'with errors thrown' do
+        before do
+          allow(record).to receive(:rdf_subject).and_return('123')
+
+          records.each do |rec|
+            allow(mapping).to receive(:process_record).with(rec)
+                               .and_raise(StandardError.new)
+          end
+        end
+
+        it 'logs errors and continues' do
+          expect(Rails.logger)
+            .to receive(:error).with(start_with('Error processing mapping for'))
+                 .exactly(3).times
+          Krikri::Mapper.map(:my_map_2, records)
+        end
       end
     end
   end

data/spec/lib/krikri/mapping_dsl/rdf_subjects_spec.rb

@@ -100,12 +100,28 @@ describe Krikri::MappingDSL::RdfSubjects do
         let(:array_value) { [value] }
       end
 
+      context 'with no values' do
+        let(:value) { [] }
+        let(:node) { RDF::Node.new }
+
+        before { allow(mapped).to receive(:rdf_subject).and_return(node) }
+
+        it 'gives the bnode subject' do
+          expect(subject.to_proc.call(mapped, '')).to eq node
+        end
+
+        it 'leaves the rdf_subject untouched' do
+          expect(mapped).not_to receive(:set_subject!)
+          subject.to_proc.call(mapped, '')
+        end
+      end
+
       context 'with too many values' do
         let(:value) { ['http://example.org/1', 'http://example.org/2'] }
 
         it 'raises an error' do
           expect { subject.to_proc.call(mapped, '') }
-            .to raise_error "URI must be set to a single value; got #{value}"
+            .to raise_error
         end
       end
     end

data/spec/lib/krikri/mapping_spec.rb

@@ -2,9 +2,22 @@ require 'spec_helper'
 
 describe Krikri::Mapping do
 
-  let(:record) { build(:oai_dc_record) }
+  let(:target_class) { double }
+  let(:parser) { double }
+  let(:parser_args) { [1,2,3] }
+
+  describe '#new' do
+    it 'accepts target class, parser, and parser arguments' do
+      expect(described_class.new(target_class, parser, *parser_args))
+        .to have_attributes(klass: target_class,
+                            parser: parser,
+                            parser_args: parser_args)
+    end
+  end
 
   describe '#process_record' do
+    let(:record) { build(:oai_dc_record) }
+
     it 'creates a DPLA::MAP record' do
       expect(subject.process_record(record)).to be_a DPLA::MAP::Aggregation
     end
@@ -15,6 +28,23 @@ describe Krikri::Mapping do
       expect(new_mapping.process_record(record)).to be_a klass
     end
 
+    context 'with parser' do
+      before do
+        target_instance = double
+        allow(target_class).to receive(:new).and_return(target_instance)
+        allow(target_instance).to receive(:my_property=).and_return('')
+        subject.my_property ''
+      end
+
+      subject { described_class.new(target_class, parser, *parser_args) }
+
+      it 'parses record before mapping' do
+        expect(parser)
+          .to receive(:parse).with(record, *parser_args).and_return(record)
+        subject.process_record(record)
+      end
+    end
+
     context 'with static properties' do
       before do
         subject.rightsStatement value

data/spec/models/activity_spec.rb

@@ -24,7 +24,7 @@ describe Krikri::Activity, type: :model do
     end
   end
 
-  describe 'start_time' do
+  describe '#start_time' do
     before do
       subject.set_start_time
     end
@@ -34,12 +34,39 @@ describe Krikri::Activity, type: :model do
     end
   end
 
-  describe 'end_time' do
+  describe '#end_time' do
     it 'raises an error if not started' do
       expect { subject.set_end_time }.to raise_error
     end
   end
 
+  describe '#ended?' do
+    context 'before completion' do
+      it 'returns false' do
+        expect(subject).not_to be_ended
+      end
+    end
+
+    context 'while running' do
+      before { subject.set_start_time }
+
+      it 'returns false' do
+        expect(subject).not_to be_ended
+      end
+    end
+
+    context 'after completion' do
+      before do
+        subject.set_start_time
+        subject.set_end_time
+      end
+
+      it 'returns true' do
+        expect(subject).to be_ended
+      end
+    end
+  end
+
   describe '#run' do
     it 'runs the given block' do
       expect { |b| subject.run(&b) }
@@ -52,6 +79,42 @@ describe Krikri::Activity, type: :model do
       Timecop.return    # come back to the present for future tests
       expect(subject).to have_duration_of(duration)
     end
+
+    context 'after first run' do
+      before do
+        subject.run { }
+      end
+
+      it 'sets end_time to nil before running' do
+        subject.run { expect(subject.end_time).to be_nil }
+      end
+    end
+
+    context 'with error' do
+      let(:error) { StandardError.new('my error') }
+
+      it 'logs errors' do
+        message = "Error performing Activity: #{subject.id}\nmy error"
+        expect(Rails.logger).to receive(:error).with(start_with(message))
+        begin
+          subject.run { raise error }
+        rescue
+        end
+      end
+
+      it 'rethrows error' do
+        expect { subject.run { raise error } }
+          .to raise_error StandardError
+      end
+
+      it 'sets end time' do
+        begin
+          subject.run { raise error }
+        rescue
+        end
+        expect(subject.end_time).to be_within(1.second).of(Time.now)
+      end
+    end
   end
 
   describe '#agent_instance' do

data/spec/support/shared_examples/parser.rb

@@ -10,10 +10,17 @@ shared_examples_for 'a parser' do
   end
 
   describe '#parse' do
+    let(:args) { [1, 2, 3] }
     it 'wraps a record in this parser' do
       expect(described_class.parse(record)).to be_a described_class
     end
 
+    it 'uses parser args' do
+      expect(described_class)
+        .to receive(:new).with(record, *args).and_return(:parsed)
+      expect(described_class.parse(record, *args)).to eq :parsed
+    end
+
     it 'returns the record if already parsed' do
       expect(described_class.parse(parser)).to eq parser
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: krikri
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Audrey Altman