rucoa 0.8.0 → 0.10.0

data/lib/rucoa/yard/definition_generators/base.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Yard
+    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 [String]
+        def description
+          docstring_parser.to_docstring.to_s
+        end
+
+        # @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 [Rucoa::Location]
+        # @example returns source uri and entire range of target node
+        #   definitions = Rucoa::Source.new(
+        #     content: <<~RUBY,
+        #       class Foo
+        #       end
+        #     RUBY
+        #     uri: '/path/to/foo.rb'
+        #   ).definitions
+        #   expect(definitions[0].location).to eq(
+        #     Rucoa::Location.new(
+        #       range: Rucoa::Range.new(
+        #         Rucoa::Position.new(
+        #           column: 0,
+        #           line: 1
+        #         ),
+        #         Rucoa::Position.new(
+        #           column: 3,
+        #           line: 2
+        #         )
+        #       ),
+        #       uri: '/path/to/foo.rb'
+        #     )
+        #   )
+        def location
+          Location.from_rucoa_node(@node)
+        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
+    end
+  end
+end

data/lib/rucoa/yard/definition_generators/class_definition_generator.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Yard
+    module DefinitionGenerators
+      class ClassDefinitionGenerator < ModuleDefinitionGenerator
+        # @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)
+        # @example detects single-argument include
+        #   definitions = Rucoa::Source.new(
+        #     content: <<~RUBY,
+        #       class Foo
+        #         include Bar
+        #       end
+        #     RUBY
+        #     uri: '/path/to/foo.rb'
+        #   ).definitions
+        #   expect(definitions[0].included_module_unqualified_names.map(&:chained_name)).to eq(%w[Bar])
+        # @example detects multi-arguments include
+        #   definitions = Rucoa::Source.new(
+        #     content: <<~RUBY,
+        #       class Foo
+        #         include Bar, Baz
+        #       end
+        #     RUBY
+        #     uri: '/path/to/foo.rb'
+        #   ).definitions
+        #   expect(definitions[0].included_module_unqualified_names.map(&:chained_name)).to eq(%w[Bar Baz])
+        # @example ignores non-simple include
+        #   definitions = Rucoa::Source.new(
+        #     content: <<~RUBY,
+        #       class Foo
+        #         include foo
+        #       end
+        #     RUBY
+        #     uri: '/path/to/foo.rb'
+        #   ).definitions
+        #   expect(definitions[0].included_module_unqualified_names.map(&:chained_name)).to eq([])
+        def call
+          return [] unless @node.is_a?(Nodes::ClassNode)
+
+          [
+            Definitions::ClassDefinition.new(
+              description: description,
+              included_module_unqualified_names: included_module_unqualified_names,
+              location: location,
+              prepended_module_unqualified_names: prepended_module_unqualified_names,
+              qualified_name: @node.qualified_name,
+              super_class_unqualified_name: UnqualifiedName.new(
+                chained_name: @node.super_class_chained_name,
+                module_nesting: @node.module_nesting
+              )
+            )
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/yard/definition_generators/constant_assignment_definition_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Yard
+    module DefinitionGenerators
+      class ConstantAssignmentDefinitionGenerator < Base
+        # @example returns constant definition for constant assignment node
+        #   definitions = Rucoa::Source.new(
+        #     content: <<~RUBY,
+        #       Foo = 'foo'
+        #     RUBY
+        #     uri: '/path/to/foo.rb'
+        #   ).definitions
+        #   expect(definitions[0]).to be_a(Rucoa::Definitions::ConstantDefinition)
+        def call
+          return [] unless @node.is_a?(Nodes::CasgnNode)
+
+          [
+            Definitions::ConstantDefinition.new(
+              description: description,
+              location: location,
+              qualified_name: @node.qualified_name
+            )
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/yard/definition_generators/method_definition_generator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Yard
+    module DefinitionGenerators
+      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: description,
+              kind: @node.singleton? ? :singleton : :instance,
+              location: location,
+              method_name: @node.name,
+              namespace: @node.namespace,
+              types: return_types.map do |type|
+                Types::MethodType.new(
+                  parameters_string: '', # TODO
+                  return_type: type
+                )
+              end
+            )
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/yard/definition_generators/module_definition_generator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Yard
+    module DefinitionGenerators
+      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(
+              description: description,
+              included_module_unqualified_names: included_module_unqualified_names,
+              location: location,
+              prepended_module_unqualified_names: prepended_module_unqualified_names,
+              qualified_name: @node.qualified_name
+            )
+          ]
+        end
+
+        private
+
+        # @return [Array<Rucoa::UnqualifiedName>]
+        def included_module_unqualified_names
+          unqualified_names_for('include')
+        end
+
+        # @return [Array<Rucoa::UnqualifiedName>]
+        def prepended_module_unqualified_names
+          unqualified_names_for('prepend')
+        end
+
+        # @param method_name [String]
+        # @return [Array<Rucoa::UnqualifiedName>]
+        def unqualified_names_for(method_name)
+          @node.body_children.flat_map do |child|
+            next [] unless child.is_a?(Nodes::SendNode)
+            next [] unless child.name == method_name
+
+            child.arguments.filter_map do |argument|
+              next unless argument.is_a?(Nodes::ConstNode)
+
+              UnqualifiedName.new(
+                chained_name: argument.chained_name,
+                module_nesting: @node.module_nesting
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rucoa/yard/definition_generators.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Yard
+    module DefinitionGenerators
+      autoload :AttributeReaderDefinitionGenerator, 'rucoa/yard/definition_generators/attribute_reader_definition_generator'
+      autoload :AttributeWriterDefinitionGenerator, 'rucoa/yard/definition_generators/attribute_writer_definition_generator'
+      autoload :Base, 'rucoa/yard/definition_generators/base'
+      autoload :ClassDefinitionGenerator, 'rucoa/yard/definition_generators/class_definition_generator'
+      autoload :ConstantAssignmentDefinitionGenerator, 'rucoa/yard/definition_generators/constant_assignment_definition_generator'
+      autoload :MethodDefinitionGenerator, 'rucoa/yard/definition_generators/method_definition_generator'
+      autoload :ModuleDefinitionGenerator, 'rucoa/yard/definition_generators/module_definition_generator'
+    end
+  end
+end

data/lib/rucoa/yard/definitions_loader.rb

@@ -1,84 +1,63 @@
 # 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(2)
-        #   expect(definitions[1].full_qualified_name).to eq('Foo#foo')
-        #   expect(definitions[1].source_path).to eq('/path/to/foo.rb')
-        #   expect(definitions[1].description).to eq('Return given argument as an Integer.')
-        #   expect(definitions[1].return_types).to eq(%w[Integer])
-        def load_string(content:, path:)
-          load(path: path) do
-            ::YARD.parse_string(content)
-          end
-        end
-
-        # @param globs [String]
-        # @return [Array<Rucoa::Definitions::Base>]
-        def load_globs(globs:)
-          load do
-            ::YARD.parse(globs)
-          end
+        # @param associations [Hash]
+        # @param root_node [Rucoa::Nodes::Base]
+        def call(
+          associations:,
+          root_node:
+        )
+          new(
+            associations: associations,
+            root_node: root_node
+          ).call
         end
+      end
 
-        private
+      # @param associations [Hash]
+      # @param root_node [Rucoa::Nodes::Base]
+      def initialize(
+        associations:,
+        root_node:
+      )
+        @associations = associations
+        @root_node = root_node
+      end
 
-        # @param code_object [YARD::CodeObjects::Base]
-        # @param path [String, nil]
-        # @return [Rucoa::Definitions::Base, nil]
-        def map(code_object, path:)
-          case code_object
-          when ::YARD::CodeObjects::ClassObject
-            Definitions::ClassDefinition.new(
-              full_qualified_name: code_object.path,
-              source_path: path || code_object.file,
-              super_class_name: code_object.superclass.to_s # TODO: superclass may not include full namespace on `YARD.parse_string`.
+      # @return [Array<Rucoa::Definition::Base>]
+      def call
+        [
+          @root_node,
+          *@root_node.descendants
+        ].flat_map do |node|
+          [
+            DefinitionGenerators::ClassDefinitionGenerator,
+            DefinitionGenerators::ConstantAssignmentDefinitionGenerator,
+            DefinitionGenerators::MethodDefinitionGenerator,
+            DefinitionGenerators::ModuleDefinitionGenerator,
+            DefinitionGenerators::AttributeReaderDefinitionGenerator,
+            DefinitionGenerators::AttributeWriterDefinitionGenerator
+          ].flat_map do |generator|
+            generator.call(
+              comment: comment_for(node),
+              node: node
             )
-          when ::YARD::CodeObjects::ModuleObject
-            Definitions::ModuleDefinition.new(
-              full_qualified_name: code_object.path,
-              source_path: path || code_object.file
-            )
-          when ::YARD::CodeObjects::MethodObject
-            MethodDefinitionMapper.call(code_object, path: path)
-          end
-        end
-
-        # @param path [String, nil]
-        # @return [Array<Rucoa::Definitions::Base>]
-        def load(path: nil, &block)
-          ::YARD::Registry.clear
-          quietly(&block)
-          ::YARD::Registry.all.filter_map do |code_object|
-            map(code_object, path: path)
           end
         end
+      end
 
-        def quietly(&block)
-          ::YARD::Logger.instance.enter_level(::Logger::FATAL, &block)
-        end
+      # @return [String]
+      def comment_for(node)
+        @associations[node.location].map do |parser_comment|
+          parser_comment.text.gsub(/^#\s*/m, '')
+        end.join("\n")
       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,8 @@
 
 module Rucoa
   module Yard
+    autoload :DefinitionGenerators, 'rucoa/yard/definition_generators'
     autoload :DefinitionsLoader, 'rucoa/yard/definitions_loader'
-    autoload :MethodDefinitionMapper, 'rucoa/yard/method_definition_mapper'
+    autoload :Type, 'rucoa/yard/type'
   end
 end

data/lib/rucoa.rb

@@ -6,16 +6,18 @@ module Rucoa
   autoload :Cli, 'rucoa/cli'
   autoload :Configuration, 'rucoa/configuration'
   autoload :DefinitionArchiver, 'rucoa/definition_archiver'
-  autoload :Definitions, 'rucoa/definitions'
   autoload :DefinitionStore, 'rucoa/definition_store'
+  autoload :Definitions, 'rucoa/definitions'
   autoload :Errors, 'rucoa/errors'
   autoload :HandlerConcerns, 'rucoa/handler_concerns'
   autoload :Handlers, 'rucoa/handlers'
+  autoload :Location, 'rucoa/location'
   autoload :MessageReader, 'rucoa/message_reader'
   autoload :MessageWriter, 'rucoa/message_writer'
   autoload :NodeConcerns, 'rucoa/node_concerns'
   autoload :NodeInspector, 'rucoa/node_inspector'
   autoload :Nodes, 'rucoa/nodes'
+  autoload :ParseResult, 'rucoa/parse_result'
   autoload :Parser, 'rucoa/parser'
   autoload :ParserBuilder, 'rucoa/parser_builder'
   autoload :Position, 'rucoa/position'
@@ -26,5 +28,6 @@ module Rucoa
   autoload :Source, 'rucoa/source'
   autoload :SourceStore, 'rucoa/source_store'
   autoload :Types, 'rucoa/types'
+  autoload :UnqualifiedName, 'rucoa/unqualified_name'
   autoload :Yard, 'rucoa/yard'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rucoa
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-17 00:00:00.000000000 Z
+date: 2022-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -123,14 +123,18 @@ files:
 - lib/rucoa/handlers/text_document_selection_range_handler.rb
 - lib/rucoa/handlers/text_document_signature_help_handler.rb
 - lib/rucoa/handlers/workspace_did_change_configuration_handler.rb
+- lib/rucoa/location.rb
 - 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/body.rb
+- lib/rucoa/node_concerns/qualified_name.rb
 - lib/rucoa/node_inspector.rb
 - lib/rucoa/nodes.rb
 - lib/rucoa/nodes/base.rb
+- lib/rucoa/nodes/begin_node.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
@@ -141,6 +145,7 @@ 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
@@ -160,10 +165,19 @@ files:
 - lib/rucoa/source_store.rb
 - lib/rucoa/types.rb
 - lib/rucoa/types/method_type.rb
+- lib/rucoa/unqualified_name.rb
 - lib/rucoa/version.rb
 - lib/rucoa/yard.rb
+- lib/rucoa/yard/definition_generators.rb
+- lib/rucoa/yard/definition_generators/attribute_reader_definition_generator.rb
+- lib/rucoa/yard/definition_generators/attribute_writer_definition_generator.rb
+- lib/rucoa/yard/definition_generators/base.rb
+- lib/rucoa/yard/definition_generators/class_definition_generator.rb
+- lib/rucoa/yard/definition_generators/constant_assignment_definition_generator.rb
+- lib/rucoa/yard/definition_generators/method_definition_generator.rb
+- lib/rucoa/yard/definition_generators/module_definition_generator.rb
 - lib/rucoa/yard/definitions_loader.rb
-- lib/rucoa/yard/method_definition_mapper.rb
+- lib/rucoa/yard/type.rb
 - rucoa.gemspec
 homepage: https://github.com/r7kamura/rucoa
 licenses: