pennmarc 1.0.12 → 1.0.15.pre

data/lib/pennmarc/helpers/subject.rb

@@ -32,9 +32,9 @@ module PennMARC
       #       a search (non-display) field?
       # @param [Hash] relator_map
       # @param [MARC::Record] record
-      # @return [Array] array of all subject values for search
+      # @return [Array<String>] array of all subject values for search
       def search(record, relator_map: Mappers.relator)
-        subject_fields(record, type: :search).filter_map do |field|
+        subject_fields(record, type: :search).filter_map { |field|
           subj_parts = field.filter_map do |subfield|
             # TODO: use term hash here? pro/chr would be rejected...
             # TODO: should we care about punctuation in a search field? relator mapping?
@@ -55,21 +55,21 @@ module PennMARC
           next if subj_parts.empty?
 
           join_and_squish subj_parts
-        end
+        }.uniq
       end
 
       # All Subjects for faceting
       #
       # @note this is ported mostly form MG's new-style Subject parsing
       # @param [MARC::Record] record
-      # @return [Array] array of all subject values for faceting
+      # @return [Array<String>] array of all subject values for faceting
       def facet(record)
-        subject_fields(record, type: :facet).filter_map do |field|
+        subject_fields(record, type: :facet).filter_map { |field|
           term_hash = build_subject_hash(field)
           next if term_hash.blank? || term_hash[:count]&.zero?
 
           format_term type: :facet, term: term_hash
-        end
+        }.uniq
       end
 
       # All Subjects for display. This includes all {DISPLAY_TAGS} and {LOCAL_TAGS}. For tags that specify a source,
@@ -173,9 +173,9 @@ module PennMARC
 
         case type.to_sym
         when :facet
-          "#{term[:parts].join('--')} #{term[:lasts].join(' ')}".strip
+          term[:parts].join('--').strip
         when :display
-          "#{term[:parts].join('--')} #{term[:lasts].join(' ')} #{term[:append].join(' ')}".strip
+          "#{term[:parts].join('--')} #{term[:append].join(' ')}".strip
         end
       end
 
@@ -227,9 +227,9 @@ module PennMARC
       # @todo do i need all this?
       # @todo do i need to handle punctuation? see append_new_part
       # @param [MARC::DataField] field
-      # @return [Hash{Symbol->Integer | Array}]
+      # @return [Hash{Symbol => Integer, Array}, Nil]
       def build_subject_hash(field)
-        term_info = { count: 0, parts: [], append: [], lasts: [], uri: nil,
+        term_info = { count: 0, parts: [], append: [], uri: nil,
                       local: field.indicator2 == '4' || field.tag.starts_with?('69'), # local subject heading
                       vernacular: field.tag == '880' }
         field.each do |subfield|
@@ -251,8 +251,8 @@ module PennMARC
             # 'e' is relator term; not sure what 'w' is. These are used to append for record-view display only
             term_info[:append] << subfield.value.strip # TODO: map relator code?
           when 'b', 'c', 'd', 'p', 'q', 't'
-            # these are appended to the last component if possible (i.e., when joined, should have no delimiter)
-            term_info[:lasts] << subfield.value.strip
+            # these are appended to the last component (part) if possible (i.e., when joined, should have no delimiter)
+            term_info[:parts].last << ", #{subfield.value.strip}"
             term_info[:count] += 1
           else
             # the usual case; add a new component to `parts`

data/lib/pennmarc/helpers/title.rb

@@ -35,11 +35,11 @@ module PennMARC
       # @param [MARC::Record] record
       # @return [Array<String>] array of title values for search
       def search(record)
-        record.fields(%w[245 880]).filter_map do |field|
+        record.fields(%w[245 880]).filter_map { |field|
           next if field.tag == '880' && subfield_value_not_in?(field, '6', %w[245])
 
           join_subfields(field, &subfield_not_in?(%w[c 6 8 h]))
-        end
+        }.uniq
       end
 
       # Auxiliary Title Search field. Takes from many fields defined in {AUX_TITLE_TAGS} that contain title-like
@@ -47,10 +47,11 @@ module PennMARC
       # @param [MARC::Record] record
       # @return [Array<String>] array of auxiliary title values for search
       def search_aux(record)
-        search_aux_values(record: record, title_type: :main, &subfield_not_in?(%w[c 6 8])) +
-          search_aux_values(record: record, title_type: :related, &subfield_not_in?(%w[s t])) +
-          search_aux_values(record: record, title_type: :entity, &subfield_in?(%w[t])) +
-          search_aux_values(record: record, title_type: :note, &subfield_in?(%w[t]))
+        values = search_aux_values(record: record, title_type: :main, &subfield_not_in?(%w[c 6 8])) +
+                 search_aux_values(record: record, title_type: :related, &subfield_not_in?(%w[s t])) +
+                 search_aux_values(record: record, title_type: :entity, &subfield_in?(%w[t])) +
+                 search_aux_values(record: record, title_type: :note, &subfield_in?(%w[t]))
+        values.uniq
       end
 
       # Journal Title Search field. Takes from {https://www.loc.gov/marc/bibliographic/bd245.html 245} and linked 880.
@@ -61,11 +62,11 @@ module PennMARC
       def journal_search(record)
         return [] if not_a_serial?(record)
 
-        record.fields(%w[245 880]).filter_map do |field|
+        record.fields(%w[245 880]).filter_map { |field|
           next if field.tag == '880' && subfield_value_not_in?(field, '6', %w[245])
 
           join_subfields(field, &subfield_not_in?(%w[c 6 8 h]))
-        end
+        }.uniq
       end
 
       # Auxiliary Journal Title Search field. Takes from many fields defined in {AUX_TITLE_TAGS} that contain title-like
@@ -74,10 +75,11 @@ module PennMARC
       # @param [MARC::Record] record
       # @return [Array<String>] auxiliary journal title information for search
       def journal_search_aux(record)
-        search_aux_values(record: record, title_type: :main, journal: true, &subfield_not_in?(%w[c 6 8])) +
-          search_aux_values(record: record, title_type: :related, journal: true, &subfield_not_in?(%w[s t])) +
-          search_aux_values(record: record, title_type: :entity, journal: true, &subfield_in?(%w[t])) +
-          search_aux_values(record: record, title_type: :note, journal: true, &subfield_in?(%w[t]))
+        values = search_aux_values(record: record, title_type: :main, journal: true, &subfield_not_in?(%w[c 6 8])) +
+                 search_aux_values(record: record, title_type: :related, journal: true, &subfield_not_in?(%w[s t])) +
+                 search_aux_values(record: record, title_type: :entity, journal: true, &subfield_in?(%w[t])) +
+                 search_aux_values(record: record, title_type: :note, journal: true, &subfield_in?(%w[t]))
+        values.uniq
       end
 
       # Single-valued Title, for use in headings. Takes the first {https://www.oclc.org/bibformats/en/2xx/245.html 245}
@@ -162,12 +164,13 @@ module PennMARC
 
           join_subfields(field, &subfield_not_in?(%w[5 6 8 e w]))
         end
-        standardized_titles + record.fields('880').filter_map do |field|
+        titles = standardized_titles + record.fields('880').filter_map do |field|
           next unless subfield_undefined?(field, 'i') ||
                       subfield_value_in?(field, '6', %w[130 240 730])
 
           join_subfields field, &subfield_not_in?(%w[5 6 8 e w])
         end
+        titles.uniq
       end
 
       # Other Title for display
@@ -187,11 +190,12 @@ module PennMARC
 
           join_subfields(field, &subfield_not_in?(%w[5 6 8]))
         end
-        other_titles + record.fields('880').filter_map do |field|
+        titles = other_titles + record.fields('880').filter_map do |field|
           next unless subfield_value_in? field, '6', %w[246 740]
 
           join_subfields(field, &subfield_not_in?(%w[5 6 8]))
         end
+        titles.uniq
       end
 
       # Former Title for display.
@@ -204,13 +208,13 @@ module PennMARC
       # @return [Array<String>] array of former titles
       def former_show(record)
         record.fields
-              .filter_map do |field|
+              .filter_map { |field|
           next unless field.tag == '247' || (field.tag == '880' && subfield_value?(field, '6', /^247/))
 
           former_title = join_subfields field, &subfield_not_in?(%w[6 8 e w]) # 6 and 8 are not meaningful for display
           former_title_append = join_subfields field, &subfield_in?(%w[e w])
           "#{former_title} #{former_title_append}".strip
-        end
+        }.uniq
       end
 
       private

data/lib/pennmarc/mappings/locations.yml

@@ -588,6 +588,10 @@ finecore:
   specific_location: Fisher Fine Arts Library - Core Reading Collection
   library: Fisher Fine Arts Library
   display: Fine Arts Library - Core Reading Collection
+fineexhib:
+  specific_location: Fisher Fine Arts Library - Exhibitions Corridor
+  library: Fisher Fine Arts Library
+  display: Fine Arts Library - Exhibitions Corridor
 finelock:
   specific_location: Fisher Fine Arts Library - Locked Case
   library:

data/lib/pennmarc/util.rb

@@ -14,7 +14,7 @@ module PennMARC
     end
 
     # Join subfields from a field selected based on a provided proc
-    # @param [MARC::DataField] field
+    # @param [MARC::DataField, nil] field
     # @param [Proc] selector
     # @return [String]
     def join_subfields(field, &selector)
@@ -125,6 +125,21 @@ module PennMARC
       string.sub map[trailer.to_sym], ''
     end
 
+    # Intelligently append given punctuation to the end of a string
+    # @param [Symbol] trailer
+    # @param [String] string
+    # @return [String]
+    def append_trailing(trailer, string)
+      return string if string.end_with?('.', '-')
+
+      map = { semicolon: ';',
+              colon: ':',
+              slash: '/',
+              comma: ',',
+              period: '.' }
+      string + map[trailer.to_sym]
+    end
+
     # MARC 880 field "Alternate Graphic Representation" contains text "linked" to another
     # field (e.g., 254 [Title]) used as an alternate representation. Often used to hold
     # translations of title values. A common need is to extract subfields as selected by
@@ -158,7 +173,7 @@ module PennMARC
     # Returns the non-6,8 subfields from a datafield and its 880 link.
     # @param [MARC::Record] record
     # @param [String] tag
-    # @return [Array] acc
+    # @return [Array<String>] values
     def datafield_and_linked_alternate(record, tag)
       record.fields(tag).filter_map { |field|
         join_subfields(field, &subfield_not_in?(%w[6 8]))
@@ -223,7 +238,7 @@ module PennMARC
     # @param [String] prefix to select from subject field
     # @return [Array] array of values
     def prefixed_subject_and_alternate(record, prefix)
-      record.fields(%w[650 880]).filter_map do |field|
+      record.fields(%w[650 880]).filter_map { |field|
         next unless field.indicator2 == '4'
 
         next if field.tag == '880' && subfield_values(field, '6').exclude?('650')
@@ -233,7 +248,7 @@ module PennMARC
         elements = field.select(&subfield_in?(%w[a])).map { |sf| sf.value.gsub(/^%?#{prefix}/, '') }
         elements << join_subfields(field, &subfield_not_in?(%w[a 6 8 e w 5]))
         join_and_squish elements
-      end
+      }.uniq
     end
 
     # Does the given field specify an allowed source code?

data/lib/pennmarc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PennMARC
-  VERSION = '1.0.12'
+  VERSION = '1.0.15.pre'
 end

data/spec/lib/pennmarc/helpers/access_spec.rb

@@ -10,7 +10,7 @@ describe 'PennMARC::Access' do
       let(:record) { marc_record fields: [marc_field(tag: tag)] }
 
       context 'with enrichment via the Alma publishing process' do
-        let(:tag) { PennMARC::EnrichedMarc::TAG_ELECTRONIC_INVENTORY }
+        let(:tag) { PennMARC::Enriched::Pub::ELEC_INVENTORY_TAG }
 
         it 'returns expected access value' do
           expect(helper.facet(record)).to contain_exactly(PennMARC::Access::ONLINE)
@@ -18,7 +18,7 @@ describe 'PennMARC::Access' do
       end
 
       context 'with enrichment with availability info via the Alma API' do
-        let(:tag) { PennMARC::EnrichedMarc::AlmaApi::TAG_ELECTRONIC_INVENTORY }
+        let(:tag) { PennMARC::Enriched::Api::ELEC_INVENTORY_TAG }
 
         it 'returns expected access value' do
           expect(helper.facet(record)).to contain_exactly(PennMARC::Access::ONLINE)
@@ -30,7 +30,7 @@ describe 'PennMARC::Access' do
       let(:record) { marc_record fields: [marc_field(tag: tag)] }
 
       context 'with enrichment via the Alma publishing process' do
-        let(:tag) { PennMARC::EnrichedMarc::TAG_HOLDING }
+        let(:tag) { PennMARC::Enriched::Pub::PHYS_INVENTORY_TAG }
 
         it 'returns expected access value' do
           expect(helper.facet(record)).to contain_exactly(PennMARC::Access::AT_THE_LIBRARY)
@@ -38,7 +38,7 @@ describe 'PennMARC::Access' do
       end
 
       context 'with enrichment with availability info via the Alma API' do
-        let(:tag) { PennMARC::EnrichedMarc::AlmaApi::TAG_PHYSICAL_INVENTORY }
+        let(:tag) { PennMARC::Enriched::Api::PHYS_INVENTORY_TAG }
 
         it 'returns expected access value' do
           expect(helper.facet(record)).to contain_exactly(PennMARC::Access::AT_THE_LIBRARY)
@@ -48,7 +48,7 @@ describe 'PennMARC::Access' do
 
     context 'with a record containing a link to a finding aid (as a handle link)' do
       let(:record) do
-        marc_record fields: [marc_field(tag: PennMARC::EnrichedMarc::TAG_HOLDING),
+        marc_record fields: [marc_field(tag: PennMARC::Enriched::Pub::PHYS_INVENTORY_TAG),
                              marc_field(tag: '856', subfields: location_and_access_subfields, **indicators)]
       end
 

data/spec/lib/pennmarc/helpers/classification_spec.rb

@@ -17,9 +17,9 @@ describe 'PennMARC::Classification' do
 
   describe '.facet' do
     context 'with enrichment via the Alma publishing process' do
-      let(:tag) { PennMARC::EnrichedMarc::TAG_ITEM }
-      let(:call_number_type_sf) { PennMARC::EnrichedMarc::SUB_ITEM_CALL_NUMBER_TYPE }
-      let(:call_number_sf) { PennMARC::EnrichedMarc::SUB_ITEM_CALL_NUMBER }
+      let(:tag) { PennMARC::Enriched::Pub::ITEM_TAG }
+      let(:call_number_type_sf) { PennMARC::Enriched::Pub::ITEM_CALL_NUMBER_TYPE }
+      let(:call_number_sf) { PennMARC::Enriched::Pub::ITEM_CALL_NUMBER }
 
       it 'returns expected values' do
         expect(helper.facet(record)).to contain_exactly('T - Technology', '600 - Technology',
@@ -28,9 +28,9 @@ describe 'PennMARC::Classification' do
     end
 
     context 'with enrichment with availability info via Alma Api' do
-      let(:tag) { PennMARC::EnrichedMarc::AlmaApi::TAG_PHYSICAL_INVENTORY }
-      let(:call_number_type_sf) { PennMARC::EnrichedMarc::AlmaApi::SUB_PHYSICAL_CALL_NUMBER_TYPE }
-      let(:call_number_sf) { PennMARC::EnrichedMarc::AlmaApi::SUB_PHYSICAL_CALL_NUMBER }
+      let(:tag) { PennMARC::Enriched::Api::PHYS_INVENTORY_TAG }
+      let(:call_number_type_sf) { PennMARC::Enriched::Api::PHYS_CALL_NUMBER_TYPE }
+      let(:call_number_sf) { PennMARC::Enriched::Api::PHYS_CALL_NUMBER }
 
       it 'returns expected values' do
         expect(helper.facet(record)).to contain_exactly('T - Technology', '600 - Technology',

data/spec/lib/pennmarc/helpers/creator_spec.rb

@@ -17,11 +17,11 @@ describe 'PennMARC::Creator' do
       end
 
       it 'contains the expected search field values for a single author work' do
-        expect(helper.search(record, relator_map: mapping)).to eq [
+        expect(helper.search(record, relator_map: mapping)).to contain_exactly(
           'Name Surname http://cool.uri/12345 author 1900-2000.',
           'Surname, Name http://cool.uri/12345 author 1900-2000.',
           'Alternative Surname'
-        ]
+        )
       end
     end
 
@@ -32,8 +32,33 @@ describe 'PennMARC::Creator' do
       end
 
       it 'contains the expected search field values for a corporate author work' do
-        expect(helper.search(record, relator_map: mapping)).to eq ['Group of People Annual Meeting Author.',
-                                                                   'Alt. Group Name Alt. Annual Meeting']
+        expect(helper.search(record, relator_map: mapping)).to contain_exactly(
+          'Group of People Annual Meeting, Author.',
+          'Alt. Group Name Alt. Annual Meeting'
+        )
+      end
+    end
+  end
+
+  describe '.search_aux' do
+    let(:record) { marc_record fields: fields }
+
+    context 'with a record that has an added name in the 7xx field' do
+      let(:fields) do
+        [marc_field(tag: '100', subfields: { a: 'Author', c: 'Fancy', d: 'active 24th century AD', '4': 'aut' }),
+         marc_field(tag: '700', subfields: { a: 'Author, Added' }),
+         marc_field(tag: '880', subfields: { '6': '100', a: 'Alt Author', c: 'Alt Fanciness' }),
+         marc_field(tag: '880', subfields: { '6': '700', a: 'Alt Added Author' })]
+      end
+
+      it 'contains the expected search_aux field values for a single author work' do
+        expect(helper.search_aux(record, relator_map: mapping)).to contain_exactly(
+          'Author Fancy active 24th century AD, Author.',
+          'Author, Added.',
+          'Added Author.',
+          'Alt Author Alt Fanciness',
+          'Alt Added Author'
+        )
       end
     end
   end
@@ -187,6 +212,18 @@ describe 'PennMARC::Creator' do
     end
   end
 
+  describe '.conference_search' do
+    let(:record) do
+      marc_record fields: [
+        marc_field(tag: '111', subfields: { a: 'MARC History Symposium', c: 'Moscow', '4': 'aut' })
+      ]
+    end
+
+    it 'returns conference name information for searching without relator value' do
+      expect(helper.conference_search(record)).to eq ['MARC History Symposium Moscow']
+    end
+  end
+
   describe '.contributor_show' do
     let(:record) do
       marc_record fields: [
@@ -217,7 +254,4 @@ describe 'PennMARC::Creator' do
       )
     end
   end
-
-  # describe '.conference_search'
-  # describe '.search_aux'
 end

data/spec/lib/pennmarc/helpers/format_spec.rb

@@ -68,9 +68,9 @@ describe 'PennMARC::Format' do
       context 'with API enriched fields' do
         let(:record) do
           marc_record fields: [
-            marc_field(tag: PennMARC::EnrichedMarc::AlmaApi::TAG_PHYSICAL_INVENTORY, subfields: {
+            marc_field(tag: PennMARC::Enriched::Api::PHYS_INVENTORY_TAG, subfields: {
                          :h => 'AB123',
-                         PennMARC::EnrichedMarc::AlmaApi::SUB_PHYSICAL_CALL_NUMBER_TYPE => '.456 Microfilm'
+                         PennMARC::Enriched::Api::PHYS_CALL_NUMBER_TYPE => '.456 Microfilm'
                        })
           ]
         end
@@ -83,9 +83,9 @@ describe 'PennMARC::Format' do
       context 'with publishing enriched fields' do
         let(:record) do
           marc_record fields: [
-            marc_field(tag: PennMARC::EnrichedMarc::TAG_HOLDING,
+            marc_field(tag: PennMARC::Enriched::Pub::PHYS_INVENTORY_TAG,
                        subfields: { :h => 'AB123',
-                                    PennMARC::EnrichedMarc::SUB_ITEM_CALL_NUMBER_TYPE => '.456 Microfilm' })
+                                    PennMARC::Enriched::Pub::ITEM_CALL_NUMBER_TYPE => '.456 Microfilm' })
           ]
         end
 

data/spec/lib/pennmarc/helpers/inventory_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+describe 'PennMARC::Inventory' do
+  include MarcSpecHelpers
+
+  let(:helper) { PennMARC::Inventory }
+  let(:record) do
+    marc_record fields: fields
+  end
+
+  describe 'physical' do
+    let(:fields) do
+      [marc_field(tag: mapper::PHYS_INVENTORY_TAG,
+                  subfields: subfields)]
+    end
+
+    context 'with API enrichment fields' do
+      let(:mapper) { PennMARC::Enriched::Api }
+      let(:subfields) do
+        { mapper::PHYS_CALL_NUMBER => 'AB123.4',
+          mapper::PHYS_HOLDING_ID => '123456789',
+          mapper::PHYS_LOCATION_CODE => 'vanpelt',
+          mapper::PHYS_LOCATION_NAME => 'Van Pelt Library',
+          mapper::PHYS_PRIORITY => '1' }
+      end
+
+      it 'returns expected array of hash values' do
+        expect(helper.physical(record)).to contain_exactly(
+          { call_num: 'AB123.4', holding_id: '123456789', location_code: 'vanpelt',
+            location_name: 'Van Pelt Library', priority: '1' }
+        )
+      end
+    end
+
+    context 'with Pub enrichment fields' do
+      let(:mapper) { PennMARC::Enriched::Pub }
+      let(:subfields) do
+        { mapper::HOLDING_CLASSIFICATION_PART => 'AB123',
+          mapper::HOLDING_ITEM_PART => '.4',
+          mapper::PHYS_HOLDING_ID => '123456789',
+          mapper::PHYS_LOCATION_CODE => 'vanpelt',
+          mapper::PHYS_LOCATION_NAME => 'Van Pelt Library' }
+      end
+
+      it 'returns expected array of hash values' do
+        expect(helper.physical(record)).to contain_exactly(
+          { call_num: 'AB123.4', holding_id: '123456789', location_code: 'vanpelt',
+            location_name: 'Van Pelt Library', priority: nil }
+        )
+      end
+    end
+  end
+
+  describe 'electronic' do
+    let(:fields) do
+      [marc_field(tag: mapper::ELEC_INVENTORY_TAG,
+                  subfields: subfields)]
+    end
+    let(:subfields) do
+      { mapper::ELEC_PORTFOLIO_ID => '234567890',
+        mapper::ELEC_SERVICE_URL => 'https://www.iwish.com',
+        mapper::ELEC_COLLECTION_NAME => 'All Articles Repo',
+        mapper::ELEC_COVERAGE_STMT => 'All time',
+        mapper::ELEC_PUBLIC_NOTE => 'Portfolio public note' }
+    end
+
+    context 'with API enrichment fields' do
+      let(:mapper) { PennMARC::Enriched::Api }
+
+      it 'returns expected array of hash values' do
+        expect(helper.electronic(record)).to contain_exactly(
+          { portfolio_id: '234567890', url: 'https://www.iwish.com', collection_name: 'All Articles Repo',
+            coverage: 'All time', note: 'Portfolio public note' }
+        )
+      end
+    end
+
+    context 'with Pub enrichment fields' do
+      let(:mapper) { PennMARC::Enriched::Pub }
+
+      it 'returns expected array of hash values' do
+        expect(helper.electronic(record)).to contain_exactly(
+          { portfolio_id: '234567890', url: 'https://www.iwish.com', collection_name: 'All Articles Repo',
+            coverage: 'All time', note: 'Portfolio public note' }
+        )
+      end
+    end
+  end
+
+  describe 'electronic_portfolio_count' do
+    let(:fields) { [marc_field(tag: inventory_tag), marc_field(tag: inventory_tag)] }
+
+    context 'with API enrichment fields' do
+      let(:inventory_tag) { PennMARC::Enriched::Api::ELEC_INVENTORY_TAG }
+
+      it 'returns the correct count' do
+        expect(helper.electronic_portfolio_count(record)).to eq 2
+      end
+    end
+
+    context 'with Pub enrichment fields' do
+      let(:inventory_tag) { PennMARC::Enriched::Pub::ELEC_INVENTORY_TAG }
+
+      it 'returns the correct count' do
+        expect(helper.electronic_portfolio_count(record)).to eq 2
+      end
+    end
+  end
+
+  describe 'physical_holding_count' do
+    let(:fields) { [marc_field(tag: inventory_tag), marc_field(tag: inventory_tag)] }
+
+    context 'with API enrichment fields' do
+      let(:inventory_tag) { PennMARC::Enriched::Api::PHYS_INVENTORY_TAG }
+
+      it 'returns the correct count' do
+        expect(helper.physical_holding_count(record)).to eq 2
+      end
+    end
+
+    context 'with Pub enrichment fields' do
+      let(:inventory_tag) { PennMARC::Enriched::Pub::PHYS_INVENTORY_TAG }
+
+      it 'returns the correct count' do
+        expect(helper.physical_holding_count(record)).to eq 2
+      end
+    end
+  end
+end

data/spec/lib/pennmarc/helpers/location_spec.rb

@@ -4,11 +4,15 @@ describe 'PennMARC::Location' do
   include MarcSpecHelpers
 
   let(:helper) { PennMARC::Location }
+  let(:enriched_marc) { PennMARC::Enriched }
   let(:mapping) { location_map }
 
   describe 'location' do
     context "with only 'itm' field present" do
-      let(:record) { marc_record(fields: [marc_field(tag: 'itm', subfields: { g: 'stor' })]) }
+      let(:record) do
+        marc_record(fields: [marc_field(tag: enriched_marc::Pub::ITEM_TAG,
+                                        subfields: { enriched_marc::Pub::ITEM_CURRENT_LOCATION => 'stor' })])
+      end
 
       it 'returns expected value' do
         expect(helper.location(record: record, location_map: mapping,
@@ -19,7 +23,10 @@ describe 'PennMARC::Location' do
     end
 
     context "with only 'hld' field present" do
-      let(:record) { marc_record(fields: [marc_field(tag: 'hld', subfields: { c: 'stor' })]) }
+      let(:record) do
+        marc_record(fields: [marc_field(tag: enriched_marc::Pub::PHYS_INVENTORY_TAG,
+                                        subfields: { enriched_marc::Pub::PHYS_LOCATION_CODE => 'stor' })])
+      end
 
       it 'returns expected value' do
         expect(helper.location(record: record, location_map: mapping,
@@ -29,10 +36,12 @@ describe 'PennMARC::Location' do
       end
     end
 
-    context "with both 'hld' and 'itm' fields present" do
+    context 'with both holding and item tag fields present=' do
       let(:record) do
-        marc_record(fields: [marc_field(tag: 'itm', subfields: { g: 'stor' }),
-                             marc_field(tag: 'hld', subfields: { c: 'dent' })])
+        marc_record(fields: [marc_field(tag: enriched_marc::Pub::ITEM_TAG,
+                                        subfields: { enriched_marc::Pub::ITEM_CURRENT_LOCATION => 'stor' }),
+                             marc_field(tag: enriched_marc::Pub::PHYS_INVENTORY_TAG,
+                                        subfields: { enriched_marc::Pub::PHYS_LOCATION_CODE => 'dent' })])
       end
 
       it 'returns item location' do
@@ -42,7 +51,7 @@ describe 'PennMARC::Location' do
     end
 
     context 'with multiple library locations' do
-      let(:record) { marc_record(fields: [marc_field(tag: 'itm', subfields: { g: %w[dent] })]) }
+      let(:record) { marc_record(fields: [marc_field(tag: enriched_marc::Pub::ITEM_TAG, subfields: { g: %w[dent] })]) }
 
       it 'returns expected value' do
         expect(helper.location(record: record, location_map: mapping,
@@ -60,17 +69,26 @@ describe 'PennMARC::Location' do
     end
 
     context 'with electronic inventory tag' do
-      let(:record) { marc_record(fields: [marc_field(tag: 'itm', subfields: { g: 'stor' }), marc_field(tag: 'prt')]) }
+      let(:record) do
+        marc_record(fields: [marc_field(tag: enriched_marc::Pub::ITEM_TAG,
+                                        subfields: { enriched_marc::Pub::ITEM_CURRENT_LOCATION => 'stor' }),
+                             marc_field(tag: enriched_marc::Pub::ELEC_INVENTORY_TAG)])
+      end
 
       it 'returns expected value' do
         expect(helper.location(record: record, location_map: mapping,
-                               display_value: :library)).to contain_exactly('LIBRA', 'Online library')
+                               display_value: :library)).to contain_exactly('LIBRA', helper::ONLINE_LIBRARY)
       end
     end
 
     context 'with AVA fields' do
       let(:record) do
-        marc_record(fields: [marc_field(tag: 'AVA', subfields: { b: 'Libra', c: 'LIBRA', j: 'stor' })])
+        marc_record(fields: [marc_field(tag: enriched_marc::Api::PHYS_INVENTORY_TAG,
+                                        subfields: {
+                                          enriched_marc::Api::PHYS_LIBRARY_CODE => 'Libra',
+                                          enriched_marc::Api::PHYS_LOCATION_NAME => 'LIBRA',
+                                          enriched_marc::Api::PHYS_LOCATION_CODE => 'stor'
+                                        })])
       end
 
       it 'returns expected values' do
@@ -79,5 +97,18 @@ describe 'PennMARC::Location' do
         )
       end
     end
+
+    context 'with AVE fields' do
+      let(:record) do
+        marc_record(fields: [marc_field(tag: enriched_marc::Api::ELEC_INVENTORY_TAG,
+                                        subfields: { enriched_marc::Api::ELEC_COLLECTION_NAME => 'Nature' })])
+      end
+
+      it 'returns expected values' do
+        expect(helper.location(record: record, location_map: mapping, display_value: :library)).to(
+          contain_exactly(helper::ONLINE_LIBRARY)
+        )
+      end
+    end
   end
 end