lowtype 1.3.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c777de40504eea68870df0ee7936de827b1e5a771aca97e40d1ef2b41d3e38ed
+  data.tar.gz: cab3b2a605413173922eee3680a18951f19ec28065e0eb320d5d649b99300c34
+SHA512:
+  metadata.gz: 7c4391bb32203a889a6a88ebdbe2895fd19bf8f195caa2a6d890475a5312fbb4b3e184bd5ea7a6d0031d95246411b8c56cf8323f62774aeda7d78b958f6bd2f0
+  data.tar.gz: d958d6ccd1f5d6c8c328aef5d7a12b2a46dc75253f82ed0f26d31da29666aa81f6e49e06515be901f6bd1ee5c4781e048131ef5d72505fd753da9135a52dee05

data/lib/adapters/adapter_loader.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'sinatra_adapter'
+
+module Low
+  module Adapter
+    class Loader
+      class << self
+        def load(klass:, class_proxy:)
+          ancestors = klass.ancestors.map(&:to_s)
+
+          return unless ancestors.include?('Sinatra::Base')
+
+          klass.prepend SinatraAdapter.new.module(file_path: class_proxy.file_path)
+        end
+      end
+    end
+  end
+end

data/lib/adapters/sinatra_adapter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'prism'
+require 'lowkey'
+
+require_relative '../interfaces/adapter_interface'
+require_relative '../proxies/return_proxy'
+require_relative '../types/error_types'
+
+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 SinatraAdapter < AdapterInterface
+      def module(file_path:) # rubocop:disable Metrics/AbcSize
+        Module.new do
+          @@file_path = file_path # rubocop:disable Style/ClassVars
+
+          # Unfortunately overriding invoke() is the best way to validate types for now. Though direct it's also very compute efficient.
+          # I originally tried an after filter and it mostly worked but it only had access to Response which isn't the raw return value.
+          # I suggest that Sinatra provide a hook that allows us to access the raw return value of a route before it becomes a Response.
+          def invoke(&block)
+            res = catch(:halt, &block)
+
+            lowtype_validate!(value: res) if res
+
+            res = [res] if res.is_a?(Integer) || res.is_a?(String)
+            if res.is_a?(::Array) && res.first.is_a?(Integer)
+              res = res.dup
+              status(res.shift)
+              body(res.pop)
+              headers(*res)
+            elsif res.respond_to? :each
+              body res
+            end
+
+            nil # avoid double setting the same response tuple twice
+          end
+
+          def lowtype_validate!(value:)
+            route = "#{request.request_method} #{request.path}"
+            if (method_proxy = Lowkey[@@file_path][self.class.name][route]) && (proxy = method_proxy.return_proxy)
+              proxy.expression.validate!(value:, proxy:)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/definitions/evaluator.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'expressions'
+require 'lowkey'
+
+require_relative '../expressions/expression_helpers'
+require_relative '../expressions/type_expression'
+require_relative '../syntax/syntax'
+require_relative '../types/complex_types'
+require_relative '../types/status'
+
+module Low
+  # Evaluate code stored in strings into constants and values.
+  # ┌────────┐     ┌─────────┐     ┌─────────────┐     ┌─────────┐     ┌─────────┐
+  # │ Lowkey │     │ Proxies │     │ Expressions │     │ LowType │     │ Methods │
+  # └────┬───┘     └────┬────┘     └──────┬──────┘     └────┬────┘     └────┬────┘
+  #      │              │                 │                 │               │
+  #      │ Parses AST   │                 │                 │               │
+  #      ├─────────────►│                 │                 │               │
+  #      │              │                 │                 │               │
+  #      │              │ Stores          │                 │               │
+  #      │              ├────────────────►│                 │               │
+  #      │              │                 │                 │               │
+  #      │              │                 │ Evaluates <-- YOU ARE HERE.     |
+  #      │              │                 │◄────────────────┤               │
+  #      │              │                 │                 │               │
+  #      │              │                 │                 │ Redefines     │
+  #      │              │                 │                 ├──────────────►│
+  #      │              │                 │                 │               │
+  #      │              │                 │ Validates       │               │
+  #      │              │                 │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤
+  #      │              │                 │                 │               │
+  class Evaluator
+    include ExpressionHelpers
+    include Types
+    using LowType::Syntax
+
+    def low_evaluate(proxy:)
+      # Not a security risk because the code comes from a trusted source; the file that included lowtype.
+      eval(proxy.value, binding, proxy.file_path, proxy.start_line) # rubocop:disable Security/Eval
+    end
+
+    def class_evaluate(proxy:, class_binding:)
+      # Not a security risk because the code comes from a trusted source; the file that included lowtype.
+      eval(proxy.value, class_binding, proxy.file_path, proxy.start_line) # rubocop:disable Security/Eval
+    end
+
+    class << self
+      def evaluate(method_proxies:, class_binding: nil)
+        require_relative '../syntax/union_types' if LowType.config.union_type_expressions
+
+        method_proxies.each_value do |method_proxy|
+          evaluate_param_proxy_expressions(method_proxy:, class_binding:)
+          evaluate_return_proxy_expression(return_proxy: method_proxy.return_proxy) if method_proxy.return_proxy
+        end
+      end
+
+      def evaluate_param_proxy_expressions(method_proxy:, class_binding: nil)
+        begin # rubocop:disable Style/RedundantBegin
+          method_proxy.tagged_params(:value).each do |param_proxy|
+            expression = begin
+              new.low_evaluate(proxy: param_proxy)
+            rescue NameError
+              raise unless class_binding
+
+              new.class_evaluate(proxy: param_proxy, class_binding:)
+            end
+            param_proxy.expression = cast_type_expression(expression:, param_proxy:)
+          end
+        rescue NameError => e
+          mp = method_proxy
+          raise NameError, "Unknown type '#{e.name}' for #{mp.scope} at #{mp.file_path}:#{mp.start_line}"
+        end
+      end
+
+      def evaluate_return_proxy_expression(return_proxy:)
+        begin
+          expression = new.low_evaluate(proxy: return_proxy)
+        rescue NameError
+          rp = return_proxy
+          raise NameError, "Unknown return type '#{rp.value}' for #{rp.scope} at #{rp.file_path}:#{rp.start_line}"
+        end
+
+        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
+
+        return_proxy.expression = expression
+      end
+
+      private
+
+      def cast_type_expression(expression:, param_proxy:)
+        if expression.is_a?(::Expressions::Expression)
+          return expression
+        elsif expression.instance_of?(Class) && expression.name == 'Low::Dependency'
+          return expression.new(provider_key: param_proxy.name)
+        elsif TypeQuery.type?(expression)
+          return TypeExpression.new(type: expression)
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/definitions/redefiner.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require_relative '../expressions/value_expression'
+require_relative '../definitions/evaluator'
+
+module Low
+  # Redefine methods to have their arguments and return values type checked.
+  # ┌────────┐     ┌─────────┐     ┌─────────────┐     ┌─────────┐     ┌─────────┐
+  # │ Lowkey │     │ Proxies │     │ Expressions │     │ LowType │     │ Methods │
+  # └────┬───┘     └────┬────┘     └──────┬──────┘     └────┬────┘     └────┬────┘
+  #      │              │                 │                 │               │
+  #      │ Parses AST   │                 │                 │               │
+  #      ├─────────────►│                 │                 │               │
+  #      │              │                 │                 │               │
+  #      │              │ Stores          │                 │               │
+  #      │              ├────────────────►│                 │               │
+  #      │              │                 │                 │               │
+  #      │              │                 │ Evaluates       │               │
+  #      │              │                 │◄────────────────┤               │
+  #      │              │                 │                 │               │
+  #      │              │                 │                 │ Redefines <-- YOU ARE HERE.
+  #      │              │                 │                 ├──────────────►│
+  #      │              │                 │                 │               │
+  #      │              │                 │ Validates       │               │
+  #      │              │                 │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤
+  #      │              │                 │                 │               │
+  class Redefiner
+    class << self
+      # TODO: Pass in "klass" and use it to class_eval/eval methods in the binding of the class that included LowType.
+      def redefine(method_proxies:, class_proxy:)
+        if LowType.config.type_checking
+          typed_methods(method_proxies:, class_proxy:)
+        else
+          untyped_methods(method_proxies:, class_proxy:)
+        end
+      end
+
+      def untyped_args(args:, kwargs:, method_proxy:) # rubocop:disable Metrics/AbcSize
+        method_proxy.params_with_expressions.each do |param_proxy|
+          value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
+
+          next unless value.nil?
+          raise param_proxy.error_type, param_proxy.error_message(value:) if param_proxy.expression.required?
+
+          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
+
+        [args, kwargs]
+      end
+
+      private
+
+      def typed_methods(method_proxies:, class_proxy:) # rubocop:disable Metrics
+        Module.new do
+          method_proxies.values.filter(&:expressions?).each do |method_proxy|
+            define_method(method_proxy.name) do |*args, **kwargs|
+              method_proxy.params_with_expressions.each do |param_proxy|
+                positional = %i[pos_req pos_opt].include?(param_proxy.type)
+
+                value = positional ? args[param_proxy.position] : kwargs[param_proxy.name]
+                value = param_proxy.expression.default_value if value.nil? && !param_proxy.expression.required?
+
+                param_proxy.expression.validate!(value:, proxy: param_proxy)
+                value = value.value if value.is_a?(ValueExpression)
+
+                positional ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
+              end
+
+              if (return_proxy = method_proxy.return_proxy)
+                return_value = super(*args, **kwargs)
+                return_proxy.expression.validate!(value: return_value, proxy: return_proxy)
+                return return_value
+              end
+
+              super(*args, **kwargs)
+            end
+
+            private method_proxy.name if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
+          end
+        end
+      end
+
+      def untyped_methods(method_proxies:, class_proxy:)
+        Module.new do
+          method_proxies.values.filter(&:expressions?).each do |method_proxy|
+            # You are now in the binding of the includer class.
+            define_method(method_proxy.name) do |*args, **kwargs|
+              # NOTE: Type checking is currently disabled. See 'config.type_checking'.
+              method_proxy = Lowkey[class_proxy.file_path][class_proxy.namespace][__method__]
+
+              args, kwargs = Low::Redefiner.untyped_args(args:, kwargs:, method_proxy:)
+              super(*args, **kwargs)
+            end
+
+            private method_proxy.name if class_proxy.private_start_line && method_proxy.start_line > class_proxy.private_start_line
+          end
+        end
+      end
+    end
+  end
+end

data/lib/definitions/type_accessors.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../expressions/type_expression'
+require_relative '../proxies/return_proxy'
+require_relative '../queries/type_query'
+
+module Low
+  # Usage:
+  #
+  # type_accessor name: String # => @name getter and @name=() setter
+  # type_accessor name: String | 'Cher'
+  #
+  # type_reader name: String
+  # type_reader name: String | 'Cher' # defaults to 'Cher' if nil
+  #
+  # type_writer name: String
+  # type_writer name: String | nil # accepts String or nil
+  #
+  module TypeAccessors
+    def type_reader(named_expressions)
+      named_expressions.each do |name, exp|
+        last_caller = caller_locations(1, 1).first
+
+        file_path = last_caller.path
+        scope = "#{self}##{name}"
+
+        expression = cast_type_expression(exp)
+        # Source usually defined on file load with access to lines in a source file, but type accessors are defined on class load.
+        source = ::Lowkey::Source.new(file_path:, scope:, lines: [], start_line: last_caller.lineno, end_line: last_caller.lineno)
+        proxy = ::Lowkey::ReturnProxy.new(name:, source:, expression:)
+
+        define_method(name) do
+          value = instance_variable_get("@#{name}")
+          expression.validate!(value:, proxy:)
+          value
+        end
+      end
+    end
+
+    def type_writer(named_expressions)
+      named_expressions.each do |name, expression|
+        last_caller = caller_locations(1, 1).first
+
+        file_path = last_caller.path
+        scope = "#{self}##{name}"
+
+        expression = cast_type_expression(expression)
+        # Source usually defined on file load with access to lines in a source file, but type accessors are defined on class load.
+        source = ::Lowkey::Source.new(file_path:, scope:, lines: [], start_line: last_caller.lineno, end_line: last_caller.lineno)
+        proxy = ::Lowkey::ParamProxy.new(name:, source:, type: :pos_req, position: nil, expression:)
+
+        define_method("#{name}=") do |value|
+          expression.validate!(value:, proxy:)
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+
+    def type_accessor(named_expressions)
+      named_expressions.each do |name, expression|
+        type_reader({ name => expression })
+        type_writer({ name => expression })
+      end
+    end
+
+    private
+
+    def cast_type_expression(expression)
+      if expression.is_a?(::Expressions::Expression)
+        expression
+      elsif TypeQuery.type?(expression)
+        TypeExpression.new(type: expression)
+      end
+    end
+  end
+end

data/lib/expressions/expression_helpers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'type_expression'
+require_relative 'value_expression'
+require_relative '../proxies/local_proxy'
+
+module Low
+  module ExpressionHelpers
+    def type(type_expression)
+      value = type_expression.default_value
+
+      last_caller = caller_locations(1, 1).first
+      file_path = last_caller.path
+      start_line = last_caller.lineno
+      proxy = LocalProxy.new(type_expression:, name: self, file_path:, start_line:, scope: 'local type')
+
+      type_expression.validate!(value:, proxy:)
+
+      return value.value if value.is_a?(ValueExpression)
+
+      value
+    rescue NoMethodError
+      raise ConfigError, "Invalid type expression. Did you add 'using LowType::Syntax'?"
+    end
+    alias low_type type
+
+    def value(type)
+      TypeExpression.new(default_value: ValueExpression.new(value: type))
+    end
+    alias low_value value
+  end
+end

data/lib/expressions/type_expression.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'expressions'
+
+require_relative 'value_expression'
+require_relative '../proxies/param_proxy'
+require_relative '../queries/type_query'
+
+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") }
+
+  HIDDEN_PATHS = [File.expand_path(__FILE__), *adapter_paths, *module_paths].freeze
+
+  # Represent types and default values as a series of chainable expressions.
+  class TypeExpression < ::Expressions::Expression
+    attr_reader :types, :default_value
+
+    # @param type - A literal type or an instance representation of a typed structure.
+    def initialize(type: nil, default_value: :LOW_TYPE_UNDEFINED)
+      @types = []
+      @types << type unless type.nil?
+      @default_value = default_value
+      # TODO: Override per type expression with a config expression.
+      @deep_type_check = nil
+    end
+
+    def required?
+      @default_value == :LOW_TYPE_UNDEFINED
+    end
+
+    def validate!(value:, proxy:) # rubocop:disable Metrics
+      if value.nil?
+        return true if @default_value.nil?
+        raise proxy.error_type, proxy.error_message(value:) if required?
+      end
+
+      @types.each do |type|
+        return true if type_matches_value?(type:, value:, proxy:)
+        return true if type.is_a?(Array) && value.is_a?(Array) && array_types_match_values?(types: type, values: value, proxy:)
+        return true if type.is_a?(Hash) && value.is_a?(Hash) && hash_types_match_values?(types: type, values: value)
+      end
+
+      raise proxy.error_type, proxy.error_message(value:)
+    rescue proxy.error_type => e
+      raise proxy.error_type, e.message, proxy.backtrace(backtrace: e.backtrace, hidden_paths: HIDDEN_PATHS)
+    end
+
+    def valid_types
+      types = @types.map do |type|
+        if type.is_a?(Array)
+          "[#{type.map { |subtype| valid_subtype(subtype:) }.join(', ')}]"
+        else
+          type.inspect.to_s.delete_prefix('Low::Types::')
+        end
+      end
+
+      types << 'nil' if @default_value.nil?
+      types.join(' | ')
+    end
+
+    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)
+      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('Low::Types::')
+      end
+    end
+
+    def array_types_match_values?(types:, values:, proxy:)
+      # [X, Y, Z] An arbitrary amount of elements are arbitrary types in an arbitrary order.
+      if types.length > 1
+        return multiple_types_match_values?(types:, values:, proxy:)
+      # [T] All elements are the same type.
+      elsif types.length == 1
+        return single_type_matches_values?(type: types.first, values:, proxy:)
+      end
+
+      # [] Misconfigured empty Array[] type.
+      true
+    end
+
+    def multiple_types_match_values?(types:, values:, proxy:)
+      types.each_with_index do |type, index|
+        return false unless type_matches_value?(type:, value: values[index], proxy:)
+      end
+
+      true
+    end
+
+    def single_type_matches_values?(type:, values:, proxy:)
+      # [V, ...] Type check all elements.
+      if deep_type_check?
+        return false if values.any? { |value| !type_matches_value?(type:, value:, proxy:) }
+      # [V] Type check the first element.
+      else
+        return false unless type_matches_value?(type:, value: values.first, proxy:)
+      end
+
+      true
+    end
+
+    def hash_types_match_values?(types:, values:)
+      return true if values.empty? && empty_hash_default_value?
+      return values.empty? if types.empty?
+      return false if values.empty?
+
+      # TODO: Shallow validation of hash could be made deeper with user config.
+      types.keys[0] == values.keys[0].class && types.values[0] == values.values[0].class
+    end
+
+    def type_matches_value?(type:, value:, proxy:)
+      if type.instance_of?(Class)
+        return type.match?(value:) if Low::TypeQuery.complex_type?(expression: type)
+        return value.value <= type if value.instance_of?(ValueExpression)
+
+        return value.is_a?(type)
+      elsif type.instance_of?(Low::TypeExpression)
+        type.validate!(value:, proxy:)
+        return true
+      end
+
+      false
+    end
+
+    def deep_type_check?
+      return @deep_type_check unless @deep_type_check.nil?
+
+      LowType.config.deep_type_check
+    end
+
+    def empty_hash_default_value?
+      @default_value.is_a?(Hash) && @default_value.empty?
+    end
+  end
+end

data/lib/expressions/value_expression.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Low
+  # A value expression presents a type as a value:
+  #   1. It is an instance
+  #   2. It mimics the class method
+  class ValueExpression
+    attr_reader :value
+
+    def initialize(value:)
+      @value = value
+    end
+
+    def class
+      @value
+    end
+  end
+end

data/lib/factories/type_factory.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Low
+  class TypeFactory
+    class << self
+      def complex_type(parent_type)
+        Class.new(parent_type) do
+          def self.match?(value:)
+            return true if value.instance_of?(self.class) || value.instance_of?(superclass)
+
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interfaces/adapter_interface.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Low
+  class AdapterInterface
+    def module
+      nil
+    end
+  end
+end

data/lib/interfaces/error_handling.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Low
+  # Used by proxies to output errors.
+  module ErrorHandling
+    def error_type
+      raise NotImplementedError
+    end
+
+    def error_message(value:)
+      raise NotImplementedError
+    end
+
+    def output(value:)
+      case LowType.config.output_mode
+      when :type
+        # TODO: Show full type structure in error output instead of just the type of the supertype.
+        value.class
+      when :value
+        value.inspect[0...LowType.config.output_size]
+      else
+        'REDACTED'
+      end
+    end
+
+    def backtrace(backtrace:, hidden_paths:)
+      # Remove LowType defined method file paths from the backtrace.
+      filtered_backtrace = backtrace.reject { |line| hidden_paths.find { |file_path| line.include?(file_path) } }
+
+      # Add the proxied entity to the backtrace.
+      proxy_file_backtrace = "#{file_path}:#{start_line}:in '#{scope}'"
+      from_prefix = filtered_backtrace.first.match(/\s+from /)
+      proxy_file_backtrace = "#{from_prefix}#{proxy_file_backtrace}" if from_prefix
+
+      [proxy_file_backtrace, *filtered_backtrace]
+    end
+  end
+end

data/lib/lowtype.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'lowkey'
+
+require_relative 'adapters/adapter_loader'
+require_relative 'definitions/redefiner'
+require_relative 'definitions/type_accessors'
+require_relative 'expressions/expression_helpers'
+require_relative 'queries/file_query'
+require_relative 'syntax/syntax'
+require_relative 'types/complex_types'
+
+# Architecture:
+# ┌────────┐     ┌─────────┐     ┌─────────────┐     ┌─────────┐     ┌─────────┐
+# │ Lowkey │     │ Proxies │     │ Expressions │     │ LowType │     │ Methods │
+# └────┬───┘     └────┬────┘     └──────┬──────┘     └────┬────┘     └────┬────┘
+#      │              │                 │                 │               │
+#      │ Parses AST   │                 │                 │               │
+#      ├─────────────►│                 │                 │               │
+#      │              │                 │                 │               │
+#      │              │ Stores          │                 │               │
+#      │              ├────────────────►│                 │               │
+#      │              │                 │                 │               │
+#      │              │                 │ Evaluates       │               │
+#      │              │                 │◄────────────────┤               │
+#      │              │                 │                 │               │
+#      │              │                 │                 │ Redefines     │
+#      │              │                 │                 ├──────────────►│
+#      │              │                 │                 │               │
+#      │              │                 │ Validates       │               │
+#      │              │                 │◄┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┤
+#      │              │                 │                 │               │
+module LowType
+  # Defers evaluation and redefinition until after the class body finishes loading via TracePoint :end.
+  def self.included(klass)
+    file_path = Low::FileQuery.file_path(klass:)
+    file_proxy = Lowkey.load(file_path)
+    class_proxy = file_proxy[klass.name]
+
+    klass.include Low::ExpressionHelpers
+    klass.extend Low::ExpressionHelpers
+    klass.extend Low::TypeAccessors
+    klass.extend Low::Types
+
+    # Use TracePoint :end to capture the class binding after the class body finishes loading.
+    # At :end time, trace.self is the including class and trace.binding is the class body's binding,
+    # stored on class_proxy.class_binding for use by LowType and other consumers.
+    tp = TracePoint.new(:end) do |trace|
+      next unless trace.self == klass
+
+      class_proxy.class_binding = trace.binding
+
+      Low::Evaluator.evaluate(method_proxies: class_proxy.keyed_methods, class_binding: class_proxy.class_binding)
+
+      klass.prepend Low::Redefiner.redefine(method_proxies: class_proxy.instance_methods, class_proxy:)
+      klass.singleton_class.prepend Low::Redefiner.redefine(method_proxies: class_proxy.class_methods, class_proxy:)
+
+      Low::Adapter::Loader.load(klass:, class_proxy:)
+
+      tp.disable
+    end
+
+    tp.enable
+  end
+
+  Config = Struct.new(
+    :type_checking,
+    :error_mode,
+    :output_mode,
+    :output_size,
+    :deep_type_check,
+    :union_type_expressions
+  )
+
+  class << self
+    def config
+      @config ||= Config.new(true, :error, :type, 100, true, true)
+    end
+
+    def configure
+      yield(config)
+    end
+  end
+end

data/lib/proxies/local_proxy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/error_handling'
+require_relative '../types/error_types'
+
+module Low
+  class LocalProxy
+    include ErrorHandling
+
+    attr_reader :type_expression, :name, :file_path, :start_line, :scope
+
+    def initialize(type_expression:, name:, file_path:, start_line:, scope:)
+      @file_path = file_path
+      @start_line = start_line
+      @scope = scope
+
+      @type_expression = type_expression
+      @name = name
+    end
+
+    def error_type
+      LocalTypeError
+    end
+
+    def error_message(value:)
+      "Invalid variable type #{output(value:)} in '#{name.class}:#{@start_line}'. Valid types: '#{type_expression.valid_types}'"
+    end
+  end
+end

data/lib/proxies/param_proxy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'lowkey'
+
+require_relative '../interfaces/error_handling'
+require_relative '../types/error_types'
+
+module ::Lowkey
+  class ParamProxy
+    include ::Low::ErrorHandling
+
+    def error_type
+      ::Low::ArgumentTypeError
+    end
+
+    def error_message(value:)
+      "Invalid argument type '#{output(value:)}' for parameter '#{@name}'. Valid types: '#{@expression.valid_types}'"
+    end
+  end
+end

data/lib/proxies/return_proxy.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'lowkey'
+
+require_relative '../interfaces/error_handling'
+require_relative '../types/error_types'
+
+module ::Lowkey
+  class ReturnProxy
+    include ::Low::ErrorHandling
+
+    def error_type
+      ::Low::ReturnTypeError
+    end
+
+    def error_message(value:)
+      "Invalid return type '#{output(value:)}' for method '#{@name}'. Valid types: '#{@expression.valid_types}'"
+    end
+  end
+end

data/lib/queries/file_query.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Low
+  class MissingFileError < StandardError; end
+
+  class FileQuery
+    class << self
+      def file_path(klass:)
+        file_path = Object.const_source_location(klass.name).first
+
+        return file_path if File.exist?(file_path)
+
+        raise MissingFileError, "No file found at path '#{file_path}'"
+      end
+    end
+  end
+end

data/lib/queries/type_query.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../expressions/type_expression'
+
+module Low
+  # TODO: Unit test.
+  class TypeQuery
+    class << self
+      def type?(expression)
+        basic_type?(expression:) || complex_type?(expression:)
+      end
+
+      def typed_array?(expression:)
+        expression.is_a?(Array) && (basic_type?(expression: expression.first) || expression.first.is_a?(TypeExpression))
+      end
+
+      def value?(value)
+        !basic_type?(expression: value) && !complex_type?(expression: value)
+      end
+
+      def complex_type?(expression:)
+        Low::Types::COMPLEX_TYPES.include?(expression) || typed_array?(expression:) || typed_hash?(expression:)
+      end
+
+      private
+
+      def basic_type?(expression:)
+        expression.instance_of?(Class)
+      end
+
+      def typed_hash?(expression:)
+        expression.is_a?(Hash) && basic_type?(expression: expression.keys.first) && basic_type?(expression: expression.values.first)
+      end
+    end
+  end
+end

data/lib/syntax/syntax.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../queries/type_query'
+
+module LowType
+  module Syntax
+    refine Array.singleton_class do
+      def [](*expression)
+        if Low::TypeQuery.type?(expression.first) || Low::TypeQuery.typed_array?(expression:)
+          return Low::TypeExpression.new(type: [*expression])
+        end
+
+        super
+      end
+    end
+
+    refine Hash.singleton_class do
+      def [](type)
+        return Low::TypeExpression.new(type:) if Low::TypeQuery.type?(type)
+
+        super
+      end
+    end
+  end
+end

data/lib/syntax/union_types.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+###
+# Type expressions from union types.
+#
+# The "|" pipe syntax requires a monkey-patch but can be disabled if you don't need union types with default values.
+# This is the only monkey-patch in the entire library and is a relatively harmless one.
+# @see LowType.config.union_type_expressions
+###
+class Object
+  # 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)
+      ::Low::TypeExpression.new(type: self) | expression
+    end
+  end
+end

data/lib/types/complex_type.rb

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

data/lib/types/complex_types.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../factories/type_factory'
+require_relative 'status'
+
+module Low
+  module Types
+    COMPLEX_TYPES = [
+      Boolean = TypeFactory.complex_type(Object),
+      Headers = TypeFactory.complex_type(Hash),
+      HTML = TypeFactory.complex_type(String),
+      JSON = TypeFactory.complex_type(String),
+      Status,
+      Tuple = TypeFactory.complex_type(Array),
+      XML = TypeFactory.complex_type(String)
+    ].freeze
+  end
+end

data/lib/types/error_types.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Low
+  class ArgumentTypeError < TypeError; end
+  class LocalTypeError < TypeError; end
+  class ReturnTypeError < TypeError; end
+  class AllowedTypeError < TypeError; end
+  class ConfigError < TypeError; end
+end

data/lib/types/status.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'complex_type'
+require_relative 'error_types'
+
+module Low
+  module Types
+    # Status is an Integer for basic type checking...
+    class Status < Integer
+      extend ComplexType
+
+      # ...but becomes an instance of StatusCode when called with "Status[:code]" for advanced type checking (status + code).
+      def self.[](status_code)
+        @status_code = StatusCode.new(status_code)
+      end
+
+      class StatusCode
+        attr_reader :status_code
+
+        STATUS_CODES = [
+          # Info.
+          100, 101, 102, 103,
+          # Success.
+          200, 201, 202, 203, 204, 205, 206, 207, 208, 226,
+          # Redirect.
+          300, 301, 302, 303, 304, 305, 306, 307, 308,
+          # Client Error.
+          400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
+          415, 416, 417, 418, 421, 422, 423, 424, 425, 426, 428, 429, 431, 451,
+          # Server Error.
+          500, 501, 502, 503, 504, 505, 506, 507, 508, 510, 511
+        ].freeze
+
+        def initialize(status_code)
+          raise AllowedTypeError unless STATUS_CODES.include?(status_code)
+
+          @status_code = status_code
+        end
+
+        def ==(other)
+          other.class == self.class && other.status_code == @status_code
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def hash
+          [self.class, @status_code].hash
+        end
+      end
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Low
+  module Type
+    VERSION = '1.3.2'
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: lowtype
+version: !ruby/object:Gem::Version
+  version: 1.3.2
+platform: ruby
+authors:
+- maedi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+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'
+- !ruby/object:Gem::Dependency
+  name: lowkey
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: "LowType introduces the concept of \"type expressions\" in method arguments.
+  \nWhen an argument's default value resolves to a type instead of a value then it's
+  treated as a type expression. \nNow you can have types in Ruby in the simplest syntax
+  possible\n"
+email:
+- maediprichard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/adapters/adapter_loader.rb
+- lib/adapters/sinatra_adapter.rb
+- lib/definitions/evaluator.rb
+- lib/definitions/redefiner.rb
+- lib/definitions/type_accessors.rb
+- lib/expressions/expression_helpers.rb
+- lib/expressions/type_expression.rb
+- lib/expressions/value_expression.rb
+- lib/factories/type_factory.rb
+- lib/interfaces/adapter_interface.rb
+- lib/interfaces/error_handling.rb
+- lib/lowtype.rb
+- lib/proxies/local_proxy.rb
+- lib/proxies/param_proxy.rb
+- lib/proxies/return_proxy.rb
+- lib/queries/file_query.rb
+- lib/queries/type_query.rb
+- lib/syntax/syntax.rb
+- lib/syntax/union_types.rb
+- lib/types/complex_type.rb
+- lib/types/complex_types.rb
+- lib/types/error_types.rb
+- lib/types/status.rb
+- lib/version.rb
+homepage: https://github.com/low-rb/lowtype
+licenses: []
+metadata:
+  homepage_uri: https://github.com/low-rb/lowtype
+  source_code_uri: https://github.com/low-rb/lowtype/src/branch/main
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Elegant types in Ruby
+test_files: []