oai 1.0.0 → 1.2.0

data/lib/oai/provider/model/activerecord_wrapper.rb

@@ -32,12 +32,12 @@ module OAI::Provider
     end
 
     def earliest
-      earliest_obj = model.order("#{timestamp_field} asc").first
+      earliest_obj = model.order("#{model.base_class.table_name}.#{timestamp_field} asc").first
       earliest_obj.nil? ? Time.at(0) : earliest_obj.send(timestamp_field)
     end
 
     def latest
-      latest_obj = model.order("#{timestamp_field} desc").first
+      latest_obj = model.order("#{model.base_class.table_name}.#{timestamp_field} desc").first
       latest_obj.nil? ? Time.now : latest_obj.send(timestamp_field)
     end
     # A model class is expected to provide a method Model.sets that
@@ -61,7 +61,7 @@ module OAI::Provider
           find_scope.where(conditions)
         end
       else
-        find_scope.where(conditions).find_by!(identifier_field => selector)
+        find_scope.where(conditions).where(identifier_field => selector).first
       end
     end
 
@@ -129,15 +129,7 @@ module OAI::Provider
       raise OAI::ResumptionTokenException.new unless @limit
 
       token = ResumptionToken.parse(token_string)
-      total = find_scope.where(token_conditions(token)).count
-
-      if @limit < total
-        select_partial(find_scope, token)
-      else # end of result set
-        find_scope.where(token_conditions(token))
-          .limit(@limit)
-          .order("#{identifier_field} asc")
-      end
+      select_partial(find_scope, token)
     end
 
     # select a subset of the result set, and return it with a
@@ -145,10 +137,12 @@ module OAI::Provider
     def select_partial(find_scope, token)
       records = find_scope.where(token_conditions(token))
         .limit(@limit)
-        .order("#{identifier_field} asc")
+        .order("#{model.base_class.table_name}.#{identifier_field} asc")
       raise OAI::ResumptionTokenException.new unless records
-      offset = records.last.send(identifier_field)
 
+      total = find_scope.where(token_conditions(token)).count
+      # token offset should be nil if this is the last set
+      offset = (@limit >= total) ? nil : records.last.send(identifier_field)
       PartialResult.new(records, token.next(offset))
     end
 
@@ -159,13 +153,13 @@ module OAI::Provider
     # the last 'id' of the previous set is used as the
     # filter to the next set.
     def token_conditions(token)
-      last = token.last
+      last_id = token.last_str
       sql = sql_conditions token.to_conditions_hash
 
-      return sql if 0 == last
+      return sql if "0" == last_id
       # Now add last id constraint
-      sql.first << " AND #{identifier_field} > :id"
-      sql.last[:id] = last
+      sql.first << " AND #{model.base_class.table_name}.#{identifier_field} > :id"
+      sql.last[:id] = last_id
 
       return sql
     end
@@ -175,27 +169,49 @@ module OAI::Provider
       sql = []
       esc_values = {}
       if opts.has_key?(:from)
-        sql << "#{timestamp_field} >= :from"
+        sql << "#{model.base_class.table_name}.#{timestamp_field} >= :from"
         esc_values[:from] = parse_to_local(opts[:from])
       end
       if opts.has_key?(:until)
         # Handle databases which store fractions of a second by rounding up
-        sql << "#{timestamp_field} < :until"
+        sql << "#{model.base_class.table_name}.#{timestamp_field} < :until"
         esc_values[:until] = parse_to_local(opts[:until]) { |t| t + 1 }
       end
+      
       return [sql.join(" AND "), esc_values]
     end
 
     private
 
     def parse_to_local(time)
-      time_obj = Time.parse(time.to_s)
+      if time.respond_to?(:strftime)
+        time_obj = time
+      else
+        begin
+          if time[-1] == "Z"
+            time_obj = Time.strptime(time, "%Y-%m-%dT%H:%M:%S%Z")
+          else
+            time_obj = Date.strptime(time, "%Y-%m-%d")
+          end
+        rescue
+          raise OAI::ArgumentException.new, "unparsable date: '#{time}'"
+        end
+      end
+        
       time_obj = yield(time_obj) if block_given?
-      # Convert to same as DB - :local => :getlocal, :utc => :getutc
-      tzconv = "get#{model.default_timezone.to_s}".to_sym
-      time_obj.send(tzconv).strftime("%Y-%m-%d %H:%M:%S")
+
+      if time_obj.kind_of?(Date)
+        time_obj.strftime("%Y-%m-%d")
+      else
+        # Convert to same as DB - :local => :getlocal, :utc => :getutc
+        if ActiveRecord::VERSION::MAJOR >= 7
+          tzconv = "get#{ActiveRecord.default_timezone.to_s}".to_sym
+        else
+          tzconv = "get#{model.default_timezone.to_s}".to_sym
+        end
+        time_obj.send(tzconv).strftime("%Y-%m-%d %H:%M:%S")
+      end
     end
 
   end
 end
-

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.rb

@@ -90,10 +90,13 @@ module OAI
 
     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
+      
+      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
 

data/lib/oai/provider/resumption_token.rb

@@ -1,5 +1,4 @@
 require 'time'
-require 'enumerator'
 require File.dirname(__FILE__) + "/partial_result"
 
 module OAI::Provider
@@ -8,16 +7,41 @@ module OAI::Provider
   # The ResumptionToken class forms the basis of paging query results.  It
   # provides several helper methods for dealing with resumption tokens.
   #
+  # OAI-PMH spec does not specify anything about resumptionToken format, they can
+  # be purely opaque tokens.
+  #
+  # Our implementation however encodes everything needed to construct the next page
+  # inside the resumption token.
+  #
+  # == The 'last' component: offset or ID/pk to resume from
+  #
+  # The `#last` component is an offset or ID to resume from. In the case of it being
+  # an ID to resume from, this assumes that ID's are sortable and results are returned
+  # in ID order, so that the 'last' ID can be used as the place to resume from.
+  #
+  # Originally it was assumed that #last was always an integer, but since existing
+  # implementations (like ActiveRecordWrapper) used it as an ID, and identifiers and
+  # primary keys are _not_ always integers (can be UUID etc), we have expanded to allow
+  # any string value.
+  #
+  # However, for backwards compatibility #last always returns an integer (sometimes 0 if
+  # actual last component is not an integer), and #last_str returns the full string version.
+  # Trying to change #last itself to be string broke a lot of existing code in this gem
+  # in mysterious ways.
+  #
+  # Also beware that in some cases the value 0/"0" seems to be a special value used
+  # to signify some special case. A lot of "code archeology" going on here after significant
+  # period of no maintenance to this gem.
   class ResumptionToken
-    attr_reader :prefix, :set, :from, :until, :last, :expiration, :total
+    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 = /(.+):(\d+)$/.match(token_string)
-        options[:last] = matches.captures[1].to_i
-        
+        matches = /(.+):([^ :]+)$/.match(token_string)
+        options[:last] = matches.captures[1]
+
         parts = matches.captures[0].split('.')
         options[:metadata_prefix] = parts.shift
         parts.each do |part|
@@ -30,12 +54,12 @@ 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
     end
-    
+
     # extracts the metadata prefix from a token string
     def self.extract_format(token_string)
       return token_string.split('.')[0]
@@ -44,32 +68,32 @@ module OAI::Provider
     def initialize(options, expiration = nil, total = nil)
       @prefix = options[:metadata_prefix]
       @set = options[:set]
-      @last = options[:last]
+      self.last = options[:last]
       @from = options[:from] if options[:from]
       @until = options[:until] if options[:until]
       @expiration = expiration if expiration
       @total = total if total
     end
-          
+
     # convenience method for setting the offset of the next set of results
     def next(last)
-      @last = last
+      self.last = last
       self
     end
-    
+
     def ==(other)
       prefix == other.prefix and set == other.set and from == other.from and
-        self.until == other.until and last == other.last and 
+        self.until == other.until and last == other.last and
         expiration == other.expiration and total == other.total
     end
-    
+
     # output an xml resumption token
     def to_xml
       xml = Builder::XmlMarkup.new
       xml.resumptionToken(encode_conditions, hash_of_attributes)
       xml.target!
     end
-    
+
     # return a hash containing just the model selection parameters
     def to_conditions_hash
       conditions = {:metadata_prefix => self.prefix }
@@ -78,20 +102,45 @@ module OAI::Provider
       conditions[:until] = self.until if self.until
       conditions
     end
-    
-    # return the a string representation of the token minus the offset
+
+    # return the a string representation of the token minus the offset/ID
+    #
+    # Q: Why does it eliminate the offset/id "last" on the end? Doesn't fully
+    #    represent state without it, which is confusing. Not sure, but
+    #    other code seems to rely on it, tests break if not.
     def to_s
       encode_conditions.gsub(/:\w+?$/, '')
     end
 
     private
-    
+
+    # take care of our logic to store an integer and a str version, for backwards
+    # compat where it was assumed to be an integer, as well as supporting string.
+    def last=(value)
+      @last = value.to_i
+      @last_str = value.to_s
+    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
-      encoded_token << ":#{last}"
+      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
 
     def hash_of_attributes

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

@@ -35,6 +35,13 @@ class SimpleResumptionProvider < OAI::Provider::Base
   source_model ActiveRecordWrapper.new(DCField, :limit => 25)
 end
 
+class SimpleResumptionProviderWithNonIntegerID < OAI::Provider::Base
+  repository_name 'ActiveRecord Resumption Provider With Non-Integer ID'
+  repository_url 'http://localhost'
+  record_prefix 'oai:test'
+  source_model ActiveRecordWrapper.new(DCField, :limit => 25, identifier_field: "source")
+end
+
 class CachingResumptionProvider < OAI::Provider::Base
   repository_name 'ActiveRecord Caching Resumption Provider'
   repository_url 'http://localhost'
@@ -49,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
+
+