rucoa 0.8.0 → 0.10.0

data/lib/rucoa/node_inspector.rb

@@ -4,7 +4,10 @@ module Rucoa
   class NodeInspector
     # @param definition_store [Rucoa::DefinitionStore]
     # @param node [Rucoa::Node]
-    def initialize(definition_store:, node:)
+    def initialize(
+      definition_store:,
+      node:
+    )
       @definition_store = definition_store
       @node = node
     end
@@ -90,22 +93,14 @@ module Rucoa
     def constant_definition
       return unless @node.is_a?(Nodes::ConstNode)
 
-      module_nesting_full_qualified_names = @node.each_ancestor(:class, :module).map(&:full_qualified_name)
-      candidate_full_qualified_names = module_nesting_full_qualified_names.flat_map do |module_nesting_full_qualified_name|
-        [
-          module_nesting_full_qualified_name
-          # TODO: *ancestors_of(module_nesting_full_qualified_name)
-        ].map do |full_qualified_name|
-          [
-            full_qualified_name,
-            @node.chained_name
-          ].join('::')
-        end
-      end + [@node.chained_name]
-      candidate_full_qualified_names.find do |candidate_full_qualified_name|
-        definition = @definition_store.select_by_full_qualified_name(candidate_full_qualified_name).first
-        break definition if definition
-      end
+      @definition_store.find_definition_by_qualified_name(
+        @definition_store.resolve_constant(
+          UnqualifiedName.new(
+            chained_name: @node.chained_name,
+            module_nesting: @node.module_nesting
+          )
+        )
+      )
     end
 
     # @return [Boolean]
@@ -114,20 +109,21 @@ module Rucoa
     end
 
     # @return [String, nil]
-    def nearest_def_full_qualified_name
-      @node.each_ancestor(:def).first&.full_qualified_name
+    def nearest_def_qualified_name
+      @node.each_ancestor(:def).first&.qualified_name
     end
 
     # @return [Array<String>]
     def return_types_for_lvar
-      full_qualified_name = nearest_def_full_qualified_name
-      return [] unless full_qualified_name
+      qualified_name = nearest_def_qualified_name
+      return [] unless qualified_name
 
-      @definition_store.select_by_full_qualified_name(full_qualified_name).flat_map do |definition|
-        definition.parameters.select do |parameter|
-          parameter.name == @node.name
-        end.flat_map(&:types)
-      end
+      definition = @definition_store.find_definition_by_qualified_name(qualified_name)
+      return [] unless definition
+
+      definition.parameters.select do |parameter|
+        parameter.name == @node.name
+      end.flat_map(&:types)
     end
 
     # @return [Array<String>]

data/lib/rucoa/nodes/base.rb

@@ -37,7 +37,10 @@ module Rucoa
       # @param types [Array<Symbol>]
       # @return [Rucoa::Nodes::Base] if a block is given
       # @return [Enumerator] if no block is given
-      def each_ancestor(*types, &block)
+      def each_ancestor(
+        *types,
+        &block
+      )
         return to_enum(__method__, *types) unless block
 
         visit_ancestors(types, &block)
@@ -47,7 +50,10 @@ module Rucoa
       # @param types [Array<Symbol>]
       # @return [Rucoa::Nodes::Base] if a block is given
       # @return [Enumerator] if no block is given
-      def each_child_node(*types, &block)
+      def each_child_node(
+        *types,
+        &block
+      )
         return to_enum(__method__, *types) unless block
 
         visit_child_node(types, &block)
@@ -57,7 +63,10 @@ module Rucoa
       # @param types [Array<Symbol>]
       # @return [Rucoa::Nodes::Base] if a block is given
       # @return [Enumerator] if no block is given
-      def each_descendant(*types, &block)
+      def each_descendant(
+        *types,
+        &block
+      )
         return to_enum(__method__, *types) unless block
 
         visit_descendants(types, &block)
@@ -68,7 +77,11 @@ module Rucoa
       #   Some nodes change their type depending on the context.
       #   For example, `const` node can be `casgn` node.
       # @return [Rucoa::Nodes::Base]
-      def updated(type = nil, children = nil, properties = {})
+      def updated(
+        type = nil,
+        children = nil,
+        properties = {}
+      )
         properties[:location] ||= @location
         ParserBuilder.node_class_for(type || @type).new(
           type || @type,
@@ -89,7 +102,7 @@ module Rucoa
       # @return [String]
       # @example returns namespace
       #   node = Rucoa::Source.new(
-      #     content: <<~RUBY
+      #     content: <<~RUBY,
       #       module Foo
       #         class Bar
       #           def baz
@@ -97,6 +110,7 @@ module Rucoa
       #         end
       #       end
       #     RUBY
+      #     uri: 'file:///path/to/foo/bar.rb'
       #   ).node_at(
       #     Rucoa::Position.new(
       #       column: 4,
@@ -105,14 +119,38 @@ module Rucoa
       #   )
       #   expect(node.namespace).to eq('Foo::Bar')
       # @example returns "Object" when the node is not in a namespace
-      #   node = Rucoa::Parser.call(
-      #     <<~RUBY
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
       #       foo
       #     RUBY
-      #   )
+      #     uri: 'file:///path/to/example.rb'
+      #   ).root_node
       #   expect(node.namespace).to eq('Object')
       def namespace
-        each_ancestor(:module, :class).first&.full_qualified_name || 'Object'
+        module_nesting.first || 'Object'
+      end
+
+      # @return [Array<String>]
+      # @example return ["Bar::Foo", "Foo"] for class Foo::Bar::Baz
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           module Baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar/baz.rb'
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 3
+      #     )
+      #   )
+      #   expect(node.module_nesting).to eq(['Foo::Bar', 'Foo'])
+      def module_nesting
+        each_ancestor(:class, :module).map(&:qualified_name)
       end
 
       protected
@@ -120,7 +158,10 @@ module Rucoa
       # Visit all descendants.
       # @param types [Array<Symbol>]
       # @return [void]
-      def visit_descendants(types, &block)
+      def visit_descendants(
+        types,
+        &block
+      )
         each_child_node do |child|
           yield(child) if types.empty? || types.include?(child.type)
           child.visit_descendants(types, &block)

data/lib/rucoa/nodes/begin_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class BeginNode < Base
+    end
+  end
+end

data/lib/rucoa/nodes/casgn_node.rb

@@ -3,7 +3,7 @@
 module Rucoa
   module Nodes
     class CasgnNode < Base
-      include NodeConcerns::NameFullQualifiable
+      include NodeConcerns::QualifiedName
 
       # @return [String]
       def name

data/lib/rucoa/nodes/cbase_node.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class CbaseNode < Base
+    end
+  end
+end

data/lib/rucoa/nodes/class_node.rb

@@ -2,7 +2,69 @@
 
 module Rucoa
   module Nodes
-    class ClassNode < ModuleNode
+    class ClassNode < Base
+      include NodeConcerns::Body
+      include NodeConcerns::QualifiedName
+
+      # @return [String]
+      def name
+        const_node.name
+      end
+
+      # @return [String, nil]
+      # @example returns nil for class for `class Foo`
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       class Foo
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo.rb'
+      #   ).root_node
+      #   expect(node.super_class_chained_name).to be_nil
+      # @example returns "Bar" for class for `class Foo < Bar`
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       class Foo < Bar
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo.rb'
+      #   ).root_node
+      #   expect(node.super_class_chained_name).to eq('Bar')
+      # @example returns "Bar::Baz" for class for `class Foo < Bar::Baz`
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       class Foo < Bar::Baz
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo.rb'
+      #   ).root_node
+      #   expect(node.super_class_chained_name).to eq('Bar::Baz')
+      # @example returns "::Bar" for class for `class Foo < ::Bar`
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       class Foo < ::Bar
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo.rb'
+      #   ).root_node
+      #   expect(node.super_class_chained_name).to eq('::Bar')
+      def super_class_chained_name
+        return unless super_class_node.is_a?(Nodes::ConstNode)
+
+        super_class_node.chained_name
+      end
+
+      private
+
+      # @return [Rucoa::Nodes::ConstNode]
+      def const_node
+        children[0]
+      end
+
+      # @return [Rucoa::Nodes::Base, nil]
+      def super_class_node
+        children[1]
+      end
     end
   end
 end

data/lib/rucoa/nodes/const_node.rb

@@ -5,10 +5,25 @@ module Rucoa
     class ConstNode < Base
       # @return [String]
       # @example returns "A" for "A"
-      #   node = Rucoa::Parser.call('A')
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       A
+      #     RUBY
+      #     uri: 'file:///path/to/a.rb'
+      #   ).root_node
       #   expect(node.name).to eq('A')
       # @example returns "B" for "A::B"
-      #   node = Rucoa::Parser.call('A::B')
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       A::B
+      #     RUBY
+      #     uri: 'file:///path/to/a.rb'
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 1
+      #     )
+      #   )
       #   expect(node.name).to eq('B')
       def name
         children[1].to_s
@@ -16,13 +31,34 @@ module Rucoa
 
       # @return [String]
       # @example returns "A" for "A"
-      #   node = Rucoa::Parser.call('A')
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       A
+      #     RUBY
+      #     uri: 'file:///path/to/a.rb'
+      #   ).root_node
       #   expect(node.chained_name).to eq('A')
       # @example returns "A::B" for "A::B"
-      #   node = Rucoa::Parser.call('A::B')
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       A::B
+      #     RUBY
+      #     uri: 'file:///path/to/a.rb'
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 1
+      #     )
+      #   )
       #   expect(node.chained_name).to eq('A::B')
       def chained_name
-        if receiver.is_a?(ConstNode)
+        case receiver
+        when Nodes::CbaseNode
+          [
+            '',
+            name
+          ].join('::')
+        when Nodes::ConstNode
           [
             receiver.chained_name,
             name
@@ -32,6 +68,29 @@ module Rucoa
         end
       end
 
+      # @return [Array<String>]
+      # @example return ["Bar::Foo", "Foo"] for class Foo::Bar::Baz
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
+      #       module Foo
+      #         module Bar
+      #           module Baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #     uri: 'file:///path/to/foo/bar/baz.rb'
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 3
+      #     )
+      #   )
+      #   expect(node.module_nesting).to eq(['Foo::Bar', 'Foo'])
+      def module_nesting
+        each_ancestor(:class, :module).map(&:qualified_name)
+      end
+
       private
 
       # @return [Rucoa::Nodes::Base, nil]

data/lib/rucoa/nodes/def_node.rb

@@ -6,7 +6,7 @@ module Rucoa
       # @return [String]
       # @example returns method name
       #   node = Rucoa::Source.new(
-      #     content: <<~RUBY
+      #     content: <<~RUBY,
       #       module Foo
       #         class Bar
       #           def baz
@@ -14,6 +14,7 @@ module Rucoa
       #         end
       #       end
       #     RUBY
+      #     uri: 'file:///path/to/foo/bar.rb'
       #   ).node_at(
       #     Rucoa::Position.new(
       #       column: 4,
@@ -28,7 +29,7 @@ module Rucoa
       # @return [String]
       # @example returns full qualified name
       #   node = Rucoa::Source.new(
-      #     content: <<~RUBY
+      #     content: <<~RUBY,
       #       module Foo
       #         class Bar
       #           def baz
@@ -36,14 +37,15 @@ module Rucoa
       #         end
       #       end
       #     RUBY
+      #     uri: 'file:///path/to/foo/bar.rb'
       #   ).node_at(
       #     Rucoa::Position.new(
       #       column: 4,
       #       line: 3
       #     )
       #   )
-      #   expect(node.full_qualified_name).to eq('Foo::Bar#baz')
-      def full_qualified_name
+      #   expect(node.qualified_name).to eq('Foo::Bar#baz')
+      def qualified_name
         [
           namespace,
           method_marker,
@@ -51,6 +53,11 @@ module Rucoa
         ].join
       end
 
+      # @return [Boolean]
+      def singleton?
+        each_ancestor(:sclass).any?
+      end
+
       private
 
       # @return [String]
@@ -61,11 +68,6 @@ module Rucoa
           '#'
         end
       end
-
-      # @return [Boolean]
-      def singleton?
-        each_ancestor(:sclass).any?
-      end
     end
   end
 end

data/lib/rucoa/nodes/defs_node.rb

@@ -3,10 +3,31 @@
 module Rucoa
   module Nodes
     class DefsNode < Base
+      # @return [String]
+      def qualified_name
+        [
+          namespace,
+          method_marker,
+          name
+        ].join
+      end
+
       # @return [String]
       def name
         children[1].to_s
       end
+
+      # @return [Boolean]
+      def singleton?
+        true
+      end
+
+      private
+
+      # @return [String]
+      def method_marker
+        '.'
+      end
     end
   end
 end

data/lib/rucoa/nodes/lvar_node.rb

@@ -6,10 +6,11 @@ module Rucoa
       # @return [String]
       # @example returns local variable name
       #   node = Rucoa::Source.new(
-      #     content: <<~RUBY
+      #     content: <<~RUBY,
       #       foo = 1
       #       foo
       #     RUBY
+      #     uri: 'file:///path/to/example.rb'
       #   ).node_at(
       #     Rucoa::Position.new(
       #       column: 2,

data/lib/rucoa/nodes/module_node.rb

@@ -3,7 +3,8 @@
 module Rucoa
   module Nodes
     class ModuleNode < Base
-      include NodeConcerns::NameFullQualifiable
+      include NodeConcerns::Body
+      include NodeConcerns::QualifiedName
 
       # @return [String]
       def name

data/lib/rucoa/nodes/send_node.rb

@@ -5,11 +5,12 @@ module Rucoa
     class SendNode < Base
       # @return [Array<Rucoa::Nodes::Base>]
       # @example returns arguments
-      #   node = Rucoa::Parser.call(
-      #     <<~RUBY
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
       #       foo(bar, baz)
       #     RUBY
-      #   )
+      #     uri: 'file:///path/to/example.rb'
+      #   ).root_node
       #   expect(node.arguments.map(&:name)).to eq(
       #     %w[
       #       bar
@@ -22,11 +23,12 @@ module Rucoa
 
       # @return [String]
       # @example returns method name
-      #   node = Rucoa::Parser.call(
-      #     <<~RUBY
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
       #       foo(bar, baz)
       #     RUBY
-      #   )
+      #     uri: 'file:///path/to/example.rb'
+      #   ).root_node
       #   expect(node.name).to eq('foo')
       def name
         children[1].to_s
@@ -34,17 +36,19 @@ module Rucoa
 
       # @return [Rucoa::Nodes::Base, nil]
       # @example returns nil for receiver-less method call
-      #   node = Rucoa::Parser.call(
-      #     <<~RUBY
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY,
       #       foo(bar, baz)
       #     RUBY
-      #   )
+      #     uri: 'file:///path/to/example.rb'
+      #   ).root_node
       #   expect(node.receiver).to be_nil
       # @example returns receiver
       #   node = Rucoa::Source.new(
-      #     content: <<~RUBY
+      #     content: <<~RUBY,
       #       foo.bar
       #     RUBY
+      #     uri: 'file:///path/to/example.rb'
       #   ).node_at(
       #     Rucoa::Position.new(
       #       column: 4,

data/lib/rucoa/nodes.rb

@@ -3,8 +3,10 @@
 module Rucoa
   module Nodes
     autoload :Base, 'rucoa/nodes/base'
-    autoload :ClassNode, 'rucoa/nodes/class_node'
+    autoload :BeginNode, 'rucoa/nodes/begin_node'
     autoload :CasgnNode, 'rucoa/nodes/casgn_node'
+    autoload :CbaseNode, 'rucoa/nodes/cbase_node'
+    autoload :ClassNode, 'rucoa/nodes/class_node'
     autoload :ConstNode, 'rucoa/nodes/const_node'
     autoload :DefNode, 'rucoa/nodes/def_node'
     autoload :DefsNode, 'rucoa/nodes/defs_node'

data/lib/rucoa/parse_result.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rucoa
+  class ParseResult
+    # @return [Array<Parser::Source::Comment>, nil]
+    attr_reader :associations
+
+    # @return [Rucoa::Nodes::Base, nil]
+    attr_reader :root_node
+
+    # @param associations [Array<Parser::Source::Comment>, nil]
+    # @param failed [Boolean]
+    # @param root_node [Rucoa::Nodes::Base, nil]
+    def initialize(
+      associations: nil,
+      failed: false,
+      root_node: nil
+    )
+      @associations = associations
+      @failed = failed
+      @root_node = root_node
+    end
+
+    # @return [Boolean]
+    def failed?
+      @failed
+    end
+  end
+end

data/lib/rucoa/parser.rb

@@ -3,29 +3,61 @@
 require 'parser/current'
 
 module Rucoa
-  # Parses Ruby text code.
   class Parser
     class << self
       # @param text [String]
-      # @return [Rucoa::Nodes::Base]
-      def call(text)
-        new(text).call
+      # @param uri [String]
+      # @return [Rucoa::ParseResult]
+      # @example returns non-failed parse result for valid Ruby source
+      #   result = Rucoa::Parser.call(
+      #     text: 'foo',
+      #     uri: 'file:///path/to/foo.rb'
+      #   )
+      #   expect(result).not_to be_failed
+      # @example returns failed parse result for invalid Ruby source
+      #   result = Rucoa::Parser.call(
+      #     text: 'foo(',
+      #     uri: 'file:///path/to/foo.rb'
+      #   )
+      #   expect(result).to be_failed
+      def call(
+        text:,
+        uri:
+      )
+        new(
+          text: text,
+          uri: uri
+        ).call
       end
     end
 
     # @param text [String]
-    def initialize(text)
+    # @param uri [String]
+    def initialize(
+      text:,
+      uri:
+    )
       @text = text
+      @uri = uri
     end
 
-    # @return [Rucoa::Nodes::Base]
+    # @return [Rucoa::ParseResult]
     def call
-      parser.parse(
+      root_node, comments = parser.parse_with_comments(
         ::Parser::Source::Buffer.new(
-          '',
+          @uri,
           source: @text
         )
       )
+      ParseResult.new(
+        associations: ::Parser::Source::Comment.associate_locations(
+          root_node,
+          comments
+        ),
+        root_node: root_node
+      )
+    rescue ::Parser::SyntaxError
+      ParseResult.new(failed: true)
     end
 
     private