low_type 0.8.11 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f0c69a8ca233198b383a056a7c78819a2dae7944b73d681846924ef8bfe9355
-  data.tar.gz: fb04f1df5257523e0a1cb266500ff9d106c30723ee8aa46e66929ffa80198340
+  metadata.gz: 5872bc6f373425ddfc4342d0421dd09e4e3bd6a5e7e0b4d3ba1d1c19cd077a5c
+  data.tar.gz: 9b5543ba7bded1c2a043966376956316624408a101f2b30ec9a6b16d07976973
 SHA512:
-  metadata.gz: a8eaaeed7102693d813d82fde2da76124b050eba9afa042bfaea2e94f40923629596c4fe613fce66f8cfba3342b86499bd257e14094c40ae8e399962dec2fe74
-  data.tar.gz: '0519fec1df0f3e1b80403e376aa41cdc2e25a6d1dbd87d85c3c76cc185340c3c937255c84136f3d467bbd63d01ce8bfbc78e0c253e817324338a7a29e12dddae'
+  metadata.gz: c3a31c05871cc0d4b5fde6fca3c03c94fbc7e2ccc2696eb7eab401f8817e0b0a1abbd0bf4aa91d72454a61c60265b22ba9997148161f7d3e796d2e9c790e9c81
+  data.tar.gz: 3629f1ac45bc9cbfce9979f85e933bb3b12b731747b714fb8eba6b7399cf139ac6098eb37667b97b624e95eda4e02c104ce9d7cd2b6013ea3fbb639e1e4a0125

data/lib/adapters/sinatra_adapter.rb

@@ -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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../proxies/return_proxy'
+require_relative '../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 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?
+        expression = eval(return_type.slice, binding, __FILE__, __LINE__).call # rubocop:disable Security/Eval
+        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
+
+        ReturnProxy.new(type_expression: expression, name: method_node.name, file:)
+      end
+    end
+  end
+end

data/lib/instance_types.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'proxies/return_proxy'
+require_relative 'type_expression'
+
+module LowType
+  module InstanceTypes
+    def type_reader(named_expressions)
+      named_expressions.each do |name, expression|
+        last_caller = caller_locations(1, 1).first
+        type_expression = type_expression(expression)
+        file = FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: "#{self}##{name}")
+
+        @low_methods[name] = MethodProxy.new(name:, return_proxy: ReturnProxy.new(type_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)
+          value
+        end
+      end
+    end
+
+    def type_writer(named_expressions)
+      named_expressions.each do |name, expression|
+        last_caller = caller_locations(1, 1).first
+        type_expression = type_expression(expression)
+        file = FileProxy.new(path: last_caller.path, line: last_caller.lineno, scope: "#{self}##{name}")
+
+        @low_methods["#{name}="] = MethodProxy.new(name:, params: [ParamProxy.new(type_expression:, name:, type: :hashreq, file:)])
+
+        define_method("#{name}=") do |value|
+          method_proxy = self.class.low_methods["#{name}="]
+          type_expression.validate!(value:, proxy: method_proxy.params.first)
+          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 type_expression(expression)
+      if expression.instance_of?(TypeExpression)
+        expression
+      elsif ::LowType.type?(expression)
+        TypeExpression.new(type: expression)
+      end
+    end
+  end
+end

data/lib/local_types.rb

@@ -6,25 +6,18 @@ require_relative 'type_expression'
 require_relative 'value_expression'
 
 module LocalTypes
-  class AssignmentError < StandardError; end
-
   def type(type_expression)
-    referenced_object = type_expression.default_value.dup
-
-    raise AssignmentError, "Single-instance objects like #{referenced_object} are not supported" unless LowType.value?(referenced_object)
+    value = type_expression.default_value
 
     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)
+    proxy = LowType::LocalProxy.new(type_expression:, name: self, file:)
 
-    type_expression.validate!(value: referenced_object, proxy: local_proxy)
+    type_expression.validate!(value:, proxy:)
 
-    define_with_type(referenced_object:)
+    return value.value if value.is_a?(ValueExpression)
 
-    return referenced_object.value if referenced_object.is_a?(ValueExpression)
-
-    referenced_object
+    value
   end
   alias low_type type
 
@@ -32,39 +25,4 @@ module LocalTypes
     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
-    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
-
-      self
-    end
-  end
 end

data/lib/low_type.rb

@@ -2,7 +2,10 @@
 
 require_relative 'adapters/adapter_loader'
 require_relative 'basic_types'
+require_relative 'instance_types'
+require_relative 'local_types'
 require_relative 'redefiner'
+require_relative 'subclasses'
 require_relative 'type_expression'
 require_relative 'value_expression'
 
@@ -10,11 +13,6 @@ require_relative 'value_expression'
 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:)
-
     class << klass
       def low_methods
         @low_methods ||= {}
@@ -25,6 +23,8 @@ module LowType
     parser = LowType::Parser.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:)
 
@@ -32,26 +32,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.
@@ -87,24 +79,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/redefiner.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
+require_relative 'factories/proxy_factory'
 require_relative 'proxies/file_proxy'
 require_relative 'proxies/method_proxy'
 require_relative 'proxies/param_proxy'
-require_relative 'proxies/return_proxy'
-require_relative 'parser'
 require_relative 'type_expression'
 
 module LowType
@@ -18,7 +17,7 @@ module LowType
             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 = Redefiner.return_proxy(method_node:, file:)
+            return_proxy = ProxyFactory.return_proxy(method_node:, file:)
 
             klass.low_methods[name] = MethodProxy.new(name:, params:, return_proxy:)
 
@@ -51,7 +50,7 @@ module LowType
         end
       end
 
-      def params_with_type_expressions(method_node:, file:) # rubocop:disable Metrics/MethodLength
+      def params_with_type_expressions(method_node:, file:)
         return [] if method_node.parameters.nil?
 
         params = method_node.parameters.slice
@@ -88,17 +87,6 @@ module LowType
         raise ArgumentError, "Incorrect param syntax: #{e.message}"
       end
 
-      def return_proxy(method_node:, file:)
-        return_type = Parser.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?
-        expression = eval(return_type.slice).call # rubocop:disable Security/Eval
-        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
-
-        ReturnProxy.new(type_expression: expression, name: method_node.name, file:)
-      end
-
       private
 
       def required_args(proxy_method:)

data/lib/subclasses.rb

@@ -0,0 +1,58 @@
+module LowType
+  # Scoped to the class that includes LowType module.
+  class Array < ::Array
+    def self.[](*types)
+      return LowType::TypeExpression.new(type: [*types]) if types.all? { |type| LowType.type?(type) }
+      super
+    end
+
+    def self.===(other)
+      return true if other == ::Array
+      super
+    end
+
+    def ==(other)
+      return true if other.class == ::Array
+      super
+    end
+  end
+
+  # Scoped to the class that includes LowType module.
+  class Hash < ::Hash
+    def self.[](type)
+      return LowType::TypeExpression.new(type:) if LowType.type?(type)
+      super
+    end
+
+    def self.===(other)
+      return true if other == ::Hash
+      super
+    end
+
+    def ==(other)
+      return true if other.class == ::Hash
+      super
+    end
+  end
+end
+
+# Scoped to the top-level for method type expressions to work. Could we bind/unbind? Yes. Should we? Probably not.
+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::' namespaces 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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.8.11
+  version: 1.0.0
 platform: ruby
 authors:
 - maedi
@@ -21,6 +21,8 @@ files:
 - lib/adapters/sinatra_adapter.rb
 - lib/basic_types.rb
 - lib/error_types.rb
+- lib/factories/proxy_factory.rb
+- lib/instance_types.rb
 - lib/interfaces/adapter_interface.rb
 - lib/interfaces/error_interface.rb
 - lib/local_types.rb
@@ -32,6 +34,7 @@ files:
 - lib/proxies/param_proxy.rb
 - lib/proxies/return_proxy.rb
 - lib/redefiner.rb
+- lib/subclasses.rb
 - lib/type_expression.rb
 - lib/value_expression.rb
 - lib/version.rb