evt-constant 2.1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 37688b1a76f8bdfc93bbbcd855c899a1b8a7d62f474e222f1f21e54c9190894a
+  data.tar.gz: d524e8c0d42196c7ae0ed435cb5f12ed582b519d1e9f2e32020447bc24f860c8
+SHA512:
+  metadata.gz: 625602ca4e22aef84ec15503580c73df54af1b6df8b65cd7027f32d6e86de16ddc9174f59f7be511b142584e549dc287046f308e380f2fe4ebe5deb5e5884b2c
+  data.tar.gz: e6ff42d4593cbc572b44d2382c8e221c28b87ce8e25c979836c0224f44094a9b7700e4ddaf5dc35b93b3e6f2d722be59f2d09be0284e6e1303dd28e8a76aff23

data/lib/constant/coerce.rb

@@ -0,0 +1,16 @@
+module Constant
+  module Coerce
+    refine Kernel do
+      def Constant(value, namespace=nil, inherit: nil)
+        if value.is_a?(Constant)
+          value
+        elsif value.is_a?(::Module) || value.is_a?(::String) || value.is_a?(::Symbol)
+          Constant.get(value, namespace, inherit: inherit)
+        else
+          type_name = value.nil? ? "nil" : value.class
+          raise TypeError, "can't convert #{type_name} into Constant"
+        end
+      end
+    end
+  end
+end

data/lib/constant/constant.rb

@@ -0,0 +1,72 @@
+module Constant
+  Error = Class.new(RuntimeError)
+
+  class << self
+    alias __name name
+  end
+
+  def self.get(value, namespace=nil, inherit: nil)
+    namespace ||= Object
+
+    if value.is_a?(::Module)
+      Constant::Module.build(value)
+    else
+      if namespace.is_a?(::Module) || namespace.is_a?(Constant)
+        namespace_constant = Constant::Module.build(namespace)
+      else
+        namespace_constant = get(namespace)
+      end
+
+      namespace_constant.get(value, inherit: inherit)
+    end
+  end
+
+  def self.name(mod)
+    name = mod.name
+
+    if name.nil?
+      return nil
+    end
+
+    name.rpartition("::").last
+  end
+
+  def self.namespace(mod)
+    name = mod.name
+
+    if name.nil?
+      return nil
+    end
+
+    namespace_name = name.rpartition("::").first
+
+    if namespace_name.empty?
+      Constant::Module.new(Object)
+    else
+      namespace_mod = Object.const_get(namespace_name)
+      Constant::Module.new(namespace_mod)
+    end
+  end
+
+  def self.defined?(name, namespace_name_or_module=nil, inherit: nil)
+    namespace_name_or_module ||= Object
+
+    namespace_constant = get(namespace_name_or_module)
+    namespace_constant.get(name, inherit: inherit)
+    true
+  rescue Constant::Error # #get raises when the name is undefined, or its path runs through a literal
+    false
+  end
+
+  def ==(other)
+    other.is_a?(Constant) && identity == other.identity
+  end
+
+  def eql?(other)
+    self == other
+  end
+
+  def hash
+    identity.hash
+  end
+end

data/lib/constant/controls/constant.rb

@@ -0,0 +1,55 @@
+module Constant
+  module Controls
+    module Constant
+      def self.example(name: nil, randomize_name: nil, inner_constants: nil, ancestor: nil)
+        inner_constants ||= []
+
+        mod = ::Module.new
+
+        name ||= "ExampleModule"
+
+        if [nil, true].include?(randomize_name)
+          name = "#{name}_#{SecureRandom.hex(2).upcase}"
+        end
+
+        Object.const_set(name, mod)
+
+        if not inner_constants.empty?
+          add_inner_constants(mod, inner_constants)
+        end
+
+        if not ancestor.nil?
+          add_ancestors(mod, ancestor)
+        end
+
+        mod
+      end
+
+      def self.add_ancestors(mod, ancestors)
+        ancestors.each do |ancestor_name, ancestor_inner_constants|
+          ancestor_module = example(name: ancestor_name, inner_constants: ancestor_inner_constants)
+          mod.include(ancestor_module)
+        end
+      end
+
+      def self.add_inner_constants(mod, inner_constants)
+        if inner_constants.is_a?(Hash)
+          inner_constants.each do |inner_constant_name, inner_constant_value|
+            if inner_constant_value.is_a?(Hash)
+              inner_mod = ::Module.new
+              mod.const_set(inner_constant_name, inner_mod)
+              add_inner_constants(inner_mod, inner_constant_value)
+            else
+              mod.const_set(inner_constant_name, inner_constant_value)
+            end
+          end
+        else
+          inner_constants.each do |inner_constant_name|
+            inner_constant_value = ::Module.new
+            mod.const_set(inner_constant_name, inner_constant_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/constant/controls.rb

@@ -0,0 +1,3 @@
+require "securerandom"
+
+require "constant/controls/constant"

data/lib/constant/define.rb

@@ -0,0 +1,9 @@
+module Constant
+  module Define
+    def self.call(constant_name, destination_constant, constant_value=nil)
+      constant_value = ::Module.new if constant_value.nil?
+      destination_constant.const_set(constant_name, constant_value)
+      constant_value
+    end
+  end
+end

data/lib/constant/import/macro.rb

@@ -0,0 +1,11 @@
+module Constant
+  module Import
+    module Macro
+      def __import_constant(origin_constant, **kwargs)
+        Import.(origin_constant, self, **kwargs)
+      end
+
+      alias import __import_constant
+    end
+  end
+end

data/lib/constant/import.rb

@@ -0,0 +1,35 @@
+module Constant
+  module Import
+    Error = Class.new(RuntimeError)
+
+    def self.included(base)
+      base.extend(Macro)
+    end
+
+    def self.call(origin_constant, destination_constant, **kwargs)
+      alias_name = kwargs[:alias]
+
+      if alias_name.nil? && destination_constant.ancestors.include?(origin_constant)
+        raise Error, "#{destination_constant} already includes #{origin_constant}"
+      end
+
+      target = destination_constant
+
+      if not alias_name.nil?
+        target = Define.(alias_name, destination_constant)
+      end
+
+      inherit = false
+
+      import_constant_names = origin_constant.constants(inherit)
+
+      imported_constants = import_constant_names.map do |import_constant_name|
+        import_constant = origin_constant.const_get(import_constant_name, inherit)
+        target.const_set(import_constant_name, import_constant)
+        import_constant
+      end
+
+      imported_constants
+    end
+  end
+end

data/lib/constant/literal.rb

@@ -0,0 +1,38 @@
+module Constant
+  class Literal
+    include Constant
+    include Initializer
+
+    initializer :name, :value, :namespace
+
+    def self.build(name, value, namespace)
+      name = name.to_s
+      namespace = Constant::Module.build(namespace)
+      new(name, value, namespace)
+    end
+
+    def full_name
+      if namespace.value.equal?(Object)
+        name
+      else
+        "#{namespace.full_name}::#{name}"
+      end
+    end
+
+    def identity
+      full_name
+    end
+
+    def constants(inherit: nil)
+      []
+    end
+
+    def get(name, inherit: nil)
+      raise Constant::Error, "Literal constants are primitive values. They don't support inner constants. #{name} is not defined in #{full_name}."
+    end
+
+    def defined?(name_or_module, inherit: nil)
+      false
+    end
+  end
+end

data/lib/constant/module.rb

@@ -0,0 +1,101 @@
+module Constant
+  class Module
+    include Constant
+    include Initializer
+
+    initializer :value
+
+    def name
+      Constant.name(value)
+    end
+
+    def full_name
+      value.name
+    end
+
+    def namespace
+      Constant.namespace(value)
+    end
+
+    def self.build(mod)
+      if mod.is_a?(Constant)
+        mod
+      else
+        new(mod)
+      end
+    end
+
+    def get(name, inherit: nil)
+      inherit ||= false
+
+      name = name.to_s
+      head, _, rest = name.partition("::")
+
+      if not rest.empty?
+        head_constant = get(head, inherit: inherit)
+        return head_constant.get(rest, inherit: inherit)
+      end
+
+      if not value.const_defined?(name, inherit)
+        raise Constant::Error, "#{name} is not defined in #{value}"
+      end
+
+      resolved = value.const_get(name, inherit)
+
+      if resolved.is_a?(::Module)
+        Constant::Module.build(resolved)
+      else
+        Constant::Literal.build(name, resolved, self)
+      end
+    end
+
+    def constants(include_literal_constants: nil, inherit: nil)
+      include_literal_constants ||= false
+      inherit ||= false
+
+      constant_symbols = value.constants(inherit)
+
+      constant_symbols.filter_map do |constant_name|
+        resolved = value.const_get(constant_name, inherit)
+
+        if resolved.is_a?(::Module)
+          Constant::Module.build(resolved)
+        elsif include_literal_constants
+          Constant::Literal.build(constant_name, resolved, self)
+        end
+      end
+    end
+
+    def constant_names(include_literal_constants: nil, inherit: nil)
+      include_literal_constants ||= false
+      inherit ||= false
+
+      constant_symbols = value.constants(inherit)
+
+      constant_symbols.filter_map do |constant_symbol|
+        resolved = value.const_get(constant_symbol, inherit)
+
+        if resolved.is_a?(::Module) || include_literal_constants
+          constant_symbol.to_s
+        end
+      end
+    end
+
+    def defined?(name_or_module, inherit: nil)
+      if name_or_module.is_a?(::Module)
+        inherit ||= false
+
+        value.constants(inherit).any? do |constant_name|
+          resolved = value.const_get(constant_name, inherit)
+          resolved.equal?(name_or_module)
+        end
+      else
+        Constant.defined?(name_or_module, value, inherit: inherit)
+      end
+    end
+
+    def identity
+      value
+    end
+  end
+end

data/lib/constant.rb

@@ -0,0 +1,9 @@
+require "initializer"
+
+require "constant/constant"
+require "constant/module"
+require "constant/literal"
+require "constant/coerce"
+require "constant/define"
+require "constant/import"
+require "constant/import/macro"

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: evt-constant
+version: !ruby/object:Gem::Version
+  version: 2.1.0.0
+platform: ruby
+authors:
+- The Eventide Project
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: evt-initializer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test_bench
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Utilities for working with constants
+email: opensource@eventide-project.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/constant.rb
+- lib/constant/coerce.rb
+- lib/constant/constant.rb
+- lib/constant/controls.rb
+- lib/constant/controls/constant.rb
+- lib/constant/define.rb
+- lib/constant/import.rb
+- lib/constant/import/macro.rb
+- lib/constant/literal.rb
+- lib/constant/module.rb
+homepage: https://github.com/eventide-project/constant
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: ''
+test_files: []