glossarist 2.3.0 → 2.3.2

data/lib/glossarist/managed_concept.rb

@@ -1,90 +1,101 @@
-# frozen_string_literal: true
+require_relative "localized_concept"
 
 module Glossarist
-  class ManagedConcept < Model
-    include Glossarist::Utilities::Enum
+  class ManagedConcept < Lutaml::Model::Serializable
     include Glossarist::Utilities::CommonFunctions
 
-    # @return [String]
-    attr_accessor :id
-    alias :termid= :id=
-    alias :identifier= :id=
+    attribute :data, ManagedConceptData
 
-    attr_accessor :uuid
+    attribute :related, RelatedConcept, collection: true
+    attribute :dates, ConceptDate, collection: true
+    attribute :sources, ConceptSource
+    attribute :date_accepted, ConceptDate
+    # TODO: convert to LocalizedConceptCollection when custom
+    #       collections are implemented in lutaml-model
+    attribute :status, :string,
+              values: Glossarist::GlossaryDefinition::CONCEPT_STATUSES
 
-    # @return [Array<RelatedConcept>]
-    attr_reader :related
+    attribute :identifier, :string
+    alias :id :identifier
+    alias :id= :identifier=
 
-    # @return [String]
-    register_enum :status, Glossarist::GlossaryDefinition::CONCEPT_STATUSES
+    attribute :uuid, :string
 
-    # return [Array<ConceptDate>]
-    attr_reader :dates
+    yaml do
+      map :data, to: :data
+      map :id, with: { to: :identifier_to_yaml, from: :identifier_from_yaml }
+      map :identifier,
+          with: { to: :identifier_to_yaml, from: :identifier_from_yaml }
+      map :related, to: :related
+      map :dates, to: :dates
+      map %i[date_accepted dateAccepted], with: { from: :date_accepted_from_yaml, to: :date_accepted_to_yaml }
+      map :status, to: :status
 
-    # return [Array<LocalizedConcept>]
-    attr_reader :localized_concepts
-
-    # Concept group
-    # @return [Array<String>]
-    attr_reader :groups
-
-    # List of authorative sources.
-    # @return [Array<ConceptSource>]
-    attr_reader :sources
+      map :uuid, to: :uuid, with: { from: :uuid_from_yaml, to: :uuid_to_yaml }
+    end
 
-    # All localizations for this concept.
-    #
-    # Keys are language codes and values are instances of {LocalizedConcept}.
-    # @return [Hash<String, LocalizedConcept>]
-    attr_reader :localizations
+    def localized_concepts
+      data.localized_concepts
+    end
 
-    def initialize(attributes = {})
-      @localizations = {}
-      @localized_concepts = {}
-      @localized_concept_class = Config.class_for(:localized_concept)
-      @uuid_namespace = Glossarist::Utilities::UUID::OID_NAMESPACE
+    def localized_concepts=(val)
+      data.localized_concepts = val
+    end
 
-      attributes = symbolize_keys(attributes)
-      @uuid = attributes[:uuid]
+    def localizations
+      data.localizations
+    end
 
-      data = attributes.delete(:data) || {}
-      data["groups"] = attributes[:groups]
-      data["status"] = attributes[:status]
+    def localization(lang)
+      localizations[lang]
+    end
+    alias :l10n :localization
 
-      data = symbolize_keys(data.compact)
+    def date_accepted_from_yaml(model, value)
+      model.dates ||= []
+      model.dates << ConceptDate.of_yaml({ "date" => value,
+                                           "type" => "accepted" })
+    end
 
-      super(slice_keys(data, managed_concept_attributes))
+    def date_accepted_to_yaml(model, doc)
+      doc["date_accepted"] = model.date_accepted.date if model.date_accepted
     end
 
-    def uuid
-      @uuid ||= Glossarist::Utilities::UUID.uuid_v5(@uuid_namespace, to_h_no_uuid.to_yaml)
+    def uuid_to_yaml(model, doc)
+      doc["id"] = model.uuid if model.uuid
     end
 
-    def related=(related)
-      @related = related&.map { |r| RelatedConcept.new(r) }
+    def uuid_from_yaml(model, value)
+      model.uuid = value if value
     end
 
-    def dates=(dates)
-      @dates = dates&.map { |d| ConceptDate.new(d) }
+    def uuid
+      @uuid ||= Glossarist::Utilities::UUID.uuid_v5(
+        Glossarist::Utilities::UUID::OID_NAMESPACE,
+        to_yaml(except: [:uuid]),
+      )
     end
 
-    def groups=(groups)
-      return unless groups
+    def identifier_to_yaml(model, doc)
+      value = model.identifier || model.id
+      doc["id"] = value if value && !doc["id"]
+    end
 
-      @groups = groups.is_a?(Array) ? groups : [groups]
+    def identifier_from_yaml(model, value)
+      model.identifier = value || model.identifier
     end
 
-    def localized_concepts=(localized_concepts)
-      return unless localized_concepts
+    def localized_concepts=(localized_concepts_collection)
+      return unless localized_concepts_collection
 
-      if localized_concepts.is_a?(Hash)
-        @localized_concepts = stringify_keys(localized_concepts)
+      if localized_concepts_collection.is_a?(Hash)
+        @localized_concepts = stringify_keys(localized_concepts_collection)
       else
-        localized_concepts.each do |localized_concept_hash|
-          lang = localized_concept_hash["language_code"].to_s
+        localized_concepts_collection.each do |localized_concept_hash|
+          lang = localized_concept_hash.dig("data", "language_code").to_s
 
           localized_concept = add_localization(
-            @localized_concept_class.new(localized_concept_hash["data"] || localized_concept_hash),
+            Config.class_for(:localized_concept).of_yaml(localized_concept_hash),
           )
 
           @localized_concepts[lang] = localization(lang).uuid
@@ -93,72 +104,22 @@ module Glossarist
         end
       end
     end
-
-    def sources=(sources)
-      @sources = sources&.map do |source|
-        ConceptSource.new(source)
-      end || []
-    end
-
-    def localizations=(localizations)
-      return unless localizations
-
-      @localizations = {}
-
-      localizations.each do |localized_concept|
-        unless localized_concept.is_a?(@localized_concept_class)
-          localized_concept = @localized_concept_class.new(
-            localized_concept["data"] || localized_concept,
-          )
-        end
-
-        add_l10n(localized_concept)
-      end
-    end
-
-    def localizations_hash
-      @localizations.map do |key, localized_concept|
-        [key, localized_concept.to_h]
-      end.to_h
-    end
+    attr_reader :localized_concepts
 
     # Adds concept localization.
     # @param localized_concept [LocalizedConcept]
     def add_localization(localized_concept)
       lang = localized_concept.language_code
-      @localized_concepts[lang] = @localized_concepts[lang] || localized_concept.uuid
+      @localized_concepts ||= {}
+      @localized_concepts[lang] =
+        @localized_concepts[lang] || localized_concept.uuid
       localizations.store(lang, localized_concept)
     end
-
     alias :add_l10n :add_localization
 
     # Returns concept localization.
     # @param lang [String] language code
     # @return [LocalizedConcept]
-    def localization(lang)
-      localizations[lang]
-    end
-
-    alias :l10n :localization
-
-    def to_h_no_uuid
-      {
-        "data" => {
-          "identifier" => id,
-          "localized_concepts" => localized_concepts.empty? ? nil : localized_concepts,
-          "groups" => groups,
-          "sources" => sources&.map(&:to_h),
-        }.compact,
-        "related" => related&.map(&:to_h),
-        "date_accepted" => date_accepted&.date,
-        "status" => status,
-      }.compact
-    end
-
-    def to_h
-      to_h_no_uuid.merge("id" => uuid)
-    end
-
     def default_designation
       localized = localization("eng") || localizations.values.first
       terms = localized&.preferred_terms&.first || localized&.terms&.first
@@ -167,47 +128,13 @@ module Glossarist
 
     def default_definition
       localized = localization("eng") || localizations.values.first
-      localized&.definition&.first&.content
+      localized&.data&.definition&.first&.content
     end
 
     def default_lang
       localization("eng") || localizations.values.first
     end
 
-    def date_accepted=(date)
-      date_hash = {
-        "type" => "accepted",
-        "date" => date,
-      }
-
-      @dates ||= []
-      @dates << ConceptDate.new(date_hash)
-    end
-
-    def date_accepted
-      return nil unless @dates
-      @dates.find { |date| date.accepted? }
-    end
-
-    def managed_concept_attributes
-      %i[
-        data
-        id
-        identifier
-        uuid
-        related
-        status
-        dates
-        date_accepted
-        dateAccepted
-        localized_concepts
-        localizedConcepts
-        localizations
-        groups
-        sources
-      ].compact
-    end
-
     Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES.each do |type|
       # List of related concepts of the specified type.
       # @return [Array<RelatedConcept>]

data/lib/glossarist/managed_concept_collection.rb

@@ -1,36 +1,23 @@
-# frozen_string_literal: true
-
 module Glossarist
   class ManagedConceptCollection
     include Enumerable
 
+    attr_accessor :managed_concepts
+
     def initialize
-      @managed_concepts = {}
+      @managed_concepts = []
       @managed_concepts_ids = {}
       @concept_manager = ConceptManager.new
     end
 
-    # @return [Array<ManagedConcept>]
-    def managed_concepts
-      @managed_concepts.values
-    end
-
-    def managed_concepts=(managed_concepts = [])
-      managed_concepts.each do |managed_concept|
-        store(Config.class_for(:managed_concept).new(managed_concept))
-      end
-
-      @managed_concepts.values
-    end
-
     def to_h
       {
-        "managed_concepts" => managed_concepts.map(&:to_h),
+        "managed_concepts" => managed_concepts.map(&:to_yaml_hash),
       }.compact
     end
 
     def each(&block)
-      @managed_concepts.each_value(&block)
+      @managed_concepts.each(&block)
     end
 
     # Returns concept with given ID, if it is present in collection, or +nil+
@@ -40,9 +27,10 @@ module Glossarist
     #    ManagedConcept ID
     # @return [ManagedConcept, nil]
     def fetch(id)
-      @managed_concepts[id] || @managed_concepts[@managed_concepts_ids[id]]
+      @managed_concepts.find do |c|
+        c.uuid == id || c.uuid == @managed_concepts_ids[id]
+      end
     end
-
     alias :[] :fetch
 
     # If ManagedConcept with given ID is present in this collection, then
@@ -53,7 +41,7 @@ module Glossarist
     #    ManagedConcept ID
     # @return [ManagedConcept]
     def fetch_or_initialize(id)
-      fetch(id) or store(Config.class_for(:managed_concept).new(data: { id: id }))
+      fetch(id) or store(Config.class_for(:managed_concept).of_yaml(data: { id: id }))
     end
 
     # Adds concept to the collection. If collection contains a concept with
@@ -62,12 +50,15 @@ module Glossarist
     # @param managed_concept [ManagedConcept]
     #   ManagedConcept about to be added
     def store(managed_concept)
-      @managed_concepts[managed_concept.uuid] = managed_concept
-      @managed_concepts_ids[managed_concept.id] = managed_concept.uuid if managed_concept.id
+      @managed_concepts ||= []
+      @managed_concepts << managed_concept
+      if managed_concept.data.id
+        @managed_concepts_ids[managed_concept.data.id] =
+          managed_concept.uuid
+      end
 
       managed_concept
     end
-
     alias :<< :store
 
     def load_from_files(path)

data/lib/glossarist/managed_concept_data.rb

@@ -0,0 +1,47 @@
+module Glossarist
+  class ManagedConceptData < Lutaml::Model::Serializable
+    include Glossarist::Utilities::CommonFunctions
+
+    attribute :id, :string
+    attribute :localized_concepts, :hash
+    attribute :groups, :string, collection: true
+    attribute :sources, ConceptSource, collection: true
+    attribute :localizations, :hash, collection: true, default: -> { {} }
+
+    yaml do
+      map %i[id identifier], to: :id,
+                             with: { to: :id_to_yaml, from: :id_from_yaml }
+      map %i[localized_concepts localizedConcepts], to: :localized_concepts
+      map :groups, to: :groups
+      map :sources, to: :sources
+      map :localizations, to: :localizations,
+                          with: { from: :localizations_from_yaml, to: :localizations_to_yaml }
+    end
+
+    def id_to_yaml(model, doc)
+      value = model.id || model.identifier
+      doc["identifier"] = value if value && !doc["identifier"]
+    end
+
+    def id_from_yaml(model, value)
+      model.id = value unless model.id
+    end
+
+    def localizations_from_yaml(model, value)
+      model.localizations ||= {}
+
+      value.each do |localized_concept_hash|
+        localized_concept = Glossarist::LocalizedConcept.of_yaml(localized_concept_hash)
+        model.localizations[localized_concept.language_code] = localized_concept
+      end
+    end
+
+    def localizations_to_yaml(model, doc); end
+
+    def authoritative_source
+      return [] unless sources
+
+      sources.select(&:authoritative?)
+    end
+  end
+end

data/lib/glossarist/non_verb_rep.rb

@@ -1,18 +1,15 @@
-# frozen_string_literal: true
-
 module Glossarist
-  class NonVerbRep
-    attr_accessor :image
-    attr_accessor :table
-    attr_accessor :formula
-
-    # @return [Array<ConceptSource>]
-    attr_reader :sources
+  class NonVerbRep < Lutaml::Model::Serializable
+    attribute :image, :string
+    attribute :table, :string
+    attribute :formula, :string
+    attribute :sources, ConceptSource, collection: true
 
-    def sources=(sources)
-      @sources = sources&.map do |source|
-        ConceptSource.new(source)
-      end
+    yaml do
+      map :image, to: :image
+      map :table, to: :table
+      map :formula, to: :formula
+      map :sources, to: :sources
     end
   end
 end

data/lib/glossarist/related_concept.rb

@@ -1,31 +1,24 @@
 # frozen_string_literal: true
 
 module Glossarist
-  class RelatedConcept < Model
-    include Glossarist::Utilities::Enum
+  class RelatedConcept < Lutaml::Model::Serializable
+    attribute :content, :string
+    attribute :type, :string,
+              values: Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES
+    attribute :ref, Citation
 
-    register_enum :type, Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES
-
-    # @return [String]
-    attr_accessor :content
-
-    # Reference to the related concept.
-    # @return [Citation]
-    attr_reader :ref
-
-    def ref=(ref)
-      @ref = Citation.new(ref)
+    yaml do
+      map :content, to: :content
+      map :type, to: :type
+      map :ref, with: { from: :ref_from_yaml, to: :ref_to_yaml }
     end
 
-    def to_h
-      reference = ref&.to_h
-      reference&.merge!(reference&.delete("ref"))
+    def ref_to_yaml(model, doc)
+      doc["ref"] = Citation.as_yaml(model.ref)["ref"] if model.ref
+    end
 
-      {
-        "type" => type.to_s,
-        "content" => content,
-        "ref" => reference,
-      }.compact
+    def ref_from_yaml(model, value)
+      model.ref = Citation.of_yaml(value)
     end
   end
 end

data/lib/glossarist/utilities/uuid.rb

@@ -21,12 +21,13 @@ module Glossarist
       #
       # See RFC 4122 for details of UUID at: https://www.ietf.org/rfc/rfc4122.txt
       def self.uuid_from_hash(hash_class, namespace, name)
-        if hash_class == Digest::MD5 || hash_class == OpenSSL::Digest::MD5
+        if [Digest::MD5, OpenSSL::Digest::MD5].include?(hash_class)
           version = 3
-        elsif hash_class == Digest::SHA1 || hash_class == OpenSSL::Digest::SHA1
+        elsif [Digest::SHA1, OpenSSL::Digest::SHA1].include?(hash_class)
           version = 5
         else
-          raise ArgumentError, "Expected OpenSSL::Digest::SHA1 or OpenSSL::Digest::MD5, got #{hash_class.name}."
+          raise ArgumentError,
+                "Expected OpenSSL::Digest::SHA1 or OpenSSL::Digest::MD5, got #{hash_class.name}."
         end
 
         uuid_namespace = pack_uuid_namespace(namespace)
@@ -58,12 +59,16 @@ module Glossarist
       end
 
       def self.pack_uuid_namespace(namespace)
-        if [DNS_NAMESPACE, OID_NAMESPACE, URL_NAMESPACE, X500_NAMESPACE].include?(namespace)
+        if [DNS_NAMESPACE, OID_NAMESPACE, URL_NAMESPACE,
+            X500_NAMESPACE].include?(namespace)
           namespace
         else
           match_data = namespace.match(/\A(\h{8})-(\h{4})-(\h{4})-(\h{4})-(\h{4})(\h{8})\z/)
 
-          raise ArgumentError, "Only UUIDs are valid namespace identifiers" unless match_data.present?
+          unless match_data.present?
+            raise ArgumentError,
+                  "Only UUIDs are valid namespace identifiers"
+          end
 
           match_data.captures.map { |s| s.to_i(16) }.pack("NnnnnN")
         end

data/lib/glossarist/utilities.rb

@@ -1,6 +1,4 @@
 # frozen_string_literal: true
 
-require_relative "utilities/enum"
-require_relative "utilities/boolean_attributes"
 require_relative "utilities/common_functions"
 require_relative "utilities/uuid"

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "2.3.0"
+  VERSION = "2.3.2"
 end

data/lib/glossarist.rb

@@ -5,28 +5,29 @@
 
 require "psych"
 require "thor"
+require "lutaml/model"
 
 require_relative "glossarist/utilities"
 require_relative "glossarist/version"
 require_relative "glossarist/glossary_definition"
 
+require_relative "glossarist/designation"
 require_relative "glossarist/asset"
-require_relative "glossarist/model"
-require_relative "glossarist/concept_date"
-require_relative "glossarist/detailed_definition"
-require_relative "glossarist/related_concept"
 require_relative "glossarist/citation"
+require_relative "glossarist/collection"
+require_relative "glossarist/concept_date"
+require_relative "glossarist/concept_manager"
 require_relative "glossarist/concept_set"
 require_relative "glossarist/concept_source"
-require_relative "glossarist/collection"
-require_relative "glossarist/designation"
+require_relative "glossarist/detailed_definition"
+require_relative "glossarist/related_concept"
+require_relative "glossarist/concept_data"
 require_relative "glossarist/concept"
 require_relative "glossarist/localized_concept"
-require_relative "glossarist/managed_concept_collection"
-require_relative "glossarist/concept_manager"
+require_relative "glossarist/managed_concept_data"
 require_relative "glossarist/managed_concept"
+require_relative "glossarist/managed_concept_collection"
 require_relative "glossarist/non_verb_rep"
-require_relative "glossarist/v1_reader"
 
 require_relative "glossarist/collections"
 

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.3.2
 platform: ruby
 authors:
 - Ribose
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-19 00:00:00.000000000 Z
+date: 2025-02-13 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: lutaml-model
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: relaton
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +52,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - open.source@ribose.com
 executables:
@@ -53,6 +67,7 @@ files:
 - ".hound.yml"
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
 - Gemfile
 - LICENSE.txt
 - README.adoc
@@ -70,6 +85,7 @@ files:
 - lib/glossarist/collections/collection.rb
 - lib/glossarist/collections/designation_collection.rb
 - lib/glossarist/concept.rb
+- lib/glossarist/concept_data.rb
 - lib/glossarist/concept_date.rb
 - lib/glossarist/concept_manager.rb
 - lib/glossarist/concept_set.rb
@@ -92,18 +108,12 @@ files:
 - lib/glossarist/localized_concept.rb
 - lib/glossarist/managed_concept.rb
 - lib/glossarist/managed_concept_collection.rb
-- lib/glossarist/model.rb
+- lib/glossarist/managed_concept_data.rb
 - lib/glossarist/non_verb_rep.rb
 - lib/glossarist/related_concept.rb
 - lib/glossarist/utilities.rb
-- lib/glossarist/utilities/boolean_attributes.rb
 - lib/glossarist/utilities/common_functions.rb
-- lib/glossarist/utilities/enum.rb
-- lib/glossarist/utilities/enum/class_methods.rb
-- lib/glossarist/utilities/enum/enum_collection.rb
-- lib/glossarist/utilities/enum/instance_methods.rb
 - lib/glossarist/utilities/uuid.rb
-- lib/glossarist/v1_reader.rb
 - lib/glossarist/version.rb
 homepage: https://github.com/glossarist/glossarist-ruby
 licenses:
@@ -112,7 +122,7 @@ metadata:
   homepage_uri: https://github.com/glossarist/glossarist-ruby
   source_code_uri: https://github.com/glossarist/glossarist-ruby
   bug_tracker_uri: https://github.com/glossarist/glossarist-ruby/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,7 +138,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.3.27
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Concept models for terminology glossaries conforming ISO 10241-1.
 test_files: []