glossarist 2.3.0 → 2.3.2

data/lib/glossarist/model.rb

@@ -1,40 +0,0 @@
-# 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
-      if Config.extension_attributes.include?(name)
-        extension_attributes[name] = value
-      elsif name.match?(/[A-Z]/) # adding support for camel case
-        name = snake_case(name.to_s).to_sym
-        retry
-      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)
-      new(hash)
-    end
-
-    def snake_case(str)
-      str.gsub(/([A-Z])/) { "_#{$1.downcase}" }
-    end
-  end
-end

data/lib/glossarist/utilities/boolean_attributes.rb

@@ -1,35 +0,0 @@
-# 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/enum/class_methods.rb

@@ -1,99 +0,0 @@
-# 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

@@ -1,45 +0,0 @@
-# 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

@@ -1,55 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-# 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/v1_reader.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Glossarist
-  # An adapter to read concepts in V1 format, converts them to v2 format and
-  # load into glossarist concept model.
-  class V1Reader
-    def self.load_concept_from_file(filename)
-      new.load_concept_from_file(filename)
-    end
-
-    def load_concept_from_file(filename)
-      concept_hash = Psych.safe_load(File.read(filename), permitted_classes: [Date, Time])
-      Config.class_for(:managed_concept).new(generate_v2_concept_hash(concept_hash))
-    end
-
-    private
-
-    def generate_v2_concept_hash(concept_hash)
-      v2_concept = { "groups" => concept_hash["groups"] }
-      v2_concept["data"] = {
-        "identifier" => concept_hash["termid"],
-        "localized_concepts" => concept_hash.values.grep(Hash),
-      }
-
-      v2_concept
-    end
-  end
-end