exlibris-primo 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Exlibris::Primo
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Exlibris::Primo'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/exlibris-primo.rb

@@ -0,0 +1,11 @@
+PATH = File.dirname(__FILE__) + "/exlibris/primo/"
+[ 
+  'web_service',
+  'holding',
+  'related_link',
+  'rsrc',
+  'toc',
+  'searcher'
+].each do |library|
+  require PATH + library
+end

data/lib/exlibris/primo/holding.rb

@@ -0,0 +1,185 @@
+# == Overview
+# Exlibris::Primo::Holding represents a Primo holding.
+# This class should be extended to create Primo source objects for 
+# expanding holdings information, linking to Primo sources, and storing 
+# additional metadata based on those sources.
+#
+# == Tips on Extending
+# When extending the class, a few basics guidelines should be observed.
+# 1.  A Exlibris::Primo::Holding is initialized from random Hash of parameters.
+#     Instance variables are created from these parameters for use in the class.
+#
+# 2.  A Exlibris::Primo::Holding can be initialized from an input 
+#     Exlibris::Primo::Holding by specifying the reserved
+#     parameter name :holding, i.e. :holding => input_holding.
+#     If the input holding has instance variables that are also specified in
+#     the random Hash, the value in the Hash takes precedence.
+#
+# 3.  The following methods are available for overriding:
+#     expand -    expand holdings information based on data source. default: [self]
+#     dedup? -    does this data source contain duplicate holdings that need to be deduped? default: false
+#
+# 4.  The following instance variables will be saved in the view_data and will be available
+#     to a local holding partial:
+#     @record_id, @source_id, @original_source_id, @source_record_id,
+#     @availlibrary, @institution_code, @institution, @library_code, @library,
+#     @status_code, @status, @id_one, @id_two, @origin, @display_type, @coverage, @notes,
+#     @url, @request_url, @source_data
+#
+# 5.  Additional source data should be saved in the @source_data instance variable.
+#     @source_data is a hash that can contain any number of string elements,
+#     perfect for storing local source information.
+#
+# == Examples
+# Example of Primo source implementations are:
+# * Exlibris::Primo::Source::Aleph
+module Exlibris
+  module Primo
+    class Holding
+      @base_attributes = [ :record_id, :source_id, :original_source_id, :source_record_id,
+        :availlibrary, :institution_code, :institution, :library_code, :library,
+        :status_code, :status, :id_one, :id_two, :origin, :display_type, :coverage, :notes,
+        :url, :request_url, :source_data ]
+      # Make sure attribute you're aliasing in in base_attributes
+      @attribute_aliases = { :collection => :id_one, :call_number => :id_two }
+      @required_parameters = [ :base_url, :record_id, :source_id, 
+        :original_source_id, :source_record_id, :availlibrary,
+        :institution_code, :library_code, :id_one, :id_two, :status_code ]
+      @parameter_default_values = { :vid => "DEFAULT", :config => {}, 
+        :max_holdings => 10, :coverage => [], :source_data => {} }
+      @decode_variables = { 
+        :institution => {}, 
+        :library => { :address => "libraries" },
+        :status => { :address => "statuses" }
+      }
+      class << self; attr_reader :base_attributes, :attribute_aliases, :required_parameters, :parameter_default_values, :decode_variables end
+
+      def initialize(parameters={})
+        # Set attr_readers
+        base_attributes = (self.class.base_attributes.nil?) ? 
+          Exlibris::Primo::Holding.base_attributes : self.class.base_attributes
+        base_attributes.each { |attribute|
+          self.class.send(:attr_reader, attribute)
+        }
+        # Defensive copy the holding parameter.
+        holding = parameters[:holding].clone unless parameters[:holding].nil?
+        raise "Initialization error in #{self.class}. Unexpected holding parameter: #{holding.class}." unless holding.kind_of? Holding or holding.nil?
+        # Copy the defensive copy of holding to self.
+        holding.instance_variables.each { |name| 
+          instance_variable_set((name).to_sym, holding.instance_variable_get(name)) 
+        } if holding.kind_of? Holding
+        # Add required instance variables, raising an exception if they're missing
+        # Params passed in overwrite instance variables copied from the holding
+        required_parameters = (self.class.required_parameters.nil?) ? 
+          Exlibris::Primo::Holding.required_parameters : self.class.required_parameters
+        required_parameters.each do |param|
+          instance_variable_set(
+            "@#{param}".to_sym, 
+            parameters.delete(param) { 
+              instance_variable_get("@#{param}") if instance_variable_defined?("@#{param}") }
+          )
+          raise_required_parameter_error param unless instance_variable_defined?("@#{param}")
+        end
+        # Set additional instance variables from passed parameters
+        # Params passed in overwrite instance variables copied from the holding
+        parameters.each { |param, value| 
+          instance_variable_set("@#{param}".to_sym, value)
+        }
+        # If appropriate, add defaults to non-required elements
+        parameter_default_values = (self.class.parameter_default_values.nil?) ? 
+          Exlibris::Primo::Holding.parameter_default_values : self.class.parameter_default_values
+        parameter_default_values.each { |param, default|
+          instance_variable_set("@#{param}".to_sym, default) unless instance_variable_defined?("@#{param}")
+        }
+        # Set decoded fields
+        decode_variables = (self.class.decode_variables.nil?) ? 
+          Exlibris::Primo::Holding.decode_variables : self.class.decode_variables
+        decode_variables.each { |var, decode_params|
+          decode var, decode_params, true
+        }
+        # Deep link URL to record
+        @url = primo_url if @url.nil?
+        # Set source parameters
+        @source_config = @config["sources"][source_id] unless @config["sources"].nil?
+        @source_class = @source_config["class_name"] unless @source_config.nil?
+        @source_url = @source_config["base_url"] unless @source_config.nil?
+        @source_type = @source_config["type"] unless @source_config.nil?
+        @source_data = {
+          :source_class => @source_class,
+          :source_url => @source_url,
+          :source_type => @source_type
+        }
+        # Set aliases for convenience
+        attribute_aliases = (self.class.attribute_aliases.nil?) ? 
+          Exlibris::Primo::Holding.attribute_aliases : self.class.attribute_aliases
+        attribute_aliases.each { |alias_name, method_name|
+          begin
+            self.class.send(:alias_method, alias_name.to_sym, method_name.to_sym)
+          rescue NameError => ne
+            raise NameError, "Error in #{self}. Make sure method, #{method_name}, is defined. You may need to add it to #{self} @base_attributes.\nRoot exception: #{ne.message}"
+          end
+        }
+      end
+    
+      # Returns an array of self.
+      # Should be overridden by source subclasses to map multiple holdings
+      # to one availlibrary.
+      def expand
+        return [self]
+      end
+
+      # Determine if we're de-duplicating.
+      # Should be overridden by source subclasses if appropriate.
+      def dedup?
+        return false
+      end
+    
+      # Return this holding as a new holdings subclass instance based on source
+      def to_source
+        return self if @source_class.nil?
+        begin
+          # Get source class in Primo::Source module
+           return Exlibris::Primo::Source.const_get(@source_class).new(:holding => self)
+        rescue Exception => e
+          Rails.logger.error("#{e.message}")
+          Rails.logger.error("Class #{@source_class} can't be found in Exlibris::Primo::Source.  
+            Please check primo.yml to ensure the class_name is defined correctly.  
+            Not converting to source.")
+          return self
+        end
+      end
+
+      def [](key)
+        raise "Error in #{self.class}. #{key} doesn't exist or is restricted." unless self.class.base_attributes.include?(key)
+        method(key).call
+      end
+
+      protected
+      def decode(var, decode_params={}, refresh=false)
+        return instance_variable_get("@#{var}") unless (not instance_variable_defined?("@#{var}")) or refresh
+        code_sym = (decode_params[:code].nil?) ? "#{var}_code".to_sym : decode_params[:code]
+        code = instance_variable_get("@#{code_sym}")
+        config_sym = (decode_params[:config].nil?) ? :config : decode_params[:config]
+        config = instance_variable_get("@#{config_sym}")
+        address = (decode_params[:address].nil?) ? "#{var}s" : decode_params[:address]
+        instance_variable_set("@#{var}", 
+          (config[address].nil? or config[address][code].nil?) ? 
+            code : config[address][code]) unless code.nil?
+      end
+
+      # Returns Primo deep link URL to record
+      def primo_url
+        "#{@base_url}/primo_library/libweb/action/dlDisplay.do?docId=#{@record_id}&institution=#{@institution_code}&vid=#{@vid}"
+      end
+ 
+      private
+      # def self.add_attr_reader(reader)
+      #   attr_reader reader.to_sym
+      # end
+      # 
+      def raise_required_parameter_error(parameter)
+        raise "Initialization error in #{self.class}. Missing required parameter: #{parameter}."
+      end
+    end
+  end
+end

data/lib/exlibris/primo/related_link.rb

@@ -0,0 +1,19 @@
+module Exlibris
+  module Primo
+    # Class for handling Primo related links from links/addlink
+    class RelatedLink
+      @base_attributes = [ :record_id, :addlink, :url, :display,  :notes ]
+      class << self; attr_reader :base_attributes end
+      def initialize(options={})
+        base_attributes = (self.class.base_attributes.nil?) ? 
+          Exlibris::Primo::RelatedLink.base_attributes : self.class.base_attributes
+        base_attributes.each { |attribute|
+          self.class.send(:attr_reader, attribute)
+        }
+        options.each { |option, value| 
+          self.instance_variable_set(('@'+option.to_s).to_sym, value) 
+        }
+      end
+    end
+  end
+end

data/lib/exlibris/primo/rsrc.rb

@@ -0,0 +1,19 @@
+module Exlibris
+  module Primo
+    # Class for handling Primo Rsrcs from links/linktorsrc
+    class Rsrc
+      @base_attributes = [ :record_id, :linktorsrc, :v, :url, :display, :institution_code, :origin, :notes ]
+      class << self; attr_reader :base_attributes end
+      def initialize(options={})
+        base_attributes = (self.class.base_attributes.nil?) ? 
+          Exlibris::Primo::Rsrc.base_attributes : self.class.base_attributes
+        base_attributes.each { |attribute|
+          self.class.send(:attr_reader, attribute)
+        }
+        options.each { |option, value| 
+          self.instance_variable_set(('@'+option.to_s).to_sym, value) 
+        }
+      end
+    end
+  end
+end

data/lib/exlibris/primo/searcher.rb

@@ -0,0 +1,292 @@
+# == Overview
+# Searcher searches Primo for records.
+# Searcher must have sufficient metadata to make 
+# the request. Sufficient means either:
+#     * We have a Primo doc id
+#     * We have either an isbn OR an issn
+#     * We have a title AND an author AND a genre
+# If none of these criteria are met, Searcher.search
+# will raise a RuntimeException. 
+
+module Exlibris
+  module Primo
+    class Searcher
+      #@required_setup = [ :base_url ]
+      #@setup_default_values = { :vid => "DEFAULT", :config => {} }
+
+      attr_reader :response, :count
+      attr_reader :cover_image, :titles, :author
+      attr_reader :holdings, :rsrcs, :tocs, :related_links
+      PNX_NS = {'pnx' => 'http://www.exlibrisgroup.com/xsd/primo/primo_nm_bib'}
+      SEARCH_NS = {'search' => 'http://www.exlibrisgroup.com/xsd/jaguar/search'}
+    
+      # Instantiates the object and performs the search for based on the input search criteria.
+      # setup parameter requires { :base_url => http://primo.server.institution.edu }
+      # Other optional parameters are :vid => "view_id", :config => { Hash of primo config settings}
+      # search_params are a sufficient combination of 
+      # { :primo_id => "primo_1", :isbn => "ISBN", :issn => "ISSN", 
+      #   :title => "=Title", :author => "Author", :genre => "Genre" }
+      def initialize(setup, search_params)
+        @holdings = []
+        @rsrcs = []
+        @tocs = []
+        @related_links = []
+        @holding_attributes = Exlibris::Primo::Holding.base_attributes
+        @base_url = setup[:base_url]
+        raise_required_setup_parameter_error :base_url if @base_url.nil?
+        @institution = setup[:institution]
+        raise_required_setup_parameter_error :institution if @institution.nil?
+        @vid = setup.fetch(:vid, "DEFAULT")
+        raise_required_setup_parameter_error :vid if @vid.nil?
+        @config = setup.fetch(:config, {})
+        raise_required_setup_parameter_error :config if @config.nil?
+        search_params.each { |param, value| self.instance_variable_set("@#{param}".to_sym, value) }
+        # Perform the search
+        search
+      end
+
+      private
+      def self.add_attr_reader(reader)
+        attr_reader reader.to_sym
+      end
+    
+      # Execute search based on instance vars
+      # Process Holdings based on display/availlibrary
+      # Process URLs based on links/linktorsrc
+      # Process TOCs based on links/linktotoc
+      def search
+        Rails.logger.warn("Insufficient search terms for #{self.class}. "+
+          "Please refer to #{self.class}'s documentation to determine how to structure "+
+          "a sufficient query.") and return if insufficient_query?
+        # Call Primo Web Services
+        unless @primo_id.nil? or @primo_id.empty?
+          get_record = Exlibris::Primo::WebService::GetRecord.new(@primo_id, @base_url, {:institution => @institution}) 
+          @response = get_record.response
+          process_record and process_search_results #since this is a search in addition to being a record call
+        else
+          brief_search = Exlibris::Primo::WebService::SearchBrief.new(search_params, @base_url, {:institution => @institution})
+          @response = brief_search.response
+          process_search_results
+        end
+      end
+
+      # Determine whether we have sufficient search criteria to search
+      # Sufficient means either:
+      #     * We have a Primo doc id
+      #     * We have either an isbn OR an issn
+      #     * We have a title AND an author AND a genre
+      def insufficient_query?
+        return false unless (@primo_id.nil? or @primo_id.empty?)
+        return false unless (@issn.nil? or @issn.empty?) and (@isbn.nil? or @isbn.empty?)
+        return false unless (@title.nil? or @title.empty?) or (@author.nil? or @author.empty?) or (@genre.nil? or @genre.empty?)
+        return true
+      end
+    
+      # Search params are determined by input to Exlibris::PrimoWS::SearchBrief
+      def search_params
+        search_params = {}
+        unless (@issn.nil? or @issn.empty?) and (@isbn.nil? or @isbn.empty?)
+          search_params[:isbn] = @isbn unless @isbn.nil?
+          search_params[:issn] = @issn if search_params.empty?
+        else
+          search_params[:title] = @title unless @title.nil?
+          search_params[:author] = @author unless @title.nil? or @author.nil?
+          search_params[:genre] = @genre unless @title.nil? or @author.nil? or @genre.nil?
+        end
+        return search_params
+      end
+    
+      # Process a single record
+      def process_record
+        @count = response.at("//search:DOCSET", SEARCH_NS)["TOTALHITS"] unless response.nil? or @count
+        response.at("//pnx:addata", PNX_NS).children.each do |addata_child|
+          name = addata_child.name and value = addata_child.inner_text if addata_child.elem?
+          next if value.nil?
+          self.class.add_attr_reader name.to_sym unless name.nil?
+          instance_variable_set("@#{name}".to_sym, "#{value}") unless name.nil?
+        end
+        @cover_image = response.at("//pnx:addata/pnx:lad02", PNX_NS).inner_text unless response.at("//pnx:addata/pnx:lad02", PNX_NS).nil?
+        @titles = []
+        response.search("//pnx:display/pnx:title", PNX_NS).each do |title|
+          @titles.push(title.inner_text)
+        end
+        @authors = []
+        response.search("//pnx:display/pnx:creator", PNX_NS).each do |creator|
+          @authors.push(creator.inner_text)
+        end
+      end
+ 
+      # Process search results
+      # Process Holdings based on display/availlibrary
+      # Process URLs based on links/linktorsrc
+      # Process TOCs based on links/linktotoc
+      def process_search_results
+        @count = response.at("//search:DOCSET", SEARCH_NS)["TOTALHITS"] unless response.nil? or @count
+        # Loop through records to set metadata for holdings, urls and tocs
+        response.search("//pnx:record", PNX_NS).each do |record|
+          # Default genre to article if necessary
+          record_genre = (record.xpath("pnx:addata/pnx:genre", PNX_NS).nil?) ? "article" : record.xpath("pnx:addata/pnx:genre", PNX_NS).inner_text
+          # Don't process if passed in genre doesn't match the record genre unless the discrepancy is only b/w journals and articles
+          # If we're working off id numbers, we should be good to proceed
+          next unless @primo_id or @isbn or @issn or 
+              @genre == record_genre or (@genre == "journal" and record_genre == "article")
+          # Just take the first element for record level elements 
+          # (should only be one, except sourceid which will be handled later)
+          record_id = record.xpath("pnx:control/pnx:recordid", PNX_NS).inner_text
+          display_type = record.xpath("pnx:display/pnx:type", PNX_NS).inner_text
+          original_source_id = record.xpath("pnx:control/pnx:originalsourceid", PNX_NS).inner_text unless record.xpath("pnx:control/pnx:originalsourceid", PNX_NS).nil?
+          original_source_ids = process_control_hash(record, "pnx:control/pnx:originalsourceid", PNX_NS)
+          source_id = record.xpath("pnx:control/pnx:sourceid", PNX_NS).inner_text
+          source_ids = process_control_hash(record, "pnx:control/pnx:sourceid", PNX_NS)
+          source_record_id = record.xpath("pnx:control/pnx:sourcerecordid", PNX_NS).inner_text
+          # Process holdings
+          source_record_ids = process_control_hash(record, "pnx:control/pnx:sourcerecordid", PNX_NS)
+          record.xpath("pnx:display/pnx:availlibrary", PNX_NS).each do |availlibrary|
+            availlibrary, institution_code, library_code, id_one, id_two, status_code, origin = process_availlibrary availlibrary
+            holding_original_source_id = (origin.nil?) ? original_source_ids[record_id] : original_source_ids[origin] unless original_source_ids.empty?
+            holding_original_source_id = original_source_id if holding_original_source_id.nil?
+            holding_source_id = (origin.nil?) ? source_ids[record_id] : source_ids[origin] unless source_ids.empty?
+            holding_source_id = source_id if holding_source_id.nil?
+            holding_source_record_id = (origin.nil?) ? source_record_ids[record_id] : source_record_ids[origin] unless source_record_ids.empty?
+            holding_source_record_id =  source_record_id if holding_source_record_id.nil?
+            holding_parameters = {
+              :base_url => @base_url, :vid => @vid, :config => @config,
+              :record_id => record_id, :original_source_id => holding_original_source_id,
+              :source_id => holding_source_id, :source_record_id => holding_source_record_id,
+              :origin => origin, :availlibrary => availlibrary, :institution_code => institution_code, 
+              :library_code => library_code, :id_one => id_one, :id_two => id_two, 
+              :status_code => status_code, :origin => origin, :display_type => display_type, :notes => ""# ,
+              # :match_reliability => 
+              #   (record.xpath("pnx:display/pnx:title", PNX_NS) and record.xpath("pnx:display/pnx:creator", PNX_NS)) ? 
+              #     (reliable_match?(:title => record.xpath("pnx:display/pnx:title", PNX_NS).inner_text, :author => record.xpath("pnx:display/pnx:creator", PNX_NS).inner_text)) ? 
+              #       ServiceResponse::MatchExact : ServiceResponse::MatchUnsure : ServiceResponse::MatchExact
+            }
+            holding = Exlibris::Primo::Holding.new(holding_parameters)
+            @holdings.push(holding) unless holding.nil?
+          end
+          # Process urls
+          record.xpath("pnx:links/pnx:linktorsrc", PNX_NS).each do |linktorsrc|
+            linktorsrc, v, url, display, institution_code, origin = process_linktorsrc linktorsrc
+            rsrc = Exlibris::Primo::Rsrc.new({
+              :record_id => record_id, :linktorsrc => linktorsrc, 
+              :v => v, :url => url, :display => display, 
+              :institution_code => institution_code, :origin => origin,
+              :notes => ""
+            }) unless linktorsrc.nil?
+            @rsrcs.push(rsrc) unless (rsrc.nil? or rsrc.url.nil?)
+          end
+          # Process tocs
+          record.xpath("pnx:links/pnx:linktotoc", PNX_NS).each do |linktotoc|
+            linktotoc, url, display = process_linktotoc linktotoc
+            toc = Exlibris::Primo::Toc.new({
+              :record_id => record_id, :linktotoc => linktotoc, 
+              :url => url, :display => display, 
+              :notes => ""
+            }) unless linktotoc.nil?
+            @tocs.push(toc) unless (toc.nil? or toc.url.nil?)
+          end
+          # Process addlinks
+          record.xpath("pnx:links/pnx:addlink", PNX_NS).each do |addlink|
+            addlink, url, display = process_addlink addlink
+            related_link = Exlibris::Primo::RelatedLink.new({
+              :record_id => record_id, :addlink => addlink, 
+              :url => url, :display => display, 
+              :notes => ""
+            }) unless addlink.nil?
+            @related_links.push(related_link) unless (related_link.nil? or related_link.url.nil?)
+          end
+        end
+      end
+
+      def process_control_hash(record, xpath, ns)
+        h = {}
+        record.xpath(xpath, ns).each do |e|
+          str = e.inner_text unless e.nil?
+          a = str.split(/\$(?=\$)/) unless str.nil?
+          v = nil
+          o = nil
+          a.each do |s|
+            v = s.sub!(/^\$V/, "") unless s.match(/^\$V/).nil?
+            o = s.sub!(/^\$O/, "") unless s.match(/^\$O/).nil?
+          end
+          h[o] = v unless (o.nil? or v.nil?)
+        end
+        return h
+      end
+    
+      # Determine how sure we are that this is a match.
+      # Dynamically compares record metadata to input values 
+      # based on the values passed in.
+      # Minimum requirement is to check title.
+      def reliable_match?(record_metadata)
+        return true unless (@primo_id.nil? or @primo_id.empty?)
+        return true unless (@issn.nil? or @issn.empty?) and (@isbn.nil? or @isbn.empty?)
+        return false if (record_metadata.nil? or record_metadata.empty? or record_metadata[:title].nil? or record_metadata[:title].empty?)
+        # Titles must be equal
+        return false unless record_metadata[:title].downcase.eql?(@title.downcase)
+        # Compare record metadata with metadata that was passed in.  
+        # Only check if the record metadata value contains the input value since we can't be too strict.
+        record_metadata.each { |type, value| return false if value.downcase.match("#{self.method(type).call}".downcase).nil?}
+        return true
+      end
+    
+      def process_availlibrary(input)
+        availlibrary, institution_code, library_code, id_one, id_two, status_code, origin =
+          nil, nil, nil, nil, nil, nil, nil
+        return institution_code, library_code, id_one, id_two, status_code, origin if input.nil? or input.inner_text.nil?
+        availlibrary = input.inner_text
+        availlibrary.split(/\$(?=\$)/).each do |s|
+          institution_code = s.sub!(/^\$I/, "") unless s.match(/^\$I/).nil?
+          library_code = s.sub!(/^\$L/, "") unless s.match(/^\$L/).nil?
+          id_one = s.sub!(/^\$1/, "") unless s.match(/^\$1/).nil?
+          id_two = s.sub!(/^\$2/, "") unless s.match(/^\$2/).nil?
+          # Always display "Check Availability" if this is from Primo.
+          #@status_code = s.sub!(/^\$S/, "") unless s.match(/^\$S/).nil?
+          status_code = "check_holdings"
+          origin = s.sub!(/^\$O/, "") unless s.match(/^\$O/).nil?
+        end
+        return availlibrary, institution_code, library_code, id_one, id_two, status_code, origin
+      end
+    
+      def process_linktorsrc(input)
+        linktorsrc, v, url, display, institution_code, origin = nil, nil, nil, nil, nil, nil
+        return linktorsrc, v, url, display, institution_code, origin if input.nil? or input.inner_text.nil?
+        linktorsrc = input.inner_text
+        linktorsrc.split(/\$(?=\$)/).each do |s|
+          v = s.sub!(/^\$V/, "")  unless s.match(/^\$V/).nil?
+          url = s.sub!(/^\$U/, "")  unless s.match(/^\$U/).nil?
+          display = s.sub!(/^\$D/, "")  unless s.match(/^\$D/).nil?
+          institution_code = s.sub!(/^\$I/, "") unless s.match(/^\$I/).nil?
+          origin = s.sub!(/^\$O/, "") unless s.match(/^\$O/).nil?
+        end
+        return linktorsrc, v, url, display, institution_code, origin
+      end
+
+      def process_linktotoc(input)
+        linktotoc, url, display, = nil, nil, nil
+        return linktotoc, url, display if input.nil? or input.inner_text.nil?
+        linktotoc = input.inner_text
+        linktotoc.split(/\$(?=\$)/).each do |s|
+          url = s.sub!(/^\$U/, "")  unless s.match(/^\$U/).nil?
+          display = s.sub!(/^\$D/, "")  unless s.match(/^\$D/).nil?
+        end
+        return linktotoc, url, display
+      end
+
+      def process_addlink(input)
+        addlink, url, display, = nil, nil, nil
+        return addlink, url, display if input.nil? or input.inner_text.nil?
+        addlink = input.inner_text
+        addlink.split(/\$(?=\$)/).each do |s|
+          url = s.sub!(/^\$U/, "")  unless s.match(/^\$U/).nil?
+          display = s.sub!(/^\$D/, "")  unless s.match(/^\$D/).nil?
+        end
+        return addlink, url, display
+      end
+
+      def raise_required_setup_parameter_error(parameter)
+        raise "Initialization error in #{self.class}. Missing required setup parameter: #{parameter}."
+      end
+    end
+  end
+end