rof 1.0.7 → 1.2.0

data/lib/rof/compare_rof.rb

@@ -3,90 +3,119 @@ require 'rdf/ntriples'
 require 'rdf/rdfxml'
 require 'rof/rdf_context'
 require 'rdf/isomorphic'
+require 'active_support/core_ext/array/wrap'
 
 module ROF
  class CompareRof
 
-    # compare fedora rof to bendo_rof
-    # return true in equivalent, false if not
-    def self.fedora_vs_bendo( fedora_rof, bendo_rof, output)
+    # Compare two ROF objects; we'll call one fedora_rof and the other bendo_rof
+    # @return 0 if no errors; otherwise there are errors
+    def self.fedora_vs_bendo(fedora_rof, bendo_rof, _output = nil, options = {})
+      new(Array.wrap(fedora_rof)[0], Array.wrap(bendo_rof)[0], options).error_count
+    end
 
-      error_count = 0
-      # dereferencing an array of one element with [0]. Oh, the horror of it.
-      error_count += compare_rights( fedora_rof[0], bendo_rof[0], output)
-      error_count += compare_rels_ext(fedora_rof[0], bendo_rof[0])
-      error_count += compare_metadata(fedora_rof[0], bendo_rof[0])
-      error_count += compare_everything_else(fedora_rof[0], bendo_rof[0], output)
-      error_count
+    def initialize(fedora, bendo, options = {})
+      @fedora = Array.wrap(fedora).first
+      @bendo = Array.wrap(bendo).first
+      @skip_rels_ext_context = options.fetch(:skip_rels_ext_context) { false }
+    end
+    attr_reader :fedora, :bendo
+
+    def error_count
+      @error_count = 0
+      @error_count += compare_rights
+      @error_count += compare_rels_ext
+      @error_count += compare_metadata
+      @error_count += compare_everything_else
+      @error_count
     end
 
     # do rights comparison
     # return 0 if the same, >0 if different
-    def self.compare_rights( fedora_rof, bendo_rof, output )
+    def compare_rights
 
       error_count =0
 
       # Use same comparison scheme on all rights
       [ 'read' , 'read-groups', 'edit', 'edit-groups', 'edit-users', 'embargo-date'].each do |attribute|
-        error_count += rights_equal(attribute, fedora_rof, bendo_rof)
+        error_count += rights_equal(attribute)
         break if error_count != 0
       end
 
       error_count
     end
 
-    # compare array or element for equivalence
-    def self.rights_equal(rights_attr, fedora, bendo)
-      f_rights = fedora.fetch('rights', {}).fetch(rights_attr, [])
-      b_rights = bendo.fetch('rights', {}).fetch(rights_attr, [])
+    private
 
-      f_rights = f_rights.sort if f_rights.respond_to?(:"sort")
-      b_rights = b_rights.sort if b_rights.respond_to?(:"sort")
+    # compare array or element for equivalence
+    def rights_equal(rights_attr)
+      f_rights = Array.wrap(fedora.fetch('rights', {}).fetch(rights_attr, [])).sort
+      b_rights = Array.wrap(bendo.fetch('rights', {}).fetch(rights_attr, [])).sort
 
       return 0 if f_rights == b_rights
       1
     end
 
+    public
+
     # convert RELS-EXT sections to RDF::graph and compater w/ rdf-isomorphic
-    def self.compare_rels_ext(fedora, bendo)
+    def compare_rels_ext
       error_count = 0
-      bendo_rdf = jsonld_to_rdf(bendo['rels-ext'], ROF::RelsExtRefContext)
-      fedora_rdf = jsonld_to_rdf(fedora['rels-ext'], ROF::RelsExtRefContext)
+      # Because Sipity's RELS-EXT context was out of whack, I need a switch to skip comparing
+      # the @context of the rels-ext document
+      bendo_rdf = jsonld_to_rdf(bendo.fetch('rels-ext', {}), ROF::RelsExtRefContext, @skip_rels_ext_context)
+      fedora_rdf = jsonld_to_rdf(fedora.fetch('rels-ext', {}), ROF::RelsExtRefContext, @skip_rels_ext_context)
       error_count +=1 if ! bendo_rdf.isomorphic_with? fedora_rdf
       error_count
     end
-    
-    def self.jsonld_to_rdf(doc, default_context)
-      doc["@context"] = default_context unless doc.has_key?("@context")
+
+    private
+
+    def jsonld_to_rdf(doc, default_context, skip_context = false)
+      if skip_context
+        doc.delete('@context')
+      else
+        doc["@context"] ||= default_context
+      end
       RDF::Graph.new << JSON::LD::API.toRdf(doc)
     end
 
+    public
+
     # convert metadata sections to RDF::graph and compater w/ rdf-isomorphic
-    def self.compare_metadata(fedora, bendo)
+    def compare_metadata
       error_count = 0
-      bendo_rdf = jsonld_to_rdf(bendo['metadata'], ROF::RdfContext)
-      fedora_rdf = jsonld_to_rdf(fedora['metadata'], ROF::RdfContext)
+      bendo_rdf = jsonld_to_rdf(bendo.fetch('metadata', {}), ROF::RdfContext)
+      fedora_rdf = jsonld_to_rdf(fedora.fetch('metadata', {}), ROF::RdfContext)
       error_count +=1 if ! bendo_rdf.isomorphic_with? fedora_rdf
       error_count
     end
 
     # compare what remains
-    def self.compare_everything_else( fedora, bendo, output)
+    def compare_everything_else
       error_count =0
-      fedora = remove_others(fedora)
-      bendo = remove_others(bendo)
-      # comparsion using builtin equivalency operation
-      error_count = 1 if bendo != fedora
+      exclude_keys = ['rights', 'rels-ext', 'metadata', 'thumbnail-file']
+      all_keys_to_check = (bendo.keys + fedora.keys - exclude_keys).uniq
+      all_keys_to_check.each do |key|
+        bendo_value = bendo.fetch(key, nil)
+        fedora_value = fedora.fetch(key, nil)
+        # Treat an empty hash and an empty array as equal
+        next if bendo_value.empty? && fedora_value.empty?
+        next if normalize_value(bendo_value) == normalize_value(fedora_value)
+        error_count += 1
+        break
+      end
       error_count
     end
 
-    # remove elements we've dealt with already
-    def self.remove_others( rof_object)
-      rof_object.delete('rights')
-      rof_object.delete('rels-ext')
-      rof_object.delete('metadata')
-      rof_object.delete('thumbnail-file')
-      rof_object
+    private
+
+    # Because sometimes we have carriage returns and line breaks but we really don't care
+    # @todo Do we care about line breaks?
+    def normalize_value(values)
+      Array.wrap(values).map do |value|
+        value.is_a?(String) ? value.gsub("\n", "") : value
+      end
     end
   end
 end

data/lib/rof/filter.rb

@@ -0,0 +1,21 @@
+module ROF
+  # A placeholder implementation for an ROF::Filter.
+  # @see ROF::Filters
+  class Filter
+    # @param [Hash] options - a hash with symbol keys; used to configure the instantiation of the filter
+    def initialize(options = {})
+    end
+
+    # Performs operations on the given obj_list. This can be things like:
+    #
+    # * Adding new keys to the inner Hash
+    # * Converting placeholder values with calculated values (@see ROF::Filters::Label)
+    # * Other changes
+    #
+    # @param [Array<Hash>] obj_list - An Array of Hash objects
+    # @return [Array<Hash>] a changed version of the given
+    def process(obj_list)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/rof/filters.rb

@@ -0,0 +1,38 @@
+Dir.glob(File.expand_path('../filters/*.rb', __FILE__)).each do |filename|
+  require filename
+end
+
+module ROF
+  # A container class for all ROF filters. What is an ROF filter? @see ROF::Filters.for
+  # @see ROF::Filter for abstract definition
+  module Filters
+    class UnknownFilterError < RuntimeError
+      def initialize(filter_name, available_filters)
+        super(%(Unable to find filter "#{filter_name}". Available filter names are: #{available_filters.inspect}))
+      end
+    end
+    AVAILABLE_FILTERS = {
+      "bendo" => ROF::Filters::Bendo,
+      "datestamp" => ROF::Filters::DateStamp,
+      "file-to-url" => ROF::Filters::FileToUrl,
+      "label" => ROF::Filters::Label,
+      "work" => ROF::Filters::Work,
+    }
+    # @api public
+    #
+    # @param [String] filter_name - the named filter you want to instantiate
+    # @param [Hash] options - a hash (with symbol keys) that is used for configuring the instantiating of the filter
+    # @return [ROF::Filter]
+    # @raise ROF::Filters::UnknownFilterError if the given filter name is not registered
+    # @see ./spec/support/an_rof_filter.rb
+    # @see ROF::Filter
+    def self.for(filter_name, options = {})
+      begin
+        filter = AVAILABLE_FILTERS.fetch(filter_name)
+      rescue KeyError
+        raise UnknownFilterError.new(filter_name, AVAILABLE_FILTERS.keys)
+      end
+      filter.new(options)
+    end
+  end
+end

data/lib/rof/filters/bendo.rb

@@ -1,30 +1,28 @@
-require 'date'
-
+require 'rof/filter'
 module ROF
   module Filters
 
     # If bendo server is set , add it into datasreams that contain an URl referencing bendo
-    #
-    class Bendo
-      def initialize(bendo=nil)
-        @bendo = bendo
+    class Bendo < ROF::Filter
+      def initialize(options = {})
+        @bendo = options.fetch(:bendo_info)
       end
 
-      def process(obj_list, _fname)
-
-        ends_meta = Regexp.new('(.+)-meta')
-
-        # for *-meta objects containing "URL", sub in bendo string if provided
-
+      # for *-meta objects containing "URL", sub in bendo string if provided
+      def process(obj_list)
+        # NOTE: This was refactored to short-circuit the loop. A side-effect is that the code
+        # is now returning the same object as was passed in. The previous behavior was that a
+        # new object_list was created via the #map! method.
+        return obj_list unless @bendo
+        key_name_ends_in_meta_regexp = Regexp.new('(.+)-meta')
         obj_list.map! do |obj|
-          obj.map do |name, value|
-            if name =~ ends_meta
-              if obj[name]["URL"] && @bendo
-                obj[name]["URL"] = obj[name]["URL"].sub("bendo:",@bendo)
+          obj.map do |key_name, value|
+            if key_name =~ key_name_ends_in_meta_regexp
+              if obj[key_name]["URL"]
+                obj[key_name]["URL"] = obj[key_name]["URL"].sub("bendo:", @bendo)
               end
             end
           end
-          # print object
           obj
         end
       end

data/lib/rof/filters/date_stamp.rb

@@ -1,3 +1,4 @@
+require 'rof/filter'
 require 'date'
 
 module ROF
@@ -5,9 +6,9 @@ module ROF
     # Set the upload date to be the date given, provided it doesn't already exist.
     # Also set the date modified to be the date given.
     # If not given, the date used defaults to the local time on the computer.
-    class DateStamp
-      def initialize(date=nil)
-        @today = date || Date::today
+    class DateStamp < ROF::Filter
+      def initialize(options = {})
+        @today = options.fetch(:as_of) { Date::today }
         @today_s = if @today.is_a?(Date)
                      @today.strftime('%FZ')
                    else
@@ -15,7 +16,7 @@ module ROF
                    end
       end
 
-      def process(obj_list, _fname)
+      def process(obj_list)
         obj_list.map! do |obj|
           if obj["metadata"].nil?
             obj["metadata"] = {

data/lib/rof/filters/file_to_url.rb

@@ -1,3 +1,5 @@
+require 'rof/filter'
+
 module ROF
   module Filters
     # Convert any content datastream files into a bendo URL, and alter the rof
@@ -5,11 +7,11 @@ module ROF
     # will only exist for items having a bendo-item id set. The URL generated
     # supposes the file keeps the same relative path the item originally had in
     # the rof file.
-    class FileToUrl
-      def initialize()
+    class FileToUrl < ROF::Filter
+      def initialize(options = {})
       end
 
-      def process(obj_list, _fname)
+      def process(obj_list)
         obj_list.map! do |obj|
           bendo_item = obj['bendo-item']
           content_file = obj['content-file']

data/lib/rof/filters/label.rb

@@ -1,3 +1,4 @@
+require 'rof/filter'
 require 'noids_client'
 
 module ROF
@@ -5,7 +6,7 @@ module ROF
     # Class Label locates in-place labels of the form
     # "$(label_name)" in the ROF file, assigns each
     # label a pid, then replaces the label with that pid.
-    class Label
+    class Label < ROF::Filter
       class MissingLabel < RuntimeError
       end
 
@@ -21,14 +22,15 @@ module ROF
       # Use :id_list to pass in a ruby object responding to #shift and #empty? to generate
       # ids. This is usually a list, to facilitate testing.
       #
-      # If prefix is not nil, then "#{prefix}:" is prepended to
+      # If prefix is not nil, then "<prefix>:" is prepended to
       # every identifier.
-      def initialize(prefix, options)
+      def initialize(options = {})
+        prefix = options.fetch(:prefix, nil)
         @id_list =  case
                     when options[:id_list]
                       options[:id_list]
                     when options[:noid_server]
-                      NoidsPool.new(options[:noid_server], options[:pool_name])
+                      NoidsPool.new(options[:noid_server], options.fetch(:pool_name))
                     else
                       raise NoPool
                     end
@@ -39,7 +41,7 @@ module ROF
 
       # mutate obj_list by assigning labels and resolving labels where needed
       # Every fobject will be assigned an pid and a bendo_item
-      def process(obj_list, _fname)
+      def process(obj_list)
         labels = {}
 
         # Use two passes. First assign ids, and then resolve labels
@@ -136,8 +138,8 @@ module ROF
 
       # Encapsulates connection to Noids Server
       class NoidsPool
-        def initialize(noids_server, pool_name)
-          @pool = NoidsClient::Connection.new(noids_server).get_pool(pool_name)
+        def initialize(noids_server_url, pool_name)
+          @pool = NoidsClient::Connection.new(noids_server_url).get_pool(pool_name)
         end
 
         def shift

data/lib/rof/filters/work.rb

@@ -1,5 +1,5 @@
 require 'mime-types'
-
+require 'rof/filter'
 module ROF
   module Filters
     # Expand objects of type "Work(-(.+))?" into a
@@ -8,17 +8,19 @@ module ROF
     # adds a depositor
     # turns original object into an fobject/$1
     # and copies the access to each fobject.
-    class Work
+    class Work < ROF::Filter
       class NoFile < RuntimeError
       end
 
-      def initialize
+      def initialize(options = {})
+        @file_name = options.fetch(:file_name)
         @utility = ROF::Utility.new
       end
+      attr_reader :file_name
 
       # wade through object list
-      def process(obj_list, filename)
-        @utility.set_workdir(filename)
+      def process(obj_list)
+        @utility.set_workdir(file_name)
         obj_list.map! { |x| process_one_work(x) }
         obj_list.flatten!
       end

data/lib/rof/ingest.rb

@@ -20,6 +20,11 @@ module ROF
   # Otherwise fedora is a Rubydora::Reporitory object (for now...)
   # Returns a list of ingested datastreams, if everything is okay.
   # Otherwise raises an exception depending on the error.
+  # @param [Hash] item - has string based keys
+  # @param [#find_or_initialize, nil] fedora - when nil then we verify that item is in the proper format; otherwise we ingest or update
+  # @param [Array] search_paths
+  # @param [nil, String] bendo - when nil, no attempts to substitute the bendo URL
+  # @return [Array<String>] List of ingested data streams; Implies everything ingested ok.
   def self.Ingest(item, fedora=nil, search_paths=[], bendo=nil)
     raise NotFobjectError if item["type"] != "fobject"
     raise TooManyIdentitiesError if item.key?("id") && item.key?("pid")

data/lib/rof/osf_context.rb

@@ -1,5 +1,4 @@
 module ROF
-
   OsfPrefixList = {
     'dcterms' => 'http://purl.org/dc/terms/',
     'osf-model' => 'http://www.dataconservancy.org/osf-business-object-model#'
@@ -14,6 +13,7 @@ module ROF
     'hasContributor' => 'http://www.dataconservancy.org/osf-business-object-model#hasContributor',
     'isBibliographic' => 'http://www.dataconservancy.org/osf-business-object-model#isBibliographic',
     'hasFullName' => 'http://www.dataconservancy.org/osf-business-object-model#hasFullName',
-    'hasUser' => 'http://www.dataconservancy.org/osf-business-object-model#hasUser'
+    'hasUser' => 'http://www.dataconservancy.org/osf-business-object-model#hasUser',
+    'registeredFrom' => 'http://www.dataconservancy.org/osf-business-object-model#registeredFrom'
   }.freeze
 end

data/lib/rof/rdf_context.rb

@@ -11,6 +11,7 @@ module ROF
     'rdfs' => 'http://www.w3.org/2000/01/rdf-schema#',
     'ths' => 'http://id.loc.gov/vocabulary/relators/',
     'vracore' => 'http://purl.org/vra/',
+    'pav' => 'http://purl.org/pav/',
 
     'dc:dateSubmitted' => {
       '@type' => 'http://www.w3.org/2001/XMLSchema#date'
@@ -26,6 +27,7 @@ module ROF
   RelsExtRefContext = {
     '@vocab' => 'info:fedora/fedora-system:def/relations-external#',
     'fedora-model' => 'info:fedora/fedora-system:def/model#',
+    'pav' => 'http://purl.org/pav/',
     'hydra' => 'http://projecthydra.org/ns/relations#',
     'hasModel' => { '@id' => 'fedora-model:hasModel', '@type' => '@id' },
     'hasEditor' => { '@id' => 'hydra:hasEditor', '@type' => '@id' },

data/lib/rof/translator.rb

@@ -0,0 +1,18 @@
+module ROF
+  # A translator is responsible for converting the input into the given output.
+  # The input and output need not be the same type (e.g. CSV to Hash)
+  #
+  # @todo This is a work in progress; I will be normalizing the .call behavior.
+  #
+  # @see ROF::Translators::CsvToRof
+  # @see ROF::Translators::FedoraToRof
+  # @see ROF::Translators::OsfToRof
+  class Translator
+    # @param [Object] input - the thing that will be processed
+    # @param [Hash] config - a Hash with symbol keys
+    # @return [Hash] often times a Hash that can be serialized into JSON
+    def self.call(input, config = {})
+      raise NotImplementedError
+    end
+  end
+end