glossarist 0.2.0 → 1.0.5

data/lib/glossarist/concept_set.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class ConceptSet
+    # a `Glossarist::ManagedConceptCollection` object
+    attr_accessor :concepts
+
+    # a `BibliographyCollection` object
+    attr_accessor :bibliographies
+
+    # an `Collections::Asset` object
+    attr_accessor :assets
+
+    # @parameters
+    #   concepts => a `Glossarist::ManagedConceptCollection` object or
+    #               a string containing the path of the folder with concepts
+    #   assets => a collection of Glossarist::Asset
+    def initialize(concepts, assets, options = {})
+      @concepts = read_concepts(concepts)
+      @assets = Glossarist::Collections::AssetCollection.new(assets)
+      @bibliographies = Glossarist::Collections::BibliographyCollection.new(
+        @concepts,
+        options.dig(:bibliography, :global_cache),
+        options.dig(:bibliography, :local_cache),
+      )
+    end
+
+    def to_latex(filename = nil)
+      return to_latex_from_file(filename) if filename
+
+      @concepts.map do |concept|
+        latex_template(concept)
+      end.join("\n")
+    end
+
+    private
+
+    def to_latex_from_file(entries_file)
+      File.readlines(entries_file).map do |concept_name|
+        concept = concept_map[concept_name.strip.downcase]
+
+        if concept.nil?
+           puts "  [Not Found]: #{concept_name.strip}"
+        else
+          latex_template(concept)
+        end
+      end.compact.join("\n")
+    end
+
+    def read_concepts(concepts)
+      return concepts if concepts.is_a?(Glossarist::ManagedConceptCollection)
+
+      collection = Glossarist::ManagedConceptCollection.new
+      collection.load_from_files(concepts)
+      collection
+    end
+
+    def latex_template(concept)
+      <<~TEMPLATE
+        \\newglossaryentry{#{concept.default_designation.gsub('_', '-')}}
+        {
+        name={#{concept.default_designation.gsub('_', '\_')}}
+        description={#{normalize_definition(concept.default_definition)}}
+        }
+      TEMPLATE
+    end
+
+    def normalize_definition(definition)
+      definition.gsub(/{{([^}]*)}}/) do |match|
+        "\\textbf{\\gls{#{Regexp.last_match[1].gsub('_', '-')}}}"
+      end
+    end
+
+    def concept_map
+      @concept_map ||= concepts.managed_concepts.map do |concept|
+        [concept.default_designation.downcase, concept]
+      end.to_h
+    end
+  end
+end

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/config.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module Glossarist
+  class Config
+    include Singleton
+
+    DEFAULT_CLASSES = {
+      localized_concept: Glossarist::LocalizedConcept,
+    }.freeze
+
+    attr_reader :registered_classes
+
+    def initialize
+      @registered_classes = DEFAULT_CLASSES.dup
+      @extension_attributes = []
+    end
+
+    def class_for(name)
+      @registered_classes[name.to_sym]
+    end
+
+    def register_class(class_name, klass)
+      @registered_classes[class_name] = klass
+    end
+
+    def extension_attributes
+      @extension_attributes
+    end
+
+    def register_extension_attributes(attributes)
+      @extension_attributes = attributes
+    end
+
+    class << self
+      def class_for(name)
+        self.instance.class_for(name)
+      end
+
+      def extension_attributes
+        self.instance.extension_attributes
+      end
+
+      def register_class(class_name, klass)
+        self.instance.register_class(class_name, klass)
+      end
+
+      def register_extension_attributes(attributes)
+        self.register_extension_attributes(attributes)
+      end
+    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

@@ -4,43 +4,12 @@
 #
 
 module Glossarist
-  class LocalizedConcept < Model
-    # Needs to be identical with {Concept#id}.
-    # @todo Here for legacy reasons.  Will be removed eventually.
-    attr_accessor :id
-
+  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
 
-    # Concept designations.
-    # @todo Alias +terms+ exists only for legacy reasons and will be removed.
-    # @return [Array<Designations::Base>]
-    attr_accessor :designations
-    alias :terms :designations
-    alias :terms= :designations=
-
-    # @return [Array<String>]
-    attr_accessor :notes
-
-    # @return [Array<String>]
-    attr_accessor :examples
-
-    # Concept definition.
-    # @todo Support multiple definitions.
-    # @return [String]
-    attr_accessor :definition
-
-    # @todo Right now accepts hashes for legacy reasons, but they will be
-    #   replaced with dedicated classes.
-    # @todo Alias +authoritative_source+ exists for legacy reasons and may be
-    #   removed.
-    # @return [Array<Hash>]
-    attr_accessor :sources
-    alias :authoritative_source :sources
-    alias :authoritative_source= :sources=
-
     # Must be one of the following:
     # +notValid+, +valid+, +superseded+, +retired+.
     # @todo Proper type checking.
@@ -59,48 +28,30 @@ module Glossarist
     attr_accessor :review_decision_date
     attr_accessor :review_decision_event
 
-    attr_accessor :date_accepted
-    attr_accessor :date_amended
-
-    # @todo Here for legacy reasons.  Will be moved to Concept.
-    # @todo Right now is an array of hashes for legacy reasons, but these hashes
-    #    will be replaced with some dedicated class.
-    # @todo Should be read-only, but for now it is not for legacy reasons.
-    #    Don't use the setter.
-    # @return [Array<Hash>]
-    attr_accessor :superseded_concepts
-
     def initialize(*)
       @examples = []
-      @notes = []
-      @designations = []
-      @superseded_concepts = []
-      @sources = []
+
       super
     end
 
     def to_h # rubocop:disable Metrics/MethodLength
-      {
-        "id" => id,
-        "terms" => (terms&.map(&:to_h) || []),
-        "definition" => definition,
+      super.merge({
         "language_code" => language_code,
-        "notes" => notes,
-        "examples" => examples,
         "entry_status" => entry_status,
+        "sources" => sources.empty? ? nil : sources&.map(&:to_h),
         "classification" => classification,
-        "authoritative_source" => (sources if sources&.any?),
-        "date_accepted" => date_accepted,
-        "date_amended" => date_amended,
+        "dates" => dates&.map(&:to_h),
         "review_date" => review_date,
         "review_decision_date" => review_decision_date,
         "review_decision_event" => review_decision_event,
-      }.compact
+      }.compact).merge(@extension_attributes)
     end
 
     def self.from_h(hash)
-      terms = hash["terms"]&.map { |h| Designations::Base.from_h(h) } || []
-      super(hash.merge({"terms" => terms}))
+      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.