low_type 1.1.8 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 295c067ff64ba1d3ddb26243c1676a7bbe7d3a41fb65c4c51e868462a44e4f1b
-  data.tar.gz: 2cff7d3f4f7f1dd8f6df9ab48e34737f562929cb802f798cf497a377034eee16
+  metadata.gz: 372ec6574de86edfe13eba87a457e290934635e88b092a711798df69d04aaa30
+  data.tar.gz: 3afaccd3fed8508ca0064cc9552b80bd05cf7b09ecfdd1906a93a043034ec978
 SHA512:
-  metadata.gz: 1f697cb2610e1acb2bc89a41ec35cd1f78a381fea7f3fed90c1984166d4ae514cffb8adf4ba6ef4916cd32897b85ba22e4ee84d26e4b187cb21657d7dedc6553
-  data.tar.gz: 54725a86fa96ac6bbf286d6c28d8a1af06090b64f1d75e5fe4ee21e398078d592aae71dd39b6c9d6170584f9ca4bd86175c827bf6d9ea1aaa0240540035080f7
+  metadata.gz: d59f9cf98881584fb19d3ca79748d67fdc71c5a9b55ff4ff3c4324c5658cedc88567b4037876e1d8ed5a087aafb76deff459f9493f2194ccbf002ff855a1f88b
+  data.tar.gz: be0a567f9212cb628c7efe852f71901ea4495cb9eb75681a259e68e7ef2fa545cfdfa8df0b01e4774872158db607f57fd950f274a4dcad32910c87f743de6208

data/lib/adapters/adapter_loader.rb

@@ -6,11 +6,11 @@ module Low
   module Adapter
     class Loader
       class << self
-        def load(klass:, parser:, file_path:)
+        def load(klass:, class_proxy:)
           adaptor = nil
 
           ancestors = klass.ancestors.map(&:to_s)
-          adaptor = Sinatra.new(klass:, parser:, file_path:) if ancestors.include?('Sinatra::Base')
+          adaptor = Sinatra.new(klass:, class_proxy:) if ancestors.include?('Sinatra::Base')
 
           return if adaptor.nil?
 

data/lib/adapters/sinatra_adapter.rb

@@ -11,41 +11,37 @@ module Low
   module Adapter
     # We don't use https://sinatrarb.com/extensions.html because we need to type check all Ruby methods (not just Sinatra) at a lower level.
     class Sinatra < AdapterInterface
-      def initialize(klass:, parser:, file_path:)
+      def initialize(klass:, class_proxy:)
         @klass = klass
-        @parser = parser
-        @file_path = file_path
+        @class_proxy = class_proxy
+        @file_path = class_proxy.file_path
       end
 
       def process # rubocop:disable Metrics/AbcSize
-        method_calls = @parser.method_calls(method_names: %i[get post patch put delete options query])
+        method_calls = @class_proxy.method_calls(%i[get post patch put delete options query])
 
         # Type check return values.
-        method_calls.each do |method_call|
-          arguments_node = method_call.compact_child_nodes.first
+        method_calls.each do |method_node|
+          arguments_node = method_node.compact_child_nodes.first
           next unless arguments_node.is_a?(Prism::ArgumentsNode)
 
           pattern = arguments_node.arguments.first.content
+          name = "#{method_node.name.upcase} #{pattern}"
+          scope = name
+          start_line = method_node.start_line
 
-          file = ProxyFactory.file_proxy(node: method_call, path: @file_path, scope: "#{@klass}##{method_call.name}")
-          next unless (return_proxy = return_proxy(method_node: method_call, pattern:, file:))
+          next unless (return_proxy = ProxyFactory.return_proxy(method_node:, name:, file_path:, scope: pattern))
 
-          route = "#{method_call.name.upcase} #{pattern}"
-          params = [ParamProxy.new(expression: nil, name: :route, type: :req, position: 0, file:)]
-          @klass.low_methods[route] = MethodProxy.new(name: method_call.name, params:, return_proxy:)
+          route = "#{method_node.name.upcase} #{pattern}"
+          name = method_node.name
+          param_proxies = [ParamProxy.new(expression: nil, name: :route, type: :req, file_path:, start_line:, scope:, position: 0)]
+          @klass.low_methods[route] = MethodProxy.new(file_path:, start_line:, scope:, name:, param_proxies:, return_proxy:)
         end
       end
 
-      def return_proxy(method_node:, pattern:, file:)
-        return_type = FileParser.return_type(method_node:)
-        return nil if return_type.nil?
+      private
 
-        # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
-        expression = eval(return_type.slice).call # rubocop:disable Security/Eval
-        expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
-
-        ReturnProxy.new(type_expression: expression, name: "#{method_node.name.upcase} #{pattern}", file:)
-      end
+      attr_reader :file_path
     end
 
     module Methods

data/lib/definitions/redefiner.rb

@@ -10,22 +10,22 @@ module Low
   # Redefine methods to have their arguments and return values type checked.
   class Redefiner
     class << self
-      def redefine(method_nodes:, class_proxy:, file_path:)
-        method_proxies = build_methods(method_nodes:, klass: class_proxy.klass, file_path:)
+      def redefine(method_nodes:, class_proxy:, klass:)
+        method_proxies = build_methods(method_nodes:, klass:, file_path: class_proxy.file_path)
 
         if LowType.config.type_checking
-          typed_methods(method_proxies:, class_proxy:)
+          typed_methods(method_proxies:, class_proxy:, klass:)
         else
-          untyped_methods(method_proxies:, class_proxy:)
+          untyped_methods(method_proxies:, class_proxy:, klass:)
         end
       end
 
-      def redefinable?(method_proxy:, class_proxy:)
-        method_has_types?(method_proxy:, class_proxy:) && method_within_class_bounds?(method_proxy:, class_proxy:)
+      def redefinable?(method_proxy:, class_proxy:, klass:)
+        method_has_types?(method_proxy:, klass:) && method_within_class_bounds?(method_proxy:, class_proxy:, klass:)
       end
 
       def untyped_args(args:, kwargs:, method_proxy:) # rubocop:disable Metrics/AbcSize
-        method_proxy.params.each do |param_proxy|
+        method_proxy.param_proxies.each do |param_proxy|
           value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
 
           next unless value.nil?
@@ -44,11 +44,12 @@ module Low
       def build_methods(method_nodes:, klass:, file_path:)
         method_nodes.each do |name, method_node|
           begin # rubocop:disable Style/RedundantBegin
-            file = ProxyFactory.file_proxy(path: file_path, node: method_node, scope: "#{klass}##{name}")
+            name = method_node.name
+            scope = name
 
-            param_proxies = ProxyFactory.param_proxies(method_node:, file:)
-            return_proxy = ProxyFactory.return_proxy(method_node:, file:)
-            method_proxy = MethodProxy.new(name:, params: param_proxies, return_proxy:, file:)
+            param_proxies = ProxyFactory.param_proxies(method_node:, file_path:, scope:)
+            return_proxy = ProxyFactory.return_proxy(method_node:, name:, file_path:, scope:)
+            method_proxy = MethodProxy.new(file_path:, start_line: method_node.start_line, scope:, name:, param_proxies:, return_proxy:)
 
             Repository.save(method: method_proxy, klass:)
           # When we can't parse the method's params or return type then skip it.
@@ -60,17 +61,17 @@ module Low
         Repository.all(klass:)
       end
 
-      def typed_methods(method_proxies:, class_proxy:) # rubocop:disable Metrics
+      def typed_methods(method_proxies:, class_proxy:, klass:) # rubocop:disable Metrics
         Module.new do
           method_proxies.each do |name, method_proxy|
-            next unless Low::Redefiner.redefinable?(method_proxy:, class_proxy:)
+            next unless Low::Redefiner.redefinable?(method_proxy:, class_proxy:, klass:)
 
             # You are now in the binding of the includer class (`name` is also available here).
             define_method(name) do |*args, **kwargs|
               # Inlined version of Repository.load() for performance increase.
               method_proxy = instance_of?(Class) ? low_methods[name] : self.class.low_methods[name] || Object.low_methods[name]
 
-              method_proxy.params.each do |param_proxy|
+              method_proxy.param_proxies.each do |param_proxy|
                 value = param_proxy.position ? args[param_proxy.position] : kwargs[param_proxy.name]
                 value = param_proxy.expression.default_value if value.nil? && !param_proxy.required?
 
@@ -93,10 +94,10 @@ module Low
         end
       end
 
-      def untyped_methods(method_proxies:, class_proxy:)
+      def untyped_methods(method_proxies:, class_proxy:, klass:)
         Module.new do
           method_proxies.each do |name, method_proxy|
-            next unless Low::Redefiner.redefinable?(method_proxy:, class_proxy:)
+            next unless Low::Redefiner.redefinable?(method_proxy:, class_proxy:, klass:)
 
             # You are now in the binding of the includer class (`name` is also available here).
             define_method(name) do |*args, **kwargs|
@@ -111,19 +112,20 @@ module Low
         end
       end
 
-      def method_has_types?(method_proxy:, class_proxy:)
-        if method_proxy.params == [] && method_proxy.return_proxy.nil?
-          Low::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
+      def method_has_types?(method_proxy:, klass:)
+        if method_proxy.param_proxies == [] && method_proxy.return_proxy.nil?
+          Low::Repository.delete(name: method_proxy.name, klass:)
           return false
         end
 
         true
       end
 
-      def method_within_class_bounds?(method_proxy:, class_proxy:)
-        within_bounds = method_proxy.start_line > class_proxy.start_line && method_proxy.end_line <= class_proxy.end_line
-        if method_proxy.lines? && class_proxy.lines? && !within_bounds
-          Low::Repository.delete(name: method_proxy.name, klass: class_proxy.klass)
+      def method_within_class_bounds?(method_proxy:, class_proxy:, klass:)
+        within_bounds = method_proxy.start_line > class_proxy.start_line && method_proxy.start_line <= class_proxy.end_line
+
+        unless within_bounds
+          Low::Repository.delete(name: method_proxy.name, klass:)
           return false
         end
 

data/lib/definitions/type_accessors.rb

@@ -9,31 +9,37 @@ module Low
     def type_reader(named_expressions)
       named_expressions.each do |name, exp|
         last_caller = caller_locations(1, 1).first
-        file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
+        file_path = last_caller.path
+        start_line = last_caller.lineno
+        scope = "#{self}##{name}"
 
-        expression = expression(exp)
-        @low_methods[name] = MethodProxy.new(name:, return_proxy: ReturnProxy.new(type_expression: expression, name:, file:))
+        type_expression = type_expression(exp)
+        return_proxy = ReturnProxy.new(type_expression:, name:, file_path:, start_line:, scope:)
+
+        @low_methods[name] = MethodProxy.new(file_path:, start_line:, scope:, name:, return_proxy:)
 
         define_method(name) do
           method_proxy = self.class.low_methods[name]
           value = instance_variable_get("@#{name}")
-          expression.validate!(value:, proxy: method_proxy.return_proxy)
+          type_expression.validate!(value:, proxy: method_proxy.return_proxy)
           value
         end
       end
     end
 
     def type_writer(named_expressions) # rubocop:disable Metrics/AbcSize
-      named_expressions.each do |name, exp|
+      named_expressions.each do |name, expression|
         last_caller = caller_locations(1, 1).first
-        file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: "#{self}##{name}")
+        file_path = last_caller.path
+        start_line = last_caller.lineno
+        scope = "#{self}##{name}"
 
-        params = [ParamProxy.new(expression: expression(exp), name:, type: :hashreq, file:)]
-        @low_methods["#{name}="] = MethodProxy.new(name:, params:)
+        param_proxies = [ParamProxy.new(expression: type_expression(expression), name:, type: :hashreq, file_path:, start_line:, scope:)]
+        @low_methods["#{name}="] = MethodProxy.new(file_path:, start_line:, scope:, name:, param_proxies:)
 
         define_method("#{name}=") do |value|
           method_proxy = self.class.low_methods["#{name}="]
-          method_proxy.params.first.expression.validate!(value:, proxy: method_proxy.params.first)
+          method_proxy.param_proxies.first.expression.validate!(value:, proxy: method_proxy.param_proxies.first)
           instance_variable_set("@#{name}", value)
         end
       end
@@ -48,7 +54,7 @@ module Low
 
     private
 
-    def expression(expression)
+    def type_expression(expression)
       if expression.is_a?(::Expressions::Expression)
         expression
       elsif ::Low::TypeQuery.type?(expression)

data/lib/expressions/expressions.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require_relative '../factories/expression_factory'
-require_relative '../proxies/file_proxy'
 require_relative '../proxies/local_proxy'
 require_relative '../types/error_types'
 
@@ -11,8 +10,9 @@ module Low
       value = type_expression.default_value
 
       last_caller = caller_locations(1, 1).first
-      file = FileProxy.new(path: last_caller.path, start_line: last_caller.lineno, scope: 'local type')
-      proxy = LocalProxy.new(type_expression:, name: self, file:)
+      file_path = last_caller.path
+      start_line = last_caller.lineno
+      proxy = LocalProxy.new(type_expression:, name: self, file_path:, start_line:, scope: 'local type')
 
       type_expression.validate!(value:, proxy:)
 

data/lib/factories/proxy_factory.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
 require 'expressions'
+require 'lowkey'
 
 require_relative '../expressions/expressions'
 require_relative '../expressions/type_expression'
-require_relative '../proxies/file_proxy'
 require_relative '../proxies/param_proxy'
 require_relative '../proxies/return_proxy'
-require_relative '../queries/file_parser'
 require_relative '../syntax/syntax'
 require_relative '../types/complex_types'
 require_relative '../types/status'
@@ -20,15 +19,8 @@ module Low
       include Low::Expressions
       include Low::Types
 
-      def file_proxy(node:, path:, scope:)
-        start_line = node.respond_to?(:start_line) ? node.start_line : nil
-        end_line = node.respond_to?(:end_line) ? node.end_line : nil
-
-        FileProxy.new(path:, start_line:, end_line:, scope:)
-      end
-
       # The evals below aren't a security risk because the code comes from a trusted source; the file itself that did the include.
-      def param_proxies(method_node:, file:)
+      def param_proxies(method_node:, file_path:, scope:)
         return [] if method_node.parameters.nil?
 
         params_without_block = method_node.parameters.slice.delete_suffix(', &block')
@@ -38,7 +30,7 @@ module Low
         # Local variable names are prefixed with __lt or __rb where needed to avoid being overridden by method parameters.
         typed_method = <<~RUBY
           -> (#{params_without_block}, __rb_method:, __lt_file:) {
-            param_proxies_for_expressions(ruby_method: __rb_method, file: __lt_file, method_binding: binding)
+            param_proxies_for_expressions(ruby_method: __rb_method, file_path: __lt_file, start_line: method_node.start_line, scope:, method_binding: binding)
           }
         RUBY
 
@@ -46,27 +38,29 @@ module Low
 
         # Called with only required args (as nil) and optional args omitted, to evaluate expressions stored as default values.
         eval(typed_method, binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
-          .call(*required_args, **required_kwargs, __rb_method: ruby_method, __lt_file: file)
+          .call(*required_args, **required_kwargs, __rb_method: ruby_method, __lt_file: file_path)
 
       # TODO: Unit test this.
       rescue ArgumentError => e
         raise ArgumentError, "Incorrect param syntax: #{e.message}"
       end
 
-      def return_proxy(method_node:, file:)
-        return_type = FileParser.return_type(method_node:)
+      def return_proxy(method_node:, name:, file_path:, scope:)
+        return_type = Lowkey::ClassProxy.return_type(method_node:)
         return nil if return_type.nil?
 
+        start_line = method_node.start_line
+
         begin
           # Not a security risk because the code comes from a trusted source; the file that did the include. Does the file trust itself?
           expression = eval(return_type.slice, binding, __FILE__, __LINE__).call # rubocop:disable Security/Eval
         rescue NameError
-          raise NameError, "Unknown return type '#{return_type.slice}' for #{file.scope} at #{file.path}:#{file.start_line}"
+          raise NameError, "Unknown return type '#{return_type.slice}' for #{scope} at #{file_path}:#{start_line}"
         end
 
         expression = TypeExpression.new(type: expression) unless expression.is_a?(TypeExpression)
 
-        ReturnProxy.new(type_expression: expression, name: method_node.name, file:)
+        ReturnProxy.new(type_expression: expression, name:, file_path:, start_line:, scope:)
       end
 
       private
@@ -89,7 +83,7 @@ module Low
         [required_args, required_kwargs]
       end
 
-      def param_proxies_for_expressions(ruby_method:, file:, method_binding:)
+      def param_proxies_for_expressions(ruby_method:, file_path:, start_line:, scope:, method_binding:)
         param_proxies = []
 
         ruby_method.parameters.each_with_index do |param, position|
@@ -110,7 +104,7 @@ module Low
             expression = TypeExpression.new(type: local_variable)
           end
 
-          param_proxies << ParamProxy.new(expression:, name:, type:, position:, file:) if expression
+          param_proxies << ParamProxy.new(expression:, name:, type:, file_path:, start_line:, scope:, position:) if expression
         end
 
         param_proxies

data/lib/interfaces/error_interface.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
 module Low
+  # Used by proxies to output errors.
   class ErrorInterface
-    attr_reader :file
+    attr_reader :file_path, :start_line, :scope
+
+    def initialize(file_path:, start_line:, scope:)
+      @file_path = file_path
+      @start_line = start_line
+      @scope = scope
 
-    def initialize
-      @file = nil
       @output_mode = LowType.config.output_mode
       @output_size = LowType.config.output_size
     end
@@ -34,8 +38,8 @@ module Low
       # Remove LowType defined method file paths from the backtrace.
       filtered_backtrace = backtrace.reject { |line| hidden_paths.find { |file_path| line.include?(file_path) } }
 
-      # Add the proxied file to the backtrace.
-      proxy_file_backtrace = "#{file.path}:#{file.start_line}:in '#{file.scope}'"
+      # Add the proxied entity to the backtrace.
+      proxy_file_backtrace = "#{file_path}:#{start_line}:in '#{scope}'"
       from_prefix = filtered_backtrace.first.match(/\s+from /)
       proxy_file_backtrace = "#{from_prefix}#{proxy_file_backtrace}" if from_prefix
 

data/lib/low_type.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
+require 'lowkey'
+
 require_relative 'adapters/adapter_loader'
 require_relative 'definitions/redefiner'
 require_relative 'definitions/type_accessors'
 require_relative 'expressions/expressions'
-require_relative 'queries/file_parser'
 require_relative 'queries/file_query'
 require_relative 'syntax/syntax'
 require_relative 'types/complex_types'
@@ -23,15 +24,16 @@ module LowType
     file_path = Low::FileQuery.file_path(klass:)
     return unless File.exist?(file_path)
 
-    parser = Low::FileParser.new(klass:, file_path:)
+    file_proxy = Lowkey.load(file_path:)
+    class_proxy = file_proxy.definitions[klass.name]
 
     klass.extend Low::TypeAccessors
     klass.include Low::Types
     klass.include Low::Expressions
-    klass.prepend Low::Redefiner.redefine(method_nodes: parser.instance_methods, class_proxy: parser.class_proxy, file_path:)
-    klass.singleton_class.prepend Low::Redefiner.redefine(method_nodes: parser.class_methods, class_proxy: parser.class_proxy, file_path:)
+    klass.prepend Low::Redefiner.redefine(method_nodes: class_proxy.instance_methods, class_proxy:, klass:)
+    klass.singleton_class.prepend Low::Redefiner.redefine(method_nodes: class_proxy.class_methods, class_proxy:, klass:)
 
-    if (adapter = Low::Adapter::Loader.load(klass:, parser:, file_path:))
+    if (adapter = Low::Adapter::Loader.load(klass:, class_proxy:))
       adapter.process
       klass.prepend Low::Adapter::Methods
     end

data/lib/proxies/local_proxy.rb

@@ -7,12 +7,11 @@ module Low
   class LocalProxy < ErrorInterface
     attr_reader :type_expression, :name
 
-    def initialize(type_expression:, name:, file:)
-      super()
+    def initialize(type_expression:, name:, file_path:, start_line:, scope:)
+      super(file_path:, start_line:, scope:)
 
       @type_expression = type_expression
       @name = name
-      @file = file
     end
 
     def error_type
@@ -20,7 +19,7 @@ module Low
     end
 
     def error_message(value:)
-      "Invalid variable type #{output(value:)} in '#{name.class}:#{@file.start_line}'. Valid types: '#{type_expression.valid_types}'"
+      "Invalid variable type #{output(value:)} in '#{name.class}:#{@start_line}'. Valid types: '#{type_expression.valid_types}'"
     end
   end
 end

data/lib/proxies/method_proxy.rb

@@ -1,20 +1,17 @@
 # frozen_string_literal: true
 
-require 'forwardable'
-
 module Low
   class MethodProxy
-    extend Forwardable
-
-    attr_reader :name, :file, :params, :return_proxy
+    attr_reader :file_path, :start_line, :scope, :name, :param_proxies, :return_proxy
 
-    # File is queried by redefiner but not sinatra adapter nor type accessors.
-    def_delegators :@file, :start_line, :end_line, :lines?
+    # TODO: Refactor file path, start line and scope into "meta scope" model.
+    def initialize(file_path:, start_line:, scope:, name:, param_proxies: [], return_proxy: nil) # rubocop:disable Metrics/ParameterLists
+      @file_path = file_path
+      @start_line = start_line
+      @scope = scope
 
-    def initialize(name:, file: nil, params: [], return_proxy: nil)
       @name = name
-      @file = file
-      @params = params
+      @param_proxies = param_proxies
       @return_proxy = return_proxy
     end
   end

data/lib/proxies/param_proxy.rb

@@ -7,14 +7,14 @@ module Low
   class ParamProxy < ErrorInterface
     attr_reader :expression, :name, :type, :position
 
-    def initialize(expression:, name:, type:, file:, position: nil)
-      super()
+    # TODO: Refactor file path, start line and scope into "meta scope" model.
+    def initialize(expression:, name:, type:, file_path:, start_line:, scope:, position: nil) # rubocop:disable Metrics/ParameterLists
+      super(file_path:, start_line:, scope:)
 
       @expression = expression
       @name = name
       @type = type
       @position = position
-      @file = file
     end
 
     def required?

data/lib/proxies/return_proxy.rb

@@ -7,12 +7,11 @@ module Low
   class ReturnProxy < ErrorInterface
     attr_reader :type_expression, :name
 
-    def initialize(type_expression:, name:, file:)
-      super()
+    def initialize(type_expression:, name:, file_path:, start_line:, scope:)
+      super(file_path:, start_line:, scope:)
 
       @type_expression = type_expression
       @name = name
-      @file = file
     end
 
     def error_type

data/lib/version.rb

@@ -2,6 +2,6 @@
 
 module Low
   module Type
-    VERSION = '1.1.8'
+    VERSION = '1.1.9'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: low_type
 version: !ruby/object:Gem::Version
-  version: 1.1.8
+  version: 1.1.9
 platform: ruby
 authors:
 - maedi
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: lowkey
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
 description: An elegant and simple way to define types in Ruby, only when you need
   them.
 email:
@@ -45,13 +59,10 @@ files:
 - lib/interfaces/adapter_interface.rb
 - lib/interfaces/error_interface.rb
 - lib/low_type.rb
-- lib/proxies/class_proxy.rb
-- lib/proxies/file_proxy.rb
 - lib/proxies/local_proxy.rb
 - lib/proxies/method_proxy.rb
 - lib/proxies/param_proxy.rb
 - lib/proxies/return_proxy.rb
-- lib/queries/file_parser.rb
 - lib/queries/file_query.rb
 - lib/queries/type_query.rb
 - lib/syntax/syntax.rb

data/lib/proxies/class_proxy.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-module Low
-  class ClassProxy
-    extend Forwardable
-
-    attr_reader :name, :klass, :file, :private_start_line
-
-    def_delegators :@file, :start_line, :end_line, :lines?
-
-    def initialize(klass:, file:, private_start_line:)
-      @name = klass.to_s
-      @klass = klass
-      @file = file
-      @private_start_line = private_start_line
-    end
-  end
-end

data/lib/proxies/file_proxy.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Low
-  class FileProxy
-    attr_reader :path, :scope
-    attr_accessor :start_line, :end_line
-
-    def initialize(path:, scope:, start_line:, end_line: nil)
-      @path = path
-      @start_line = start_line
-      @end_line = end_line || start_line
-      @scope = scope
-    end
-
-    def lines?
-      start_line && end_line
-    end
-  end
-end

data/lib/queries/file_parser.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require 'prism'
-require_relative '../proxies/class_proxy'
-
-module Low
-  class FileParser
-    attr_reader :parent_map, :instance_methods, :class_methods, :class_proxy
-
-    def initialize(klass:, 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 = MethodDefVisitor.new(root_node: @root_node, parent_map:, klass:, file_path:)
-      @root_node.accept(method_visitor)
-
-      @instance_methods = method_visitor.instance_methods
-      @class_methods = method_visitor.class_methods
-      @class_proxy = ClassProxy.new(klass:, file: method_visitor.file_proxy, private_start_line: method_visitor.private_start_line)
-    end
-
-    def method_calls(method_names:)
-      block_visitor = MethodCallVisitor.new(parent_map:, method_names:)
-      @root_node.accept(block_visitor)
-      block_visitor.method_calls
-    end
-
-    class << self
-      # Only a lambda defined immediately after a method's parameters/block is considered a return type expression.
-      def return_type(method_node:)
-        # Method statements.
-        statements_node = method_node.compact_child_nodes.find { |node| node.is_a?(Prism::StatementsNode) }
-
-        # Block statements.
-        if statements_node.nil?
-          block_node = method_node.compact_child_nodes.find { |node| node.is_a?(Prism::BlockNode) }
-          statements_node = block_node.compact_child_nodes.find { |node| node.is_a?(Prism::StatementsNode) } if block_node
-        end
-
-        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
-      end
-    end
-  end
-
-  class MethodDefVisitor < Prism::Visitor
-    attr_reader :class_methods, :instance_methods, :file_proxy, :private_start_line
-
-    def initialize(root_node:, parent_map:, klass:, file_path:)
-      @parent_map = parent_map
-      @klass = klass
-
-      @instance_methods = {}
-      @class_methods = {}
-
-      end_line = root_node.respond_to?(:end_line) ? root_node.end_line : nil
-      @file_proxy = FileProxy.new(path: file_path, start_line: 0, end_line:, scope: klass.to_s)
-      @private_start_line = nil
-    end
-
-    def visit_def_node(node)
-      if class_method?(node)
-        @class_methods[node.name] = node
-      else
-        @instance_methods[node.name] = node
-      end
-
-      super # Continue walking the tree.
-    end
-
-    def visit_call_node(node)
-      return super unless node.name == :private && node.respond_to?(:start_line) && file_proxy.start_line && file_proxy.end_line
-
-      @private_start_line = node.start_line if node.start_line > file_proxy.start_line && node.start_line < file_proxy.end_line
-
-      super
-    end
-
-    def visit_class_node(node)
-      if node.name == @klass.to_s.to_sym
-        file_proxy.start_line = node.class_keyword_loc.start_line
-        file_proxy.end_line = node.end_keyword_loc.end_line
-      end
-
-      super
-    end
-
-    private
-
-    def class_method?(node)
-      return true if node.is_a?(::Prism::DefNode) && node.receiver.instance_of?(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 MethodCallVisitor < Prism::Visitor
-    attr_reader :method_calls
-
-    def initialize(parent_map:, method_names:)
-      @parent_map = parent_map
-      @method_names = method_names
-
-      @method_calls = []
-    end
-
-    def visit_call_node(node)
-      @method_calls << node if @method_names.include?(node.name)
-
-      super # Continue walking the tree.
-    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