glossarist 2.3.0 → 2.3.2

data/lib/glossarist/concept.rb

@@ -1,244 +1,104 @@
-# frozen_string_literal: true
-
-# (c) Copyright 2021 Ribose Inc.
-#
-
 module Glossarist
-  class Concept < Model
-    # Concept ID.
-    # @return [String]
-    attr_reader :id
-
-    attr_writer :uuid
-
-    # Concept designations.
-    # @todo Alias +terms+ exists only for legacy reasons and will be removed.
-    # @return [Array<Designations::Base>]
-    attr_reader :designations
-    alias :terms :designations
-
-    # <<BasicDocument>>LocalizedString
-    # @return [String]
-    attr_accessor :domain
-
-    # <<BasicDocument>>LocalizedString
-    # @return [String]
-    attr_accessor :subject
-
-    # Concept definition.
-    # @return [Array<DetailedDefinition>]
-    attr_reader :definition
-
-    # Non verbal representation of the concept.
-    # @return [NonVerbRep]
-    attr_accessor :non_verb_rep
-
-    # Concept notes
-    # @return [Array<DetailedDefinition>]
-    attr_reader :notes
-
-    # Concept examples
-    # @return [Array<DetailedDefinition>]
-    attr_reader :examples
-
-    # Contains list of extended attributes
-    attr_accessor :extension_attributes
-
-    attr_accessor :lineage_source
-    attr_accessor :lineage_source_similarity
-
-    attr_accessor :release
-
-    def initialize(*args)
-      @localizations = {}
-      @sources = Glossarist::Collections::Collection.new(klass: ConceptSource)
-      @related = Glossarist::Collections::Collection.new(klass: RelatedConcept)
-      @definition = Glossarist::Collections::Collection.new(klass: DetailedDefinition)
-      @notes = Glossarist::Collections::Collection.new(klass: DetailedDefinition)
-      @examples = Glossarist::Collections::Collection.new(klass: DetailedDefinition)
-      @dates = Glossarist::Collections::Collection.new(klass: ConceptDate)
-
-      @designations = Glossarist::Collections::DesignationCollection.new
-      @extension_attributes = {}
-
-      normalize_args(args)
-
-      super
-    end
-
-    def uuid
-      @uuid ||= Glossarist::Utilities::UUID.uuid_v5(
-        Glossarist::Utilities::UUID::OID_NAMESPACE,
-        to_h_no_uuid.to_yaml,
-      )
+  class Concept < Lutaml::Model::Serializable
+    attribute :data, ConceptData, default: -> { ConceptData.new }
+    attribute :id, :string
+    attribute :uuid, :string
+    attribute :subject, :string
+    attribute :non_verb_rep, :string
+    attribute :extension_attributes, :string
+    attribute :lineage_source, :string
+    attribute :localizations, :hash
+    attribute :extension_attributes, :hash
+    attribute :termid, :string
+
+    yaml do
+      map :data, to: :data
+      map :termid, to: :termid
+      map :subject, to: :subject
+      map %i[non_verb_rep nonVerbRep], to: :non_verb_rep
+      map %i[extension_attributes extensionAttributes], to: :extension_attributes
+      map %i[lineage_source lineageSource], to: :lineage_source
+      map :localizations, to: :localizations
+      map %i[extension_attributes extensionAttributes], to: :extension_attributes
+
+      map %i[date_accepted dateAccepted], with: { from: :date_accepted_from_yaml, to: :date_accepted_to_yaml }
+      map :uuid, to: :uuid, with: { to: :uuid_to_yaml, from: :uuid_from_yaml }
+      map :id, to: :id, with: { to: :id_to_yaml, from: :id_from_yaml }
+      map :identifier, to: :id, with: { to: :id_to_yaml, from: :id_from_yaml }
+    end
+
+    def designations
+      data.terms
     end
+    alias :terms :designations
 
-    def id=(id)
-      # Some of the glossaries that are not generated using glossarist, contains ids that are integers
-      # so adding a temporary check until every glossary is updated using glossarist.
-      if !id.nil? && (id.is_a?(String) || id.is_a?(Integer))
-        @id = id
-      else
-        raise(Glossarist::Error, "Expect id to be a String or Integer, Got #{id.class} (#{id})")
-      end
+    def definition
+      data.definition
     end
 
-    alias :termid= :id=
-    alias :identifier= :id=
-
-    # List of authorative sources.
-    # @todo Alias +authoritative_source+ exists for legacy reasons and may be
-    #   removed.
-    # @return [Array<ConceptSource>]
-    attr_reader :sources
-
-    # return [Array<ConceptDate>]
-    attr_reader :dates
-
-    def examples=(examples)
-      @examples.clear!
-      examples&.each { |example| @examples << example }
+    def definition=(value)
+      data.definition = value
     end
 
-    def notes=(notes)
-      @notes.clear!
-      notes&.each { |note| @notes << note }
+    def sources
+      data.sources
     end
 
-    def definition=(definition)
-      @definition.clear!
-      definition&.each { |definition| @definition << definition }
+    def examples
+      data.examples
     end
 
-    def designations=(designations)
-      @designations.clear!
-      designations&.each { |designation| @designations << designation }
+    def notes
+      data.notes
     end
 
-    alias :terms= :designations=
-
     def preferred_designations
-      @designations.select(&:preferred?)
+      data.terms.select(&:preferred?)
     end
-
     alias :preferred_terms :preferred_designations
 
-    def dates=(dates)
-      @dates.clear!
-      dates&.each { |date| @dates << date }
-    end
-
-    def sources=(sources)
-      @sources.clear!
-      sources&.each { |source| @sources << source }
+    def date_accepted
+      data.date_accepted
     end
 
     def authoritative_source
-      @sources.select { |source| source.authoritative? }
-    end
-
-    def authoritative_source=(sources)
-      sources&.each do |source|
-        @sources << source.merge({ "type" => "authoritative" })
-      end
+      data.authoritative_source
     end
 
-    def date_accepted=(date)
-      date_hash = {
-        "type" => "accepted",
-        "date" => date,
-      }
-
-      @dates ||= []
-      @dates << ConceptDate.new(date_hash)
+    def uuid_to_yaml(model, doc)
+      doc["id"] = model.uuid if model.uuid
     end
 
-    def date_accepted
-      return nil unless @dates
-      @dates.find { |date| date.accepted? }
+    def uuid_from_yaml(model, value)
+      model.uuid = value
     end
 
-    def to_h_no_uuid
-      {
-        "data" => {
-          "dates" => dates&.map(&:to_h),
-          "definition" => definition&.map(&:to_h),
-          "examples" => examples&.map(&:to_h),
-          "id" => id,
-          "lineage_source_similarity" => lineage_source_similarity,
-          "notes" => notes&.map(&:to_h),
-          "release" => release,
-          "sources" => sources.empty? ? nil : sources&.map(&:to_h),
-          "terms" => (terms&.map(&:to_h) || []),
-          "related" => related&.map(&:to_h),
-          "domain" => domain,
-        }.compact,
-
-        "date_accepted" => date_accepted&.date,
-
-      }.compact
-    end
+    def id_to_yaml(model, doc); end
 
-    def to_h
-      to_h_no_uuid.merge("id" => uuid)
+    def id_from_yaml(model, value)
+      model.id = value
     end
 
-    # @deprecated For legacy reasons only.
-    #   Implicit conversion (i.e. {#to_hash} alias) will be removed soon.
-    alias :to_hash :to_h
-
-    # rubocop:disable Metrics/AbcSize, Style/RescueModifier
-    def self.from_h(hash)
-      new.tap do |concept|
-        concept.id = hash.dig("termid") || hash.dig("id")
-        concept.sources = hash.dig("sources")
-        concept.related = hash.dig("related")
-        concept.definition = hash.dig("definition")
-
-        hash.values
-          .grep(Hash)
-          .map { |subhash| Config.class_for(:localized_concept).from_h(subhash) rescue nil }
-          .compact
-
-        concept.related = hash.dig("related") || []
+    def date_accepted_to_yaml(model, doc)
+      if model.date_accepted
+        doc["date_accepted"] =
+          model.date_accepted.date.iso8601
       end
     end
-    # rubocop:enable Metrics/AbcSize, Style/RescueModifier
 
-    # All Related Concepts
-    # @return [Array<RelatedConcept>]
-    def related
-      @related.empty? ? nil : @related
-    end
+    def date_accepted_from_yaml(model, value)
+      return if model.date_accepted
 
-    def related=(related)
-      @related.clear!
-      related&.each { |r| @related << r }
-    end
-
-    Glossarist::GlossaryDefinition::CONCEPT_DATE_TYPES.each do |type|
-      # Sets the ConceptDate and add it to dates list of the specified type.
-      define_method("date_#{type}=") do |date|
-        date_hash = {
-          "type" => type,
-          "date" => date,
-        }
-        @dates ||= []
-        @dates << ConceptDate.new(date_hash)
-      end
+      model.data.dates ||= []
+      model.data.dates << ConceptDate.of_yaml({ "date" => value,
+                                                "type" => "accepted" })
     end
 
-    def normalize_args(args)
-      args.each do |arg|
-        data = arg.delete("data")
-
-        arg.merge!(data) if data
-
-        if arg["sources"]
-          arg.delete("authoritative_source")
-          arg.delete("authoritativeSource")
-        end
-      end
+    def uuid
+      @uuid ||= Glossarist::Utilities::UUID.uuid_v5(
+        Glossarist::Utilities::UUID::OID_NAMESPACE,
+        data.to_yaml,
+      )
     end
   end
 end

data/lib/glossarist/concept_data.rb

@@ -0,0 +1,66 @@
+module Glossarist
+  class ConceptData < Lutaml::Model::Serializable
+    include Glossarist::Utilities::CommonFunctions
+
+    attribute :dates, ConceptDate, collection: true
+    attribute :definition, DetailedDefinition, collection: true
+    attribute :examples, DetailedDefinition, collection: true
+    attribute :id, :string
+    attribute :lineage_source_similarity, :integer
+    attribute :notes, DetailedDefinition, collection: true
+    attribute :release, :string
+    attribute :sources, ConceptSource, collection: true
+    attribute :terms, Designation::Base, collection: true
+    attribute :related, RelatedConcept, collection: true
+    attribute :domain, :string
+    attribute :review_date, :date_time
+    attribute :review_decision_date, :date_time
+    attribute :review_decision_event, :string
+
+    # Concept Methods
+    # Language code should be exactly 3 char long.
+    # TODO: use min_length, max_length once added in lutaml-model
+    attribute :language_code, :string, pattern: /^.{3}$/
+    attribute :entry_status, :string
+
+    yaml do
+      map :dates, to: :dates
+      map :definition, to: :definition, render_nil: true
+      map :examples, to: :examples, render_nil: true
+      map :id, to: :id
+      map %i[lineage_source_similarity lineageSourceSimilarity], to: :lineage_source_similarity
+      map :notes, to: :notes, render_nil: true
+      map :release, to: :release
+      map :sources, to: :sources
+      map :terms, to: :terms,
+                  with: { from: :terms_from_yaml, to: :terms_to_yaml }
+      map :related, to: :related
+      map :domain, to: :domain
+      map %i[language_code languageCode], to: :language_code
+      map %i[entry_status entryStatus], to: :entry_status
+      map %i[review_date reviewDate], to: :review_date
+      map %i[review_decision_date reviewDecisionDate], to: :review_decision_date
+      map %i[review_decision_event reviewDecisionEvent], to: :review_decision_event
+    end
+
+    def terms_from_yaml(model, value)
+      model.terms = value.map { |v| Designation::Base.of_yaml(v) }
+    end
+
+    def terms_to_yaml(model, doc)
+      doc["terms"] = model.terms.map(&:to_yaml_hash)
+    end
+
+    def date_accepted
+      return nil unless dates
+
+      dates.find(&:accepted?)
+    end
+
+    def authoritative_source
+      return [] unless sources
+
+      sources.select(&:authoritative?)
+    end
+  end
+end

data/lib/glossarist/concept_date.rb

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 
 module Glossarist
-  class ConceptDate < Model
-    include Glossarist::Utilities::Enum
-
+  class ConceptDate < Lutaml::Model::Serializable
     # Iso8601 date
     # @return [String]
-    attr_accessor :date
-
-    register_enum :type, Glossarist::GlossaryDefinition::CONCEPT_DATE_TYPES
+    attribute :date, :date_time
+    attribute :type, :string,
+              values: Glossarist::GlossaryDefinition::CONCEPT_DATE_TYPES
 
-    def to_h
-      {
-        "date" => date,
-        "type" => type,
-      }.compact
+    yaml do
+      map :date, to: :date
+      map :type, to: :type
     end
   end
 end

data/lib/glossarist/concept_manager.rb

@@ -1,44 +1,35 @@
-# frozen_string_literal: true
-
 module Glossarist
-  class ConceptManager
-    # Path to concepts directory.
-    # @return [String]
-    attr_accessor :path
-    attr_accessor :localized_concepts_path
-
-    # @param path [String]
-    #   concepts directory path, either absolute or relative to CWD
-    def initialize(path: nil)
-      @path = path
+  class ConceptManager < Lutaml::Model::Serializable
+    attribute :path, :string
+    attribute :localized_concepts_path, :string
+
+    yaml do
+      map :path, to: :path
+      map %i[localized_concepts_path localizedConceptsPath], to: :localized_concepts_path
     end
 
-    # Reads all concepts from files.
     def load_from_files(collection: nil)
       collection ||= ManagedConceptCollection.new
 
       Dir.glob(concepts_glob) do |filename|
-        concept = if v1_collection?
-                    Glossarist::V1Reader.load_concept_from_file(filename)
-                  else
-                    load_concept_from_file(filename)
-                  end
+        concept = load_concept_from_file(filename)
 
         collection.store(concept)
       end
     end
 
-    # Writes all concepts to files.
     def save_to_files(managed_concepts)
-      managed_concepts.each_value &method(:save_concept_to_file)
+      managed_concepts.each &method(:save_concept_to_file)
     end
 
     def load_concept_from_file(filename)
-      concept_hash = Psych.safe_load(File.read(filename), permitted_classes: [Date, Time])
+      concept_hash = Psych.safe_load(File.read(filename),
+                                     permitted_classes: [Date, Time])
       concept_hash["uuid"] = concept_hash["id"] || File.basename(filename, ".*")
 
-      concept = Config.class_for(:managed_concept).new(concept_hash)
-      concept.localized_concepts.each do |_lang, id|
+      concept = Config.class_for(:managed_concept).of_yaml(concept_hash)
+
+      concept.data.localized_concepts.each_value do |id|
         localized_concept = load_localized_concept(id)
         concept.add_l10n(localized_concept)
       end
@@ -55,7 +46,7 @@ module Glossarist
       )
       concept_hash["uuid"] = id
 
-      Config.class_for(:localized_concept).new(concept_hash)
+      Config.class_for(:localized_concept).of_yaml(concept_hash)
     rescue Psych::SyntaxError => e
       raise Glossarist::ParseError.new(filename: filename, line: e.line)
     end
@@ -70,16 +61,14 @@ module Glossarist
       Dir.mkdir(localized_concept_dir) unless Dir.exist?(localized_concept_dir)
 
       filename = File.join(concept_dir, "#{concept.uuid}.yaml")
-      File.write(filename, Psych.dump(concept.to_h))
+      File.write(filename, concept.to_yaml)
 
       concept.localized_concepts.each do |lang, uuid|
         filename = File.join(localized_concept_dir, "#{uuid}.yaml")
-        File.write(filename, Psych.dump(concept.localization(lang).to_h))
+        File.write(filename, concept.localization(lang).to_yaml)
       end
     end
 
-    private
-
     def concepts_glob
       if v1_collection?
         File.join(path, "concept-*.{yaml,yml}")
@@ -116,7 +105,8 @@ module Glossarist
     end
 
     def v1_collection?
-      @v1_collection ||= !Dir.glob(File.join(path, "concept-*.{yaml,yml}")).empty?
+      @v1_collection ||= !Dir.glob(File.join(path,
+                                             "concept-*.{yaml,yml}")).empty?
     end
   end
 end

data/lib/glossarist/concept_set.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Glossarist
   class ConceptSet
     # a `Glossarist::ManagedConceptCollection` object
@@ -40,7 +42,7 @@ module Glossarist
         concept = concept_map[concept_name.strip.downcase]
 
         if concept.nil?
-           puts "  [Not Found]: #{concept_name.strip}"
+          puts "  [Not Found]: #{concept_name.strip}"
         else
           latex_template(concept)
         end
@@ -57,7 +59,7 @@ module Glossarist
 
     def latex_template(concept)
       <<~TEMPLATE
-        \\newglossaryentry{#{concept.default_designation.gsub('_', '-')}}
+        \\newglossaryentry{#{concept.default_designation.tr('_', '-')}}
         {
         name={#{concept.default_designation.gsub('_', '\_')}}
         description={#{normalize_definition(concept.default_definition)}}
@@ -66,8 +68,8 @@ module Glossarist
     end
 
     def normalize_definition(definition)
-      definition.gsub(/{{([^}]*)}}/) do |match|
-        "\\textbf{\\gls{#{Regexp.last_match[1].gsub('_', '-')}}}"
+      definition.gsub(/{{([^}]*)}}/) do |_match|
+        "\\textbf{\\gls{#{Regexp.last_match[1].tr('_', '-')}}}"
       end
     end
 

data/lib/glossarist/concept_source.rb

@@ -1,62 +1,19 @@
-# frozen_string_literal: true
-
 module Glossarist
-  class ConceptSource < Model
-    include Glossarist::Utilities::Enum
-    include Glossarist::Utilities::CommonFunctions
-
-    register_enum :status, Glossarist::GlossaryDefinition::CONCEPT_SOURCE_STATUSES
-    register_enum :type, Glossarist::GlossaryDefinition::CONCEPT_SOURCE_TYPES
-
-    attr_reader :origin
-    alias_method :ref, :origin
-
-    attr_accessor :modification
-
-    def initialize(attributes = {})
-      if rel = attributes.delete("relationship")
-        self.status = rel["type"]
-        self.modification = rel["modification"]
-      end
-
-      self.origin = slice_keys(attributes, ref_param_names)
-
-      remaining_attributes = attributes.dup
-      ref_param_names.each { |k| remaining_attributes.delete(k) }
-
-      super(remaining_attributes)
-    end
-
-    def origin=(origin)
-      @origin = Citation.new(origin)
-    end
-
-    alias_method :ref=, :origin=
-
-    def to_h
-      origin_hash = self.origin.to_h.empty? ? nil : self.origin.to_h
-
-      {
-        "origin" => origin_hash,
-        "type" => type.to_s,
-        "status" => status&.to_s,
-        "modification" => modification,
-      }.compact
-    end
-
-    private
-
-    def ref_param_names
-      %w[
-        ref
-        text
-        source
-        id
-        version
-        clause
-        link
-        original
-      ]
+  class ConceptSource < Lutaml::Model::Serializable
+    attribute :status, :string,
+              values: Glossarist::GlossaryDefinition::CONCEPT_SOURCE_STATUSES
+    attribute :type, :string,
+              values: Glossarist::GlossaryDefinition::CONCEPT_SOURCE_TYPES
+    attribute :origin, Citation
+    attribute :modification, :string
+
+    yaml do
+      # TODO: change to `map [:ref, :origin], to: :origin
+      #       when multiple key mapping is supported in lutaml-model
+      map :origin, to: :origin
+      map :status, to: :status
+      map :type, to: :type
+      map :modification, to: :modification
     end
   end
 end

data/lib/glossarist/config.rb

@@ -42,19 +42,19 @@ module Glossarist
 
     class << self
       def class_for(name)
-        self.instance.class_for(name)
+        instance.class_for(name)
       end
 
       def extension_attributes
-        self.instance.extension_attributes
+        instance.extension_attributes
       end
 
       def register_class(class_name, klass)
-        self.instance.register_class(class_name, klass)
+        instance.register_class(class_name, klass)
       end
 
       def register_extension_attributes(attributes)
-        self.instance.register_extension_attributes(attributes)
+        instance.register_extension_attributes(attributes)
       end
     end
   end

data/lib/glossarist/designation/abbreviation.rb

@@ -1,26 +1,25 @@
-# frozen_string_literal: true
-
-require_relative "expression"
-require_relative "../utilities"
-
 module Glossarist
   module Designation
     class Abbreviation < Expression
-      include Glossarist::Utilities::Enum
-
-      register_enum :type, Glossarist::GlossaryDefinition::ABBREVIATION_TYPES
+      attribute :international, :boolean
+      attribute :type, :string, default: -> { "abbreviation" }
 
-      attr_accessor :international
+      Glossarist::GlossaryDefinition::ABBREVIATION_TYPES.each do |name|
+        attribute name.to_sym, :boolean
+      end
 
-      def to_h
-        type_hash = {
-          "type" => "abbreviation",
-          "international" => international,
-        }
+      yaml do
+        map :international, to: :international
+        map :type, to: :type, render_default: true
+        Glossarist::GlossaryDefinition::ABBREVIATION_TYPES.each do |name|
+          map name.to_sym, to: name.to_sym
+        end
+      end
 
-        type_hash[type.to_s] = true if type
+      def self.of_yaml(hash, options = {})
+        hash["type"] = "abbreviation" unless hash["type"]
 
-        super().merge(type_hash).compact
+        super
       end
     end
   end