oai 0.2.1 → 0.3.0

data/lib/oai/provider/metadata_format/oai_dc.rb

@@ -1,9 +1,8 @@
 module OAI::Provider::Metadata
-  # = OAI::Metadata::DublinCore
-  # 
+
   # Simple implementation of the Dublin Core metadata format.
   class DublinCore < Format
-    
+
     def initialize
       @prefix = 'oai_dc'
       @schema = 'http://www.openarchives.org/OAI/2.0/oai_dc.xsd'
@@ -19,9 +18,9 @@ module OAI::Provider::Metadata
         'xmlns:oai_dc' => "http://www.openarchives.org/OAI/2.0/oai_dc/",
         'xmlns:dc' => "http://purl.org/dc/elements/1.1/",
         'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
-        'xsi:schemaLocation' => 
-          %{http://www.openarchives.org/OAI/2.0/oai_dc/ 
-            http://www.openarchives.org/OAI/2.0/oai_dc.xsd}            
+        'xsi:schemaLocation' =>
+          %{http://www.openarchives.org/OAI/2.0/oai_dc/
+            http://www.openarchives.org/OAI/2.0/oai_dc.xsd}.gsub(/\s+/, ' ')
       }
     end
 

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

@@ -1,21 +1,21 @@
 require 'active_record'
 
 module OAI::Provider
-  
+
   # ActiveRecord model class in support of the caching wrapper.
   class OaiToken < ActiveRecord::Base
-    has_many :entries, :class_name => 'OaiEntry', 
+    has_many :entries, :class_name => 'OaiEntry',
       :order => "record_id", :dependent => :destroy
 
     validates_uniqueness_of :token
-    
+
     # Make sanitize_sql a public method so we can make use of it.
     public
-     
+
     def self.sanitize_sql(*arg)
       super(*arg)
     end
-    
+
     def new_record_before_save?
       @new_record_before_save
     end
@@ -28,12 +28,10 @@ module OAI::Provider
 
     validates_uniqueness_of :record_id, :scope => :oai_token
   end
-  
-  # = OAI::Provider::ActiveRecordCachingWrapper
-  # 
+
   # This class wraps an ActiveRecord model and delegates all of the record
   # selection/retrieval to the AR model.  It accepts options for specifying
-  # the update timestamp field, a timeout, and a limit.  The limit option 
+  # the update timestamp field, a timeout, and a limit.  The limit option
   # is used for doing pagination with resumption tokens.  The timeout is
   # used to expire old tokens from the cache.  Default timeout is 12 hours.
   #
@@ -43,18 +41,18 @@ module OAI::Provider
   # If you have an extremely active respository you may want to consider
   # the caching wrapper.  The caching wrapper takes the entire result set
   # from a request and caches it in another database table, well tables
-  # actually.  So the result returned to the client will always be 
+  # actually.  So the result returned to the client will always be
   # internally consistent.
   #
   class ActiveRecordCachingWrapper < ActiveRecordWrapper
-    
+
     attr_reader :model, :timestamp_field, :expire
-    
+
     def initialize(model, options={})
       @expire = options.delete(:timeout) || 12.hours
       super(model, options)
     end
-    
+
     def find(selector, options={})
       sweep_cache
       return next_set(options[:resumption_token]) if options[:resumption_token]
@@ -73,9 +71,9 @@ module OAI::Provider
         model.find(selector, :conditions => conditions)
       end
     end
-  
-    protected 
-  
+
+    protected
+
     def next_set(token_string)
       raise ResumptionTokenException.new unless @limit
 
@@ -84,11 +82,11 @@ module OAI::Provider
 
       if token.last * @limit + @limit < total
         select_partial(token)
-      else 
+      else
         select_partial(token).records
       end
     end
-  
+
     # select a subset of the result set, and return it with a
     # resumption token to get the next subset
     def select_partial(token)
@@ -101,30 +99,30 @@ module OAI::Provider
             "#{OaiToken.sanitize_sql(token_conditions(token))}")
         end
       end
-      
+
       oaitoken = OaiToken.find_by_token(token.to_s)
       raise ResumptionTokenException.new unless oaitoken
 
       PartialResult.new(
-        hydrate_records(oaitoken.entries.find(:all, :limit => @limit, 
+        hydrate_records(oaitoken.entries.find(:all, :limit => @limit,
           :offset => token.last * @limit)), token.next(token.last + 1)
       )
     end
-    
+
     def sweep_cache
       OaiToken.destroy_all(["created_at < ?", Time.now - expire])
     end
-    
+
     def hydrate_records(records)
       model.find(records.collect {|r| r.record_id })
     end
-    
+
     def token_conditions(token)
       sql_conditions token.to_conditions_hash
     end
-    
+
     private
-    
+
     def expires_at(creation)
       created = Time.parse(creation.strftime("%Y-%m-%d %H:%M:%S"))
       created.utc + expire

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

@@ -1,23 +1,22 @@
 require 'active_record'
+
 module OAI::Provider
-  # = OAI::Provider::ActiveRecordWrapper
-  # 
   # This class wraps an ActiveRecord model and delegates all of the record
   # selection/retrieval to the AR model.  It accepts options for specifying
-  # the update timestamp field, a timeout, and a limit.  The limit option 
+  # the update timestamp field, a timeout, and a limit.  The limit option
   # is used for doing pagination with resumption tokens.  The
   # expiration timeout is ignored, since all necessary information is
   # encoded in the token.
   #
   class ActiveRecordWrapper < Model
-    
+
     attr_reader :model, :timestamp_field
-    
+
     def initialize(model, options={})
       @model = model
       @timestamp_field = options.delete(:timestamp_field) || 'updated_at'
       @limit = options.delete(:limit)
-      
+
       unless options.empty?
         raise ArgumentError.new(
           "Unsupported options [#{options.keys.join(', ')}]"
@@ -26,36 +25,39 @@ module OAI::Provider
     end
 
     def earliest
-      model.find(:first, 
-        :order => "#{timestamp_field} asc").send(timestamp_field)
+      earliest_obj = model.find(:first, :order => "#{timestamp_field} asc")
+      earliest_obj.nil? ? Time.at(0) : earliest_obj.send(timestamp_field)
     end
-    
+
     def latest
-      model.find(:first, 
-        :order => "#{timestamp_field} desc").send(timestamp_field)
+      latest_obj = model.find(:first, :order => "#{timestamp_field} desc")
+      latest_obj.nil? ? Time.now : latest_obj.send(timestamp_field)
     end
     # A model class is expected to provide a method Model.sets that
-    # returns all the sets the model supports.  See the 
-    # activerecord_provider tests for an example.   
+    # returns all the sets the model supports.  See the
+    # activerecord_provider tests for an example.
     def sets
       model.sets if model.respond_to?(:sets)
     end
-    
+
     def find(selector, options={})
-      return next_set(options[:resumption_token]) if options[:resumption_token]
+      find_scope = find_scope(options)
+      return next_set(find_scope,
+        options[:resumption_token]) if options[:resumption_token]
       conditions = sql_conditions(options)
       if :all == selector
-        total = model.count(:id, :conditions => conditions)
+        total = find_scope.count(:id, :conditions => conditions)
         if @limit && total > @limit
-          select_partial(ResumptionToken.new(options.merge({:last => 0})))
+          select_partial(find_scope,
+            ResumptionToken.new(options.merge({:last => 0})))
         else
-          model.find(:all, :conditions => conditions)
+          find_scope.find(:all, :conditions => conditions)
         end
       else
-        model.find(selector, :conditions => conditions)
+        find_scope.find(selector, :conditions => conditions)
       end
     end
-    
+
     def deleted?(record)
       if record.respond_to?(:deleted_at)
         return record.deleted_at
@@ -63,10 +65,10 @@ module OAI::Provider
         return record.deleted
       end
       false
-    end    
-    
+    end
+
     def respond_to?(m, *args)
-      if m =~ /^map_/ 
+      if m =~ /^map_/
         model.respond_to?(m, *args)
       else
         super
@@ -82,66 +84,112 @@ module OAI::Provider
     end
 
     protected
-    
+
+    def find_scope(options)
+      return model unless options.key?(:set)
+
+      # Find the set or return an empty scope
+      set = find_set_by_spec(options[:set])
+      return model.scoped(:limit => 0) if set.nil?
+
+      # If the set has a backward relationship, we'll use it
+      if set.class.respond_to?(:reflect_on_all_associations)
+        set.class.reflect_on_all_associations.each do |assoc|
+          return set.send(assoc.name).scoped if assoc.klass == model
+        end
+      end
+
+      # Search the attributes for 'set'
+      if model.column_names.include?('set')
+        # Scope using the set attribute as the spec
+        model.scoped(:conditions => {:set => options[:set]})
+      else
+        # Default to empty set, as we've tried everything else
+        model.scoped(:limit => 0)
+      end
+    end
+
+    def find_set_by_spec(spec)
+      if sets.class == ActiveRecord::Relation
+        sets.find_by_spec(spec)
+      else
+        sets.detect {|set| set.spec == spec}
+      end
+    end
+
     # Request the next set in this sequence.
-    def next_set(token_string)
+    def next_set(find_scope, token_string)
       raise OAI::ResumptionTokenException.new unless @limit
-    
+
       token = ResumptionToken.parse(token_string)
-      total = model.count(:id, :conditions => token_conditions(token))
-    
+      total = find_scope.count(:id, :conditions => token_conditions(token))
+
       if @limit < total
-        select_partial(token)
+        select_partial(find_scope, token)
       else # end of result set
-        model.find(:all, 
-          :conditions => token_conditions(token), 
+        find_scope.find(:all,
+          :conditions => token_conditions(token),
           :limit => @limit, :order => "#{model.primary_key} asc")
       end
     end
-    
+
     # select a subset of the result set, and return it with a
     # resumption token to get the next subset
-    def select_partial(token)
-      records = model.find(:all, 
+    def select_partial(find_scope, token)
+      records = find_scope.find(:all,
         :conditions => token_conditions(token),
-        :limit => @limit, 
+        :limit => @limit,
         :order => "#{model.primary_key} asc")
       raise OAI::ResumptionTokenException.new unless records
       offset = records.last.send(model.primary_key.to_sym)
-      
+
       PartialResult.new(records, token.next(offset))
     end
-    
+
     # build a sql conditions statement from the content
     # of a resumption token.  It is very important not to
     # miss any changes as records may change scope as the
     # harvest is in progress.  To avoid loosing any changes
-    # the last 'id' of the previous set is used as the 
+    # the last 'id' of the previous set is used as the
     # filter to the next set.
     def token_conditions(token)
       last = token.last
       sql = sql_conditions token.to_conditions_hash
-      
+
       return sql if 0 == last
       # Now add last id constraint
-      sql[0] << " AND #{model.primary_key} > ?"
-      sql << last
-      
+      sql.first << " AND #{model.primary_key} > :id"
+      sql.last[:id] = last
+
       return sql
     end
-    
+
     # build a sql conditions statement from an OAI options hash
     def sql_conditions(opts)
       sql = []
-      sql << "#{timestamp_field} >= ?" << "#{timestamp_field} <= ?" 
-      sql << "set = ?" if opts[:set]
-      esc_values = [sql.join(" AND ")]
-      esc_values << Time.parse(opts[:from].to_s).localtime << Time.parse(opts[:until].to_s).localtime.to_s #-- OAI 2.0 hack - UTC fix from record_responce 
-      esc_values << opts[:set] if opts[:set]
-      
-      return esc_values
+      esc_values = {}
+      if opts.has_key?(:from)
+        sql << "#{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"
+        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)
+      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")
+    end
+
   end
 end
 

data/lib/oai/provider/response.rb

@@ -2,119 +2,121 @@ require 'builder' unless defined?(Builder)
 module OAI
   module Provider
     module Response
-  
+
   class Base
     attr_reader :provider, :options
-    
+
     class << self
       attr_reader :valid_options, :default_options, :required_options
       def valid_parameters(*args)
         @valid_options ||= []
         @valid_options = (@valid_options + args.dup).uniq
       end
-      
+
       def default_parameters(options = {})
         @default_options ||= {}
         @default_options.merge! options.dup
       end
-      
+
       def required_parameters(*args)
         valid_parameters(*args)
         @required_options ||= []
         @required_options = (@required_options + args.dup).uniq
       end
-      
-    end 
+
+    end
     def initialize(provider, options = {})
       @provider = provider
+      @request_options = options.dup
       @options = internalize(options)
       raise OAI::ArgumentException.new unless valid?
     end
     def response
       @builder = Builder::XmlMarkup.new
       @builder.instruct! :xml, :version=>"1.0", :encoding=>"UTF-8"
-      @builder.tag!('OAI-PMH', header) do 
+      @builder.tag!('OAI-PMH', header) do
         @builder.responseDate Time.now.utc.xmlschema
-        #options parameter has been removed here because with it
-        #the data won't validate against oai validators.  Without, it 
-        #validates.  
-        @builder.request(provider.url) #-- OAI 2.0 Hack - removed request options 
+        @builder.request(provider.url, (@request_options.merge(:verb => verb) unless self.class == Error))
         yield @builder
       end
     end
     private
-    
+
     def header
-      { 
+      {
         'xmlns' => "http://www.openarchives.org/OAI/2.0/",
         'xmlns:xsi' => "http://www.w3.org/2001/XMLSchema-instance",
         'xsi:schemaLocation' => %{http://www.openarchives.org/OAI/2.0/
-          http://www.openarchives.org/OAI/2.0/OAI-PMH.xsd}
+          http://www.openarchives.org/OAI/2.0/OAI-PMH.xsd}.gsub(/\s+/, ' ')
       }
     end
     def extract_identifier(id)
       id.sub("#{provider.prefix}/", '')
     end
-    
+
     def valid?
       return true if resumption?
-      
+
       return true if self.class.valid_options.nil? and options.empty?
-      
-      # check if the request includes an argument and there are no valid 
+
+      # check if the request includes an argument and there are no valid
       # arguments for that verb (Identify, for example).
       raise OAI::ArgumentException.new if self.class.valid_options.nil? && !options.empty?
-      
+
       if self.class.required_options
         return false unless (self.class.required_options - @options.keys).empty?
       end
       return false unless (@options.keys - self.class.valid_options).empty?
       populate_defaults
     end
-    
+
     def populate_defaults
       self.class.default_options.each do |k,v|
         @options[k] = v.respond_to?(:call) ? v.call(self) : v if not @options[k]
       end
     end
-    
+
     def resumption?
-      if @options.keys.include?(:resumption_token) 
+      if @options.keys.include?(:resumption_token)
         return true if 1 == @options.keys.size
         raise OAI::ArgumentException.new
       end
     end
-        
+
     # Convert our internal representations back into standard OAI options
     def externalize(value)
       value.to_s.gsub(/_[a-z]/) { |m| m.sub("_", '').capitalize }
     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::ArgumentError.new 
+      raise OAI::ArgumentError.new
     end
-    
+
     def internalize(hash = {})
       internal = {}
       hash.keys.each do |key|
         internal[key.to_s.gsub(/([A-Z])/, '_\1').downcase.intern] = hash[key].dup
       end
-      
+
       # Convert date formated strings into internal time values
       # Convert date formated strings in dates.
       internal[:from] = parse_date(internal[:from]) if internal[:from]
       internal[:until] = parse_date(internal[:until]) if internal[:until]
-      
+
       internal
     end
-    
+
+    def verb
+      self.class.to_s.split('::').last
+    end
+
   end
-  
+
 end
 end
 end