umlaut 3.0.0alpha1

data/lib/hip3/receipt.rb

@@ -0,0 +1,7 @@
+module Hip3
+  class Receipt
+    def foo
+      raise "foo"
+    end
+  end
+end

data/lib/hip3/serial_copy.rb

@@ -0,0 +1,82 @@
+module Hip3
+  # Keeps a reference to it's bib, if it needs to load it's data, 
+  # it asks bib to load all
+	# data, and the bib loads it at once for all copies, in one fetch. 	
+	class SerialCopy < Holding
+		@@Field_labels = {:location => 'Location', :collection => 'Collection', :call_no => 'Call No.', :copy_str => 'Copy No.', :status => 'Status', :notes => 'Notes'}
+		attr_accessor :items # array of items
+		attr_accessor :items_loaded
+		attr_accessor :runs # array of run types/statements
+		
+		def initialize(argBibObj, serialXmlElement=nil)
+			self.bib = argBibObj
+			self.items_loaded = false
+			if ( serialXmlElement ) 
+				loadFromSerialElement( serialXmlElement )
+			end
+		end
+		
+		def items 
+			bib.load_items_from_store if ! items_loaded?
+			
+			return @items || []
+		end
+		
+		def items_loaded?
+			return (items_loaded == true)
+		end
+				
+		def loadFromSerialElement( serialElement )
+			self.location_str = serialElement.at('/location').inner_text
+			self.id = serialElement.at('/copykey').inner_text
+			
+			# Okay, this part is potentially fragile, we have to pull out based on
+			# order in the XML, not sure if that can change. Sorry, that's HIP for you.
+			copyElements = serialElement.search('/copy/cell/data/text').collect {|e| e.inner_text}
+			# Fix this to use field lookup
+			self.location_str = bib.copy_field_lookup.text_value_for(copyElements, @@Field_labels[:location])
+			self.collection_str =  bib.copy_field_lookup.text_value_for(copyElements, @@Field_labels[:collection])
+			self.call_no = bib.copy_field_lookup.text_value_for(copyElements, @@Field_labels[:call_no])
+			self.copy_str = bib.copy_field_lookup.text_value_for(copyElements, @@Field_labels[:copy_str])
+			self.status_str = bib.copy_field_lookup.text_value_for(copyElements, @@Field_labels[:status])
+			self.notes = bib.copy_field_lookup.text_value_for(copyElements, @@Field_labels[:notes])
+			
+			
+			#Okay, got to get the 'runs' for summary holdings info.
+			self.runs ||= []
+			serialElement.search('/runlist/run').each do |run|
+				label = run.at('/runlabel').inner_text
+				run.search('/data/rundata').each do |rundata|
+          run = {:label => label, :statement => textValue(rundata.at('/text'))}
+          run[:note] = textValue(rundata.at('/note'))
+				  
+          self.runs.push( run )
+				end
+			end
+		end	
+		
+		# Not too useful, use coverage_str_to_a instead usually
+		def coverage_str
+			return runs.to_s
+		end
+		
+		# Over-riding
+		def coverage_str_to_a
+			runs.collect do |r|
+        s = ''
+        (s << r[:label] << ": ") if (! r[:label].blank?) && r[:label] != "Main run"
+        s << r[:statement]
+        s << '-- ' << r[:note] if r[:note]
+        s
+      end
+		end
+		
+		def register_item(item)
+			items ||= []
+			
+			unless items.include?(item)
+				items.push(item)
+			end
+		end
+	end
+end

data/lib/holding.rb

@@ -0,0 +1,32 @@
+class Holding
+  attr_accessor :locations, :identifier
+  def initialize
+    @locations = []
+  end
+  def find_location(location)
+    @locations.each do | loc |
+      return loc if loc.name == location
+    end
+    return nil
+  end
+  
+  def find_item_by_attribute(key, value)
+    @locations.each do | loc |
+      loc.items.each do | item |
+        return if item.instance_variable_get('@'+key) == value
+      end
+    end
+    return nil
+  end
+end
+
+class HoldingLocation
+  attr_accessor :name, :code, :items
+  def initialize
+    @items = []
+  end
+end
+
+class HoldingItem
+  attr_accessor :identifier, :status_code, :status_date, :status, :call_number, :enumeration, :chron, :year
+end

data/lib/marc_helper.rb

@@ -0,0 +1,254 @@
+
+
+module MarcHelper
+
+  # Takes an array of ruby MARC objects, adds ServiceResponses
+  # for the 856 links contained. 
+  # Returns a hash of arrays of ServiceResponse objects added, keyed
+  # by service type value string. 
+  def add_856_links(request, marc_records, options = {})
+    options[:default_service_type] ||= "fulltext"
+    options[:match_reliability] ||= ServiceResponse::MatchExact
+
+    responses_added = Hash.new
+    
+    # Keep track of urls to avoid putting the exact same url in twice
+    urls_seen = Array.new
+    
+    marc_records.each do |marc_xml|
+    
+      marc_xml.find_all {|f| '856' === f.tag}.each do |field|
+        # Might have more than one $u, in which case we want to
+        # possibly add each of them. Might have 0 $u in which case
+        # we skip. 
+        field.subfields.find_all {|sf| sf.code == 'u'}.each do |sf|        
+          url = sf.value 
+          
+          # Already got it from another catalog record?
+          next if urls_seen.include?(url)
+  
+          # Trying to avoid duplicates with SFX/link resolver. 
+          next if  should_skip_856_link?(request, marc_xml, url)
+          
+          urls_seen.push(url)
+          
+          
+          display_name = nil
+          if field['y']
+            display_name = field['y']
+          else
+            # okay let's try taking just the domain from the url
+            begin
+              u_obj = URI::parse( url )
+              display_name = u_obj.host
+            rescue Exception
+            end
+            # Okay, can't parse out a domain, whole url then.
+            display_name = url if display_name.nil?
+          end
+          # But if we've got a $3, the closest MARC comes to a field
+          # that explains what this actually IS, use that too please.
+          display_name = field['3'] + ' from ' + display_name if field['3']
+  
+          # Build the response. 
+          
+          response_params = {:service=>self, :display_text=>display_name, :url=>url}
+          # get all those $z subfields and put em in notes.      
+          response_params[:url] = url
+    
+          # subfield 3 is being used for OCA records loaded in our catalog.
+          response_params[:notes] =
+          field.subfields.collect {|f| f.value if (f.code == 'z') }.compact.join('; ')
+  
+          is_journal = (marc_xml.leader[7,1] == 's')
+          unless ( field['3'] || ! is_journal ) # subfield 3 is in fact some kind of coverage note, usually 
+            response_params[:notes] += "; " unless response_params[:notes].blank? 
+            response_params[:notes] += "Dates of coverage unknown."
+          end
+  
+          
+          unless ( options[:match_reliability] == ServiceResponse::MatchExact )
+            response_params[:match_reliability] = options[:match_reliability]
+  
+            response_params[:edition_str] = edition_statement(marc_xml)
+          end
+  
+          # Figure out the right service type value for this, fulltext, ToC,
+          # whatever.
+          response_params[:service_type_value] = service_type_for_856( field, options ) 
+  
+          # fulltext urls from MARC are always marked as specially stupid.
+          response_params[:coverage_checked] = false
+          response_params[:can_link_to_article] = false
+  
+          # Some debugging info, add the 001 bibID if we have one.
+          
+          response_params[:debug_info] = "BibID: #{marc_xml['001'].value}" if marc_xml['001']
+  
+          
+          # Add the response
+          response = request.add_service_response(response_params)
+          
+          responses_added[response_params[:service_type_value]] ||= Array.new
+          responses_added[response_params[:service_type_value]].push(response)
+        end
+      end
+    end
+    return responses_added
+  end
+
+  # Used by #add_856_links. Complicated logic to try and avoid
+  # presenting a URL from the catalog that duplicates what SFX does,
+  # but present a URL from the catalog when it's really needed.
+  #
+  # One reason not to include Catalog links for an article-level
+  # citation, even if SFX provided no targets, is maybe SFX
+  # provided no targets because SFX _knew_ that the _particular date_
+  # requested is not available. The catalog doesn't know that, but
+  # we don't want to show a link from the catalog that SFX really
+  # already knew wasn't going to be available.
+  #
+  # So:
+  #
+  # If this is a journal, skip the URL if it matches in our
+  # SFXUrl finder, because that means we think it's an SFX controlled
+  # URL. But if it's not a journal, use it anyway, because it's probably
+  # an e-book that is not in SFX, even if it's from a vendor who is in
+  # SFX. We use MARC leader byte 7 to tell if it's a journal. Confusing enough?
+  # Not yet!  Even if it is a journal, if this isn't an article-level
+  # cite and there are no other full text already provided, we
+  # still include. 
+  def should_skip_856_link?(request, marc_record, url)
+     is_journal = (marc_record.leader[7,1] == 's')
+
+     return (  is_journal && 
+               SfxUrl.sfx_controls_url?(url) && 
+                !(  request.title_level_citation? &&     
+                    request.get_service_type("fulltext").length == 0  
+                 )
+              )
+  end
+
+  # Take a ruby Marc Field object representing an 856 field,
+  # decide what umlaut service type value to map it to. Fulltext, ToC, etc.
+  # This is neccesarily a heuristic guess, Marc doesn't have enough granularity
+  # to really let us know for sure. 
+  def service_type_for_856(field, options)
+    options[:default_service_type] ||= "fulltext_title_level"
+
+    # LC records here at hopkins have "Table of contents only" in the 856$3
+      # Think that's a convention from LC? 
+      if (field['3'] && field['3'].downcase =~ /table of contents( only)?/)
+        return "table_of_contents"
+      elsif (field['3'] && field['3'].downcase =~ /description/)
+        # If it contains the word 'description', it's probably an abstract.
+        # That's the best we can do, sadly. 
+        return "abstract"
+      elsif (field['3'] && field['3'].downcase == 'sample text')
+        # LC records often include these links. 
+        return "excerpts"
+      elsif ( field['u'] =~ /www\.loc\.gov/ )
+        # Any other loc.gov link, we know it's not full text, don't put
+        # it in full text field, put it as "see also". 
+        return "highlighted_link"
+      else
+        return options[:default_service_type]
+      end
+  end
+
+  # A MARC record has two dates in it, date1 and date2. Exactly
+  # what they represent is something of an esoteric mystery.
+  # But this will return them both, in an array. 
+  def get_years(marc)
+    array = []
+    
+    # no marc 008? Weird, but okay. 
+    return array unless marc['008'] 
+    
+    date1 = marc['008'].value[7,4]
+    date1.strip! if date1
+    array.push(date1) unless date1.blank?
+    
+    date2 = marc['008'].value[11,4]
+    date2.strip! if date2
+    array.push(date2) unless date2.blank?
+
+    return array
+  end
+
+  # Take the title out of a marc record
+  def get_title(marc)
+    marc['245'].find_all {|sf| sf.code == "a" || sf.code == "b" || sf.code == "k"}.collect {|sf| sf.text}.join(" ").sub(/\s*[;:\/.,]\s*$/)
+  end
+
+  
+  # From a marc record, get a string useful to display for identifying
+  # which edition/version of a work this represents. 
+  def edition_statement(marc, options = {})
+    options[:include_repro_info] ||= true
+    options[:exclude_533_fields] = ['7','f','b', 'e']
+
+    parts = Array.new
+
+    return "" unless marc
+    
+    #245$h GMD
+    unless ( marc['245'].blank? || marc['245']['h'].blank? )
+      parts.push('(' + marc['245']['h'].gsub(/[^\w\s]/, '').strip.titlecase + ')')
+    end
+
+    #250
+    if ( marc['250'])
+      parts.push( marc['250']['a'] ) unless marc['250']['a'].blank?
+      parts.push( marc['250']['b'] ) unless marc['250']['b'].blank?
+    end
+    
+    # 260
+    if ( marc['260'])
+      if (marc['260']['b'] =~ /s\.n\./)
+        parts.push(marc['260']['a']) unless marc['260']['a'].blank?
+      else
+        parts.push(marc['260']['b']) unless marc['260']['b'].blank?
+      end
+      parts.push( marc['260']['c'] ) unless marc['260']['c'].blank?
+    end
+      
+    # 533
+    if options[:include_repro_info] && marc['533']
+      marc['533'].subfields.each do |s|
+        if ( s.code == 'a' )
+          parts.push('<em>' + s.value.gsub(/[^\w\s]/, '') + '</em>:'  )  
+        elsif (! options[:exclude_533_fields].include?( s.code ))
+          parts.push(s.value)
+        end       
+      end
+    end
+      
+    return nil if parts.length == 0
+
+    return parts.join(' ')
+  end
+
+  # AACR2 "General Material Designation" . While these are (I think?)
+  # controlled, it's actually really hard to find the list. Maybe they're
+  # only semi-controlled. 
+  # ONE list can be found here: http://www.oclc.org/bibformats/en/onlinecataloging/default.shtm#BCGFECEG
+  def gmd_values
+    # 'computer file' is an old one that may still be found in data. 
+    return ['activity card', 
+'art original','art reproduction','braille','chart','diorama','electronic resource','computer file', 'filmstrip','flash card','game','globe','kit','manuscript','map','microform','microscope slides','model','motion picture','music','picture','realia','slide','sound recording','technical drawing','text','toy','transparency','videorecording']
+  end
+
+  # removes something that looks like an AACR2 GMD in square brackets from
+  # the string. Pretty kludgey. 
+  def strip_gmd(arg_string, options = {})
+    options[:replacement] ||= ':'
+    
+    gmd_values.each do |gmd_val|
+      arg_string = arg_string.sub(/\[#{gmd_val}( \((tactile|braile|large print)\))?\]/, options[:replacement])
+    end
+    return arg_string
+  end
+
+  
+end

data/lib/metadata_helper.rb

@@ -0,0 +1,312 @@
+# Helper class to get keyword searchable terms from OpenURL author and title
+#
+# OpenURLs have some commonly agreed upon metadata elements. This module is
+# meant to help simplify things by sorting through the metadata and extracting
+# what we need in a simpler interface. These values are specifically constructed
+# from the citation to work well as keyword searches in other services.
+#
+# Also includes some helpful methods for getting identifiers out in a convenient to work with way, regardless of non-standard ways they may have been stored. 
+
+module MetadataHelper
+  include MarcHelper # for strip gmd functionality
+
+  # DEPRECATED, not flexible enough, you really need to custom fit
+  # for your given target. 
+  # method that accepts a referent to return hash of common metadata elements 
+  # choosing the available element for the format and the best available for 
+  # searching. Wrapper around the other methods.
+  def get_search_terms(rft)
+    title = get_search_title(rft)
+    creator = get_search_creator(rft)    
+    
+    # returns a hash of values so that more keys can be added
+    # and not break services that use this module
+    return {:title => title, :creator => creator}
+  end
+
+
+  # A utility method to 'normalize' a title, for use when trying to match a
+  # title from one place with records in another database.
+  # Does lowercasing and removing puncutation, but also stripping out
+  # a bunch of other things that may result
+  # in false negatives. Exactly how you want to do for best results depends
+  # on the particular data you are working with, you need to experiment to see.
+  # MANY options are offered, although defaults are somewhat sensible.
+  # Much of this stuff especially takes account of titles that may have
+  # been generated from mark.
+  # Will never return the emtpy string, will sometimes return nil. 
+  def normalize_title(arg_title, options = {})
+    # default options
+    options[:rstrip_parens] ||= true
+    options[:remove_all_parens] ||= true
+    options[:strip_gmd] ||= true
+    options[:subtitle_on_semicolon] ||=false
+    options[:remove_subtitle] ||= false
+    options[:normalize_ampersand] ||= true
+    options[:remove_punctuation] ||= true
+    # Even if you're removing other punctuation, keep the apostrophes?
+    options[:keep_apostrophes] ||=false
+    
+    return nil if arg_title.nil?
+    title = arg_title.clone
+    
+    return nil if title.blank?
+
+    # Sometimes titles given in the OpenURL have some additional stuff
+    # in parens at the end, that messes up the search and isn't really
+    # part of the title. Eliminate!
+    title.gsub!(/\([^)]*\)\s*$/, '') if options[:rstrip_parens]
+    # Or, not even just at the end, but anywhere! 
+    title.gsub!(/\([^)]*\)/, '') if options[:remove_all_parens]
+
+    # Remove things in brackets, part of an AACR2 GMD that's made it in.
+    # replace with ':' so we can keep track of the fact that everything
+    # that came afterwards was a sub-title like thing. 
+    title = strip_gmd(title) if options[:strip_gmd]
+    
+    # There seems to be some catoging/metadata disagreement about when to
+    # use ';' for a subtitle instead of ':'. Normalize to ':'.
+    title.sub!(/[\;]/, ':') if options[:subtitle_on_semicolon]
+
+    title.sub!(/\:(.*)$/, '') if options[:remove_subtitle]
+    
+    # Change ampersands to 'and' for consistency, we see it both ways.
+    title.gsub!(/\&/, ' and ') if options[:normalize_ampersand]
+      
+    # remove non-alphanumeric, excluding apostrophe
+    title.gsub!(/[^\w\s\']/, ' ') if options[:remove_punctuation]
+
+    # apostrophe not to space, just eat it.
+    title.gsub!(/[\']/, '') if options[:remove_punctuation] && ! options[:keep_apostrophes]
+
+    # compress whitespace
+    title.strip!
+    title.gsub!(/\s+/, ' ')
+
+    title.downcase!
+    
+    title = nil if title.blank?
+
+    return title
+  end
+
+  # pick title out of OpenURL referent from best element available,
+  # no normalization. 
+  def raw_search_title(rft)
+    # Just make one call to create metadata hash
+    metadata = rft.metadata
+    title = nil
+    if rft.format == 'journal' && metadata['atitle']
+      title = metadata['atitle']
+    elsif rft.format == 'book'
+      title = metadata['btitle'] unless metadata['btitle'].blank?
+      title = metadata['title'] if title.blank?
+      
+    # Well, if we don't know the format and we do have a title use that.  
+    # This might happen if we only have an ISBN to start and then enhance.
+    # So should services like Amazon also enhance with a format, should
+    # we simplify this method to not worry about format so much, or do we
+    # keep this as is?
+    elsif metadata['btitle']
+      title = metadata['btitle']
+    elsif metadata['title']
+      title = metadata['title']
+    elsif metadata['jtitle']
+      title = metadata['jtitle']
+    end
+    return title
+  end
+  
+  # chooses the best available title for the format, normalizes
+  def get_search_title(rft, options = {})
+    #defaults
+    options = {:remove_all_parens => true,
+               :subtitle_on_semicolon => true,
+               :remove_subtitle => true,
+               :remove_punctuation => true}.merge(options)
+
+    title = raw_search_title(rft)
+    
+    return normalize_title(title, options)
+    
+  end
+  
+  # chooses the best available creator for the format
+  def get_search_creator(rft)
+    # Just make one call to create metadata hash
+    metadata = rft.metadata
+    # Identify dc.creator query. Prefer aulast alone if available.
+    creator = nil
+    
+    creator = metadata['aulast'] unless metadata['aulast'].blank?
+    creator = metadata['au'] if creator.blank?
+    # FIXME if capital letters are next to each other should we insert a space?
+    #   Should we assume capitals next to each other are initials?
+    #   Maybe only if we use au? 
+    #   Logic like this makes refactoring to use Referent.to_citation less useful.
+    
+    # FIXME strip out commas from creator if we use au?
+
+    return nil if creator.blank?
+    
+    return creator
+  end
+
+  def get_top_level_creator(rft)
+     # If it's a non-journal thing, add the author if we have an aulast (preferred) or au. 
+    # But wait--if it's a book _part_, don't include the author name, since
+    # it _might_ just be the author of the part, not of the book. 
+    unless (rft.format == "journal" ||
+              ( rft.format == "book" &&  ! rft.metadata['atitle'].blank?))
+       return get_search_creator(rft)
+    end
+    return nil
+  end
+  
+  # oclcnum, lccn, and isbn are both _supposed_ to be stored as identifiers
+  # with an info: uri. info:oclcnum/#, info:lccn/#. But SFX sometimes stores
+  # them in the referent metadata instead: rft.lccn, rft.oclcnum. .
+  #
+  # On the other hand, isbn and issn can legitimately be included in referent
+  # metadata or as a urn. 
+  #
+  # This method will find you an identifier accross multiple places.
+  #
+  # type:  :urn or :info
+  # subscheme: "lccn", "oclcnum", "isbn", "issn", or anything else that could be found in either a urn an info uri or a referent metadata.
+  # referent: an umlaut Referent object
+  #
+  # returns nil if no identifier found, otherwise the bare identifier (not formatted into a urn/uri right now. Option should be maybe be added?) 
+  def get_identifier(type, sub_scheme, referent, options = {} )
+    options[:multiple] ||= false
+    
+    raise Exception.new("type must be :urn or :info") unless type == :urn or type == :info
+
+    prefix = case type
+               when :info then "info:#{sub_scheme}/"
+               when :urn  then "urn:#{sub_scheme}:"
+             end
+    
+    bare_identifier = nil
+    identifiers = referent.identifiers.collect {|id| $1 if id =~ /^#{prefix}(.*)/}.compact
+
+    if ( identifiers.blank? &&  ['lccn', 'oclcnum', 'isbn', 'issn', 'doi', 'pmid'].include?(sub_scheme) )
+      # try the referent metadata
+      from_rft = referent.metadata[sub_scheme]
+      identifiers = [from_rft] unless from_rft.blank?
+    end
+
+    if ( options[:multiple])
+      return identifiers
+    elsif ( identifiers[0].blank? )
+      return nil
+    else
+      return identifiers[0]
+    end        
+    
+  end
+
+  # finds and normalizes an LCCN. If multiple LCCNs are in the record,
+  # returns the first one. 
+  def get_lccn(rft)
+    lccn = get_identifier(:info, "lccn", rft)
+    
+    lccn = normalize_lccn(lccn)
+    
+    return lccn
+  end
+
+  # Gets an ISSN, makes sure it's a valid ISSN or else returns nil.
+  # So will return a valid ISSN (NOT empty string) or nil. 
+  def get_issn(rft)
+    issn = rft.metadata['issn']
+    issn = nil unless issn =~ /\d{4}(-)?\d{3}(\d|X)/
+    return issn
+  end
+
+  # Some normalization. See:
+  # http://info-uri.info/registry/OAIHandler?verb=GetRecord&metadataPrefix=reg&identifier=info:lccn/
+  # doesn't validate right now, only normalizes.
+  # tbd, raise exception if invalid string. 
+  def normalize_lccn(lccn)
+    if ( lccn )
+      # remove whitespace
+      lccn = lccn.gsub(/\s/, '')
+      # remove any forward slashes and anything after them
+      lccn = lccn.sub(/\/.*$/, '')
+      # pad anything after a hyphen before removing hyphen, if neccesary
+      lccn = lccn.sub(/-(.*)/) do |match_str| 
+        if $1.length < 6 
+          ("0" * (6 - $1.length)) + $1 
+        else
+          $1
+        end
+      end
+    end
+    return lccn
+  end
+
+  # Gets isbn, also removes any weird stuff on the end sometimes
+  # included as 'isbn', but not part of the isbn. Like (paperback)
+  # and such.
+  def get_isbn(rft)
+    isbn = get_identifier(:urn, "isbn", rft)
+    isbn = isbn.gsub(/[^\dX-]/, '') if isbn
+    return nil if isbn.blank?
+    return isbn
+  end
+
+  def get_oclcnum(rft)
+    return get_identifier(:info, "oclcnum", rft)    
+  end
+
+  def get_doi(rft)
+    return get_identifier(:info, "doi", rft)
+  end
+
+  def get_pmid(rft)
+    return get_identifier(:info, "pmid", rft)
+  end
+
+  # Returns an array, possibly empty. 
+  def get_gpo_item_nums(rft)
+    # In a technically illegal but used by OCLC info:gpo uri
+    ids = get_identifier(:info, "gpo", rft, :multiple => true)
+    # Remove the uri part. 
+    return ids.collect {|id| id.sub(/^info:gpo\//, '')  }
+  end
+
+  def get_sudoc(rft)
+    # Don't forget to unescape the sudoc that was escaped to maek it a uri!
+    
+    # Option 1: In a technically illegal but oh well info:sudoc uri
+    
+    sudoc = get_identifier(:info, "sudoc", rft)
+    sudoc = CGI.unescape(sudoc) if sudoc
+
+    # Option 2: rsinger's purl for sudoc. http://dilettantes.code4lib.org/2009/03/a-uri-scheme-for-sudocs/    
+    unless sudoc
+      sudoc = rft.identifiers.collect {|id| $1 if id =~ /^http:\/\/purl.org\/NET\/sudoc\/(.*)$/}.compact.slice(0)
+      sudoc = CGI.unescape(sudoc) if sudoc
+    end
+
+    return sudoc
+  end
+
+  def get_year(rft)
+    # Some link generators use an illegal 'year' parameter    
+    if (date = (rft['date'] || rft['year']))
+      return date[0,4]
+    end
+    return nil
+  end
+
+  # Look at weird bad OpenURLs, use heuristics to see if the 'title' probably
+  # represents a journal rather than a book. 
+  def title_is_serial?(rft)
+    (rft.format != "book" &&
+    ( ! rft.metadata['jtitle'].blank?) &&
+    rft.metadata['btitle'].blank?)    
+  end
+  
+end