cocina_display 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5662a1512975323d0324c31021fcef9cd4ff337ea8acfb5f6a3352d4abf0e303
-  data.tar.gz: fe0444d5c104e393718a996260346f98691f2e84585483bb7a2062acab347bfb
+  metadata.gz: 575cbfb8b11f3cf71950bfb5234ada4a916a5e55d21116422de84361854f0713
+  data.tar.gz: 4e06ee33d664822bdb6a3057ad8c40539f1f8363350f4648a463c7be0cb533ad
 SHA512:
-  metadata.gz: 8ff64dadfe8b2492f23d38bcc320e8de4bc6100af09adfd93d25df0aeb84c91585072dbcbb6cafc297bd503d773ee7b6bf35281fdda1d573e65f94fcb866a5a0
-  data.tar.gz: 29c42ee65d59dbac907159435f8c9924742cc4d598e656a787dee8cbfceaab8231f2bbf8cb87d14ee180ed586fc51b4d498e8009b6fd5442442d8b0932ebd30d
+  metadata.gz: 76ecb30d8a60bbb42bab880b0c3c5288d8daa7504cc044fb06c157e1b5e2fe21fd3e56668c3479d291f1e683eab4d719c11b2ac5d185b6e98a062e917f5ea74a
+  data.tar.gz: ce4c61a927f9bc034aeebcd9cfc0cb56c8cd1b3c4ee13f7d8d0fcd0cc83290e8d2d1fe31ead879bdb4b1d0090ee60164158ba24d9c8eeb4a7499dfd315b9cf07

data/README.md

@@ -24,11 +24,11 @@ gem install cocina_display
 
 ### Obtaining Cocina
 
-To start, you need some Cocina in JSON form. 
+To start, you need some Cocina in JSON form. Consumers of this gem are likely to be applications that are already harvesting this data (for indexing) or have it stored in an index or database (for display). In testing, you may have neither of these.
 
 You can download some directly from PURL by visiting an object's PURL URL and appending `.json` to the end, like `https://purl.stanford.edu/bb112zx3193.json`. Some examples are available in the `spec/fixtures` directory.
 
-There is also a helper method to fetch the Cocina JSON for a given DRUID and immediately parse it into a `CocinaRecord` object:
+There is also a helper method to fetch the Cocina JSON for a given DRUID over HTTP and immediately parse it into a `CocinaRecord` object:
 
 ```ruby
 > record = CocinaDisplay::CocinaRecord.fetch('bb112zx3193')
@@ -51,7 +51,7 @@ The `CocinaRecord` class provides some methods to access common fields, as well
 => "Hearst Magazines, Inc."
 ```
 
-See the [API Documentation](https://sul-dlss.github.io/cocina_display/CocinaDisplay/CocinaRecord.html) for more details on the methods available in the `CocinaRecord` class.
+See the [API Documentation](https://sul-dlss.github.io/cocina_display/CocinaDisplay/CocinaRecord.html) for more details on the methods available in the `CocinaRecord` class. The gem provides a large number of methods, organized into concerns, to access different parts of the data.
 
 ### Fetching nested data
 
@@ -61,47 +61,52 @@ The previous example used `Hash#dig` to access the first contributor's first nam
 
 ```ruby
 # name values for all contributors in description
-> record.path('$.description.contributor[*].name[*].value').search
+> record.path('$.description.contributor.*.name.*.value').search
 => ["Hearst Magazines, Inc.", "Chesebrough, Jerry"]
 # only contributors with a role with value "photographer"
-> record.path("$.description.contributor[?@.role[?@.value == 'photographer']].name[*].value").search
+> record.path("$.description.contributor[?@.role[?@.value == 'photographer']].name.*.value").search
 => ["Chesebrough, Jerry"]
 ```
 
 The JsonPath implementation used is [janeway](https://www.rubydoc.info/gems/janeway-jsonpath/0.6.0/file/README.md), which supports the full syntax from the [finalized 2024 version of the specification](https://www.rfc-editor.org/rfc/rfc9535.html). Results returned from `#path` are Enumerators.
 
-In the following example, we start an expression with `"$.."` to search for contributor nodes at _any_ level (e.g. `event.contributors`) and discover that there is a third contributor, but it has no `name` value. Using the `['code', 'value']` syntax, we can retrieve both `code` and `value` and show where they came from:
+In the following example, we start an expression with `"$.."` to search for contributor nodes at _any_ level (e.g. `event.contributors`) and discover that there is a third contributor, but it has no `name` value. Using the `['code', 'value']` syntax, we can retrieve both `code` and `value` and show the path they came from:
 
 ```ruby
-> record.path("$..contributor[*].name[*]['code', 'value']").each { |value, node, key| puts "#{key}: #{value} (from #{node})" }
-value: Hearst Magazines, Inc. (from {"structuredValue"=>[], "parallelValue"=>[], "groupedValue"=>[], "value"=>"Hearst Magazines, Inc.", "uri"=>"http://id.loc.gov/authorities/names/n2015050736", "identifier"=>[], "source"=>{"code"=>"naf", "uri"=>"http://id.loc.gov/authorities/names/", "note"=>[]}, "note"=>[], "appliesTo"=>[]})
-value: Chesebrough, Jerry (from {"structuredValue"=>[], "parallelValue"=>[], "groupedValue"=>[], "value"=>"Chesebrough, Jerry", "identifier"=>[], "note"=>[], "appliesTo"=>[]})
-code: CSt (from {"structuredValue"=>[], "parallelValue"=>[], "groupedValue"=>[], "code"=>"CSt", "uri"=>"http://id.loc.gov/vocabulary/organizations/cst", "identifier"=>[], "source"=>{"code"=>"marcorg", "uri"=>"http://id.loc.gov/vocabulary/organizations", "note"=>[]}, "note"=>[], "appliesTo"=>[]})
-=> ["Hearst Magazines, Inc.", "Chesebrough, Jerry", "CSt"]
+> record.path("$..contributor.*.name[*]['code', 'value']").map { |value, _node, key, path| [key, value, path] }
+[["value", "Hearst Magazines, Inc.", "$['description']['contributor'][0]['name'][0]['value']"],
+ ["value", "Chesebrough, Jerry", "$['description']['contributor'][1]['name'][0]['value']"],
+ ["code", "CSt", "$['description']['adminMetadata']['contributor'][0]['name'][0]['code']"]]
 ```
 
 There is also a command line utility for quickly querying a JSON file using JsonPath. Online syntax checkers may give different results, so it helps to test locally. You can run it with:
 
 ```bash
-cat spec/fixtures/bb112zx3193.json | janeway "$.description.contributor[?@.role[?@.value == 'photographer']].name[*].value"
+cat spec/fixtures/bb112zx3193.json | janeway "$.description.contributor[?@.role[?@.value == 'photographer']].name.*.value"
 [
   "Chesebrough, Jerry"
 ]
 ```
 
+### Searching for records
+
+Sometimes you need to determine if records exist "in the wild" that exhibit particular characteristics in the Cocina metadata, like the presence or absence of a field, or a specific value in a field. There is a template script in the `scripts/` directory that can be used to crawl all DRUIDs released to a particular target, like Searchworks, and examine each record.
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. This is a useful place to try out JSONPath expressions with `CocinaRecord#path`.
+
+Tests are written using [rspec](https://rspec.info), with coverage automatically measured via [simplecov](https://github.com/simplecov-ruby/simplecov). CI will fail if coverage drops below 100%. For convenience, if you invoke a single spec file locally, coverage will not be reported.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Documentation is generated using [yard](https://yardoc.org). You can generate it locally by running `yardoc`, or `yard server --reload` to start a local server and watch for changes as you edit. There is a GitHub action that automatically generates and publishes the documentation to GitHub Pages on every push/merge to `main`.
 
-Documentation is generated using [yard](https://yardoc.org). You can generate it by running `yardoc`, or `yard server --reload` to start a local server and watch for changes as you edit.
+To release a new version, update the version number in `version.rb`, run `bundle` to update `Gemfile.lock`, commit your changes, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Background
 
 Historically, applications at SUL used a combination of several gems to render objects represented by MODS XML. With the transition to the Cocina data model, infrastructure applications adopted the [cocina-models gem](https://github.com/sul-dlss/cocina-models), which provides accessor objects and validators over Cocina JSON. Internal applications can fetch such objects over HTTP using [dor-services-client](https://github.com/sul-dlss/dor-services-client).
 
-On the access side, Cocina JSON (the "public Cocina") is available statically via [PURL](https://purl.stanford.edu), but is only updated when an object is published ("shelved") from SDR. This frequently results in data that is technically invalid with respect to `cocina-models` but is still valid in the context of a patron-facing application.
+On the access side, Cocina JSON (the "public Cocina") is available statically via [PURL](https://purl.stanford.edu), but is only updated when an object is published ("shelved") from SDR. This frequently results in data that is technically invalid with respect to `cocina-models` (i.e. it does not match the latest spec) but is still valid in the context of a patron-facing application (because it can still be rendered into useful information).
 
 Cocina data can also be complex, representing the same underlying information in different ways. A "complete" implementation can involve checking multiple deeply nested paths to ensure no information is missed. Rather than tightly coupling access applications to `cocina-models`, this gem provides a set of helpers designed to safely parse Cocina JSON and render it in a consistent way across applications.
 

data/lib/cocina_display/cocina_record.rb

@@ -13,6 +13,9 @@ require_relative "concerns/identifiers"
 require_relative "concerns/titles"
 require_relative "concerns/access"
 require_relative "concerns/subjects"
+require_relative "concerns/forms"
+require_relative "concerns/languages"
+require_relative "utils"
 
 module CocinaDisplay
   # Public Cocina metadata for an SDR object, as fetched from PURL.
@@ -23,23 +26,37 @@ module CocinaDisplay
     include CocinaDisplay::Concerns::Titles
     include CocinaDisplay::Concerns::Access
     include CocinaDisplay::Concerns::Subjects
+    include CocinaDisplay::Concerns::Forms
+    include CocinaDisplay::Concerns::Languages
 
     # Fetch a public Cocina document from PURL and create a CocinaRecord.
     # @note This is intended to be used in development or testing only.
     # @param druid [String] The bare DRUID of the object to fetch.
+    # @param deep_compact [Boolean] If true, compact the JSON to remove blank values.
     # @return [CocinaDisplay::CocinaRecord]
     # :nocov:
-    def self.fetch(druid)
-      new(Net::HTTP.get(URI("https://purl.stanford.edu/#{druid}.json")))
+    def self.fetch(druid, deep_compact: false)
+      from_json(Net::HTTP.get(URI("https://purl.stanford.edu/#{druid}.json")), deep_compact: deep_compact)
     end
     # :nocov:
 
+    # Create a CocinaRecord from a JSON string.
+    # @param cocina_json [String]
+    # @param deep_compact [Boolean] If true, compact the JSON to remove blank values.
+    # @return [CocinaDisplay::CocinaRecord]
+    def self.from_json(cocina_json, deep_compact: false)
+      cocina_doc = JSON.parse(cocina_json)
+      deep_compact ? new(Utils.deep_compact_blank(cocina_doc)) : new(cocina_doc)
+    end
+
     # The parsed Cocina document.
     # @return [Hash]
     attr_reader :cocina_doc
 
-    def initialize(cocina_json)
-      @cocina_doc = JSON.parse(cocina_json)
+    # Initialize a CocinaRecord with a Cocina document hash.
+    # @param cocina_doc [Hash]
+    def initialize(cocina_doc)
+      @cocina_doc = cocina_doc
     end
 
     # Evaluate a JSONPath expression against the Cocina document.
@@ -47,9 +64,9 @@ module CocinaDisplay
     # @param path_expression [String] The JSONPath expression to evaluate.
     # @see https://www.rubydoc.info/gems/janeway-jsonpath/0.6.0/file/README.md
     # @example Name values for contributors
-    #  record.path("$.description.contributor[*].name[*].value").search #=> ["Smith, John", "ACME Corp."]
+    #  record.path("$.description.contributor.*.name.*.value").search #=> ["Smith, John", "ACME Corp."]
     # @example Filtering nodes using a condition
-    #  record.path("$.description.contributor[?(@.type == 'person')].name[*].value").search #=> ["Smith, John"]
+    #  record.path("$.description.contributor[?(@.type == 'person')].name.*.value").search #=> ["Smith, John"]
     def path(path_expression)
       Janeway.enum_for(path_expression, cocina_doc)
     end
@@ -99,7 +116,7 @@ module CocinaDisplay
     #   puts file["size"] #=> 123456
     #  end
     def files
-      path("$.structural.contains[*].structural.contains[*]")
+      path("$.structural.contains.*.structural.contains[*]")
     end
   end
 end

data/lib/cocina_display/concerns/contributors.rb

@@ -4,90 +4,113 @@ module CocinaDisplay
   module Concerns
     # Methods for finding and formatting names for contributors
     module Contributors
-      # The main author's name, formatted for display.
+      # The main contributor's name, formatted for display.
       # @param with_date [Boolean] Include life dates, if present
       # @return [String]
-      # @return [nil] if no main author is found
+      # @return [nil] if no main contributor is found
       # @example
-      #   record.main_author #=> "Smith, John"
+      #   record.main_contributor_name #=> "Smith, John"
       # @example with date
-      #   record.main_author(with_date: true) #=> "Smith, John, 1970-2020"
-      def main_author(with_date: false)
-        main_author_contributor&.display_name(with_date: with_date)
+      #   record.main_contributor_name(with_date: true) #=> "Smith, John, 1970-2020"
+      def main_contributor_name(with_date: false)
+        main_contributor&.display_name(with_date: with_date)
       end
 
-      # All author names except the main one, formatted for display.
+      # All contributor names except the main one, formatted for display.
       # @param with_date [Boolean] Include life dates, if present
       # @return [Array<String>]
-      def additional_authors(with_date: false)
-        additional_author_contributors.map { |c| c.display_name(with_date: with_date) }
+      def additional_contributor_names(with_date: false)
+        additional_contributors.map { |c| c.display_name(with_date: with_date) }
+      end
+
+      # All names of publishers, formatted for display.
+      # @return [Array<String>]
+      def publisher_names
+        publisher_contributors.map(&:display_name)
       end
 
       # All names of authors who are people, formatted for display.
       # @param with_date [Boolean] Include life dates, if present
       # @return [Array<String>]
-      def person_authors(with_date: false)
-        authors.filter(&:person?).map { |c| c.display_name(with_date: with_date) }
+      def person_contributor_names(with_date: false)
+        contributors.filter(&:person?).map { |c| c.display_name(with_date: with_date) }
       end
 
-      # All names of non-person authors, formatted for display.
+      # All names of non-person contributors, formatted for display.
       # This includes organizations, conferences, families, etc.
       # @return [Array<String>]
       # @see https://github.com/sul-dlss/cocina-models/blob/main/docs/description_types.md#contributor-types
-      def impersonal_authors
-        authors.reject(&:person?).map(&:display_name)
+      def impersonal_contributor_names
+        contributors.reject(&:person?).map(&:display_name)
       end
 
-      # All names of authors that are organizations, formatted for display.
+      # All names of contributors that are organizations, formatted for display.
       # @return [Array<String>]
-      def organization_authors
-        authors.filter(&:organization?).map(&:display_name)
+      def organization_contributor_names
+        contributors.filter(&:organization?).map(&:display_name)
       end
 
-      # All names of authors that are conferences, formatted for display.
+      # All names of contributors that are conferences, formatted for display.
       # @return [Array<String>]
-      def conference_authors
-        authors.filter(&:conference?).map(&:display_name)
+      def conference_contributor_names
+        contributors.filter(&:conference?).map(&:display_name)
       end
 
-      # A string value for sorting by author that sorts missing values last.
+      # A hash mapping role names to the names of contributors with that role.
+      # @param with_date [Boolean] Include life dates, if present
+      # @return [Hash<String, Array<String>>]
+      def contributor_names_by_role(with_date: false)
+        contributors.each_with_object({}) do |contributor, hash|
+          contributor.roles.each do |role|
+            hash[role.display_str] ||= []
+            hash[role.display_str] << contributor.display_name(with_date: with_date)
+          end
+        end
+      end
+
+      # A string value for sorting by contributor that sorts missing values last.
+      # Appends the sort title to break ties between contributor names.
       # Ignores punctuation and leading/trailing spaces.
       # @return [String]
-      def sort_author
-        (main_author_contributor&.display_name || "\u{10FFFF}").gsub(/[[:punct:]]*/, "").strip
+      def sort_contributor_name
+        sort_name = main_contributor&.display_name || "\u{10FFFF}"
+        sort_name_title = [sort_name, sort_title].join(" ")
+        sort_name_title.gsub(/[[:punct:]]*/, "").strip
       end
 
-      private
-
       # All contributors for the object, including authors, editors, etc.
+      # Checks both description.contributor and description.event.contributor.
       # @return [Array<Contributor>]
       def contributors
-        @contributors ||= path("$.description.contributor[*]").map { |c| Contributor.new(c) }
+        @contributors ||= Enumerator::Chain.new(
+          path("$.description.contributor.*"),
+          path("$.description.event.*.contributor.*")
+        ).map { |c| Contributor.new(c) }
       end
 
-      # All contributors with a "creator" or "author" role.
+      # All contributors with a "publisher" role.
       # @return [Array<Contributor>]
-      # @see Contributor#author?
-      def authors
-        contributors.filter(&:author?)
+      # @see Contributor#publisher?
+      def publisher_contributors
+        contributors.filter(&:publisher?)
       end
 
-      # Contributor object representing the primary author.
+      # Object representing the main contributor.
       # Selected according to the following rules:
-      # 1. If there is a primary author or creator, use that.
-      # 2. If there are no primary authors or creators, use the first one.
-      # 3. If there are none at all, use the first contributor without any role.
+      # 1. If there are contributors marked as primary, use the first one.
+      # 2. If there are no primary contributors, use the first contributor with no role.
+      # 3. If there are no contributors without a role, use the first contributor.
       # @return [Contributor]
-      # @return [nil] if no suitable contributor is found
-      def main_author_contributor
-        authors.find(&:primary?).presence || authors.first || contributors.find { |c| !c.role? }.presence
+      # @return [nil] if there are no contributors at all
+      def main_contributor
+        contributors.find(&:primary?).presence || contributors.find { |c| !c.role? }.presence || contributors.first
       end
 
-      # All author/creator contributors except the main one.
+      # All contributors except the main one.
       # @return [Array<Contributor>]
-      def additional_author_contributors
-        return [] if authors.empty? || authors.one? || !authors.include?(main_author_contributor)
-        authors - [main_author_contributor]
+      def additional_contributors
+        return [] if contributors.empty? || contributors.one?
+        contributors - [main_contributor]
       end
     end
   end

data/lib/cocina_display/concerns/events.rb

@@ -1,6 +1,7 @@
 require_relative "../dates/date"
 require_relative "../dates/date_range"
-require_relative "../imprint"
+require_relative "../events/event"
+require_relative "../events/imprint"
 
 module CocinaDisplay
   module Concerns
@@ -75,24 +76,28 @@ module CocinaDisplay
       # @example
       #   CocinaRecord.fetch('bt553vr2845').imprint_display_str #=> "New York : Meridian Book, 1993, c1967"
       def imprint_display_str
-        imprints.map(&:display_str).compact_blank.join("; ")
+        imprint_events.map(&:display_str).compact_blank.join("; ")
       end
 
-      private
+      # List of places of publication as strings.
+      # Considers locations for all publication, creation, and capture events.
+      # @return [Array<String>]
+      def publication_places
+        publication_events.flat_map { |event| event.locations.map(&:display_str) }
+      end
 
-      # Event dates as an array of CocinaDisplay::Dates::Date objects.
-      # If type is provided, keep dates with a matching event type OR date type.
-      # @param type [Symbol, nil] Filter by event type (e.g. :publication).
-      # @return [Array<CocinaDisplay::Dates::Date>] The list of event dates
-      def event_dates(type: nil)
-        filter_expr = type.present? ? "?match(@.type, \"#{type}\")" : "*"
+      # All events associated with the object.
+      # @return [Array<CocinaDisplay::Events::Event>]
+      def events
+        @events ||= path("$.description.event.*").map { |event| CocinaDisplay::Events::Event.new(event) }
+      end
 
-        Enumerator::Chain.new(
-          path("$.description.event[*].date[#{filter_expr}]"),
-          path("$.description.event[#{filter_expr}].date[*]")
-        ).uniq.map do |date|
-          CocinaDisplay::Dates::Date.from_cocina(date)
-        end
+      # All events that could be used to select a publication date.
+      # Includes publication, creation, and capture events.
+      # Considers event types as well as date types if the event is untyped.
+      # @return [Array<CocinaDisplay::Events::Event>]
+      def publication_events
+        events.filter { |event| event.has_any_type?("publication", "creation", "capture") }
       end
 
       # Array of CocinaDisplay::Imprint objects for all relevant Cocina events.
@@ -100,19 +105,22 @@ module CocinaDisplay
       # Considers event types as well as date types if the event is untyped.
       # Prefers events where the date was not encoded, if any.
       # @return [Array<CocinaDisplay::Imprint>] The list of Imprint objects
-      def imprints
-        filter_expr = "\"(publication|creation|capture|copyright)\""
-
-        imprints = Enumerator::Chain.new(
-          path("$.description.event[?match(@.type, #{filter_expr})]"),
-          path("$.description.event[?@.date[?match(@.type, #{filter_expr})]]")
-        ).uniq.map do |event|
-          CocinaDisplay::Imprint.new(event)
+      def imprint_events
+        imprints = events.filter do |event|
+          event.has_any_type?("publication", "creation", "capture", "copyright")
+        end.map do |event|
+          CocinaDisplay::Events::Imprint.new(event.cocina)
         end
 
         imprints.reject(&:date_encoding?).presence || imprints
       end
 
+      # All dates associated with the object via an event.
+      # @return [Array<CocinaDisplay::Dates::Date>]
+      def event_dates
+        @event_dates ||= events.flat_map(&:dates)
+      end
+
       # The earliest preferred publication date as a CocinaDisplay::Dates::Date object.
       # Considers publication, creation, and capture dates in that order.
       # Prefers dates marked as primary and those with a declared encoding.
@@ -120,8 +128,12 @@ module CocinaDisplay
       # @return [CocinaDisplay::Dates::Date] The earliest preferred date
       # @return [nil] if no dates are left after filtering
       def pub_date(ignore_qualified: false)
-        [:publication, :creation, :capture].map do |type|
-          earliest_preferred_date(event_dates(type: type), ignore_qualified: ignore_qualified)
+        pub_event_dates = event_dates.filter { |date| date.type == "publication" }
+        creation_event_dates = event_dates.filter { |date| date.type == "creation" }
+        capture_event_dates = event_dates.filter { |date| date.type == "capture" }
+
+        [pub_event_dates, creation_event_dates, capture_event_dates].flat_map do |dates|
+          earliest_preferred_date(dates, ignore_qualified: ignore_qualified)
         end.compact.first
       end
 

data/lib/cocina_display/concerns/forms.rb

@@ -0,0 +1,134 @@
+require "active_support/core_ext/enumerable"
+
+module CocinaDisplay
+  module Concerns
+    # Methods for extracting format/genre information from a Cocina object
+    module Forms
+      # Resource types of the object, expressed in SearchWorks controlled vocabulary.
+      # @return [Array<String>]
+      def resource_types
+        mapped_values = resource_type_values.flat_map { |resource_type| searchworks_resource_type(resource_type) }
+        mapped_values << "Dataset" if dataset?
+        mapped_values.uniq
+      end
+
+      # Physical or digital forms of the object.
+      # @return [Array<String>]
+      # @example GIS dataset (nz187ct8959)
+      #   record.forms #=> ["map", "optical disc", "electronic resource"]
+      def forms
+        path("$.description.form..[?@.type == 'form'].value").uniq
+      end
+
+      # Extent of the object, such as "1 audiotape" or "1 map".
+      # @return [Array<String>]
+      # @example Oral history interview (sw705fr7011)
+      #   record.extents #=> ["1 audiotape", "1 transcript"]
+      def extents
+        path("$.description.form..[?@.type == 'extent'].value").uniq
+      end
+
+      # Genres of the object, capitalized for display.
+      # @return [Array<String>]
+      # @example GIS dataset (nz187ct8959)
+      #   record.genres #=> ["Cartographic dataset", "Geospatial data", "Geographic information systems data"]
+      def genres
+        path("$.description.form..[?@.type == 'genre'].value").map(&:upcase_first).uniq
+      end
+
+      # Genres of the object, with additional values added for search/faceting.
+      # @note These values are added for discovery in SearchWorks but not for display.
+      # @return [Array<String>]
+      def genres_search
+        genres.tap do |values|
+          values << "Thesis/Dissertation" if values.include?("Thesis")
+          values << "Conference proceedings" if values.include?("Conference publication")
+          values << "Government document" if values.include?("Government publication")
+        end.uniq
+      end
+
+      # Is the object a periodical or serial?
+      # @return [Boolean]
+      def periodical?
+        issuance_terms.include?("periodical") || issuance_terms.include?("serial") || frequency.any?
+      end
+
+      # Is the object a cartographic resource?
+      # @return [Boolean]
+      def cartographic?
+        resource_type_values.include?("cartographic")
+      end
+
+      # Is the object a web archive?
+      # @return [Boolean]
+      def archived_website?
+        genres.include?("Archived website")
+      end
+
+      # Is the object a dataset?
+      # @return [Boolean]
+      def dataset?
+        genres.include?("Dataset")
+      end
+
+      private
+
+      # Map a resource type to SearchWorks format value(s).
+      # @param resource_type [String] The resource type to map.
+      # @return [Array<String>]
+      def searchworks_resource_type(resource_type)
+        values = []
+
+        case resource_type
+        when "cartographic"
+          values << "Map"
+        when "manuscript", "mixed material"
+          values << "Archive/Manuscript"
+        when "moving image"
+          values << "Video"
+        when "notated music"
+          values << "Music score"
+        when "software, multimedia"
+          # Prevent GIS datasets from being labeled as "Software"
+          values << "Software/Multimedia" unless cartographic? || dataset?
+        when "sound recording-musical"
+          values << "Music recording"
+        when "sound recording-nonmusical", "sound recording"
+          values << "Sound recording"
+        when "still image"
+          values << "Image"
+        when "text"
+          # Can potentially map to periodical AND website if both are true. Only
+          # 2 records currently (2025) in Searchworks do this, but it is real.
+          if periodical? || archived_website?
+            values << "Journal/Periodical" if periodical?
+            values << "Archived website" if archived_website?
+          else
+            values << "Book"
+          end
+        when "three dimensional object"
+          values << "Object"
+        end
+
+        values.compact_blank
+      end
+
+      # Issuance terms for a work, drawn from the event notes.
+      # @return [Array<String>]
+      def issuance_terms
+        path("$.description.event.*.note[?@.type == 'issuance'].value").map(&:downcase).uniq
+      end
+
+      # Frequency terms for a periodical, drawn from the event notes.
+      # @return [Array<String>]
+      def frequency
+        path("$.description.event.*.note[?@.type == 'frequency'].value").map(&:downcase).uniq
+      end
+
+      # Values of the resource type form field prior to mapping.
+      def resource_type_values
+        path("$.description.form..[?@.type == 'resource type'].value").uniq
+      end
+    end
+  end
+end

data/lib/cocina_display/concerns/languages.rb

@@ -0,0 +1,20 @@
+require_relative "../language"
+
+module CocinaDisplay
+  module Concerns
+    # Methods for extracting language information from a Cocina object.
+    module Languages
+      # Languages objects associated with the object.
+      # @return [Array<CocinaDisplay::Language>]
+      def languages
+        @languages ||= path("$.description.language.*").map { |lang| CocinaDisplay::Language.new(lang) }
+      end
+
+      # Names of languages associated with the object, if recognized by Searchworks.
+      # @return [Array<String>]
+      def searchworks_language_names
+        languages.filter_map { |lang| lang.display_str if lang.searchworks_language? }.compact_blank.uniq
+      end
+    end
+  end
+end