cocina_display 2.11.0 → 2.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3cdd3c641ebe565578770ae4f79867ccc886bdaefa17b2bfa966cc17c262c58b
-  data.tar.gz: 2d0e16f879c06393a3e74c2e323896384040721c95f73bc2e65fb428c4c9d94a
+  metadata.gz: 8dfb0909c582a5d1e3109bf0c98983e0ebd523af7340722856cb9d4482faa925
+  data.tar.gz: c2143a971249f8e6262dced0f4a05ef0d197426d3e86173f808c6f8f9321727e
 SHA512:
-  metadata.gz: 98248c3a9f4a68ef0e8fac5261f979702e66c529f086d9287d111d580af06bc517536b5636fb0e5d1ca02588264af17c91e9185630c5f35f287c60af5cc6de77
-  data.tar.gz: b6c79b6672639e13f31f446ca239d11434be0ba152656f93bd328ce576271d3e6db6ace9adec9b136d40cd325fce562d0d30317cabf5b4afe37d505962a5e93f
+  metadata.gz: e83761f763f300b62a7da1624d65f21b89fea93ab4170052c66a324dcd7b306b534fc5b84dc726dbb9945d5b98746398d84d8a9dbc00f3bd467658e12b801241
+  data.tar.gz: c06a74d7e19525eb27c71e314f2676d79fb1c3422efa0a9e08f39404feaa001d0c7252986761447a0bee6dd5bad6bc818310dae7a2fa89cb760af836b4bfd33f

data/lib/cocina_display/concerns/geospatial.rb

@@ -14,6 +14,8 @@ module CocinaDisplay
       # All valid coordinate data formatted for indexing into a Solr RPT field.
       # @note This type of field accommodates both points and bounding boxes.
       # @note In WKT, points have longitude first, unlike {coordinates_as_point}.
+      # @note A box crossing the antimeridian is split at the date line, so it is
+      #   rendered as a MULTIPOLYGON of its two halves.
       # @see https://solr.apache.org/guide/solr/latest/query-guide/spatial-search.html#rpt
       # @return [Array<String>]
       # @example ["POINT(-118.2437 34.0522)", "POLYGON((-118.2437 34.0522, -118.2437 34.1996, -117.9522 34.1996, -117.9522 34.0522, -118.2437 34.0522))"]
@@ -23,6 +25,7 @@ module CocinaDisplay
 
       # All valid coordinate data formatted for indexing into a Solr BBoxField.
       # @note Points are not included since they can't be represented as a box.
+      # @note West is greater than east for a box crossing the antimeridian.
       # @see https://solr.apache.org/guide/solr/latest/query-guide/spatial-search.html#bboxfield
       # @return [Array<String>]
       # @example ["ENVELOPE(-118.2437, -117.9522, 34.1996, 34.0522)"]
@@ -40,8 +43,10 @@ module CocinaDisplay
       end
 
       # All valid coordinate data formatted as bounding boxes.
-      # Format is [[min_lat, min_long], [max_lat, max_long]].
+      # Format is [[south, west], [north, east]].
       # @note Points are not included since they can't be represented as a box.
+      # @note For a box crossing the antimeridian, east is carried past 180 so that
+      #   the pair still reads southwest to northeast.
       # @return [Array<Array<Array<Float>>>]
       def coordinates_as_bbox
         coordinate_objects.map(&:as_bbox).compact.uniq

data/lib/cocina_display/events/event.rb

@@ -161,9 +161,17 @@ module CocinaDisplay
       end
 
       # Locations associated with this event as a single string.
+      # Renders every parallel value, so vernacular and transliterated forms
+      # of the same place both appear.
       # @return [String]
       def place_str
-        locations.map(&:to_s).compact_blank.uniq.join(", ")
+        location_values.map(&:to_s).compact_blank.uniq.join(", ")
+      end
+
+      # All locations associated with this event, in every language/script.
+      # @return [Array<CocinaDisplay::Events::LocationValue>]
+      def location_values
+        locations.flat_map(&:parallel_values)
       end
     end
   end

data/lib/cocina_display/events/imprint.rb

@@ -50,7 +50,7 @@ module CocinaDisplay
       # 3. Keep only unique locations after decoding
       # @return [Array<String>]
       def display_locations
-        unencoded_locs, encoded_locs = locations.partition { |loc| loc.unencoded_value? }
+        unencoded_locs, encoded_locs = location_values.partition { |loc| loc.unencoded_value? }
         locs_for_display = unencoded_locs.presence || encoded_locs
         locs_for_display.map(&:to_s).compact_blank.uniq
       end

data/lib/cocina_display/events/location.rb

@@ -1,10 +1,13 @@
 module CocinaDisplay
   module Events
-    # A single location represented in a Cocina event, like a publication place.
-    class Location
+    # A location represented in a Cocina event, like a publication place.
+    # Can be expressed as several {LocationValue}s in different languages/scripts.
+    class Location < Parallel::Parallel
       MARC_COUNTRIES_FILE_PATH = CocinaDisplay.root / "config" / "marc_countries.yml"
 
-      attr_reader :cocina
+      # Common display methods reference the main location value. For parallel
+      # values, see #translated_value and #transliterated_value.
+      delegate :to_s, :unencoded_value?, :country_name, to: :main_value
 
       # A hash mapping MARC country codes to their names.
       # @return [Hash{String => String}]
@@ -12,50 +15,12 @@ module CocinaDisplay
         @marc_countries ||= YAML.safe_load_file(MARC_COUNTRIES_FILE_PATH)
       end
 
-      # Initialize a Location object with Cocina structured data.
-      # @param cocina [Hash] The Cocina structured data for the location.
-      def initialize(cocina)
-        @cocina = cocina
-      end
-
-      # The name of the location.
-      # Decodes a MARC country code if present and no value was present.
-      # @return [String, nil]
-      def to_s
-        cocina["value"] || country_name
-      end
-
-      # Is there an unencoded value (name) for this location?
-      # @return [Boolean]
-      def unencoded_value?
-        cocina["value"].present?
-      end
-
-      # Decoded country name if the location is encoded with a MARC country code.
-      # @return [String, nil]
-      def country_name
-        Location.marc_countries[code] if marc_country? && valid_country_code?
-      end
-
       private
 
-      # A code, like a MARC country code, representing the location.
-      # @return [String, nil]
-      def code
-        cocina["code"]
-      end
-
-      # Is this a decodable country code?
-      # Excludes blank values and "xx" (unknown) and "vp" (various places).
-      # @return [Boolean]
-      def valid_country_code?
-        code.present? && ["xx", "vp"].exclude?(code)
-      end
-
-      # Is this location encoded with a MARC country code?
-      # @return [Boolean]
-      def marc_country?
-        cocina.dig("source", "code") == "marccountry"
+      # The class to use for parallel values.
+      # @return [Class]
+      def parallel_value_class
+        LocationValue
       end
     end
   end

data/lib/cocina_display/events/location_value.rb

@@ -0,0 +1,46 @@
+module CocinaDisplay
+  module Events
+    # A location in a Cocina event in a single language/script.
+    class LocationValue < Parallel::ParallelValue
+      # The name of the location.
+      # Decodes a MARC country code if present and no value was present.
+      # @return [String, nil]
+      def to_s
+        cocina["value"] || country_name
+      end
+
+      # Is there an unencoded value (name) for this location?
+      # @return [Boolean]
+      def unencoded_value?
+        cocina["value"].present?
+      end
+
+      # Decoded country name if the location is encoded with a MARC country code.
+      # @return [String, nil]
+      def country_name
+        Location.marc_countries[code] if marc_country? && valid_country_code?
+      end
+
+      private
+
+      # A code, like a MARC country code, representing the location.
+      # @return [String, nil]
+      def code
+        cocina["code"]
+      end
+
+      # Is this a decodable country code?
+      # Excludes blank values and "xx" (unknown) and "vp" (various places).
+      # @return [Boolean]
+      def valid_country_code?
+        code.present? && ["xx", "vp"].exclude?(code)
+      end
+
+      # Is this location encoded with a MARC country code?
+      # @return [Boolean]
+      def marc_country?
+        cocina.dig("source", "code") == "marccountry"
+      end
+    end
+  end
+end

data/lib/cocina_display/geospatial.rb

@@ -20,15 +20,17 @@ module CocinaDisplay
         # @return [Coordinates, nil]
         def from_structured_values(structured_values)
           if structured_values.size == 2
-            lat = structured_values.find { |v| v["type"] == "latitude" }&.dig("value")
-            lng = structured_values.find { |v| v["type"] == "longitude" }&.dig("value")
-            Point.from_coords(lat: lat, lng: lng)
+            Point.from_coords(
+              lat: structured_value(structured_values, "latitude"),
+              lng: structured_value(structured_values, "longitude")
+            )
           elsif structured_values.size == 4
-            north = structured_values.find { |v| v["type"] == "north" }&.dig("value")
-            south = structured_values.find { |v| v["type"] == "south" }&.dig("value")
-            east = structured_values.find { |v| v["type"] == "east" }&.dig("value")
-            west = structured_values.find { |v| v["type"] == "west" }&.dig("value")
-            BoundingBox.from_coords(west: west, east: east, north: north, south: south)
+            BoundingBox.from_coords(
+              west: structured_value(structured_values, "west"),
+              east: structured_value(structured_values, "east"),
+              north: structured_value(structured_values, "north"),
+              south: structured_value(structured_values, "south")
+            )
           end
         end
 
@@ -54,6 +56,36 @@ module CocinaDisplay
           # Use the matching parser to parse the string
           parser_class.parse(match_str)
         end
+
+        private
+
+        # Find a single coordinate value of the given type in structured data.
+        # @param [Array<Hash>] structured_values
+        # @param [String] type like "west" or "latitude"
+        # @return [String, nil]
+        def structured_value(structured_values, type)
+          value = structured_values.find { |v| v["type"] == type }&.dig("value")
+          normalize_value(value) if value.present?
+        end
+
+        # Standardize a single coordinate value so that Geo::Coord can parse it.
+        # Chooses a normalizer based on the string format, since structured values
+        # can be decimal degrees or DMS, including the packed MARC 034 form.
+        # @param [String] value
+        # @return [String, nil] nil if the format isn't recognized
+        # @example "W1210000" becomes "121°0′0″W"
+        def normalize_value(value)
+          # Remove all whitespace for easier matching/parsing
+          match_str = value.gsub(/\s+/, "")
+
+          # Try each normalizer in order until one matches; bail out if none do
+          normalizer_class = [
+            DMSCoordinateNormalizer,
+            DecimalCoordinateNormalizer
+          ].find { |normalizer| normalizer.supports?(match_str) }
+
+          normalizer_class&.normalize_coord(match_str)
+        end
       end
 
       protected
@@ -146,35 +178,72 @@ module CocinaDisplay
       end
     end
 
-    # A bounding box defined by two corner points.
+    # A bounding box defined by its southwest and northeast corner points.
+    # The box can wrap east-west across the antimeridian, in which case its west
+    # edge is numerically east of its east edge. Both Solr's rectangle syntax and
+    # GeoJSON spell a crossing box that way, as do MARC 034 $d/$e, which are the
+    # westernmost and easternmost longitudes rather than the minimum and maximum.
+    # @see https://datatracker.ietf.org/doc/html/rfc7946#section-5.2
     class BoundingBox < Coordinates
-      attr_reader :min_point, :max_point
+      attr_reader :southwest, :northeast
 
       # Construct a BoundingBox from west, east, north, and south string values.
+      # West and east are used as given, so a box that crosses the antimeridian
+      # is preserved instead of rejected.
       # @param [String] west western longitude
       # @param [String] east eastern longitude
       # @param [String] north northern latitude
       # @param [String] south southern latitude
       # @return [BoundingBox, nil] nil if parsing fails
       def self.from_coords(west:, east:, north:, south:)
-        min_point = Geo::Coord.parse("#{south}, #{west}")
-        max_point = Geo::Coord.parse("#{north}, #{east}")
+        southwest = Geo::Coord.parse("#{south}, #{west}")
+        northeast = Geo::Coord.parse("#{north}, #{east}")
 
         # Must be parsable
-        return unless min_point && max_point
+        return unless southwest && northeast
 
-        # Ensure min_point is southwest and max_point is northeast
-        return if min_point.lat > max_point.lat || min_point.lng > max_point.lng
+        # A box can wrap east-west, but never north-south
+        return if southwest.lat > northeast.lat
 
-        new(min_point: min_point, max_point: max_point)
+        new(southwest: southwest, northeast: northeast)
       end
 
-      # Construct a BoundingBox from two Geo::Coord points.
-      # @param [Geo::Coord] min_point
-      # @param [Geo::Coord] max_point
-      def initialize(min_point:, max_point:)
-        @min_point = min_point
-        @max_point = max_point
+      # Construct a BoundingBox from two corner Geo::Coord points.
+      # @param [Geo::Coord] southwest
+      # @param [Geo::Coord] northeast
+      def initialize(southwest:, northeast:)
+        @southwest = southwest
+        @northeast = northeast
+      end
+
+      # The westernmost longitude of the box.
+      # @return [BigDecimal]
+      def west
+        southwest.lng
+      end
+
+      # The easternmost longitude of the box.
+      # @return [BigDecimal]
+      def east
+        northeast.lng
+      end
+
+      # The northernmost latitude of the box.
+      # @return [BigDecimal]
+      def north
+        northeast.lat
+      end
+
+      # The southernmost latitude of the box.
+      # @return [BigDecimal]
+      def south
+        southwest.lat
+      end
+
+      # True if the box wraps east-west across the antimeridian.
+      # @return [Boolean]
+      def crosses_antimeridian?
+        west > east
       end
 
       # Format for display in DMS format, adapted from ISO 6709 standard.
@@ -183,33 +252,31 @@ module CocinaDisplay
       # @return [String]
       # @example "118°14′37″W -- 117°56′55″W / 34°03′08″N -- 34°11′59″N"
       def to_s
-        min_lat, min_lng = format_point(min_point)
-        max_lat, max_lng = format_point(max_point)
-        "#{min_lng} -- #{max_lng} / #{max_lat} -- #{min_lat}"
+        south_str, west_str = format_point(southwest)
+        north_str, east_str = format_point(northeast)
+        "#{west_str} -- #{east_str} / #{north_str} -- #{south_str}"
       end
 
       # Format using the Well-Known Text (WKT) representation.
       # @note Limits decimals to 6 places.
+      # @note A box crossing the antimeridian is split into two polygons at the
+      #   date line, so that every longitude stays within bounds.
       # @see https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry
+      # @see https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.9
       # @return [String]
       def as_wkt
-        "POLYGON((%.6f %.6f, %.6f %.6f, %.6f %.6f, %.6f %.6f, %.6f %.6f))" % [
-          min_point.lng, min_point.lat,
-          max_point.lng, min_point.lat,
-          max_point.lng, max_point.lat,
-          min_point.lng, max_point.lat,
-          min_point.lng, min_point.lat
-        ]
+        return "POLYGON(#{ring(west, east)})" unless crosses_antimeridian?
+
+        "MULTIPOLYGON((#{ring(west, 180)}), (#{ring(-180, east)}))"
       end
 
       # Format using the CQL ENVELOPE representation.
       # @note Limits decimals to 6 places.
+      # @note West is greater than east for a box crossing the antimeridian.
       # @example "ENVELOPE(-118.2437, -117.9522, 34.1996, 34.0522)"
       # @return [String]
       def as_envelope
-        "ENVELOPE(%.6f, %.6f, %.6f, %.6f)" % [
-          min_point.lng, max_point.lng, max_point.lat, min_point.lat
-        ]
+        "ENVELOPE(%.6f, %.6f, %.6f, %.6f)" % [west, east, north, south]
       end
 
       # The box center point as a space-separated x y (longitude latitude) pair.
@@ -217,18 +284,43 @@ module CocinaDisplay
       # @example "-118.2437 34.0522"
       # @return [String]
       def as_point
-        azimuth = min_point.azimuth(max_point)
-        distance = min_point.distance(max_point)
-        center = min_point.endpoint(distance / 2, azimuth)
-        "%.6f %.6f" % [center.lng, center.lat]
+        center_lng = (west + unwrapped_east) / 2
+        center_lng -= 360 if center_lng > 180
+        "%.6f %.6f" % [center_lng, (south + north) / 2]
       end
 
       # Format the bounding box as an array of two coordinate pairs [[S, W], [N, E]].
       # @note Limits decimals to 6 places.
+      # @note For a box crossing the antimeridian, east is carried past 180 so that
+      #   the pair still reads southwest to northeast.
       # @return [Array<Array<Float>>]
-      # @example [[-118.2437, 34.0522], [-117.9522, 34.1996]]
+      # @example [[34.0522, -118.2437], [34.1996, -117.9522]]
       def as_bbox
-        [[min_point.lat, min_point.lng], [max_point.lat, max_point.lng]]
+        [[south, west], [north, unwrapped_east]]
+      end
+
+      private
+
+      # The east edge as a continuous longitude, carried past 180 if the box
+      # crosses the antimeridian.
+      # @return [BigDecimal]
+      def unwrapped_east
+        crosses_antimeridian? ? east + 360 : east
+      end
+
+      # A closed WKT linear ring for the box, spanning the given longitudes.
+      # @note Limits decimals to 6 places.
+      # @param [Numeric] west_lng
+      # @param [Numeric] east_lng
+      # @return [String]
+      def ring(west_lng, east_lng)
+        "(%.6f %.6f, %.6f %.6f, %.6f %.6f, %.6f %.6f, %.6f %.6f)" % [
+          west_lng, south,
+          east_lng, south,
+          east_lng, north,
+          west_lng, north,
+          west_lng, south
+        ]
       end
     end
 
@@ -243,6 +335,15 @@ module CocinaDisplay
       def self.supports?(input_str)
         input_str.match?(self::PATTERN)
       end
+
+      # Move a trailing hemisphere letter to the front, since that is where the
+      # decimal normalizer expects it.
+      # @example "121.5W" becomes "W121.5"
+      # @param [String] value
+      # @return [String]
+      def self.hemisphere_first(value)
+        value.sub(/\A(.+?)([NESW])\z/, '\2\1')
+      end
     end
 
     # Mixin that adds normalization for decimal degree coordinates.
@@ -253,17 +354,28 @@ module CocinaDisplay
 
       module Helpers
         # Convert hemispheres to plus/minus signs for parsing.
+        # @note The hemisphere can either lead or trail the degrees.
         # @param [String] coord_str
         # @return [String]
         def normalize_coord(coord_str)
-          coord_str.tr("EN", "+").tr("WS", "-")
+          hemisphere_first(coord_str).tr("EN", "+").tr("WS", "-")
         end
       end
     end
 
     # Mixin that adds normalization for DMS coordinates.
     module DMSParser
-      POINT_PATTERN = /(?<hem>[NESW])(?<deg>\d{1,3})[°⁰º]?(?:(?<min>\d{1,2})[ʹ′']?)?(?:(?<sec>\d{1,2})[ʺ"″]?)?/
+      # The degrees, minutes, and seconds of a coordinate, without a hemisphere.
+      DMS_PATTERN = /(?<deg>\d{1,3})[°⁰º]?(?:(?<min>\d{1,2})[ʹ′']?)?(?:(?<sec>\d{1,2})[ʺ"″]?)?/
+
+      # A single coordinate, with the hemisphere either leading or trailing the
+      # degrees. A hemisphere is required, so that a bare number is not read as
+      # a coordinate. Both spellings are common in MARC 034 and 255$c, and the
+      # trailing form is what {Coordinates#format_point} itself emits.
+      # @note A trailing hemisphere cannot be followed by digits, otherwise a
+      #   MARC 034 $b scale like "$b3100000W120°00′00″" would read the scale as
+      #   the degrees and steal the hemisphere from the coordinate after it.
+      POINT_PATTERN = /(?:(?<hem>[NESW])#{DMS_PATTERN}|#{DMS_PATTERN}(?<hem>[NESW])(?!\d))/
 
       def self.included(base)
         base.const_set(:POINT_PATTERN, POINT_PATTERN)
@@ -313,15 +425,41 @@ module CocinaDisplay
         matches = input_str.match(self::PATTERN)
         return unless matches
 
-        min_lng = normalize_coord(matches[:min_lng])
-        max_lng = normalize_coord(matches[:max_lng])
-        min_lat = normalize_coord(matches[:min_lat])
-        max_lat = normalize_coord(matches[:max_lat])
+        west = normalize_coord(matches[:west])
+        east = normalize_coord(matches[:east])
+        south = normalize_coord(matches[:south])
+        north = normalize_coord(matches[:north])
 
-        BoundingBox.from_coords(west: min_lng, east: max_lng, north: max_lat, south: min_lat)
+        BoundingBox.from_coords(west: west, east: east, north: north, south: south)
       end
     end
 
+    # Base class for normalizers that standardize a single coordinate value, as
+    # found in Cocina structured values, so that Geo::Coord can parse it.
+    # Subclasses define a PATTERN and mix in a parser module for normalize_coord.
+    class CoordinateNormalizer < CoordinatesParser
+    end
+
+    # Normalizes DMS values, including the packed form used in MARC 034 subfields.
+    # @example W1210000
+    # @example 121°14′48″W
+    class DMSCoordinateNormalizer < CoordinateNormalizer
+      include DMSParser
+
+      # Either DMS punctuation, or a hemisphere paired with packed digits.
+      PATTERN = /[°⁰º′ʹ'″ʺ"]|\A[NESW]\d{4,}\z|\A\d{4,}[NESW]\z/
+    end
+
+    # Normalizes decimal degree values, either signed or paired with a hemisphere.
+    # @note Degrees are limited to 3 digits so that packed DMS isn't read as decimal.
+    # @example -121.24658
+    # @example W126.04
+    class DecimalCoordinateNormalizer < CoordinateNormalizer
+      include DecimalParser
+
+      PATTERN = /\A[NESW+-]?\d{1,3}(?:\.\d+)?[NESW]?\z/
+    end
+
     # Parse for decimal degree points, like "41.891797, 12.486419".
     class DecimalPointParser < PointParser
       include DecimalParser
@@ -330,10 +468,12 @@ module CocinaDisplay
     end
 
     # Parser for DMS-format points, like "N34°03′08″ W118°14′37″".
+    # @note The hemisphere can either lead or trail the degrees in each half.
+    # @example 34°03′08″N 118°14′37″W
     class DMSPointParser < PointParser
       include DMSParser
 
-      PATTERN = /(?<lat>[^EW]+)(?<lng>[^NS]+)/
+      PATTERN = /(?<lat>[NS][^NS]+|[^NS]+[NS])(?<lng>[EW][^EW]+|[^EW]+[EW])/
     end
 
     # DMS-format bounding boxes with varying punctuation, delimited by -- and /.
@@ -342,7 +482,7 @@ module CocinaDisplay
     class DMSBoundingBoxParser < BoundingBoxParser
       include DMSParser
 
-      PATTERN = /(?<min_lng>.+?)-+(?<max_lng>.+)\/(?<max_lat>.+?)-+(?<min_lat>.+)/
+      PATTERN = /(?<west>.+?)-+(?<east>.+)\/(?<north>.+?)-+(?<south>.+)/
     end
 
     # Format that pairs hemispheres with decimal degrees.
@@ -350,21 +490,21 @@ module CocinaDisplay
     class DecimalBoundingBoxParser < BoundingBoxParser
       include DecimalParser
 
-      PATTERN = /(?<min_lng>[0-9.EW]+?)-+(?<max_lng>[0-9.EW]+)\/(?<max_lat>[0-9.NS]+?)-+(?<min_lat>[0-9.NS]+)/
+      PATTERN = /(?<west>[0-9.EW]+?)-+(?<east>[0-9.EW]+)\/(?<north>[0-9.NS]+?)-+(?<south>[0-9.NS]+)/
     end
 
     # DMS-format data that appears to come from MARC 034 subfields.
     # @see https://www.oclc.org/bibformats/en/0xx/034.html
     # @example $dW0963700$eW0900700$fN0433000$gN040220
     class MarcDMSBoundingBoxParser < DMSBoundingBoxParser
-      PATTERN = /\$d(?<min_lng>[WENS].+)\$e(?<max_lng>[WENS].+)\$f(?<max_lat>[WENS].+)\$g(?<min_lat>[WENS].+)/
+      PATTERN = /\$d(?<west>[WENS].+)\$e(?<east>[WENS].+)\$f(?<north>[WENS].+)\$g(?<south>[WENS].+)/
     end
 
     # Decimal degree format data that appears to come from MARC 034 subfields.
     # @see https://www.oclc.org/bibformats/en/0xx/034.html
     # @example $d-112.0785250$e-111.6012719$f037.6516503$g036.8583209
     class MarcDecimalBoundingBoxParser < DecimalBoundingBoxParser
-      PATTERN = /\$d(?<min_lng>[0-9.-]+)\$e(?<max_lng>[0-9.-]+)\$f(?<max_lat>[0-9.-]+)\$g(?<min_lat>[0-9.-]+)/
+      PATTERN = /\$d(?<west>[0-9.-]+)\$e(?<east>[0-9.-]+)\$f(?<north>[0-9.-]+)\$g(?<south>[0-9.-]+)/
     end
   end
 end

data/lib/cocina_display/version.rb

@@ -2,5 +2,5 @@
 
 # :nodoc:
 module CocinaDisplay
-  VERSION = "2.11.0" # :nodoc:
+  VERSION = "2.13.0" # :nodoc:
 end

data/script/find_records.rb

@@ -3,28 +3,29 @@
 # This script is a simple, brute-force method for finding records that
 # exhibit certain characteristics in the public Cocina JSON for testing.
 #
-# It queries purl-fetcher for all DRUIDs released to a specific target and
-# then fetches each corresponding public Cocina record from PURL and examines it.
-#
-# You need to be on VPN to do this, as the purl-fetcher API is only accessible
-# from within the Stanford network.
+# It reads the public PURL sitemap to enumerate all released DRUIDs and then
+# fetches each corresponding public Cocina record from PURL and examines it.
 #
 # To use, modify any of the noted items below, then run:
 # $ bundle exec ruby script/find_records.rb
 #
 # You can exit early with Ctrl-C, and it will report how many records were
-# checked before exiting. Running through an entire target will take awhile,
+# checked before exiting. Running through the entire sitemap will take awhile,
 # on the order of 30 minutes or more.
 
 require "benchmark"
+require "net/http"
 require "pp"
-require "purl_fetcher/client"
+require "rexml/document"
+require "stringio"
+require "uri"
+require "zlib"
 require "cocina_display"
 require "cocina_display/utils"
 
-# This should correspond to one of the release targets available in purl-fetcher,
-# i.e. "Searchworks", "Earthworks", etc.
-RELEASE_TARGET = "Searchworks"
+# The PURL sitemap index. This points to one or more gzipped child sitemaps,
+# each of which lists PURL URLs (one per released DRUID).
+SITEMAP_URL = "https://purl.stanford.edu/system/sitemap/sitemap.xml.gz"
 
 # Modify this expression to match the JSON path you want to search, or just
 # modify the `examine_record` method directly.
@@ -36,8 +37,33 @@ def examine_record(record)
   record.path(PATH_EXPR).map { |value, _node, _key, path| [path, CocinaDisplay::Utils.deep_compact_blank(value)] }
 end
 
-# Track total records in target and how many we've seen
-released_to_target = []
+# Fetch a URL and return the response body, transparently decompressing it if
+# it was served (or named) as gzip.
+def fetch_gzipped(url)
+  body = Net::HTTP.get(URI(url))
+  Zlib::GzipReader.new(StringIO.new(body)).read
+rescue Zlib::GzipFile::Error
+  body
+end
+
+# Extract every <loc> value from a sitemap or sitemap index document.
+def sitemap_locs(xml)
+  REXML::Document.new(xml).get_elements("//loc").map { |loc| loc.text.strip }
+end
+
+# Walk the sitemap index and yield the DRUID for every URL in each child sitemap.
+def each_druid_in_sitemap(sitemap_url)
+  return enum_for(:each_druid_in_sitemap, sitemap_url) unless block_given?
+
+  sitemap_locs(fetch_gzipped(sitemap_url)).each do |child_sitemap_url|
+    sitemap_locs(fetch_gzipped(child_sitemap_url)).each do |purl_url|
+      yield File.basename(URI(purl_url).path)
+    end
+  end
+end
+
+# Track total records and how many we've seen
+druids = []
 processed_records = 0
 
 # Handle Ctrl-C gracefully
@@ -46,24 +72,21 @@ Signal.trap("INT") do
   exit
 end
 
-# Fetch everything from purl-fetcher; note that this is one single HTTP request
-# that returns a massive JSON response – it can be quite slow
-puts "Finding records released to #{RELEASE_TARGET}..."
-client = PurlFetcher::Client::Reader.new
+# Read the sitemap; this involves a handful of HTTP requests (the index plus
+# each child sitemap) that are relatively quick compared to purl-fetcher.
+puts "Finding released records from the PURL sitemap..."
 query_time = Benchmark.realtime do
-  client.released_to(RELEASE_TARGET).each do |record|
-    released_to_target << record["druid"].delete_prefix("druid:")
-  end
-rescue Faraday::ConnectionFailed => e
-  puts "Connection failed: #{e.message}; are you on VPN?"
+  each_druid_in_sitemap(SITEMAP_URL) { |druid| druids << druid }
+rescue => e
+  puts "Failed to read sitemap: #{e.message}"
   exit 1
 end
-puts "Found #{released_to_target.size} records released to #{RELEASE_TARGET} in #{query_time.round(2)} seconds"
+puts "Found #{druids.size} records in the sitemap in #{query_time.round(2)} seconds"
 
 # Iterate through the list of DRUIDs and fetch each one from PURL, creating a
 # CocinaRecord object. Then call our examine_record method on it and if
 # anything was returned, print the DRUID and the results.
-released_to_target.each do |druid|
+druids.each do |druid|
   begin
     cocina_record = CocinaDisplay::CocinaRecord.fetch(druid)
     processed_records += 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cocina_display
 version: !ruby/object:Gem::Version
-  version: 2.11.0
+  version: 2.13.0
 platform: ruby
 authors:
 - Nick Budak
@@ -217,20 +217,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.9.1
-- !ruby/object:Gem::Dependency
-  name: purl_fetcher-client
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.1'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.1'
 email:
 - budak@stanford.edu
 executables: []
@@ -279,6 +265,7 @@ files:
 - lib/cocina_display/events/event.rb
 - lib/cocina_display/events/imprint.rb
 - lib/cocina_display/events/location.rb
+- lib/cocina_display/events/location_value.rb
 - lib/cocina_display/events/note.rb
 - lib/cocina_display/forms/form.rb
 - lib/cocina_display/forms/genre.rb
@@ -326,7 +313,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.15
 specification_version: 4
 summary: Helpers for rendering Cocina metadata
 test_files: []