low_type 0.6.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84f89979651e711cb013a30df1a39f9becc619153f3fde1ac2f1810c6c0be9dc
-  data.tar.gz: ea670426a49377352c7b5503b897362c0aa1fbfef1b418d9908ba237386ae37c
+  metadata.gz: af6b3684e92cdf1cd8276d6c06b93d7a83667fdc8ebe32590c26a992d64cfb89
+  data.tar.gz: fb341f9d4ec022a3e2aeda982a30646b44d1a2389ed5d0e473cf8d3c4846fa2b
 SHA512:
-  metadata.gz: 5aeaefb6861e7500b60ecbca69192cbc0893b310e853730d876719e83adb7943cbc8cb3b8636f12a4e838da8bd4ef4aa503790a226230cc9ecd4473a1ba3faca
-  data.tar.gz: f4272f09bf0ee57dfd85df4effe1568eba8ff1e7e5136742a8f90c1735df2d32969af269c5269390da81a2c317155b1730f7a73278378ee0ad5d8402cf64f831
+  metadata.gz: 57df3e2a9db8a10f2008c7e7d14ff66cf24562bd80266676ad56c176277eafb76982401db097c3ce98f759fe318d5052095a55366742915c76967449ec22abfc
+  data.tar.gz: cccd7db020ccabd34684347b4e67182ac40b0425acdc23e31a99bd78369c575f2b80a8deabe6ba0c67ae900f2c775e2fe020b0097ce9147aad47aa04d5c3e858

data/lib/errors.rb

@@ -0,0 +1,3 @@
+class ArgumentTypeError < TypeError; end;
+class LocalTypeError < TypeError; end;
+class ReturnTypeError < TypeError; end;

data/lib/interfaces/proxy_interface.rb

@@ -0,0 +1,11 @@
+module LowType
+  class ProxyInterface
+    def error_type
+      raise NotImplementedError
+    end
+
+    def error_message(value:, line: nil)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/proxies/local_proxy.rb

@@ -0,0 +1,21 @@
+require_relative '../interfaces/proxy_interface'
+require_relative '../errors'
+
+module LowType
+  class LocalProxy < ProxyInterface
+    attr_reader :type_expression, :name
+
+    def initialize(type_expression:, name:)
+      @type_expression = type_expression
+      @name = name
+    end
+
+    def error_type
+      LocalTypeError
+    end
+
+    def error_message(value:, line:)
+      "Invalid variable type #{value.class} in '#{@name.class}' on line #{line}. Valid types: '#{@type_expression.valid_types}'"
+    end
+  end
+end

data/lib/proxies/method_proxy.rb

@@ -0,0 +1,11 @@
+module LowType
+  class MethodProxy
+    attr_reader :name, :params, :return_proxy
+
+    def initialize(name:, params: [], return_proxy: nil)
+      @name = name
+      @params = params
+      @return_proxy = return_proxy
+    end
+  end
+end

data/lib/proxies/param_proxy.rb

@@ -0,0 +1,23 @@
+require_relative '../interfaces/proxy_interface'
+require_relative '../errors'
+
+module LowType
+  class ParamProxy < ProxyInterface
+    attr_reader :type_expression, :name, :type, :position
+
+    def initialize(type_expression:, name:, type:, position: nil)
+      @type_expression = type_expression
+      @name = name
+      @type = type
+      @position = position
+    end
+
+    def error_type
+      ArgumentTypeError
+    end
+
+    def error_message(value:, line: nil)
+      "Invalid argument type '#{value.class}' for parameter '#{@name}'. Valid types: '#{@type_expression.valid_types}'"
+    end
+  end
+end

data/lib/proxies/return_proxy.rb

@@ -0,0 +1,21 @@
+require_relative '../interfaces/proxy_interface'
+require_relative '../errors'
+
+module LowType
+  class ReturnProxy < ProxyInterface
+    attr_reader :type_expression, :name
+
+    def initialize(type_expression:, name:)
+      @type_expression = type_expression
+      @name = name
+    end
+
+    def error_type
+      ReturnTypeError
+    end
+
+    def error_message(value:, line: nil)
+      "Invalid return type '#{value.class}' for method '#{@name}'. Valid types: '#{@type_expression.valid_types}'"
+    end
+  end
+end

data/lib/redefiner.rb

@@ -1,11 +1,10 @@
-require_relative 'method_proxy'
-require_relative 'param_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
-  class ReturnError < StandardError; end
-
   class Redefiner
     class << self
       def redefine_methods(method_nodes:, private_start_line:, klass:)
@@ -13,9 +12,9 @@ module LowType
           method_nodes.each do |method_node|
             name = method_node.name
             params = Redefiner.params_with_type_expressions(method_node:)
-            return_expression = Redefiner.return_type_expression(method_node:)
+            return_proxy = Redefiner.return_proxy(method_node:)
 
-            klass.low_methods[name] = MethodProxy.new(name:, params:, return_expression:)
+            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|
@@ -23,16 +22,16 @@ module LowType
                 value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
                 value = param_proxy.type_expression.default_value if value.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
                 # Validate argument type.
-                param_proxy.type_expression.validate!(value:, name: param_proxy.name, error_type: ArgumentError, error_keyword: 'required')
+                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_expression
+              if return_proxy
                 return_value = super(*args, **kwargs)
-                return_expression.validate!(value: return_value, name:, error_type: ReturnError, error_keyword: 'return')
+                return_proxy.type_expression.validate!(value: return_value, proxy: klass.low_methods[name].return_proxy)
                 return return_value
               end
 
@@ -84,14 +83,14 @@ module LowType
         raise ArgumentError, "Incorrect param syntax: #{e.message}"
       end
 
-      def return_type_expression(method_node:)
+      def return_proxy(method_node:)
         return_node = Parser.return_node(method_node:)
         return nil if return_node.nil?
 
         expression = eval(return_node.slice).call
+        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
 
-        return expression if expression.class == TypeExpression
-        TypeExpression.new(type: expression)
+        ReturnProxy.new(type_expression: expression, name: method_node.name)
       end
 
       private

data/lib/type_assignment.rb

@@ -1,3 +1,4 @@
+require_relative 'proxies/local_proxy'
 require_relative 'type_expression'
 require_relative 'value_expression'
 
@@ -11,13 +12,17 @@ module TypeAssignment
       raise AssignmentError, "Single-instance objects like #{object} are not supported"
     end
 
-    object.instance_variable_set('@type_expression', type_expression)
+    local_proxy = LowType::LocalProxy.new(type_expression:, name: self)
+    object.instance_variable_set('@local_proxy', local_proxy)
+
+    type_expression.validate!(value: object, proxy: local_proxy, line: caller_locations(1, 1).first.lineno)
 
     def object.with_type=(value)
-      type_expression = self.instance_variable_get('@type_expression')
-      type_expression.validate!(value:, name: self, error_type: TypeError, error_keyword: 'object')
+      local_proxy = self.instance_variable_get('@local_proxy')
+      type_expression = local_proxy.type_expression
+      type_expression.validate!(value:, proxy: local_proxy, line: caller_locations(1, 1).first.lineno)
 
-      # We can't re-assign self in Ruby so we re-assign instance variables instead.
+      # We can't reassign self in Ruby so we reassign instance variables instead.
       value.instance_variables.each do |variable|
         self.instance_variable_set(variable, value.instance_variable_get(variable))
       end

data/lib/type_expression.rb

@@ -1,3 +1,5 @@
+require_relative 'proxies/param_proxy'
+
 module LowType
   class TypeExpression
     attr_reader :types, :default_value
@@ -25,10 +27,10 @@ module LowType
       @default_value == :LOW_TYPE_UNDEFINED
     end
 
-    def validate!(value:, name:, error_type:, error_keyword:)
+    def validate!(value:, proxy:, line: nil)
       if value.nil?
         return true if @default_value.nil?
-        raise error_type, "Missing #{error_keyword} value of type '#{@types.join(', ')}' for '#{name}'" if required?
+        raise proxy.error_type, proxy.error_message(value:, line:) if required?
       end
 
       @types.each do |type|
@@ -40,7 +42,14 @@ module LowType
         end
       end
 
-      raise TypeError, "Invalid type '#{value.class}' for '#{name}'. Valid types: [#{@types.join(', ')}]"
+      raise proxy.error_type, proxy.error_message(value:, line:)
+    end
+
+    def valid_types
+      types = @types.map { |type| type.inspect.to_s }
+      types = types + ['nil'] if @default_value.nil?
+
+      types.join(' | ')
     end
   end
 end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.1
 platform: ruby
 authors:
 - maedi
@@ -17,10 +17,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/errors.rb
+- lib/interfaces/proxy_interface.rb
 - lib/low_type.rb
-- lib/method_proxy.rb
-- lib/param_proxy.rb
 - lib/parser.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/type_assignment.rb
 - lib/type_expression.rb

data/lib/method_proxy.rb

@@ -1,11 +0,0 @@
-module LowType
-  class MethodProxy
-    attr_reader :name, :params, :return_expression
-
-    def initialize(name:, params: [], return_expression: nil)
-      @name = name
-      @params = params
-      @return_expression = return_expression
-    end
-  end
-end

data/lib/param_proxy.rb

@@ -1,12 +0,0 @@
-module LowType
-  class ParamProxy
-    attr_reader :type_expression, :name, :type, :position
-
-    def initialize(type_expression:, name:, type:, position: nil)
-      @type_expression = type_expression
-      @name = name
-      @type = type
-      @position = position
-    end
-  end
-end