glossarist 0.2.0 → 1.0.6

data/lib/glossarist/managed_concept.rb

@@ -0,0 +1,128 @@
+# 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
+
+    # Concept group
+    # @return [Array<String>]
+    attr_reader :groups
+
+    # 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| Config.class_for(:localized_concept).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
+
+    def groups=(groups)
+      return unless groups
+
+      @groups = groups.is_a?(Array) ? groups : [groups]
+    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),
+        "groups" => groups,
+      }.merge(localizations.transform_values(&:to_h)).compact
+    end
+
+    def default_designation
+      localized = localization("eng") || localizations.values.first
+      localized&.terms&.first&.designation
+    end
+
+    def default_definition
+      localized = localization("eng") || localizations.values.first
+      localized&.definition&.first&.content
+    end
+
+    def default_lang
+      localization("eng") || localizations.values.first
+    end
+
+    def managed_concept_attributes
+      %i[
+        id
+        termid
+        related
+        status
+        dates
+        localized_concepts
+        groups
+      ].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

@@ -5,6 +5,12 @@
 
 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
@@ -12,8 +18,12 @@ module Glossarist
     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."
+      if Config.extension_attributes.include?(name)
+        extension_attributes[name] = value
+      else
+        raise ArgumentError, "#{self.class.name} does not have " +
+          "attribute #{name} defined or the attribute is read only."
+      end
     end
 
     def self.from_h(hash)

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

data/lib/glossarist/related_concept.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Glossarist
+  class RelatedConcept < Model
+    include Glossarist::Utilities::Enum
+
+    register_enum :type, Glossarist::GlossaryDefinition::RELATED_CONCEPT_TYPES
+
+    # @return [String]
+    attr_accessor :content
+
+    # Reference to the related concept.
+    # @return [Citation]
+    attr_reader :ref
+
+    def ref=(ref)
+      @ref = Citation.new(ref)
+    end
+
+    def to_h
+      reference = ref&.to_h
+      reference&.merge!(reference&.delete("ref"))
+
+      {
+        "type" => type.to_s,
+        "content" => content,
+        "ref" => reference,
+      }.compact
+    end
+  end
+end

data/lib/glossarist/utilities/boolean_attributes.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Utilities
+    module BooleanAttributes
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def self.extended(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def register_boolean_attributes(attributes)
+          attributes.each do |attribute|
+            register_boolean_attribute(attribute)
+          end
+        end
+
+        def register_boolean_attribute(attribute)
+          attr_reader attribute
+
+          define_method("#{attribute}=") do |value|
+            instance_variable_set("@#{attribute}", !!value)
+          end
+
+          define_method("#{attribute}?") do
+            !!instance_variable_get("@#{attribute}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/utilities/common_functions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Utilities
+    module CommonFunctions
+      # Hash#transform_keys is not available in Ruby 2.4
+      # so we have to do this ourselves :(
+      # symbolize hash keys
+      def symbolize_keys(hash)
+        result = {}
+        hash.each_pair do |key, value|
+          result[key.to_sym] = value
+        end
+        result
+      end
+
+      # Hash#slice is not available in Ruby 2.4
+      # so we have to do this ourselves :(
+      # slice hash keys
+      def slice_keys(hash, keys)
+        result = {}
+        keys.each do |key|
+          result[key] = hash[key] if hash.key?(key)
+        end
+        result
+      end
+    end
+  end
+end

data/lib/glossarist/utilities/enum/class_methods.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Glossarist
+  module Utilities
+    module Enum
+      module ClassMethods
+        def add_inheritable_attribute(attribute)
+          @inheritable_attributes ||= Set[:inheritable_attributes]
+          @inheritable_attributes << attribute
+        end
+
+        def inherited(subclass)
+          @inheritable_attributes.each do |inheritable_attribute|
+            instance_var = "@#{inheritable_attribute}"
+            subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+          end
+        end
+
+        def enums
+          @enums ||= EnumCollection.new
+        end
+
+        def register_enum(name, values, options = {})
+          values = standardize_values(values)
+
+          enums.add(name, values, options)
+
+          add_inheritable_attribute(:enums)
+          register_type_accessor(name)
+
+          values.each do |value|
+            register_check_method(name, value)
+            register_set_method(name, value)
+          end
+        end
+
+        def registered_enums
+          enums.registered_enums
+        end
+
+        def valid_types(name)
+          enums.valid_types(name)
+        end
+
+        def type_options(name)
+          enums.type_options(name)
+        end
+
+        def register_type_reader(name)
+          define_method(name) do
+            if self.class.type_options(name)[:multiple]
+              selected_type[name].map(&:to_s)
+            else
+              selected_type[name].first&.to_s
+            end
+          end
+        end
+
+        def register_type_writer(name)
+          define_method("#{name}=") do |type|
+            select_type(name, type)
+          end
+        end
+
+        # Adds a reader and writer for the type name given.
+        def register_type_accessor(name)
+          register_type_reader(name)
+          register_type_writer(name)
+        end
+
+        def register_check_method(name, value)
+          define_method("#{value}?") do
+            !!selected_type[name]&.include?(value.to_sym)
+          end
+        end
+
+        def register_set_method(name, value)
+          define_method("#{value}=") do |input|
+            if input
+              select_type(name, value)
+            else
+              deselect_type(name, value)
+            end
+          end
+        end
+
+        def standardize_values(values)
+          if values.is_a?(Array)
+            values.map(&:to_sym)
+          else
+            [values.to_sym]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/utilities/enum/enum_collection.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Utilities
+    module Enum
+      class EnumCollection
+        include Enumerable
+
+        def initialize
+          @collection = {}
+        end
+
+        def add(name, values, options = {})
+          @collection[name] = { registered_values: values, options: options }
+        end
+
+        def each(&block)
+          if block_given?
+            @collection.each do |object|
+              block.call(object)
+            end
+          else
+            enum_for(:each)
+          end
+        end
+
+        def registered_enums
+          @collection&.keys || []
+        end
+
+        def valid_types(name)
+          @collection[name][:registered_values]
+        end
+
+        def type_options(name)
+          @collection[name][:options]
+        end
+
+        def [](name)
+          @collection[name]
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/utilities/enum/instance_methods.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Utilities
+    module Enum
+      module InstanceMethods
+        def selected_type
+          initialize_selected_type if @selected_type.nil?
+
+          @selected_type
+        end
+
+        def select_type(type_name, values)
+          values = if values.is_a?(Array)
+                     values
+                   else
+                     [values]
+                   end
+
+          values.each do |value|
+            select_type_value(type_name, value)
+          end
+        end
+
+        def deselect_type(type_name, value)
+          selected_type[type_name].delete(value)
+        end
+
+        private
+
+        def select_type_value(type_name, value)
+          if !value
+            selected_type[type_name].clear
+          elsif self.class.valid_types(type_name).include?(value.to_sym)
+            selected_type[type_name].clear unless self.class.type_options(type_name)[:multiple]
+            selected_type[type_name] << value.to_sym
+          else
+            raise(
+              Glossarist::InvalidTypeError,
+              "`#{value}` is not a valid #{type_name}. Supported #{type_name} are #{self.class.enums[type_name][:registered_values].to_a.join(", ")}"
+            )
+          end
+        end
+
+        def initialize_selected_type
+          @selected_type = {}
+
+          self.class.registered_enums.each do |type|
+            @selected_type[type] = []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/utilities/enum.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "enum/enum_collection"
+require_relative "enum/class_methods"
+require_relative "enum/instance_methods"
+
+module Glossarist
+  module Utilities
+    module Enum
+      def self.included(base)
+        base.include(InstanceMethods)
+        base.extend(ClassMethods)
+      end
+
+      def self.extended(base)
+        base.include(InstanceMethods)
+        base.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/glossarist/utilities.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "utilities/enum"
+require_relative "utilities/boolean_attributes"
+require_relative "utilities/common_functions"

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "0.2.0"
+  VERSION = "1.0.6"
 end

data/lib/glossarist.rb

@@ -4,16 +4,41 @@
 #
 
 require "psych"
+require "thor"
 
+require_relative "glossarist/utilities"
 require_relative "glossarist/version"
+require_relative "glossarist/glossary_definition"
 
+require_relative "glossarist/asset"
 require_relative "glossarist/model"
-require_relative "glossarist/concept"
+require_relative "glossarist/concept_date"
+require_relative "glossarist/detailed_definition"
+require_relative "glossarist/related_concept"
+require_relative "glossarist/citation"
+require_relative "glossarist/concept_set"
+require_relative "glossarist/concept_source"
 require_relative "glossarist/collection"
-require_relative "glossarist/designations"
+require_relative "glossarist/designation"
+require_relative "glossarist/concept"
 require_relative "glossarist/localized_concept"
+require_relative "glossarist/managed_concept_collection"
+require_relative "glossarist/concept_manager"
+require_relative "glossarist/managed_concept"
+require_relative "glossarist/non_verb_rep"
+
+require_relative "glossarist/collections"
+
+require_relative "glossarist/config"
 
 module Glossarist
   class Error < StandardError; end
+  class InvalidTypeError < StandardError; end
   # Your code goes here...
+
+  def self.configure
+    config = Glossarist::Config.instance
+
+    yield(config) if block_given?
+  end
 end