glossarist 2.3.0 → 2.3.1

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 :lineage_source_similarity, 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 :language_code, to: :language_code
+      map :entry_status, to: :entry_status
+      map :review_date, to: :review_date
+      map :review_decision_date, to: :review_decision_date
+      map :review_decision_event, 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 :localized_concepts_path, 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

data/lib/glossarist/designation/base.rb

@@ -1,35 +1,36 @@
-# frozen_string_literal: true
-
 module Glossarist
   module Designation
-    class Base < Model
-      include Glossarist::Utilities::Enum
-
-      # @note This is not entirely aligned with agreed schema and may be
-      #   changed.
-      attr_accessor :designation
+    class Base < Lutaml::Model::Serializable
+      attribute :designation, :string
+      attribute :geographical_area, :string
+      attribute :normative_status, :string,
+                values: Glossarist::GlossaryDefinition::DESIGNATION_BASE_NORMATIVE_STATUSES
+      attribute :type, :string
 
-      attr_accessor :geographical_area
-      register_enum :normative_status, Glossarist::GlossaryDefinition::DESIGNATION_BASE_NORMATIVE_STATUSES
+      yaml do
+        map :type, to: :type
+        map :normative_status, to: :normative_status
+        map :geographical_area, to: :geographical_area
+        map :designation, to: :designation
+      end
 
-      def self.from_h(hash)
+      def self.of_yaml(hash, options = {})
         type = hash["type"]
 
         if type.nil? || /\w/ !~ type
           raise ArgumentError, "designation type is missing"
         end
 
-        designation_subclass = SERIALIZED_TYPES[type]
-
         if self == Base
           # called on Base class, delegate it to proper subclass
-          SERIALIZED_TYPES[type].from_h(hash)
+          SERIALIZED_TYPES[type].of_yaml(hash)
         else
           # called on subclass, instantiate object
           unless SERIALIZED_TYPES[self] == type
             raise ArgumentError, "unexpected designation type: #{type}"
           end
-          super(hash.reject { |k, _| k == "type" })
+
+          super(hash, options)
         end
       end
     end

data/lib/glossarist/designation/expression.rb

@@ -1,24 +1,26 @@
-# frozen_string_literal: true
-
 require_relative "base"
+require_relative "grammar_info"
 
 module Glossarist
   module Designation
     class Expression < Base
-      attr_accessor :prefix
-      attr_accessor :usage_info
-
-      # List of grammar info.
-      # @return [Array<GrammarInfo>]
-      attr_reader :grammar_info
-
-      def grammar_info=(grammar_info)
-        @grammar_info = grammar_info.map { |g| GrammarInfo.new(g) }
+      attribute :prefix, :string
+      attribute :usage_info, :string
+
+      attribute :gender, :string
+      attribute :plurality, :string
+      attribute :part_of_speech, :string
+      attribute :grammar_info, GrammarInfo, collection: true
+      attribute :type, :string, default: -> { "expression" }
+
+      yaml do
+        map :type, to: :type, render_default: true
+        map :prefix, to: :prefix
+        map :usage_info, to: :usage_info
+        map :grammar_info, to: :grammar_info
       end
 
-      # @todo Added to cater for current iev-data implementation,
-      #   might be removed in the future.
-      def self.from_h(hash)
+      def self.of_yaml(hash, options = {})
         gender = hash.delete("gender") || hash.delete(:gender)
         number = hash.delete("plurality") || hash.delete(:plurality)
         part_of_speech = hash.delete("part_of_speech") || hash.delete(:part_of_speech)
@@ -31,19 +33,9 @@ module Glossarist
           }.compact]
         end
 
-        super
-      end
+        hash["type"] = "expression" unless hash["type"]
 
-      def to_h
-        {
-          "type" => "expression",
-          "prefix" => prefix,
-          "normative_status" => normative_status,
-          "usage_info" => usage_info,
-          "designation" => designation,
-          "geographical_area" => geographical_area,
-          "grammar_info" => grammar_info&.map(&:to_h),
-        }.compact
+        super(hash, options)
       end
     end
   end

data/lib/glossarist/designation/grammar_info.rb

@@ -1,57 +1,41 @@
-# frozen_string_literal: true
-
-require_relative "../utilities"
-
 module Glossarist
   module Designation
-    class GrammarInfo
-      include Glossarist::Utilities::Enum
-      include Glossarist::Utilities::BooleanAttributes
-      include Glossarist::Utilities::CommonFunctions
-
-      register_enum :gender, Glossarist::GlossaryDefinition::GRAMMAR_INFO_GENDERS, multiple: true
-      register_enum :number, Glossarist::GlossaryDefinition::GRAMMAR_INFO_NUMBERS, multiple: true
-
-      register_boolean_attributes Glossarist::GlossaryDefinition::GRAMMAR_INFO_BOOLEAN_ATTRIBUTES
-
-      def initialize(options = {})
-        sanitized_options(options).each do |attr, value|
-          public_send("#{attr}=", value)
+    class GrammarInfo < Lutaml::Model::Serializable
+      attribute :gender, :string,
+                values: Glossarist::GlossaryDefinition::GRAMMAR_INFO_GENDERS, collection: true
+      attribute :number, :string,
+                values: Glossarist::GlossaryDefinition::GRAMMAR_INFO_NUMBERS, collection: true
+      attribute :part_of_speech, :string,
+                values: Glossarist::GlossaryDefinition::GRAMMAR_INFO_BOOLEAN_ATTRIBUTES
+
+      yaml do
+        map :gender, to: :gender
+        map :number, to: :number
+
+        map :part_of_speech,
+            with: { to: :part_of_speech_to_yaml,
+                    from: :part_of_speech_from_yaml }
+        Glossarist::GlossaryDefinition::GRAMMAR_INFO_BOOLEAN_ATTRIBUTES.each do |bool_attr|
+          map bool_attr,
+              with: { to: :"part_of_speech_#{bool_attr}_to_yaml",
+                      from: :"part_of_speech_#{bool_attr}_from_yaml" }
         end
       end
 
-      def part_of_speech=(pos)
-        public_send("#{pos}=", pos)
+      def part_of_speech_from_yaml(model, value)
+        model.part_of_speech = value
       end
 
-      def to_h
-        {
-          "preposition" => preposition?,
-          "participle" => participle?,
-          "adj" => adj?,
-          "verb" => verb?,
-          "adverb" => adverb?,
-          "noun" => noun?,
-          "gender" => gender,
-          "number" => number,
-        }
-      end
+      def part_of_speech_to_yaml(model, doc); end
 
-      private
+      Glossarist::GlossaryDefinition::GRAMMAR_INFO_BOOLEAN_ATTRIBUTES.each do |bool_attr|
+        define_method(:"part_of_speech_#{bool_attr}_from_yaml") do |model, value|
+          model.public_send("#{bool_attr}=", value)
+        end
 
-      def sanitized_options(options)
-        hash = symbolize_keys(options)
-        slice_keys(hash, [
-          :gender,
-          :number,
-          :preposition,
-          :participle,
-          :adj,
-          :verb,
-          :adverb,
-          :noun,
-          :part_of_speech,
-        ])
+        define_method(:"part_of_speech_#{bool_attr}_to_yaml") do |model, doc|
+          doc[bool_attr] = model.public_send("#{bool_attr}?")
+        end
       end
     end
   end

data/lib/glossarist/designation/graphical_symbol.rb

@@ -1,16 +1,20 @@
-# frozen_string_literal: true
+require_relative "symbol"
 
 module Glossarist
   module Designation
     class GraphicalSymbol < Symbol
-      attr_accessor :text
-      attr_accessor :image
+      attribute :text, :string
+      attribute :image, :string
 
-      def to_h
-        super.merge(
-          "text" => text,
-          "image" => image,
-        )
+      yaml do
+        map :text, to: :text
+        map :image, to: :image
+      end
+
+      def self.of_yaml(hash, options = {})
+        hash["type"] = "graphical_symbol"
+
+        super
       end
     end
   end

data/lib/glossarist/designation/letter_symbol.rb

@@ -1,18 +1,20 @@
-# frozen_string_literal: true
-
 module Glossarist
   module Designation
     class LetterSymbol < Symbol
-      attr_accessor :text
-      attr_accessor :language
-      attr_accessor :script
+      attribute :text, :string
+      attribute :language, :string
+      attribute :script, :string
+
+      yaml do
+        map :text, to: :text
+        map :language, to: :language
+        map :script, to: :script
+      end
+
+      def self.of_yaml(hash, options = {})
+        hash["type"] = "letter_symbol"
 
-      def to_h
-        super.merge(
-          "text" => text,
-          "language" => language,
-          "script" => script,
-        )
+        super
       end
     end
   end

data/lib/glossarist/designation/symbol.rb

@@ -1,20 +1,18 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
 module Glossarist
   module Designation
     class Symbol < Base
-      attr_accessor :international
+      attribute :international, :boolean
+      attribute :type, :string
+
+      yaml do
+        map :international, to: :international
+        map :type, to: :type, render_default: true
+      end
+
+      def self.of_yaml(hash, options = {})
+        hash["type"] = "symbol" unless hash["type"]
 
-      def to_h
-        {
-          "type" => Glossarist::Designation::SERIALIZED_TYPES[self.class],
-          "normative_status" => normative_status,
-          "geographical_area" => geographical_area,
-          "designation" => designation,
-          "international" => international,
-        }.compact
+        super
       end
     end
   end