glossarist 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 351ee7a983e5566dab9124def66fef23e1a8517b463c695e72388d40939c6031
-  data.tar.gz: d7f4b103f7a60ed7bb80983d30d8f9bba281a1f6c8ec293dcd73eecdbec8e2bf
+  metadata.gz: 2545436241f3fc01daf4879682439d3f4650a44a45af855cc5260ad445caca0b
+  data.tar.gz: c62fb0db9a7d1dc9ec4ad4ea9015a53a413bfbc922be77db276e4739926615a6
 SHA512:
-  metadata.gz: 4614c9b4457b76d5f7936f9b43a6f97c8ceeb62442aafb4d865e3bdc8aa786493af6062a9cef48e3328085cf38a876822eb0dd48b8ac1d490ad166eeaaf8713e
-  data.tar.gz: dcdb5aca4bda8c3ebae41a7ef1c3cfcbf3c154fe2e0aa38ea8c1b76e175c08b7c3d070daddbb9e54e3079f324f7b229b5e6f60d77908e1689d05e35ac84347e5
+  metadata.gz: d611e1a09d99e64b7ad5e745d729fba2fe59d707f7f0469aa43fa3def04286c91128f5a65088f28943df550ef7eb6099d3354cadbafa7c68a93b08873512e2c1
+  data.tar.gz: c1e0ec90c6a41c9a4c26f8db587d0cfbb986fb3c2086494554fbde8dfc829abf0406d2bf4e123d85710c2e23c699ac82b0db9c5328f3498f3c378bd509617c81

data/config.yml

@@ -71,7 +71,9 @@ grammar_info:
 concept:
   status:
     - draft
+    - submitted
     - not_valid
+    - invalid
     - valid
     - superseded
     - retired

data/lib/glossarist/collections/collection.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Collections
+    class Collection
+      include Enumerable
+
+      attr_reader :collection
+
+      alias :size :count
+
+      def initialize(klass:)
+        @klass = klass
+        @collection = []
+      end
+
+      def <<(object)
+        @collection << @klass.new(object)
+      end
+
+      def each(&block)
+        @collection.each(&block)
+      end
+
+      def empty?
+        @collection.empty?
+      end
+
+      def clear!
+        @collection = []
+      end
+    end
+  end
+end

data/lib/glossarist/collections/designation_collection.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Collections
+    class DesignationCollection < Collection
+      def initialize
+        super(klass: Designation::Base)
+      end
+
+      def <<(object)
+        @collection << @klass.from_h(object)
+      end
+    end
+  end
+end

data/lib/glossarist/collections.rb

@@ -1,2 +1,4 @@
 require_relative "collections/asset_collection"
 require_relative "collections/bibliography_collection"
+require_relative "collections/collection"
+require_relative "collections/designation_collection"

data/lib/glossarist/concept.rb

@@ -9,6 +9,8 @@ module Glossarist
     # @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>]
@@ -42,23 +44,42 @@ module Glossarist
     # Contains list of extended attributes
     attr_accessor :extension_attributes
 
-    def initialize(*)
+    attr_accessor :lineage_source
+    attr_accessor :lineage_source_similarity
+
+    attr_accessor :release
+
+    def initialize(*args)
       @localizations = {}
-      @sources = []
-      @related = []
-      @notes = []
-      @designations = []
+      @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.to_yaml,
+      )
+    end
+
     def id=(id)
-      raise(Glossarist::Error, "id must be a string") unless id.is_a?(String) || id.nil?
+      raise(Glossarist::Error, "Expect id to be a string, Got #{id.class} (#{id})") unless id.is_a?(String) || id.nil?
 
       @id = id
     end
     alias :termid= :id=
+    alias :identifier= :id=
 
     # List of authorative sources.
     # @todo Alias +authoritative_source+ exists for legacy reasons and may be
@@ -71,33 +92,40 @@ module Glossarist
     attr_reader :dates
 
     def examples=(examples)
-      @examples = examples&.map { |e| DetailedDefinition.new(e) }
+      @examples.clear!
+      examples&.each { |example| @examples << example }
     end
 
     def notes=(notes)
-      @notes = notes&.map { |n| DetailedDefinition.new(n) }
+      @notes.clear!
+      notes&.each { |note| @notes << note }
     end
 
     def definition=(definition)
-      @definition = definition&.map { |d| DetailedDefinition.new(d) }
+      @definition.clear!
+      definition&.each { |definition| @definition << definition }
     end
 
     def designations=(designations)
-      @designations = designations&.map do |designation|
-        Designation::Base.from_h(designation)
-      end
+      @designations.clear!
+      designations&.each { |designation| @designations << designation }
     end
 
     alias :terms= :designations=
 
+    def preferred_designations
+      @designations.select(&:preferred?)
+    end
+    alias :preferred_terms :preferred_designations
+
     def dates=(dates)
-      @dates = dates&.map { |d| ConceptDate.new(d) }
+      @dates.clear!
+      dates&.each { |date| @dates << date }
     end
 
     def sources=(sources)
-      @sources = sources&.map do |source|
-        ConceptSource.new(source)
-      end || []
+      @sources.clear!
+      sources&.each { |source| @sources << source }
     end
 
     def authoritative_source=(sources)
@@ -108,14 +136,19 @@ module Glossarist
 
     def to_h
       {
-        "id" => id,
-        "related" => related&.map(&:to_h),
-        "terms" => (terms&.map(&:to_h) || []),
-        "definition" => definition&.map(&:to_h),
-        "notes" => notes&.map(&:to_h),
-        "examples" => examples&.map(&:to_h),
-      }
-      .compact
+        "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),
+        }.compact,
+      }.compact
     end
 
     # @deprecated For legacy reasons only.
@@ -147,7 +180,28 @@ module Glossarist
     end
 
     def related=(related)
-      @related = related&.map { |r| RelatedConcept.new(r) } || []
+      @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
+    end
+
+    def normalize_args(args)
+      args.each do |arg|
+        data = arg.delete("data")
+
+        arg.merge!(data) if data
+      end
     end
   end
 end

data/lib/glossarist/concept_date.rb

@@ -12,8 +12,8 @@ module Glossarist
 
     def to_h
       {
-        "type" => type,
         "date" => date,
+        "type" => type,
       }.compact
     end
   end

data/lib/glossarist/concept_manager.rb

@@ -17,7 +17,13 @@ module Glossarist
       collection ||= ManagedConceptCollection.new
 
       Dir.glob(concepts_glob) do |filename|
-        collection.store(load_concept_from_file(filename))
+        concept = load_concept_from_file(filename)
+        concept.localized_concepts.each do |_lang, id|
+          localized_concept = load_localized_concept(id)
+          concept.add_l10n(localized_concept)
+        end
+
+        collection.store(concept)
       end
     end
 
@@ -27,20 +33,49 @@ module Glossarist
     end
 
     def load_concept_from_file(filename)
-      ManagedConcept.new(Psych.safe_load(File.read(filename)))
+      concept_hash = Psych.safe_load(File.read(filename), permitted_classes: [Date])
+      concept_hash["uuid"] = concept_hash["id"] || File.basename(filename, ".*")
+      ManagedConcept.new(concept_hash)
+    rescue Psych::SyntaxError => e
+      raise Glossarist::ParseError.new(filename: filename, line: e.line)
+    end
+
+    def load_localized_concept(id)
+      concept_hash = Psych.safe_load(
+        File.read(localized_concept_path(id)),
+        permitted_classes: [Date],
+      )
+      concept_hash["uuid"] = id
+
+      Config.class_for(:localized_concept).new(concept_hash)
     rescue Psych::SyntaxError => e
       raise Glossarist::ParseError.new(filename: filename, line: e.line)
     end
 
     def save_concept_to_file(concept)
-      filename = File.join(path, "concept-#{concept.id}.yaml")
+      concept_dir = File.join(path, "concept")
+      localized_concept_dir = File.join(path, "localized_concept")
+
+      Dir.mkdir(concept_dir) unless Dir.exist?(concept_dir)
+      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))
+
+      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))
+      end
     end
 
     private
 
     def concepts_glob
-      File.join(path, "concept-*.{yaml,yml}")
+      File.join(path, "concept", "*.{yaml,yml}")
+    end
+
+    def localized_concept_path(id)
+      Dir.glob(File.join(path, "localized_concept", "#{id}.{yaml,yml}"))&.first
     end
   end
 end

data/lib/glossarist/concept_source.rb

@@ -37,9 +37,9 @@ module Glossarist
       origin_hash = self.origin.to_h.empty? ? nil : self.origin.to_h
 
       {
+        "origin" => origin_hash,
         "type" => type.to_s,
         "status" => status&.to_s,
-        "origin" => origin_hash,
         "modification" => modification,
       }.compact
     end

data/lib/glossarist/localized_concept.rb

@@ -24,15 +24,14 @@ module Glossarist
     # @return [String]
     attr_accessor :classification
 
-    attr_accessor :review_date
-    attr_accessor :review_decision_date
-    attr_accessor :review_decision_event
-
-    def initialize(*)
-      @examples = []
-
-      super
-    end
+    # 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
+    ]
 
     def language_code=(language_code)
       if language_code.is_a?(String) && language_code.length == 3
@@ -42,10 +41,12 @@ module Glossarist
       end
     end
 
-    def to_h # rubocop:disable Metrics/MethodLength
-      super.merge({
-        "language_code" => language_code,
+    def to_h # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      hash = super
+
+      hash["data"].merge!({
         "domain" => domain,
+        "language_code" => language_code,
         "entry_status" => entry_status,
         "sources" => sources.empty? ? nil : sources&.map(&:to_h),
         "classification" => classification,
@@ -54,11 +55,13 @@ module Glossarist
         "review_decision_date" => review_decision_date,
         "review_decision_event" => review_decision_event,
       }.compact).merge(@extension_attributes)
+
+      hash
     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"}) }
+      sources = hash["authoritative_source"]&.each { |source| source.merge({ "type" => "authoritative" }) }
 
       super(hash.merge({"terms" => terms, "sources" => sources}))
     end

data/lib/glossarist/managed_concept.rb

@@ -8,6 +8,9 @@ module Glossarist
     # @return [String]
     attr_accessor :id
     alias :termid= :id=
+    alias :identifier= :id=
+
+    attr_accessor :uuid
 
     # @return [Array<RelatedConcept>]
     attr_reader :related
@@ -29,24 +32,27 @@ module Glossarist
     #
     # Keys are language codes and values are instances of {LocalizedConcept}.
     # @return [Hash<String, LocalizedConcept>]
-    attr_accessor :localizations
+    attr_reader :localizations
 
     def initialize(attributes = {})
       @localizations = {}
-      self.localized_concepts = attributes.values.grep(Hash)
+      @localized_concepts = {}
+      @localized_concept_class = Config.class_for(:localized_concept)
+      @uuid_namespace = Glossarist::Utilities::UUID::OID_NAMESPACE
 
       attributes = symbolize_keys(attributes)
-      super(slice_keys(attributes, managed_concept_attributes))
-    end
+      @uuid = attributes[:uuid]
 
-    def localized_concepts=(localized_concepts_hash)
-      @localized_concepts = localized_concepts_hash.map { |l| Config.class_for(:localized_concept).new(l) }.compact
+      data = attributes.delete(:data) || {}
+      data["groups"] = attributes[:groups]
 
-      @localized_concepts.each do |l|
-        add_l10n(l)
-      end
+      data = symbolize_keys(data.compact)
 
-      @localized_concepts
+      super(slice_keys(data, managed_concept_attributes))
+    end
+
+    def uuid
+      @uuid ||= Glossarist::Utilities::UUID.uuid_v5(@uuid_namespace, to_h.to_yaml)
     end
 
     def related=(related)
@@ -63,10 +69,51 @@ module Glossarist
       @groups = groups.is_a?(Array) ? groups : [groups]
     end
 
+    def localized_concepts=(localized_concepts)
+      return unless localized_concepts
+
+      if localized_concepts.is_a?(Hash)
+        @localized_concepts = stringify_keys(localized_concepts)
+      else
+        localized_concepts.each do |localized_concept|
+          lang = localized_concept["language_code"].to_s
+
+          @localized_concepts[lang] = Glossarist::Utilities::UUID.uuid_v5(@uuid_namespace, localized_concept.to_h.to_yaml)
+
+          add_localization(
+            @localized_concept_class.new(localized_concept["data"] || localized_concept),
+          )
+        end
+      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
+
     # 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
       localizations.store(lang, localized_concept)
     end
 
@@ -83,17 +130,18 @@ module Glossarist
 
     def to_h
       {
-        "termid" => id,
-        "term" => default_designation,
-        "related" => related&.map(&:to_h),
-        "dates" => dates&.empty? ? nil : dates&.map(&:to_h),
-        "groups" => groups,
-      }.merge(localizations.transform_values(&:to_h)).compact
+        "data" => {
+          "identifier" => id,
+          "localized_concepts" => localized_concepts.empty? ? nil : localized_concepts,
+          "groups" => groups,
+        }.compact,
+      }.compact
     end
 
     def default_designation
       localized = localization("eng") || localizations.values.first
-      localized&.terms&.first&.designation
+      terms = localized&.preferred_terms&.first || localized&.terms&.first
+      terms&.designation
     end
 
     def default_definition
@@ -105,14 +153,34 @@ module Glossarist
       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
+      @dates.find { |date| date.accepted? }
+    end
+
     def managed_concept_attributes
       %i[
+        data
         id
-        termid
+        identifier
+        uuid
         related
         status
         dates
+        date_accepted
+        dateAccepted
         localized_concepts
+        localizedConcepts
+        localizations
         groups
       ].compact
     end

data/lib/glossarist/managed_concept_collection.rb

@@ -6,6 +6,7 @@ module Glossarist
 
     def initialize
       @managed_concepts = {}
+      @managed_concepts_ids = {}
       @concept_manager = ConceptManager.new
     end
 
@@ -39,7 +40,7 @@ module Glossarist
     #    ManagedConcept ID
     # @return [ManagedConcept, nil]
     def fetch(id)
-      @managed_concepts[id]
+      @managed_concepts[id] || @managed_concepts[@managed_concepts_ids[id]]
     end
 
     alias :[] :fetch
@@ -52,16 +53,17 @@ module Glossarist
     #    ManagedConcept ID
     # @return [ManagedConcept]
     def fetch_or_initialize(id)
-      fetch(id) or store(ManagedConcept.new(id: id))
+      fetch(id) or store(ManagedConcept.new(data: { id: id }))
     end
 
-    # Adds concept to the collection.  If collection contains a concept with
+    # Adds concept to the collection. If collection contains a concept with
     # the same ID already, that concept is replaced.
     #
     # @param managed_concept [ManagedConcept]
     #   ManagedConcept about to be added
     def store(managed_concept)
-      @managed_concepts[managed_concept.id] = managed_concept
+      @managed_concepts[managed_concept.uuid] = managed_concept
+      @managed_concepts_ids[managed_concept.id] = managed_concept.uuid if managed_concept.id
     end
 
     alias :<< :store

data/lib/glossarist/model.rb

@@ -18,7 +18,11 @@ module Glossarist
     def set_attribute(name, value)
       public_send("#{name}=", value)
     rescue NoMethodError
-      if Config.extension_attributes.include?(name)
+      # adding support for camel case
+      if name.match?(/[A-Z]/)
+        name = snake_case(name.to_s).to_sym
+        retry
+      elsif Config.extension_attributes.include?(name)
         extension_attributes[name] = value
       else
         raise ArgumentError, "#{self.class.name} does not have " +
@@ -29,5 +33,9 @@ module Glossarist
     def self.from_h(hash)
       new(hash)
     end
+
+    def snake_case(str)
+      str.gsub(/([A-Z])/) { "_#{$1.downcase}" }
+    end
   end
 end

data/lib/glossarist/utilities/common_functions.rb

@@ -9,7 +9,26 @@ module Glossarist
       def symbolize_keys(hash)
         result = {}
         hash.each_pair do |key, value|
-          result[key.to_sym] = value
+          result[key.to_sym] = if value.is_a?(Hash)
+                                 symbolize_keys(value)
+                               else
+                                 value
+                               end
+        end
+        result
+      end
+
+      # Hash#transform_keys is not available in Ruby 2.4
+      # so we have to do this ourselves :(
+      # symbolize hash keys
+      def stringify_keys(hash)
+        result = {}
+        hash.each_pair do |key, value|
+          result[key.to_s] = if value.is_a?(Hash)
+                               stringify_keys(value)
+                             else
+                               value
+                             end
         end
         result
       end
@@ -24,6 +43,22 @@ module Glossarist
         end
         result
       end
+
+      def convert_keys_to_snake_case(hash)
+        result = {}
+        hash.each_pair do |key, value|
+          result[snake_case(key)] = if value.is_a?(Hash)
+                                      convert_keys_to_snake_case(value)
+                                    else
+                                      value
+                                    end
+        end
+        result
+      end
+
+      def snake_case(str)
+        str.gsub(/([A-Z])/) { "_#{$1.downcase}" }
+      end
     end
   end
 end

data/lib/glossarist/utilities/uuid.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# extracted from https://github.com/rails/rails/blob/main/activesupport/lib/active_support/core_ext/digest/uuid.rb
+# to generate uuid_v5 for concept files
+
+require "securerandom"
+require "openssl"
+
+module Glossarist
+  module Utilities
+    module UUID
+      DNS_NAMESPACE  = "k\xA7\xB8\x10\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
+      URL_NAMESPACE  = "k\xA7\xB8\x11\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
+      OID_NAMESPACE  = "k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
+      X500_NAMESPACE = "k\xA7\xB8\x14\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
+
+      # Generates a v5 non-random UUID (Universally Unique IDentifier).
+      #
+      # Using OpenSSL::Digest::MD5 generates version 3 UUIDs; OpenSSL::Digest::SHA1 generates version 5 UUIDs.
+      # uuid_from_hash always generates the same UUID for a given name and namespace combination.
+      #
+      # 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
+          version = 3
+        elsif hash_class == Digest::SHA1 || hash_class == OpenSSL::Digest::SHA1
+          version = 5
+        else
+          raise ArgumentError, "Expected OpenSSL::Digest::SHA1 or OpenSSL::Digest::MD5, got #{hash_class.name}."
+        end
+
+        uuid_namespace = pack_uuid_namespace(namespace)
+
+        hash = hash_class.new
+        hash.update(uuid_namespace)
+        hash.update(name)
+
+        ary = hash.digest.unpack("NnnnnN")
+        ary[2] = (ary[2] & 0x0FFF) | (version << 12)
+        ary[3] = (ary[3] & 0x3FFF) | 0x8000
+
+        "%08x-%04x-%04x-%04x-%04x%08x" % ary
+      end
+
+      # Convenience method for uuid_from_hash using OpenSSL::Digest::MD5.
+      def self.uuid_v3(uuid_namespace, name)
+        uuid_from_hash(OpenSSL::Digest::MD5, uuid_namespace, name)
+      end
+
+      # Convenience method for uuid_from_hash using OpenSSL::Digest::SHA1.
+      def self.uuid_v5(uuid_namespace, name)
+        uuid_from_hash(OpenSSL::Digest::SHA1, uuid_namespace, name)
+      end
+
+      # Convenience method for SecureRandom.uuid.
+      def self.uuid_v4
+        SecureRandom.uuid
+      end
+
+      def self.pack_uuid_namespace(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?
+
+          match_data.captures.map { |s| s.to_i(16) }.pack("NnnnnN")
+        end
+      end
+
+      private_class_method :pack_uuid_namespace
+    end
+  end
+end

data/lib/glossarist/utilities.rb

@@ -3,3 +3,4 @@
 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 = "1.1.0"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Ribose
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-11 00:00:00.000000000 Z
+date: 2023-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: relaton
@@ -109,6 +109,8 @@ files:
 - lib/glossarist/collections.rb
 - lib/glossarist/collections/asset_collection.rb
 - lib/glossarist/collections/bibliography_collection.rb
+- lib/glossarist/collections/collection.rb
+- lib/glossarist/collections/designation_collection.rb
 - lib/glossarist/concept.rb
 - lib/glossarist/concept_date.rb
 - lib/glossarist/concept_manager.rb
@@ -142,6 +144,7 @@ files:
 - 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/version.rb
 homepage: https://github.com/glossarist/glossarist-ruby
 licenses: