glossarist 2.3.0 → 2.3.2

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 %i[normative_status normativeStatus], to: :normative_status
+        map %i[geographical_area geographicalArea], 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 %i[usage_info usageInfo], to: :usage_info
+        map %i[grammar_info grammarInfo], 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,39 @@
-# 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 %i[part_of_speech partOfSpeech], 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

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,75 +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
-    alias_method :status=, :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 %i[review_type reviewType], to: :review_type
     end
 
-    def to_h_no_uuid # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      hash = super
-
-      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
+    alias_method :status=, :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