rucoa 0.3.0 → 0.5.1

data/lib/rucoa/node_inspector.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Rucoa
+  class NodeInspector
+    # @param definition_store [Rucoa::DefinitionStore]
+    # @param node [Rucoa::Node]
+    def initialize(definition_store:, node:)
+      @definition_store = definition_store
+      @node = node
+    end
+
+    # @return [Array<String>]
+    def method_definitions
+      method_full_qualified_names.flat_map do |full_qualified_name|
+        @definition_store.select_by_full_qualified_name(full_qualified_name)
+      end
+    end
+
+    # @return [Array<String>]
+    def method_receiver_types
+      return [] unless @node.is_a?(Nodes::SendNode)
+
+      if @node.receiver
+        self.class.new(
+          definition_store: @definition_store,
+          node: @node.receiver
+        ).return_types
+      else
+        [@node.namespace]
+      end
+    end
+
+    # @return [Array<String>]
+    def return_types
+      case @node.type
+      when :const
+        [@node.name]
+      when :lvar
+        return_types_for_lvar
+      when :send
+        return_types_for_send
+      when :array
+        %w[Array]
+      when :class, :module, :nil
+        %w[NilClass]
+      when :complex
+        %w[Complex]
+      when :def, :sym
+        %w[Symbol]
+      when :dstr, :str, :xstr
+        %w[String]
+      when :erange, :irange
+        %w[Range]
+      when false
+        %w[FalseClass]
+      when :float
+        %w[Float]
+      when :hash, :pair
+        %w[Hash]
+      when :int
+        %w[Integer]
+      when :rational
+        %w[Rational]
+      when :regexp, :regopt
+        %w[Regexp]
+      when true
+        %w[TrueClass]
+      else
+        []
+      end
+    end
+
+    private
+
+    # @return [Array<String>]
+    def method_full_qualified_names
+      method_receiver_types.map do |type|
+        [
+          type,
+          @node.name
+        ].join('#')
+      end
+    end
+
+    # @return [String, nil]
+    def nearest_def_full_qualified_name
+      @node.each_ancestor(:def).first&.full_qualified_name
+    end
+
+    # @return [Array<String>]
+    def return_types_for_lvar
+      full_qualified_name = nearest_def_full_qualified_name
+      return [] unless full_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
+    end
+
+    # @return [Array<String>]
+    def return_types_for_send
+      method_full_qualified_names.flat_map do |full_qualified_name|
+        @definition_store.select_by_full_qualified_name(full_qualified_name).flat_map(&:return_types)
+      end.uniq
+    end
+  end
+end

data/lib/rucoa/nodes/base.rb

@@ -64,6 +64,19 @@ module Rucoa
         self
       end
 
+      # @note Override.
+      #   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 = {})
+        properties[:location] ||= @location
+        ParserBuilder.node_class_for(type || @type).new(
+          type || @type,
+          children || @children,
+          properties
+        )
+      end
+
       # @param position [Rucoa::Position]
       # @return [Boolean]
       def include_position?(position)
@@ -72,6 +85,36 @@ module Rucoa
         Range.from_parser_range(location.expression).include?(position)
       end
 
+      # @note namespace is a String representation of `Module.nesting`.
+      # @return [String]
+      # @example returns namespace
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY
+      #       module Foo
+      #         class Bar
+      #           def baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 3
+      #     )
+      #   )
+      #   expect(node.namespace).to eq('Foo::Bar')
+      # @example returns "Object" when the node is not in a namespace
+      #   node = Rucoa::Parser.call(
+      #     <<~RUBY
+      #       foo
+      #     RUBY
+      #   )
+      #   expect(node.namespace).to eq('Object')
+      def namespace
+        each_ancestor(:module, :class).first&.full_qualified_name || 'Object'
+      end
+
       protected
 
       # Visit all descendants.

data/lib/rucoa/nodes/casgn_node.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class CasgnNode < Base
+      include NodeConcerns::NameFullQualifiable
+
+      # @return [String]
+      def name
+        children[1].to_s
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/class_node.rb

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

data/lib/rucoa/nodes/const_node.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class ConstNode < Base
+      # @return [String]
+      def name
+        children[1].to_s
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/def_node.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class DefNode < Base
+      # @return [String]
+      # @example returns method name
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY
+      #       module Foo
+      #         class Bar
+      #           def baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 3
+      #     )
+      #   )
+      #   expect(node.name).to eq('baz')
+      def name
+        children[0].to_s
+      end
+
+      # @return [String]
+      # @example returns full qualified name
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY
+      #       module Foo
+      #         class Bar
+      #           def baz
+      #           end
+      #         end
+      #       end
+      #     RUBY
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 3
+      #     )
+      #   )
+      #   expect(node.full_qualified_name).to eq('Foo::Bar#baz')
+      def full_qualified_name
+        [
+          namespace,
+          method_marker,
+          name
+        ].join
+      end
+
+      private
+
+      # @return [String]
+      def method_marker
+        if singleton?
+          '.'
+        else
+          '#'
+        end
+      end
+
+      # @return [Boolean]
+      def singleton?
+        each_ancestor(:sclass).any?
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/defs_node.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class DefsNode < Base
+      # @return [String]
+      def name
+        children[1].to_s
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/lvar_node.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class LvarNode < Base
+      # @return [String]
+      # @example returns local variable name
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY
+      #       foo = 1
+      #       foo
+      #     RUBY
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 2,
+      #       line: 2
+      #     )
+      #   )
+      #   expect(node.name).to eq('foo')
+      def name
+        children[0].to_s
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/module_node.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class ModuleNode < Base
+      include NodeConcerns::NameFullQualifiable
+
+      # @return [String]
+      def name
+        const_node.name
+      end
+
+      private
+
+      # @return [Rucoa::Nodes::ConstNode]
+      def const_node
+        children[0]
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/sclass_node.rb

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

data/lib/rucoa/nodes/send_node.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class SendNode < Base
+      # @return [Array<Rucoa::Nodes::Base>]
+      # @example returns arguments
+      #   node = Rucoa::Parser.call(
+      #     <<~RUBY
+      #       foo(bar, baz)
+      #     RUBY
+      #   )
+      #   expect(node.arguments.map(&:name)).to eq(
+      #     %w[
+      #       bar
+      #       baz
+      #     ]
+      #   )
+      def arguments
+        children[2..]
+      end
+
+      # @return [String]
+      # @example returns method name
+      #   node = Rucoa::Parser.call(
+      #     <<~RUBY
+      #       foo(bar, baz)
+      #     RUBY
+      #   )
+      #   expect(node.name).to eq('foo')
+      def name
+        children[1].to_s
+      end
+
+      # @return [Rucoa::Nodes::Base, nil]
+      # @example returns nil for receiver-less method call
+      #   node = Rucoa::Parser.call(
+      #     <<~RUBY
+      #       foo(bar, baz)
+      #     RUBY
+      #   )
+      #   expect(node.receiver).to be_nil
+      # @example returns receiver
+      #   node = Rucoa::Source.new(
+      #     content: <<~RUBY
+      #       foo.bar
+      #     RUBY
+      #   ).node_at(
+      #     Rucoa::Position.new(
+      #       column: 4,
+      #       line: 1
+      #     )
+      #   )
+      #   expect(node.receiver).to be_a(Rucoa::Nodes::SendNode)
+      def receiver
+        children[0]
+      end
+    end
+  end
+end

data/lib/rucoa/nodes/str_node.rb

@@ -3,6 +3,10 @@
 module Rucoa
   module Nodes
     class StrNode < Base
+      # @return [String]
+      def value
+        children[0]
+      end
     end
   end
 end

data/lib/rucoa/nodes/sym_node.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class SymNode < Base
+      # @return [String]
+      def value
+        children[0]
+      end
+    end
+  end
+end

data/lib/rucoa/nodes.rb

@@ -3,6 +3,16 @@
 module Rucoa
   module Nodes
     autoload :Base, 'rucoa/nodes/base'
+    autoload :ClassNode, 'rucoa/nodes/class_node'
+    autoload :CasgnNode, 'rucoa/nodes/casgn_node'
+    autoload :ConstNode, 'rucoa/nodes/const_node'
+    autoload :DefNode, 'rucoa/nodes/def_node'
+    autoload :DefsNode, 'rucoa/nodes/defs_node'
+    autoload :LvarNode, 'rucoa/nodes/lvar_node'
+    autoload :ModuleNode, 'rucoa/nodes/module_node'
+    autoload :SclassNode, 'rucoa/nodes/sclass_node'
+    autoload :SendNode, 'rucoa/nodes/send_node'
     autoload :StrNode, 'rucoa/nodes/str_node'
+    autoload :SymNode, 'rucoa/nodes/sym_node'
   end
 end

data/lib/rucoa/parser_builder.rb

@@ -5,24 +5,34 @@ require 'parser/current'
 module Rucoa
   class ParserBuilder < ::Parser::Builders::Default
     NODE_CLASS_BY_TYPE = {
-      str: Nodes::StrNode
+      casgn: Nodes::CasgnNode,
+      class: Nodes::ClassNode,
+      const: Nodes::ConstNode,
+      def: Nodes::DefNode,
+      defs: Nodes::DefsNode,
+      lvar: Nodes::LvarNode,
+      module: Nodes::ModuleNode,
+      sclass: Nodes::SclassNode,
+      send: Nodes::SendNode,
+      str: Nodes::StrNode,
+      sym: Nodes::SymNode
     }.freeze
 
+    class << self
+      # @param type [Symbol]
+      # @return [Class]
+      def node_class_for(type)
+        NODE_CLASS_BY_TYPE.fetch(type, Nodes::Base)
+      end
+    end
+
     # @note Override.
     def n(type, children, source_map)
-      node_class_for(type).new(
+      self.class.node_class_for(type).new(
         type,
         children,
         location: source_map
       )
     end
-
-    private
-
-    # @param type [Symbol]
-    # @return [Class]
-    def node_class_for(type)
-      NODE_CLASS_BY_TYPE.fetch(type, Nodes::Base)
-    end
   end
 end

data/lib/rucoa/position.rb

@@ -47,8 +47,8 @@ module Rucoa
     # @return [Hash]
     def to_vscode_position
       {
-        character: @column,
-        line: @line - 1
+        'character' => @column,
+        'line' => @line - 1
       }
     end
   end

data/lib/rucoa/range.rb

@@ -30,28 +30,85 @@ module Rucoa
 
     # @param beginning [Rucoa::Position]
     # @param ending [Ruoca::Position]
-    # @param exclude_end [Boolean]
-    def initialize(beginning, ending, exclude_end: true)
+    # @param including_ending [Boolean]
+    def initialize(beginning, ending, including_ending: true)
       @beginning = beginning
       @ending = ending
-      @exclude_end = exclude_end
+      @including_ending = including_ending
     end
 
     # @param range [Rucoa::Range]
     # @return [Boolean]
-    def contains?(range)
-      copy = with_including_end
-      copy.include?(range.beginning) && copy.include?(range.ending)
+    # @example returns true when the range is contained in self
+    #   range = Rucoa::Range.new(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 0
+    #     ),
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 2
+    #     )
+    #   )
+    #   expect(range).to contain(
+    #     Rucoa::Range.new(
+    #       Rucoa::Position.new(
+    #         column: 0,
+    #         line: 0
+    #       ),
+    #       Rucoa::Position.new(
+    #         column: 0,
+    #         line: 0
+    #       )
+    #     )
+    #   )
+    def contain?(range)
+      include?(range.beginning) && include?(range.ending)
     end
 
     # @param position [Rucoa::Position]
     # @return [Boolean]
+    # @example returns true when the position is included in self
+    #   range = Rucoa::Range.new(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 0
+    #     ),
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 2
+    #     )
+    #   )
+    #   expect(range).to include(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 0
+    #     )
+    #   )
+    #   expect(range).to include(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 1
+    #     )
+    #   )
+    #   expect(range).to include(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 2
+    #     )
+    #   )
+    #   expect(range).not_to include(
+    #     Rucoa::Position.new(
+    #       column: 0,
+    #       line: 3
+    #     )
+    #   )
     def include?(position)
       return false if position.line > @ending.line
       return false if position.line < @beginning.line
       return false if position.column < @beginning.column
       return false if position.column > @ending.column
-      return false if position.column == @ending.column && @exclude_end
+      return false if position.column == @ending.column && !@including_ending
 
       true
     end
@@ -63,12 +120,5 @@ module Rucoa
         start: @beginning.to_vscode_position
       }
     end
-
-    private
-
-    # @return [Rucoa::Range]
-    def with_including_end
-      self.class.new(@beginning, @ending, exclude_end: false)
-    end
   end
 end

data/lib/rucoa/rbs_document_loader.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'rbs'
+
+module Rucoa
+  class RbsDocumentLoader
+    class << self
+      def call
+        new.call
+      end
+    end
+
+    # @return [Array<Rucoa::Definitions::Base>]
+    def call
+      declarations.flat_map do |declaration|
+        case declaration
+        when ::RBS::AST::Declarations::Constant
+          [
+            DefinitionBuilders::RbsConstantDefinitionBuilder.call(declaration: declaration)
+          ]
+        when ::RBS::AST::Declarations::Class, ::RBS::AST::Declarations::Module
+          declaration.members.grep(::RBS::AST::Members::MethodDefinition).map do |method_definition|
+            DefinitionBuilders::RbsMethodDefinitionBuilder.call(
+              declaration: declaration,
+              method_definition: method_definition
+            )
+          end
+        else
+          []
+        end
+      end
+    end
+
+    private
+
+    # @return [Array<RBS::AST::Declarations::Base>]
+    def declarations
+      ::RBS::Environment.from_loader(
+        ::RBS::EnvironmentLoader.new
+      ).resolve_type_names.declarations
+    end
+  end
+end

data/lib/rucoa/rubocop_autocorrector.rb

@@ -31,7 +31,7 @@ module Rucoa
     # @return [String]
     def call
       @options[:stdin] = @source.content
-      run([@source.path])
+      run([@source.path || 'untitled'])
       @options[:stdin]
     end
   end

data/lib/rucoa/rubocop_investigator.rb

@@ -31,7 +31,7 @@ module Rucoa
     # @return [Array<RuboCop::Cop::Offense>]
     def call
       @options[:stdin] = @source.content
-      run([@source.path])
+      run([@source.path || 'untitled'])
       @offenses
     end