lowkey 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f105e73eb19ec3b29ba8a8e2452071c1bf9f693fdd5dc5449374bf31315566b
-  data.tar.gz: 95680c064c4020c42a473cef33e83d9277177ab22eae60ef8180cd79928fa5db
+  metadata.gz: b43e841e7df88bd529e4940fbc84e381896e105c5885824de12e8fdaa59e0b1a
+  data.tar.gz: 11feefde6d25fe3fadd3d70c38b9b5e5d4867bcade3e83d38eb5aa143eb8f790
 SHA512:
-  metadata.gz: 6427844a8671c39e1a6e3ff7298b74d89b6b128d1243c745e65a568498efe72bfc70f5fbe2ee277e5b4b632e18056bf6301f85418fe7dd201dbbd84d5258b9d5
-  data.tar.gz: fbb67e2e9a8d69848658b6bf51d4afaa1d6c96a46b630b85b74309e20791c0e0745680090d4cb56dd25a113f1e8957db159f2eb3704f29968a5093b08c8688a0
+  metadata.gz: 4c9631e357f115bcad8e12b5447b4714e821bb109e61e2c566ef1709d9efa3cca64d6657508d8092d466d37d4f3b5755446a56ed557f3c5943c520d1401c0363
+  data.tar.gz: 8c8d05eeb6ea1e3111ae28feeabc1e4558ac362f020f1a4435835db2e2810aad05b23798af28911fd3f451cef12b7773b6f2f1e6211306d8643c6c081df718b6

data/lib/adapters/adapter_loader.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'sinatra_adapter'
+require_relative '../proxies/class_proxy'
+
+module Lowkey
+  class AdapterLoader
+    class << self
+      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
+        end
+      end
+    end
+  end
+end

data/lib/adapters/sinatra_adapter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/adapter'
+
+module Lowkey
+  class SinatraAdapter < Adapter
+    def initialize(class_proxy:)
+      @class_proxy = class_proxy
+      @file_path = class_proxy.file_path
+    end
+
+    def load # rubocop:disable Metrics/AbcSize
+      # Type check return values.
+      @class_proxy.method_calls.each do |method_call_node|
+        next unless %i[get post patch put delete options].include?(method_call_node.name)
+
+        arguments_node = method_call_node.compact_child_nodes.first
+        next unless arguments_node.is_a?(Prism::ArgumentsNode)
+
+        pattern = arguments_node.arguments.first.content
+        route = "#{method_call_node.name.upcase} #{pattern}"
+        name = route
+        scope = route
+        start_line = method_call_node.start_line
+
+        next unless (return_proxy = ProxyFactory.return_proxy(method_node: method_call_node, name:, file_path:, scope:))
+
+        param_proxies = [ParamProxy.new(file_path:, start_line:, scope:, name:, type: :pos_req, position: 0)]
+
+        @class_proxy.keyed_methods[route] = MethodProxy.new(file_path:, start_line:, scope:, name:, param_proxies:, return_proxy:)
+      end
+    end
+
+    private
+
+    attr_reader :file_path
+  end
+end

data/lib/factories/proxy_factory.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../proxies/method_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:)
+        return [] if parameters_node.nil?
+
+        param_types = {
+          Prism::RequiredParameterNode => :pos_req,
+          Prism::OptionalParameterNode => :pos_opt,
+          Prism::RequiredKeywordParameterNode => :key_req,
+          Prism::OptionalKeywordParameterNode => :key_opt
+        }
+
+        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
+          value = param.respond_to?(:value) ? param.value.slice : ':LOWKEY_UNDEFINED'
+
+          ParamProxy.new(file_path:, start_line:, scope:, name:, type:, position:, value:)
+        end
+      end
+
+      def return_proxy(method_node:, name:, file_path:, scope:)
+        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:)
+      end
+
+      private
+
+      # A return type is an unassigned lambda defined immediately after a method's parameters/block.
+      def find_return_node(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
+end

data/lib/interfaces/adapter.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lowkey
+  class Adapter
+    def load
+      raise NotImplementedError
+    end
+  end
+end

data/lib/interfaces/proxy.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lowkey
+  class Proxy
+    attr_reader :file_path, :start_line, :scope
+
+    def initialize(file_path:, start_line:, scope:)
+      @file_path = file_path
+      @start_line = start_line
+      @scope = scope
+    end
+  end
+end

data/lib/lowkey.rb

@@ -2,6 +2,7 @@
 
 require 'prism'
 
+require_relative 'adapters/adapter_loader'
 require_relative 'visitors/visitor'
 require_relative 'proxies/file_proxy'
 
@@ -23,6 +24,8 @@ module Lowkey
       visitor = Visitor.new(file_proxy:, parent_map:)
       root_node.accept(visitor)
 
+      AdapterLoader.load(file_proxy:)
+
       if Lowkey.config.cache
         map_file_path(file_proxy:)
         map_definitions(file_proxy:)
@@ -48,6 +51,10 @@ module Lowkey
 
     def map_file_path(file_proxy:)
       keys[file_proxy.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
     end
 
     def map_definitions(file_proxy:)

data/lib/proxies/class_proxy.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
+require_relative '../queries/query'
+
 module Lowkey
   class ClassProxy
+    include Query
+
     attr_reader :namespace, :start_line, :end_line
-    attr_writer :method_calls
-    attr_accessor :private_start_line, :class_methods, :instance_methods
+    attr_accessor :private_start_line, :keyed_methods, :class_methods, :instance_methods, :method_calls
 
     def initialize(node:, namespace:, file_proxy:)
+      @node = node
       @namespace = namespace
       @file_proxy = file_proxy
 
@@ -15,15 +19,15 @@ module Lowkey
       @end_line = file_proxy.end_line if namespace == 'Object'
       @private_start_line = nil
 
+      @keyed_methods = {}
       @class_methods = {}
       @instance_methods = {}
+
       @method_calls = []
     end
 
-    def method_calls(method_names = nil)
-      return @method_calls if method_names.nil?
-
-      @method_calls.filter { |method_call| method_names.include?(method_call.name) }
+    def [](key)
+      key.start_with?('.') ? query(node: @node, namespace: nil, name: key.delete_prefix('.')) : @keyed_methods[key]
     end
 
     def file_path
@@ -31,31 +35,12 @@ module Lowkey
     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
-
-      def class_method?(node:, parent_map:)
-        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
+      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[node])
-          return class_method?(node: parent_node, parent_map:)
+        if (parent_node = parent_map[method_node])
+          return class_method?(method_node: parent_node, parent_map:)
         end
 
         false

data/lib/proxies/file_proxy.rb

@@ -2,14 +2,19 @@
 
 require_relative '../maps/parent_map'
 require_relative '../proxies/class_proxy'
+require_relative '../queries/query'
 
 module Lowkey
   class FileProxy
+    include Query
+
     attr_reader :path, :start_line, :end_line
     attr_accessor :definitions, :dependencies
 
     def initialize(path:, root_node:)
       @path = path
+      @root_node = root_node
+
       @start_line = 0
       @end_line = root_node.respond_to?(:end_line) ? root_node.end_line : nil
 
@@ -17,6 +22,15 @@ module Lowkey
       @dependencies = []
     end
 
+    def [](keypath)
+      namespace, *path = keypath.split('.')
+      path.empty? ? @definitions[namespace] : query(node: @root_node, namespace:, name: 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?

data/lib/proxies/method_proxy.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/proxy'
+require_relative '../queries/query'
+
+module Lowkey
+  class MethodProxy < Proxy
+    include Query
+
+    attr_reader :file_path, :start_line, :scope, :name, :params, :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:)
+
+      @name = name
+      @params = param_proxies
+      @named_params = name_params
+      @tagged_params = tag_params
+      @return_proxy = return_proxy
+    end
+
+    def [](key)
+      # TODO: Initialize method proxy with method node and support query code path.
+      key.start_with?('.') ? query(node: @node, namespace: nil, name: key.delete_prefix('.')) : @named_params[key]
+    end
+
+    def tagged_params(tag)
+      @tagged_params[tag] || []
+    end
+
+    def expressions?
+      @params.any?(&:expression) || @return_proxy
+    end
+
+    def params_with_expressions
+      @params_with_expressions ||= @params.filter(&:expression)
+    end
+
+    private
+
+    def name_params
+      @params.each_with_object({}) do |param, named_params|
+        named_params[param.name] = param if %i[pos_req pos_opt key_req key_opt].include?(param.type)
+      end
+    end
+
+    def tag_params
+      tags = { required: [], optional: [], positional: [], keyword: [], value: [] }
+
+      tag_from_types = {
+        required: %i[pos_req key_req],
+        optional: %i[pos_opt key_opt],
+        positional: %i[pos_req pos_opt],
+        keyword: %i[key_req key_opt]
+      }
+
+      tag_from_types.each do |tag, types|
+        @params.each do |param|
+          tags[tag] << param if types.include?(param.type)
+          tags[:value] << param if param.value != :LOWKEY_UNDEFINED
+        end
+      end
+
+      tags
+    end
+  end
+end

data/lib/proxies/param_proxy.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/proxy'
+
+module Lowkey
+  class ParamProxy < Proxy
+    attr_reader :name, :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:)
+
+      @name = name
+      @type = type
+      @position = position
+      @value = value
+      @expression = expression
+    end
+
+    def required?
+      @value == :LOWKEY_UNDEFINED
+    end
+  end
+end

data/lib/proxies/return_proxy.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/proxy'
+
+module Lowkey
+  class ReturnProxy < Proxy
+    attr_reader :name, :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:)
+
+      @name = name
+      @value = value
+      @expression = expression
+    end
+  end
+end

data/lib/queries/query.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lowkey
+  module Query
+    # TODO: Make name a keypath.
+    def query(node:, namespace:, name:) # rubocop:disable Lint/UnusedMethodArgument
+      node.breadth_first_search do |n|
+        n.respond_to?(:name) && n.name == name.to_sym
+      end
+    end
+  end
+end

data/lib/version.rb

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

data/lib/visitors/method_def_visitor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../factories/proxy_factory'
+
 module Lowkey
   class MethodDefVisitor
     attr_reader :parent_map
@@ -9,14 +11,29 @@ module Lowkey
       @parent_map = parent_map
     end
 
-    def visit(node)
-      class_proxy = @file_proxy.upsert_class_proxy(node:, parent_map:)
+    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
+
+      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:)
+
+      class_proxy.keyed_methods[method_node.name] = method_proxy
 
-      if ClassProxy.class_method?(node:, parent_map:)
-        class_proxy.class_methods[node.name] = node
+      # 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[node.name] = node
+        class_proxy.instance_methods[method_node.name] = method_proxy
       end
     end
+
+    private
+
+    def file_path
+      @file_proxy.path
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lowkey
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - maedi
@@ -31,10 +31,19 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/adapters/adapter_loader.rb
+- lib/adapters/sinatra_adapter.rb
+- lib/factories/proxy_factory.rb
+- lib/interfaces/adapter.rb
+- lib/interfaces/proxy.rb
 - lib/lowkey.rb
 - lib/maps/parent_map.rb
 - lib/proxies/class_proxy.rb
 - lib/proxies/file_proxy.rb
+- lib/proxies/method_proxy.rb
+- lib/proxies/param_proxy.rb
+- lib/proxies/return_proxy.rb
+- lib/queries/query.rb
 - lib/version.rb
 - lib/visitors/method_call_visitor.rb
 - lib/visitors/method_class_visitor.rb