low_type 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 849b5a1d0d8d4ec70dda7366f9e72a991aa71ce72631495f66c78e3bb03b8de3
-  data.tar.gz: 4e5f71133ec37642bee7ef092103926d9b673e6ac3d2f0c621bee69e25b4953c
+  metadata.gz: 76a73e683c2e961c41eef7d14d5f41ac3e7252f9c22cc2b4b807c6ede92b6a89
+  data.tar.gz: 0a264a10f5c070c2b08160e0c94d69cf403c86a2961a0b72eab069b5e47c33af
 SHA512:
-  metadata.gz: dc9e6b031328b7c398b04cb15ebeb9c347c3b4ff6c49a6e64570dbfdfb2b95b8facfde45bbb07f63c285631280629c2d5b8674e7709505ebac8342fd81a539ed
-  data.tar.gz: cde6c6557d6b47c1e35b6b6216fb939e85f778439483d5c493a21d64cade1d3f6b4bca5c689d0def331a5fb2f0da7f6ee7c497fd974ece7224af72dbb616970c
+  metadata.gz: cd2e3b8caf03f7575d765eb573b66035706f2cc82fecea20fb806902e94aae5a7040d3eac4afdb3888b49359a035903e5b714a4662dd1cc4b25b28d79d40797b
+  data.tar.gz: 56c33ae15714520170d9cc85df710ce20b5a50dd1162705341938129ab95f0c6556baec3cd19c3371523c3f3994ed549d024a17937c83688ec91879e8e36e6b0

data/lib/low_type.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'redefiner'
 require_relative 'type_expression'
 
 module LowType
-  class InvalidTypeError < StandardError; end;
-  class RequiredValueError < StandardError; end;
-
   # We do as much as possible on class load rather than on instantiation to be thread-safe and efficient.
-  def self.included(base)
-    class << base
+  def self.included(klass)
+    class << klass
       def low_params
         @low_params ||= {}
       end
@@ -24,43 +22,13 @@ module LowType
       alias_method :low_value, :value
     end
 
-    base.prepend LowType.redefine_methods(file_path: LowType.file_path(klass: base), klass: base)
-  end
-
-  def self.redefine_methods(file_path:, klass:)
-    Module.new do
-      # TODO: Use an AST.
-      File.readlines(file_path).each do |file_line|
-        method_line = file_line.strip
-        next unless method_line.start_with?('def ') && method_line.include?('(')
-
-        method_name, args = method_line.delete_prefix('def ').split(/[()]/)
-        method_name = method_name.to_sym
-
-        proxy_method = eval("-> (#{args}) {}")
-        required_args, required_kwargs = LowType.required_args(proxy_method)
-
-        klass.low_params[method_name] = LowType.type_expressions_from_params(proxy_method, args, required_args, required_kwargs)
-        
-        define_method(method_name) do |*args, **kwargs|
-          klass.low_params[method_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
-      end
-    end
+    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:)
   end
 
   class << self
-    def methods(klass)
-      klass.public_instance_methods(false) + klass.protected_instance_methods(false) + klass.private_instance_methods(false)
-    end
-
     def file_path(klass:)
       caller.find { |callee| callee.end_with?("<class:#{klass}>'") }.split(':').first
     end
@@ -72,67 +40,10 @@ module LowType
     def value?(expression)
       !expression.respond_to?(:new) && expression != Integer
     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
-
-    def type_expressions_from_params(proxy_method, args, required_args, required_kwargs)
-      typed_method = eval(
-        <<~RUBY
-          -> (#{args}) {
-            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)
-    end
-  end
-
-  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
 
   class ValueExpression; end
-
-  class Boolean; end
-  class KeyValue; end
+  class Boolean; end # TrueClass or FalseClass
+  class KeyValue; end # KeyValue[String => Hash]
+  class MixedTypes; end # MixedTypes[String | Integer]
 end

data/lib/param_proxy.rb

@@ -0,0 +1,12 @@
+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

data/lib/parser.rb

@@ -0,0 +1,83 @@
+require 'prism'
+
+module LowType
+  class Parser
+    attr_reader :parent_map, :instance_methods, :class_methods, :private_start_line
+
+    def initialize(file_path:)
+      root_node = Prism.parse_file(file_path).value
+
+      parent_mapper = ParentMapper.new
+      parent_mapper.visit(root_node)
+      @parent_map = parent_mapper.parent_map
+
+      method_visitor = MethodVisitor.new(@parent_map)
+      root_node.accept(method_visitor)
+
+      @instance_methods = method_visitor.instance_methods
+      @class_methods = method_visitor.class_methods
+      @private_start_line = method_visitor.private_start_line
+    end
+  end
+
+  class MethodVisitor < Prism::Visitor
+    attr_reader :class_methods, :instance_methods, :private_start_line
+
+    def initialize(parent_map)
+      @parent_map = parent_map
+
+      @instance_methods = []
+      @class_methods = []
+      @private_start_line = nil
+    end
+
+    def visit_def_node(node)
+      if class_method?(node)
+        @class_methods << node
+      else
+        @instance_methods << node
+      end
+
+      super # Continue walking the tree.
+    end
+
+    def visit_call_node(node)
+      @private_start_line = node.start_line if node.name == :private
+    end
+
+    private
+
+    def class_method?(node)
+      return true if node.is_a?(::Prism::DefNode) && node.receiver.class == Prism::SelfNode # self.method_name
+      return true if node.is_a?(::Prism::SingletonClassNode) # class << self
+
+      if (parent_node = @parent_map[node])
+        return class_method?(parent_node)
+      end
+
+      false
+    end
+  end
+
+  class ParentMapper < Prism::Visitor
+    attr_reader :parent_map
+
+    def initialize
+      @parent_map = {}
+      @current_parent = nil
+    end
+
+    def visit(node)
+      @parent_map[node] = @current_parent
+
+      old_parent = @current_parent
+      @current_parent = node
+
+      node.compact_child_nodes.each do |n|
+        visit(n)
+      end
+
+      @current_parent = old_parent
+    end
+  end
+end

data/lib/type_expression.rb

@@ -26,10 +26,10 @@ module LowType
 
     def validate!(arg:, name:)
       if arg.nil? && required?
-        raise ::LowType::RequiredValueError, "Missing value of required type [#{@types.join(',')}] for '#{name}'"
+        raise ArgumentError, "Missing required argument of type '#{@types.join(', ')}' for '#{name}'"
       end
 
-      raise ::LowType::InvalidTypeError, "Invalid type '#{arg.class}' for '#{name}'" unless @types.include?(arg.class)
+      raise TypeError, "Invalid type '#{arg.class}' for '#{name}'" unless @types.include?(arg.class)
     end
   end
 end

data/lib/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - maedi
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-10 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
 description: An elegant and simple way to define types in Ruby, only when you need
   them.
@@ -19,6 +18,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/low_type.rb
+- lib/param_proxy.rb
+- lib/parser.rb
 - lib/type_expression.rb
 - lib/version.rb
 homepage: https://codeberg.org/low_ruby/low_type
@@ -26,7 +27,6 @@ licenses: []
 metadata:
   homepage_uri: https://codeberg.org/low_ruby/low_type
   source_code_uri: https://codeberg.org/low_ruby/low_type/src/branch/main
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -34,15 +34,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.2.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 3.7.2
 specification_version: 4
 summary: An elegant way to define types in Ruby
 test_files: []