low_type 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76a73e683c2e961c41eef7d14d5f41ac3e7252f9c22cc2b4b807c6ede92b6a89
-  data.tar.gz: 0a264a10f5c070c2b08160e0c94d69cf403c86a2961a0b72eab069b5e47c33af
+  metadata.gz: b01f96320aa0543e44d8b4b40430903af4966174fb9ae1533ddf7240c1919ec1
+  data.tar.gz: 87094ba39f9755fce4befa350b7ce33d7bd807a9774f1366340a0c9003788933
 SHA512:
-  metadata.gz: cd2e3b8caf03f7575d765eb573b66035706f2cc82fecea20fb806902e94aae5a7040d3eac4afdb3888b49359a035903e5b714a4662dd1cc4b25b28d79d40797b
-  data.tar.gz: 56c33ae15714520170d9cc85df710ce20b5a50dd1162705341938129ab95f0c6556baec3cd19c3371523c3f3994ed549d024a17937c83688ec91879e8e36e6b0
+  metadata.gz: 2b4ff1cca9f7763084b3283a13b34955863a81074a6161703c3993aa6d0916180804f8b6058ee35779be159eec7000d9c2f676c656254a67039cb3548073f10d
+  data.tar.gz: 39aad0e4a488963333b31c8ec21fc6586e78e5d0ebf76a6546997183ada9ce6baacbd0107ecd0ed71ce5e5c9fa14d8597936b5db874edc48fdc6c082651ea72e

data/lib/low_type.rb

@@ -6,6 +6,19 @@ require_relative 'type_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)
+
+    # Array[] class method returns a type expression only for the duration of this "included" hook.
+    array_class_method = Array.method('[]').unbind
+    Array.define_singleton_method('[]') do |expression|
+      TypeExpression.new(type: [(expression)])
+    end
+
+    # Hash[] class method returns a type expression only for the duration of this "included" hook.
+    hash_class_method = Hash.method('[]').unbind
+    Hash.define_singleton_method('[]') do |expression|
+      TypeExpression.new(type: expression)
+    end
+
     class << klass
       def low_params
         @low_params ||= {}
@@ -24,8 +37,12 @@ module LowType
 
     parser = Parser.new(file_path: LowType.file_path(klass:))
     private_start_line = parser.private_start_line
+
     klass.prepend LowType::Redefiner.redefine_methods(method_nodes: parser.instance_methods, private_start_line:, klass:)
     klass.singleton_class.prepend LowType::Redefiner.redefine_methods(method_nodes: parser.class_methods, private_start_line:, klass:)
+  ensure
+    Array.define_singleton_method('[]', array_class_method)
+    Hash.define_singleton_method('[]', hash_class_method)
   end
 
   class << self
@@ -44,6 +61,4 @@ module LowType
 
   class ValueExpression; end
   class Boolean; end # TrueClass or FalseClass
-  class KeyValue; end # KeyValue[String => Hash]
-  class MixedTypes; end # MixedTypes[String | Integer]
 end

data/lib/redefiner.rb

@@ -0,0 +1,87 @@
+require_relative 'param_proxy'
+require_relative 'parser'
+require_relative 'type_expression'
+
+module LowType
+  class Redefiner
+    class << self
+      def redefine_methods(method_nodes:, private_start_line:, klass:)
+        Module.new do
+          method_nodes.each do |method_node|
+            klass.low_params[method_node.name] = Redefiner.param_proxy_with_type_expressions(method_node)
+            next if klass.low_params[method_node.name].empty?
+
+            define_method(method_node.name) do |*args, **kwargs|
+              klass.low_params[method_node.name].each do |param_proxy|
+                arg = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
+                arg = param_proxy.type_expression.default_value if arg.nil? && param_proxy.type_expression.default_value != :LOW_TYPE_UNDEFINED
+                param_proxy.type_expression.validate!(arg:, name: param_proxy.name)
+                param_proxy.position ? args[param_proxy.position] = arg : kwargs[param_proxy.name] = arg
+              end
+
+              super(*args, **kwargs)
+            end
+
+            if private_start_line && method_node.start_line > private_start_line
+              private method_node.name
+            end
+          end
+        end
+      end
+
+      def param_proxy_with_type_expressions(method_node)
+        params = method_node.parameters.slice
+        proxy_method = eval("-> (#{params}) {}")
+        required_args, required_kwargs = Redefiner.required_args(proxy_method)
+
+        typed_method = eval(
+          <<~RUBY
+            -> (#{params}) {
+              param_proxies = []
+
+              proxy_method.parameters.each_with_index do |param, position|
+                type, name = param
+                position = nil unless [:opt, :req, :rest].include?(type)
+
+                expression = binding.local_variable_get(name)
+
+                if expression.class == TypeExpression
+                  param_proxies << ParamProxy.new(type_expression: expression, name:, type:, position:)
+                elsif ::LowType.type?(expression)
+                  param_proxies << ParamProxy.new(type_expression: TypeExpression.new(type: expression), name:, type:, position:)
+                end
+              end
+
+              param_proxies
+            }
+          RUBY
+        )
+
+        # Call method with only its required args to evaluate type expressions (which are stored as default values).
+        typed_method.call(*required_args, **required_kwargs)
+
+      # TODO: Write spec for this.
+      rescue ArgumentError => e
+        raise ArgumentError, "Incorrect param syntax"
+      end
+
+      def required_args(proxy_method)
+        required_args = []
+        required_kwargs = {}
+
+        proxy_method.parameters.each do |param|
+          param_type, param_name = param
+
+          case param_type
+          when :req
+            required_args << nil
+          when :keyreq
+            required_kwargs[param_name] = nil
+          end
+        end
+
+        [required_args, required_kwargs]
+      end
+    end
+  end
+end

data/lib/type_expression.rb

@@ -29,7 +29,16 @@ module LowType
         raise ArgumentError, "Missing required argument of type '#{@types.join(', ')}' for '#{name}'"
       end
 
-      raise TypeError, "Invalid type '#{arg.class}' for '#{name}'" unless @types.include?(arg.class)
+      @types.each do |type|
+        return true if LowType.type?(type) && type == arg.class 
+        # TODO: Shallow validation of enumerables could be made deeper with user config.
+        return true if type.class == Array && arg.class == Array && type.first == arg.first.class
+        if type.class == Hash && arg.class == Hash && type.keys[0] == arg.keys[0].class && type.values[0] == arg.values[0].class
+          return true
+        end
+      end
+
+      raise TypeError, "Invalid type '#{arg.class}' for '#{name}'"
     end
   end
 end

data/lib/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - maedi
@@ -20,6 +20,7 @@ files:
 - lib/low_type.rb
 - lib/param_proxy.rb
 - lib/parser.rb
+- lib/redefiner.rb
 - lib/type_expression.rb
 - lib/version.rb
 homepage: https://codeberg.org/low_ruby/low_type