isq 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44823d1e9f21796b3c62de48a24105fa0b5c906e6990ddd75a1143052363f11b
-  data.tar.gz: 2671bb4938158df5c272b790000da4c53e134c9a54d4bd6b553aa57f3e4d6ba4
+  metadata.gz: a0dc68df904baa524f066fa29fa52882f1ac1f1b9be557aa1ef3118affeda590
+  data.tar.gz: efdf842000e1a325713c1558a0b6e37dede13c5da796bcb26d28425282f4a57a
 SHA512:
-  metadata.gz: 29c22ea5b84c9bce2c796164001e708a7fee5967acc0954c9042dbebda36e8f91d4a02d2badad8d6955bd5f66e9ace56600dec1b355d294ed17e34623a529e1c
-  data.tar.gz: 5812745292b217fc5ea1acb9b8c802bddfc1f315ea2a748714d5064cbc3698df0267a7a1f18bad52e8999cc11fee38233778f7741f5e3fdc8c9d8b5ad138b81e
+  metadata.gz: 18ba08c24d8d9205810c2e113fae80340f138f3e4683a9a6e63354c68719fb451ccb2f0bd194bf4f221c3bc8865778fa5c17c2b6b8c5e6b530311101a15bb717
+  data.tar.gz: 38cc4b9c2cb152d1f1bad3911d8c3d9a757e340d74863233949d5270f0dc90db7860bf31c715d456fbf3da836aa1608b967233467e05b9db72edfea924bf6905

data/exe/isq

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "isq/cli"
+
+Isq::Cli.start(ARGV)

data/lib/isq/cli.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "isq"
+require "thor"
+
+module Isq
+  class Cli < Thor
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "export", "Generate TTL and JSON-LD exports from YAML source data"
+    method_option :dataset_dir,
+                  aliases: "-d",
+                  type: :string,
+                  desc: "YAML dataset directory"
+    method_option :export_dir,
+                  aliases: "-o",
+                  type: :string,
+                  desc: "Output directory"
+    method_option :format,
+                  aliases: "-f",
+                  type: :string,
+                  enum: %w[ttl jsonld both],
+                  default: "both",
+                  desc: "Output format: ttl, jsonld, or both"
+    def export
+      dataset_dir = options[:dataset_dir] || ENV.fetch("ISQ_DATASET_DIR", default_dataset_dir)
+      export_dir = options[:export_dir] || ENV.fetch("ISQ_EXPORT_DIR", default_export_dir)
+
+      dataset = Isq::Dataset.load(dataset_dir)
+      Isq::Export.new(dataset: dataset, export_dir: export_dir,
+                      format: options[:format].to_sym).run
+
+      say "Generated exports in #{export_dir}:"
+      say "  #{dataset.total_count} entries across #{dataset.part_keys.length} parts"
+    end
+
+    private
+
+    def default_dataset_dir
+      File.expand_path("../../../iso-iec-80000/sources/dataset", __dir__)
+    end
+
+    def default_export_dir
+      File.expand_path("../../../browser/public/exports", __dir__)
+    end
+  end
+end

data/lib/isq/dataset.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Isq
+  class Dataset
+    attr_reader :entries, :math_entries, :part_keys
+
+    def initialize(entries: [], math_entries: [])
+      @entries = Array(entries)
+      @math_entries = Array(math_entries)
+      index!
+    end
+
+    def self.load(dataset_dir)
+      entries = load_yaml_file(dataset_dir, "quantities.yaml") { |yaml| Isq::Quantity.from_yaml(yaml) }
+      math_entries = load_yaml_file(dataset_dir, "math.yaml") { |yaml| Isq::MathConcept.from_yaml(yaml) }
+
+      new(entries: entries, math_entries: math_entries)
+    end
+
+    def entries_for_part(part_key)
+      by_part[part_key] || []
+    end
+
+    def unique_units_for_part(part_key)
+      part_entries = entries_for_part(part_key)
+      seen = Set.new
+      part_entries.each_with_object([]) do |entry, acc|
+        next unless entry.is_a?(Isq::Quantity)
+        next unless entry.has_unit
+
+        Array(entry.has_unit).each do |unit_ref|
+          next if seen.include?(unit_ref)
+
+          seen << unit_ref
+          acc << unit_ref
+        end
+      end
+    end
+
+    def total_count
+      @entries.length + @math_entries.length
+    end
+
+    def counts_by_part
+      by_part.transform_values(&:length)
+    end
+
+    private
+
+    def by_part
+      @by_part
+    end
+
+    def index!
+      all_entries = @entries + @math_entries
+      @by_part = all_entries.group_by(&:part)
+      @part_keys = @by_part.keys.sort
+    end
+
+    def self.load_yaml_file(dir, filename)
+      path = File.join(dir, filename)
+      return [] unless File.exist?(path)
+
+      yaml = File.read(path)
+      yield yaml
+    end
+  end
+end

data/lib/isq/designation.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Isq
+  class Designation < TermInstance
+    attribute :index_as, :string, collection: true
+  end
+end

data/lib/isq/export.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Isq
+  class Export
+    def initialize(dataset:, export_dir:, format: :both)
+      @dataset = dataset
+      @export_dir = export_dir
+      @format = format
+    end
+
+    def run
+      prepare_output_dir
+      write_per_part
+      write_bulk
+      write_manifest
+    end
+
+    private
+
+    def prepare_output_dir
+      FileUtils.rm_rf(@export_dir)
+      FileUtils.mkdir_p(@export_dir)
+    end
+
+    def write_per_part
+      @dataset.part_keys.each do |part_key|
+        part_dir = File.join(@export_dir, "part-#{part_key}")
+        FileUtils.mkdir_p(part_dir)
+
+        part_doc = Isq::PartDocument.for_part(part_key)
+        entries = @dataset.entries_for_part(part_key)
+        units = build_unit_instances(@dataset.unique_units_for_part(part_key), entries)
+
+        if write_turtle?
+          part_ttl = compose_part_turtle(part_doc, units, entries)
+          File.write(File.join(part_dir, "index.ttl"), part_ttl)
+        end
+
+        if write_jsonld?
+          part_jsonld = compose_part_jsonld(part_doc, units, entries)
+          File.write(File.join(part_dir, "index.jsonld"), part_jsonld)
+        end
+
+        write_per_entry_files(part_dir, entries)
+      end
+    end
+
+    def write_per_entry_files(part_dir, entries)
+      entries.each do |entry|
+        if write_turtle?
+          File.write(File.join(part_dir, "#{entry.id}.ttl"), entry.to_turtle)
+        end
+
+        if write_jsonld?
+          File.write(File.join(part_dir, "#{entry.id}.jsonld"), entry.to_jsonld)
+        end
+      end
+    end
+
+    def write_bulk
+      if write_turtle?
+        all_turtle = @dataset.part_keys.map do |part_key|
+          part_doc = Isq::PartDocument.for_part(part_key)
+          entries = @dataset.entries_for_part(part_key)
+          units = build_unit_instances(@dataset.unique_units_for_part(part_key), entries)
+          compose_part_turtle(part_doc, units, entries)
+        end.join("\n")
+        File.write(File.join(@export_dir, "iso80000-all.ttl"), all_turtle)
+      end
+
+      if write_jsonld?
+        all_jsonld = @dataset.part_keys.map do |part_key|
+          part_doc = Isq::PartDocument.for_part(part_key)
+          entries = @dataset.entries_for_part(part_key)
+          units = build_unit_instances(@dataset.unique_units_for_part(part_key), entries)
+          compose_part_jsonld(part_doc, units, entries)
+        end.join("\n")
+        File.write(File.join(@export_dir, "iso80000-all.jsonld"), all_jsonld)
+      end
+    end
+
+    def write_manifest
+      manifest = {
+        generated: Time.now.utc.iso8601,
+        total_entries: @dataset.total_count,
+        parts: @dataset.counts_by_part,
+        namespaces: namespace_registry,
+      }
+      File.write(File.join(@export_dir, "manifest.json"), JSON.pretty_generate(manifest))
+    end
+
+    def build_unit_instances(unit_refs, entries)
+      unit_map = collect_unit_data(entries)
+      unit_refs.filter_map do |ref|
+        data = unit_map[ref]
+        next unless data
+
+        Isq::Unit.new(
+          id: ref.sub("isoiec80000:", ""),
+          pref_label: data[:name],
+          notation: data[:symbols],
+          bindingness_type: "smart:normative",
+        )
+      end
+    end
+
+    def collect_unit_data(entries)
+      entries.each_with_object({}) do |entry, map|
+        next unless entry.is_a?(Isq::Quantity)
+        next unless entry.unit_data
+
+        map.merge!(entry.unit_data) { |_key, old, _new| old }
+      end
+    end
+
+    def compose_part_turtle(part_doc, units, entries)
+      lines = []
+      lines << part_doc.to_turtle
+      units.each { |u| lines << u.to_turtle }
+      entries.each { |e| lines << e.to_turtle }
+      lines.join("\n")
+    end
+
+    def compose_part_jsonld(part_doc, units, entries)
+      lines = []
+      lines << part_doc.to_jsonld
+      units.each { |u| lines << u.to_jsonld }
+      entries.each { |e| lines << e.to_jsonld }
+      lines.join("\n")
+    end
+
+    def namespace_registry
+      {
+        smart: "https://w3id.org/standards/smart/ontologies/core/",
+        isoiec80000: "https://w3id.org/standards/isoiec80000/ontologies/core/",
+        dcterms: "http://purl.org/dc/terms/",
+        skos: "http://www.w3.org/2004/02/skos/core#",
+        skosxl: "http://www.w3.org/2008/05/skos-xl#",
+      }
+    end
+
+    def write_turtle?
+      @format == :both || @format == :ttl
+    end
+
+    def write_jsonld?
+      @format == :both || @format == :jsonld
+    end
+  end
+end

data/lib/isq/lang_string.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "lutaml/rdf/language_tagged"
+
+module Isq
+  class LangString < String
+    include Lutaml::Rdf::LanguageTagged
+
+    attr_reader :language
+
+    def initialize(text, language: "en")
+      super(text.to_s)
+      @language = language
+    end
+  end
+end

data/lib/isq/math_concept.rb

@@ -2,21 +2,49 @@
 
 module Isq
   class MathConcept < SduSmart::TermEntry
+    include Isq::YamlAdapters
+
     attribute :identifier, :string
     attribute :pref_label, :string
-    attribute :notation, :string, collection: true
+    attribute :notation, :string, collection: true, initialize_empty: true
     attribute :definition, :string
     attribute :note, :string
+    attribute :part, :string
+    attribute :edition, :string
+    attribute :designations, Isq::Designation, collection: true, initialize_empty: true
+    attribute :symbols, Isq::SymbolTerm, collection: true, initialize_empty: true
+
+    def definition=(value)
+      value_set_for(:definition)
+      @definition = value
+    end
+
+    def note=(value)
+      value_set_for(:note)
+      @note = value
+    end
+
+    yaml do
+      map "id", to: :id
+      map "num", to: :identifier
+      map "part", to: :part
+      map "edition", to: :edition
+      map "def", with: { from: :definition_from_yaml, to: :definition_to_yaml }
+      map "remarks", with: { from: :note_from_yaml, to: :note_to_yaml }
+      map "designations", with: { from: :designations_from_yaml, to: :designations_to_yaml }
+      map "symbols", with: { from: :symbols_from_yaml, to: :symbols_to_yaml }
+    end
 
     rdf do
       namespace SduSmart::Rdf::Namespaces::IsoIec80000Namespace,
                 SduSmart::Rdf::Namespaces::SmartNamespace,
                 Lutaml::Rdf::Namespaces::DctermsNamespace,
-                Lutaml::Rdf::Namespaces::SkosNamespace
+                Lutaml::Rdf::Namespaces::SkosNamespace,
+                SduSmart::Rdf::Namespaces::SkosXlNamespace
 
       subject { |m| "https://w3id.org/standards/isoiec80000/ontologies/core/#{m.id}" }
 
-      type "isoiec80000:MathConcept"
+      type ["isoiec80000:MathConcept", "smart:TermEntry"]
 
       predicate :identifier,
                 namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
@@ -32,11 +60,13 @@ module Isq
 
       predicate :definition,
                 namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
-                to: :definition
+                to: :definition,
+                lang_tagged: true
 
       predicate :note,
                 namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
-                to: :note
+                to: :note,
+                lang_tagged: true
 
       predicate :hasBindingnessType,
                 namespace: SduSmart::Rdf::Namespaces::SmartNamespace,
@@ -45,6 +75,13 @@ module Isq
       predicate :isPartOf,
                 namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
                 to: :is_part_of
+
+      members :designations,
+              predicate_name: :prefLabel,
+              namespace: SduSmart::Rdf::Namespaces::SkosXlNamespace
+      members :symbols,
+              predicate_name: :altLabel,
+              namespace: SduSmart::Rdf::Namespaces::SkosXlNamespace
     end
   end
 end

data/lib/isq/part_document.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Isq
+  class PartDocument < SduSmart::PublicationDocument
+    PART_TITLES = {
+      "2" => "Mathematics",
+      "3" => "Space and Time",
+      "4" => "Mechanics",
+      "5" => "Thermodynamics",
+      "6" => "Electromagnetism",
+      "7" => "Light and Radiation",
+      "8" => "Acoustics",
+      "9" => "Physical Chemistry and Molecular Physics",
+      "10" => "Atomic and Nuclear Physics",
+      "11" => "Characteristic Numbers",
+      "12" => "Condensed Matter Physics",
+      "13" => "Information Science",
+    }.freeze
+
+    attribute :part_number, :string
+    attribute :title, :string
+    attribute :bindingness_type, :string
+
+    rdf do
+      namespace SduSmart::Rdf::Namespaces::SmartNamespace,
+                Lutaml::Rdf::Namespaces::DctermsNamespace
+
+      subject { |m| "https://w3id.org/standards/isoiec80000/ontologies/core/part-#{m.part_number}" }
+
+      type "smart:PublicationDocument"
+
+      predicate :title,
+                namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
+                to: :title
+
+      predicate :identifier,
+                namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
+                to: :part_number
+
+      predicate :hasPublicationType,
+                namespace: SduSmart::Rdf::Namespaces::SmartNamespace,
+                to: :publication_type
+
+      predicate :hasBindingnessType,
+                namespace: SduSmart::Rdf::Namespaces::SmartNamespace,
+                to: :bindingness_type
+    end
+
+    def self.for_part(part_number)
+      new(
+        id: "part-#{part_number}",
+        part_number: "ISO 80000-#{part_number}",
+        title: PART_TITLES.fetch(part_number, "Part #{part_number}"),
+        publication_type: "smart:internationalStandard",
+        bindingness_type: "smart:normative",
+      )
+    end
+
+    def self.all_parts
+      PART_TITLES.keys.map { |p| for_part(p) }
+    end
+  end
+end

data/lib/isq/quantity.rb

@@ -2,22 +2,53 @@
 
 module Isq
   class Quantity < SduSmart::TermEntry
+    include Isq::YamlAdapters
+
     attribute :identifier, :string
     attribute :pref_label, :string
-    attribute :notation, :string, collection: true
+    attribute :notation, :string, collection: true, initialize_empty: true
     attribute :definition, :string
     attribute :note, :string
-    attribute :has_unit, :string, collection: true
+    attribute :has_unit, :string, collection: true, initialize_empty: true
+    attribute :part, :string
+    attribute :edition, :string
+    attribute :designations, Isq::Designation, collection: true, initialize_empty: true
+    attribute :symbols, Isq::SymbolTerm, collection: true, initialize_empty: true
+
+    attr_accessor :unit_data
+
+    def definition=(value)
+      value_set_for(:definition)
+      @definition = value
+    end
+
+    def note=(value)
+      value_set_for(:note)
+      @note = value
+    end
+
+    yaml do
+      map "id", to: :id
+      map "num", to: :identifier
+      map "part", to: :part
+      map "edition", to: :edition
+      map "def", with: { from: :definition_from_yaml, to: :definition_to_yaml }
+      map "remarks", with: { from: :note_from_yaml, to: :note_to_yaml }
+      map "designations", with: { from: :designations_from_yaml, to: :designations_to_yaml }
+      map "symbols", with: { from: :symbols_from_yaml, to: :symbols_to_yaml }
+      map "units", with: { from: :units_from_yaml, to: :units_to_yaml }
+    end
 
     rdf do
       namespace SduSmart::Rdf::Namespaces::IsoIec80000Namespace,
                 SduSmart::Rdf::Namespaces::SmartNamespace,
                 Lutaml::Rdf::Namespaces::DctermsNamespace,
-                Lutaml::Rdf::Namespaces::SkosNamespace
+                Lutaml::Rdf::Namespaces::SkosNamespace,
+                SduSmart::Rdf::Namespaces::SkosXlNamespace
 
       subject { |m| "https://w3id.org/standards/isoiec80000/ontologies/core/#{m.id}" }
 
-      type "isoiec80000:Quantity"
+      type ["isoiec80000:Quantity", "smart:TermEntry"]
 
       predicate :identifier,
                 namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
@@ -33,15 +64,18 @@ module Isq
 
       predicate :definition,
                 namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
-                to: :definition
+                to: :definition,
+                lang_tagged: true
 
       predicate :note,
                 namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
-                to: :note
+                to: :note,
+                lang_tagged: true
 
       predicate :hasUnit,
                 namespace: SduSmart::Rdf::Namespaces::IsoIec80000Namespace,
-                to: :has_unit
+                to: :has_unit,
+                uri_reference: true
 
       predicate :hasBindingnessType,
                 namespace: SduSmart::Rdf::Namespaces::SmartNamespace,
@@ -50,6 +84,42 @@ module Isq
       predicate :isPartOf,
                 namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
                 to: :is_part_of
+
+      members :designations,
+              predicate_name: :prefLabel,
+              namespace: SduSmart::Rdf::Namespaces::SkosXlNamespace
+      members :symbols,
+              predicate_name: :altLabel,
+              namespace: SduSmart::Rdf::Namespaces::SkosXlNamespace
+    end
+
+    def units_from_yaml(model, value)
+      unless value.is_a?(Array)
+        model.has_unit = []
+        model.unit_data = {}
+        return []
+      end
+
+      data = {}
+      refs = value.map do |u|
+        sym = Array(u["symbol"]).first
+        ref = if sym
+                "isoiec80000:unit-#{sym}"
+              else
+                name = u["en"]&.downcase&.gsub(/\s+/, "-")
+                "isoiec80000:unit-#{name}" if name
+              end
+        data[ref] = { name: u["en"], symbols: Array(u["symbol"]) } if ref
+        ref
+      end.compact
+
+      model.has_unit = refs
+      model.unit_data = data
+      refs
+    end
+
+    def units_to_yaml(model, doc)
+      # Unit YAML round-trip requires Dataset lookup
     end
   end
 end

data/lib/isq/symbol_term.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Isq
+  class SymbolTerm < TermInstance
+  end
+end

data/lib/isq/term_instance.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Isq
+  class TermInstance < SduSmart::Term
+    attribute :text, :string
+    attribute :lang, :string, default: "en"
+
+    def text=(value)
+      value_set_for(:text)
+      @text = value
+    end
+
+    rdf do
+      namespace SduSmart::Rdf::Namespaces::SkosXlNamespace,
+                SduSmart::Rdf::Namespaces::SmartNamespace
+
+      subject { |m| "https://w3id.org/standards/isoiec80000/ontologies/core/#{m.id}" }
+
+      type ["skosxl:Label", "smart:Term"]
+
+      predicate :literalForm,
+                namespace: SduSmart::Rdf::Namespaces::SkosXlNamespace,
+                to: :text,
+                lang_tagged: true
+
+      predicate :hasTermFormType,
+                namespace: SduSmart::Rdf::Namespaces::SmartNamespace,
+                to: :term_form_type,
+                uri_reference: true
+    end
+  end
+end

data/lib/isq/unit.rb

@@ -3,7 +3,12 @@
 module Isq
   class Unit < SduSmart::TermEntry
     attribute :pref_label, :string
-    attribute :notation, :string, collection: true
+    attribute :notation, :string, collection: true, initialize_empty: true
+
+    yaml do
+      map "en", to: :pref_label
+      map "symbol", to: :notation
+    end
 
     rdf do
       namespace SduSmart::Rdf::Namespaces::IsoIec80000Namespace,
@@ -13,7 +18,7 @@ module Isq
 
       subject { |m| "https://w3id.org/standards/isoiec80000/ontologies/core/#{m.id}" }
 
-      type "isoiec80000:Unit"
+      type ["isoiec80000:Unit", "smart:TermEntry"]
 
       predicate :prefLabel,
                 namespace: Lutaml::Rdf::Namespaces::SkosNamespace,

data/lib/isq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Isq
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/isq/yaml_adapters.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Isq
+  module YamlAdapters
+    def definition_from_yaml(model, value)
+      return unless value.is_a?(Hash)
+
+      lang = value.keys.first.to_s
+      text = value.values.first
+      model.definition = Isq::LangString.new(text.to_s, language: lang)
+    end
+
+    def definition_to_yaml(model, doc)
+      return unless model.definition
+
+      lang = model.definition.language || "en"
+      doc["def"] = { lang => model.definition.to_s }
+    end
+
+    def note_from_yaml(model, value)
+      return unless value.is_a?(Hash)
+
+      lang = value.keys.first.to_s
+      text = value.values.first
+      model.note = Isq::LangString.new(text.to_s, language: lang)
+    end
+
+    def note_to_yaml(model, doc)
+      return unless model.note
+
+      lang = model.note.language || "en"
+      doc["remarks"] = { lang => model.note.to_s }
+    end
+
+    def designations_from_yaml(model, value)
+      unless value.is_a?(Array)
+        model.designations = []
+        return []
+      end
+
+      designations = value.each_with_index.map do |entry, i|
+        lang_data = entry["designation"]
+        next unless lang_data.is_a?(Hash)
+
+        lang = lang_data.keys.first.to_s
+        text_data = lang_data[lang] || lang_data[lang.to_sym]
+        next unless text_data.is_a?(Hash)
+
+        d = Isq::Designation.new(
+          id: "term-#{model.id}-#{i}",
+          lang: lang,
+          term_form_type: "smart:fullForm",
+          index_as: Array(text_data["index_as"]),
+        )
+        d.text = Isq::LangString.new(text_data["text"].to_s, language: lang)
+        d
+      end.compact
+
+      model.designations = designations
+      model.pref_label = designations.first&.text
+      designations
+    end
+
+    def designations_to_yaml(model, doc)
+      doc["designations"] = model.designations.map do |d|
+        { "designation" => { d.lang => { "text" => d.text.to_s, "index_as" => Array(d.index_as) } } }
+      end
+    end
+
+    def symbols_from_yaml(model, value)
+      unless value.is_a?(Array)
+        model.symbols = []
+        model.notation = []
+        return []
+      end
+
+      symbols = value.each_with_index.map do |sym, i|
+        s = Isq::SymbolTerm.new(
+          id: "sym-#{model.id}-#{i}",
+          lang: "en",
+          term_form_type: "smart:symbol",
+        )
+        s.text = Isq::LangString.new(sym.to_s, language: "en")
+        s
+      end
+
+      model.symbols = symbols
+      model.notation = symbols.map { |s| s.text.to_s }
+      symbols
+    end
+
+    def symbols_to_yaml(model, doc)
+      doc["symbols"] = model.symbols.map { |s| s.text.to_s }
+    end
+  end
+end

data/lib/isq.rb

@@ -3,8 +3,16 @@
 require "sdu_smart"
 
 module Isq
+  autoload :LangString, "#{__dir__}/isq/lang_string"
+  autoload :YamlAdapters, "#{__dir__}/isq/yaml_adapters"
+  autoload :TermInstance, "#{__dir__}/isq/term_instance"
+  autoload :Designation, "#{__dir__}/isq/designation"
+  autoload :SymbolTerm, "#{__dir__}/isq/symbol_term"
   autoload :Quantity, "#{__dir__}/isq/quantity"
   autoload :Unit, "#{__dir__}/isq/unit"
   autoload :MathConcept, "#{__dir__}/isq/math_concept"
+  autoload :PartDocument, "#{__dir__}/isq/part_document"
+  autoload :Dataset, "#{__dir__}/isq/dataset"
+  autoload :Export, "#{__dir__}/isq/export"
   autoload :VERSION, "#{__dir__}/isq/version"
 end

data/lib/tasks/export.rake

@@ -1,309 +1,18 @@
 # frozen_string_literal: true
 
-require "yaml"
-require "json"
-require "fileutils"
-
 namespace :export do
-  ROOT = File.join(__dir__, "..", "..", "..")
-  EXPORT_DIR = ENV.fetch("ISQ_EXPORT_DIR", File.join(ROOT, "browser", "public", "exports"))
-  DATASET_DIR = ENV.fetch("ISQ_DATASET_DIR", File.join(ROOT, "iso-iec-80000", "sources", "dataset"))
-
-  PART_TITLES = {
-    "3" => "Space and Time", "4" => "Mechanics", "5" => "Thermodynamics",
-    "6" => "Electromagnetism", "7" => "Light and Radiation", "8" => "Acoustics",
-    "9" => "Physical Chemistry", "10" => "Atomic and Nuclear", "11" => "Characteristic Numbers",
-    "12" => "Condensed Matter", "13" => "Information Science", "2" => "Mathematics",
-  }.freeze
-
-  SMART = "https://w3id.org/standards/smart/ontologies/core/"
-  ISO = "https://w3id.org/standards/isoiec80000/ontologies/core/"
-  DCTERMS = "http://purl.org/dc/terms/"
-  SKOS = "http://www.w3.org/2004/02/skos/core#"
-  SKOSXL = "http://www.w3.org/2008/05/skos-xl#"
-
-  JSONLD_CONTEXT = {
-    "@context" => {
-      "smart" => SMART,
-      "isoiec80000" => ISO,
-      "dcterms" => DCTERMS,
-      "skos" => SKOS,
-      "skosxl" => SKOSXL,
-      "rdf" => "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
-      "rdfs" => "http://www.w3.org/2000/01/rdf-schema#",
-      "owl" => "http://www.w3.org/2002/07/owl#",
-      "xsd" => "http://www.w3.org/2001/XMLSchema#",
-    },
-  }.freeze
-
-  def load_entries
-    quantities = YAML.load_file(File.join(DATASET_DIR, "quantities.yaml"))
-    math = YAML.load_file(File.join(DATASET_DIR, "math.yaml"))
-    quantities + math
-  end
-
-  def math?(entry)
-    entry["part"].to_s.start_with?("2")
-  end
-
-  def entry_rdf_type(entry)
-    math?(entry) ? "isoiec80000:MathConcept" : "isoiec80000:Quantity"
-  end
-
-  def unit_uri(unit)
-    sym = unit["symbol"]&.first
-    sym ? "isoiec80000:unit-#{sym}" : "isoiec80000:unit-#{unit['en']&.downcase&.gsub(/\s+/, '-')}"
-  end
-
-  def escape_literal(s)
-    s.gsub("\\", "\\\\\\\\").gsub('"', '\\"')
-  end
-
-  def generate_turtle(entry)
-    id = entry["id"]
-    rdf_type = entry_rdf_type(entry)
-    lines = []
-
-    # Term instances for designations
-    entry["designations"]&.each_with_index do |des, i|
-      tid = "term-#{id}-#{i}"
-      text = des.dig("designation", "en", "text")
-      next unless text
-
-      lines << "isoiec80000:#{tid} a smart:Term, skosxl:Label ;"
-      lines << "  skosxl:literalForm \"#{escape_literal(text)}\"@en ;"
-      lines << "  smart:hasTermFormType smart:fullForm ."
-      lines << ""
-    end
-
-    # Term instances for symbols
-    entry["symbols"]&.each_with_index do |sym, i|
-      tid = "sym-#{id}-#{i}"
-      lines << "isoiec80000:#{tid} a smart:Term, skosxl:Label ;"
-      lines << "  skosxl:literalForm \"#{escape_literal(sym)}\"@en ;"
-      lines << "  smart:hasTermFormType smart:symbol ."
-      lines << ""
-    end
-
-    # Main entry
-    lines << "isoiec80000:#{id} a #{rdf_type}, smart:TermEntry ;"
-    lines << "  dcterms:identifier \"#{entry['num']}\" ;"
-
-    # skosxl:prefLabel for first designation
-    if entry["designations"]&.any?
-      lines << "  skosxl:prefLabel isoiec80000:term-#{id}-0 ;"
-    end
-
-    # skosxl:altLabel for remaining designations
-    entry["designations"]&.each_with_index do |_des, i|
-      next if i == 0
-      lines << "  skosxl:altLabel isoiec80000:term-#{id}-#{i} ;"
-    end
-
-    # skosxl:altLabel for symbol terms
-    entry["symbols"]&.each_with_index do |_sym, i|
-      lines << "  skosxl:altLabel isoiec80000:sym-#{id}-#{i} ;"
-    end
-
-    if entry["def"]&.dig("en")
-      lines << "  skos:definition \"\"\"#{escape_literal(entry['def']['en'])}\"\"\"@en ;"
-    end
-
-    if entry["remarks"]&.dig("en")
-      lines << "  skos:note \"\"\"#{escape_literal(entry['remarks']['en'])}\"\"\"@en ;"
-    end
-
-    if entry["units"]&.any?
-      for unit in entry["units"]
-        lines << "  isoiec80000:hasUnit #{unit_uri(unit)} ;"
-      end
-    end
-
-    lines << "  smart:hasBindingnessType smart:normative ;"
-    lines << "  dcterms:isPartOf isoiec80000:part-#{entry['part']} ."
-
-    lines.join("\n")
-  end
-
-  def generate_unit_turtle(unit)
-    uri = unit_uri(unit)
-    name = unit["en"]
-    lines = ["#{uri} a isoiec80000:Unit, smart:TermEntry ;"]
-    lines << "  skos:prefLabel \"#{name}\"@en ;"
-    if unit["symbol"]&.any?
-      for sym in unit["symbol"]
-        lines << "  skos:notation \"#{sym}\" ;"
-      end
-    end
-    lines << "  smart:hasBindingnessType smart:normative ."
-    lines.join("\n")
-  end
-
-  def entry_jsonld(entry)
-    id = entry["id"]
-    part = entry["part"]
-
-    # Term instances for designations
-    terms = entry["designations"]&.each_with_index&.map do |des, i|
-      text = des.dig("designation", "en", "text")
-      next unless text
-
-      {
-        "@id" => "#{ISO}term-#{id}-#{i}",
-        "@type" => ["smart:Term", "skosxl:Label"],
-        "skosxl:literalForm" => { "@value" => text, "@language" => "en" },
-        "smart:hasTermFormType" => { "@id" => "smart:fullForm" },
-      }
-    end&.compact || []
-
-    # Term instances for symbols
-    symbol_terms = entry["symbols"]&.each_with_index&.map do |sym, i|
-      {
-        "@id" => "#{ISO}sym-#{id}-#{i}",
-        "@type" => ["smart:Term", "skosxl:Label"],
-        "skosxl:literalForm" => { "@value" => sym, "@language" => "en" },
-        "smart:hasTermFormType" => { "@id" => "smart:symbol" },
-      }
-    end || []
-
-    all_terms = terms + symbol_terms
-
-    entry_obj = {
-      "@id" => "#{ISO}#{id}",
-      "@type" => [entry_rdf_type(entry), "smart:TermEntry"],
-      "dcterms:identifier" => entry["num"],
-    }
-
-    if terms.any?
-      entry_obj["skosxl:prefLabel"] = { "@id" => "#{ISO}term-#{id}-0" }
-    end
-
-    alt_labels = []
-    entry["designations"]&.each_with_index do |_des, i|
-      next if i == 0
-      alt_labels << { "@id" => "#{ISO}term-#{id}-#{i}" }
-    end
-    entry["symbols"]&.each_with_index do |_sym, i|
-      alt_labels << { "@id" => "#{ISO}sym-#{id}-#{i}" }
-    end
-    entry_obj["skosxl:altLabel"] = alt_labels if alt_labels.any?
-
-    if entry["def"]&.dig("en")
-      entry_obj["skos:definition"] = { "@value" => entry["def"]["en"], "@language" => "en" }
-    end
-
-    if entry["remarks"]&.dig("en")
-      entry_obj["skos:note"] = { "@value" => entry["remarks"]["en"], "@language" => "en" }
-    end
-
-    if entry["units"]&.any?
-      entry_obj["isoiec80000:hasUnit"] = entry["units"].map { |u| { "@id" => unit_uri(u) } }
-    end
-
-    entry_obj["smart:hasBindingnessType"] = { "@id" => "smart:normative" }
-    entry_obj["dcterms:isPartOf"] = { "@id" => "#{ISO}part-#{part}" }
-
-    { "@graph" => all_terms + [entry_obj] }
-  end
-
-  def generate_part_turtle(part_key, part_entries)
-    lines = [
-      "@prefix isoiec80000: <#{ISO}> .",
-      "@prefix smart: <#{SMART}> .",
-      "@prefix dcterms: <#{DCTERMS}> .",
-      "@prefix skos: <#{SKOS}> .",
-      "@prefix skosxl: <#{SKOSXL}> .",
-      "",
-    ]
-
-    # PublicationDocument instance
-    lines << "isoiec80000:part-#{part_key} a smart:PublicationDocument ;"
-    lines << "  dcterms:title \"#{PART_TITLES[part_key] || "Part #{part_key}"}\"@en ;"
-    lines << "  dcterms:identifier \"ISO 80000-#{part_key}\" ;"
-    lines << "  smart:hasPublicationType smart:internationalStandard ;"
-    lines << "  smart:hasBindingnessType smart:normative ."
-    lines << ""
-
-    # Collect unique units
-    units = part_entries.each_with_object([]) do |entry, acc|
-      entry["units"]&.each do |u|
-        key = unit_uri(u)
-        acc << u unless acc.any? { |existing| unit_uri(existing) == key }
-      end
-    end
-
-    units.each do |u|
-      lines << generate_unit_turtle(u)
-      lines << ""
-    end
-
-    part_entries.each do |entry|
-      lines << generate_turtle(entry)
-      lines << ""
-    end
-
-    lines.join("\n")
-  end
-
   desc "Generate TTL and JSON-LD exports for all entries"
   task :all do
-    require "sdu_smart"
-
-    FileUtils.rm_rf(EXPORT_DIR)
-    FileUtils.mkdir_p(EXPORT_DIR)
-
-    entries = load_entries
-    by_part = entries.group_by { |e| e["part"].to_s }
-
-    all_turtle = []
-    all_jsonld = []
-
-    by_part.each do |part_key, part_entries|
-      part_dir = File.join(EXPORT_DIR, "part-#{part_key}")
-      FileUtils.mkdir_p(part_dir)
-
-      # Per-part Turtle
-      part_ttl = generate_part_turtle(part_key, part_entries)
-      File.write(File.join(part_dir, "index.ttl"), part_ttl)
-
-      # Per-part JSON-LD
-      part_graphs = part_entries.map { |e| entry_jsonld(e) }
-      part_jsonld = { **JSONLD_CONTEXT, "@graph" => part_graphs.flat_map { |g| g["@graph"] } }
-      File.write(File.join(part_dir, "index.jsonld"), JSON.pretty_generate(part_jsonld))
-
-      all_turtle << part_ttl
-      all_jsonld.concat(part_graphs.flat_map { |g| g["@graph"] })
-
-      # Per-entry files
-      part_entries.each do |entry|
-        base = entry["id"]
-        entry_json = entry_jsonld(entry)
-        File.write(File.join(part_dir, "#{base}.ttl"), generate_turtle(entry))
-        File.write(File.join(part_dir, "#{base}.jsonld"), JSON.pretty_generate({ **JSONLD_CONTEXT, **entry_json }))
-      end
-    end
+    require "isq"
 
-    # Full bulk exports
-    File.write(File.join(EXPORT_DIR, "iso80000-all.ttl"), all_turtle.join("\n"))
-    bulk_jsonld = { **JSONLD_CONTEXT, "@graph" => all_jsonld }
-    File.write(File.join(EXPORT_DIR, "iso80000-all.jsonld"), JSON.pretty_generate(bulk_jsonld))
+    root = File.join(__dir__, "..", "..", "..")
+    dataset_dir = ENV.fetch("ISQ_DATASET_DIR", File.join(root, "iso-iec-80000", "sources", "dataset"))
+    export_dir = ENV.fetch("ISQ_EXPORT_DIR", File.join(root, "browser", "public", "exports"))
 
-    # Manifest
-    manifest = {
-      generated: Time.now.utc.iso8601,
-      total_entries: entries.length,
-      parts: by_part.transform_values(&:length),
-      namespaces: {
-        smart: SMART,
-        isoiec80000: ISO,
-        dcterms: DCTERMS,
-        skos: SKOS,
-        skosxl: SKOSXL,
-      },
-    }
-    File.write(File.join(EXPORT_DIR, "manifest.json"), JSON.pretty_generate(manifest))
+    dataset = Isq::Dataset.load(dataset_dir)
+    Isq::Export.new(dataset: dataset, export_dir: export_dir).run
 
-    puts "Generated exports in #{EXPORT_DIR}:"
-    puts "  #{entries.length} entries across #{by_part.length} parts"
+    puts "Generated exports in #{export_dir}:"
+    puts "  #{dataset.total_count} entries across #{dataset.part_keys.length} parts"
   end
 end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: isq
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ribose
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -37,20 +37,45 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: 'Ruby gem extending the SmartSDU Core Ontology with ISO/IEC 80000-specific
   domain classes: Quantity, Unit, and MathConcept. Includes a Rake task for generating
   per-part Turtle and JSON-LD exports from YAML source data.'
 email:
 - open.source@ribose.com
-executables: []
+executables:
+- isq
 extensions: []
 extra_rdoc_files: []
 files:
+- exe/isq
 - lib/isq.rb
+- lib/isq/cli.rb
+- lib/isq/dataset.rb
+- lib/isq/designation.rb
+- lib/isq/export.rb
+- lib/isq/lang_string.rb
 - lib/isq/math_concept.rb
+- lib/isq/part_document.rb
 - lib/isq/quantity.rb
+- lib/isq/symbol_term.rb
+- lib/isq/term_instance.rb
 - lib/isq/unit.rb
 - lib/isq/version.rb
+- lib/isq/yaml_adapters.rb
 - lib/tasks/export.rake
 homepage: https://github.com/metanorma/isq
 licenses: