low_type 1.1.6 → 1.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 353f89ccc3e77dc8eaa2fe4e8df301fc1c43bda6bfd936ecd92b19e755222fec
-  data.tar.gz: c19938429cc2a5aed790df108ca1d232650807376c972f680fe161eeca77c072
+  metadata.gz: a6cfbec60ebbfe9ff5d9a3dd68a00c201b1b8cc8aea52f08f290c3b34131fb89
+  data.tar.gz: 4e745a28edb5c3da913b4fde7e1346ba62352469a27a1b259225ca6df62350fa
 SHA512:
-  metadata.gz: 0baaf85c1edffcad962cde102756894d3a2c806ded41f98b442c84a5e79fbefaecbbd19859674839e57bd6357bd850b8a799837919a7b5fcf4481022274ff9f0
-  data.tar.gz: 83d641896ca7dbf6fe8289d8870941b31a3bdc5327f4a429ba0463d14c4df206179373d4deb77f8330db6e940a84c9154e7d8bb8177f6991cd8a5958414c9cad
+  metadata.gz: ee8a741df349ef64d5d133a553339aef6c2ecf8d2238adedc7890c41e3e4b6a2bb71556fc5eac488fdb9d8a875cdee8a251bd78d268fe05ac36ecc71d0d5c31b
+  data.tar.gz: 3397ec0c358d4643b3c2ea3cf1a12243ba667ba4ea536c6aaac59eb7b067d5fdfea2850a0d121765f6fbbe3b2da49dc08123320d8e100c53ec2ee3865c0d678a

data/lib/adapters/adapter_loader.rb

@@ -2,7 +2,7 @@
 
 require_relative 'sinatra_adapter'
 
-module LowType
+module Low
   module Adapter
     class Loader
       class << self

data/lib/adapters/sinatra_adapter.rb

@@ -7,7 +7,7 @@ require_relative '../interfaces/adapter_interface'
 require_relative '../proxies/return_proxy'
 require_relative '../types/error_types'
 
-module LowType
+module Low
   module Adapter
     # We don't use https://sinatrarb.com/extensions.html because we need to type check all Ruby methods (not just Sinatra) at a lower level.
     class Sinatra < AdapterInterface
@@ -31,7 +31,7 @@ module LowType
           next unless (return_proxy = return_proxy(method_node: method_call, pattern:, file:))
 
           route = "#{method_call.name.upcase} #{pattern}"
-          params = [ParamProxy.new(type_expression: nil, name: :route, type: :req, position: 0, file:)]
+          params = [ParamProxy.new(expression: nil, name: :route, type: :req, position: 0, file:)]
           @klass.low_methods[route] = MethodProxy.new(name: method_call.name, params:, return_proxy:)
         end
       end

data/lib/definitions/redefiner.rb

@@ -6,7 +6,7 @@ require_relative '../proxies/method_proxy'
 require_relative '../queries/type_query'
 require_relative 'repository'
 
-module LowType
+module Low
   # Redefine methods to have their arguments and return values type checked.
   class Redefiner
     class << self
@@ -21,20 +21,7 @@ module LowType
       end
 
       def redefinable?(method_proxy:, class_proxy:)
-        # Method has no types.
-        if method_proxy.params == [] && method_proxy.return_proxy.nil?
-          LowType::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
-          return false
-        end
-
-        # Method outside class bounds.
-        within_bounds = method_proxy.start_line > class_proxy.start_line && method_proxy.end_line <= class_proxy.end_line
-        if method_proxy.lines? && class_proxy.lines? && !within_bounds
-          LowType::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
-          return false
-        end
-
-        true
+        method_has_types?(method_proxy:, class_proxy:) && method_within_class_bounds?(method_proxy:, class_proxy:)
       end
 
       def untyped_args(args:, kwargs:, method_proxy:) # rubocop:disable Metrics/AbcSize
@@ -44,7 +31,7 @@ module LowType
           next unless value.nil?
           raise param_proxy.error_type, param_proxy.error_message(value:) if param_proxy.required?
 
-          value = param_proxy.type_expression.default_value # Default value can still be `nil`.
+          value = param_proxy.expression.default_value # Default value can still be `nil`.
           value = value.value if value.is_a?(ValueExpression)
           param_proxy.position ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
         end
@@ -76,7 +63,7 @@ module LowType
       def typed_methods(method_proxies:, class_proxy:) # rubocop:disable Metrics
         Module.new do
           method_proxies.each do |name, method_proxy|
-            next unless LowType::Redefiner.redefinable?(method_proxy:, class_proxy:)
+            next unless Low::Redefiner.redefinable?(method_proxy:, class_proxy:)
 
             # You are now in the binding of the includer class (`name` is also available here).
             define_method(name) do |*args, **kwargs|
@@ -85,9 +72,9 @@ module LowType
 
               method_proxy.params.each do |param_proxy|
                 value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
-                value = param_proxy.type_expression.default_value if value.nil? && !param_proxy.required?
+                value = param_proxy.expression.default_value if value.nil? && !param_proxy.required?
 
-                param_proxy.type_expression.validate!(value:, proxy: param_proxy)
+                param_proxy.expression.validate!(value:, proxy: param_proxy)
                 value = value.value if value.is_a?(ValueExpression)
                 param_proxy.position ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
               end
@@ -109,13 +96,13 @@ module LowType
       def untyped_methods(method_proxies:, class_proxy:)
         Module.new do
           method_proxies.each do |name, method_proxy|
-            next unless LowType::Redefiner.redefinable?(method_proxy:, class_proxy:)
+            next unless Low::Redefiner.redefinable?(method_proxy:, class_proxy:)
 
             # You are now in the binding of the includer class (`name` is also available here).
             define_method(name) do |*args, **kwargs|
               # NOTE: Type checking is currently disabled. See 'config.type_checking'.
               method_proxy = instance_of?(Class) ? low_methods[name] : self.class.low_methods[name] || Object.low_methods[name]
-              args, kwargs = LowType::Redefiner.untyped_args(args:, kwargs:, method_proxy:)
+              args, kwargs = Low::Redefiner.untyped_args(args:, kwargs:, method_proxy:)
               super(*args, **kwargs)
             end
 
@@ -123,6 +110,25 @@ module LowType
           end
         end
       end
+
+      def method_has_types?(method_proxy:, class_proxy:)
+        if method_proxy.params == [] && method_proxy.return_proxy.nil?
+          Low::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
+          return false
+        end
+
+        true
+      end
+
+      def method_within_class_bounds?(method_proxy:, class_proxy:)
+        within_bounds = method_proxy.start_line > class_proxy.start_line && method_proxy.end_line <= class_proxy.end_line
+        if method_proxy.lines? && class_proxy.lines? && !within_bounds
+          Low::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
+          return false
+        end
+
+        true
+      end
     end
   end
 end

data/lib/definitions/repository.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LowType
+module Low
   class Repository
     class << self
       def all(klass:)

data/lib/definitions/type_accessors.rb

@@ -4,36 +4,36 @@ require_relative '../expressions/type_expression'
 require_relative '../proxies/return_proxy'
 require_relative '../queries/type_query'
 
-module LowType
+module Low
   module TypeAccessors
     def type_reader(named_expressions)
-      named_expressions.each do |name, expression|
+      named_expressions.each do |name, exp|
         last_caller = caller_locations(1, 1).first
-        type_expression = type_expression(expression)
         file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
 
-        @low_methods[name] = MethodProxy.new(name:, return_proxy: ReturnProxy.new(type_expression:, name:, file:))
+        expression = expression(exp)
+        @low_methods[name] = MethodProxy.new(name:, return_proxy: ReturnProxy.new(type_expression: expression, name:, file:))
 
         define_method(name) do
           method_proxy = self.class.low_methods[name]
           value = instance_variable_get("@#{name}")
-          type_expression.validate!(value:, proxy: method_proxy.return_proxy)
+          expression.validate!(value:, proxy: method_proxy.return_proxy)
           value
         end
       end
     end
 
-    def type_writer(named_expressions)
-      named_expressions.each do |name, expression|
+    def type_writer(named_expressions) # rubocop:disable Metrics/AbcSize
+      named_expressions.each do |name, exp|
         last_caller = caller_locations(1, 1).first
-        type_expression = type_expression(expression)
         file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
 
-        @low_methods["#{name}="] = MethodProxy.new(name:, params: [ParamProxy.new(type_expression:, name:, type: :hashreq, file:)])
+        params = [ParamProxy.new(expression: expression(exp), name:, type: :hashreq, file:)]
+        @low_methods["#{name}="] = MethodProxy.new(name:, params:)
 
         define_method("#{name}=") do |value|
           method_proxy = self.class.low_methods["#{name}="]
-          type_expression.validate!(value:, proxy: method_proxy.params.first)
+          method_proxy.params.first.expression.validate!(value:, proxy: method_proxy.params.first)
           instance_variable_set("@#{name}", value)
         end
       end
@@ -48,10 +48,10 @@ module LowType
 
     private
 
-    def type_expression(expression)
-      if expression.instance_of?(TypeExpression)
+    def expression(expression)
+      if expression.is_a?(::Expressions::Expression)
         expression
-      elsif ::LowType::TypeQuery.type?(expression)
+      elsif ::Low::TypeQuery.type?(expression)
         TypeExpression.new(type: expression)
       end
     end

data/lib/expressions/expressions.rb

@@ -5,7 +5,7 @@ require_relative '../proxies/file_proxy'
 require_relative '../proxies/local_proxy'
 require_relative '../types/error_types'
 
-module LowType
+module Low
   module Expressions
     def type(type_expression)
       value = type_expression.default_value

data/lib/expressions/type_expression.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require 'expressions'
+
 require_relative '../proxies/param_proxy'
 require_relative '../queries/type_query'
 
-module LowType
+module Low
   root_path = File.expand_path(__dir__)
   adapter_paths = Dir.chdir(root_path) { Dir.glob('adapters/*') }.map { |path| File.join(root_path, path) }
   module_paths = %w[expressions/expressions instance_types redefiner].map { |path| File.join(root_path, "#{path}.rb") }
@@ -11,7 +13,7 @@ module LowType
   HIDDEN_PATHS = [File.expand_path(__FILE__), *adapter_paths, *module_paths].freeze
 
   # Represent types and default values as a series of chainable expressions.
-  class TypeExpression
+  class TypeExpression < ::Expressions::Expression
     attr_reader :types, :default_value
 
     # @param type - A literal type or an instance representation of a typed structure.
@@ -23,19 +25,6 @@ module LowType
       @deep_type_check = LowType.config.deep_type_check
     end
 
-    def |(expression)
-      if expression.instance_of?(::LowType::TypeExpression)
-        @types += expression.types
-        @default_value = expression.default_value
-      elsif ::LowType::TypeQuery.value?(expression)
-        @default_value = expression
-      else
-        @types << expression
-      end
-
-      self
-    end
-
     def required?
       @default_value == :LOW_TYPE_UNDEFINED
     end
@@ -62,7 +51,7 @@ module LowType
         if type.is_a?(Array)
           "[#{type.map { |subtype| valid_subtype(subtype:) }.join(', ')}]"
         else
-          type.inspect.to_s.delete_prefix('LowType::')
+          type.inspect.to_s.delete_prefix('Low::')
         end
       end
 
@@ -72,13 +61,31 @@ module LowType
 
     private
 
+    def union_expression(expression)
+      @types += expression.types
+      @default_value = expression.default_value
+    end
+
+    def union_type(type)
+      @types << type
+    end
+
+    def union_value(value)
+      @default_value = value
+    end
+
+    # Override Expressions as LowType supports complex types which are implemented as values.
+    def value?(expression)
+      ::Low::TypeQuery.value?(expression) || expression.nil?
+    end
+
     def valid_subtype(subtype:)
       if subtype.is_a?(TypeExpression)
         types = subtype.types
         types << 'nil' if subtype.default_value.nil?
         types.join(' | ')
       else
-        subtype.to_s.delete_prefix('LowType::')
+        subtype.to_s.delete_prefix('Low::')
       end
     end
 
@@ -122,10 +129,10 @@ module LowType
 
     def type_matches_value?(type:, value:, proxy:)
       if type.instance_of?(Class)
-        return type.match?(value:) if LowType::TypeQuery.complex_type?(expression: type)
+        return type.match?(value:) if Low::TypeQuery.complex_type?(expression: type)
 
         return type == value.class
-      elsif type.instance_of?(::LowType::TypeExpression)
+      elsif type.instance_of?(::Low::TypeExpression)
         type.validate!(value:, proxy:)
         return true
       end

data/lib/factories/expression_factory.rb

@@ -3,7 +3,7 @@
 require_relative '../expressions/type_expression'
 require_relative '../expressions/value_expression'
 
-module LowType
+module Low
   class ExpressionFactory
     class << self
       def type_expression_with_value(type:)

data/lib/factories/proxy_factory.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'expressions'
+
 require_relative '../expressions/expressions'
 require_relative '../expressions/type_expression'
 require_relative '../proxies/file_proxy'
@@ -8,7 +10,7 @@ require_relative '../proxies/return_proxy'
 require_relative '../queries/file_parser'
 require_relative '../syntax/syntax'
 
-module LowType
+module Low
   class ProxyFactory
     using ::LowType::Syntax
 
@@ -22,25 +24,24 @@ module LowType
         FileProxy.new(path:, start_line:, end_line:, scope:)
       end
 
+      # The evals below aren't a security risk because the code comes from a trusted source; the file itself that did the include.
       def param_proxies(method_node:, file:)
         return [] if method_node.parameters.nil?
 
         params_without_block = method_node.parameters.slice.delete_suffix(', &block')
 
-        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
         ruby_method = eval("-> (#{params_without_block}) {}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
 
-        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
-        # Local variable names are prefixed with __lt or __rb where necessary to avoid being overridden by method parameters.
+        # Local variable names are prefixed with __lt or __rb where needed to avoid being overridden by method parameters.
         typed_method = <<~RUBY
           -> (#{params_without_block}, __rb_method:, __lt_file:) {
-            param_proxies_for_type_expressions(ruby_method: __rb_method, file: __lt_file, method_binding: binding)
+            param_proxies_for_expressions(ruby_method: __rb_method, file: __lt_file, method_binding: binding)
           }
         RUBY
 
-        # Called with only required args (as nil) and optional args omitted, to evaluate type expressions (from default values).
-        # Passes internal variables with namespaced names to avoid conflicts with the method parameters.
         required_args, required_kwargs = required_args(ruby_method:)
+
+        # Called with only required args (as nil) and optional args omitted, to evaluate expressions stored as default values.
         eval(typed_method, binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
           .call(*required_args, **required_kwargs, __rb_method: ruby_method, __lt_file: file)
 
@@ -85,22 +86,28 @@ module LowType
         [required_args, required_kwargs]
       end
 
-      def param_proxies_for_type_expressions(ruby_method:, file:, method_binding:)
+      def param_proxies_for_expressions(ruby_method:, file:, method_binding:)
         param_proxies = []
 
         ruby_method.parameters.each_with_index do |param, position|
           type, name = param
-          position = nil unless %i[opt req rest].include?(type)
-          expression = method_binding.local_variable_get(name)
-
-          type_expression = nil
-          if expression.is_a?(TypeExpression)
-            type_expression = expression
-          elsif ::LowType::TypeQuery.type?(expression)
-            type_expression = TypeExpression.new(type: expression)
+
+          # We don't support splatted *positional and **keyword arguments as by definition they are untyped.
+          next if type == :rest
+
+          position = nil unless %i[opt req].include?(type)
+          local_variable = method_binding.local_variable_get(name)
+
+          expression = nil
+          if local_variable.is_a?(::Expressions::Expression)
+            expression = local_variable
+          elsif local_variable.instance_of?(Class) && local_variable < ::Expressions::Expression
+            expression = local_variable.new(provider_key: name)
+          elsif ::Low::TypeQuery.type?(local_variable)
+            expression = TypeExpression.new(type: local_variable)
           end
 
-          param_proxies << ParamProxy.new(type_expression:, name:, type:, position:, file:) if type_expression
+          param_proxies << ParamProxy.new(expression:, name:, type:, position:, file:) if expression
         end
 
         param_proxies

data/lib/factories/type_factory.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LowType
+module Low
   class TypeFactory
     class << self
       def complex_type(parent_type)

data/lib/interfaces/adapter_interface.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LowType
+module Low
   class AdapterInterface
     def process
       raise NotImplementedError

data/lib/interfaces/error_interface.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LowType
+module Low
   class ErrorInterface
     attr_reader :file
 

data/lib/low_type.rb

@@ -20,25 +20,32 @@ module LowType
       end
     end
 
-    file_path = FileQuery.file_path(klass:)
+    file_path = Low::FileQuery.file_path(klass:)
     return unless File.exist?(file_path)
 
-    parser = FileParser.new(klass:, file_path:)
+    parser = Low::FileParser.new(klass:, file_path:)
 
-    klass.extend TypeAccessors
-    klass.include Expressions
-    klass.prepend Redefiner.redefine(method_nodes: parser.instance_methods, class_proxy: parser.class_proxy, file_path:)
-    klass.singleton_class.prepend Redefiner.redefine(method_nodes: parser.class_methods, class_proxy: parser.class_proxy, file_path:)
+    klass.extend Low::TypeAccessors
+    klass.include Low::Expressions
+    klass.prepend Low::Redefiner.redefine(method_nodes: parser.instance_methods, class_proxy: parser.class_proxy, file_path:)
+    klass.singleton_class.prepend Low::Redefiner.redefine(method_nodes: parser.class_methods, class_proxy: parser.class_proxy, file_path:)
 
-    if (adapter = Adapter::Loader.load(klass:, parser:, file_path:))
+    if (adapter = Low::Adapter::Loader.load(klass:, parser:, file_path:))
       adapter.process
-      klass.prepend Adapter::Methods
+      klass.prepend Low::Adapter::Methods
     end
   end
 
   class << self
     def config
-      config = Struct.new(:type_checking, :error_mode, :output_mode, :output_size, :deep_type_check, :union_type_expressions)
+      config = Struct.new(
+        :type_checking,
+        :error_mode,
+        :output_mode,
+        :output_size,
+        :deep_type_check,
+        :union_type_expressions
+      )
       @config ||= config.new(true, :error, :type, 100, false, true)
     end
 

data/lib/proxies/class_proxy.rb

@@ -2,7 +2,7 @@
 
 require 'forwardable'
 
-module LowType
+module Low
   class ClassProxy
     extend Forwardable
 

data/lib/proxies/file_proxy.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LowType
+module Low
   class FileProxy
     attr_reader :path, :scope
     attr_accessor :start_line, :end_line

data/lib/proxies/local_proxy.rb

@@ -3,7 +3,7 @@
 require_relative '../interfaces/error_interface'
 require_relative '../types/error_types'
 
-module LowType
+module Low
   class LocalProxy < ErrorInterface
     attr_reader :type_expression, :name
 

data/lib/proxies/method_proxy.rb

@@ -2,7 +2,7 @@
 
 require 'forwardable'
 
-module LowType
+module Low
   class MethodProxy
     extend Forwardable
 

data/lib/proxies/param_proxy.rb

@@ -3,14 +3,14 @@
 require_relative '../interfaces/error_interface'
 require_relative '../types/error_types'
 
-module LowType
+module Low
   class ParamProxy < ErrorInterface
-    attr_reader :type_expression, :name, :type, :position
+    attr_reader :expression, :name, :type, :position
 
-    def initialize(type_expression:, name:, type:, file:, position: nil)
+    def initialize(expression:, name:, type:, file:, position: nil)
       super()
 
-      @type_expression = type_expression
+      @expression = expression
       @name = name
       @type = type
       @position = position
@@ -18,7 +18,7 @@ module LowType
     end
 
     def required?
-      @type_expression.default_value == :LOW_TYPE_UNDEFINED
+      @expression.required?
     end
 
     def error_type
@@ -26,7 +26,7 @@ module LowType
     end
 
     def error_message(value:)
-      "Invalid argument type '#{output(value:)}' for parameter '#{@name}'. Valid types: '#{@type_expression.valid_types}'"
+      "Invalid argument type '#{output(value:)}' for parameter '#{@name}'. Valid types: '#{@expression.valid_types}'"
     end
   end
 end

data/lib/proxies/return_proxy.rb

@@ -3,7 +3,7 @@
 require_relative '../interfaces/error_interface'
 require_relative '../types/error_types'
 
-module LowType
+module Low
   class ReturnProxy < ErrorInterface
     attr_reader :type_expression, :name
 

data/lib/queries/file_parser.rb

@@ -3,7 +3,7 @@
 require 'prism'
 require_relative '../proxies/class_proxy'
 
-module LowType
+module Low
   class FileParser
     attr_reader :parent_map, :instance_methods, :class_methods, :class_proxy
 

data/lib/queries/file_query.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LowType
+module Low
   class FileQuery
     class << self
       def file_path(klass:)

data/lib/queries/type_query.rb

@@ -2,7 +2,7 @@
 
 require_relative '../expressions/type_expression'
 
-module LowType
+module Low
   # TODO: Unit test.
   class TypeQuery
     class << self
@@ -19,7 +19,7 @@ module LowType
       end
 
       def complex_type?(expression:)
-        LowType::COMPLEX_TYPES.include?(expression) || typed_array?(expression:) || typed_hash?(expression:)
+        Low::COMPLEX_TYPES.include?(expression) || typed_array?(expression:) || typed_hash?(expression:)
       end
 
       private

data/lib/syntax/syntax.rb

@@ -6,7 +6,9 @@ module LowType
   module Syntax
     refine Array.singleton_class do
       def [](*expression)
-        return TypeExpression.new(type: [*expression]) if TypeQuery.type?(expression.first) || TypeQuery.typed_array?(expression:)
+        if Low::TypeQuery.type?(expression.first) || Low::TypeQuery.typed_array?(expression:)
+          return Low::TypeExpression.new(type: [*expression])
+        end
 
         super
       end
@@ -14,7 +16,7 @@ module LowType
 
     refine Hash.singleton_class do
       def [](type)
-        return TypeExpression.new(type:) if TypeQuery.type?(type)
+        return Low::TypeExpression.new(type:) if Low::TypeQuery.type?(type)
 
         super
       end

data/lib/syntax/union_types.rb

@@ -8,21 +8,13 @@
 # @see LowType.config.union_type_expressions
 ###
 class Object
-  # For "Type | [type_expression/type/value]" situations, redirecting to or generating a type expression from types.
+  # For "Type | [type_expression/type/value]" situations, convert type into a type expression to continue the chain.
   # "|" is not defined on Object class and this is the most compute-efficient way to achieve our goal (world peace).
   # "|" is overridable by any child object. While we could def/undef this method, this approach is actually lighter.
   # "|" bitwise operator on Integer is not defined when the receiver is an Integer class, so we are not in conflict.
   class << self
     def |(expression)
-      if expression.instance_of?(::LowType::TypeExpression)
-        # We pass our type into their type expression.
-        expression | self
-        expression
-      else
-        # We turn our type into a type expression and pass in their type/value.
-        type_expression = ::LowType::TypeExpression.new(type: self)
-        type_expression | expression
-      end
+      ::Low::TypeExpression.new(type: self) | expression
     end
   end
 end

data/lib/types/complex_type.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LowType
+module Low
   module ComplexType
     def match?(value:)
       return true if value.instance_of?(self.class) || value.instance_of?(superclass)

data/lib/types/complex_types.rb

@@ -3,7 +3,7 @@
 require_relative '../factories/type_factory'
 require_relative 'status'
 
-module LowType
+module Low
   COMPLEX_TYPES = [
     Boolean = TypeFactory.complex_type(Object),
     Headers = TypeFactory.complex_type(Hash),

data/lib/types/error_types.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module LowType
+module Low
   class ArgumentTypeError < TypeError; end
   class LocalTypeError < TypeError; end
   class ReturnTypeError < TypeError; end

data/lib/types/status.rb

@@ -3,7 +3,7 @@
 require_relative 'complex_type'
 require_relative 'error_types'
 
-module LowType
+module Low
   # Status is an Integer for type checking, but an instance of StatusCode for advanced functionality.
   class Status < Integer
     extend ComplexType

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module LowType
-  VERSION = '1.1.6'
+module Low
+  TYPE_VERSION = '1.1.7'
 end

metadata

@@ -1,14 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 1.1.7
 platform: ruby
 authors:
 - maedi
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies: []
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: expressions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 description: An elegant and simple way to define types in Ruby, only when you need
   them.
 email:
@@ -47,11 +61,11 @@ files:
 - lib/types/error_types.rb
 - lib/types/status.rb
 - lib/version.rb
-homepage: https://codeberg.org/low_ruby/low_type
+homepage: https://github.com/low-rb/low_type
 licenses: []
 metadata:
-  homepage_uri: https://codeberg.org/low_ruby/low_type
-  source_code_uri: https://codeberg.org/low_ruby/low_type/src/branch/main
+  homepage_uri: https://github.com/low-rb/low_type
+  source_code_uri: https://github.com/low-rb/low_type/src/branch/main
 rdoc_options: []
 require_paths:
 - lib