lowkey 0.3.2 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32447c431fd5565b44ba41a641dbf1081619def560b139fbb090902a281827f6
-  data.tar.gz: 98e73906e4657e135ab0b5e4b9c81d9b4b898d34caff0162c77155859c68d3b8
+  metadata.gz: a2bcc0b4b60c158051ab7da59abb915078011d30cf4a231db29ddc03f87a9af4
+  data.tar.gz: 50ed70e6d38d529f0b9d8c39cd31e3af9df2fd0f04100bf4739235d81daadb59
 SHA512:
-  metadata.gz: 8eaed237ab5aaadffdef5e5a2b9cd0a5fd882b5d5f1591aeb64c7bebbe7c0407e3d4c5626dd3dbb86343391dbfa49750f889877f7a404e4536bfd3034ce22586
-  data.tar.gz: 9118dada97ff5c4f245d4e3479cd64771956b4cecf28f0ad5b475dc46cba4cdd49d3f00e2cc25cf1ae6ed7283416dc74e6ce4cbd4322880f593e47224e1301f7
+  metadata.gz: 2585284e511997be690bffcee538d8e8e97150ce9338b803867aafc4680f1e8caa70b4d34d8d8c4952cf8ba2cd141462ae74d7b0fad0194b5e22d3cb90ed7fb5
+  data.tar.gz: eb4a250a62dfd1cf13110095f8a4b831b9b47c282944c38f2edd642bb3f4817ddfd9fe838acd5241d0088ab93ec3d2e56c3ae6cec45dfbda2de0b84b389c019b

data/lib/adapters/adapter_loader.rb

@@ -9,7 +9,7 @@ module Lowkey
       def load(file_proxy:)
         class_proxies = file_proxy.definitions.values.filter { |definition| definition.instance_of?(ClassProxy) }
         class_proxies.each do |class_proxy|
-          SinatraAdapter.new(class_proxy:).load
+          SinatraAdapter.new(file_proxy:, class_proxy:).load
         end
       end
     end

data/lib/adapters/sinatra_adapter.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
+require_relative '../factories/source_factory'
 require_relative '../interfaces/adapter'
 
 module Lowkey
   class SinatraAdapter < Adapter
-    def initialize(class_proxy:)
+    def initialize(file_proxy:, class_proxy:)
+      @file_proxy = file_proxy
       @class_proxy = class_proxy
-      @file_path = class_proxy.file_path
     end
 
     def load # rubocop:disable Metrics/AbcSize
@@ -20,19 +21,25 @@ module Lowkey
         pattern = arguments_node.arguments.first.content
         route = "#{method_call_node.name.upcase} #{pattern}"
         name = route
-        scope = route
-        start_line = method_call_node.start_line
+        source = SourceFactory.method_call_source(method_call_node:, arguments_node:, file_path:, lines:)
 
-        next unless (return_proxy = ProxyFactory.return_proxy(method_node: method_call_node, name:, file_path:, scope:))
+        next unless (return_proxy = ProxyFactory.return_proxy(method_node: method_call_node, name:, source:))
 
-        param_proxies = [ParamProxy.new(file_path:, start_line:, scope:, name:, type: :pos_req, position: 0)]
+        param_proxies = [ParamProxy.new(source:, name:, type: :pos_req, position: 0)]
+        method_proxy = MethodProxy.new(source:, name:, param_proxies:, return_proxy:)
 
-        @class_proxy.keyed_methods[route] = MethodProxy.new(file_path:, start_line:, scope:, name:, param_proxies:, return_proxy:)
+        @class_proxy.keyed_methods[route] = method_proxy
       end
     end
 
     private
 
-    attr_reader :file_path
+    def file_path
+      @file_proxy.file_path
+    end
+
+    def lines
+      @file_proxy.lines
+    end
   end
 end

data/lib/factories/proxy_factory.rb

@@ -1,13 +1,48 @@
 # frozen_string_literal: true
 
+require_relative '../factories/source_factory'
+
+require_relative '../proxies/body_proxy'
+require_relative '../proxies/class_proxy'
+require_relative '../proxies/file_proxy'
 require_relative '../proxies/method_proxy'
+require_relative '../proxies/module_proxy'
 require_relative '../proxies/param_proxy'
 require_relative '../proxies/return_proxy'
 
 module Lowkey
   class ProxyFactory
     class << self
-      def param_proxies(parameters_node:, file_path:, scope:)
+      def file_proxy(root_node:, file_path:)
+        source = SourceFactory.file_source(root_node:, file_path:)
+        FileProxy.new(root_node:, source:)
+      end
+
+      def module_proxy(node:, namespace:, file_path:, lines:)
+        source = SourceFactory.module_source(node:, namespace:, file_path:, lines:)
+        name = node.respond_to?(:name) ? node.name : 'Object'
+        ModuleProxy.new(node:, name:, namespace:, source:)
+      end
+
+      def class_proxy(node:, namespace:, file_path:, lines:)
+        source = SourceFactory.class_source(node:, file_path:, lines:)
+        ClassProxy.new(node:, name: node.name, namespace:, source:)
+      end
+
+      def method_proxy(method_node:, file_proxy:)
+        name = method_node.name
+
+        method_source = SourceFactory.method_source(method_node:, file_path: file_proxy.file_path, lines: file_proxy.lines)
+        body_source = SourceFactory.body_source(method_source:)
+
+        param_proxies = param_proxies(parameters_node: method_node.parameters, file_path: file_proxy.file_path, source: method_source)
+        body_proxy = BodyProxy.new(name:, source: body_source)
+        return_proxy = return_proxy(name:, method_node:, source: method_source)
+
+        MethodProxy.new(name:, source: method_source, param_proxies:, body_proxy:, return_proxy:)
+      end
+
+      def param_proxies(parameters_node:, source:, file_path:)
         return [] if parameters_node.nil?
 
         param_types = {
@@ -19,24 +54,22 @@ module Lowkey
 
         params = [*parameters_node.requireds, *parameters_node.optionals, *parameters_node.keywords]
         params.map.with_index do |param, position|
-          type = param_types[param.class]
           name = param.name
-          scope = name
-          start_line = param.start_line
+          source = SourceFactory.param_source(param_node: param, file_path:, lines: source.lines)
+          type = param_types[param.class]
           value = param.respond_to?(:value) ? param.value.slice : ':LOWKEY_UNDEFINED'
 
-          ParamProxy.new(file_path:, start_line:, scope:, name:, type:, position:, value:)
+          ParamProxy.new(name:, source:, type:, position:, value:)
         end
       end
 
-      def return_proxy(method_node:, name:, file_path:, scope:)
+      def return_proxy(method_node:, name:, source:)
         return_node = find_return_node(method_node:)
         return nil if return_node.nil?
 
-        start_line = return_node.start_line
         value = return_node.body.slice
 
-        ReturnProxy.new(name:, file_path:, start_line:, scope:, value:)
+        ReturnProxy.new(name:, source:, value:)
       end
 
       private

data/lib/factories/source_factory.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative '../models/source'
+
+module Lowkey
+  class SourceFactory
+    class << self
+      def file_source(root_node:, file_path:)
+        end_line = root_node.respond_to?(:end_line) ? root_node.end_line : nil
+
+        Source.new(file_path:, scope: 'file', lines: root_node.script_lines, start_line: 0, end_line:)
+      end
+
+      def module_source(node:, namespace:, file_path:, lines:)
+        start_line = node.respond_to?(:class_keyword_loc) ? node.class_keyword_loc.start_line : 0
+        end_line = node.respond_to?(:end_keyword_loc) ? node.end_keyword_loc.end_line : start_line
+        end_line = node.end_line if namespace == 'Object'
+        scope = node.respond_to?(:name) ? node.name : 'Object'
+
+        Source.new(file_path:, scope:, lines:, start_line:, end_line:)
+      end
+
+      def class_source(node:, file_path:, lines:)
+        start_line = node.respond_to?(:class_keyword_loc) ? node.class_keyword_loc.start_line : 0
+        end_line = node.respond_to?(:end_keyword_loc) ? node.end_keyword_loc.end_line : start_line
+
+        Source.new(file_path:, scope: node.name, lines:, start_line:, end_line:)
+      end
+
+      def method_source(method_node:, file_path:, lines:)
+        scope = method_node.name
+        start_line = method_node.start_line
+        end_line = method_node.end_line
+        end_line = end_line_from_indent(method_node:, lines:) if end_line > lines.count
+
+        Source.new(file_path:, scope:, lines:, start_line:, end_line:)
+      end
+
+      def param_source(param_node:, file_path:, lines:)
+        scope = param_node.name
+        start_line = param_node.start_line
+        end_line = param_node.end_line
+
+        Source.new(file_path:, scope:, lines:, start_line:, end_line:)
+      end
+
+      def body_source(method_source:)
+        # TODO: Handle multi-line return proxy which increases body start line.
+        start_line = method_source.start_line + 1
+        end_line = method_source.end_line - 1
+
+        Source.new(file_path: method_source.file_path, scope: method_source.scope, lines: method_source.lines, start_line:, end_line:)
+      end
+
+      def method_call_source(method_call_node:, arguments_node:, file_path:, lines:)
+        pattern = arguments_node.arguments.first.content
+        scope = "#{method_call_node.name.upcase} #{pattern}"
+        start_line = method_call_node.start_line
+        end_line = method_call_node.end_line
+
+        Source.new(file_path:, scope:, lines:, start_line:, end_line:)
+      end
+
+      private
+
+      # TODO: end_line = start_line if it's an endless method like "def method = expression".
+      def end_line_from_indent(method_node:, lines:)
+        end_index = nil
+
+        index = method_node.start_line - 1
+        indent = lines[index].split('def').first
+
+        while end_index.nil?
+          end_index = index if lines[index].nil?
+          end_index = index if lines[index].start_with?("#{indent}end")
+          index += 1
+        end
+
+        end_index + 1
+      end
+    end
+  end
+end

data/lib/interfaces/proxy.rb

@@ -1,13 +1,21 @@
 # frozen_string_literal: true
 
+require 'forwardable'
+
 module Lowkey
+  # Proxy and Source abstract away nodes and avoid referencing the node on the proxy itself. Will this change?
+  # The goal is to make an API that's indiependent of the AST, that can manipulate source code line by line.
   class Proxy
-    attr_reader :file_path, :start_line, :scope
+    extend Forwardable
+
+    attr_reader :name
+
+    def_delegators :@source, :file_path, :lines, :start_line, :end_line, :scope
+    def_delegators :@source, :wrap, :export
 
-    def initialize(file_path:, start_line:, scope:)
-      @file_path = file_path
-      @start_line = start_line
-      @scope = scope
+    def initialize(name:, source:)
+      @name = name
+      @source = source
     end
   end
 end

data/lib/lowkey.rb

@@ -3,6 +3,8 @@
 require 'prism'
 
 require_relative 'adapters/adapter_loader'
+require_relative 'factories/proxy_factory'
+require_relative 'maps/parent_map'
 require_relative 'visitors/visitor'
 require_relative 'proxies/file_proxy'
 
@@ -16,9 +18,9 @@ module Lowkey
       keys[key]
     end
 
-    def load(file_path)
+    def load(file_path, cache: true)
       root_node = Prism.parse_file(file_path).value
-      file_proxy = FileProxy.new(path: file_path, root_node:)
+      file_proxy = ProxyFactory.file_proxy(root_node:, file_path:)
 
       parent_map = ParentMap.new(root_node:)
       visitor = Visitor.new(file_proxy:, parent_map:)
@@ -26,7 +28,7 @@ module Lowkey
 
       AdapterLoader.load(file_proxy:)
 
-      if Lowkey.config.cache
+      if Lowkey.config.cache && cache
         map_file_path(file_proxy:)
         map_definitions(file_proxy:)
       end
@@ -50,11 +52,11 @@ module Lowkey
     private
 
     def map_file_path(file_proxy:)
-      keys[file_proxy.path] = file_proxy
+      keys[file_proxy.file_path] = file_proxy
 
       # Map absolute paths to project root/relative paths.
-      project_path = file_proxy.path.delete_prefix(Dir.pwd).delete_prefix('/')
-      keys[project_path] = file_proxy if project_path != file_proxy.path
+      project_path = file_proxy.file_path.delete_prefix(Dir.pwd).delete_prefix('/')
+      keys[project_path] = file_proxy if project_path != file_proxy.file_path
     end
 
     def map_definitions(file_proxy:)

data/lib/models/source.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Lowkey
+  class Source
+    attr_reader :file_path, :scope
+    attr_accessor :lines, :start_line, :end_line
+
+    def initialize(file_path:, scope:, lines:, start_line:, end_line: nil)
+      @file_path = file_path
+      @scope = scope
+
+      @start_line = start_line
+      @end_line = end_line
+      @lines = lines
+    end
+
+    def wrap(prefix:, suffix:)
+      start_line = lines[start_index]
+      indent = start_line[/^\s+/]
+      lines[start_index] = indent + prefix.to_s + start_line.lstrip
+
+      lines[end_index] = lines[end_index] + suffix.to_s
+    end
+
+    def export
+      lines.join
+    end
+
+    private
+
+    def start_index
+      start_line - 1
+    end
+
+    def end_index
+      end_line - 1
+    end
+  end
+end

data/lib/proxies/body_proxy.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/proxy'
+
+module Lowkey
+  class BodyProxy < Proxy
+    def initialize(name:, source:)
+      super(name:, source:)
+    end
+  end
+end

data/lib/proxies/class_proxy.rb

@@ -1,50 +1,15 @@
 # frozen_string_literal: true
 
-require_relative '../queries/query'
+require_relative 'module_proxy'
 
 module Lowkey
-  class ClassProxy
-    include Query
+  class ClassProxy < ModuleProxy
+    attr_accessor :instance_methods
 
-    attr_reader :namespace, :start_line, :end_line
-    attr_accessor :private_start_line, :keyed_methods, :class_methods, :instance_methods, :method_calls
+    def initialize(node:, name:, namespace:, source:)
+      super(node:, name:, namespace:, source:)
 
-    def initialize(node:, namespace:, file_proxy:)
-      @node = node
-      @namespace = namespace
-      @file_proxy = file_proxy
-
-      @start_line = node.respond_to?(:class_keyword_loc) ? node.class_keyword_loc.start_line : 0
-      @end_line = node.respond_to?(:end_keyword_loc) ? node.end_keyword_loc.end_line : @start_line
-      @end_line = file_proxy.end_line if namespace == 'Object'
-      @private_start_line = nil
-
-      @keyed_methods = {}
-      @class_methods = {}
       @instance_methods = {}
-
-      @method_calls = []
-    end
-
-    def [](key)
-      key.start_with?('.') ? query(node: @node, namespace: nil, name: key.delete_prefix('.')) : @keyed_methods[key]
-    end
-
-    def file_path
-      @file_proxy.path
-    end
-
-    class << self
-      def class_method?(method_node:, parent_map:)
-        return true if method_node.is_a?(::Prism::DefNode) && method_node.receiver.instance_of?(Prism::SelfNode) # self.method_name
-        return true if method_node.is_a?(::Prism::SingletonClassNode) # class << self
-
-        if (parent_node = parent_map[method_node])
-          return class_method?(method_node: parent_node, parent_map:)
-        end
-
-        false
-      end
     end
   end
 end

data/lib/proxies/file_proxy.rb

@@ -1,50 +1,41 @@
 # frozen_string_literal: true
 
-require_relative '../maps/parent_map'
+require_relative '../interfaces/proxy'
 require_relative '../proxies/class_proxy'
 require_relative '../queries/query'
 
 module Lowkey
-  class FileProxy
+  class FileProxy < Proxy
     include Query
 
-    attr_reader :path, :start_line, :end_line
+    attr_reader :root_node
     attr_accessor :definitions, :dependencies
 
-    def initialize(path:, root_node:)
-      @path = path
-      @root_node = root_node
+    def initialize(root_node:, source:)
+      super(name: nil, source:)
 
-      @start_line = 0
-      @end_line = root_node.respond_to?(:end_line) ? root_node.end_line : nil
+      @root_node = root_node
 
       @definitions = {}
-      @dependencies = []
+      @dependencies = Set.new
     end
 
     def [](keypath)
-      namespace, *path = keypath.split('.')
-      path.empty? ? @definitions[namespace] : query(node: @root_node, namespace:, name: path.join)
+      namespace, *file_path = keypath.split('.')
+      file_path.empty? ? @definitions[namespace] : query(node: @root_node, namespace:, name: file_path.join)
     end
 
     def []=(keypath, value)
       # TODO: Slice the lines in a file and replace with the output of the class proxy.
     end
 
-    def upsert_class_proxy(node:, parent_map:)
-      namespace = namespace(node:, parent_map:).reverse.join('::')
-      namespace = 'Object' if namespace.empty?
-      @definitions[namespace] ||= ClassProxy.new(node:, namespace:, file_proxy: self)
+    def upsert_definition(module_proxy:)
+      # TODO: Merge duplicate class with existing class.
+      @definitions[module_proxy.namespace] ||= module_proxy
     end
 
-    private
-
-    def namespace(node:, parent_map:, namespace: [])
-      return namespace if parent_map[node].nil?
-
-      namespace << node.constant_path.name.to_s if node.respond_to?(:constant_path)
-
-      namespace(node: parent_map[node], parent_map:, namespace:)
+    def upsert_dependency(namespace:)
+      @dependencies.add(namespace)
     end
   end
 end

data/lib/proxies/method_proxy.rb

@@ -7,17 +7,17 @@ module Lowkey
   class MethodProxy < Proxy
     include Query
 
-    attr_reader :file_path, :start_line, :scope, :name, :params, :return_proxy
+    attr_reader :params, :body, :return_proxy
 
-    # TODO: Refactor file path, start line and scope into "scope" model.
-    def initialize(file_path:, start_line:, scope:, name:, param_proxies: [], return_proxy: nil) # rubocop:disable Metrics/ParameterLists
-      super(file_path:, start_line:, scope:)
+    def initialize(name:, source:, param_proxies: [], body_proxy: nil, return_proxy: nil)
+      super(name:, source:)
 
-      @name = name
       @params = param_proxies
+      @body = body_proxy
+      @return_proxy = return_proxy
+
       @named_params = name_params
       @tagged_params = tag_params
-      @return_proxy = return_proxy
     end
 
     def [](key)

data/lib/proxies/module_proxy.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/proxy'
+require_relative '../queries/query'
+
+module Lowkey
+  class ModuleProxy < Proxy
+    include Query
+
+    attr_reader :namespace
+    attr_accessor :private_start_line, :keyed_methods, :class_methods, :method_calls
+
+    def initialize(node:, name:, namespace:, source:)
+      super(name:, source:)
+
+      @node = node
+      @namespace = namespace
+
+      @private_start_line = nil
+
+      @keyed_methods = {}
+      @class_methods = {}
+
+      @method_calls = []
+    end
+
+    def [](key)
+      key.start_with?('.') ? query(node: @node, namespace: nil, name: key.delete_prefix('.')) : @keyed_methods[key]
+    end
+
+    class << self
+      def class_method?(method_node:, parent_map:)
+        return true if method_node.is_a?(::Prism::DefNode) && method_node.receiver.instance_of?(Prism::SelfNode) # self.method_name
+        return true if method_node.is_a?(::Prism::SingletonClassNode) # class << self
+
+        if (parent_node = parent_map[method_node])
+          return class_method?(method_node: parent_node, parent_map:)
+        end
+
+        false
+      end
+    end
+  end
+end

data/lib/proxies/param_proxy.rb

@@ -4,17 +4,16 @@ require_relative '../interfaces/proxy'
 
 module Lowkey
   class ParamProxy < Proxy
-    attr_reader :name, :type, :position, :value
+    attr_reader :type, :position, :value
     attr_accessor :expression
 
-    # TODO: Refactor file path, start line and scope into "scope" model.
-    def initialize(file_path:, start_line:, scope:, name:, type:, value: :LOWKEY_UNDEFINED, position: nil, expression: nil) # rubocop:disable Metrics/ParameterLists
-      super(file_path:, start_line:, scope:)
+    def initialize(name:, source:, type:, position: nil, value: :LOWKEY_UNDEFINED, expression: nil) # rubocop:disable Metrics/ParameterLists
+      super(name:, source:)
 
-      @name = name
       @type = type
       @position = position
       @value = value
+
       @expression = expression
     end
 

data/lib/proxies/return_proxy.rb

@@ -4,13 +4,12 @@ require_relative '../interfaces/proxy'
 
 module Lowkey
   class ReturnProxy < Proxy
-    attr_reader :name, :value
+    attr_reader :value
     attr_accessor :expression
 
-    def initialize(file_path:, start_line:, scope:, name:, value: :LOWKEY_UNDEFINED, expression: nil) # rubocop:disable Metrics/ParameterLists
-      super(file_path:, start_line:, scope:)
+    def initialize(name:, source:, value: :LOWKEY_UNDEFINED, expression: nil)
+      super(name:, source:)
 
-      @name = name
       @value = value
       @expression = expression
     end

data/lib/queries/query.rb

@@ -8,5 +8,16 @@ module Lowkey
         n.respond_to?(:name) && n.name == name.to_sym
       end
     end
+
+    def namespace(node:, parent_map:, namespace: [])
+      if parent_map[node].nil?
+        namespace << 'Object' if namespace.empty?
+        return namespace.reverse.join('::')
+      end
+
+      namespace << node.constant_path.name.to_s if node.respond_to?(:constant_path)
+
+      namespace(node: parent_map[node], parent_map:, namespace:)
+    end
   end
 end

data/lib/version.rb

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

data/lib/visitors/class_visitor.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../factories/proxy_factory'
+require_relative '../queries/query'
+
+module Lowkey
+  class ClassVisitor
+    include Query
+
+    def initialize(file_proxy:, parent_map:)
+      @file_proxy = file_proxy
+      @parent_map = parent_map
+    end
+
+    def visit(node)
+      namespace = namespace(node:, parent_map:)
+      class_proxy = ProxyFactory.class_proxy(node:, namespace:, file_path:, lines:)
+      @file_proxy.upsert_definition(module_proxy: class_proxy)
+    end
+
+    attr_reader :parent_map
+
+    def file_path
+      @file_proxy.file_path
+    end
+
+    def lines
+      @file_proxy.lines
+    end
+  end
+end

data/lib/visitors/method_call_visitor.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
+require_relative '../queries/query'
+
 module Lowkey
   class MethodCallVisitor
-    attr_reader :parent_map
+    include Query
 
     def initialize(file_proxy:, parent_map:)
       @file_proxy = file_proxy
@@ -10,13 +12,28 @@ module Lowkey
     end
 
     def visit(node)
-      class_proxy = @file_proxy.upsert_class_proxy(node:, parent_map:)
-      class_proxy.method_calls << node
+      namespace = namespace(node:, parent_map:)
+      module_proxy = file_proxy[namespace]
+
+      module_proxy.method_calls << node
+      upsert_dependency(node:, namespace:)
 
-      return unless node.name == :private && node.respond_to?(:start_line) && class_proxy.start_line && class_proxy.end_line
-      return unless node.start_line > class_proxy.start_line && node.start_line < class_proxy.end_line
+      return unless node.name == :private && node.respond_to?(:start_line) && module_proxy.start_line && module_proxy.end_line
+      return unless node.start_line > module_proxy.start_line && node.start_line < module_proxy.end_line
 
-      class_proxy.private_start_line = node.start_line
+      module_proxy.private_start_line = node.start_line
     end
+
+    private
+
+    def upsert_dependency(node:, namespace:)
+      return unless %i[include extend].include?(node.name)
+
+        dependency_name = node.arguments.arguments.first.name.to_s
+        dependency_name = "#{namespace}::#{dependency_name}" unless dependency_name.start_with?('::')
+        file_proxy.upsert_dependency(namespace: dependency_name)
+    end
+
+    attr_reader :file_proxy, :parent_map
   end
 end

data/lib/visitors/method_def_visitor.rb

@@ -1,39 +1,36 @@
 # frozen_string_literal: true
 
+require_relative '../factories/source_factory'
 require_relative '../factories/proxy_factory'
+require_relative '../proxies/method_proxy'
+require_relative '../queries/query'
 
 module Lowkey
   class MethodDefVisitor
-    attr_reader :parent_map
+    include Query
 
     def initialize(file_proxy:, parent_map:)
       @file_proxy = file_proxy
       @parent_map = parent_map
     end
 
-    def visit(method_node) # rubocop:disable Metrics/AbcSize
-      class_proxy = @file_proxy.upsert_class_proxy(node: method_node, parent_map:)
-      name = method_node.name
-      scope = name
+    def visit(method_node)
+      namespace = namespace(node: method_node, parent_map:)
+      module_proxy = file_proxy[namespace]
+      method_proxy = ProxyFactory.method_proxy(method_node:, file_proxy:)
 
-      param_proxies = ProxyFactory.param_proxies(parameters_node: method_node.parameters, file_path:, scope:)
-      return_proxy = ProxyFactory.return_proxy(name:, method_node:, file_path:, scope:)
-      method_proxy = MethodProxy.new(file_path:, start_line: method_node.start_line, scope:, name:, param_proxies:, return_proxy:)
+      module_proxy.keyed_methods[method_node.name] = method_proxy
 
-      class_proxy.keyed_methods[method_node.name] = method_proxy
-
-      # TODO: Implemented as sorted methods similar to sorted params.
-      if ClassProxy.class_method?(method_node:, parent_map:)
-        class_proxy.class_methods[method_node.name] = method_proxy
-      else
-        class_proxy.instance_methods[method_node.name] = method_proxy
+      # TODO: Implemented as tagged methods similar to tagged params.
+      if ModuleProxy.class_method?(method_node:, parent_map:)
+        module_proxy.class_methods[method_node.name] = method_proxy
+      elsif module_proxy.class <= ClassProxy
+        module_proxy.instance_methods[method_node.name] = method_proxy
       end
     end
 
     private
 
-    def file_path
-      @file_proxy.path
-    end
+    attr_reader :file_proxy, :parent_map
   end
 end

data/lib/visitors/module_visitor.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../factories/proxy_factory'
+require_relative '../queries/query'
+
+module Lowkey
+  class ModuleVisitor
+    include Query
+
+    def initialize(file_proxy:, parent_map:)
+      @file_proxy = file_proxy
+      @parent_map = parent_map
+
+      create_root_module
+    end
+
+    def visit(node)
+      namespace = namespace(node:, parent_map:)
+      module_proxy = ProxyFactory.module_proxy(node:, namespace:, file_path:, lines:)
+      @file_proxy.upsert_definition(module_proxy:)
+    end
+
+    private
+
+    def create_root_module
+      module_proxy = ProxyFactory.module_proxy(node: @file_proxy.root_node, namespace: 'Object', file_path:, lines:)
+      @file_proxy.upsert_definition(module_proxy:)
+    end
+
+    attr_reader :parent_map
+
+    def file_path
+      @file_proxy.file_path
+    end
+
+    def lines
+      @file_proxy.lines
+    end
+  end
+end

data/lib/visitors/visitor.rb

@@ -1,24 +1,26 @@
 # frozen_string_literal: true
 
-require_relative 'method_call_visitor'
-require_relative 'method_class_visitor'
+require_relative 'class_visitor'
+require_relative 'module_visitor'
 require_relative 'method_def_visitor'
+require_relative 'method_call_visitor'
 
 module Lowkey
   class Visitor < Prism::Visitor
     def initialize(file_proxy:, parent_map:)
-      @method_call_visitor = MethodCallVisitor.new(file_proxy:, parent_map:)
-      @method_class_visitor = MethodClassVisitor.new(file_proxy:, parent_map:)
+      @class_visitor = ClassVisitor.new(file_proxy:, parent_map:)
+      @module_visitor = ModuleVisitor.new(file_proxy:, parent_map:)
       @method_def_visitor = MethodDefVisitor.new(file_proxy:, parent_map:)
+      @method_call_visitor = MethodCallVisitor.new(file_proxy:, parent_map:)
     end
 
-    def visit_call_node(node)
-      @method_call_visitor.visit(node)
+    def visit_class_node(node)
+      @class_visitor.visit(node)
       super
     end
 
-    def visit_class_node(node)
-      @method_class_visitor.visit(node)
+    def visit_module_node(node)
+      @module_visitor.visit(node)
       super
     end
 
@@ -26,5 +28,10 @@ module Lowkey
       @method_def_visitor.visit(node)
       super
     end
+
+    def visit_call_node(node)
+      @method_call_visitor.visit(node)
+      super
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lowkey
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.1
 platform: ruby
 authors:
 - maedi
@@ -34,20 +34,25 @@ files:
 - lib/adapters/adapter_loader.rb
 - lib/adapters/sinatra_adapter.rb
 - lib/factories/proxy_factory.rb
+- lib/factories/source_factory.rb
 - lib/interfaces/adapter.rb
 - lib/interfaces/proxy.rb
 - lib/lowkey.rb
 - lib/maps/parent_map.rb
+- lib/models/source.rb
+- lib/proxies/body_proxy.rb
 - lib/proxies/class_proxy.rb
 - lib/proxies/file_proxy.rb
 - lib/proxies/method_proxy.rb
+- lib/proxies/module_proxy.rb
 - lib/proxies/param_proxy.rb
 - lib/proxies/return_proxy.rb
 - lib/queries/query.rb
 - lib/version.rb
+- lib/visitors/class_visitor.rb
 - lib/visitors/method_call_visitor.rb
-- lib/visitors/method_class_visitor.rb
 - lib/visitors/method_def_visitor.rb
+- lib/visitors/module_visitor.rb
 - lib/visitors/visitor.rb
 homepage: https://github.com/low-rb/lowkey
 licenses: []

data/lib/visitors/method_class_visitor.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Lowkey
-  class MethodClassVisitor
-    attr_reader :parent_map
-
-    def initialize(file_proxy:, parent_map:)
-      @file_proxy = file_proxy
-      @parent_map = parent_map
-    end
-
-    def visit(node)
-      @file_proxy.upsert_class_proxy(node:, parent_map:)
-    end
-  end
-end