iev 0.4.4 → 0.4.6

data/lib/iev/source_parser.rb

@@ -12,6 +12,7 @@ module Iev
   #   SourceParser.new(cell_data_string).parsed_sources
   class SourceParser
     include Utilities
+
     using DataConversions
 
     # When false, obtain_source_link skips Relaton network calls.
@@ -79,10 +80,11 @@ module Iev
       relationship = extract_source_relationship(raw_ref)
       clean_ref = normalize_ref_string(raw_ref)
       source_ref = extract_source_ref(clean_ref)
+      ref_source, ref_id = split_ref(source_ref)
       clause = extract_source_clause(clean_ref)
 
       origin = Glossarist::Citation.new(
-        ref: source_ref,
+        ref: Glossarist::Citation::Ref.new(source: ref_source, id: ref_id),
         locality: build_locality(clause),
         link: obtain_source_link(source_ref),
         original: Iev::Converter.mathml_to_asciimath(
@@ -111,13 +113,13 @@ module Iev
       # IEC 62313:2009, 3.6, modifié
 
       str
-        .gsub(/CEI/, "IEC")
-        .gsub(/Guide IEC/, "IEC Guide")
+        .gsub("CEI", "IEC")
+        .gsub("Guide IEC", "IEC Guide")
         .gsub(%r{Guide ISO/IEC}, "ISO/IEC Guide")
-        .gsub(/VEI/, "IEV")
-        .gsub(/UIT/, "ITU")
-        .gsub(/IUT-R/, "ITU-R")
-        .gsub(/UTI-R/, "ITU-R")
+        .gsub("VEI", "IEV")
+        .gsub("UIT", "ITU")
+        .gsub("IUT-R", "ITU-R")
+        .gsub("UTI-R", "ITU-R")
         .gsub(/Recomm[ea]ndation ITU-T/, "ITU-T Recommendation")
         .gsub(/ITU-T (\w.\d{3}):(\d{4})/, 'ITU-T Recommendation \1 (\2)')
         .gsub(/ITU-R Rec. (\d+)/, 'ITU-R Recommendation \1')
@@ -289,17 +291,15 @@ module Iev
       ].map do |regex, _rule|
         # TODO: Rubocop complains about unused rule -- need to make sure
         # that no one forgot about something.
-        res = []
         # puts "str is '#{str}'"
         # puts "regex is '#{regex.to_s}'"
-        str.scan(regex).each do |result|
+        str.scan(regex).map do |result|
           # puts "result is #{result.first}"
-          res << {
+          {
             index: $LAST_MATCH_INFO.offset(0)[0],
             clause: result.first.strip,
           }
         end
-        res
         # sort by index and also the length of match
       end.flatten.sort_by { |hash| [hash[:index], -hash[:clause].length] }
 
@@ -351,6 +351,52 @@ module Iev
       )
     end
 
+    # Splits a normalized bibliographic reference into [source, id] for
+    # structured Citation::Ref construction.  The full string is still
+    # passed to Relaton for link resolution — only the Citation::Ref
+    # model receives the split form.
+    #
+    #   "IEC 62302:2007"           → ["IEC",          "62302:2007"]
+    #   "ISO/IEC 2382:2015"        → ["ISO/IEC",      "2382:2015"]
+    #   "ISO/TS 14812:2022"        → ["ISO/TS",       "14812:2022"]
+    #   "IEC CISPR 16-1:2003"      → ["IEC CISPR",    "16-1:2003"]
+    #   "ITU-T Recommendation F.791 (11/2015)" → ["ITU-T Recommendation", "F.791 (11/2015)"]
+    #   "IEV"                      → ["IEV",          nil]
+    def split_ref(full_ref)
+      case full_ref
+      when /\A(ISO\/IEC\/IEEE)\s+(.+)/
+        [$1, $2]
+      when /\A(ISO\/IEC\s+Guide)\s+(.+)/
+        [$1, $2]
+      when /\A(ISO\/IEC)\s+(.+)/
+        [$1, $2]
+      when /\A(IEC\/IEEE)\s+(.+)/
+        [$1, $2]
+      when %r{\A((?:ISO|IEC)/(?:PAS|TR|TS))\s+(.+)}
+        [$1, $2]
+      when /\A(IEC\s+CISPR)\s+(.+)/
+        [$1, $2]
+      when /\A(ITU-T\s+Recommendation)\s+(.+)/
+        [$1, $2]
+      when /\A(ITU-R\s+Recommendation)\s+(.+)/
+        [$1, $2]
+      when /\A(ITU-R)\s+(.+)/
+        [$1, $2]
+      when /\A((?:ISO|IEC)\s+Guide)\s+(.+)/
+        [$1, $2]
+      when /\A(ISO|IEC|IAEA)\s+(.+)/
+        [$1, $2]
+      when /\AIEV\z/
+        ["IEV", nil]
+      when /\A(JCGM)\s+(VIM)\z/
+        [$1, $2]
+      when /\ABBIPM/
+        ["BIPM", "SI Brochure"]
+      else
+        [full_ref, nil]
+      end
+    end
+
     # Uses Relaton to obtain link for given source ref.
     def obtain_source_link(ref)
       return nil unless self.class.relaton_enabled

data/lib/iev/subject_area.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Iev
+  # Immutable value object representing an IEV subject area (e.g. "102").
+  #
+  # A subject area is the aggregate root for its sections.
+  # Navigation: area → sections (direct), section → area (via registry).
+  class SubjectArea
+    attr_reader :code, :title, :sections
+
+    # @param code [#to_s] area code, e.g. "103"
+    # @param title [#to_s] area title, e.g. "Mathematics - Functions"
+    # @param sections [Array<Iev::Section>] child sections
+    def initialize(code:, title:, sections: [])
+      @code = code.to_s
+      @title = title.to_s
+      @sections = sections
+      freeze
+    end
+
+    def uri
+      "area-#{code}"
+    end
+
+    def section(section_code)
+      sections.find { |s| s.code == section_code.to_s }
+    end
+
+    def to_h
+      {
+        "code" => code,
+        "title" => title,
+        "sections" => sections.map(&:to_h),
+      }
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && code == other.code
+    end
+    alias_method :eql?, :==
+
+    def hash
+      code.hash
+    end
+  end
+end

data/lib/iev/subject_area_concepts.rb

@@ -4,14 +4,21 @@ module Iev
   # Creates ManagedConcept entries for the IEV subject area hierarchy.
   #
   # The hierarchy has two levels:
-  #   - Area (e.g., "102" = "Mathematics - General concepts and linear algebra")
+  #   - Area (e.g., "102" = "Mathematics - General concepts")
   #   - Section (e.g., "102-01" = "Sets and operations")
   #
-  # Linking:
-  #   - Each IEV concept's ConceptData#domain references its section URI
-  #   - Each IEV concept's ManagedConceptData#domains includes area and section codes
-  #   - Each section concept has a "broader" relation to its parent area
-  #   - Each area concept has "narrower" relations to its sections
+  # Linking (all at ManagedConcept#related level):
+  #   - Each area has "narrower" relations to its sections
+  #   - Each section has "broader" relation to parent area
+  #   - Each section gets "narrower" to child concepts (added by Exporter)
+  #   - Each regular IEV concept gets "broader" to its section
+  #     (added by Exporter)
+  #
+  # Classification (separate from hierarchy):
+  #   - Each concept's ManagedConceptData#domains includes domain and
+  #     section ConceptReferences (per ConceptReferenceType)
+  #   - Each section concept's ConceptData#domain references parent area
+  #     title text (a LocalizedString, not a URI)
   module SubjectAreaConcepts
     class << self
       # Build all area and section concepts and add them to the collection.
@@ -23,7 +30,7 @@ module Iev
           area_mc = build_area_concept(area)
           collection.store(area_mc)
 
-          (area["sections"] || []).each do |section|
+          area.sections.each do |section|
             section_mc = build_section_concept(section, area)
             collection.store(section_mc)
           end
@@ -33,41 +40,52 @@ module Iev
       private
 
       def build_area_concept(area)
-        id = SubjectAreas.area_uri(area["code"])
+        id = area.uri
 
         mc = Glossarist::ManagedConcept.new(
           data: Glossarist::ManagedConceptData.new(
             id: id,
-            domains: [Glossarist::ConceptReference.domain(id)],
+            domains: [domain_ref(id)],
+            tags: [area.title],
           ),
         )
+        mc.uuid = id
+        mc.schema_version = "3"
 
-        mc.add_localization(build_localization(id, area["title"], "eng"))
-
-        narrower = (area["sections"] || []).map { |s| build_narrower_ref(s["code"]) }
-        mc.related = narrower unless narrower.empty?
+        mc.add_localization(
+          build_localization(id, build_concept_data(id, area.title, "eng")),
+        )
+        mc.related = area.sections.map { |s| narrower_relation(s.uri) }
+        mc.related = nil if mc.related.empty?
 
         mc
       end
 
       def build_section_concept(section, area)
-        id = SubjectAreas.section_uri(section["code"])
+        id = section.uri
 
         mc = Glossarist::ManagedConcept.new(
           data: Glossarist::ManagedConceptData.new(
             id: id,
             domains: [
-              Glossarist::ConceptReference.domain(SubjectAreas.area_uri(area["code"])),
-              Glossarist::ConceptReference.domain(id),
+              domain_ref(area.uri),
+              section_ref(id),
             ],
+            tags: [area.title, section.title],
           ),
         )
+        mc.uuid = id
+        mc.schema_version = "3"
+
+        cd = build_concept_data(id, section.title, "eng")
+        # ConceptData#domain is a LocalizedString — use the area title text,
+        # not a URI. The structural relationship is expressed via domains[]
+        # and related[].
+        cd.domain = area.title
 
-        cd = build_concept_data(id, section["title"], "eng")
-        cd.domain = SubjectAreas.area_uri(area["code"])
-        cd.related = [build_broader_ref(area["code"])]
+        mc.add_localization(build_localization(id, cd))
+        mc.related = [broader_relation(area.uri)]
 
-        mc.add_localization(build_localization_from_data(id, cd))
         mc
       end
 
@@ -85,37 +103,44 @@ module Iev
         )
       end
 
-      def build_localization(id, title, lang_code)
-        cd = build_concept_data(id, title, lang_code)
-
+      def build_localization(id, concept_data)
         l10n = Glossarist::LocalizedConcept.new
-        l10n.data = cd
+        l10n.data = concept_data
         l10n.id = id
         l10n.entry_status = "valid"
         l10n.data.review_decision_event = "published"
         l10n
       end
 
-      def build_localization_from_data(id, concept_data)
-        l10n = Glossarist::LocalizedConcept.new
-        l10n.data = concept_data
-        l10n.id = id
-        l10n.entry_status = "valid"
-        l10n.data.review_decision_event = "published"
-        l10n
+      # --- ConceptReference factory methods ---
+
+      def domain_ref(concept_id)
+        ref = Glossarist::ConceptReference.domain(concept_id)
+        ref.source = IEV_SOURCE
+        ref
+      end
+
+      def section_ref(concept_id)
+        ref = Glossarist::ConceptReference.section(concept_id)
+        ref.source = IEV_SOURCE
+        ref
       end
 
-      def build_broader_ref(area_code)
+      # --- RelatedConcept factory methods ---
+
+      def broader_relation(target_uri)
         Glossarist::RelatedConcept.new(
           type: "broader",
-          content: SubjectAreas.area_uri(area_code),
+          content: target_uri,
+          ref: Glossarist::ConceptRef.new(source: "IEV", id: target_uri),
         )
       end
 
-      def build_narrower_ref(section_code)
+      def narrower_relation(target_uri)
         Glossarist::RelatedConcept.new(
           type: "narrower",
-          content: SubjectAreas.section_uri(section_code),
+          content: target_uri,
+          ref: Glossarist::ConceptRef.new(source: "IEV", id: target_uri),
         )
       end
     end

data/lib/iev/subject_areas.rb

@@ -3,7 +3,6 @@
 require "yaml"
 require "nokogiri"
 require "fileutils"
-require "iev/config"
 
 module Iev
   module SubjectAreas
@@ -39,49 +38,59 @@ module Iev
         "section-#{code}"
       end
 
-      # --- Query API (reads from bundled data) ---
+      # --- Query API (returns typed objects) ---
 
       # Return all subject areas with their sections.
-      # @return [Array<Hash>] each hash has "code", "title", "sections"
+      # @return [Array<SubjectArea>]
       def all
-        data["areas"]
+        @all ||= raw_data["areas"].map { |h| build_area(h) }
       end
 
-      # Find a single subject area by its numeric code.
+      # Find a single subject area by its numeric code. O(1) indexed.
       # @param code [String, Integer] e.g. "102" or 102
-      # @return [Hash, nil]
+      # @return [SubjectArea, nil]
       def find_area(code)
-        all.find { |a| a["code"] == code.to_s }
+        area_index[code.to_s]
       end
 
       # Return all sections for a given area code.
       # @param code [String, Integer] area code, e.g. "102"
-      # @return [Array<Hash>] each hash has "code", "title"
+      # @return [Array<Section>]
       def sections_for(code)
-        area = find_area(code)
-        area ? area["sections"] : []
+        find_area(code)&.sections || []
       end
 
-      # Find a single section by its section code.
+      # Find a single section by its section code. O(1) indexed.
       # @param section_code [String] e.g. "102-01"
-      # @return [Hash, nil]
+      # @return [Section, nil]
       def find_section(section_code)
-        sc = section_code.to_s
-        all.each do |area|
-          found = area["sections"]&.find { |s| s["code"] == sc }
-          return found if found
-        end
-        nil
+        section_index[section_code.to_s]
       end
 
       # Return the parent area for a given section code.
       # @param section_code [String] e.g. "102-01"
-      # @return [Hash, nil]
+      # @return [SubjectArea, nil]
       def area_for_section(section_code)
-        sc = section_code.to_s
-        all.find do |area|
-          area["sections"]&.any? { |s| s["code"] == sc }
-        end
+        sec = find_section(section_code)
+        sec ? find_area(sec.area_code) : nil
+      end
+
+      # --- Navigation from IEV reference ---
+
+      # Find the subject area for any IEV reference.
+      # @param ievref [String] e.g. "103-01-02"
+      # @return [SubjectArea, nil]
+      def area_for(ievref)
+        code = IevCode.new(ievref)
+        find_area(code.area_code)
+      end
+
+      # Find the section for any IEV reference.
+      # @param ievref [String] e.g. "103-01-02"
+      # @return [Section, nil]
+      def section_for(ievref)
+        code = IevCode.new(ievref)
+        code.section_code ? find_section(code.section_code) : nil
       end
 
       # --- Fetching (network, writes to bundled data file) ---
@@ -95,7 +104,7 @@ module Iev
         puts "Found #{fresh_areas.length} areas (#{areas.length} cached)" if $stdout.tty?
 
         # Merge: keep existing sections, add new areas
-        existing = areas.each_with_object({}) { |a, h| h[a["code"]] = a }
+        existing = areas.to_h { |a| [a["code"], a] }
         fresh_areas.each do |fa|
           existing[fa["code"]] ||= fa
         end
@@ -109,13 +118,13 @@ module Iev
             area["fetched"] = true
           rescue FetchError
             area["sections"] ||= []
-            warn "IEV: Skipping area #{area["code"]} due to WAF"
+            warn "IEV: Skipping area #{area['code']} due to WAF"
           end
 
-          puts "[#{i + 1}/#{areas.length}] #{area["code"]}: #{area["title"]} — #{area["sections"].length} sections" if $stdout.tty?
+          puts "[#{i + 1}/#{areas.length}] #{area['code']}: #{area['title']} — #{area['sections'].length} sections" if $stdout.tty?
 
           # Save progress every 10 areas so partial results survive WAF failures
-          if (i + 1) % 10 == 0
+          if ((i + 1) % 10).zero?
             write_cache("subject_areas.yaml", { "areas" => areas })
           end
 
@@ -164,19 +173,51 @@ module Iev
         sections.uniq { |s| s["code"] }
       end
 
+      # Clear cached typed objects (useful after fetch updates raw data).
+      def reload!
+        @typed_areas = nil
+        @area_index = nil
+        @section_index = nil
+        @raw_data = nil
+      end
+
       private
 
-      def data
-        @data ||= begin
+      def build_area(hash)
+        area_code = hash["code"]
+        sections = (hash["sections"] || []).map do |s|
+          Section.new(code: s["code"], title: s["title"], area_code: area_code)
+        end
+
+        SubjectArea.new(
+          code: area_code,
+          title: hash["title"],
+          sections: sections,
+        )
+      end
+
+      def raw_data
+        @raw_data ||= begin
           path = File.exist?(DATA_FILE) ? DATA_FILE : nil
           if path
-            YAML.safe_load(File.read(path, encoding: "utf-8")) || { "areas" => [] }
+            YAML.safe_load(File.read(path,
+                                     encoding: "utf-8")) || { "areas" => [] }
           else
             { "areas" => [] }
           end
         end
       end
 
+      def area_index
+        @area_index ||= all.to_h { |a| [a.code, a] }
+      end
+
+      def section_index
+        @section_index ||= all.each_with_object({}) do |area, h|
+          area.sections.each { |s| h[s.code] = s }
+        end
+      end
+
       def complete?(data)
         areas = data["areas"]
         return false unless areas&.length&.>= 99
@@ -192,10 +233,8 @@ module Iev
       end
 
       def fetch_page_with_retry(url, retries: MAX_RETRIES)
-        require "iev/scraper/browser"
-
         retries.times do |attempt|
-          html = ScraperBrowser.fetch(url)
+          html = Scraper::Browser.fetch(url)
           raise FetchError, "Failed to fetch #{url}" unless html
 
           unless captcha_page?(html)

data/lib/iev/supersession_parser.rb

@@ -54,10 +54,9 @@ module Iev
     def relation_from_match(match_data)
       Glossarist::RelatedConcept.new(
         type: "supersedes",
-        ref: Glossarist::Citation.new(
+        ref: Glossarist::ConceptRef.new(
           source: "IEV",
           id: match_data[:ref],
-          version: match_data[:version],
         ),
       )
     end

data/lib/iev/term_attrs_parser.rb

@@ -68,7 +68,7 @@ module Iev
       extract_usage_info(curr_str)
       extract_prefix(curr_str)
 
-      return unless /\p{Word}/.match?(curr_str)
+      nil unless /\p{Word}/.match?(curr_str)
 
       # Term attributes could not be parsed completely
     end

data/lib/iev/term_builder.rb

@@ -7,6 +7,7 @@ module Iev
   class TermBuilder
     include Cli::Ui
     include Utilities
+
     using DataConversions
 
     def initialize(data)
@@ -102,18 +103,22 @@ module Iev
     end
 
     # Derives the domain (subject area section) from the IEVREF identifier.
-    # IEVREF format: "AAA-BB-CC" where AAA = area, AAA-BB = section.
-    # Returns a URI reference to the section concept (e.g. "section-103-01").
+    #
+    # Returns the section or area title text as a localized string.
+    # Per the concept model, ConceptData#domain is a LocalizedString
+    # (the domain name), not a URI. Structural membership is expressed
+    # via ManagedConceptData#domains[] with ConceptReference objects.
     def extract_domain
       return nil unless term_id
 
-      section_code = term_id.split("-")[0..1].join("-")
-      section = Iev.find_section(section_code)
-      return SubjectAreas.section_uri(section_code) if section
+      code = IevCode.new(term_id)
+      section = Iev.find_section(code.section_code) if code.section_code
+      return section.title if section
 
-      area_code = term_id.split("-")[0]
-      SubjectAreas.area_uri(area_code)
-    rescue StandardError
+      area = Iev.find_subject_area(code.area_code)
+      area&.title
+    rescue StandardError => e
+      warn "IEV: extract_domain failed for #{term_id}: #{e.message}"
       nil
     end
 
@@ -142,7 +147,7 @@ module Iev
             Note \d+\sto\sentry: |
             Note\s*\d+\sto\sthe\sentry: |
             Note\sto\sentry\s*\d+: |
-            Note\s*\d+?\sà\sl['']article: |
+            Note\s*\d+?\sà\sl'article: |
             <NOTE/?>?\s*\d?\s+[–-]\s* |
             NOTE(?:\s+-)?\s* |
             Note\s+\d+\s[–-]\s* |

data/lib/iev/utilities.rb

@@ -5,6 +5,10 @@ module Iev
     IMAGE_PATH_PREFIX = "image::/assets/images/parts"
     IEV_CODE_RE = /\A(IEV)?\s*(\d{2,3}-\d{2,3}-\d{2,3})\z/
 
+    # Pattern matching an anchor's inner text that is just an IEV code
+    # (not a meaningful term designation).
+    IEV_CODE_TEXT_RE = /\A\s*IEV\s*\d{2,3}-\d{2,3}-\d{2,3}\s*\z/
+
     # SIMG/Figure patterns — custom IEV XML, pre-processed before Nokogiri.
     # Uses [^>] and [^<] instead of . to avoid polynomial backtracking.
     SIMG_PATH_REGEX = /<simg [^>]*\/\$file\/([\d\-\w.]+)>/
@@ -134,12 +138,36 @@ module Iev
 
       if href.match?(IEV_CODE_RE)
         iev_code = href.sub(/\AIEV\s*/, "")
-        "{{#{inner}, urn:iec:std:iec:60050-#{iev_code}}}"
+        display = render_term_for(inner, iev_code)
+        "{{urn:iec:std:iec:60050-#{iev_code}, #{display}}}"
       elsif !href.empty?
         "#{href}[#{inner}]"
       else
         inner
       end
     end
+
+    # Resolve the display (render) text for an IEV cross-reference.
+    #
+    # When the anchor text is already a meaningful term (e.g. "adjective"),
+    # use it directly. When it's just a bare IEV code (e.g. "IEV 102-01-10"),
+    # try to look up the actual term designation via DataSource.
+    #
+    # @param inner_text [String] the anchor element's inner text
+    # @param iev_code [String] the extracted numeric IEV code (e.g. "102-01-10")
+    # @return [String] the term designation to use as render text
+    def render_term_for(inner_text, iev_code)
+      stripped = inner_text.strip
+      return stripped unless iev_code_only?(stripped)
+
+      Iev.get(iev_code, "en") || stripped
+    rescue StandardError
+      stripped
+    end
+
+    # True when the anchor text is just a raw IEV code, not a term designation.
+    def iev_code_only?(text)
+      text.match?(IEV_CODE_TEXT_RE)
+    end
   end
 end

data/lib/iev/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Iev
-  VERSION = "0.4.4"
+  VERSION = "0.4.6"
 end