low_type 0.4.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ec90c752620d94c2f38e287ce6927684bb77b17caf65c9551765a37b031d2ab
-  data.tar.gz: 6d6106390f7286f5d1812c4de79fe1a72f021db0d0b0f62c1dce5bf5a4cfc02c
+  metadata.gz: 84f89979651e711cb013a30df1a39f9becc619153f3fde1ac2f1810c6c0be9dc
+  data.tar.gz: ea670426a49377352c7b5503b897362c0aa1fbfef1b418d9908ba237386ae37c
 SHA512:
-  metadata.gz: 791da36eca530ac38f459cbdb25253089be16e1d2c544f478c3c0fc80a7249f5c942706ec93cc4ef5340779d746f5c3be559d435f8bbdb25f2d092c6d9128681
-  data.tar.gz: a92a680924fd3219cc5b88e6097aaadb12fb0f0f26d175591bbcd27c5d045286dd5c392d3218f5ed1600b639a79be5be643d6c0784212a7c72e6dde945946625
+  metadata.gz: 5aeaefb6861e7500b60ecbca69192cbc0893b310e853730d876719e83adb7943cbc8cb3b8636f12a4e838da8bd4ef4aa503790a226230cc9ecd4473a1ba3faca
+  data.tar.gz: f4272f09bf0ee57dfd85df4effe1568eba8ff1e7e5136742a8f90c1735df2d32969af269c5269390da81a2c317155b1730f7a73278378ee0ad5d8402cf64f831

data/lib/low_type.rb

@@ -2,6 +2,7 @@
 
 require_relative 'redefiner'
 require_relative 'type_expression'
+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.
@@ -31,16 +32,6 @@ module LowType
       def low_methods
         @low_methods ||= {}
       end
-
-      def type(expression)
-        # TODO: Runtime type expression for the supplied variable.
-      end
-      alias_method :low_type, :type
-
-      def value(expression)
-        # TODO: Cancel out a type expression.
-      end
-      alias_method :low_value, :value
     end
 
     parser = Parser.new(file_path: LowType.file_path(klass:))
@@ -54,19 +45,40 @@ module LowType
   end
 
   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:)
+      TypeExpression.new(default_value: ValueExpression.new(value: type))
+    end
   end
 
-  class ValueExpression; end
   class Boolean; end # TrueClass or FalseClass
 end

data/lib/parser.rb

@@ -21,8 +21,10 @@ module LowType
 
     def self.return_node(method_node:)
       # Only a lambda defined immediately after a method's parameters is considered a return type expression.
-      node = method_node.compact_child_nodes.find { |node| node.is_a?(Prism::StatementsNode) }.body.first
+      statements_node = method_node.compact_child_nodes.find { |node| node.is_a?(Prism::StatementsNode) }
+      return nil if statements_node.nil? # Sometimes developers define methods without code inside them.
 
+      node = statements_node.body.first
       return node if node.is_a?(Prism::LambdaNode)
 
       nil

data/lib/redefiner.rb

@@ -4,6 +4,8 @@ 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:)
@@ -17,15 +19,20 @@ module LowType
 
             define_method(name) do |*args, **kwargs|
               klass.low_methods[name].params.each do |param_proxy|
+                # Get argument value or default value.
                 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
-                param_proxy.type_expression.validate!(value:, name: param_proxy.name)
+                # Validate argument type.
+                param_proxy.type_expression.validate!(value:, name: param_proxy.name, error_type: ArgumentError, error_keyword: 'required')
+                # 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
                 return_value = super(*args, **kwargs)
-                return_expression.validate!(value: return_value, name:)
+                return_expression.validate!(value: return_value, name:, error_type: ReturnError, error_keyword: 'return')
                 return return_value
               end
 
@@ -39,22 +46,12 @@ module LowType
         end
       end
 
-      def return_type_expression(method_node:)
-        return_node = Parser.return_node(method_node:)
-        return nil if return_node.nil?
-
-        expression = eval(return_node.slice).call
-
-        return expression if expression.class == TypeExpression
-        TypeExpression.new(type: expression)
-      end
-
       def params_with_type_expressions(method_node:)
         return [] if method_node.parameters.nil?
 
         params = method_node.parameters.slice
         proxy_method = eval("-> (#{params}) {}")
-        required_args, required_kwargs = Redefiner.required_args(proxy_method:)
+        required_args, required_kwargs = required_args(proxy_method:)
 
         typed_method = eval(
           <<~RUBY
@@ -84,9 +81,21 @@ module LowType
 
       # TODO: Write spec for this.
       rescue ArgumentError => e
-        raise ArgumentError, "Incorrect param syntax"
+        raise ArgumentError, "Incorrect param syntax: #{e.message}"
+      end
+
+      def return_type_expression(method_node:)
+        return_node = Parser.return_node(method_node:)
+        return nil if return_node.nil?
+
+        expression = eval(return_node.slice).call
+
+        return expression if expression.class == TypeExpression
+        TypeExpression.new(type: expression)
       end
 
+      private
+
       def required_args(proxy_method:)
         required_args = []
         required_kwargs = {}
@@ -104,6 +113,11 @@ module LowType
 
         [required_args, required_kwargs]
       end
+
+      # 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
 end

data/lib/type_assignment.rb

@@ -0,0 +1,54 @@
+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
+
+    object.instance_variable_set('@type_expression', type_expression)
+
+    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')
+
+      # We can't re-assign self in Ruby so we re-assign 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

@@ -2,8 +2,9 @@ module LowType
   class TypeExpression
     attr_reader :types, :default_value
 
-    def initialize(type:, default_value: :LOW_TYPE_UNDEFINED)
-      @types = [type]
+    def initialize(type: nil, default_value: :LOW_TYPE_UNDEFINED)
+      @types = []
+      @types << type unless type.nil?
       @default_value = default_value
     end
 
@@ -24,35 +25,39 @@ module LowType
       @default_value == :LOW_TYPE_UNDEFINED
     end
 
-    def validate!(value:, name:)
+    def validate!(value:, name:, error_type:, error_keyword:)
       if value.nil?
         return true if @default_value.nil?
-        raise ArgumentError, "Missing required argument of type '#{@types.join(', ')}' for '#{name}'" if required?
+        raise error_type, "Missing #{error_keyword} value of type '#{@types.join(', ')}' for '#{name}'" 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}'"
+      raise TypeError, "Invalid type '#{value.class}' for '#{name}'. Valid types: [#{@types.join(', ')}]"
     end
   end
 end
 
 class Object
   class << self
+    # 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.
     def |(expression)
       if expression.class == ::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

data/lib/value_expression.rb

@@ -0,0 +1,11 @@
+class ValueExpression
+  attr_reader :value
+
+  def initialize(value:)
+    @value = value
+  end
+
+  def class
+    @value
+  end
+end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.6.0
 platform: ruby
 authors:
 - maedi
@@ -22,7 +22,9 @@ files:
 - lib/param_proxy.rb
 - lib/parser.rb
 - lib/redefiner.rb
+- lib/type_assignment.rb
 - lib/type_expression.rb
+- lib/value_expression.rb
 - lib/version.rb
 homepage: https://codeberg.org/low_ruby/low_type
 licenses: []
@@ -45,5 +47,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: []