oai 1.0.1 → 1.2.1

data/lib/oai/provider/model.rb

@@ -29,7 +29,7 @@ module OAI::Provider
   # see the ResumptionToken class for more details.
   #
   class Model
-    attr_reader :timestamp_field, :identifier_field
+    attr_reader :timestamp_field, :identifier_field, :limit
 
     def initialize(limit = nil, timestamp_field = 'updated_at', identifier_field = 'id')
       @limit = limit

data/lib/oai/provider/response/list_records.rb

@@ -2,6 +2,18 @@ module OAI::Provider::Response
 
   class ListRecords < RecordResponse
     required_parameters :metadata_prefix
+    
+    def valid?
+      super && matching_granularity?
+    end
+    
+    def matching_granularity?
+      if options[:from].nil? == false && options[:until].nil? == false && options[:from].class.name != options[:until].class.name
+        raise OAI::ArgumentException.new, "The 'from' and 'until' options specified must have the same granularity"
+      else
+        true
+      end
+    end
 
     def to_xml
       result = provider.model.find(:all, options)

data/lib/oai/provider/response/record_response.rb

@@ -3,8 +3,26 @@ module OAI::Provider::Response
     def self.inherited(klass)
       klass.valid_parameters    :metadata_prefix, :from, :until, :set
       klass.default_parameters  :metadata_prefix => "oai_dc",
-           :from => Proc.new {|x| Time.parse(x.provider.model.earliest.to_s) }, #-- OAI 2.0 hack - UTC
-           :until => Proc.new {|x| Time.parse(x.provider.model.latest.to_s) }   #-- OAI 2.0 hack - UTC
+           :from => method(:default_from).to_proc,
+           :until => method(:default_until).to_proc
+    end
+
+    def self.default_from(response)
+      value = Time.parse(response.provider.model.earliest.to_s).utc
+      if response.options[:until]
+        u = parse_date(response.options[:until])
+        value = value.to_date if u.is_a? Date
+      end
+      value
+    end
+
+    def self.default_until(response)
+      value = Time.parse(response.provider.model.latest.to_s).utc
+      if response.options[:from]
+        f = parse_date(response.options[:from])
+        value = value.to_date if f.is_a? Date
+      end
+      value
     end
 
     # emit record header

data/lib/oai/provider/response.rb

@@ -40,6 +40,21 @@ module OAI
         yield @builder
       end
     end
+
+    protected
+
+    def self.parse_date(value)
+      return value if value.respond_to?(:strftime)
+
+      if value[-1] == "Z"
+        Time.strptime(value, "%Y-%m-%dT%H:%M:%S%Z").utc
+      else
+        Date.strptime(value, "%Y-%m-%d")
+      end
+    rescue ArgumentError => e
+      raise OAI::ArgumentException.new, "unparsable date: '#{value}'"
+    end
+
     private
 
     def header
@@ -89,12 +104,7 @@ module OAI
     end
 
     def parse_date(value)
-      return value if value.respond_to?(:strftime)
-
-      Date.parse(value) # This will raise an exception for badly formatted dates
-      Time.parse(value).utc #  -- UTC Bug fix hack 8/08 not in core
-    rescue
-      raise OAI::ArgumentException.new, "unparsable date: '#{value}'"
+      self.class.parse_date(value)
     end
 
     def internalize(hash = {})

data/lib/oai/provider/resumption_token.rb

@@ -1,5 +1,4 @@
 require 'time'
-require 'enumerator'
 require File.dirname(__FILE__) + "/partial_result"
 
 module OAI::Provider
@@ -37,7 +36,7 @@ module OAI::Provider
     attr_reader :prefix, :set, :from, :until, :last, :last_str, :expiration, :total
 
     # parses a token string and returns a ResumptionToken
-    def self.parse(token_string)
+    def self.parse(token_string, expiration = nil, total = nil)
       begin
         options = {}
         matches = /(.+):([^ :]+)$/.match(token_string)
@@ -55,7 +54,7 @@ module OAI::Provider
             options[:until] = Time.parse(part.sub(/^u\(/, '').sub(/\)$/, '')).localtime
           end
         end
-        self.new(options)
+        self.new(options, expiration, total)
       rescue => err
         raise OAI::ResumptionTokenException.new
       end
@@ -123,10 +122,24 @@ module OAI::Provider
     end
 
     def encode_conditions
+      return "" if last_str.nil? || last_str.to_s.strip.eql?("")
+
       encoded_token = @prefix.to_s.dup
       encoded_token << ".s(#{set})" if set
-      encoded_token << ".f(#{self.from.utc.xmlschema})" if self.from
-      encoded_token << ".u(#{self.until.utc.xmlschema})" if self.until
+      if self.from
+        if self.from.respond_to?(:utc)
+          encoded_token << ".f(#{self.from.utc.xmlschema})"
+        else
+          encoded_token << ".f(#{self.from.xmlschema})"
+        end
+      end
+      if self.until
+        if self.until.respond_to?(:utc)
+          encoded_token << ".u(#{self.until.utc.xmlschema})" 
+        else
+          encoded_token << ".u(#{self.until.xmlschema})" 
+        end
+      end
       encoded_token << ":#{last_str}"
     end
 

data/lib/oai/provider.rb

@@ -139,6 +139,35 @@ end
 #
 # Special thanks to Jose Hales-Garcia for this solution.
 #
+# ### Leverage the Provider instance
+#
+# The traditional implementation of the OAI::Provider would pass the OAI::Provider
+# class to the different resposnes. This made it hard to inject context into a
+# common provider. Consider that we might have different request headers that
+# change the scope of the OAI::Provider queries.
+#
+# ```ruby
+# class InstanceProvider
+#   def initialize(options = {})
+#     super({ :provider_context => :instance_based })
+#     @controller = options.fetch(:controller)
+#   end
+#   attr_reader :controller
+# end
+#
+# class OaiController < ApplicationController
+#   def index
+#     provider = InstanceProvider.new({ :controller => self })
+#     request_body =  provider.process_request(oai_params.to_h)
+#     render :body => request_body, :content_type => 'text/xml'
+#   end
+# ```
+#
+# In the above example, the underlying response object will now receive an
+# instance of the InstanceProvider. Without the `super({ :provider_context => :instance_based })`
+# the response objects would have received the class InstanceProvider as the
+# given provider.
+#
 # ## Supporting custom metadata formats
 #
 # See {OAI::MetadataFormat} for details.
@@ -292,39 +321,132 @@ module OAI::Provider
 
     Base.register_format(OAI::Provider::Metadata::DublinCore.instance)
 
+    PROVIDER_CONTEXTS = {
+      :class_based => :class_based,
+      :instance_based => :instance_based
+    }
+
+    def initialize(options = {})
+      provider_context = options.fetch(:provider_context) { :class_based }
+      @provider_context = PROVIDER_CONTEXTS.fetch(provider_context)
+    end
+
+    # @note These are the accessor methods on the class. If you need to overwrite
+    # them on the instance level you can do that. However, an instance of this
+    # class won't be used unless you initialize with:
+    # { :provider_context => :instance_based }
+    attr_writer :name, :url, :prefix, :email, :delete_support, :granularity, :model, :identifier, :description
+
+    # The traditional interaction of a Provider has been to:
+    #
+    # 1) Assign attributes to the Provider class
+    # 2) Instantiate the Provider class
+    # 3) Call response instance methods for theProvider which pass
+    #    the Provider class and not the instance.
+    #
+    # The above behavior continues unless you initialize the Provider with
+    # { :provider_context => :instance_based }. If you do that, then the
+    # Provider behavior will be:
+    #
+    # 1) Assign attributes to Provider class
+    # 2) Instantiate the Provider class
+    # 3) Call response instance methods for theProvider which pass an
+    #    instance of the Provider to those response objects.
+    #    a) The instance will mirror all of the assigned Provider class
+    #       attributes, but allows for overriding and extending on a
+    #       case by case basis.
+    # (Dear reader, please note the second behavior is something most
+    # of us would've assumed to be the case, but for historic now lost
+    # reasons is not the case.)
+    def provider_context
+      if @provider_context == :instance_based
+        self
+      else
+        self.class
+      end
+    end
+
+    def format_supported?(*args)
+      self.class.format_supported?(*args)
+    end
+
+    def format(*args)
+      self.class.format(*args)
+    end
+
+    def formats
+      self.class.formats
+    end
+
+    def name
+      @name || self.class.name
+    end
+
+    def url
+      @url || self.class.url
+    end
+
+    def prefix
+      @prefix || self.class.prefix
+    end
+
+    def email
+      @email || self.class.email
+    end
+
+    def delete_support
+      @delete_support || self.class.delete_support
+    end
+
+    def granularity
+      @granularity || self.class.granularity
+    end
+
+    def model
+      @model || self.class.model
+    end
+
+    def identifier
+      @identifier || self.class.identifier
+    end
+
+    def description
+      @description || self.class.description
+    end
+
     # Equivalent to '&verb=Identify', returns information about the repository
     def identify(options = {})
-      Response::Identify.new(self.class, options).to_xml
+      Response::Identify.new(provider_context, options).to_xml
     end
 
     # Equivalent to '&verb=ListSets', returns a list of sets that are supported
     # by the repository or an error if sets are not supported.
     def list_sets(options = {})
-      Response::ListSets.new(self.class, options).to_xml
+      Response::ListSets.new(provider_context, options).to_xml
     end
 
     # Equivalent to '&verb=ListMetadataFormats', returns a list of metadata formats
     # supported by the repository.
     def list_metadata_formats(options = {})
-      Response::ListMetadataFormats.new(self.class, options).to_xml
+      Response::ListMetadataFormats.new(provider_context, options).to_xml
     end
 
     # Equivalent to '&verb=ListIdentifiers', returns a list of record headers that
     # meet the supplied criteria.
     def list_identifiers(options = {})
-      Response::ListIdentifiers.new(self.class, options).to_xml
+      Response::ListIdentifiers.new(provider_context, options).to_xml
     end
 
     # Equivalent to '&verb=ListRecords', returns a list of records that meet the
     # supplied criteria.
     def list_records(options = {})
-      Response::ListRecords.new(self.class, options).to_xml
+      Response::ListRecords.new(provider_context, options).to_xml
     end
 
     # Equivalent to '&verb=GetRecord', returns a record matching the required
     # :identifier option
     def get_record(options = {})
-      Response::GetRecord.new(self.class, options).to_xml
+      Response::GetRecord.new(provider_context, options).to_xml
     end
 
     #  xml_response = process_verb('ListRecords', :from => 'October 1, 2005',
@@ -336,7 +458,7 @@ module OAI::Provider
       begin
 
         # Allow the request to pass in a url
-        self.class.url = params['url'] ? params.delete('url') : self.class.url
+        provider_context.url = params['url'] ? params.delete('url') : self.url
 
         verb = params.delete('verb') || params.delete(:verb)
 

data/test/activerecord_provider/database/0001_oaipmh_tables.rb

@@ -10,6 +10,12 @@ class OaipmhTables < ActiveRecord::Migration[5.2]
       t.column :oai_token_id, :integer, :null => false
     end
 
+    create_table :dc_langs do |t|
+      t.column :name,           :string
+      t.column :updated_at,     :datetime
+      t.column :created_at,     :datetime
+    end
+
     dc_fields = proc do |t|
       t.column  :title,         :string
       t.column  :creator,       :string
@@ -21,7 +27,7 @@ class OaipmhTables < ActiveRecord::Migration[5.2]
       t.column  :type,          :string
       t.column  :format,        :string
       t.column  :source,        :string
-      t.column  :language,      :string
+      t.column  :dc_lang_id,    :integer
       t.column  :relation,      :string
       t.column  :coverage,      :string
       t.column  :rights,        :string

data/test/activerecord_provider/helpers/providers.rb

@@ -56,11 +56,13 @@ class ARLoader
       File.join(File.dirname(__FILE__), '..', 'fixtures', 'dc.yml')
     )
     fixtures.keys.sort.each do |key|
-      DCField.create(fixtures[key])
+      lang = DCLang.create(name: fixtures[key].delete('language'))
+      DCField.create(fixtures[key].merge(dc_lang: lang))
     end
   end
 
   def self.unload
     DCField.delete_all
+    DCLang.delete_all
   end
 end

data/test/activerecord_provider/helpers/transactional_test_case.rb

@@ -19,7 +19,8 @@ class TransactionalTestCase < Test::Unit::TestCase
     )
     disable_logging do
       fixtures.keys.sort.each do |key|
-        DCField.create(fixtures[key])
+        lang = DCLang.create(name: fixtures[key].delete('language'))
+        DCField.create(fixtures[key].merge(dc_lang: lang))
       end
     end
   end

data/test/activerecord_provider/models/dc_field.rb

@@ -4,4 +4,12 @@ class DCField < ActiveRecord::Base
     :join_table => "dc_fields_dc_sets",
     :foreign_key => "dc_field_id",
     :class_name => "DCSet"
+
+  belongs_to :dc_lang, class_name: "DCLang", optional: true
+
+  default_scope -> { left_outer_joins(:dc_lang) }
+
+  def language
+    dc_lang&.name
+  end
 end

data/test/activerecord_provider/models/dc_lang.rb

@@ -0,0 +1,3 @@
+class DCLang < ActiveRecord::Base
+  has_many :dc_fields
+end

data/test/activerecord_provider/models/exclusive_set_dc_field.rb

@@ -8,4 +8,10 @@ class ExclusiveSetDCField < ActiveRecord::Base
     end
   end
 
+  belongs_to :dc_lang, class_name: "DCLang", optional: true
+
+  def language
+    dc_lang&.name
+  end
+
 end

data/test/activerecord_provider/tc_activerecord_wrapper.rb

@@ -0,0 +1,63 @@
+require 'test_helper_ar_provider'
+
+class ActiveRecordWrapperTest < TransactionalTestCase
+  def test_sql_conditions_from_date
+    input = "2005-12-25"
+    expected = input.dup
+    sql_template, sql_opts = sql_conditions(from: input)
+    assert_equal "dc_fields.updated_at >= :from", sql_template
+    assert_equal expected, sql_opts[:from]
+    sql_template, sql_opts = sql_conditions(from: Date.strptime(input, "%Y-%m-%d"))
+    assert_equal "dc_fields.updated_at >= :from", sql_template
+    assert_equal expected, sql_opts[:from]
+  end
+
+  def test_sql_conditions_from_time
+    input = "2005-12-25T00:00:00Z"
+    expected = "2005-12-25 00:00:00"
+    sql_template, sql_opts = sql_conditions(from: input)
+    assert_equal "dc_fields.updated_at >= :from", sql_template
+    assert_equal expected, sql_opts[:from]
+    sql_template, sql_opts = sql_conditions(from: Time.strptime(input, "%Y-%m-%dT%H:%M:%S%Z"))
+    assert_equal "dc_fields.updated_at >= :from", sql_template
+    assert_equal expected, sql_opts[:from]
+  end
+
+  def test_sql_conditions_until_date
+    input = "2005-12-25"
+    expected = "2005-12-26"
+    sql_template, sql_opts = sql_conditions(until: input)
+    assert_equal "dc_fields.updated_at < :until", sql_template
+    assert_equal expected, sql_opts[:until]
+    sql_template, sql_opts = sql_conditions(until: Date.strptime(input, "%Y-%m-%d"))
+    assert_equal "dc_fields.updated_at < :until", sql_template
+    assert_equal expected, sql_opts[:until]
+  end
+
+  def test_sql_conditions_until_time
+    input = "2005-12-25T00:00:00Z"
+    expected = "2005-12-25 00:00:01"
+    sql_template, sql_opts = sql_conditions(until: input)
+    assert_equal "dc_fields.updated_at < :until", sql_template
+    assert_equal expected, sql_opts[:until]
+    sql_template, sql_opts = sql_conditions(until: Time.strptime(input, "%Y-%m-%dT%H:%M:%S%Z"))
+    assert_equal "dc_fields.updated_at < :until", sql_template
+    assert_equal expected, sql_opts[:until]
+  end
+
+  def test_sql_conditions_both
+    input = "2005-12-25"
+    sql_template, sql_opts = sql_conditions(from: input, until: input)
+    assert_equal "dc_fields.updated_at >= :from AND dc_fields.updated_at < :until", sql_template
+  end
+
+  def setup
+    @wrapper = OAI::Provider::ActiveRecordWrapper.new(DCField)
+  end
+
+  def sql_conditions(opts)
+    @wrapper.send :sql_conditions, opts
+  end
+end
+
+

data/test/activerecord_provider/tc_ar_provider.rb

@@ -81,30 +81,30 @@ class ActiveRecordProviderTest < TransactionalTestCase
 
   def test_from
     first_id = DCField.order("id asc").first.id
-    DCField.where("id < #{first_id + 90}").update_all(updated_at: Time.parse("January 1 2005"))
+    DCField.where("dc_fields.id < #{first_id + 90}").update_all(updated_at: Time.parse("January 1 2005"))
 
-    DCField.where("id < #{first_id + 10}").update_all(updated_at: Time.parse("June 1 2005"))
+    DCField.where("dc_fields.id < #{first_id + 10}").update_all(updated_at: Time.parse("June 1 2005"))
 
 
-    from_param = Time.parse("January 1 2006")
+    from_param = Time.parse("January 1 2006").getutc.iso8601
 
     doc = REXML::Document.new(
       @provider.list_records(
         :metadata_prefix => 'oai_dc', :from => from_param)
     )
-    assert_equal DCField.where(["updated_at >= ?", from_param]).size,
+    assert_equal DCField.where(["dc_fields.updated_at >= ?", from_param]).size,
       doc.elements['OAI-PMH/ListRecords'].size
 
     doc = REXML::Document.new(
       @provider.list_records(
-        :metadata_prefix => 'oai_dc', :from => Time.parse("May 30 2005"))
+        :metadata_prefix => 'oai_dc', :from => Time.parse("May 30 2005").getutc.iso8601)
     )
     assert_equal 20, doc.elements['OAI-PMH/ListRecords'].to_a.size
   end
 
   def test_until
-    first_id = DCField.order("id asc").first.id
-    DCField.where("id < #{first_id + 10}").update_all(updated_at: Time.parse("June 1 2005"))
+    first_id = DCField.order(id: :asc).first.id
+    DCField.where("dc_fields.id < ?", first_id + 10).update_all(updated_at: Time.parse("June 1 2005"))
 
     doc = REXML::Document.new(
       @provider.list_records(
@@ -114,19 +114,46 @@ class ActiveRecordProviderTest < TransactionalTestCase
   end
 
   def test_from_and_until
-    first_id = DCField.order("id asc").first.id
+    first_id = DCField.order(id: :asc).first.id
     DCField.update_all(updated_at: Time.parse("June 1 2005"))
-    DCField.where("id < #{first_id + 50}").update_all(updated_at: Time.parse("June 15 2005"))
-    DCField.where("id < #{first_id + 10}").update_all(updated_at: Time.parse("June 30 2005"))
+    DCField.where("dc_fields.id < ?", first_id + 50).update_all(updated_at: Time.parse("June 15 2005"))
+    DCField.where("dc_fields.id < ?", first_id + 10).update_all(updated_at: Time.parse("June 30 2005"))
 
     doc = REXML::Document.new(
       @provider.list_records(
         :metadata_prefix => 'oai_dc',
-        :from => Time.parse("June 3 2005"),
-        :until => Time.parse("June 16 2005"))
+        :from => Time.parse("June 3 2005").getutc.iso8601,
+        :until => Time.parse("June 16 2005").getutc.iso8601)
       )
     assert_equal 40, doc.elements['OAI-PMH/ListRecords'].to_a.size
   end
+  
+  def test_bad_until_raises_exception
+    DCField.order(id: :asc).limit(10).update_all(updated_at: 1.year.ago)
+    DCField.order(id: :desc).limit(10).update_all(updated_at: 1.year.from_now)
+    badTimes = [
+      'junk',
+      'February 92nd, 2015']
+    badTimes.each do |time|
+      assert_raise(OAI::ArgumentException) do
+        @provider.list_records(:metadata_prefix => 'oai_dc', :until => time)
+      end
+    end
+  end
+  
+  def test_bad_from_raises_exception
+    DCField.order(id: :asc).limit(10).update_all(updated_at: 1.year.ago)
+    DCField.order(id: :desc).limit(10).update_all(updated_at: 1.year.from_now)
+    
+    badTimes = [
+      'junk',
+      'February 92nd, 2015']
+    badTimes.each do |time|
+      assert_raise(OAI::ArgumentException) do
+        @provider.list_records(:metadata_prefix => 'oai_dc', :from => time)
+      end
+    end
+  end
 
   def test_handles_empty_collections
     DCField.delete_all
@@ -142,6 +169,21 @@ class ActiveRecordProviderTest < TransactionalTestCase
       REXML::Document.new(@provider.list_records(:metadata_prefix => 'oai_dc'))
     end
   end
+  
+  def test_bad_id_raises_exception
+    badIdentifiers = [
+      'invalid"id',
+      'oai:test/5000',
+      'oai:test/-1',
+      'oai:test/one',
+      'oai:test/\\$1\1!']
+    badIdentifiers.each do |id|
+      assert_raise(OAI::IdException) do
+        @provider.get_record(:identifier => id, :metadata_prefix => 'oai_dc')
+      end
+    end
+  end
+  
 
   def setup
     @provider = ARProvider.new
@@ -149,18 +191,4 @@ class ActiveRecordProviderTest < TransactionalTestCase
 
 end
 
-class ActiveRecordProviderTimezoneTest < ActiveRecordProviderTest
-
-  def setup
-    require 'active_record'
-    ActiveRecord::Base.default_timezone = :utc
-    super
-  end
 
-  def teardown
-    require 'active_record'
-    ActiveRecord::Base.default_timezone = :local
-    super
-  end
-
-end

data/test/activerecord_provider/tc_ar_sets_provider.rb

@@ -51,22 +51,22 @@ class ActiveRecordSetProviderTest < TransactionalTestCase
     set_ab = DCSet.create(:name => "Set A:B", :spec => "A:B")
 
     next_id = 0
-    DCField.limit(10).order("id asc").each do |record|
+    DCField.limit(10).order(id: :asc).each do |record|
       set_a.dc_fields << record
       next_id = record.id
     end
 
-    DCField.where("id > #{next_id}").limit(10).order("id asc").each do |record|
+    DCField.where("dc_fields.id > ?", next_id).limit(10).order(id: :asc).each do |record|
       set_b.dc_fields << record
       next_id = record.id
     end
 
-    DCField.where("id > #{next_id}").limit(10).order("id asc").each do |record|
+    DCField.where("dc_fields.id > ?", next_id).limit(10).order(id: :asc).each do |record|
       set_ab.dc_fields << record
       next_id = record.id
     end
 
-    DCField.where("id > #{next_id}").limit(10).order("id asc").each do |record|
+    DCField.where("dc_fields.id > ?", next_id).limit(10).order(id: :asc).each do |record|
       set_a.dc_fields << record
       set_c.dc_fields << record
       next_id = record.id
@@ -117,25 +117,25 @@ class ActiveRecordExclusiveSetsProviderTest < TransactionalTestCase
   def define_sets
     next_id = 0
 
-    ExclusiveSetDCField.limit(10).order("id asc").each do |record|
+    ExclusiveSetDCField.limit(10).order(id: :asc).each do |record|
       record.set = "A"
       record.save!
       next_id = record.id
     end
 
-    ExclusiveSetDCField.where("id > #{next_id}").limit(10).order("id asc").each do |record|
+    ExclusiveSetDCField.where("id > ?", next_id).limit(10).order(id: :asc).each do |record|
       record.set = "B"
       record.save!
       next_id = record.id
     end
 
-    ExclusiveSetDCField.where("id > #{next_id}").limit(10).order("id asc").each do |record|
+    ExclusiveSetDCField.where("id > ?", next_id).limit(10).order(id: :asc).each do |record|
       record.set = "A:B"
       record.save!
       next_id = record.id
     end
 
-    ExclusiveSetDCField.where("id > #{next_id}").limit(10).order("id asc").each do |record|
+    ExclusiveSetDCField.where("id > ?", next_id).limit(10).order(id: :asc).each do |record|
       record.set = "A"
       record.save!
       next_id = record.id
@@ -150,7 +150,8 @@ class ActiveRecordExclusiveSetsProviderTest < TransactionalTestCase
     )
     disable_logging do
       fixtures.keys.sort.each do |key|
-        ExclusiveSetDCField.create(fixtures[key])
+        lang = DCLang.create(name: fixtures[key].delete('language'))
+        ExclusiveSetDCField.create(fixtures[key].merge(dc_lang: lang))
       end
     end
   end