glossarist 2.6.1 → 2.6.3

data/lib/glossarist/sts/term_extractor.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Sts
+    class TermExtractor
+      def initialize(xml_path)
+        raw = File.read(xml_path)
+        @standard = ::Sts::IsoSts::Standard.from_xml(raw)
+        @source_ref = extract_source_ref
+      end
+
+      def extract
+        term_secs = collect_term_secs
+        term_secs.filter_map do |ts|
+          next unless ts.term_entry
+
+          build_extracted_term(ts)
+        end
+      end
+
+      private
+
+      def collect_term_secs
+        secs = []
+        walk_sections(@standard.body, secs) if @standard.body
+        secs
+      end
+
+      def walk_sections(container, collected)
+        collect_term_secs_from(container, collected)
+        walk_child_secs(container, collected)
+      end
+
+      def collect_term_secs_from(container, collected)
+        secs = container.term_sec
+        secs&.each do |ts|
+          collected << ts
+          walk_sections(ts, collected) if ts.term_sec&.any?
+        end
+      end
+
+      def walk_child_secs(container, collected)
+        secs = container_child_secs(container)
+        secs&.each { |s| walk_sections(s, collected) }
+      end
+
+      def container_child_secs(container)
+        case container
+        when ::Sts::IsoSts::Body, ::Sts::IsoSts::Sec
+          container.sec
+        end
+      end
+
+      def build_extracted_term(term_sec)
+        entry = term_sec.term_entry
+        label_text = extract_label(term_sec)
+
+        lang_sets = entry.lang_set.filter_map do |ls|
+          build_lang_set(ls)
+        end
+
+        Sts::ExtractedTerm.new(
+          id: entry.id,
+          label: label_text,
+          source_ref: @source_ref,
+          lang_sets: lang_sets,
+        )
+      end
+
+      def extract_label(term_sec)
+        label = term_sec.label
+        return nil unless label
+
+        label.content&.join.to_s.strip
+      end
+
+      def build_lang_set(lang_set) # rubocop:disable Metrics/AbcSize
+        lang_code = Sts.convert_language_code(lang_set.lang.to_s)
+
+        Sts::ExtractedLangSet.new(
+          language_code: lang_code,
+          definition_text: extract_definition_text(lang_set),
+          note_texts: extract_note_texts(lang_set),
+          example_texts: extract_example_texts(lang_set),
+          source_texts: extract_source_texts(lang_set),
+          domain: extract_subject_field(lang_set),
+          designations: lang_set.tig.filter_map do |tig|
+            build_designation(tig)
+          end,
+        )
+      end
+
+      def extract_definition_text(lang_set)
+        definitions = lang_set.definition
+        return "" unless definitions&.any?
+
+        definitions.first.value&.join.to_s.strip
+      end
+
+      def extract_note_texts(lang_set)
+        lang_set.note.filter_map do |n|
+          text = n.value&.join.to_s.strip
+          text unless text.empty?
+        end
+      end
+
+      def extract_example_texts(lang_set)
+        lang_set.example.filter_map do |e|
+          text = e.value&.join.to_s.strip
+          text unless text.empty?
+        end
+      end
+
+      def extract_source_texts(lang_set)
+        lang_set.source.filter_map do |s|
+          text = s.value&.join.to_s.strip
+          text unless text.empty?
+        end
+      end
+
+      def extract_subject_field(lang_set)
+        fields = lang_set.subject_field
+        return nil unless fields&.any?
+
+        text = fields.first.value&.join.to_s.strip
+        text unless text.empty?
+      end
+
+      def build_designation(tig)
+        Sts::ExtractedDesignation.new(
+          term: resolve_term_text(tig),
+          type: map_term_type(tig),
+          normative_status: map_normative_status(tig),
+          part_of_speech: tig.pos&.value,
+          abbreviation_type: map_abbreviation_type(tig),
+        )
+      end
+
+      def resolve_term_text(tig)
+        tig.term&.value&.join.to_s.strip
+      end
+
+      def map_term_type(tig)
+        raw = tig.term_type&.value.to_s
+        mapped = TERM_TYPE_MAP[raw]
+        mapped.nil? || raw.empty? ? "expression" : mapped
+      end
+
+      def map_abbreviation_type(tig)
+        raw = tig.term_type&.value.to_s
+        return nil unless TERM_TYPE_MAP[raw] == "abbreviation"
+
+        raw == "acronym" ? "acronym" : "truncation"
+      end
+
+      def map_normative_status(tig)
+        NORMATIVE_STATUS_MAP[tig.normative_authorization&.value.to_s]
+      end
+
+      def extract_source_ref # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        front = @standard.front
+        return nil unless front
+
+        meta = front.iso_meta || front.std_meta
+        return nil unless meta
+
+        refs = meta.std_ref
+        return nil unless refs&.any?
+
+        best_ref = refs.find { |r| r.type == "dated" } ||
+          refs.find { |r| r.type == "undated" } ||
+          refs.first
+
+        extract_ref_text(best_ref)
+      end
+
+      def extract_ref_text(ref)
+        if ref.value.is_a?(String)
+          ref.value.to_s.strip
+        else
+          ref.content&.join.to_s.strip
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/sts/term_mapper.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Sts
+    class TermMapper
+      def map(extracted_term)
+        concept_id = extracted_term.label || extracted_term.id
+
+        mc = Glossarist::ManagedConcept.new(data: { id: concept_id })
+
+        extracted_term.lang_sets.each do |ls|
+          mc.add_localization(build_localized_concept(ls,
+                                                      extracted_term.source_ref))
+        end
+
+        mc
+      end
+
+      private
+
+      def build_localized_concept(lang_set, source_ref)
+        terms = lang_set.designations.map { |d| build_designation(d) }
+
+        Glossarist::LocalizedConcept.of_yaml(
+          "data" => {
+            "language_code" => lang_set.language_code,
+            "terms" => terms,
+            "definition" => build_definitions(lang_set.definition_text),
+            "notes" => build_detailed_definitions(lang_set.note_texts),
+            "examples" => build_detailed_definitions(lang_set.example_texts),
+            "sources" => build_sources(lang_set.source_texts, source_ref),
+            "domain" => lang_set.domain,
+            "entry_status" => "valid",
+          },
+        )
+      end
+
+      def build_definitions(text)
+        return [] unless text && !text.empty?
+
+        [{ "content" => text }]
+      end
+
+      def build_detailed_definitions(texts)
+        texts.filter_map do |text|
+          next if text.empty?
+
+          { "content" => text }
+        end
+      end
+
+      def build_designation(ext_desig)
+        case ext_desig.type
+        when "abbreviation"
+          build_abbreviation_designation(ext_desig)
+        when "symbol"
+          build_symbol_designation(ext_desig)
+        else
+          build_expression_designation(ext_desig)
+        end
+      end
+
+      def build_expression_designation(ext_desig)
+        hash = {
+          "type" => "expression",
+          "designation" => ext_desig.term,
+          "normative_status" => ext_desig.normative_status,
+        }.compact
+
+        if ext_desig.part_of_speech
+          hash["grammar_info"] =
+            [{ "part_of_speech" => ext_desig.part_of_speech }]
+        end
+
+        hash
+      end
+
+      def build_abbreviation_designation(ext_desig)
+        {
+          "type" => "abbreviation",
+          "designation" => ext_desig.term,
+          "normative_status" => ext_desig.normative_status,
+          "abbreviation_type" => ext_desig.abbreviation_type,
+        }.compact
+      end
+
+      def build_symbol_designation(ext_desig)
+        {
+          "type" => "symbol",
+          "designation" => ext_desig.term,
+          "normative_status" => ext_desig.normative_status,
+        }.compact
+      end
+
+      def build_sources(source_texts, source_ref)
+        sources = []
+        if source_ref
+          sources << {
+            "status" => "identical",
+            "type" => "authoritative",
+            "origin" => { "text" => source_ref },
+          }
+        end
+
+        source_texts.each do |text|
+          next if text.empty?
+
+          sources << {
+            "type" => "authoritative",
+            "origin" => { "text" => text },
+          }
+        end
+
+        sources
+      end
+    end
+  end
+end

data/lib/glossarist/sts.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "sts"
+
+module Glossarist
+  module Sts
+    autoload :ExtractedDesignation, "#{__dir__}/sts/extracted_designation"
+    autoload :ExtractedLangSet,     "#{__dir__}/sts/extracted_lang_set"
+    autoload :ExtractedTerm,        "#{__dir__}/sts/extracted_term"
+    autoload :ImportResult,         "#{__dir__}/sts/import_result"
+    autoload :Importer,             "#{__dir__}/sts/importer"
+    autoload :TermExtractor,        "#{__dir__}/sts/term_extractor"
+    autoload :TermMapper,           "#{__dir__}/sts/term_mapper"
+
+    ISO_639_1_TO_639_2 = {
+      "aa" => "aar", "ab" => "abk", "af" => "afr", "ak" => "aka",
+      "am" => "amh", "an" => "arg", "ar" => "ara", "as" => "asm",
+      "av" => "ava", "ay" => "aym", "az" => "aze", "ba" => "bak",
+      "be" => "bel", "bg" => "bul", "bh" => "bih", "bi" => "bis",
+      "bm" => "bam", "bn" => "ben", "bo" => "bod", "br" => "bre",
+      "bs" => "bos", "ca" => "cat", "ce" => "che", "ch" => "cha",
+      "co" => "cos", "cr" => "cre", "cs" => "ces", "cu" => "chu",
+      "cv" => "chv", "cy" => "cym", "da" => "dan", "de" => "deu",
+      "dv" => "div", "dz" => "dzo", "ee" => "ewe", "el" => "ell",
+      "en" => "eng", "eo" => "epo", "es" => "spa", "et" => "est",
+      "eu" => "eus", "fa" => "fas", "ff" => "ful", "fi" => "fin",
+      "fj" => "fij", "fo" => "fao", "fr" => "fra", "fy" => "fry",
+      "ga" => "gle", "gd" => "gla", "gl" => "glg", "gn" => "grn",
+      "gu" => "guj", "gv" => "glv", "ha" => "hau", "he" => "heb",
+      "hi" => "hin", "ho" => "hmo", "hr" => "hrv", "ht" => "hat",
+      "hu" => "hun", "hy" => "hye", "hz" => "her", "ia" => "ina",
+      "id" => "ind", "ie" => "ile", "ig" => "ibo", "ii" => "iii",
+      "ik" => "ipk", "io" => "ido", "is" => "isl", "it" => "ita",
+      "iu" => "iku", "ja" => "jpn", "jv" => "jav", "ka" => "kat",
+      "kg" => "kon", "ki" => "kik", "kj" => "kua", "kk" => "kaz",
+      "kl" => "kal", "km" => "khm", "kn" => "kan", "ko" => "kor",
+      "kr" => "kau", "ks" => "kas", "ku" => "kur", "kv" => "kom",
+      "kw" => "cor", "ky" => "kir", "la" => "lat", "lb" => "ltz",
+      "lg" => "lug", "li" => "lim", "ln" => "lin", "lo" => "lao",
+      "lt" => "lit", "lu" => "lub", "lv" => "lav", "mg" => "mlg",
+      "mh" => "mah", "mi" => "mri", "mk" => "mkd", "ml" => "mal",
+      "mn" => "mon", "mr" => "mar", "ms" => "msa", "mt" => "mlt",
+      "my" => "mya", "na" => "nau", "nb" => "nob", "nd" => "nde",
+      "ne" => "nep", "ng" => "ndo", "nl" => "nld", "nn" => "nno",
+      "no" => "nor", "nr" => "nbl", "nv" => "nav", "ny" => "nya",
+      "oc" => "oci", "oj" => "oji", "om" => "orm", "or" => "ori",
+      "os" => "oss", "pa" => "pan", "pi" => "pli", "pl" => "pol",
+      "ps" => "pus", "pt" => "por", "qu" => "que", "rm" => "roh",
+      "rn" => "run", "ro" => "ron", "ru" => "rus", "rw" => "kin",
+      "sa" => "san", "sc" => "srd", "sd" => "snd", "se" => "sme",
+      "sg" => "sag", "si" => "sin", "sk" => "slk", "sl" => "slv",
+      "sm" => "smo", "sn" => "sna", "so" => "som", "sq" => "sqi",
+      "sr" => "srp", "ss" => "ssw", "st" => "sot", "su" => "sun",
+      "sv" => "swe", "sw" => "swa", "ta" => "tam", "te" => "tel",
+      "tg" => "tgk", "th" => "tha", "ti" => "tir", "tk" => "tuk",
+      "tl" => "tgl", "tn" => "tsn", "to" => "ton", "tr" => "tur",
+      "ts" => "tso", "tt" => "tat", "tw" => "twi", "ty" => "tah",
+      "ug" => "uig", "uk" => "ukr", "ur" => "urd", "uz" => "uzb",
+      "ve" => "ven", "vi" => "vie", "vo" => "vol", "wa" => "wln",
+      "wo" => "wol", "xh" => "xho", "yi" => "yid", "yo" => "yor",
+      "za" => "zha", "zh" => "zho", "zu" => "zul"
+    }.freeze
+
+    TERM_TYPE_MAP = {
+      "acronym" => "abbreviation",
+      "abbreviation" => "abbreviation",
+      "fullForm" => "expression",
+      "symbol" => "symbol",
+      "variant" => "expression",
+      "equation" => "expression",
+      "formula" => "expression",
+    }.freeze
+
+    NORMATIVE_STATUS_MAP = {
+      "preferredTerm" => "preferred",
+      "admittedTerm" => "admitted",
+      "deprecatedTerm" => "deprecated",
+    }.freeze
+
+    def self.convert_language_code(code)
+      return code if code.nil?
+      return code if code.length == 3
+
+      ISO_639_1_TO_639_2[code] || code
+    end
+  end
+end

data/lib/glossarist/transforms/concept_to_skos_transform.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../rdf"
-
 module Glossarist
   module Transforms
     class ConceptToSkosTransform

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "2.6.1"
+  VERSION = "2.6.3"
 end

data/lib/glossarist.rb

@@ -7,14 +7,13 @@ require "psych"
 require "thor"
 require "lutaml/model"
 
-require_relative "glossarist/glossary_definition"
-
 module Glossarist
   autoload :Asset,                    "glossarist/asset"
   autoload :Citation,                 "glossarist/citation"
   autoload :CLI,                      "glossarist/cli"
   autoload :CollectionConfig,         "glossarist/collection_config"
   autoload :Collection,               "glossarist/collection"
+  autoload :Collections,              "glossarist/collections"
   autoload :Concept,                  "glossarist/concept"
   autoload :ConceptData,              "glossarist/concept_data"
   autoload :ConceptReference,         "glossarist/concept_reference"
@@ -35,10 +34,10 @@ module Glossarist
   autoload :DetailedDefinition,       "glossarist/detailed_definition"
   autoload :Designation,              "glossarist/designation"
   autoload :Error,                    "glossarist/error"
-  autoload :GcrPackage,              "glossarist/gcr_package"
-  autoload :GcrMetadata,             "glossarist/gcr_metadata"
-  autoload :GcrStatistics,           "glossarist/gcr_statistics"
-  autoload :GcrValidator,            "glossarist/gcr_validator"
+  autoload :GcrPackage,               "glossarist/gcr_package"
+  autoload :GcrMetadata,              "glossarist/gcr_metadata"
+  autoload :GcrStatistics,            "glossarist/gcr_statistics"
+  autoload :GcrValidator,             "glossarist/gcr_validator"
   autoload :InvalidTypeError, "glossarist/error/invalid_type_error"
   autoload :InvalidLanguageCodeError,
            "glossarist/error/invalid_language_code_error"
@@ -52,16 +51,20 @@ module Glossarist
   autoload :ManagedConceptData,       "glossarist/managed_concept_data"
   autoload :NonVerbRep,               "glossarist/non_verb_rep"
   autoload :RelatedConcept,           "glossarist/related_concept"
+  autoload :Rdf,                      "glossarist/rdf"
+  autoload :Sts,                      "glossarist/sts"
+  autoload :Transforms,               "glossarist/transforms"
   autoload :SchemaMigration,          "glossarist/schema_migration"
   autoload :UrnResolver,              "glossarist/urn_resolver"
   autoload :Utilities,                "glossarist/utilities"
-  autoload :RegisterData, "glossarist/register_data"
+  autoload :RegisterData,             "glossarist/register_data"
   autoload :ValidationResult,         "glossarist/validation_result"
   autoload :V1,                       "glossarist/v1"
 end
 
 require_relative "glossarist/version"
 require_relative "glossarist/collections"
+require_relative "glossarist/glossary_definition"
 
 module Glossarist
   LANG_CODES = %w[eng ara deu fra spa ita jpn kor pol por srp swe zho rus fin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.6.1
+  version: 2.6.3
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-06 00:00:00.000000000 Z
+date: 2026-05-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -122,6 +122,7 @@ files:
 - lib/glossarist/citation.rb
 - lib/glossarist/cli.rb
 - lib/glossarist/cli/export_command.rb
+- lib/glossarist/cli/import_command.rb
 - lib/glossarist/cli/package_command.rb
 - lib/glossarist/cli/upgrade_command.rb
 - lib/glossarist/cli/validate_command.rb
@@ -192,6 +193,14 @@ files:
 - lib/glossarist/resolution_adapter/remote.rb
 - lib/glossarist/resolution_adapter/route.rb
 - lib/glossarist/schema_migration.rb
+- lib/glossarist/sts.rb
+- lib/glossarist/sts/extracted_designation.rb
+- lib/glossarist/sts/extracted_lang_set.rb
+- lib/glossarist/sts/extracted_term.rb
+- lib/glossarist/sts/import_result.rb
+- lib/glossarist/sts/importer.rb
+- lib/glossarist/sts/term_extractor.rb
+- lib/glossarist/sts/term_mapper.rb
 - lib/glossarist/transforms.rb
 - lib/glossarist/transforms/concept_to_skos_transform.rb
 - lib/glossarist/transforms/concept_to_tbx_transform.rb