low_type 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5862d1077a767f4d1df0df6f535a3b8c5d0de646a23088ea9679316a11a57f9e
-  data.tar.gz: ae4b3a7e0d57ab5e088e8d666de25df1b121d248b832a343a13565f1cb44d6b5
+  metadata.gz: d845917e9ed4afc79db302fe7f5a2955a4e299d7bd415e82e2f26af3b14cd25f
+  data.tar.gz: f9213b5731f3805ebf1e99efa0ccdd741b955464403842aeaa171d0b41fff146
 SHA512:
-  metadata.gz: ddf2c76d224b5dc51a5503f7635d9c6f0e2de8ee3c9dccdf9cc1e7eb6105fe88cb1045438a2a40322ceb78128c6a8a5604cc2db5d1f8bb71eeaf23d28f0ccc99
-  data.tar.gz: ceb481d5488ce8b217b5715f43991280359b846acee3d7f0fa205ab485f17e4c1da48c914db3b293a37a2ee21b5516ab5334b8240c69a9ab69730bbbfdc7cca7
+  metadata.gz: 6066f8c29073720201a83438c58067ef37d2b02b493f108e31bee624069b68a7049e3a64aebe20da851f7b8e13e7d599c02deb1adbb9050ccd271a895933c6c2
+  data.tar.gz: 16c144045ae7666c1ab42610e641d9b4946b14cc9adf22023239a55dbfcbc5a8da714b53c94972a883249008512bcc56a60b465ce9ba9da1908a0151856afa7c

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(value:)
+      raise NotImplementedError
+    end
+
+    def error_message(value:, line: nil)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/low_type.rb

@@ -29,19 +29,6 @@ module LowType
     end
 
     class << klass
-      # Public API.
-      def type(expression)
-        # TODO: Runtime type expression for the supplied variable.
-      end
-      alias_method :low_type, :type
-
-      # Public API.
-      def value(expression)
-        ::LowType.value(expression)
-      end
-      alias_method :low_value, :value
-
-      # Internal API.
       def low_methods
         @low_methods ||= {}
       end
@@ -57,21 +44,38 @@ module LowType
     Hash.define_singleton_method('[]', hash_class_method)
   end
 
-  # Internal API.
   class << self
+    # Public API.
+
+    def config
+      config = Struct.new(:type_assignment, :deep_type_check)
+      @config ||= config.new(false, false)
+    end
+
+    def configure
+      yield(config)
+
+      if config.type_assignment
+        require_relative 'type_assignment'
+        include TypeAssignment
+      end
+    end
+  
+    # Internal API.
+
     def file_path(klass:)
       caller.find { |callee| callee.end_with?("<class:#{klass}>'") }.split(':').first
     end
 
-    def type?(expression)
-      expression.respond_to?(:new) || expression == Integer || (expression.is_a?(Hash) && expression.keys.first.respond_to?(:new) && expression.values.first.respond_to?(:new))
+    def type?(type)
+      type.respond_to?(:new) || type == Integer || (type.is_a?(::Hash) && type.keys.first.respond_to?(:new) && type.values.first.respond_to?(:new))
     end
 
     def value?(expression)
       !expression.respond_to?(:new) && expression != Integer
     end
 
-    def value(type)
+    def value(type:)
       TypeExpression.new(default_value: ValueExpression.new(value: type))
     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(value:)
+      LocalTypeError
+    end
+
+    def error_message(value:, line:)
+      "Invalid variable type #{value.class} in '#{@name.class}' on line #{line}. Valid types: '#{@type_expression.valid_types.join(', ')}'"
+    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,26 @@
+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(value:)
+      return ArgumentError if value.nil?
+      ArgumentTypeError
+    end
+
+    def error_message(value:, line: nil)
+      return "Missing argument for parameter '#{@name}'. Position: #{@position}" if value.nil?
+
+      "Invalid argument type '#{value.class}' for parameter '#{@name}'. Valid types: '#{@type_expression.valid_types.join(', ')}'"
+    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(value:)
+      ReturnTypeError
+    end
+
+    def error_message(value:, line: nil)
+      "Invalid return type '#{value.class}' for method '#{@name}'. Valid types: '#{@type_expression.valid_types.join(', ')}'"
+    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
@@ -114,9 +113,9 @@ module LowType
         [required_args, required_kwargs]
       end
 
-      # Type expressions are eval()'d in the context of this module class (the instance doesn't exist yet) so alias API.
-      def value(expression)
-        ::LowType.value(expression)
+      # Value expressions are eval()'d in the context of this module class (the instance doesn't exist yet) so alias API.
+      def value(type)
+        LowType.value(type:)
       end
     end
   end

data/lib/type_assignment.rb

@@ -0,0 +1,59 @@
+require_relative 'proxies/local_proxy'
+require_relative 'type_expression'
+require_relative 'value_expression'
+
+module TypeAssignment
+  class AssignmentError < StandardError; end
+
+  def type(type_expression)
+    object = type_expression.default_value
+
+    if !LowType.value?(object)
+      raise AssignmentError, "Single-instance objects like #{object} are not supported"
+    end
+
+    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)
+      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 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
+
+      self
+    end
+
+    return object.value if object.is_a?(ValueExpression)
+
+    object
+  end
+  alias_method :low_type, :type
+
+  def value(type)
+    LowType.value(type:)
+  end
+  alias_method :low_value, :value
+end
+
+module LowType
+  class Array < ::Array
+    def self.[](type)
+      return TypeExpression.new(type: [type]) if LowType.type?(type)
+      super
+    end
+  end
+
+  class Hash < ::Hash
+    def self.[](type)
+      return TypeExpression.new(type:) if LowType.type?(type)
+      super
+    end
+  end
+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,22 +27,28 @@ 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(value:), proxy.error_message(value:, line:) if required?
       end
 
       @types.each do |type|
         return true if LowType.type?(type) && type == value.class 
         # TODO: Shallow validation of enumerables could be made deeper with user config.
-        return true if type.class == Array && value.class == Array && type.first == value.first.class
-        if type.class == Hash && value.class == Hash && type.keys[0] == value.keys[0].class && type.values[0] == value.values[0].class
+        return true if type.class == ::Array && value.class == ::Array && type.first == value.first.class
+        if type.class == ::Hash && value.class == ::Hash && type.keys[0] == value.keys[0].class && type.values[0] == value.values[0].class
           return true
         end
       end
 
-      raise TypeError, "Invalid type '#{value.class}' for '#{name}'. Valid types: [#{@types.join(', ')}]"
+      raise proxy.error_type(value:), proxy.error_message(value:, line:)
+    end
+
+    def valid_types
+      types = @types.map { |type| type.inspect.to_s }
+      return types + ['nil'] if @default_value.nil?
+      types
     end
   end
 end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - maedi
@@ -17,11 +17,16 @@ 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
 - lib/value_expression.rb
 - lib/version.rb
@@ -46,5 +51,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.2
 specification_version: 4
-summary: An elegant way to define types in Ruby
+summary: Elegant types in Ruby
 test_files: []

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