low_type 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4ec90c752620d94c2f38e287ce6927684bb77b17caf65c9551765a37b031d2ab
-  data.tar.gz: 6d6106390f7286f5d1812c4de79fe1a72f021db0d0b0f62c1dce5bf5a4cfc02c
+  metadata.gz: 5862d1077a767f4d1df0df6f535a3b8c5d0de646a23088ea9679316a11a57f9e
+  data.tar.gz: ae4b3a7e0d57ab5e088e8d666de25df1b121d248b832a343a13565f1cb44d6b5
 SHA512:
-  metadata.gz: 791da36eca530ac38f459cbdb25253089be16e1d2c544f478c3c0fc80a7249f5c942706ec93cc4ef5340779d746f5c3be559d435f8bbdb25f2d092c6d9128681
-  data.tar.gz: a92a680924fd3219cc5b88e6097aaadb12fb0f0f26d175591bbcd27c5d045286dd5c392d3218f5ed1600b639a79be5be643d6c0784212a7c72e6dde945946625
+  metadata.gz: ddf2c76d224b5dc51a5503f7635d9c6f0e2de8ee3c9dccdf9cc1e7eb6105fe88cb1045438a2a40322ceb78128c6a8a5604cc2db5d1f8bb71eeaf23d28f0ccc99
+  data.tar.gz: ceb481d5488ce8b217b5715f43991280359b846acee3d7f0fa205ab485f17e4c1da48c914db3b293a37a2ee21b5516ab5334b8240c69a9ab69730bbbfdc7cca7

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.
@@ -28,19 +29,22 @@ module LowType
     end
 
     class << klass
-      def low_methods
-        @low_methods ||= {}
-      end
-
+      # Public API.
       def type(expression)
         # TODO: Runtime type expression for the supplied variable.
       end
       alias_method :low_type, :type
 
+      # Public API.
       def value(expression)
-        # TODO: Cancel out a type expression.
+        ::LowType.value(expression)
       end
       alias_method :low_value, :value
+
+      # Internal API.
+      def low_methods
+        @low_methods ||= {}
+      end
     end
 
     parser = Parser.new(file_path: LowType.file_path(klass:))
@@ -53,6 +57,7 @@ module LowType
     Hash.define_singleton_method('[]', hash_class_method)
   end
 
+  # Internal API.
   class << self
     def file_path(klass:)
       caller.find { |callee| callee.end_with?("<class:#{klass}>'") }.split(':').first
@@ -65,8 +70,11 @@ module LowType
     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
+
+      # 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)
+      end
     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,10 +25,10 @@ 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|
@@ -39,20 +40,24 @@ module LowType
         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.5.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.5.0
 platform: ruby
 authors:
 - maedi
@@ -23,6 +23,7 @@ files:
 - lib/parser.rb
 - lib/redefiner.rb
 - lib/type_expression.rb
+- lib/value_expression.rb
 - lib/version.rb
 homepage: https://codeberg.org/low_ruby/low_type
 licenses: []