rucoa 0.8.0 → 0.9.0

data/lib/rucoa/source.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'uri'
+
 module Rucoa
   class Source
     # @return [String]
@@ -9,8 +11,8 @@ module Rucoa
     attr_reader :uri
 
     # @param content [String]
-    # @param uri [String, nil]
-    def initialize(content:, uri: nil)
+    # @param uri [String]
+    def initialize(content:, uri:)
       @content = content
       @uri = uri
     end
@@ -34,34 +36,36 @@ module Rucoa
     #     ]
     #   )
     def definitions
-      @definitions ||= Yard::DefinitionsLoader.load_string(
-        content: @content,
-        path: path
-      )
+      @definitions ||=
+        if parse_result.failed?
+          []
+        else
+          Yard::DefinitionsLoader.call(
+            associations: parse_result.associations,
+            root_node: parse_result.root_node
+          )
+        end
     end
 
     # @return [String, nil]
-    # @example returns path from given VSCode URI
+    # @example returns path for file URI
     #   source = Rucoa::Source.new(
     #     content: '',
     #     uri: 'file:///path/to/foo.rb'
     #   )
-    #   expect(source.path).to eq('/path/to/foo.rb')
-    # @example returns name for untitled URI
+    #   expect(source.name).to eq('/path/to/foo.rb')
+    # @example returns opaque for untitled URI
     #   source = Rucoa::Source.new(
     #     content: '',
     #     uri: 'untitled:Untitled-1'
     #   )
-    #   expect(source.path).to eq('Untitled-1')
-    def path
-      return unless @uri
-
-      return @uri.split(':', 2).last if untitled?
-
-      path = ::URI.parse(@uri).path
-      return unless path
-
-      ::CGI.unescape(path)
+    #   expect(source.name).to eq('Untitled-1')
+    def name
+      if untitled?
+        uri_object.opaque
+      else
+        uri_object.path
+      end
     end
 
     # @param position [Rucoa::Position]
@@ -70,34 +74,45 @@ module Rucoa
       root_and_descendant_nodes.reverse.find do |node|
         node.include_position?(position)
       end
-    rescue ::Parser::SyntaxError
-      nil
     end
 
     # @return [Rucoa::Nodes::Base, nil]
     def root_node
-      @root_node ||= Parser.call(@content)
-    rescue ::Parser::SyntaxError
-      nil
+      parse_result.root_node
     end
 
     # @return [Boolean]
-    def syntax_error?
-      root_node.nil?
+    def failed_to_parse?
+      parse_result.failed?
     end
 
     # @return [Boolean]
     def untitled?
-      @uri&.start_with?('untitled:')
+      uri_object.scheme == 'untitled'
     end
 
     private
 
+    # @return [Rucoa::ParseResult]
+    def parse_result
+      return @parse_result if instance_variable_defined?(:@parse_result)
+
+      @parse_result = Parser.call(
+        path: name,
+        text: @content
+      )
+    end
+
     # @return [Array<Rucoa::Nodes::Base>]
     def root_and_descendant_nodes
       return [] unless root_node
 
       [root_node, *root_node.descendants]
     end
+
+    # @return [URI]
+    def uri_object
+      @uri_object ||= ::URI.parse(@uri)
+    end
   end
 end

data/lib/rucoa/source_store.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'cgi'
-require 'uri'
-
 module Rucoa
   class SourceStore
     def initialize
@@ -26,15 +23,5 @@ module Rucoa
     def each_uri(&block)
       @data.each_key(&block)
     end
-
-    private
-
-    # @param uri [String]
-    # @return [String]
-    def path_from_uri(uri)
-      ::CGI.unescape(
-        ::URI.parse(uri).path || 'untitled'
-      )
-    end
   end
 end

data/lib/rucoa/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rucoa
-  VERSION = '0.8.0'
+  VERSION = '0.9.0'
 end

data/lib/rucoa/yard/definitions_loader.rb

@@ -1,83 +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(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
+        # @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 globs [String]
-        # @return [Array<Rucoa::Definitions::Base>]
-        def load_globs(globs:)
-          load do
-            ::YARD.parse(globs)
+      # @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
 
-        private
-
-        # @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`.
-            )
-          when ::YARD::CodeObjects::ModuleObject
-            Definitions::ModuleDefinition.new(
-              full_qualified_name: code_object.path,
-              source_path: path || code_object.file
+      # @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:
             )
-          when ::YARD::CodeObjects::MethodObject
-            MethodDefinitionMapper.call(code_object, path: path)
+              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
 
-        # @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)
+        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
 
-        def quietly(&block)
-          ::YARD::Logger.instance.enter_level(::Logger::FATAL, &block)
+        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

@@ -3,6 +3,6 @@
 module Rucoa
   module Yard
     autoload :DefinitionsLoader, 'rucoa/yard/definitions_loader'
-    autoload :MethodDefinitionMapper, 'rucoa/yard/method_definition_mapper'
+    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.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Ryo Nakamura
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-17 00:00:00.000000000 Z
+date: 2022-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -126,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
@@ -141,6 +142,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
@@ -163,7 +165,7 @@ files:
 - lib/rucoa/version.rb
 - lib/rucoa/yard.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: