openurl 0.0.1

data/lib/openurl.rb

@@ -0,0 +1,10 @@
+# A library to create and parse NISO Z39.88 OpenURLs
+# Can also work with OpenURL 0.1, but your YMMV
+# See:  http://alcme.oclc.org/openurl/docs/implementation_guidelines/
+# for more information on implementing NISO Z39.88
+require 'date'
+require 'rexml/document'
+require 'cgi'
+require 'openurl/context_object'
+require 'openurl/context_object_entity'
+require 'openurl/transport'

data/lib/openurl/context_object.rb

@@ -0,0 +1,530 @@
+module OpenURL
+  
+  # The ContextObject class is intended to both create new OpenURL 1.0 context
+  # objects or parse existing ones, either from Key-Encoded Values (KEVs) or XML.
+  # Usage:
+  #   require 'openurl/context_object'
+  #   include OpenURL
+  #   ctx = ContextObject.new
+  #   ctx.referent.set_format('journal')
+  #   ctx.referent.add_identifier('info:doi/10.1016/j.ipm.2005.03.024')
+  #   ctx.referent.set_metadata('issn', '0306-4573')
+  #   ctx.referent.set_metadata('aulast', 'Bollen')
+  #   ctx.referrer.add_identifier('info:sid/google')
+  #   puts ctx.kev
+  #   # url_ver=Z39.88-2004&ctx_tim=2007-10-29T12%3A18%3A53-0400&ctx_ver=Z39.88-2004&ctx_enc=info%3Aofi%2Fenc%3AUTF-8&ctx_id=&rft.issn=0306-4573&rft.aulast=Bollen&rft_val_fmt=info%3Aofi%2Ffmt%3Axml%3Axsd%3Ajournal&rft_id=info%3Adoi%2F10.1016%2Fj.ipm.2005.03.024&rfr_id=info%3Asid%2Fgoogle
+  
+  class ContextObject    
+
+    attr_accessor(:referent, :referringEntity, :requestor, :referrer, :serviceType, :resolver, :custom)
+		attr_reader(:admin)
+    @@defined_entities = {"rft"=>"referent", "rfr"=>"referrer", "rfe"=>"referring-entity", "req"=>"requestor", "svc"=>"service-type", "res"=>"resolver"}
+    
+    # Creates a new ContextObject object and initializes the ContextObjectEntities.
+    
+    def initialize()
+      @referent = ReferentEntity.new()
+      @referringEntity = ReferringEntity.new()
+      @requestor = RequestorEntity.new()
+      @referrer = ReferrerEntity.new()
+      @serviceType = [ServiceTypeEntity.new()]
+      @resolver = [ResolverEntity.new()]
+      @custom = []
+      @admin = {"ctx_ver"=>{"label"=>"version", "value"=>"Z39.88-2004"}, "ctx_tim"=>{"label"=>"timestamp", "value"=>DateTime.now().to_s}, "ctx_id"=>{"label"=>"identifier", "value"=>""}, "ctx_enc"=>{"label"=>"encoding", "value"=>"info:ofi/enc:UTF-8"}}    
+    end
+
+    def deep_copy
+      cloned = ContextObject.new
+      cloned.import_context_object( self )
+      return cloned
+    end
+    
+    # Serialize the ContextObject to XML.
+    
+    def xml      
+      doc = REXML::Document.new()
+      coContainer = doc.add_element "ctx:context-objects"
+      coContainer.add_namespace("ctx","info:ofi/fmt:xml:xsd:ctx")
+      coContainer.add_namespace("xsi", "http://www.w3.org/2001/XMLSchema-instance")
+      coContainer.add_attribute("xsi:schemaLocation", "info:ofi/fmt:xml:xsd:ctx http://www.openurl.info/registry/docs/info:ofi/fmt:xml:xsd:ctx")
+      co = coContainer.add_element "ctx:context-object"
+      @admin.each_key do |k|
+        co.add_attribute(@admin[k]["label"], @admin[k]["value"])
+      end
+
+      [@referent, @referringEntity, @requestor, @referrer].each do | ent |
+        ent.xml(co) unless ent.empty?
+      end
+      
+      [@serviceType, @resolver, @custom].each do |entCont|
+        entCont.each do |ent|
+          ent.xml(co) unless ent.empty?                      
+        end
+      end
+
+      return doc.to_s
+    end
+    
+    # Alias for .xml
+    
+    def sap2
+      return xml
+    end
+    
+    # Output the ContextObject as a Key-encoded value string.  Pass a boolean
+    # true argument if you do not want the ctx_tim key included.
+    
+    def kev(no_date=false)
+      require 'cgi'
+      kevs = ["url_ver=Z39.88-2004"]
+      
+      # Loop through the administrative metadata      
+      @admin.each_key do |k|
+        next if k == "ctx_tim" && no_date                    
+        kevs.push(k+"="+CGI.escape(@admin[k]["value"].to_s)) if @admin[k]["value"]                  
+      end
+
+      [@referent, @referringEntity, @requestor, @referrer].each do | ent |
+        kevs.push(ent.kev) unless ent.empty?                  
+      end
+      
+      [@serviceType, @resolver, @custom].each do |entCont|
+        entCont.each do |ent|
+          kevs.push(ent.kev) unless ent.empty?                      
+        end
+      end        
+      return kevs.join("&")
+    end
+    
+    # Outputs the ContextObject as a ruby hash.
+    
+    def to_hash
+      co_hash = {"url_ver"=>"Z39.88-2004"}           
+      
+      @admin.each_key do |k|
+        co_hash[k]=@admin[k]["value"] if @admin[k]["value"]
+      end
+
+      [@referent, @referringEntity, @requestor, @referrer].each do | ent |
+        co_hash.merge!(ent.to_hash) unless ent.empty?
+      end
+      
+      [@serviceType, @resolver, @custom].each do |entCont|
+        entCont.each do |ent|
+          co_hash.merge!(ent.to_hash) unless ent.empty?
+        end
+      end        
+      return co_hash
+    end    
+    
+    # Alias for .kev
+    
+    def sap1
+      return kev
+    end
+    
+    # Outputs a COinS (ContextObject in SPANS) span tag for the ContextObject.
+    # Arguments are any other CSS classes you want included and the innerHTML 
+    # content.
+    
+    def coins (classnames=nil, innerHTML=nil)      
+      return "<span class='Z3988 #{classnames}' title='"+CGI.escapeHTML(self.kev(true))+"'>#{innerHTML}</span>"
+    end
+    
+    # Adds another ServiceType entity to the context object and returns the 
+    # array index of the new object.
+    
+    def add_service_type_entity
+      @serviceType << ServiceTypeEntity.new
+      return @serviceType.index(@serviceType.last)
+    end
+
+    # Adds another Resolver entity to the context object and returns the 
+    # array index of the new object.
+    
+    def add_resolver_entity
+      @resolver << ResolverEntity.new      
+      return @resolver.index(@resolver.last)
+    end  
+
+    # Adds a custom entity to the ContextObject and returns array index of the 
+    # new object.  Expects an abbreviation and label for KEV and XML output.
+    
+    def add_custom_entity(abbr=nil, label=nil)
+      @custom << CustomEntity.new(abbr, label)      
+      return @custom.index(@custom.last)
+    end
+
+    # Returns the appropriate CustomEntity for the given entity abbreviation.
+    
+    def custom_entity(abbr)
+      return @custom.find { |c| c.abbr == abbr }
+    end
+    
+    # Sets a ContextObject administration field.
+    
+    def set_administration_key(key, val)
+      raise ArgumentException, "#{key} is not a valid admin key!" unless @admin.keys.index(key)
+      @admin[key]["value"] = val
+    end
+
+    # Imports an existing Key-encoded value string and sets the appropriate 
+    # entities.
+    
+    def import_kev(kev)      
+      co = CGI::parse(kev)
+      co2 = {}
+      co.each_key do |k|
+        # Only take the first value from the value array
+      	co2[k] = co[k][0]
+      end
+      self.import_hash(co2)
+    end
+    
+    # Initialize a new ContextObject object from an existing KEV
+    
+    def self.new_from_kev(kev)
+      co = self.new
+      co.import_kev(kev)
+      return co
+    end  
+    
+    # Imports an existing XML encoded context object and sets the appropriate
+    # entities
+    
+    def import_xml(xml)			
+			doc = REXML::Document.new xml
+      # Cut to the context object
+			ctx = REXML::XPath.first(doc, ".//ctx:context-object", {"ctx"=>"info:ofi/fmt:xml:xsd:ctx"})
+			ctx.attributes.each do |attr, val|				
+				@admin.each do |adm, vals|
+					self.set_administration_key(adm, val) if vals["label"] == attr											
+				end
+			end
+			ctx.to_a.each do | ent |
+				if @@defined_entities.value?(ent.name())
+					var = @@defined_entities.keys[@@defined_entities.values.index(ent.name())]
+					meth = "import_#{var}_node"
+					self.send(meth, ent)
+				else
+					self.import_custom_node(ent)
+				end
+			end
+    end
+    
+    # Initialize a new ContextObject object from an existing XML ContextObject
+    
+    def self.new_from_xml(xml)
+      co = self.new
+      co.import_xml(xml)
+      return co
+    end
+    
+    # Searches the Custom Entities for the key/value pair and returns an array
+    # of the @custom array keys of any matches.
+		
+    def search_custom_entities(key, val)
+      matches = []
+      @custom.each do |cus|
+        begin
+          matches << @custom.index(cus) if cus.instance_variable_get('@'+key) == val                      
+        rescue NameError
+          next
+        end
+      end
+      return matches
+    end
+    
+    # Imports an existing hash of ContextObject values and sets the appropriate
+    # entities.
+    
+    def import_hash(hash)            
+      ref = {}
+      openurl_keys = ["url_ver", "url_tim", "url_ctx_fmt"]
+      hash.each do |key, val|
+        if openurl_keys.include?(key)          
+          next # None of these matter much for our purposes
+        elsif @admin.has_key?(key)
+          self.set_administration_key(key, val)
+        elsif key.downcase.match(/^[a-z]{3}_val_fmt$/)
+          # Realistically should only be rft or rfe:  get the format
+          (entity, v, fmt) = key.split("_")
+          ent = self.translate_abbr(entity)  
+          eval("@"+ent).set_format(val)
+        elsif key.match(/^[a-z]{3}_ref/)
+          # determines if we have a by-reference context object
+          (entity, v, fmt) = key.split("_")
+          ent = self.translate_abbr(entity)
+          # by-reference requires two fields, format and location, if this is
+          # the first field we've run across, set a place holder until we get
+          # the other value
+          unless ref[entity]
+            if fmt
+              ref_key = "format"
+            else 
+              ref_key = "location"
+            end
+            ref[entity] = [ref_key, val]
+          else
+            if ref[entity][0] == "format"
+              eval("@"+ent).set_reference(val, ref[entity][1])
+            else
+              eval("@"+ent).set_reference(ref[entity][1], val)
+            end
+          end
+        elsif key.match(/^[a-z]{3}_id$/)
+          # Get the entity identifier
+          (entity, v) = key.split("_")
+          ent = self.translate_abbr(entity)
+          eval("@"+ent).set_identifier(val)      
+        elsif key.match(/^[a-z]{3}_dat$/)
+          # Get any private data
+          (entity, v) = key.split("_")
+          ent = self.translate_abbr(entity)
+          eval("@"+ent).set_private_data(val)  
+        else
+          # collect the entity metadata
+          keyparts = key.split(".")            
+          if keyparts.length > 1
+            # This is 1.0 OpenURL
+            ent = self.translate_abbr(keyparts[0])
+            eval("@"+ent).set_metadata(keyparts[1], val)
+          else
+            # This is a 0.1 OpenURL.  Your mileage may vary on how accurately
+            # this maps.
+            if key == 'id'
+              @referent.set_identifier(val)
+            elsif key == 'sid'
+              @referrer.set_identifier("info:sid/"+val.to_s)            
+            else 
+              @referent.set_metadata(key, val)
+            end
+          end
+        end
+      end  
+      
+      # Initialize a new ContextObject object from an existing key/value hash
+      
+      def self.new_from_hash(hash)
+        co = self.new
+        co.import_hash(hash)
+        return co
+      end
+      
+      # if we don't have a referent format (most likely because we have a 0.1
+      # OpenURL), try to determine something from the genre.  If that doesn't 
+      # exist, just call it a journal since most 0.1 OpenURLs would be one,
+      # anyway.
+      unless @referent.format        
+       fmt = case @referent.metadata['genre']
+         when /article|journal|issue|proceeding|conference|preprint/ then 'journal'
+         when /book|bookitem|report|document/ then 'book'
+         else 'journal'
+         end
+       @referent.set_format(fmt)
+      end
+    end
+    
+    # Translates the abbreviated entity (rft, rfr, etc.) to the associated class
+    # name.  For repeatable entities, uses the first object in the array.  Returns
+    # a string of the object name which would then be eval'ed to call a method
+    # upon.
+    
+    def translate_abbr(abbr)
+      if @@defined_entities.has_key?abbr
+        ent = @@defined_entities[abbr]
+        if ent == "service-type"
+          ent = "serviceType[0]"
+        elsif ent == "resolver"
+          ent = "resolver[0]"
+        elsif ent == "referring-entity"      
+          ent = "referringEntity"
+        end
+      else
+        idx = self.search_custom_entities("abbr", abbr)
+        if idx.length == 0
+          self.add_custom_entity(abbr)
+          idx = self.search_custom_entities("abbr", abbr)
+        end
+        ent = "custom["+idx[0].to_s+"]"
+      end
+      return ent
+    end
+    
+    # Imports an existing OpenURL::ContextObject object and sets the appropriate
+    # entity values.
+    
+    def import_context_object(context_object)
+    	@admin.each_key { |k|
+    		self.set_administration_key(k, context_object.admin[k]["value"])
+    	}	
+      [context_object.referent, context_object.referringEntity, context_object.requestor, context_object.referrer].each {| ent |
+        unless ent.empty?
+          ['identifier', 'format', 'private_data'].each { |var|
+            unless ent.send(var).nil?
+              unless ent.kind_of?(OpenURL::ReferringEntity)
+                eval("@"+ent.label.downcase).send('set_'+var,ent.send(var))
+              else
+                @referringEntity.send('set_'+var,ent.send(var))
+              end
+            end
+          }
+          unless ent.reference["format"].nil? or ent.reference["format"].nil?
+            unless ent.kind_of?(OpenURL::ReferringEntity)          
+              eval("@"+ent.label.downcase).set_reference(ent.reference["location"], ent.reference["format"])
+            else
+              @referringEntity.set_referent(ent.reference["location"], ent.reference["format"])
+            end
+          end
+          ent.metadata.each_key { |k|
+            unless ent.metadata[k].nil?
+              unless ent.kind_of?(OpenURL::ReferringEntity)          
+                eval("@"+ent.label.downcase).set_metadata(k, ent.metadata[k])
+              else
+                @referringEntity.set_metadata(k, ent.metadata[k])
+              end
+            end
+          }
+        end
+      }
+      context_object.serviceType.each { |svc|
+        if @serviceType[0].empty?
+          @serviceType[0] = svc
+        else
+          idx = self.add_service_type_entity
+          @serviceType[idx] = svc
+        end
+          
+      }
+      context_object.resolver.each { |res|
+        if @resolver[0].empty?
+          @resolver[0] = res
+        else
+          idx = self.add_resolver_entity
+          @resolver[idx] = res
+        end
+          
+      }
+      context_object.custom.each { |cus|
+        idx = self.add_custom_entity(cus.abbr, cus.label)
+        @custom[idx] = cus
+      }         
+    end
+    
+    # Initialize a new ContextObject object from an existing 
+    # OpenURL::ContextObject
+
+    def self.new_from_context_object(context_object)
+      co = self.new
+      co.import_context_object(context_object)
+      return co
+    end       
+    
+    protected
+        
+    def import_rft_node(node)
+			self.import_xml_common(@referent, node)	
+			self.import_xml_mbv_ref(@referent, node)
+    end
+    
+    def import_rfe_node(node)    	
+			self.import_xml_common(@referringEntity, node)	    	
+			self.import_xml_mbv_ref(@referringEntity, node)			
+    end
+
+    def import_rfr_node(node)
+			self.import_xml_common(@referrer, node)	
+			self.import_xml_mbv(@referrer, node)
+    end
+    
+    def import_req_node(node)
+			self.import_xml_common(@requestor, node)	    	
+			self.import_xml_mbv(@requestor, node)			
+    end
+		
+		def import_svc_node(node)
+    	if @serviceType[0].empty?
+    		key = 0
+    	else
+    		key = self.add_service_type_entity
+    	end
+			self.import_xml_common(@serviceType[key], node)				
+			self.import_xml_mbv(@serviceType[key], node)			
+		end
+		
+		def import_custom_node(node)
+			key = self.add_custom_entity(node.name())
+			self.import_xml_commom(@custom[key], node)
+			self.import_xml_mbv(@custom[key], node)			
+		end
+
+    def import_res_node(node)
+    	if @resolver[0].empty?
+    		key = 0
+    	else
+    		key = self.add_resolver_entity
+    	end
+			self.import_xml_common(@resolver[key], node)	
+			self.import_xml_mbv(@resolver[key], node)			
+    end
+    
+    # Parses the data that should apply to all XML context objects
+    
+		def import_xml_common(ent, node) 
+			fmt = REXML::XPath.first(node, ".//ctx:format", {"ctx"=>"info:ofi/fmt:xml:xsd:ctx"})
+			ent.set_format(fmt.get_text.value) if fmt and fmt.has_text
+
+			id = REXML::XPath.first(node, ".//ctx:identifier", {"ctx"=>"info:ofi/fmt:xml:xsd:ctx"})
+			ent.set_identifier(id.get_text.value) if id and id.has_text?
+
+			priv = REXML::XPath.first(node, ".//ctx:private-data", {"ctx"=>"info:ofi/fmt:xml:xsd:ctx"})
+			ent.set_private_data(priv.get_text.value) if priv and priv.has_text?
+
+			ref = REXML::XPath.first(node, ".//ctx:metadata-by-ref", {"ctx"=>"info:ofi/fmt:xml:xsd:ctx"})					
+			if ref
+				ref.to_a.each do |r|
+					if r.name() == "format"
+						format = r.get_text.value
+					else 
+						location = r.get_text.value
+					end
+					ent.set_reference(location, format)
+				end
+			end
+		end
+		
+    # Parses metadata-by-val data
+    
+		def import_xml_mbv(ent, node)
+			mbv = REXML::XPath.first(node, ".//ctx:metadata-by-val", {"ctx"=>"info:ofi/fmt:xml:xsd:ctx"})
+      
+			if mbv        
+				mbv.to_a.each { |m|
+					ent.set_metadata(m.name(), m.get_text.value)
+				}
+			end			
+		end
+    
+    # Referent and ReferringEntities place their metadata-by-val inside
+    # the format element
+    
+		def import_xml_mbv_ref(ent, node)
+			ns = "info:ofi/fmt:xml:xsd:"+ent.format
+			mbv = REXML::XPath.first(node, ".//fmt:"+ent.format, {"fmt"=>ns})					
+			if mbv
+				mbv.to_a.each { |m|
+          if m.has_text?
+            ent.set_metadata(m.name(), m.get_text.value)            
+          end
+          if m.has_elements?
+            m.to_a.each { | md |
+              if md.has_text?
+                ent.set_metadata(md.name(), md.get_text.value)
+              end
+            }
+          end
+				}
+			end					
+		end    
+  end  
+end

data/lib/openurl/context_object_entity.rb

@@ -0,0 +1,303 @@
+module OpenURL
+  
+  # The ContextObjectEntity is a generic class to define an entity.  It should
+  # not be initialized directly, only through one of its children: 
+  #   ReferentEntity, ReferrerEntity, ReferringEntity, ResolverEntity, 
+  #   ServiceTypeEntity, or CustomEntity
+  
+  class ContextObjectEntity
+    # identifiers should always be an array, but it might be an empty one. 
+    attr_reader(:identifiers, :reference, :format, :metadata, :private_data, :abbr, :label)
+    
+    def initialize
+      @identifiers = []
+      @reference = {"format"=>nil, "location"=>nil}
+      @format = nil
+      @metadata = {}
+      @private_data = nil
+    end
+    
+    # Sets the location and format of a by-reference context object entity
+    
+    def set_reference(loc, fmt)
+      @reference["location"] = loc
+      @reference["format"] = fmt
+    end
+
+    # 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) )
+    end
+    alias :set_identifier :add_identifier
+    
+    # We can actually have more than one, but certain code calls this
+    # method as if there's only one. We return the first. 
+    def identifier
+      return @identifiers[0]
+    end
+    
+    
+    def set_private_data(val)
+      @private_data = val
+    end  
+
+    def set_metadata(key, val)
+      @metadata[key] = val
+    end
+    
+    def get_metadata(key)
+      return @metadata[key]
+    end
+    
+    def set_format(format)
+      @format = format
+    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)}
+
+      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
+        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
+        end
+      end
+      if @reference["format"] 
+        meta["metadata-by-ref"] = meta["container"].add_element("ctx:metadata-by-ref")
+        meta["ref_format"] = meta["metadata-by-ref"].add_element("ctx:format")
+        meta["ref_format"].text = @reference["format"]
+        meta["ref_loc"] = meta["metadata-by-ref"].add_element("ctx:location")
+        meta["ref_loc"].text = @reference["location"]          
+      end
+      
+      @identifiers.each do |id|
+        # Yes, meta["identifier"] will get over-written if there's more than
+        # one identifier. But I dont' think this meta hash is used for much
+        # I don't think it's a problem. -JR 
+        meta["identifier"] = meta["container"].add_element("ctx:identifier")
+        meta["identifier"].text = id
+      end
+      if @private_data
+        meta["private-data"] = meta["container"].add_element("ctx:private-data")
+        meta["private-data"].text = @private_data
+      end          
+      return co_elem
+    end
+    
+    # Outputs the entity as a KEV array
+    
+    def kev
+      kevs = []
+      
+      @metadata.each do |k,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 @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
+    
+    # Outputs the entity as a hash
+    
+    def to_hash
+      co_hash = {}
+      
+      @metadata.each do |k,v|
+        co_hash["#{@abbr}.#{k}"]=v if v
+      end
+      
+      co_hash["#{@abbr}_val_fmt"]="info:ofi/fmt:xml:xsd:#{@format}" if @format              
+
+      if @reference["format"] 
+        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 )
+      end
+      co_hash["#{@abbr}_dat"]=@private_data if @private_data
+              
+      return co_hash    
+    end    
+    
+    # Checks to see if the entity has any metadata set.
+    
+    def empty?
+      return false if (@identifiers.length > 0 ) or @reference["format"] or @reference["location"] or @metadata.length > 0 or @format or @private_data              
+      return true      
+    end
+    
+    # Serializes the metadata values for Referent and ReferringEntity entities
+    # since their schema is a little different.
+    
+    def xml_for_ref_entity(co_elem)      
+      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
+
+          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"].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].text = v
+            end
+          end
+        end
+      end
+      if @reference["format"] 
+        meta["metadata-by-ref"] = meta["container"].add_element("ctx:metadata-by-ref")
+        meta["ref_format"] = meta["metadata-by-ref"].add_element("ctx:format")
+        meta["ref_format"].text = @reference["format"]
+        meta["ref_loc"] = meta["metadata-by-ref"].add_element("ctx:location")
+        meta["ref_loc"].text = @reference["location"]          
+      end
+      
+      @identifiers.each do |id|
+        # Yes, if there's more than one, meta["identifier"] will get
+        # overwritten with last. I don't think this is a problem, cause
+        # meta["identifier"] isn't used anywhere. 
+        meta["identifier"] = meta["container"].add_element("ctx:identifier")
+        meta["identifier"].text = id
+      end
+      if @private_data
+        meta["private-data"] = meta["container"].add_element("ctx:private-data")
+        meta["private-data"].text = @private_data
+      end          
+      return co_elem
+    end  
+
+    # Switch old 0.1 style ids to new 1.0 style ids.
+    # Eg, turn << doi:[x] >>    into     << info:doi/[x] >>
+    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/')
+        end
+
+        return value
+    end
+    
+  end
+
+  class ReferentEntity < ContextObjectEntity
+    def initialize
+      super()
+      @abbr = "rft"
+      @label = "referent"
+    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 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"
+    end
+  end
+
+  class ServiceTypeEntity < ContextObjectEntity
+    def initialize
+      super()
+      @abbr = "svc"
+      @label = "service-type"
+    end
+  end
+  class ResolverEntity < ContextObjectEntity
+    def initialize
+      super()
+      @abbr = "res"
+      @label = "resolver"
+    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
+
+    end
+  end
+  
+end

data/lib/openurl/transport.rb

@@ -0,0 +1,172 @@
+require 'net/http'
+require 'uri'		
+
+module OpenURL  
+  # The Transport class is intended to be used to deliver ContextObject objects
+  # to an OpenURL enabled host.  Currently only HTTP is supported.  
+  # Usage:
+  # require 'openurl'  
+  # include OpenURL
+  # context_object = ContextObject.new_from_kev('ctx_enc=info%3Aofi%2Fenc%3AUTF-8&ctx_ver=Z39.88-2004&rft.genre=article&rft_id=info%3Adoi%2F10.1016%2Fj.ipm.2005.03.024&rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Aarticle&url_ctx_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Actx&url_ver=Z39.88-2004')
+  # transport = Transport.new('http://demo.exlibrisgroup.com:9003/lr_3', context_object)
+  # transport.get
+  # puts tranport.response
+  
+  class Transport
+  	attr_accessor(:extra_args, :ctx_id)
+  	attr_reader(:response, :request_string, :context_objects, :code, :message)
+    
+    # Creates the transport object which can be used to initiate
+    # subsequent requests.  The contextobject argument can be an OpenURL 
+    # ContextObject object, and array of ContextObjects or nil.  http_arguments 
+    # set the Net::HTTP attributes: {:open_timeout=>3, :read_timeout=>5}, etc.
+    
+		def initialize(target_base_url, contextobject=nil, http_arguments={})      
+			@uri = URI.parse(target_base_url)
+			@context_objects = []
+      self.add_context_object(contextobject) if contextobject
+			@url_ver = "Z39.88-2004"			
+			@extra_args = {}      
+      @client = Net::HTTP.new(@uri.host, @uri.port)
+      @client.open_timeout = (http_arguments[:open_timeout]||3)
+      @client.read_timeout = (http_arguments[:read_timeout]||5)
+		end
+		
+    # Can take either an OpenURL::ContextObject or an array of ContextObjects
+    # to send to the Transport target
+    
+		def add_context_object(contextobject)
+      
+      if contextobject.is_a?(OpenURL::ContextObject)
+        @context_objects << contextobject
+      elsif contextobject.is_a?(Array)
+        contextobject.each do | co |
+          raise ArgumentError, "Each element in array much be an OpenURL::ContextObject!" unless co.is_a?(OpenURL::ContextObject)          
+          @context_objects << co
+        end      
+      else 
+        raise ArgumentError, "Argument must be a ContextObject or array of ContextObjects!, #{contextobject.class} sent."        
+      end      	
+		end
+    
+    # Accepts either a ContextObject or array index to remove from array being
+    # sent to the Transport target
+    
+  	def remove_context_object(element)
+      idx = case element.class
+      when Fixnum then element
+      when OpenURL::ContextObject then @context_objects.index(element)
+      else raise ArgumentError, "Invalid argument for element"
+      end
+      @context_objects.delete_at(idx)
+  	end
+    
+    # Perform an inline HTTP GET request.  Only one context object can be sent
+    # via GET, so pass the index of the desired context object (defaults to the 
+    # first)
+    
+    def get(idx=0)      
+      extra = ""
+      @extra_args.each do | key, val |        
+        extra << "&#{key}=#{val}"
+      end      
+      self.parse_response(@client.get("#{@uri.path}?#{@context_objects[idx].kev}#{extra}"))      
+    end        
+    
+    # Sends an inline transport request.  YOu can specify which HTTP method
+    # to use.  Since you can only send one context object per inline request, 
+    # the second argument is the index of the desired context object.
+    
+    def transport_inline(method="GET", idx=0)
+      return(self.get(idx)) if method=="GET"
+      return(self.post({:inline=>true, :index=>idx})) if method=="POST"
+    end
+    
+    # Sends an by-value transport request.  YOu can specify which HTTP method
+    # to use.  Since a GET request is effectively the same as an inline request,
+    # the index of which context object must be specified (defaults to 0).
+    
+		def transport_by_val(method="POST", idx=0)
+      return(self.get(idx)) if method=="GET"
+      return(self.post) if method=="POST"	
+		end    
+    
+    # POSTs an HTTP request to the transport target.  To send an inline request,
+    # include a hash that looks like: {:inline=>true, :index=>n} (:index defaults
+    # to 0.  Transport.post must be used to send multiple context objects to a
+    # target.
+    
+    def post(args={})
+      # Inline requests send the context object as a hash
+      if args[:inline]
+        self.parse_response(self.post_http(@context_objects[(args[:index]||0)].to_hash.merge(@extra_args.merge({"url_ctx_fmt"=>"info:ofi/fmt:kev:mtx:ctx"}))))        
+        return
+      end            
+      ctx_hash = {"url_ctx_fmt" => "info:ofi/fmt:xml:xsd:ctx"}
+      # If we're only sending one context object, use that, otherwise concatenate
+      # them.
+      if @context_objects.length == 1
+        ctx_hash["url_ctx_val"] = @context_objects[0].xml
+      else
+        ctx_hash["url_ctx_val"] = self.merge_context_objects
+      end
+      @context_objects[0].admin.each do | key, hsh |
+        ctx_hash[key] = hsh["value"]
+      end         
+      
+      self.parse_response(self.post_http(ctx_hash.merge(@extra_args)))      
+    end
+    
+    # For a multiple context object request, takes the first context object in
+    # the context_objects attribute, and adds the other context objects to it, 
+    # under /ctx:context-objects/ctx:context-object and serializes it all as XML.
+    # Returns a string of the XML document
+    
+    def merge_context_objects
+      ctx_doc = REXML::Document.new(@context_objects[0].xml)
+      root = ctx_doc.root
+      @context_objects.each do | ctx |
+        next if @context_objects.index(ctx) == 0
+        c_doc = REXML::Document.new(ctx.xml)
+        c_elm = c_doc.elements['ctx:context-objects/ctx:context-object']
+        root.add_element(c_elm)
+      end      
+      return ctx_doc.to_s
+    end
+    
+    # Deprecated.  Set by-reference in OpenURL::ContextObject and use .get or 
+    # .post
+    
+  	def transport_by_ref(fmt, ref, method="GET")
+  		md = "url_ver=Z39.88-2004&url_ctx_fmt="+CGI.escape(fmt)+"&url_tim="+CGI.escape(DateTime.now().to_s)
+  		if method == "GET"  	
+        parse.response(@client.get("#{@uri.path}?#{md}&url_ctx_ref="+CGI.escape(ref)))
+  		else
+  			args = {"url_ver"=>"Z39.88-2004",
+          "url_ctx_fmt"=>fmt,
+          "url_tim"=>DateTime.now().to_s,
+          "url_ctx_ref" => ref}  			
+  			args = args.merge(@extra_args) unless @extra_args.empty?
+  				  			
+  			self.parse_response(self.post_http(args))
+  		end
+  	end		  		
+    
+    protected
+    
+    # Reads the HTTP::Response object and sets the response, code and message
+    # attributes
+    
+    def parse_response(response)
+      @response = response.body
+      @code = response.code
+      @message = response.message
+    end 
+
+    # Sends the actual POST request.
+    
+  	def post_http(args)
+		  return(Net::HTTP.post_form @uri, args)			
+  	end    
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: openurl
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-10-29 00:00:00 -04:00
+summary: a Ruby library to create, parse and use NISO Z39.88 OpenURLs
+require_paths: 
+- lib
+email: rossfsinger@gmail.com
+homepage: http://openurl.rubyforge.org/
+rubyforge_project: 
+description: 
+autorequire: openurl
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ross Singer
+files: 
+- lib/openurl
+- lib/openurl/context_object.rb
+- lib/openurl/context_object_entity.rb
+- lib/openurl/transport.rb
+- lib/openurl.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+