obp-access 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b3fda155513c49b50f81b401262456e78f63e55fb0ced23f8a54bf4577ee0af
-  data.tar.gz: 75070c8db35ae812f69f19bb55e536c9c9b3da5ec29a5846bd9d9cd53e6d5f2a
+  metadata.gz: 728e6533423209e6fc2a17945ca7afc15f7b36c8bfe39451e1ad8f66d6554bb5
+  data.tar.gz: 92a04641a9ebc2774e60518e560871287c9855998848f2d3d2ffddcee95f0221
 SHA512:
-  metadata.gz: fcf54d0abc492eae8542e14e3313199be54bce5eb45fd454996a3c69dc8d5c7641a8a4bd58bbde701320c142d051ab186441b4ce47d39f47dba1774d6b329562
-  data.tar.gz: c19c3f486740f899e6e0ecad8479f78f34a7c9cf3cad8638c2eb5344408a2047e3f6f8e7222e31ea57ac7e1c79047709466c23795872c6bf238e8b076a31e77f
+  metadata.gz: e4f9adc699152992207abfc9986d5e06e8db3a110f37eb2ed1e6cfd4f3dcd57d6f4ee63614ed44b26a40bcf70d355a3ebd2cf51041ba961040a5063a9ee88802
+  data.tar.gz: 883124569b65db99872fa2f12de85070ee72dea94fa113b6af87d94a8ecc2bb2c61f7eaf0a261eacdb69d817e032c9820810fb5973301043476f0f15768e5989

data/.rubocop.yml

@@ -1,18 +1,31 @@
 # Auto-generated by Cimas: Do not edit it manually!
 # See https://github.com/metanorma/cimas
 inherit_from:
+  - https://raw.githubusercontent.com/riboseinc/oss-guides/main/ci/rubocop.yml
+  # .rubocop_todo.yml MUST be the last entry. inherit_from is last-wins:
+  # if listed before oss-guides, the shared config's stricter Metrics/
+  # (MethodLength, BlockLength, etc.) rules override the todo's per-file
+  # grandfathering, and the todo becomes inert on those cops. Empirically
+  # verified on suma 2026-07-06: with todo listed first, 34 Metrics/* offenses
+  # remained; moved last, cleared. Every gem in the metanorma-org fleet
+  # already ships a `.rubocop_todo.yml` on its live tree (audited 2026-07-06,
+  # 54/54 have it), so this reference is safe to emit unconditionally.
   - .rubocop_todo.yml
-  - https://raw.githubusercontent.com/riboseinc/oss-guides/master/ci/rubocop.yml
+
+# Rubocop plugins enabled centrally so every metanorma-org gem picks them up
+# on cimas sync — best practice belongs at the shared-template layer, not
+# per-repo. Per ronaldtse feedback on metanorma/ci#332.
+plugins:
+  - rubocop-rspec
+  - rubocop-performance
+  - rubocop-rake
 
 # local repo-specific modifications
 # ...
 
 AllCops:
-  NewCops: enable
-  SuggestExtensions: false
-
-Metrics/MethodLength:
-  Max: 30
-
-Layout/LineLength:
-  Max: 120
+  # 3.3 matches the org-wide minimum being pushed via #274 (Raise minimum
+  # Ruby version to 3.3 due to EOL of 3.2 on 2026-03-31). Was 3.4 before
+  # this commit — 3.4 was above the org's stated minimum and would have
+  # applied Rubocop rules that fail-close on gems still targeting 3.3.
+  TargetRubyVersion: 3.3

data/.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2026-06-15 08:31:30 UTC using RuboCop version 1.86.1.
+# on 2026-07-18 01:14:30 UTC using RuboCop version 1.88.2.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
@@ -11,9 +11,116 @@ Gemspec/RequiredRubyVersion:
   Exclude:
     - 'obp-access.gemspec'
 
+# Offense count: 139
+# This cop supports safe autocorrection (--autocorrect).
+# Configuration parameters: Max, AllowHeredoc, AllowURI, AllowQualifiedName, URISchemes, AllowRBSInlineAnnotation, AllowCopDirectives, AllowedPatterns, SplitStrings.
+# URISchemes: http, https
+Layout/LineLength:
+  Exclude:
+    - 'fetch_en_html.rb'
+    - 'fetch_html.rb'
+    - 'lib/obp/access/catalog.rb'
+    - 'lib/obp/access/cli.rb'
+    - 'lib/obp/access/domain_extractor.rb'
+    - 'lib/obp/access/elements/base.rb'
+    - 'lib/obp/access/elements/bibliography.rb'
+    - 'lib/obp/access/elements/figure_group.rb'
+    - 'lib/obp/access/elements/index.rb'
+    - 'lib/obp/access/elements/root.rb'
+    - 'lib/obp/access/elements/terminology/definition.rb'
+    - 'lib/obp/access/elements/terminology/example.rb'
+    - 'lib/obp/access/elements/terminology/tig.rb'
+    - 'lib/obp/access/elements/terminology/tig_deprecated.rb'
+    - 'lib/obp/access/grammar_parser.rb'
+    - 'lib/obp/access/inline_renderer.rb'
+    - 'lib/obp/access/parser.rb'
+    - 'lib/obp/access/retriever.rb'
+    - 'obp-access.gemspec'
+    - 'spec/obp/access/access_spec.rb'
+    - 'spec/obp/access/cli_spec.rb'
+    - 'spec/obp/access/deliverable_spec.rb'
+    - 'spec/obp/access/elements/bib_ref_spec.rb'
+    - 'spec/obp/access/elements/disp_formula_spec.rb'
+    - 'spec/obp/access/elements/figure_group_spec.rb'
+    - 'spec/obp/access/elements/figure_spec.rb'
+    - 'spec/obp/access/elements/footnotes_spec.rb'
+    - 'spec/obp/access/elements/index_spec.rb'
+    - 'spec/obp/access/elements/non_normative_example_spec.rb'
+    - 'spec/obp/access/elements/protected_content_note_spec.rb'
+    - 'spec/obp/access/elements/section_title_spec.rb'
+    - 'spec/obp/access/elements/table_wrap_spec.rb'
+    - 'spec/obp/access/elements/terminology/definition_spec.rb'
+    - 'spec/obp/access/elements/terminology/tig_spec.rb'
+    - 'spec/obp/access/grammar_parser_spec.rb'
+    - 'spec/obp/access/inline_renderer_spec.rb'
+    - 'spec/obp/access/retriever_spec.rb'
+
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+Lint/SafeNavigationWithEmpty:
+  Exclude:
+    - 'lib/obp/access/elements/disp_formula.rb'
+
 # Offense count: 3
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Exclude:
     - 'lib/obp/access/elements/bibliography/bib_ref.rb'
     - 'lib/obp/access/elements/root.rb'
+
+# Offense count: 11
+# Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
+Metrics/MethodLength:
+  Max: 16
+
+# Offense count: 1
+# Configuration parameters: IgnoredMetadata.
+RSpec/DescribeClass:
+  Exclude:
+    - '**/spec/features/**/*'
+    - '**/spec/requests/**/*'
+    - '**/spec/routing/**/*'
+    - '**/spec/system/**/*'
+    - '**/spec/views/**/*'
+    - 'spec/obp/access/elements/terminology/tig_spec.rb'
+
+# Offense count: 44
+# Configuration parameters: CountAsOne.
+RSpec/ExampleLength:
+  Max: 26
+
+# Offense count: 1
+# This cop supports safe autocorrection (--autocorrect).
+RSpec/IteratedExpectation:
+  Exclude:
+    - 'spec/obp/access/catalog_spec.rb'
+
+# Offense count: 1
+RSpec/MultipleDescribes:
+  Exclude:
+    - 'spec/obp/access/elements/terminology/tig_spec.rb'
+
+# Offense count: 65
+RSpec/MultipleExpectations:
+  Max: 11
+
+# Offense count: 14
+# Configuration parameters: CustomTransform, IgnoreMethods, IgnoreMetadata, InflectorPath, EnforcedInflector.
+# SupportedInflectors: default, active_support
+RSpec/SpecFilePathFormat:
+  Exclude:
+    - '**/spec/routing/**/*'
+    - 'spec/obp/access/access_spec.rb'
+    - 'spec/obp/access/elements/bib_ref_spec.rb'
+    - 'spec/obp/access/elements/disp_formula_spec.rb'
+    - 'spec/obp/access/elements/figure_group_spec.rb'
+    - 'spec/obp/access/elements/figure_spec.rb'
+    - 'spec/obp/access/elements/footnotes_spec.rb'
+    - 'spec/obp/access/elements/index_spec.rb'
+    - 'spec/obp/access/elements/non_normative_example_spec.rb'
+    - 'spec/obp/access/elements/protected_content_note_spec.rb'
+    - 'spec/obp/access/elements/root_spec.rb'
+    - 'spec/obp/access/elements/section_title_spec.rb'
+    - 'spec/obp/access/elements/section_type_spec.rb'
+    - 'spec/obp/access/elements/table_wrap_spec.rb'
+    - 'spec/obp/access/elements/terminology/definition_spec.rb'

data/README.adoc

@@ -86,6 +86,117 @@ The output is NISO STS XML with TBX-Basic terminology markup:
 * Domains are extracted as `<tbx:subjectField>`
 * Deprecated terms use `<tbx:normativeAuthorization value="deprecatedTerm"/>`
 
+=== Tables and terms as YAML
+
+Besides STS XML, the same preview HTML can be read as YAML table data.
+ISO standards that carry terminology in tables rather than TBX term
+sections (the ISO 80000 quantity tables, "list of equivalent terms"
+tables) become machine-readable through two views:
+
+[source,ruby]
+----
+obp = Obp::Access.fetch("iso:std:iso:80000-12:ed-2:v2:en")
+obp.to_tables # => YAML string: every table in the document
+obp.to_terms  # => YAML string: term entries from term-carrying tables
+----
+
+Both reuse the already-fetched preview HTML, so no extra OBP request is
+made. A document without tables yields an empty YAML array (`--- []`).
+
+==== Generic tables (`to_tables`)
+
+`Obp::Access::TableMapper` maps every table-carrying node —
+`div.sts-table-wrap` and `div.sts-array`, in document order — to plain
+hashes, arrays and strings:
+
+[source,yaml]
+----
+- id: iso_std_iso_80000-12_ed-2_v2_en_tab_1 # wrapper id, if present
+  section: '3'      # containing clause ("index"/"bibl"/... stay raw)
+  label: Table 1    # .sts-caption-label, if present
+  caption: Quantities and units used in condensed matter physics
+  header:
+  - - text: Item No.
+    - text: Quantity
+      colspan: 3    # colspan/rowspan only when greater than 1
+    - text: Unit
+    - text: Remarks
+  rows:
+  - - text: 12-1.1
+    - text: lattice vector
+    - text: R
+    - text: translation vector that maps the crystal lattice on itself
+    - text: m
+    - text: The non-SI unit ångström (Å) is widely used ...
+----
+
+Cell text is plain stripped text: OBP `sts-unknown-element` placeholder
+spans are removed, and `<br>` / `div.sts-p` boundaries become spaces so
+multi-paragraph cells do not glue words together.
+
+==== Term entries (`to_terms`)
+
+`Obp::Access::TableTermExtractor` consumes the generic table model (not
+raw HTML) and extracts entries from term-carrying tables. Recognition
+rules, first match wins per table:
+
+. *Quantity/item tables* (ISO 80000 family): at least 4 columns, the
+  table sits in a numbered clause, and a majority of body rows start
+  with an item number (`12-1.1`, `4-1`). Column roles are resolved from
+  the joined header text — this handles the two-row colspan headers in
+  both English (Item No. / Quantity / Unit / Remarks) and French
+  (N° / Grandeur / Unité / Remarques) — falling back to the ISO 80000
+  column order item, designation, symbol, definition, unit, remarks.
+. *Equivalent-terms tables*: a header row naming languages in at least
+  2 columns. One entry per row, with `designations` keyed by downcased
+  language name; rows with a single designation (letter dividers) are
+  skipped.
+. Anything else is not a term table and yields no entries.
+
+[source,yaml]
+----
+- id: 12-1.1
+  designation: lattice vector
+  definition: translation vector that maps the crystal lattice on itself
+  symbol: R
+  unit: m
+  remarks: The non-SI unit ångström (Å) is widely used ...
+  source:
+    table: iso_std_iso_80000-12_ed-2_v2_en_tab_1
+    section: '3'
+- id: '2'
+  designations:
+    english: absorption, atmospheric
+    francais: absorption atmosphérique
+    deutsch: atmosphärische Absorption
+  source:
+    section: '1.1'
+----
+
+Only non-empty fields are emitted (`id` and `designation` are always
+present); duplicate item numbers within one table keep the first row.
+For equivalent-terms tables the entry `id` is the row's first cell when
+it looks like an item number, else the 1-based row index.
+
+==== Known limitations
+
+* Column mapping is header-text and position based; exotic header
+  layouts (rowspans in `thead`, role columns in unusual order) are not
+  resolved.
+* Quantity tables are recognized only in numbered clauses and only when
+  a strict majority of rows start with an item number; continuation
+  rows (blank item number) are skipped rather than merged into the
+  previous entry.
+* Item numbers must match `\d+-\d+(\.\d+)?` (U+2011 non-breaking hyphen
+  is normalized to `-`); rows printed differently in the source, such
+  as the `3.10.2` typo in ISO 80000-3, are skipped.
+* Cell text is flattened: subscripts/superscripts, inline formulas and
+  images lose their markup (`a1` for a₁), and French gender markers stay
+  glued to designations (`vecteur du réseau, m`).
+* Equivalent-terms designations are keyed by the downcased header text
+  as printed (`francais` in ISO 5843-6); mojibake headers (e.g.
+  `PyCCKMM` for Russian) are not recognized as languages.
+
 == Credits
 
 This gem is developed, maintained and funded by

data/lib/obp/access/element_registry.rb

@@ -11,8 +11,10 @@ module Obp
           @elements ||= []
         end
 
+        # Flattened unique class names across all registered elements, so
+        # callers can test membership against individual node classes.
         def css_classes
-          @css_classes ||= elements.filter_map(&:classes).uniq
+          @css_classes ||= elements.filter_map(&:classes).flatten.uniq
         end
       end
     end

data/lib/obp/access/elements/base.rb

@@ -17,12 +17,17 @@ module Obp
             nil
           end
 
+          # Subset match: OBP varies class order and adds marker classes
+          # (e.g. "commentable"), so a node matches when it carries at
+          # least the registered classes, regardless of order or extras.
           def match_node?
-            node.classes == self.class.classes
+            (self.class.classes - node.classes).empty?
           end
 
           def render(target:)
-            effective_target = insertion_target || target
+            # Top-level nodes without their own insertion target (e.g. a
+            # floating sts-p between sections) default to the body.
+            effective_target = insertion_target || target || "body"
             effective_target = "#{effective_target}#{path_suffix}" if path_suffix
             document.at(effective_target).public_send(insert_method, to_xml)
           end

data/lib/obp/access/elements/disp_formula.rb

@@ -0,0 +1,53 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        class DispFormula < Base
+          def self.classes
+            %w[sts-disp-formula-panel]
+          end
+
+          private
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.public_send(:"disp-formula") do
+                xml.label label if label
+                if math
+                  xml << math.to_xml
+                elsif graphic_path
+                  xml.graphic("xlink:href": graphic_path)
+                end
+              end
+            end
+          end
+
+          def label
+            text = node.at_css(".sts-disp-formula-label")&.text&.strip
+            text unless text&.empty?
+          end
+
+          def math
+            @math ||= node.at_css("math")
+          end
+
+          # OBP serves formula images from its own graphics store, which
+          # Imager does not download; fall back to the original src.
+          def graphic_path
+            @graphic_path ||= begin
+              img = node.at_css("img")
+              img && (stored_image_path(img) || img.attr("src"))
+            end
+          end
+
+          def stored_image_path(img)
+            images = metas["images"]
+            images[img.attr("src")] if images.is_a?(Hash)
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::DispFormula)

data/lib/obp/access/elements/footnotes.rb

@@ -0,0 +1,47 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        # OBP emits page footnotes as a trailing "sts-footnotes" container
+        # holding one "sts-fn" div per note, each text prefixed with the
+        # note number.
+        class Footnotes < Base
+          def self.classes
+            %w[sts-footnotes]
+          end
+
+          private
+
+          def insertion_target
+            "back"
+          end
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.public_send(:"fn-group") do
+                node.css("div.sts-fn").each { |note| render_fn(xml, note) }
+              end
+            end
+          end
+
+          def render_fn(xml, note)
+            xml.fn(id: "fn_#{fn_id(note)}") do
+              xml.label fn_id(note)
+              xml.p fn_text(note)
+            end
+          end
+
+          def fn_id(note)
+            note.attr("id").split("_").last
+          end
+
+          def fn_text(note)
+            note.at_css("div").text.strip.sub(/\A\d+\s*/, "")
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::Footnotes)

data/lib/obp/access/elements/non_normative_example.rb

@@ -0,0 +1,28 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        # Renders the example label; the content div.sts-p children are
+        # rendered by Paragraph when the renderer recurses into them.
+        class NonNormativeExample < Base
+          def self.classes
+            %w[sts-non-normative-example]
+          end
+
+          private
+
+          def content
+            Nokogiri::XML::Builder.new do |xml|
+              xml.public_send(:"non-normative-example") do
+                label_node = node.at_css(".sts-non-normative-example-label")
+                xml.label label_node.text if label_node
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::NonNormativeExample)

data/lib/obp/access/elements/protected_content_note.rb

@@ -0,0 +1,25 @@
+module Obp
+  class Access
+    class Renderer
+      class Elements
+        # OBP replaces paywalled sections with this placeholder ("Only
+        # informative sections of standards are publicly available...").
+        # Skip it explicitly: render nothing and halt recursion, so the
+        # placeholder text never leaks into the output.
+        class ProtectedContentNote < Base
+          def self.classes
+            %w[sts-protected-content-note]
+          end
+
+          # Accepts (and ignores) the render target; the nil return tells
+          # the renderer to halt recursion into this subtree.
+          def render(*)
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+
+Obp::Access::ElementRegistry.register(Obp::Access::Renderer::Elements::ProtectedContentNote)

data/lib/obp/access/elements/table_wrap.rb

@@ -4,7 +4,7 @@ module Obp
       class Elements
         class TableWrap < Base
           def self.classes
-            %w[sts-table-wrap fig-index]
+            %w[sts-table-wrap]
           end
 
           def match_node?
@@ -26,17 +26,28 @@ module Obp
                     xml.title caption_text
                   end
                 end
-                xml.table { xml << node.at_css("table").inner_html }
+                xml.table { xml << table_markup }
               end
             end
           end
 
+          # Serialize the children as XML so void elements (e.g. <col>)
+          # self-close; inner_html emits unclosed HTML voids that swallow
+          # following rows when the builder re-parses the fragment. OBP's
+          # "sts-unknown-element" placeholders are stripped first.
+          def table_markup
+            table = node.at_css("table").dup
+            table.css(".sts-unknown-element").each(&:remove)
+            table.children.map(&:to_xml).join
+          end
+
           def caption_label
             @caption_label ||= node.at_css(".sts-caption-label")&.content
           end
 
           def caption_text
-            @caption_text ||= node.at_css(".sts-caption")&.content
+            @caption_text ||= node.at_css(".sts-caption-title")&.content ||
+              node.at_css(".sts-caption")&.content
           end
         end
       end

data/lib/obp/access/inline_renderer.rb

@@ -6,6 +6,9 @@ module Obp
         %w[sts-xref] => :xref,
         %w[sts-std-ref] => :std_ref,
         %w[sts-label] => :label,
+        # OBP's marker for content it could not map; drop its placeholder
+        # text ("[no rendering defined for element: ...]").
+        %w[sts-unknown-element] => :skip,
       }.freeze
 
       def render_inline(xml, node)
@@ -19,7 +22,7 @@ module Obp
       def render_node_by_type(xml, node, type)
         if CONTAINER_TYPES.key?(type)
           render_container(xml, node, CONTAINER_TYPES[type])
-        elsif type == :label
+        elsif %i[label skip].include?(type)
           nil
         elsif type == :element
           render_children(xml, node)

data/lib/obp/access/renderer.rb

@@ -20,23 +20,35 @@ module Obp
       def render(node:, target: nil)
         return unless css_classes_match?(node)
 
-        ElementRegistry.elements.each do |element_class|
-          element = element_class.new(document:, metas:, node:)
-          next unless element.match_node?
-
-          xml = element.render(target:)
-          section_path = xml.first.path
+        element = matching_element(node)
+        # A nil xml means the element rendered nothing (e.g. an explicit
+        # skip element); recursion into its children halts with it.
+        xml = element&.render(target:)
+        render_children(node, xml) if xml
+      end
 
-          node.children.each do |child|
-            render(node: child, target: section_path)
-          end
+      def render_children(node, xml)
+        section_path = xml.first&.path
+        return unless section_path
 
-          xml
+        node.children.each do |child|
+          render(node: child, target: section_path)
         end
       end
 
+      # First match wins: the matching element with the most registered
+      # classes is the most specific (e.g. Terminology beats Section for
+      # "sts-section sts-tbx-sec"); ties resolve in registration order
+      # because max_by keeps the first maximum.
+      def matching_element(node)
+        ElementRegistry.elements.filter_map do |element_class|
+          element = element_class.new(document:, metas:, node:)
+          element if element.match_node?
+        end.max_by { |element| element.class.classes.size }
+      end
+
       def css_classes_match?(node)
-        ElementRegistry.css_classes.any?(node.classes)
+        ElementRegistry.css_classes.intersect?(node.classes)
       end
     end
   end

data/lib/obp/access/table_mapper.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require "yaml"
+
+module Obp
+  class Access
+    # Maps the table-carrying nodes of an OBP preview HTML fragment —
+    # div.sts-table-wrap and div.sts-array, in document order — to a
+    # generic table model built from plain hashes, arrays and strings,
+    # ready for YAML serialization. This is an additive read of the same
+    # HTML source the Converter renders to STS XML; TableTermExtractor
+    # consumes this model.
+    class TableMapper
+      # Both wrapper kinds carry a single <table>.
+      WRAP_SELECTOR = "div.sts-table-wrap, div.sts-array"
+
+      # Section ids look like "toc_iso_std_iso_80000-12_ed-2_v2_en_sec_3";
+      # the clause key is whatever follows "_sec_" ("3", "1.1", "index").
+      SECTION_ID_PATTERN = /_sec_(.+)\z/
+
+      attr_reader :source
+
+      def initialize(source:)
+        @source = source
+      end
+
+      def tables
+        @tables ||= wraps.map { |node| map_table(node) }
+      end
+
+      def to_yaml
+        tables.to_yaml
+      end
+
+      private
+
+      def document
+        @document ||= Nokogiri::HTML(source.gsub(/[[:space:]]/, " "))
+      end
+
+      def wraps
+        @wraps ||= begin
+          nodes = document.css("body > div.sts-standard").css(WRAP_SELECTOR)
+          nodes.each { |node| node.css(".sts-unknown-element").each(&:remove) }
+          nodes
+        end
+      end
+
+      def map_table(node)
+        {
+          "id" => node["id"],
+          "section" => section_of(node),
+          "label" => text_of(node.at_css(".sts-caption-label")),
+          "caption" => caption_of(node),
+          "header" => map_rows(node.css("thead tr")),
+          "rows" => map_rows(body_rows(node)),
+        }.compact
+      end
+
+      def section_of(node)
+        section = node.ancestors("div").find do |ancestor|
+          ancestor.classes.include?("sts-section")
+        end
+        section&.[]("id")&.[](SECTION_ID_PATTERN, 1)
+      end
+
+      def caption_of(node)
+        text_of(node.at_css(".sts-caption-title")) ||
+          text_of(node.at_css(".sts-caption"))
+      end
+
+      # Body rows come from <tbody> when the source splits head/body;
+      # otherwise every <tr> outside a <thead> is a body row.
+      def body_rows(node)
+        rows = node.css("tbody tr")
+        return rows unless rows.empty?
+
+        node.css("table tr").reject { |tr| tr.ancestors("thead").any? }
+      end
+
+      def map_rows(rows)
+        rows.map do |tr|
+          tr.element_children.map { |cell| map_cell(cell) }
+        end.reject(&:empty?)
+      end
+
+      def map_cell(cell)
+        mapped = { "text" => cell_text(cell) }
+        %w[colspan rowspan].each do |attribute|
+          span = cell[attribute].to_i
+          mapped[attribute] = span if span > 1
+        end
+        mapped
+      end
+
+      # Plain stripped cell text. OBP's unknown-element placeholders are
+      # removed at the wrapper level; <br> and block-level div.sts-p
+      # boundaries become spaces so multi-paragraph cells do not glue
+      # words together.
+      def cell_text(cell)
+        copy = cell.dup
+        copy.css("br, div.sts-p").each do |node|
+          node.add_previous_sibling(" ")
+        end
+        copy.content.gsub(/[[:space:]]+/, " ").strip
+      end
+
+      def text_of(node)
+        return unless node
+
+        text = node.content.gsub(/[[:space:]]+/, " ").strip
+        text unless text.empty?
+      end
+    end
+  end
+end

data/lib/obp/access/table_term_extractor.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Obp
+  class Access
+    # Extracts term entries from TableMapper's generic table model.
+    #
+    # Recognition rules, first match wins per table:
+    #
+    # 1. Quantity/item tables (the ISO 80000 family): at least 4 columns,
+    #    placed in a numbered clause (the terms clause), and a majority of
+    #    body rows whose first cell is an item number (e.g. "12-1.1").
+    #    Column roles come from header text when possible ("Quantity
+    #    Symbol", "Grandeur Symbole", ...), falling back to the ISO 80000
+    #    column order [item, designation, symbol, definition, unit,
+    #    remarks].
+    # 2. Equivalent-terms tables: a header row naming languages in at
+    #    least 2 columns; one entry per row with designations keyed by
+    #    the downcased language name.
+    #
+    # Anything else is not a term table and yields no entries.
+    class TableTermExtractor
+      # "12-1.1" or "4-1"; OBP sometimes prints U+2011 NON-BREAKING
+      # HYPHEN, normalized away by normalize_item.
+      ITEM_PATTERN = /\A\d+-\d+(?:\.\d+)?\z/
+
+      MIN_QUANTITY_COLUMNS = 4
+      MIN_LANGUAGE_COLUMNS = 2
+
+      # Terms clauses are numbered ("3", "3.2"); foreword, intro, bibl
+      # and index sections are not.
+      NUMERIC_SECTION = /\A\d+(\.\d+)*\z/
+
+      # Checked in order against each column's joined header text; the
+      # first unassigned column matching wins, so "Quantity Symbol"
+      # becomes "symbol" and not "designation".
+      COLUMN_ROLE_PATTERNS = [
+        ["symbol", /symbol|symbole/i],
+        ["definition", /definition|définition/i],
+        ["unit", /unit|unité/i],
+        ["remarks", /remark|remarque/i],
+        ["item", /item\s+no|n[°º]|numéro|no\./i],
+        ["designation", /quantity|grandeur|term|terme|name|nom/i],
+      ].freeze
+
+      # Fallback when header-text matching cannot place item+designation.
+      POSITIONAL_ROLES = %w[
+        item designation symbol definition unit remarks
+      ].freeze
+
+      # Language names recognized in equivalent-terms table headers.
+      LANGUAGES = %w[
+        english french français francais anglais russian russe русский
+        german deutsch allemand spanish español espagnol italian italiano
+        italien chinese chinois japanese japonais arabic arabe portuguese
+        portugais korean coréen
+      ].freeze
+
+      attr_reader :tables
+
+      def initialize(tables:)
+        @tables = tables
+      end
+
+      def entries
+        @entries ||= tables.flat_map { |table| table_entries(table) }
+      end
+
+      def to_yaml
+        entries.to_yaml
+      end
+
+      private
+
+      def table_entries(table)
+        if quantity_table?(table)
+          quantity_entries(table)
+        elsif equivalent_terms_table?(table)
+          equivalent_entries(table)
+        else
+          []
+        end
+      end
+
+      def quantity_table?(table)
+        return false unless NUMERIC_SECTION.match?(table["section"].to_s)
+        return false unless column_count(table) >= MIN_QUANTITY_COLUMNS
+
+        rows = table["rows"]
+        return false if rows.empty?
+
+        rows.count { |row| item_number?(cell_text(row, 0)) } * 2 > rows.size
+      end
+
+      def quantity_entries(table)
+        roles = column_roles(table)
+        seen = {}
+        table["rows"].filter_map do |row|
+          id = normalize_item(cell_text(row, roles["item"]))
+          next unless ITEM_PATTERN.match?(id)
+          next if seen[id]
+
+          seen[id] = true
+          quantity_entry(table, row, roles, id)
+        end
+      end
+
+      def quantity_entry(table, row, roles, id)
+        entry = { "id" => id,
+                  "designation" => cell_text(row, roles["designation"]).to_s }
+        %w[definition symbol unit remarks].each do |role|
+          text = cell_text(row, roles[role])
+          entry[role] = text unless text.nil? || text.empty?
+        end
+        entry["source"] = source_of(table)
+        entry
+      end
+
+      def equivalent_terms_table?(table)
+        !language_header_row(table).nil?
+      end
+
+      def equivalent_entries(table)
+        languages = language_columns(language_header_row(table))
+        seen = {}
+        table["rows"].each_with_index.filter_map do |row, index|
+          entry = equivalent_entry(table, row, languages, index)
+          next if entry.nil? || seen[entry["id"]]
+
+          seen[entry["id"]] = true
+          entry
+        end
+      end
+
+      def equivalent_entry(table, row, languages, index)
+        designations = languages.each_with_object({}) do |(column, lang), hash|
+          text = cell_text(row, column)
+          hash[lang] = text unless text.nil? || text.empty?
+        end
+        # Rows with a single designation are letter dividers ("A", "B",
+        # ...), not equivalences.
+        return if designations.size < 2
+
+        { "id" => entry_id(row, index),
+          "designations" => designations,
+          "source" => source_of(table) }
+      end
+
+      def entry_id(row, index)
+        first = normalize_item(cell_text(row, 0))
+        ITEM_PATTERN.match?(first) ? first : (index + 1).to_s
+      end
+
+      def language_header_row(table)
+        table["header"].find do |row|
+          row.count { |cell| language?(cell["text"]) } >= MIN_LANGUAGE_COLUMNS
+        end
+      end
+
+      def language_columns(header_row)
+        columns = {}
+        position = 0
+        header_row.each do |cell|
+          columns[position] = cell["text"].downcase if language?(cell["text"])
+          position += cell["colspan"] || 1
+        end
+        columns
+      end
+
+      def language?(text)
+        LANGUAGES.include?(text.to_s.downcase)
+      end
+
+      # First unassigned column matching each role pattern wins; matched
+      # columns are blanked so later roles cannot claim them again.
+      def column_roles(table)
+        headers = column_header_texts(table)
+        roles = {}
+        COLUMN_ROLE_PATTERNS.each do |role, pattern|
+          column = headers.index { |text| text.match?(pattern) }
+          next unless column
+
+          headers[column] = ""
+          roles[role] = column
+        end
+        return roles if roles["item"] && roles["designation"]
+
+        positional_roles(table)
+      end
+
+      def positional_roles(table)
+        POSITIONAL_ROLES.first(column_count(table)).each_with_index.to_h
+      end
+
+      # Each column's header text joined across header rows, colspans
+      # repeated ("Quantity" + "Symbol" => "Quantity Symbol").
+      def column_header_texts(table)
+        grid = table["header"].map { |row| expand_row(row) }
+        (0...grid_width(grid)).map do |column|
+          grid.filter_map { |row| row[column] }.reject(&:empty?).join(" ")
+        end
+      end
+
+      def grid_width(grid)
+        grid.map(&:size).max || 0
+      end
+
+      def expand_row(row)
+        row.flat_map { |cell| [cell["text"]] * (cell["colspan"] || 1) }
+      end
+
+      def column_count(table)
+        (table["header"] + table["rows"])
+          .map { |row| row.sum { |cell| cell["colspan"] || 1 } }.max || 0
+      end
+
+      def cell_text(row, column)
+        return if column.nil?
+
+        cell_at(row, column)&.fetch("text")
+      end
+
+      def cell_at(row, column)
+        position = 0
+        row.each do |cell|
+          span = cell["colspan"] || 1
+          return cell if column >= position && column < position + span
+
+          position += span
+        end
+        nil
+      end
+
+      def item_number?(text)
+        ITEM_PATTERN.match?(normalize_item(text))
+      end
+
+      def normalize_item(text)
+        text.to_s.tr("\u2011", "-")
+      end
+
+      def source_of(table)
+        { "table" => table["id"], "section" => table["section"] }.compact
+      end
+    end
+  end
+end

data/lib/obp/access/version.rb

@@ -1,5 +1,5 @@
 module Obp
   class Access
-    VERSION = "0.1.4".freeze
+    VERSION = "0.1.5".freeze
   end
 end

data/lib/obp/access.rb

@@ -19,6 +19,8 @@ require_relative "access/parser"
 require_relative "access/converter"
 require_relative "access/imager"
 require_relative "access/renderer"
+require_relative "access/table_mapper"
+require_relative "access/table_term_extractor"
 require_relative "access/cli"
 
 require_relative "access/elements/base"
@@ -36,6 +38,10 @@ require_relative "access/elements/table_wrap"
 require_relative "access/elements/title"
 require_relative "access/elements/paragraph"
 require_relative "access/elements/non_normative_note"
+require_relative "access/elements/non_normative_example"
+require_relative "access/elements/disp_formula"
+require_relative "access/elements/footnotes"
+require_relative "access/elements/protected_content_note"
 require_relative "access/elements/copyright"
 require_relative "access/elements/bibliography"
 require_relative "access/elements/terminology"
@@ -91,6 +97,18 @@ module Obp
       Sts::NisoSts::Standard.from_xml(to_xml)
     end
 
+    # YAML serialization of every table in the OBP preview HTML
+    # (TableMapper's generic table model).
+    def to_tables
+      table_mapper.to_yaml
+    end
+
+    # YAML serialization of term entries extracted from the document's
+    # term-carrying tables (TableTermExtractor over the table model).
+    def to_terms
+      TableTermExtractor.new(tables: table_mapper.tables).to_yaml
+    end
+
     def to_xml_file
       path = File.join(tmpdir, "#{urn.safe}.xml")
       File.write(path, to_xml(pretty: true))
@@ -107,6 +125,12 @@ module Obp
       @parser ||= Parser.new(urn:, directory: tmpdir)
     end
 
+    # Shares Parser#html (memoized) with the STS conversion path, so
+    # reading tables does not re-POST to the OBP.
+    def table_mapper
+      @table_mapper ||= TableMapper.new(source: parser.html)
+    end
+
     def pretty_print(xml)
       Nokogiri::XML(xml, &:noblanks).to_xml
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: obp-access
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-15 00:00:00.000000000 Z
+date: 2026-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -93,13 +93,17 @@ files:
 - lib/obp/access/elements/bibliography.rb
 - lib/obp/access/elements/bibliography/bib_ref.rb
 - lib/obp/access/elements/copyright.rb
+- lib/obp/access/elements/disp_formula.rb
 - lib/obp/access/elements/figure.rb
 - lib/obp/access/elements/figure_group.rb
+- lib/obp/access/elements/footnotes.rb
 - lib/obp/access/elements/index.rb
 - lib/obp/access/elements/introduction.rb
 - lib/obp/access/elements/list.rb
+- lib/obp/access/elements/non_normative_example.rb
 - lib/obp/access/elements/non_normative_note.rb
 - lib/obp/access/elements/paragraph.rb
+- lib/obp/access/elements/protected_content_note.rb
 - lib/obp/access/elements/root.rb
 - lib/obp/access/elements/section.rb
 - lib/obp/access/elements/section_title.rb
@@ -123,6 +127,8 @@ files:
 - lib/obp/access/parser.rb
 - lib/obp/access/renderer.rb
 - lib/obp/access/retriever.rb
+- lib/obp/access/table_mapper.rb
+- lib/obp/access/table_term_extractor.rb
 - lib/obp/access/urn.rb
 - lib/obp/access/version.rb
 homepage: ''