glossarist-new 1.0.0

data/lib/glossarist/concept_source.rb

@@ -0,0 +1,62 @@
+# 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
+
+      {
+        "type" => type.to_s,
+        "status" => status&.to_s,
+        "origin" => origin_hash,
+        "modification" => modification,
+      }.compact
+    end
+
+    private
+
+    def ref_param_names
+      %w[
+        ref
+        text
+        source
+        id
+        version
+        clause
+        link
+        original
+      ]
+    end
+  end
+end

data/lib/glossarist/designation/abbreviation.rb

@@ -0,0 +1,23 @@
+# 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
+
+      attr_accessor :international
+
+      def to_h
+        super().merge({
+          "type" => type.to_s,
+          "international" => international,
+        }).compact
+      end
+    end
+  end
+end

data/lib/glossarist/designation/base.rb

@@ -0,0 +1,37 @@
+# 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
+
+      attr_accessor :geographical_area
+      register_enum :normative_status, Glossarist::GlossaryDefinition::DESIGNATION_BASE_NORMATIVE_STATUSES
+
+      def self.from_h(hash)
+        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)
+        else
+          # called on subclass, instantiate object
+          unless SERIALIZED_TYPES[self] == type
+            raise ArgumentError, "unexpected designation type: #{type}"
+          end
+          super(hash.reject { |k, _| k == "type" })
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/designation/expression.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+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) }
+      end
+
+      # @todo Added to cater for current iev-data implementation,
+      #   might be removed in the future.
+      def self.from_h(hash)
+        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)
+
+        if gender || number || part_of_speech
+          hash["grammar_info"] = [{
+            "gender" => gender,
+            "number" => number,
+            part_of_speech => part_of_speech,
+          }.compact]
+        end
+
+        super
+      end
+
+      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
+      end
+    end
+  end
+end

data/lib/glossarist/designation/grammar_info.rb

@@ -0,0 +1,58 @@
+# 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)
+        end
+      end
+
+      def part_of_speech=(pos)
+        public_send("#{pos}=", pos)
+      end
+
+      def to_h
+        {
+          "preposition" => preposition?,
+          "participle" => participle?,
+          "adj" => adj?,
+          "verb" => verb?,
+          "adverb" => adverb?,
+          "noun" => noun?,
+          "gender" => gender,
+          "number" => number,
+        }
+      end
+
+      private
+
+      def sanitized_options(options)
+        hash = symbolize_keys(options)
+        slice_keys(hash, [
+          :gender,
+          :number,
+          :preposition,
+          :participle,
+          :adj,
+          :verb,
+          :adverb,
+          :noun,
+          :part_of_speech,
+        ])
+      end
+    end
+  end
+end

data/lib/glossarist/designation/graphical_symbol.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Designation
+    class GraphicalSymbol < Symbol
+      attr_accessor :text
+      attr_accessor :image
+
+      def to_h
+        super.merge(
+          "text" => text,
+          "image" => image,
+        )
+      end
+    end
+  end
+end

data/lib/glossarist/designation/letter_symbol.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Designation
+    class LetterSymbol < Symbol
+      attr_accessor :text
+      attr_accessor :language
+      attr_accessor :script
+
+      def to_h
+        super.merge(
+          "text" => text,
+          "language" => language,
+          "script" => script,
+        )
+      end
+    end
+  end
+end

data/lib/glossarist/designation/symbol.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Glossarist
+  module Designation
+    class Symbol < Base
+      attr_accessor :international
+
+      def to_h
+        {
+          "type" => Glossarist::Designation::SERIALIZED_TYPES[self.class],
+          "normative_status" => normative_status,
+          "geographical_area" => geographical_area,
+          "designation" => designation,
+          "international" => international,
+        }.compact
+      end
+    end
+  end
+end

data/lib/glossarist/designation.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# (c) Copyright 2021 Ribose Inc.
+#
+
+require_relative "designation/abbreviation"
+require_relative "designation/base"
+require_relative "designation/expression"
+require_relative "designation/grammar_info"
+require_relative "designation/symbol"
+require_relative "designation/graphical_symbol"
+require_relative "designation/letter_symbol"
+
+module Glossarist
+  module Designation
+    # Bi-directional class-to-string mapping for STI-like serialization.
+    SERIALIZED_TYPES = {
+      Expression => "expression",
+      Symbol => "symbol",
+      Abbreviation => "abbreviation",
+      GraphicalSymbol => "graphical_symbol",
+      LetterSymbol => "letter_symbol",
+    }
+    .tap { |h| h.merge!(h.invert) }
+    .freeze
+  end
+end

data/lib/glossarist/detailed_definition.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class DetailedDefinition < Model
+
+    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
+    end
+  end
+end

data/lib/glossarist/glossary_definition.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+module Glossarist
+  module GlossaryDefinition
+    config = YAML.load_file(File.expand_path("../../../config.yml", __FILE__)) || {}
+
+    CONCEPT_SOURCE_STATUSES = config.dig("concept_source", "status").freeze
+
+    CONCEPT_SOURCE_TYPES = config.dig("concept_source", "type").freeze
+
+    RELATED_CONCEPT_TYPES = config.dig("related_concept", "type").freeze
+
+    ABBREVIATION_TYPES = config.dig("abbreviation", "type").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
+
+    CONCEPT_DATE_TYPES = config.dig("concept_date", "type").freeze
+
+    CONCEPT_STATUSES = config.dig("concept", "status").freeze
+  end
+end

data/lib/glossarist/localized_concept.rb

@@ -0,0 +1,61 @@
+# 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_accessor :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
+
+    attr_accessor :review_date
+    attr_accessor :review_decision_date
+    attr_accessor :review_decision_event
+
+    def initialize(*)
+      @examples = []
+
+      super
+    end
+
+    def to_h # rubocop:disable Metrics/MethodLength
+      super.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)
+    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"}) }
+
+      super(hash.merge({"terms" => terms, "sources" => sources}))
+    end
+
+    # @deprecated For legacy reasons only.
+    #   Implicit conversion (i.e. {#to_hash} alias) will be removed soon.
+    alias :to_hash :to_h
+  end
+end

data/lib/glossarist/managed_concept.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ManagedConcept < Model
+    include Glossarist::Utilities::Enum
+    include Glossarist::Utilities::CommonFunctions
+
+    # @return [String]
+    attr_accessor :id
+    alias :termid= :id=
+
+    # @return [Array<RelatedConcept>]
+    attr_reader :related
+
+    # @return [String]
+    register_enum :status, Glossarist::GlossaryDefinition::CONCEPT_STATUSES
+
+    # return [Array<ConceptDate>]
+    attr_reader :dates
+
+    # return [Array<LocalizedConcept>]
+    attr_reader :localized_concepts
+
+    # All localizations for this concept.
+    #
+    # Keys are language codes and values are instances of {LocalizedConcept}.
+    # @return [Hash<String, LocalizedConcept>]
+    attr_accessor :localizations
+
+    def initialize(attributes = {})
+      @localizations = {}
+      self.localized_concepts = attributes.values.grep(Hash)
+
+      attributes = symbolize_keys(attributes)
+      super(slice_keys(attributes, managed_concept_attributes))
+    end
+
+    def localized_concepts=(localized_concepts_hash)
+      @localized_concepts = localized_concepts_hash.map { |l| LocalizedConcept.new(l) }.compact
+
+      @localized_concepts.each do |l|
+        add_l10n(l)
+      end
+
+      @localized_concepts
+    end
+
+    def related=(related)
+      @related = related&.map { |r| RelatedConcept.new(r) }
+    end
+
+    def dates=(dates)
+      @dates = dates&.map { |d| ConceptDate.new(d) }
+    end
+
+    # Adds concept localization.
+    # @param localized_concept [LocalizedConcept]
+    def add_localization(localized_concept)
+      lang = localized_concept.language_code
+      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
+      {
+        "termid" => id,
+        "term" => default_designation,
+        "related" => related&.map(&:to_h),
+        "dates" => dates&.empty? ? nil : dates&.map(&:to_h),
+      }.merge(localizations.transform_values(&:to_h)).compact
+    end
+
+    def default_designation
+      localized = localization("eng") || localizations.values.first
+      localized&.terms&.first&.designation
+    end
+
+    def managed_concept_attributes
+      %i[
+        id
+        termid
+        related
+        status
+        dates
+        localized_concepts
+      ].compact
+    end
+
+    Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES.each do |type|
+      # List of related concepts of the specified type.
+      # @return [Array<RelatedConcept>]
+      define_method("#{type}_concepts") do
+        related&.select { |concept| concept.type == type.to_s } || []
+      end
+    end
+  end
+end

data/lib/glossarist/managed_concept_collection.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ManagedConceptCollection
+    include Enumerable
+
+    def initialize
+      @managed_concepts = {}
+      @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(ManagedConcept.new(managed_concept))
+      end
+
+      @managed_concepts.values
+    end
+
+    def to_h
+      {
+        "managed_concepts" => managed_concepts.map(&:to_h),
+      }.compact
+    end
+
+    def each(&block)
+      @managed_concepts.each_value(&block)
+    end
+
+    # Returns concept with given ID, if it is present in collection, or +nil+
+    # otherwise.
+    #
+    # @param id [String]
+    #    ManagedConcept ID
+    # @return [ManagedConcept, nil]
+    def fetch(id)
+      @managed_concepts[id]
+    end
+
+    alias :[] :fetch
+
+    # If ManagedConcept with given ID is present in this collection, then
+    # returns it. Otherwise, instantiates a new ManagedConcept, adds it to
+    # the collection, and returns it.
+    #
+    # @param id [String]
+    #    ManagedConcept ID
+    # @return [ManagedConcept]
+    def fetch_or_initialize(id)
+      fetch(id) or store(ManagedConcept.new(id: id))
+    end
+
+    # 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
+    end
+
+    alias :<< :store
+
+    def load_from_files(path)
+      @concept_manager.path = path
+      @concept_manager.load_from_files(collection: self)
+    end
+
+    def save_to_files(path)
+      @concept_manager.path = path
+      @concept_manager.save_to_files(@managed_concepts)
+    end
+  end
+end

data/lib/glossarist/model.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# (c) Copyright 2021 Ribose Inc.
+#
+
+module Glossarist
+  class Model
+    def self.new(params = {})
+      return params if params.is_a?(self)
+
+      super
+    end
+
+    def initialize(attributes = {})
+      attributes.each_pair { |k, v| set_attribute(k, v) }
+    end
+
+    def set_attribute(name, value)
+      public_send("#{name}=", value)
+    rescue NoMethodError
+      raise ArgumentError, "#{self.class.name} does not have " +
+        "attribute #{name} defined or the attribute is read only."
+    end
+
+    def self.from_h(hash)
+      new(hash)
+    end
+  end
+end

data/lib/glossarist/non_verb_rep.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class NonVerbRep
+    attr_accessor :image
+    attr_accessor :table
+    attr_accessor :formula
+
+    # @return [Array<ConceptSource>]
+    attr_reader :sources
+
+    def sources=(sources)
+      @sources = sources&.map do |source|
+        ConceptSource.new(source)
+      end
+    end
+  end
+end