3695068a-fea6-4cda-8ddb-e3cf6a70ab4e

Committed 10 Oct 2024 02:13PM UTC coverage: 85.402% (-1.9%) from 87.326%

Build # 3695068a-fea6-4cda-8ddb-e3cf6a70ab4e

Build Type

Pull #86

circleci

Committed by

jrgriffiniii

Commit Message

Resolving indexing bugs for the "location" field

Pull Request Pull Request #86: Restructuring the generation of access restriction text during indexing and implementing a Rake Task for indexing OAI Items using a given Set ID

Run Details

5 of 24 new or added lines in 3 files covered. (20.83%)

4 existing lines in 1 file now uncovered.

626 of 733 relevant lines covered (85.4%)

17.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.65

/lib/orangetheses/indexer.rb

# frozen_string_literal: true

require 'rsolr'
require 'rexml/document'
require 'chronic'
require 'logger'
require 'json'
require 'iso-639'
require 'yaml'
require 'erb'
require 'ostruct'

module Orangetheses
  class Indexer
    SET = 'Princeton University Senior Theses'

    NON_SPECIAL_ELEMENT_MAPPING = {
      'creator' => %w[author_display author_s],
      'contributor' => %w[advisor_display author_s],
      'format' => ['description_display'],
      'rights' => ['rights_reproductions_note_display'],
      'description' => ['summary_note_display']
    }.freeze

    REST_NON_SPECIAL_ELEMENT_MAPPING = {
      'dc.contributor.author' => %w[author_display author_s],
      'dc.contributor.advisor' => %w[advisor_display author_s],
      'dc.contributor' => %w[contributor_display author_s],
      'pu.department' => %w[department_display author_s],
      'pu.certificate' => %w[certificate_display author_s],
      'dc.format.extent' => ['description_display'],
      'dc.description.abstract' => ['summary_note_display']
    }.freeze

    HARD_CODED_TO_ADD = {
      'format' => 'Senior thesis'
    }.freeze

    # @todo This needs to be refactored into a separate Class
    def self.config_file
      File.join(File.dirname(__FILE__), '..', '..', 'config', 'solr.yml')
    end

    def self.config_yaml
      ERB.new(IO.read(config_file)).result(binding)
    rescue StandardError, SyntaxError => e
      raise("#{config_file} was found, but could not be parsed with ERB. \n#{e.inspect}")
    end

    def self.config_values
      YAML.safe_load(config_yaml)
    end

    def self.env
      ENV['ORANGETHESES_ENV'] || 'development'
    end

    def self.config
      OpenStruct.new(solr: config_values[env])
    end

    def self.default_solr_url
      config.solr['url']
    end

    def initialize(solr_server = nil)
      solr_server ||= self.class.default_solr_url

      @solr = RSolr.connect(url: solr_server)
      @logger = Logger.new($stdout)
      @logger.level = Logger::INFO
      @logger.formatter = proc do |severity, datetime, _progname, msg|
        time = datetime.strftime('%H:%M:%S')
        "[#{time}] #{severity}: #{msg}\n"
      end
    end

    # @param element  A REXML::Element (because this is what we get from the OAI gem)
    # @return  The HTTP response status from Solr (??)
    def index(metadata_element)
      dc_elements = pull_dc_elements(metadata_element)
      doc = build_hash(dc_elements)
      @logger.info("Adding #{doc['id']}")
      @solr.add(doc, add_attributes: { commitWithin: 10 })
    rescue NoMethodError => e
      @logger.error(e.to_s)
      @logger.error(metadata_element)
    rescue StandardError => e
      @logger.error(e.to_s)
      dc_elements.each { |element| @logger.error(element.to_s) }
    end

    # Constructs DataspaceDocument objects from a Hash of attributes
    # @returns [DataspaceDocument]
    def build_solr_document(**values)
      id = values['id']

      title = values['dc.title']
      title_t = title_search_hash(title)
      title_citation_display = first_or_nil(title)
      title_display = title_citation_display
      title_sort = title_sort_hash(title)

      author = values['dc.contributor.author']
      author_sort = first_or_nil(author)

      electronic_access_1display = ark_hash(values)

      identifier_other = values['dc.identifier.other']
      call_number_display = call_number(identifier_other)
      call_number_browse_s = call_number_display

      language_iso = values['dc.language.iso']
      language_facet = code_to_language(language_iso)
      language_name_display = language_facet

      embargo_lift = values['pu.embargo.lift']
      embargo_terms = values['pu.embargo.terms']
      walkin = values['pu.mudd.walkin']
      location = values['pu.location']
      access_rights = values['dc.rights.accessRights']

      attrs = {
        'id' => id,
        'title_t' => title_t,
        'title_citation_display' => title_citation_display,
        'title_display' => title_display,
        'title_sort' => title_sort,
        'author_sort' => author_sort,
        'electronic_access_1display' => electronic_access_1display,
        'pu.embargo.lift' => embargo_lift,
        'pu.embargo.terms' => embargo_terms,
        'pu.mudd.walkin' => walkin,
        'restrictions_note_display' => location,
        'dc.rights.accessRights' => access_rights,
        'call_number_display' => call_number_display,
        'call_number_browse_s' => call_number_browse_s,
        'language_facet' => language_facet,
        'language_name_display' => language_name_display
      }
      mapped = map_rest_non_special_to_solr(values)
      attrs.merge!(mapped)

      holdings = holdings_access(values)
      attrs.merge!(holdings)

      class_years = class_year_fields(values)
      attrs.merge!(class_years)

      attrs.merge!(HARD_CODED_TO_ADD)

      DataspaceDocument.new(document: attrs, logger: @logger)
    end

    # @param doc [Hash] Metadata hash with dc and pu terms
    # @return  The HTTP response status from Solr (??)
    def index_document(**values)
      solr_doc = build_solr_document(**values)

      @logger.info("Adding #{solr_doc['id']}")
      @solr.add(solr_doc, add_attributes: { commitWithin: 10 })
    rescue NoMethodError => e
      @logger.error(e.to_s)
      @logger.error(doc.to_s)
    rescue StandardError => e
      @logger.error(e.to_s)
      @logger.error(doc.to_s)
    end

    private

    def build_hash(dc_elements)
      date = choose_date(dc_elements)
      h = {
        'id' => id(dc_elements),
        'title_t' => title(dc_elements),
        'title_citation_display' => title(dc_elements),
        'title_display' => title(dc_elements),
        'title_sort' => title_sort(dc_elements),
        'author_sort' => author_sort(dc_elements),
        'format' => 'Senior Thesis',
        'pub_date_display' => date,
        'pub_date_start_sort' => date,
        'pub_date_end_sort' => date,
        'class_year_s' => date,
        'access_facet' => 'Online',
        'electronic_access_1display' => ark(dc_elements),
        'standard_no_1display' => non_ark_ids(dc_elements),
        'electronic_portfolio_s' => online_holding({})

      }
      h.merge!(map_non_special_to_solr(dc_elements))
      h.merge!(HARD_CODED_TO_ADD)
      h
    end

    # @return Array<REXML::Element>  the descriptive elements
    def pull_dc_elements(element)
      element.elements.to_a('oai_dc:dc/*')
    end

    def choose_date(dc_elements)
      dates = all_date_elements(dc_elements).map { |d| Chronic.parse(d.text) }
      dates.empty? ? nil : dates.min.year
    end

    def all_date_elements(dc_elements)
      dc_elements.select { |e| e.name == 'date' }
    end

    def title(dc_elements)
      titles = dc_elements.select { |e| e.name == 'title' }
      titles.empty? ? nil : titles.first.text
    end

    def title_sort(dc_elements)
      titles = dc_elements.select { |e| e.name == 'title' }
      title = titles.empty? ? nil : titles.first.text
      title.downcase.gsub(/[^\p{Alnum}\s]/, '').gsub(/^(a|an|the)\s/, '').gsub(/\s/, '') unless title.nil?
    end

    def ark(dc_elements)
      arks = dc_elements.select do |e|
        e.name == 'identifier' && e.text.start_with?('http://arks.princeton')
      end
      arks.empty? ? nil : { arks.first.text => dspace_display_text(dc_elements) }.to_json.to_s
    end

    def online_holding(doc)
      {
        'thesis' => {
          'call_number' => call_number(doc['dc.identifier.other']),
          'call_number_browse' => call_number(doc['dc.identifier.other']),
          'dspace' => true
        }
      }.to_json.to_s
    end

    def physical_holding(doc, accessible: true)
      {
        'thesis' => {
          'location' => 'Mudd Manuscript Library',
          'library' => 'Mudd Manuscript Library',
          'location_code' => 'mudd$stacks',
          'call_number' => call_number(doc['dc.identifier.other']),
          'call_number_browse' => call_number(doc['dc.identifier.other']),
          'dspace' => accessible
        }
      }.to_json.to_s
    end

    def non_ark_ids(dc_elements)
      non_ark_ids = dc_elements.select do |e|
        e.name == 'identifier' && !e.text.start_with?('http://arks.princeton')
      end
      return { 'Other identifier' => non_ark_ids.map(&:text) }.to_json.to_s unless non_ark_ids.empty?

      nil
    end

    def id(dc_elements)
      arks = dc_elements.select do |e|
        e.name == 'identifier' && e.text.start_with?('http://arks.princeton')
      end
      arks.empty? ? nil : arks.first.text.split('/').last
    end

    def author_sort(dc_elements)
      authors = dc_elements.select { |e| e.name == 'creator' }
      authors.empty? ? nil : authors.first.text
    end

    def choose_date_hash(doc)
      dates = all_date_elements_hash(doc).map { |_k, v| Chronic.parse(v.first) }.compact
      dates.empty? ? nil : dates.min.year
    end

    def all_date_elements_hash(doc)
      doc.select { |k, _v| k[/dc\.date/] }
    end

    def title_sort_hash(titles)
      titles.first.downcase.gsub(/[^\p{Alnum}\s]/, '').gsub(/^(a|an|the)\s/, '').gsub(/\s/, '') unless titles.nil?
    end

    # Take first title, strip out latex expressions when present to include along
    # with non-normalized version (allowing users to get matches both when LaTex
    # is pasted directly into the search box and when sub/superscripts are placed
    # adjacent to regular characters
    def title_search_hash(titles)
      return if titles.nil?

      title = titles.first
      title.scan(/\\\(.*?\\\)/).each do |latex|
        title = title.gsub(latex, latex.gsub(/[^\p{Alnum}]/, ''))
      end
      title == titles.first ? title : [titles.first, title]
    end

    def ark_hash(doc)
      arks = doc['dc.identifier.uri']
      arks.nil? ? nil : { arks.first => dspace_display_text_hash(doc) }.to_json.to_s
    end

    def call_number(non_ark_ids)
      non_ark_ids.nil? ? 'AC102' : "AC102 #{non_ark_ids.first}"
    end

    def first_or_nil(field)
      field&.first
    end

    def dspace_display_text(dc_elements)
      text = [dataspace]
      text << if dc_elements.select { |e| e.name == 'rights' }.empty?
                full_text
              else
                citation
              end
      text
    end

    def dspace_display_text_hash(doc)
      text = [dataspace]
      text << if on_site_only?(doc)
                citation
              else
                full_text
              end
      text
    end

    def on_site_only?(doc)
      output = false

      has_location = doc.key?('pu.location')
      output ||= has_location

      has_rights = doc.key?('pu.rights.accessRights')
      output ||= has_rights

      output ||= walkin?(doc)

      if output
        values = doc.fetch('dc.date.accessioned', [])
        output = if !values.empty?
                   accessioned = values.first
                   accession_date = DateTime.parse(accessioned)

                   # For theses, there is no physical copy since 2013
                   # anything 2012 and prior have a physical copy
                   # @see https://github.com/pulibrary/orangetheses/issues/76
                   accession_date.year < 2013
                 else
                   false
                 end
      end

      output ||= embargo?(doc)
      output
    end

    def embargo?(doc)
      date = doc['pu.embargo.lift'] || doc['pu.embargo.terms']
      return false if date.nil?

      date = Chronic.parse(date.first)
      if date.nil?
        @logger.info("No valid embargo date for #{doc['id']}")
        return false
      end

      date > Time.now
    end

    def embargo(doc)
      return if doc.key?('pu.embargo.lift')

      date = doc['pu.embargo.lift'] || doc['pu.embargo.terms']
      date = Chronic.parse(date.first) unless date.nil?
      date = date.strftime('%B %-d, %Y') unless date.nil?
      date
    end

    def walkin?(doc)
      walkin = doc['pu.mudd.walkin']
      !walkin.nil? && walkin.first == 'yes'
    end

    def build_embargo_text(doc)
      embargo_date = embargo(doc)
      doc_id = doc['id']
      "This content is embargoed until #{embargo_date}. For more information contact the "\
      "<a href=\"mailto:dspadmin@princeton.edu?subject=Regarding embargoed DataSpace Item 88435/#{doc_id}\"> "\
      'Mudd Manuscript Library</a>.'
    end

    def walkin_text
      'Walk-in Access. This thesis can only be viewed on computer terminals at the '\
      '<a href=\"http://mudd.princeton.edu\">Mudd Manuscript Library</a>.'
    end

    def restrictions_display_text(doc)
      if embargo?(doc)
        output = build_embargo_text(doc)

        return output
      end

      if walkin?(doc)
        output = walkin_text

        return output
      end

      fields = []
      if doc.key?('pu.location')
        field = doc['pu.location']
        fields << field
      end

      if doc.key?('dc.rights.accessRights')
        field = doc['pu.rights.accessRights']
        fields << field
      end

      flattened = fields.flatten
      flattened.compact
    end

    def dataspace
      'DataSpace'
    end

    def full_text
      'Full text'
    end

    def citation
      'Citation only'
    end

    # this is kind of a mess...
    def map_non_special_to_solr(dc_elements)
      h = {}
      NON_SPECIAL_ELEMENT_MAPPING.each do |element_name, fields|
        elements = dc_elements.select { |e| e.name == element_name }
        fields.each do |f|
          if h.key?(f)
            h[f].push(*elements.map(&:text))
          else
            h[f] = elements.map(&:text)
          end
        end
      end
      h
    end

    # default English
    def code_to_language(codes)
      languages = []
      # en_US is not valid iso code
      codes&.each do |c|
        code_lang = ISO_639.find(c[/^[^_]*/]) # en_US is not valid iso code
        l = code_lang.nil? ? 'English' : code_lang.english_name
        languages << l
      end
      languages.empty? ? 'English' : languages.uniq
    end

    def map_rest_non_special_to_solr(doc)
      h = {}
      REST_NON_SPECIAL_ELEMENT_MAPPING.each do |field_name, solr_fields|
        next unless doc.key?(field_name)

        solr_fields.each do |f|
          val = []
          val << h[f]
          val << doc[field_name]
          h[f] = val.flatten.compact
          # Ruby might have a bug here
          # if h.has_key?(f)
          #   h[f].push(doc[field_name])
          # else
          #   h[f] = doc[field_name]
          # end
        end
      end
      h
    end

    def class_year_fields(doc)
      h = {}
      if doc.key?('pu.date.classyear') && doc['pu.date.classyear'].first =~ /^\d+$/
        h['class_year_s'] = doc['pu.date.classyear']
        h['pub_date_start_sort'] = doc['pu.date.classyear']
        h['pub_date_end_sort'] = doc['pu.date.classyear']
      end
      h
    end

    # online access when there isn't a restriction/location note
    def holdings_access(doc)
      # This handles cases for items in the Mudd Library
      doc_embargoed = embargo?(doc)
      doc_on_site_only = on_site_only?(doc)

      if doc_embargoed || doc_on_site_only
        output = {
          'location' => 'Mudd Manuscript Library',
          'location_display' => 'Mudd Manuscript Library',
          'location_code_s' => 'mudd$stacks',
          'advanced_location_s' => ['mudd$stacks', 'Mudd Manuscript Library']
        }

        if doc_embargoed
          access_facet = nil
          holdings_display = physical_holding(doc, accessible: false)
        else
          access_facet = 'In the Library'
          holdings_display = physical_holding(doc)
        end

        output['access_facet'] = access_facet
        output['holdings_1display'] = holdings_display
        output
      else
        {
          'access_facet' => 'Online',
          'electronic_portfolio_s' => online_holding(doc)
        }
      end
    end
  end
end

1	# frozen_string_literal: true
2
3	require 'rsolr'	1✔
4	require 'rexml/document'	1✔
5	require 'chronic'	1✔
6	require 'logger'	1✔
7	require 'json'	1✔
8	require 'iso-639'	1✔
9	require 'yaml'	1✔
10	require 'erb'	1✔
11	require 'ostruct'	1✔
12
13	module Orangetheses	1✔
14	class Indexer	1✔
15	SET = 'Princeton University Senior Theses'	1✔
16
17	NON_SPECIAL_ELEMENT_MAPPING = {
18	'creator' => %w[author_display author_s],	1✔
19	'contributor' => %w[advisor_display author_s],
20	'format' => ['description_display'],
21	'rights' => ['rights_reproductions_note_display'],
22	'description' => ['summary_note_display']
23	}.freeze
24
25	REST_NON_SPECIAL_ELEMENT_MAPPING = {
26	'dc.contributor.author' => %w[author_display author_s],	1✔
27	'dc.contributor.advisor' => %w[advisor_display author_s],
28	'dc.contributor' => %w[contributor_display author_s],
29	'pu.department' => %w[department_display author_s],
30	'pu.certificate' => %w[certificate_display author_s],
31	'dc.format.extent' => ['description_display'],
32	'dc.description.abstract' => ['summary_note_display']
33	}.freeze
34
35	HARD_CODED_TO_ADD = {	1✔
36	'format' => 'Senior thesis'
37	}.freeze
38
39	# @todo This needs to be refactored into a separate Class
40	def self.config_file	1✔
41	File.join(File.dirname(__FILE__), '..', '..', 'config', 'solr.yml')	76✔
42	end
43
44	def self.config_yaml	1✔
45	ERB.new(IO.read(config_file)).result(binding)	76✔
46	rescue StandardError, SyntaxError => e
47	raise("#{config_file} was found, but could not be parsed with ERB. \n#{e.inspect}")	×
48	end
49
50	def self.config_values	1✔
51	YAML.safe_load(config_yaml)	76✔
52	end
53
54	def self.env	1✔
55	ENV['ORANGETHESES_ENV'] \|\| 'development'	76✔
56	end
57
58	def self.config	1✔
59	OpenStruct.new(solr: config_values[env])	76✔
60	end
61
62	def self.default_solr_url	1✔
63	config.solr['url']	76✔
64	end
65
66	def initialize(solr_server = nil)	1✔
67	solr_server \|\|= self.class.default_solr_url	76✔
68
69	@solr = RSolr.connect(url: solr_server)	76✔
70	@logger = Logger.new($stdout)	76✔
71	@logger.level = Logger::INFO	76✔
72	@logger.formatter = proc do \|severity, datetime, _progname, msg\|	76✔
73	time = datetime.strftime('%H:%M:%S')	3✔
74	"[#{time}] #{severity}: #{msg}\n"	3✔
75	end
76	end
77
78	# @param element A REXML::Element (because this is what we get from the OAI gem)
79	# @return The HTTP response status from Solr (??)
80	def index(metadata_element)	1✔
81	dc_elements = pull_dc_elements(metadata_element)	×
82	doc = build_hash(dc_elements)	×
83	@logger.info("Adding #{doc['id']}")	×
84	@solr.add(doc, add_attributes: { commitWithin: 10 })	×
85	rescue NoMethodError => e
86	@logger.error(e.to_s)	×
87	@logger.error(metadata_element)	×
88	rescue StandardError => e
89	@logger.error(e.to_s)	×
90	dc_elements.each { \|element\| @logger.error(element.to_s) }	×
91	end
92
93	# Constructs DataspaceDocument objects from a Hash of attributes
94	# @returns [DataspaceDocument]
95	def build_solr_document(**values)	1✔
96	id = values['id']	10✔
97
98	title = values['dc.title']	10✔
99	title_t = title_search_hash(title)	10✔
100	title_citation_display = first_or_nil(title)	10✔
101	title_display = title_citation_display	10✔
102	title_sort = title_sort_hash(title)	10✔
103
104	author = values['dc.contributor.author']	10✔
105	author_sort = first_or_nil(author)	10✔
106
107	electronic_access_1display = ark_hash(values)	10✔
108
109	identifier_other = values['dc.identifier.other']	10✔
110	call_number_display = call_number(identifier_other)	10✔
111	call_number_browse_s = call_number_display	10✔
112
113	language_iso = values['dc.language.iso']	10✔
114	language_facet = code_to_language(language_iso)	10✔
115	language_name_display = language_facet	10✔
116
117	embargo_lift = values['pu.embargo.lift']	10✔
118	embargo_terms = values['pu.embargo.terms']	10✔
119	walkin = values['pu.mudd.walkin']	10✔
120	location = values['pu.location']	10✔
121	access_rights = values['dc.rights.accessRights']	10✔
122
123	attrs = {
124	'id' => id,	10✔
125	'title_t' => title_t,
126	'title_citation_display' => title_citation_display,
127	'title_display' => title_display,
128	'title_sort' => title_sort,
129	'author_sort' => author_sort,
130	'electronic_access_1display' => electronic_access_1display,
131	'pu.embargo.lift' => embargo_lift,
132	'pu.embargo.terms' => embargo_terms,
133	'pu.mudd.walkin' => walkin,
134	'restrictions_note_display' => location,
135	'dc.rights.accessRights' => access_rights,
136	'call_number_display' => call_number_display,
137	'call_number_browse_s' => call_number_browse_s,
138	'language_facet' => language_facet,
139	'language_name_display' => language_name_display
140	}
141	mapped = map_rest_non_special_to_solr(values)	10✔
142	attrs.merge!(mapped)	10✔
143
144	holdings = holdings_access(values)	10✔
145	attrs.merge!(holdings)	10✔
146
147	class_years = class_year_fields(values)	10✔
148	attrs.merge!(class_years)	10✔
149
150	attrs.merge!(HARD_CODED_TO_ADD)	10✔
151
152	DataspaceDocument.new(document: attrs, logger: @logger)	10✔
153	end
154
155	# @param doc [Hash] Metadata hash with dc and pu terms
156	# @return The HTTP response status from Solr (??)
157	def index_document(**values)	1✔
158	solr_doc = build_solr_document(**values)	×
159
160	@logger.info("Adding #{solr_doc['id']}")	×
161	@solr.add(solr_doc, add_attributes: { commitWithin: 10 })	×
162	rescue NoMethodError => e
163	@logger.error(e.to_s)	×
164	@logger.error(doc.to_s)	×
165	rescue StandardError => e
166	@logger.error(e.to_s)	×
167	@logger.error(doc.to_s)	×
168	end
169
170	private	1✔
171
172	def build_hash(dc_elements)	1✔
173	date = choose_date(dc_elements)	1✔
174	h = {
175	'id' => id(dc_elements),	1✔
176	'title_t' => title(dc_elements),
177	'title_citation_display' => title(dc_elements),
178	'title_display' => title(dc_elements),
179	'title_sort' => title_sort(dc_elements),
180	'author_sort' => author_sort(dc_elements),
181	'format' => 'Senior Thesis',
182	'pub_date_display' => date,
183	'pub_date_start_sort' => date,
184	'pub_date_end_sort' => date,
185	'class_year_s' => date,
186	'access_facet' => 'Online',
187	'electronic_access_1display' => ark(dc_elements),
188	'standard_no_1display' => non_ark_ids(dc_elements),
189	'electronic_portfolio_s' => online_holding({})
190
191	}
192	h.merge!(map_non_special_to_solr(dc_elements))	1✔
193	h.merge!(HARD_CODED_TO_ADD)	1✔
194	h	1✔
195	end
196
197	# @return Array<REXML::Element> the descriptive elements
198	def pull_dc_elements(element)	1✔
199	element.elements.to_a('oai_dc:dc/*')	1✔
200	end
201
202	def choose_date(dc_elements)	1✔
203	dates = all_date_elements(dc_elements).map { \|d\| Chronic.parse(d.text) }	11✔
204	dates.empty? ? nil : dates.min.year	4✔
205	end
206
207	def all_date_elements(dc_elements)	1✔
208	dc_elements.select { \|e\| e.name == 'date' }	15✔
209	end
210
211	def title(dc_elements)	1✔
212	titles = dc_elements.select { \|e\| e.name == 'title' }	12✔
213	titles.empty? ? nil : titles.first.text	5✔
214	end
215
216	def title_sort(dc_elements)	1✔
217	titles = dc_elements.select { \|e\| e.name == 'title' }	10✔
218	title = titles.empty? ? nil : titles.first.text	5✔
219	title.downcase.gsub(/[^\p{Alnum}\s]/, '').gsub(/^(a\|an\|the)\s/, '').gsub(/\s/, '') unless title.nil?	5✔
220	end
221
222	def ark(dc_elements)	1✔
223	arks = dc_elements.select do \|e\|	4✔
224	e.name == 'identifier' && e.text.start_with?('http://arks.princeton')	9✔
225	end
226	arks.empty? ? nil : { arks.first.text => dspace_display_text(dc_elements) }.to_json.to_s	4✔
227	end
228
229	def online_holding(doc)	1✔
230	{
231	'thesis' => {	15✔
232	'call_number' => call_number(doc['dc.identifier.other']),
233	'call_number_browse' => call_number(doc['dc.identifier.other']),
234	'dspace' => true
235	}
236	}.to_json.to_s
237	end
238
239	def physical_holding(doc, accessible: true)	1✔
240	{
241	'thesis' => {	9✔
242	'location' => 'Mudd Manuscript Library',
243	'library' => 'Mudd Manuscript Library',
244	'location_code' => 'mudd$stacks',
245	'call_number' => call_number(doc['dc.identifier.other']),
246	'call_number_browse' => call_number(doc['dc.identifier.other']),
247	'dspace' => accessible
248	}
249	}.to_json.to_s
250	end
251
252	def non_ark_ids(dc_elements)	1✔
253	non_ark_ids = dc_elements.select do \|e\|	1✔
254	e.name == 'identifier' && !e.text.start_with?('http://arks.princeton')	1✔
255	end
256	return { 'Other identifier' => non_ark_ids.map(&:text) }.to_json.to_s unless non_ark_ids.empty?	1✔
257
258	nil
259	end
260
261	def id(dc_elements)	1✔
262	arks = dc_elements.select do \|e\|	1✔
263	e.name == 'identifier' && e.text.start_with?('http://arks.princeton')	1✔
264	end
265	arks.empty? ? nil : arks.first.text.split('/').last	1✔
266	end
267
268	def author_sort(dc_elements)	1✔
269	authors = dc_elements.select { \|e\| e.name == 'creator' }	9✔
270	authors.empty? ? nil : authors.first.text	3✔
271	end
272
273	def choose_date_hash(doc)	1✔
274	dates = all_date_elements_hash(doc).map { \|_k, v\| Chronic.parse(v.first) }.compact	9✔
275	dates.empty? ? nil : dates.min.year	3✔
276	end
277
278	def all_date_elements_hash(doc)	1✔
279	doc.select { \|k, _v\| k[/dc\.date/] }	13✔
280	end
281
282	def title_sort_hash(titles)	1✔
283	titles.first.downcase.gsub(/[^\p{Alnum}\s]/, '').gsub(/^(a\|an\|the)\s/, '').gsub(/\s/, '') unless titles.nil?	14✔
284	end
285
286	# Take first title, strip out latex expressions when present to include along
287	# with non-normalized version (allowing users to get matches both when LaTex
288	# is pasted directly into the search box and when sub/superscripts are placed
289	# adjacent to regular characters
290	def title_search_hash(titles)	1✔
291	return if titles.nil?	11✔
292
293	title = titles.first	4✔
294	title.scan(/\\\(.*?\\\)/).each do \|latex\|	4✔
295	title = title.gsub(latex, latex.gsub(/[^\p{Alnum}]/, ''))	2✔
296	end
297	title == titles.first ? title : [titles.first, title]	4✔
298	end
299
300	def ark_hash(doc)	1✔
301	arks = doc['dc.identifier.uri']	13✔
302	arks.nil? ? nil : { arks.first => dspace_display_text_hash(doc) }.to_json.to_s	13✔
303	end
304
305	def call_number(non_ark_ids)	1✔
306	non_ark_ids.nil? ? 'AC102' : "AC102 #{non_ark_ids.first}"	60✔
307	end
308
309	def first_or_nil(field)	1✔
310	field&.first	22✔
311	end
312
313	def dspace_display_text(dc_elements)	1✔
314	text = [dataspace]	2✔
315	text << if dc_elements.select { \|e\| e.name == 'rights' }.empty?	8✔
316	full_text	1✔
317	else
318	citation	1✔
319	end
320	text	2✔
321	end
322
323	def dspace_display_text_hash(doc)	1✔
324	text = [dataspace]	5✔
325	text << if on_site_only?(doc)	5✔
326	citation	×
327	else
328	full_text	5✔
329	end
330	text	5✔
331	end
332
333	def on_site_only?(doc)	1✔
334	output = false	30✔
335
336	has_location = doc.key?('pu.location')	30✔
337	output \|\|= has_location	30✔
338
339	has_rights = doc.key?('pu.rights.accessRights')	30✔
340	output \|\|= has_rights	30✔
341
342	output \|\|= walkin?(doc)	30✔
343
344	if output	30✔
345	values = doc.fetch('dc.date.accessioned', [])	12✔
346	output = if !values.empty?	12✔
347	accessioned = values.first	8✔
348	accession_date = DateTime.parse(accessioned)	8✔
349
350	# For theses, there is no physical copy since 2013
351	# anything 2012 and prior have a physical copy
352	# @see https://github.com/pulibrary/orangetheses/issues/76
353	accession_date.year < 2013	8✔
354	else
355	false	4✔
356	end
357	end
358
359	output \|\|= embargo?(doc)	30✔
360	output	30✔
361	end
362
363	def embargo?(doc)	1✔
364	date = doc['pu.embargo.lift'] \|\| doc['pu.embargo.terms']	45✔
365	return false if date.nil?	45✔
366
367	date = Chronic.parse(date.first)	19✔
368	if date.nil?	19✔
369	@logger.info("No valid embargo date for #{doc['id']}")	2✔
370	return false	2✔
371	end
372
373	date > Time.now	17✔
374	end
375
376	def embargo(doc)	1✔
377	return if doc.key?('pu.embargo.lift')	×
378
379	date = doc['pu.embargo.lift'] \|\| doc['pu.embargo.terms']	×
380	date = Chronic.parse(date.first) unless date.nil?	×
381	date = date.strftime('%B %-d, %Y') unless date.nil?	×
382	date	×
383	end
384
385	def walkin?(doc)	1✔
386	walkin = doc['pu.mudd.walkin']	22✔
387	!walkin.nil? && walkin.first == 'yes'	22✔
388	end
389
390	def build_embargo_text(doc)	1✔
NEW 391	embargo_date = embargo(doc)	×
NEW 392	doc_id = doc['id']	×
NEW 393	"This content is embargoed until #{embargo_date}. For more information contact the "\	×
394	"<a href=\"mailto:dspadmin@princeton.edu?subject=Regarding embargoed DataSpace Item 88435/#{doc_id}\"> "\
395	'Mudd Manuscript Library</a>.'
396	end
397
398	def walkin_text	1✔
399	'Walk-in Access. This thesis can only be viewed on computer terminals at the '\	×
400	'<a href=\"http://mudd.princeton.edu\">Mudd Manuscript Library</a>.'
401	end
402
403	def restrictions_display_text(doc)	1✔
NEW 404	if embargo?(doc)	×
NEW 405	output = build_embargo_text(doc)	×
406
NEW 407	return output	×
408	end
409
NEW 410	if walkin?(doc)	×
NEW 411	output = walkin_text	×
412
NEW 413	return output	×
414	end
415
NEW 416	fields = []	×
NEW 417	if doc.key?('pu.location')	×
NEW 418	field = doc['pu.location']	×
NEW 419	fields << field	×
420	end
421
NEW 422	if doc.key?('dc.rights.accessRights')	×
NEW 423	field = doc['pu.rights.accessRights']	×
NEW 424	fields << field	×
425	end
426
NEW 427	flattened = fields.flatten	×
NEW 428	flattened.compact	×
429	end
430
431	def dataspace	1✔
432	'DataSpace'	11✔
433	end
434
435	def full_text	1✔
436	'Full text'	9✔
437	end
438
439	def citation	1✔
440	'Citation only'	2✔
441	end
442
443	# this is kind of a mess...
444	def map_non_special_to_solr(dc_elements)	1✔
445	h = {}	3✔
446	NON_SPECIAL_ELEMENT_MAPPING.each do \|element_name, fields\|	3✔
447	elements = dc_elements.select { \|e\| e.name == element_name }	80✔
448	fields.each do \|f\|	15✔
449	if h.key?(f)	21✔
450	h[f].push(*elements.map(&:text))	3✔
451	else
452	h[f] = elements.map(&:text)	18✔
453	end
454	end
455	end
456	h	3✔
457	end
458
459	# default English
460	def code_to_language(codes)	1✔
461	languages = []	14✔
462	# en_US is not valid iso code
463	codes&.each do \|c\|	14✔
464	code_lang = ISO_639.find(c[/^[^_]*/]) # en_US is not valid iso code	5✔
465	l = code_lang.nil? ? 'English' : code_lang.english_name	5✔
466	languages << l	5✔
467	end
468	languages.empty? ? 'English' : languages.uniq	14✔
469	end
470
471	def map_rest_non_special_to_solr(doc)	1✔
472	h = {}	12✔
473	REST_NON_SPECIAL_ELEMENT_MAPPING.each do \|field_name, solr_fields\|	12✔
474	next unless doc.key?(field_name)	84✔
475
476	solr_fields.each do \|f\|	21✔
477	val = []	35✔
478	val << h[f]	35✔
479	val << doc[field_name]	35✔
480	h[f] = val.flatten.compact	35✔
481	# Ruby might have a bug here
482	# if h.has_key?(f)
483	# h[f].push(doc[field_name])
484	# else
485	# h[f] = doc[field_name]
486	# end
487	end
488	end
489	h	12✔
490	end
491
492	def class_year_fields(doc)	1✔
493	h = {}	15✔
494	if doc.key?('pu.date.classyear') && doc['pu.date.classyear'].first =~ /^\d+$/	15✔
495	h['class_year_s'] = doc['pu.date.classyear']	6✔
496	h['pub_date_start_sort'] = doc['pu.date.classyear']	6✔
497	h['pub_date_end_sort'] = doc['pu.date.classyear']	6✔
498	end
499	h	15✔
500	end
501
502	# online access when there isn't a restriction/location note
503	def holdings_access(doc)	1✔
504	# This handles cases for items in the Mudd Library
505	doc_embargoed = embargo?(doc)	16✔
506	doc_on_site_only = on_site_only?(doc)	16✔
507
508	if doc_embargoed \|\| doc_on_site_only	16✔
509	output = {
510	'location' => 'Mudd Manuscript Library',	4✔
511	'location_display' => 'Mudd Manuscript Library',
512	'location_code_s' => 'mudd$stacks',
513	'advanced_location_s' => ['mudd$stacks', 'Mudd Manuscript Library']
514	}
515
516	if doc_embargoed	4✔
517	access_facet = nil	4✔
518	holdings_display = physical_holding(doc, accessible: false)	4✔
519	else
520	access_facet = 'In the Library'	×
521	holdings_display = physical_holding(doc)	×
522	end
523
524	output['access_facet'] = access_facet	4✔
525	output['holdings_1display'] = holdings_display	4✔
526	output	4✔
527	else
528	{
529	'access_facet' => 'Online',	12✔
530	'electronic_portfolio_s' => online_holding(doc)
531	}
532	end
533	end
534	end
535	end

pulibrary / orangetheses / 3695068a-fea6-4cda-8ddb-e3cf6a70ab4e

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous