glossarist 2.2.1 → 2.3.1

data/lib/glossarist/designation.rb

@@ -3,9 +3,9 @@
 # (c) Copyright 2021 Ribose Inc.
 #
 
-require_relative "designation/abbreviation"
 require_relative "designation/base"
 require_relative "designation/expression"
+require_relative "designation/abbreviation"
 require_relative "designation/grammar_info"
 require_relative "designation/symbol"
 require_relative "designation/graphical_symbol"
@@ -21,7 +21,7 @@ module Glossarist
       GraphicalSymbol => "graphical_symbol",
       LetterSymbol => "letter_symbol",
     }
-    .tap { |h| h.merge!(h.invert) }
-    .freeze
+      .tap { |h| h.merge!(h.invert) }
+      .freeze
   end
 end

data/lib/glossarist/detailed_definition.rb

@@ -1,31 +1,13 @@
 # frozen_string_literal: true
 
 module Glossarist
-  class DetailedDefinition < Model
+  class DetailedDefinition < Lutaml::Model::Serializable
+    attribute :content, :string
+    attribute :sources, ConceptSource, collection: true
 
-    def initialize(attributes = {})
-      if attributes.is_a?(Hash)
-        super
-      else
-        self.content = attributes
-      end
-    end
-
-    # @return [String]
-    attr_accessor :content
-
-    # @return [Array<ConceptSource>]
-    attr_reader :sources
-
-    def sources=(sources)
-      @sources = sources.map { |s| ConceptSource.new(s) }
-    end
-
-    def to_h
-      {
-        "content" => content,
-        "sources" => sources&.map(&:to_h),
-      }.compact
+    yaml do
+      map :content, to: :content
+      map :sources, to: :sources
     end
   end
 end

data/lib/glossarist/error.rb

@@ -1,8 +1,8 @@
-require_relative "error/invalid_type_error"
-require_relative "error/invalid_language_code_error"
-require_relative "error/parse_error"
-
 module Glossarist
   class Error < StandardError
   end
 end
+
+require_relative "error/invalid_type_error"
+require_relative "error/invalid_language_code_error"
+require_relative "error/parse_error"

data/lib/glossarist/glossary_definition.rb

@@ -4,7 +4,8 @@ require "yaml"
 
 module Glossarist
   module GlossaryDefinition
-    config = YAML.load_file(File.expand_path("../../../config.yml", __FILE__)) || {}
+    config = YAML.load_file(File.expand_path("../../config.yml",
+                                             __dir__)) || {}
 
     CONCEPT_SOURCE_STATUSES = config.dig("concept_source", "status").freeze
 
@@ -14,13 +15,15 @@ module Glossarist
 
     ABBREVIATION_TYPES = config.dig("abbreviation", "type").freeze
 
-    GRAMMAR_INFO_BOOLEAN_ATTRIBUTES = config.dig("grammar_info", "boolean_attribute").freeze
+    GRAMMAR_INFO_BOOLEAN_ATTRIBUTES = config.dig("grammar_info",
+                                                 "boolean_attribute").freeze
 
     GRAMMAR_INFO_GENDERS = config.dig("grammar_info", "gender").freeze
 
     GRAMMAR_INFO_NUMBERS = config.dig("grammar_info", "number").freeze
 
-    DESIGNATION_BASE_NORMATIVE_STATUSES = config.dig("designation", "base", "normative_status").freeze
+    DESIGNATION_BASE_NORMATIVE_STATUSES = config.dig("designation", "base",
+                                                     "normative_status").freeze
 
     CONCEPT_DATE_TYPES = config.dig("concept_date", "type").freeze
 

data/lib/glossarist/localized_concept.rb

@@ -1,74 +1,30 @@
-# frozen_string_literal: true
-
-# (c) Copyright 2021 Ribose Inc.
-#
-
 module Glossarist
   class LocalizedConcept < Concept
-    # ISO 639-2 code for terminology.
-    # @see https://www.loc.gov/standards/iso639-2/php/code_list.php code list
-    # @return [String]
-    attr_reader :language_code
-
-    # Must be one of the following:
-    # +notValid+, +valid+, +superseded+, +retired+.
-    # @todo Proper type checking.
-    # @note Works with strings, but soon they may be replaced with symbols.
-    # @return [String]
-    attr_accessor :entry_status
-
-    # Must be one of the following:
-    # +preferred+, +admitted+, +deprecated+.
-    # @todo Proper type checking.
-    # @note Works with strings, but soon they may be replaced with symbols.
-    # @return [String]
-    attr_accessor :classification
-
-    # Temporary fields
-    # @todo Need to remove these once the isotc211-glossary is fixed
-    attr_accessor *%i[
-                    review_date
-                    review_decision_date
-                    review_decision_event
-                    review_type
-                  ]
+    attribute :classification, :string
+    attribute :review_type, :string
+    attribute :entry_status, :string
 
-    def language_code=(language_code)
-      if language_code.is_a?(String) && language_code.length == 3
-        @language_code = language_code
-      else
-        raise Glossarist::InvalidLanguageCodeError.new(code: language_code)
-      end
+    yaml do
+      map :classification, to: :classification
+      map :review_type, to: :review_type
     end
 
-    def to_h_no_uuid # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      hash = super
+    alias_method :status=, :entry_status=
 
-      hash["data"].merge!({
-        "language_code" => language_code,
-        "entry_status" => entry_status,
-        "sources" => sources.empty? ? nil : sources&.map(&:to_h),
-        "classification" => classification,
-        "dates" => dates&.map(&:to_h),
-        "review_date" => review_date,
-        "review_decision_date" => review_decision_date,
-        "review_decision_event" => review_decision_event,
-      }.compact).merge!(@extension_attributes)
-
-      hash["status"] = entry_status if entry_status
-
-      hash
+    def language_code
+      data.language_code
     end
 
-    def self.from_h(hash)
-      terms = hash["terms"]&.map { |h| Designation::Base.from_h(h) } || []
-      sources = hash["authoritative_source"]&.each { |source| source.merge({ "type" => "authoritative" }) }
+    def entry_status
+      data.entry_status
+    end
 
-      super(hash.merge({ "terms" => terms, "sources" => sources }))
+    def language_code=(value)
+      data.language_code = value
     end
 
-    # @deprecated For legacy reasons only.
-    #   Implicit conversion (i.e. {#to_hash} alias) will be removed soon.
-    alias :to_hash :to_h
+    def entry_status=(value)
+      data.entry_status = value
+    end
   end
 end

data/lib/glossarist/managed_concept.rb

@@ -1,90 +1,102 @@
-# 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 :date_accepted,
+          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 +105,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 +129,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