rucoa 0.7.0 → 0.9.0

data/lib/rucoa/yard/definitions_loader.rb

@@ -1,60 +1,332 @@
 # frozen_string_literal: true
 
 require 'logger'
+require 'set'
 require 'yard'
 
 module Rucoa
   module Yard
     class DefinitionsLoader
       class << self
-        # @param content [String]
-        # @return [Array<Rucoa::Definitions::Base>]
-        # @example returns method definitions from Ruby source code
-        #   content = <<~RUBY
-        #     class Foo
-        #       # Return given argument as an Integer.
-        #       # @param bar [String]
-        #       # @return [Integer]
-        #       def foo(bar)
-        #         bar.to_i
-        #       end
-        #     end
-        #   RUBY
-        #   definitions = Rucoa::Yard::DefinitionsLoader.load_string(
-        #     content: content,
-        #     path: '/path/to/foo.rb'
-        #   )
-        #   expect(definitions.size).to eq(1)
-        #   expect(definitions.first.full_qualified_name).to eq('Foo#foo')
-        #   expect(definitions.first.source_path).to eq('/path/to/foo.rb')
-        #   expect(definitions.first.description).to eq('Return given argument as an Integer.')
-        #   expect(definitions.first.return_types).to eq(%w[Integer])
-        def load_string(content:, path:)
-          ::YARD::Registry.clear
-          quietly do
-            ::YARD.parse_string(content)
-          end
-          ::YARD::Registry.all.filter_map do |code_object|
-            DefinitionMapper.call(code_object, path: path)
-          end
-        end
-
-        # @param globs [String]
-        # @return [Array<Rucoa::Definitions::Base>]
-        def load_globs(globs:)
-          ::YARD::Registry.clear
-          quietly do
-            ::YARD.parse(globs)
-          end
-          ::YARD::Registry.all.filter_map do |code_object|
-            DefinitionMapper.call(code_object)
-          end
-        end
-
-        private
-
-        def quietly(&block)
-          ::YARD::Logger.instance.enter_level(::Logger::FATAL, &block)
+        # @param associations [Hash]
+        # @param root_node [Rucoa::Nodes::Base]
+        def call(
+          associations:,
+          root_node:
+        )
+          new(
+            associations: associations,
+            root_node: root_node
+          ).call
+        end
+      end
+
+      # @param associations [Hash]
+      # @param root_node [Rucoa::Nodes::Base]
+      def initialize(
+        associations:,
+        root_node:
+      )
+        @associations = associations
+        @root_node = root_node
+      end
+
+      # @return [Array<Rucoa::Definition::Base>]
+      def call
+        [
+          @root_node,
+          *@root_node.descendants
+        ].flat_map do |node|
+          [
+            DefinitionGenerators::ClassDefinitionGenerator,
+            DefinitionGenerators::MethodDefinitionGenerator,
+            DefinitionGenerators::ModuleDefinitionGenerator,
+            DefinitionGenerators::AttributeReaderDefinitionGenerator,
+            DefinitionGenerators::AttributeWriterDefinitionGenerator
+          ].flat_map do |generator|
+            generator.call(
+              comment: comment_for(node),
+              node: node
+            )
+          end
+        end
+      end
+
+      # @return [String]
+      def comment_for(node)
+        @associations[node.location].map do |parser_comment|
+          parser_comment.text.gsub(/^#\s*/m, '')
+        end.join("\n")
+      end
+
+      module DefinitionGenerators
+        class Base
+          class << self
+            # @param comment [String]
+            # @param node [Rucoa::Nodes::Base]
+            # @return [Array<Rucoa::Definitions::Base>]
+            def call(
+              comment:,
+              node:
+            )
+              new(
+                comment: comment,
+                node: node
+              ).call
+            end
+          end
+
+          # @param comment [String]
+          # @param node [Rucoa::Nodes::Base]
+          def initialize(
+            comment:,
+            node:
+          )
+            @comment = comment
+            @node = node
+          end
+
+          # @return [Array<Rucoa::Definitions::Base>]
+          def call
+            raise ::NotImplementedError
+          end
+
+          private
+
+          # @return [YARD::DocstringParser]
+          def docstring_parser
+            @docstring_parser ||= ::YARD::Logger.instance.enter_level(::Logger::FATAL) do
+              ::YARD::Docstring.parser.parse(
+                @comment,
+                ::YARD::CodeObjects::Base.new(:root, 'stub')
+              )
+            end
+          end
+
+          # @return [Array<String>]
+          # @example returns annotated return types if return tag is provided
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       # @return [String]
+          #       def foo
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions[0].return_types).to eq(%w[String])
+          # @example returns Object if no return tag is provided
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       def foo
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions[0].return_types).to eq(%w[Object])
+          def return_types
+            types = docstring_parser.tags.select do |tag|
+              tag.tag_name == 'return'
+            end.flat_map(&:types).compact.map do |yard_type|
+              Type.new(yard_type).to_rucoa_type
+            end
+            if types.empty?
+              %w[Object]
+            else
+              types
+            end
+          end
+        end
+
+        class ClassDefinitionGenerator < Base
+          # @example returns class definition for class node
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       class Foo
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions[0]).to be_a(Rucoa::Definitions::ClassDefinition)
+          def call
+            return [] unless @node.is_a?(Nodes::ClassNode)
+
+            [
+              Definitions::ClassDefinition.new(
+                fully_qualified_name: @node.fully_qualified_name,
+                module_nesting: @node.module_nesting,
+                source_path: @node.location.expression.source_buffer.name,
+                super_class_chained_name: @node.super_class_chained_name
+              )
+            ]
+          end
+        end
+
+        class ModuleDefinitionGenerator < Base
+          # @example returns module definition for module node
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       module Foo
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions[0]).to be_a(Rucoa::Definitions::ModuleDefinition)
+          def call
+            return [] unless @node.is_a?(Nodes::ModuleNode)
+
+            [
+              Definitions::ModuleDefinition.new(
+                fully_qualified_name: @node.fully_qualified_name,
+                source_path: @node.location.expression.source_buffer.name
+              )
+            ]
+          end
+        end
+
+        class MethodDefinitionGenerator < Base
+          # @example returns method definition for def node
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       def foo
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions[0]).to be_a(Rucoa::Definitions::MethodDefinition)
+          # @example returns method definition for defs node
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       def self.foo
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions[0]).to be_a(Rucoa::Definitions::MethodDefinition)
+          def call
+            return [] unless @node.is_a?(Nodes::DefNode) || @node.is_a?(Nodes::DefsNode)
+
+            [
+              Definitions::MethodDefinition.new(
+                description: docstring_parser.to_docstring.to_s,
+                kind: @node.singleton? ? :singleton : :instance,
+                method_name: @node.name,
+                namespace: @node.namespace,
+                source_path: @node.location.expression.source_buffer.name,
+                types: return_types.map do |type|
+                  Types::MethodType.new(
+                    parameters_string: '', # TODO
+                    return_type: type
+                  )
+                end
+              )
+            ]
+          end
+        end
+
+        class AttributeReaderDefinitionGenerator < Base
+          READER_METHOD_NAMES = ::Set[
+            'attr_accessor',
+            'attr_reader'
+          ].freeze
+
+          # @example returns method definition for attr_reader node
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       class Foo
+          #         attr_reader :bar
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions[1]).to be_a(Rucoa::Definitions::MethodDefinition)
+          # @example returns method definition for attr_accessor node
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       class Foo
+          #         attr_accessor :bar
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions.map(&:fully_qualified_name)).to eq(
+          #     %w[
+          #       Foo
+          #       Foo#bar
+          #       Foo#bar=
+          #     ]
+          #   )
+          def call
+            return [] unless @node.is_a?(Nodes::SendNode) && READER_METHOD_NAMES.include?(@node.name)
+
+            @node.arguments.map do |argument|
+              Definitions::MethodDefinition.new(
+                description: docstring_parser.to_docstring.to_s,
+                kind: :instance,
+                method_name: argument.value.to_s,
+                namespace: @node.namespace,
+                source_path: @node.location.expression.source_buffer.name,
+                types: return_types.map do |type|
+                  Types::MethodType.new(
+                    parameters_string: '', # TODO
+                    return_type: type
+                  )
+                end
+              )
+            end
+          end
+        end
+
+        class AttributeWriterDefinitionGenerator < Base
+          WRITER_METHOD_NAMES = ::Set[
+            'attr_accessor',
+            'attr_writer'
+          ].freeze
+
+          # @example returns method definition for attr_writer node
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       class Foo
+          #         attr_writer :bar
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions[1]).to be_a(Rucoa::Definitions::MethodDefinition)
+          # @example returns method definition for attr_accessor node
+          #   definitions = Rucoa::Source.new(
+          #     content: <<~RUBY,
+          #       class Foo
+          #         attr_accessor :bar
+          #       end
+          #     RUBY
+          #     uri: '/path/to/foo.rb'
+          #   ).definitions
+          #   expect(definitions.map(&:fully_qualified_name)).to eq(
+          #     %w[
+          #       Foo
+          #       Foo#bar
+          #       Foo#bar=
+          #     ]
+          #   )
+          def call
+            return [] unless @node.is_a?(Nodes::SendNode) && WRITER_METHOD_NAMES.include?(@node.name)
+
+            @node.arguments.map do |argument|
+              Definitions::MethodDefinition.new(
+                description: docstring_parser.to_docstring.to_s,
+                kind: :instance,
+                method_name: "#{argument.value}=",
+                namespace: @node.namespace,
+                source_path: @node.location.expression.source_buffer.name,
+                types: return_types.map do |type|
+                  Types::MethodType.new(
+                    parameters_string: 'value', # TODO
+                    return_type: type
+                  )
+                end
+              )
+            end
+          end
         end
       end
     end

data/lib/rucoa/yard/type.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Yard
+    class Type
+      # @param value [String]
+      def initialize(value)
+        @value = value
+      end
+
+      # @return [String]
+      # @example scrubs "Array<String>" to "Array"
+      #   yard_type = Rucoa::Yard::Type.new(
+      #     'Array<String>'
+      #   )
+      #   expect(yard_type.to_rucoa_type).to eq('Array')
+      # @example scrubs "Array(String, Integer)" to "Array"
+      #   yard_type = Rucoa::Yard::Type.new(
+      #     'Array(String, Integer)'
+      #   )
+      #   expect(yard_type.to_rucoa_type).to eq('Array')
+      # @example scrubs "::Array" to "Array"
+      #   yard_type = Rucoa::Yard::Type.new(
+      #     '::Array'
+      #   )
+      #   expect(yard_type.to_rucoa_type).to eq('Array')
+      # @example scrubs "Hash{Symbol => Object}" to "Hash"
+      #   yard_type = Rucoa::Yard::Type.new(
+      #     'Hash{Symbol => Object}'
+      #   )
+      #   expect(yard_type.to_rucoa_type).to eq('Hash')
+      # @example scrubs "Array<Array<Integer>>" to "Array"
+      #   yard_type = Rucoa::Yard::Type.new(
+      #     'Array<Array<Integer>>'
+      #   )
+      #   expect(yard_type.to_rucoa_type).to eq('Array')
+      def to_rucoa_type
+        @value
+          .delete_prefix('::')
+          .gsub(/<.+>/, '')
+          .gsub(/\{.+\}/, '')
+          .gsub(/\(.+\)/, '')
+      end
+    end
+  end
+end

data/lib/rucoa/yard.rb

@@ -2,7 +2,7 @@
 
 module Rucoa
   module Yard
-    autoload :DefinitionMapper, 'rucoa/yard/definition_mapper'
     autoload :DefinitionsLoader, 'rucoa/yard/definitions_loader'
+    autoload :Type, 'rucoa/yard/type'
   end
 end

data/lib/rucoa.rb

@@ -18,6 +18,7 @@ module Rucoa
   autoload :Nodes, 'rucoa/nodes'
   autoload :Parser, 'rucoa/parser'
   autoload :ParserBuilder, 'rucoa/parser_builder'
+  autoload :ParseResult, 'rucoa/parse_result'
   autoload :Position, 'rucoa/position'
   autoload :Range, 'rucoa/range'
   autoload :Rbs, 'rucoa/rbs'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rucoa
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-15 00:00:00.000000000 Z
+date: 2022-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -95,9 +95,11 @@ files:
 - lib/rucoa/definition_store.rb
 - lib/rucoa/definitions.rb
 - lib/rucoa/definitions/base.rb
+- lib/rucoa/definitions/class_definition.rb
 - lib/rucoa/definitions/constant_definition.rb
 - lib/rucoa/definitions/method_definition.rb
 - lib/rucoa/definitions/method_parameter_definition.rb
+- lib/rucoa/definitions/module_definition.rb
 - lib/rucoa/errors.rb
 - lib/rucoa/handler_concerns.rb
 - lib/rucoa/handler_concerns/configuration_requestable.rb
@@ -110,6 +112,7 @@ files:
 - lib/rucoa/handlers/shutdown_handler.rb
 - lib/rucoa/handlers/text_document_code_action_handler.rb
 - lib/rucoa/handlers/text_document_completion_handler.rb
+- lib/rucoa/handlers/text_document_definition_handler.rb
 - lib/rucoa/handlers/text_document_did_change_handler.rb
 - lib/rucoa/handlers/text_document_did_close_handler.rb
 - lib/rucoa/handlers/text_document_did_open_handler.rb
@@ -123,11 +126,12 @@ files:
 - lib/rucoa/message_reader.rb
 - lib/rucoa/message_writer.rb
 - lib/rucoa/node_concerns.rb
-- lib/rucoa/node_concerns/name_full_qualifiable.rb
+- lib/rucoa/node_concerns/name_fully_qualifiable.rb
 - lib/rucoa/node_inspector.rb
 - lib/rucoa/nodes.rb
 - lib/rucoa/nodes/base.rb
 - lib/rucoa/nodes/casgn_node.rb
+- lib/rucoa/nodes/cbase_node.rb
 - lib/rucoa/nodes/class_node.rb
 - lib/rucoa/nodes/const_node.rb
 - lib/rucoa/nodes/def_node.rb
@@ -138,13 +142,16 @@ files:
 - lib/rucoa/nodes/send_node.rb
 - lib/rucoa/nodes/str_node.rb
 - lib/rucoa/nodes/sym_node.rb
+- lib/rucoa/parse_result.rb
 - lib/rucoa/parser.rb
 - lib/rucoa/parser_builder.rb
 - lib/rucoa/position.rb
 - lib/rucoa/range.rb
 - lib/rucoa/rbs.rb
+- lib/rucoa/rbs/class_definition_mapper.rb
 - lib/rucoa/rbs/constant_definition_mapper.rb
 - lib/rucoa/rbs/method_definition_mapper.rb
+- lib/rucoa/rbs/module_definition_mapper.rb
 - lib/rucoa/rbs/ruby_definitions_loader.rb
 - lib/rucoa/rubocop.rb
 - lib/rucoa/rubocop/autocorrector.rb
@@ -157,8 +164,8 @@ files:
 - lib/rucoa/types/method_type.rb
 - lib/rucoa/version.rb
 - lib/rucoa/yard.rb
-- lib/rucoa/yard/definition_mapper.rb
 - lib/rucoa/yard/definitions_loader.rb
+- lib/rucoa/yard/type.rb
 - rucoa.gemspec
 homepage: https://github.com/r7kamura/rucoa
 licenses: