openurl 0.0.1 → 0.1.0

data/lib/openurl/context_object_entity.rb

@@ -27,9 +27,15 @@ module OpenURL
     # Should really be called "add identifier", since we can have more
     # than one. But for legacy, it's "set_identifier". 
     def add_identifier(val)
-      @identifiers.push( self.class.normalize_id(val) )
+      return if val.nil?      
+      @identifiers.push( self.class.normalize_id(val) ) unless @identifiers.index(self.class.normalize_id(val))
     end
     alias :set_identifier :add_identifier
+
+    def delete_identifier(val)
+      return @identifiers.delete(val)
+    end
+     
     
     # We can actually have more than one, but certain code calls this
     # method as if there's only one. We return the first. 
@@ -49,28 +55,37 @@ module OpenURL
     def get_metadata(key)
       return @metadata[key]
     end
+
+    def set_format(format) 
+      return unless format
+      if format.match(/^info:ofi\/fmt/)      
+        @format = format.split(":").last
+      else
+        @format = format
+      end
+    end        
     
-    def set_format(format)
-      @format = format
-    end  
+    def self.new_from_format(format)
+      if format.match(/^info:ofi\/fmt/)
+        return ContextObjectEntityFactory.format( format )        
+      else
+        return self.new
+      end
+    end
     
     # Serializes the entity to XML and attaches it to the supplied REXML element.
     
-    def xml(co_elem)      
-      meta = {"container"=>co_elem.add_element("ctx:"+@label)}
-
+    def xml(co_elem, label) 
+      full_label = OpenURL::ContextObject.entities(label)
+      meta = {"container"=>co_elem.add_element("ctx:#{full_label}")}          
       if @metadata.length > 0 or @format
         meta["metadata-by-val"] = meta["container"].add_element("ctx:metadata-by-val")
         if @format 
-          meta["format"] = meta["container"].add_element("ctx:format")
-          meta["format"].text = "info:ofi/fmt:xml:xsd:"+@format
+          meta["format"] = meta["metadata-by-val"].add_element("ctx:format")
+          meta["format"].text = (@xml_ns||"info:ofi/fmt:xml:xsd:#{@format}")
         end
         if @metadata.length > 0
-          meta["metadata"] = meta["metadata-by-val"].add_element("ctx:metadata")
-          @metadata.each do |k,v|
-            meta[k] = meta["metadata"].add_element("ctx:"+k)
-            meta[k].text = v
-          end
+          self.serialize_metadata(meta["metadata-by-val"], label)
         end
       end
       if @reference["format"] 
@@ -95,53 +110,76 @@ module OpenURL
       return co_elem
     end
     
+    def serialize_metadata(elem, label)
+      meta = {}
+      metadata = elem.add_element("ctx:metadata")
+      @metadata.each do |k,v|
+        meta[k] = metadata.add_element("#{label}:"+k)
+        meta[k].add_namespace(label, (@xml_ns||"info:ofi/fmt:xml:xsd:#{@format}"))
+        meta[k].text = v
+      end      
+    end
+            
     # Outputs the entity as a KEV array
     
-    def kev
+    def kev(abbr)
       kevs = []
       
       @metadata.each do |k,v|
-        kevs << "#{@abbr}.#{k}="+CGI.escape(v) if v                      
+        kevs << "#{abbr}.#{k}="+CGI.escape(v) if v                      
       end
-      
-      kevs << "#{@abbr}_val_fmt="+CGI.escape("info:ofi/fmt:xml:xsd:#{@format}") if @format                  
-
+      if @kev_ns
+        kevs << "#{abbr}_val_fmt="+CGI.escape(@kev_ns)
+      elsif @format
+        kevs << "#{abbr}_val_fmt="+CGI.escape("info:ofi/fmt:kev:mtx:#{@format}")
+      end
+                   
       if @reference["format"] 
-        kevs << "#{@abbr}_ref_fmt="+CGI.escape(@reference["format"])
-        kevs << "#{@abbr}_ref="+CGI.escape(@reference["location"])      
+        kevs << "#{abbr}_ref_fmt="+CGI.escape(@reference["format"])
+        kevs << "#{abbr}_ref="+CGI.escape(@reference["location"])      
       end
       
       @identifiers.each do |id| 
-          kevs << "#{@abbr}_id="+CGI.escape(id)
+          kevs << "#{abbr}_id="+CGI.escape(id)
       end
       
-      kevs << "#{@abbr}_dat="+CGI.escape(@private_data) if @private_data
+      kevs << "#{abbr}_dat="+CGI.escape(@private_data) if @private_data
                     
       return kevs      
     end
     
     # Outputs the entity as a hash
-    
-    def to_hash
+    # Outputting a context object as a hash
+    # is imperfect, because context objects can have multiple elements
+    # with the same key. So this function is really deprecated, but here
+    # because we have so much code dependent on it.
+    #
+    # self does not know it's own entity abbreviation prefix, so must
+    # be passed in.
+    def to_hash(abbr)
+
       co_hash = {}
       
       @metadata.each do |k,v|
-        co_hash["#{@abbr}.#{k}"]=v if v
+        co_hash["#{abbr}.#{k}"]=v if v
       end
-      
-      co_hash["#{@abbr}_val_fmt"]="info:ofi/fmt:xml:xsd:#{@format}" if @format              
+
+      # Not sure what this should be? Can we know what it is set to, or
+      # it's output dependent? If the latter, can't really know
+      # anything, since this is just a hash! 
+      co_hash["#{abbr}_val_fmt"]="info:ofi/fmt:kev:mtx:#{@format}" if @format              
 
       if @reference["format"] 
-        co_hash["#{@abbr}_ref_fmt"]=@reference["format"]
-        co_hash["#{@abbr}_ref"]=@reference["location"]
+        co_hash["#{abbr}_ref_fmt"]=@reference["format"]
+        co_hash["#{abbr}_ref"]=@reference["location"]
       end
       
       @identifiers.each do |id|
         # Put em in a list. 
-        co_hash["#{@abbr}_id"] ||= Array.new
-        co_hash["#{@abbr}_id"].push( id )
+        co_hash["#{abbr}_id"] ||= Array.new
+        co_hash["#{abbr}_id"].push( id )
       end
-      co_hash["#{@abbr}_dat"]=@private_data if @private_data
+      co_hash["#{abbr}_dat"]=@private_data if @private_data
               
       return co_hash    
     end    
@@ -157,21 +195,21 @@ module OpenURL
     # since their schema is a little different.
     
     def xml_for_ref_entity(co_elem)      
-      meta = {"container"=>co_elem.add_element("ctx:"+@label)}
+      meta = {"container"=>co_elem.add_element("ctx:#{@label}")}
 
       if @metadata.length > 0 or @format
         meta["metadata-by-val"] = meta["container"].add_element("ctx:metadata-by-val")
         if @format 
           meta["format"] = meta["metadata-by-val"].add_element("ctx:format")
-          meta["format"].text = "info:ofi/fmt:xml:xsd:"+@format
+          meta["format"].text = "info:ofi/fmt:xml:xsd:#{@format}"
 
           if @metadata.length > 0
             meta["metadata"] = meta["metadata-by-val"].add_element("ctx:metadata")
-            meta["format_container"] = meta["metadata"].add_element(@format)
+            meta["format_container"] = meta["metadata"].add_element("rft:#{@format}")
             meta["format_container"].add_namespace(@abbr, meta["format"].text)
             meta["format_container"].add_attribute("xsi:schemaLocation", meta["format"].text+" http://www.openurl.info/registry/docs/info:ofi/fmt:xml:xsd:"+@format)          
             @metadata.each do |k,v|
-              meta[k] = meta["format_container"].add_element(@abbr+":"+k)
+              meta[k] = meta["format_container"].add_element("#{@abbr}:#{k}")
               meta[k].text = v
             end
           end
@@ -201,103 +239,72 @@ module OpenURL
 
     # Switch old 0.1 style ids to new 1.0 style ids.
     # Eg, turn << doi:[x] >>    into     << info:doi/[x] >>
+    # Looks for things that are NOT valid URI prefixes, but
+    # were commonly used in OpenURL 0.1, and can be easily turned
+    # into info URIs.  
     def self.normalize_id(value)
-        # info, urn, and http are all good new style 1.0 ids.
-        # we assume anything else is not. Is this a valid assumption?
-        unless ( (value.slice(0,5) == 'info:') || 
-          (value.slice(0,4) == 'urn:') || 
-          (value.slice(0,5) == 'http:') )
-          value = value.sub(/^([a-z,A-Z]+)\:/, 'info:\1/')
+        value =~ /^(\w+)(\:|\/)(.*)/
+        prefix = $1
+        remainder = $3
+        # info ones
+        if ["doi", "pmid", "oclcnum", "sici", "lccn", "sid"].include?(prefix)
+          value = "info:#{prefix}/#{remainder}"
         end
-
+        # urn ones
+        if ["isbn", "issn"].include?(prefix)
+          value = "urn:#{prefix}:#{remainder}"
+        end
+        
         return value
     end
     
-  end
+    def import_xml_metadata(node)
+      mbv = REXML::XPath.first(node, "./ctx:metadata-by-val", {"ctx"=>"info:ofi/fmt:xml:xsd:ctx"})
 
-  class ReferentEntity < ContextObjectEntity
-    def initialize
-      super()
-      @abbr = "rft"
-      @label = "referent"
-    end
-    def xml(co_elem)
-      return self.xml_for_ref_entity(co_elem)
+      if mbv        
+        mbv.to_a.each do |m|
+          self.set_metadata(m.name(), m.get_text.value) if m && m.get_text
+        end
+      end			
+    end    
+    
+  end  
+  
+  class ContextObjectEntityFactory
+    @@factories = []
+    
+    def self.inherited(factory)
+      @@factories.insert(0,factory)
     end 
-    def set_format(fmt) 
-      if fmt.split(":").length > 1
-        @format = fmt.split(":").last
-      else
-        @format = fmt
-      end
-    end
-  end
-
-  class ReferringEntity < ContextObjectEntity
-    def initialize
-      super()
-      @abbr = "rfe"
-      @label = "referring-entity"
-    end
-    def xml(co_elem)
-      return self.xml_for_ref_entity(co_elem)
-    end
-    def set_format(fmt) 
-      if fmt.split(":").length > 1
-        @format = fmt.split(":").last
-      else
-        @format = fmt
-      end
-  	end    
-  end
-
-  class ReferrerEntity < ContextObjectEntity
-    def initialize
-      super()
-      @abbr = "rfr"
-      @label = "referrer"
-    end
-  end
-
-  class RequestorEntity < ContextObjectEntity
-    def initialize
-      super()
-      @abbr = "req"
-      @label = "requestor"
+    
+    def self.add_factory(factory)
+      @@factories.insert(0,factory)
     end
-  end
-
-  class ServiceTypeEntity < ContextObjectEntity
-    def initialize
-      super()
-      @abbr = "svc"
-      @label = "service-type"
+    
+    def self.delete_factory_at(index)
+      @@factories.delete_at(index)
     end
-  end
-  class ResolverEntity < ContextObjectEntity
-    def initialize
-      super()
-      @abbr = "res"
-      @label = "resolver"
+    
+    def self.format(format_id)      
+      @@factories.each { |factory|        
+        if factory.identifiers.index(format_id)
+          return factory.create()
+        end
+      }
+      ent = OpenURL::ContextObjectEntity.new
+      ent.set_format(format_id)
+      return ent
     end
-  end
-
-  class CustomEntity < ContextObjectEntity
-    attr_accessor :abbr, :label
-    def initialize(abbr=nil, label=nil)
-      super()
-      unless abbr
-        @abbr = "cus"
-      else
-        @abbr = abbr
-      end
-      unless label
-        @label = @abbr
-      else
-        @abbr = label
-      end
-
+    
+    def self.factories
+      return @@factories
     end
+    
+    def self.load(dirname)
+      Dir.open( dirname ).each { |fn|
+        next unless ( fn =~ /[.]rb$/ )
+        require "#{dirname}/#{fn}"
+      }
+    end    
   end
-  
 end

data/lib/openurl/metadata_formats/book.rb

@@ -0,0 +1,36 @@
+# 
+# book.rb
+# 
+# Created on Oct 31, 2007, 1:07:33 PM
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+require 'openurl/metadata_formats/scholarly_common'
+module OpenURL
+  class Book < ScholarlyCommon     
+    attr_reader :authors
+    def initialize
+      super()
+      @format = 'book'
+      @metadata_keys = ['btitle','atitle','title','place','pub','date','edition',
+        'tpages','series', 'spage','epage', 'pages','issn','isbn','bici']
+      @valid_genres = ["book","bookitem","conference","proceeding","report",
+        "document","unknown" ]
+      @xml_ns = "info:ofi/fmt:xml:xsd:book"
+      @kev_ns = "info:ofi/fmt:kev:mtx:book"
+    end
+    
+   
+  end
+  
+  class BookFactory < ContextObjectEntityFactory
+    @@identifiers = ["info:ofi/fmt:kev:mtx:book","info:ofi/fmt:xml:xsd:book"]
+    def self.identifiers
+      return @@identifiers
+    end
+    def self.create()
+      return OpenURL::Book.new
+    end    
+  end
+end

data/lib/openurl/metadata_formats/dissertation.rb

@@ -0,0 +1,36 @@
+# 
+# dissertation.rb
+# 
+# Created on Nov 1, 2007, 10:35:28 AM
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+require 'openurl/metadata_formats/scholarly_common'
+module OpenURL
+  class Dissertation < ScholarlyCommon
+    
+    def initialize
+      super()
+      @format = 'dissertation'
+      @metadata_keys = ['title','co','cc','inst','advisor','date','tpages',
+        'isbn','degree'
+        ]
+      @xml_ns = "info:ofi/fmt:xml:xsd:dissertation"
+      @kev_ns = "info:ofi/fmt:kev:mtx:dissertation"
+    end    
+    def genre=(genre)
+      raise ArgumentError, "Genre is not a valid #{self.class} metadata key."      
+    end    
+  end
+  
+  class DissertationFactory < ContextObjectEntityFactory
+    @@identifiers = ["info:ofi/fmt:kev:mtx:dissertation","info:ofi/fmt:xml:xsd:dissertation"]
+    def self.identifiers
+      return @@identifiers
+    end
+    def self.create()
+      return OpenURL::Dissertation.new
+    end    
+  end
+end

data/lib/openurl/metadata_formats/dublin_core.rb

@@ -0,0 +1,114 @@
+# 
+# dublin_core.rb
+# 
+# Created on Nov 12, 2007, 10:35:28 AM
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+module OpenURL
+  class DublinCore < ContextObjectEntity
+    def initialize      
+      super
+      @metadata_keys = ['title','creator','subject','description','publisher',
+        'contributor','date','type','format','identifier','source', 'language',
+        'relation', 'coverage', 'rights'
+        ]      
+      @xml_ns = "info:ofi/fmt:xml:xsd:oai_dc"
+      @kev_ns = "info:ofi/fmt:kev:mtx:dc"
+      @oai_ns = "http://www.openarchives.org/OAI/2.0/oai_dc/"
+    end    
+    
+    def method_missing(metadata, value=nil)
+      meta = metadata.to_s.sub(/=$/,'')
+      raise ArgumentError, "#{meta.to_s} is not a valid #{self.class} metadata field." unless @metadata_keys.index(meta)
+      if metadata.to_s.match(/=$/)
+        self.set_metadata(meta, value)
+      else
+        return self.metadata[meta]
+      end      
+    end
+    
+    def set_metadata(key, val)
+      @metadata[key] ||=[]    
+      @metadata[key] << val unless @metadata[key].index(val)
+    end    
+  
+
+    def serialize_metadata(elem, label)
+      meta = []
+      fmt = elem.add_element("ctx:format")
+      fmt.text = @xml_ns
+      metadata = elem.add_element("ctx:metadata")
+      dc_container = metadata.add_element("#{label}:dc")
+      dc_container.add_namespace(label, @oai_ns)
+      dc_container.add_namespace("dc", "http://purl.org/dc/elements/1.1/")
+      dc_container.add_namespace("xsi", "http://www.w3.org/2001/XMLSchema-instance")
+      dc_container.add_attribute("xsi:schemaLocation", "http://www.openarchives.org/OAI/2.0/oai_dc/ http://www.openarchives.org/OAI/2.0/oai_dc.xsd")
+       
+      @metadata.each do |key,vals|
+        vals.each do | val |
+          meta << dc_container.add_element("#{label}:#{key}")
+          meta.last.text = val
+        end
+      end                 
+    end 
+    
+    def import_xml_metadata(node)         
+      mbv = REXML::XPath.first(node, "./ctx:metadata-by-val/ctx:metadata/fmt:dc", {"ctx"=>"info:ofi/fmt:xml:xsd:ctx", "fmt"=>@oai_ns})					              
+      if mbv
+        mbv.to_a.each do |m|
+          self.set_metadata(m.name(), CGI.unescapeHTML(m.children.to_s)) unless m.children.empty?                                  
+        end      
+      end					
+    end 
+    
+    def import_dc(dc)
+      raise ArgumentError, "Argument must be a REXML::Document or String!" unless dc.is_a?(REXML::Document) or dc.is_a?(String)
+      doc = dc
+      doc = REXML::Document.new(dc) if doc.is_a?(String)
+      doc.root.elements.each do | elem |
+        self.set_metadata(elem.name(), CGI.unescapeHTML(elem.children.to_s)) unless elem.children.empty?                                  
+      end
+      
+    end
+    
+    # Outputs the entity as a KEV array
+    
+    def kev(abbr)
+      kevs = []
+      
+      @metadata.each do |key, vals|
+        vals.each do | val |
+          kevs << "#{abbr}.#{key}="+CGI.escape(val)
+        end
+      end
+      
+      kevs << "#{abbr}_val_fmt="+CGI.escape(@kev_ns)      
+     
+      
+      if @reference["format"] 
+        kevs << "#{abbr}_ref_fmt="+CGI.escape(@reference["format"])
+        kevs << "#{abbr}_ref="+CGI.escape(@reference["location"])      
+      end
+      
+      @identifiers.each do |id| 
+          kevs << "#{abbr}_id="+CGI.escape(id)
+      end
+      
+      kevs << "#{abbr}_dat="+CGI.escape(@private_data) if @private_data
+                    
+      return kevs      
+    end    
+  end
+  
+  class DublinCoreFactory < ContextObjectEntityFactory
+    @@identifiers = ["info:ofi/fmt:kev:mtx:dc","info:ofi/fmt:xml:xsd:oai_dc"]
+    def self.identifiers
+      return @@identifiers
+    end
+    def self.create()
+      return OpenURL::DublinCore.new
+    end    
+  end
+end