isq 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 44823d1e9f21796b3c62de48a24105fa0b5c906e6990ddd75a1143052363f11b
+  data.tar.gz: 2671bb4938158df5c272b790000da4c53e134c9a54d4bd6b553aa57f3e4d6ba4
+SHA512:
+  metadata.gz: 29c22ea5b84c9bce2c796164001e708a7fee5967acc0954c9042dbebda36e8f91d4a02d2badad8d6955bd5f66e9ace56600dec1b355d294ed17e34623a529e1c
+  data.tar.gz: 5812745292b217fc5ea1acb9b8c802bddfc1f315ea2a748714d5064cbc3698df0267a7a1f18bad52e8999cc11fee38233778f7741f5e3fdc8c9d8b5ad138b81e

data/lib/isq/math_concept.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Isq
+  class MathConcept < SduSmart::TermEntry
+    attribute :identifier, :string
+    attribute :pref_label, :string
+    attribute :notation, :string, collection: true
+    attribute :definition, :string
+    attribute :note, :string
+
+    rdf do
+      namespace SduSmart::Rdf::Namespaces::IsoIec80000Namespace,
+                SduSmart::Rdf::Namespaces::SmartNamespace,
+                Lutaml::Rdf::Namespaces::DctermsNamespace,
+                Lutaml::Rdf::Namespaces::SkosNamespace
+
+      subject { |m| "https://w3id.org/standards/isoiec80000/ontologies/core/#{m.id}" }
+
+      type "isoiec80000:MathConcept"
+
+      predicate :identifier,
+                namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
+                to: :identifier
+
+      predicate :prefLabel,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :pref_label
+
+      predicate :notation,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :notation
+
+      predicate :definition,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :definition
+
+      predicate :note,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :note
+
+      predicate :hasBindingnessType,
+                namespace: SduSmart::Rdf::Namespaces::SmartNamespace,
+                to: :bindingness_type
+
+      predicate :isPartOf,
+                namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
+                to: :is_part_of
+    end
+  end
+end

data/lib/isq/quantity.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Isq
+  class Quantity < SduSmart::TermEntry
+    attribute :identifier, :string
+    attribute :pref_label, :string
+    attribute :notation, :string, collection: true
+    attribute :definition, :string
+    attribute :note, :string
+    attribute :has_unit, :string, collection: true
+
+    rdf do
+      namespace SduSmart::Rdf::Namespaces::IsoIec80000Namespace,
+                SduSmart::Rdf::Namespaces::SmartNamespace,
+                Lutaml::Rdf::Namespaces::DctermsNamespace,
+                Lutaml::Rdf::Namespaces::SkosNamespace
+
+      subject { |m| "https://w3id.org/standards/isoiec80000/ontologies/core/#{m.id}" }
+
+      type "isoiec80000:Quantity"
+
+      predicate :identifier,
+                namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
+                to: :identifier
+
+      predicate :prefLabel,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :pref_label
+
+      predicate :notation,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :notation
+
+      predicate :definition,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :definition
+
+      predicate :note,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :note
+
+      predicate :hasUnit,
+                namespace: SduSmart::Rdf::Namespaces::IsoIec80000Namespace,
+                to: :has_unit
+
+      predicate :hasBindingnessType,
+                namespace: SduSmart::Rdf::Namespaces::SmartNamespace,
+                to: :bindingness_type
+
+      predicate :isPartOf,
+                namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
+                to: :is_part_of
+    end
+  end
+end

data/lib/isq/unit.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Isq
+  class Unit < SduSmart::TermEntry
+    attribute :pref_label, :string
+    attribute :notation, :string, collection: true
+
+    rdf do
+      namespace SduSmart::Rdf::Namespaces::IsoIec80000Namespace,
+                SduSmart::Rdf::Namespaces::SmartNamespace,
+                Lutaml::Rdf::Namespaces::DctermsNamespace,
+                Lutaml::Rdf::Namespaces::SkosNamespace
+
+      subject { |m| "https://w3id.org/standards/isoiec80000/ontologies/core/#{m.id}" }
+
+      type "isoiec80000:Unit"
+
+      predicate :prefLabel,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :pref_label
+
+      predicate :notation,
+                namespace: Lutaml::Rdf::Namespaces::SkosNamespace,
+                to: :notation
+
+      predicate :hasBindingnessType,
+                namespace: SduSmart::Rdf::Namespaces::SmartNamespace,
+                to: :bindingness_type
+
+      predicate :isPartOf,
+                namespace: Lutaml::Rdf::Namespaces::DctermsNamespace,
+                to: :is_part_of
+    end
+  end
+end

data/lib/isq/version.rb

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

data/lib/isq.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "sdu_smart"
+
+module Isq
+  autoload :Quantity, "#{__dir__}/isq/quantity"
+  autoload :Unit, "#{__dir__}/isq/unit"
+  autoload :MathConcept, "#{__dir__}/isq/math_concept"
+  autoload :VERSION, "#{__dir__}/isq/version"
+end

data/lib/tasks/export.rake

@@ -0,0 +1,309 @@
+# 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
+
+    # 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))
+
+    # 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))
+
+    puts "Generated exports in #{EXPORT_DIR}:"
+    puts "  #{entries.length} entries across #{by_part.length} parts"
+  end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: isq
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sdu_smart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+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: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/isq.rb
+- lib/isq/math_concept.rb
+- lib/isq/quantity.rb
+- lib/isq/unit.rb
+- lib/isq/version.rb
+- lib/tasks/export.rake
+homepage: https://github.com/metanorma/isq
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/metanorma/isq
+  source_code_uri: https://github.com/metanorma/isq
+  changelog_uri: https://github.com/metanorma/isq/releases
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: ISO/IEC 80000 International System of Quantities — Ruby domain classes and
+  RDF export.
+test_files: []