low_type 0.9.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a340469d2c2f4945b043ab3cd4973f14cf12f9d80336b7939bdb85b0da5b739e
-  data.tar.gz: 2e51c25e1b944dff67fb85f4582a2f3f38eca299fe58d4cc464c4b8c162a9d8a
+  metadata.gz: 3541ef39f820d9554a2493481686ad0692f66d36a31920d2c4304a62cb55bbb9
+  data.tar.gz: 19bebceb57fff771317130dae93e5caf86962028db3e81321b03855ccf3c42cb
 SHA512:
-  metadata.gz: 8857cb2e301aa2e7f4ddf167fe622d3988d7d28ff223361a50a056f28ea248e4ad81ecc48fc2174f2f8845c7af7e8fad072ac9bf3ed4eea5a0bad37a06ab9b6d
-  data.tar.gz: c401324adf4f5aa4b4da5a1c6f19d5b3daa095e7ff28a43a9075f28f4d7a8947a13fcba500bab252eece331b51d65e89fee09efd99e1d61f5e0290faae51dab7
+  metadata.gz: 61dace65facc045407b0300157a9e66e6269b14a3414ed943ed3bb5bd817ab313d4c10fd184cad0c2f6803c50a03c6c7d5929253ce68ba89b909a49f55d79fcb
+  data.tar.gz: 207f390f476e60af068bffc5bed65c0f76f20bc4997e1d76905496779e63aeaf9022405fe95576d4d8f14ad35107ea6c07f8a98fb4ddfb447d50eff35a1a6921

data/lib/adapters/sinatra_adapter.rb

@@ -5,7 +5,7 @@ require 'prism'
 require_relative '../interfaces/adapter_interface'
 require_relative '../proxies/file_proxy'
 require_relative '../proxies/return_proxy'
-require_relative '../error_types'
+require_relative '../types/error_types'
 
 module LowType
   module Adapter
@@ -27,7 +27,7 @@ module LowType
 
           pattern = arguments_node.arguments.first.content
 
-          line = Parser.line_number(node: method_call)
+          line = FileParser.line_number(node: method_call)
           file = FileProxy.new(path: @file_path, line:, scope: "#{@klass}##{method_call.name}")
           next unless (return_proxy = return_proxy(method_node: method_call, pattern:, file:))
 
@@ -38,7 +38,7 @@ module LowType
       end
 
       def return_proxy(method_node:, pattern:, file:)
-        return_type = Parser.return_type(method_node:)
+        return_type = FileParser.return_type(method_node:)
         return nil if return_type.nil?
 
         # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
@@ -50,13 +50,16 @@ module LowType
     end
 
     module Methods
+      # 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)
 
         low_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)
+        if res.is_a?(::Array) && res.first.is_a?(Integer)
           res = res.dup
           status(res.shift)
           body(res.pop)

data/lib/factories/proxy_factory.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require_relative '../proxies/return_proxy'
-require_relative '../parser'
+require_relative '../file_parser'
 require_relative '../type_expression'
 
 module LowType
   class ProxyFactory
     class << self
       def return_proxy(method_node:, file:)
-        return_type = Parser.return_type(method_node:)
+        return_type = FileParser.return_type(method_node:)
         return nil if return_type.nil?
 
         # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?

data/lib/{parser.rb → file_parser.rb}

@@ -3,7 +3,7 @@
 require 'prism'
 
 module LowType
-  class Parser
+  class FileParser
     attr_reader :parent_map, :instance_methods, :class_methods, :private_start_line
 
     def initialize(file_path:)

data/lib/local_types.rb

@@ -2,69 +2,32 @@
 
 require_relative 'proxies/file_proxy'
 require_relative 'proxies/local_proxy'
+require_relative 'types/error_types'
 require_relative 'type_expression'
 require_relative 'value_expression'
 
-module LocalTypes
-  class AssignmentError < StandardError; end
+module LowType
+  module LocalTypes
+    def type(type_expression)
+      value = type_expression.default_value
 
-  def type(type_expression)
-    referenced_object = type_expression.default_value.dup
+      last_caller = caller_locations(1, 1).first
+      file = FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: 'local type')
+      proxy = LocalProxy.new(type_expression:, name: self, file:)
 
-    raise AssignmentError, "Single-instance objects like #{referenced_object} are not supported" unless LowType.value?(referenced_object)
+      type_expression.validate!(value:, proxy:)
 
-    last_caller = caller_locations(1, 1).first
-    file = LowType::FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: 'local type')
-    local_proxy = LowType::LocalProxy.new(type_expression:, name: self, file:)
-    referenced_object.instance_variable_set('@local_proxy', local_proxy)
+      return value.value if value.is_a?(ValueExpression)
 
-    type_expression.validate!(value: referenced_object, proxy: local_proxy)
-
-    define_with_type(referenced_object:)
-
-    return referenced_object.value if referenced_object.is_a?(ValueExpression)
-
-    referenced_object
-  end
-  alias low_type type
-
-  def value(type)
-    LowType.value(type:)
-  end
-  alias low_value value
-
-  # Scoped to the class that includes LowTypes module.
-  class Array < ::Array
-    def self.[](*types)
-      return LowType::TypeExpression.new(type: [*types]) if types.all? { |type| LowType.type?(type) }
-
-      super
+      value
+    rescue NoMethodError
+      raise ConfigError, "Invalid type expression, likely because you didn't add 'using LowType::Syntax'"
     end
-  end
-
-  # Scoped to the class that includes LowTypes module.
-  class Hash < ::Hash
-    def self.[](type)
-      return LowType::TypeExpression.new(type:) if LowType.type?(type)
-
-      super
-    end
-  end
-
-  private
-
-  def define_with_type(referenced_object:)
-    def referenced_object.with_type=(value)
-      local_proxy = instance_variable_get('@local_proxy')
-      type_expression = local_proxy.type_expression
-      type_expression.validate!(value:, proxy: local_proxy)
-
-      # We can't reassign self in Ruby so we reassign instance variables instead.
-      value.instance_variables.each do |variable|
-        instance_variable_set(variable, value.instance_variable_get(variable))
-      end
+    alias low_type type
 
-      self
+    def value(type)
+      LowType.value(type:)
     end
+    alias low_value value
   end
 end

data/lib/low_type.rb

@@ -1,21 +1,17 @@
 # frozen_string_literal: true
 
 require_relative 'adapters/adapter_loader'
-require_relative 'basic_types'
+require_relative 'types/complex_types'
 require_relative 'instance_types'
+require_relative 'local_types'
 require_relative 'redefiner'
+require_relative 'syntax'
 require_relative 'type_expression'
 require_relative 'value_expression'
 
-# Include this module into your class to define and check types.
 module LowType
   # We do as much as possible on class load rather than on instantiation to be thread-safe and efficient.
-  def self.included(klass) # rubocop:disable Metrics/AbcSize
-    # Array[] and Hash[] class method returns a type expression only for the duration of this "included" hook.
-    array_class_method = Array.method('[]').unbind
-    hash_class_method = Hash.method('[]').unbind
-    LowType.redefine(hash_class_method:)
-
+  def self.included(klass)
     class << klass
       def low_methods
         @low_methods ||= {}
@@ -23,10 +19,11 @@ module LowType
     end
 
     file_path = LowType.file_path(klass:)
-    parser = LowType::Parser.new(file_path:)
+    parser = FileParser.new(file_path:)
     private_start_line = parser.private_start_line
 
     klass.extend InstanceTypes
+    klass.include LocalTypes
     klass.prepend LowType::Redefiner.redefine(method_nodes: parser.instance_methods, klass:, private_start_line:, file_path:)
     klass.singleton_class.prepend LowType::Redefiner.redefine(method_nodes: parser.class_methods, klass:, private_start_line:, file_path:)
 
@@ -34,26 +31,18 @@ module LowType
       adapter.process
       klass.prepend Adapter::Methods
     end
-  ensure
-    Array.define_singleton_method('[]', array_class_method)
-    Hash.define_singleton_method('[]', hash_class_method)
   end
 
   class << self
     # Public API.
 
     def config
-      config = Struct.new(:local_types, :deep_type_check)
-      @config ||= config.new(false, false)
+      config = Struct.new(:deep_type_check, :severity_level)
+      @config ||= config.new(false, :error)
     end
 
     def configure
       yield(config)
-
-      return unless config.local_types
-
-      require_relative 'local_types'
-      include LocalTypes
     end
 
     # Internal API.
@@ -89,24 +78,5 @@ module LowType
     def value(type:)
       TypeExpression.new(default_value: ValueExpression.new(value: type))
     end
-
-    # TODO: Unit test.
-    def redefine(hash_class_method:)
-      Array.define_singleton_method('[]') do |*types|
-        TypeExpression.new(type: [*types])
-      end
-
-      Hash.define_singleton_method('[]') do |type|
-        # Support Pry which uses Hash[].
-        unless LowType.type?(type)
-          Hash.define_singleton_method('[]', hash_class_method)
-          result = Hash[type]
-          Hash.method('[]').unbind
-          return result
-        end
-
-        TypeExpression.new(type:)
-      end
-    end
   end
 end

data/lib/proxies/local_proxy.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/error_interface'
-require_relative '../error_types'
+require_relative '../types/error_types'
 
 module LowType
   class LocalProxy < ErrorInterface

data/lib/proxies/param_proxy.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/error_interface'
-require_relative '../error_types'
+require_relative '../types/error_types'
 
 module LowType
   class ParamProxy < ErrorInterface

data/lib/proxies/return_proxy.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../interfaces/error_interface'
-require_relative '../error_types'
+require_relative '../types/error_types'
 
 module LowType
   class ReturnProxy < ErrorInterface

data/lib/redefiner.rb

@@ -4,41 +4,57 @@ require_relative 'factories/proxy_factory'
 require_relative 'proxies/file_proxy'
 require_relative 'proxies/method_proxy'
 require_relative 'proxies/param_proxy'
+require_relative 'syntax'
 require_relative 'type_expression'
 
 module LowType
   # Redefine methods to have their arguments and return values type checked.
   class Redefiner
+    using Syntax
+
     class << self
-      def redefine(method_nodes:, klass:, private_start_line:, file_path:) # rubocop:disable Metrics
+      def redefine(method_nodes:, klass:, private_start_line:, file_path:)
+        create_proxies(method_nodes:, klass:, file_path:)
+        define_methods(method_nodes:, private_start_line:)
+      end
+
+      private
+
+      def create_proxies(method_nodes:, klass:, file_path:)
+        method_nodes.each do |method_node|
+          name = method_node.name
+          line = FileParser.line_number(node: method_node)
+          file = FileProxy.new(path: file_path, line:, scope: "#{klass}##{name}")
+          params = param_proxies(method_node:, file:)
+          return_proxy = ProxyFactory.return_proxy(method_node:, file:)
+
+          klass.low_methods[name] = MethodProxy.new(name:, params:, return_proxy:)
+        end
+      end
+
+      def define_methods(method_nodes:, private_start_line:) # rubocop:disable Metrics
         Module.new do
           method_nodes.each do |method_node|
             name = method_node.name
-            line = Parser.line_number(node: method_node)
-            file = FileProxy.new(path: file_path, line:, scope: "#{klass}##{method_node.name}")
-            params = Redefiner.params_with_type_expressions(method_node:, file:)
-            return_proxy = ProxyFactory.return_proxy(method_node:, file:)
-
-            klass.low_methods[name] = MethodProxy.new(name:, params:, return_proxy:)
 
             define_method(name) do |*args, **kwargs|
-              klass.low_methods[name].params.each do |param_proxy|
+              method_proxy = instance_of?(Class) ? low_methods[name] : self.class.low_methods[name]
+
+              method_proxy.params.each do |param_proxy|
                 # Get argument value or default value.
                 value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
                 if value.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
                   value = param_proxy.type_expression.default_value
                 end
-                # Validate argument type.
+
                 param_proxy.type_expression.validate!(value:, proxy: param_proxy)
-                # Handle value(type) special case.
                 value = value.value if value.is_a?(ValueExpression)
-                # Redefine argument value.
                 param_proxy.position ? args[param_proxy.position] = value : kwargs[param_proxy.name] = value
               end
 
-              if return_proxy
+              if (return_proxy = method_proxy.return_proxy)
                 return_value = super(*args, **kwargs)
-                return_proxy.type_expression.validate!(value: return_value, proxy: klass.low_methods[name].return_proxy)
+                return_proxy.type_expression.validate!(value: return_value, proxy: return_proxy)
                 return return_value
               end
 
@@ -50,12 +66,11 @@ module LowType
         end
       end
 
-      def params_with_type_expressions(method_node:, file:)
+      def param_proxies(method_node:, file:)
         return [] if method_node.parameters.nil?
 
         params = method_node.parameters.slice
-        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
-        proxy_method = eval("-> (#{params}) {}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
+        proxy_method = proxy_method(method_node:)
         required_args, required_kwargs = required_args(proxy_method:)
 
         # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
@@ -87,7 +102,11 @@ module LowType
         raise ArgumentError, "Incorrect param syntax: #{e.message}"
       end
 
-      private
+      def proxy_method(method_node:)
+        params = method_node.parameters.slice
+        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
+        eval("-> (#{params}) {}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
+      end
 
       def required_args(proxy_method:)
         required_args = []

data/lib/syntax.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module LowType
+  module Syntax
+    refine Array.singleton_class do
+      def [](*types)
+        return LowType::TypeExpression.new(type: [*types]) if types.all? { |type| LowType.type?(type) }
+
+        super
+      end
+    end
+
+    refine Hash.singleton_class do
+      def [](type)
+        return LowType::TypeExpression.new(type:) if LowType.type?(type)
+
+        super
+      end
+    end
+  end
+end
+
+# Refine doesn't support inheritence.
+class Object
+  # For "Type | [type_expression/type/value]" situations, redirecting to or generating a type expression from types.
+  # "|" 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_expression/type/value].
+        type_expression = ::LowType::TypeExpression.new(type: self)
+        type_expression | expression
+      end
+    end
+  end
+end

data/lib/type_expression.rb

@@ -56,7 +56,15 @@ module LowType
     end
 
     def valid_types
-      types = @types.map { |type| type.inspect.to_s }
+      types = @types.map do |type|
+        # Remove 'LowType::' namespace in subtypes.
+        if type.is_a?(::Array)
+          "[#{type.map { |subtype| subtype.to_s.delete_prefix('LowType::') }.join(', ')}]"
+        else
+          type.inspect.to_s.delete_prefix('LowType::')
+        end
+      end
+
       types += ['nil'] if @default_value.nil?
       types.join(' | ')
     end
@@ -97,23 +105,3 @@ module LowType
     end
   end
 end
-
-# For "Type | [type_expression/type/value]" situations, redirecting to or generating a type expression from types.
-# "|" 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 Object
-  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_expression/type/value].
-        type_expression = ::LowType::TypeExpression.new(type: self)
-        type_expression | expression
-      end
-    end
-  end
-end

data/lib/{error_types.rb → types/error_types.rb}

@@ -5,4 +5,5 @@ module LowType
   class LocalTypeError < TypeError; end
   class ReturnTypeError < TypeError; end
   class AllowedTypeError < TypeError; end
+  class ConfigError < TypeError; end
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LowType
-  VERSION = '0.9.0'
+  VERSION = '1.0.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.1
 platform: ruby
 authors:
 - maedi
@@ -19,22 +19,23 @@ extra_rdoc_files: []
 files:
 - lib/adapters/adapter_loader.rb
 - lib/adapters/sinatra_adapter.rb
-- lib/basic_types.rb
-- lib/error_types.rb
 - lib/factories/proxy_factory.rb
+- lib/file_parser.rb
 - lib/instance_types.rb
 - lib/interfaces/adapter_interface.rb
 - lib/interfaces/error_interface.rb
 - lib/local_types.rb
 - lib/low_type.rb
-- lib/parser.rb
 - lib/proxies/file_proxy.rb
 - lib/proxies/local_proxy.rb
 - lib/proxies/method_proxy.rb
 - lib/proxies/param_proxy.rb
 - lib/proxies/return_proxy.rb
 - lib/redefiner.rb
+- lib/syntax.rb
 - lib/type_expression.rb
+- lib/types/complex_types.rb
+- lib/types/error_types.rb
 - lib/value_expression.rb
 - lib/version.rb
 homepage: https://codeberg.org/low_ruby/low_type