low_type 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a340469d2c2f4945b043ab3cd4973f14cf12f9d80336b7939bdb85b0da5b739e
-  data.tar.gz: 2e51c25e1b944dff67fb85f4582a2f3f38eca299fe58d4cc464c4b8c162a9d8a
+  metadata.gz: 5872bc6f373425ddfc4342d0421dd09e4e3bd6a5e7e0b4d3ba1d1c19cd077a5c
+  data.tar.gz: 9b5543ba7bded1c2a043966376956316624408a101f2b30ec9a6b16d07976973
 SHA512:
-  metadata.gz: 8857cb2e301aa2e7f4ddf167fe622d3988d7d28ff223361a50a056f28ea248e4ad81ecc48fc2174f2f8845c7af7e8fad072ac9bf3ed4eea5a0bad37a06ab9b6d
-  data.tar.gz: c401324adf4f5aa4b4da5a1c6f19d5b3daa095e7ff28a43a9075f28f4d7a8947a13fcba500bab252eece331b51d65e89fee09efd99e1d61f5e0290faae51dab7
+  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/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

@@ -3,7 +3,9 @@
 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'
 
@@ -11,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 ||= {}
@@ -27,6 +24,7 @@ module LowType
     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 +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.
@@ -89,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/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.9.0'
+  VERSION = '1.0.0'
 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.0
 platform: ruby
 authors:
 - maedi
@@ -34,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