rucoa 0.1.0 → 0.4.0

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,17 @@
+# frozen_string_literal: true
+
+module Rucoa
+  module Nodes
+    class SendNode < Base
+      # @return [Array<Rucoa::Nodes::Base>]
+      def arguments
+        children[2..]
+      end
+
+      # @return [String]
+      def name
+        children[1].to_s
+      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,15 @@
 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 :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,33 @@ 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,
+      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/range.rb

@@ -7,32 +7,53 @@ module Rucoa
       # @return [Rucoa::Range]
       def from_parser_range(range)
         new(
-          Position.from_parser_range_beginning(range.begin),
-          Position.from_parser_range_beginning(range.end)
+          Position.from_parser_range_beginning(range),
+          Position.from_parser_range_ending(range)
         )
       end
 
-      # @param offense [RuboCop::Cop::Offense]
+      # @param hash [Hash]
       # @return [Rucoa::Range]
-      def from_rubocop_offense(offense)
+      def from_vscode_range(hash)
         new(
-          Position.from_parser_range_beginning(offense.location),
-          Position.from_parser_range_ending(offense.location)
+          Position.from_vscode_position(hash['start']),
+          Position.from_vscode_position(hash['end'])
         )
       end
     end
 
+    # @return [Rucoa::Position]
+    attr_reader :beginning
+
+    # @return [Rucoa::Position]
+    attr_reader :ending
+
     # @param beginning [Rucoa::Position]
     # @param ending [Ruoca::Position]
-    def initialize(beginning, ending)
+    # @param exclude_end [Boolean]
+    def initialize(beginning, ending, exclude_end: true)
       @beginning = beginning
       @ending = ending
+      @exclude_end = exclude_end
+    end
+
+    # @param range [Rucoa::Range]
+    # @return [Boolean]
+    def contains?(range)
+      copy = with_including_end
+      copy.include?(range.beginning) && copy.include?(range.ending)
     end
 
     # @param position [Rucoa::Position]
     # @return [Boolean]
     def include?(position)
-      !exclude?(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
+
+      true
     end
 
     # @return [Hash]
@@ -45,13 +66,9 @@ module Rucoa
 
     private
 
-    # @param position [Rucoa::Position]
-    # @return [Boolean]
-    def exclude?(position)
-      position.line > @ending.line ||
-        position.line < @beginning.line ||
-        (position.line == @beginning.line && position.column < @beginning.column) ||
-        (position.line == @ending.line && position.column >= @ending.column)
+    # @return [Rucoa::Range]
+    def with_including_end
+      self.class.new(@beginning, @ending, exclude_end: false)
     end
   end
 end

data/lib/rucoa/rubocop_autocorrector.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Rucoa
+  class RubocopAutocorrector < ::RuboCop::Runner
+    class << self
+      # @param source [Rucoa::Source]
+      # @return [String]
+      def call(source:)
+        new(source: source).call
+      end
+    end
+
+    # @param source [Rucoa::Source]
+    def initialize(source:)
+      @source = source
+      super(
+        ::RuboCop::Options.new.parse(
+          %w[
+            --stderr
+            --force-exclusion
+            --format RuboCop::Formatter::BaseFormatter
+            -A
+          ]
+        ).first,
+        ::RuboCop::ConfigStore.new
+      )
+    end
+
+    # @return [String]
+    def call
+      @options[:stdin] = @source.content
+      run([@source.path])
+      @options[:stdin]
+    end
+  end
+end

data/lib/rucoa/rubocop_configuration_checker.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Rucoa
+  class RubocopConfigurationChecker
+    class << self
+      # @return [Boolean]
+      def call
+        new.call
+      end
+    end
+
+    # @return [Boolean]
+    def call
+      rubocop_configured_for_current_directory?
+    end
+
+    private
+
+    # @return [Boolean]
+    def rubocop_configured_for_current_directory?
+      each_current_and_ancestor_pathname.any? do |pathname|
+        pathname.join('.rubocop.yml').exist?
+      end
+    end
+
+    # @return [Enumerable<Pathname>]
+    def each_current_and_ancestor_pathname
+      return to_enum(__method__) unless block_given?
+
+      pathname = ::Pathname.pwd
+      loop do
+        yield pathname
+        break if pathname.root?
+
+        pathname = pathname.parent
+      end
+      self
+    end
+  end
+end

data/lib/rucoa/{rubocop_runner.rb → rubocop_investigator.rb}

@@ -3,18 +3,18 @@
 require 'rubocop'
 
 module Rucoa
-  class RubocopRunner < ::RuboCop::Runner
+  class RubocopInvestigator < ::RuboCop::Runner
     class << self
-      # @param path [String]
+      # @param source [Rucoa::Source]
       # @return [Array<RuboCop::Cop::Offense>]
-      def call(path:)
-        new(path: path).call
+      def call(source:)
+        new(source: source).call
       end
     end
 
-    # @param path [String]
-    def initialize(path:)
-      @path = path
+    # @param source [Rucoa::Source]
+    def initialize(source:)
+      @source = source
       @offenses = []
       super(
         ::RuboCop::Options.new.parse(
@@ -30,7 +30,8 @@ module Rucoa
 
     # @return [Array<RuboCop::Cop::Offense>]
     def call
-      run([@path])
+      @options[:stdin] = @source.content
+      run([@source.path])
       @offenses
     end
 

data/lib/rucoa/server.rb

@@ -2,131 +2,114 @@
 
 module Rucoa
   class Server
-    # @param reader [IO]
-    # @param writer [IO]
-    def initialize(reader:, writer:)
-      @reader = MessageReader.new(reader)
-      @writer = MessageWriter.new(writer)
+    # @return [Hash{String => Class}]
+    METHOD_TO_HANDLER_MAP = {
+      'initialize' => Handlers::InitializeHandler,
+      'initialized' => Handlers::InitializedHandler,
+      'textDocument/codeAction' => Handlers::TextDocumentCodeActionHandler,
+      'textDocument/didChange' => Handlers::TextDocumentDidChangeHandler,
+      'textDocument/didOpen' => Handlers::TextDocumentDidOpenHandler,
+      'textDocument/documentSymbol' => Handlers::TextDocumentDocumentSymbolHandler,
+      'textDocument/formatting' => Handlers::TextDocumentFormattingHandler,
+      'textDocument/rangeFormatting' => Handlers::TextDocumentRangeFormattingHandler,
+      'textDocument/selectionRange' => Handlers::TextDocumentSelectionRangeHandler,
+      'workspace/didChangeConfiguration' => Handlers::WorkspaceDidChangeConfigurationHandler
+    }.freeze
+    private_constant :METHOD_TO_HANDLER_MAP
+
+    # @return [Rucoa::Configuration]
+    attr_reader :configuration
+
+    # @return [Rucoa::SourceStore]
+    attr_reader :source_store
+
+    # @param input [IO]
+    # @param output [IO]
+    def initialize(input:, output:)
+      @reader = MessageReader.new(input)
+      @writer = MessageWriter.new(output)
+
+      @configuration = Configuration.new
+      @server_request_id = 0
+      @client_response_handlers = {}
       @source_store = SourceStore.new
     end
 
     # @return [void]
     def start
-      read do |request|
-        result = handle(request)
-        if result
-          write(
-            request: request,
-            result: result
-          )
-        end
+      @reader.read do |request|
+        handle(request)
       end
     end
 
-    private
-
-    # @param request [Hash]
-    # @return [Object]
-    def handle(request)
-      case request['method']
-      when 'initialize'
-        on_initialize(request)
-      when 'textDocument/didChange'
-        on_text_document_did_change(request)
-      when 'textDocument/didOpen'
-        on_text_document_did_open(request)
-      when 'textDocument/selectionRange'
-        on_text_document_selection_range(request)
+    # @yieldparam response [Hash]
+    # @param message [Hash]
+    # @return [void]
+    def write(message, &block)
+      if block
+        write_server_request(message, &block)
+      else
+        write_server_response(message)
       end
     end
 
-    # @yieldparam request [Hash]
-    # @return [void]
-    def read(&block)
-      @reader.read(&block)
+    # @note This method is for testing.
+    # @return [Array<Hash>]
+    def responses
+      io = @writer.io
+      io.rewind
+      MessageReader.new(io).read.to_a
     end
 
+    private
+
     # @param request [Hash]
-    # @param result [Object]
     # @return [void]
-    def write(request:, result:)
-      @writer.write(
-        {
-          id: request['id'],
-          result: result
-        }
-      )
+    def handle(request)
+      if request['method']
+        handle_client_request(request)
+      elsif request['id']
+        handle_client_response(request)
+      end
     end
 
-    # @param uri [String]
+    # @param request [Hash]
     # @return [void]
-    def investigate_diagnostics(uri:)
-      diagnostics = DiagnosticProvider.call(
-        source: @source_store.get(uri)
-      )
-      return if diagnostics.empty?
-
-      @writer.write(
-        method: 'textDocument/publishDiagnostics',
-        params: {
-          diagnostics: diagnostics,
-          uri: uri
-        }
+    def handle_client_request(request)
+      find_client_request_handler(request['method'])&.call(
+        request: request,
+        server: self
       )
     end
 
-    # @param _request [Hash]
-    # @return [Hash]
-    def on_initialize(_request)
-      {
-        capabilities: {
-          textDocumentSync: {
-            change: 1, # Full
-            openClose: true
-          },
-          selectionRangeProvider: true
-        }
-      }
+    # @param response [Hash]
+    # @return [void]
+    def handle_client_response(response)
+      @client_response_handlers.delete(response['id'])&.call(response)
     end
 
-    # @param request [Hash]
-    # @return [Array<Hash>]
-    def on_text_document_did_change(request)
-      uri = request.dig('params', 'textDocument', 'uri')
-      @source_store.set(
-        uri,
-        request.dig('params', 'contentChanges')[0]['text']
-      )
-      investigate_diagnostics(uri: uri)
-      nil
+    # @param request_method [String]
+    # @return [Class, nil]
+    def find_client_request_handler(request_method)
+      METHOD_TO_HANDLER_MAP[request_method]
     end
 
-    # @param request [Hash]
-    # @return [Array<Hash>]
-    def on_text_document_did_open(request)
-      uri = request.dig('params', 'textDocument', 'uri')
-      @source_store.set(
-        uri,
-        request.dig('params', 'textDocument', 'text')
+    # @param message [Hash]
+    # @return [void]
+    def write_server_request(message, &block)
+      @writer.write(
+        message.merge(
+          id: @server_request_id
+        )
       )
-      investigate_diagnostics(uri: uri)
-      nil
+      @client_response_handlers[@server_request_id] = block
+      @server_request_id += 1
     end
 
-    # @param request [Hash]
-    # @return [Array<Hash>, nil]
-    def on_text_document_selection_range(request)
-      source = @source_store.get(
-        request.dig('params', 'textDocument', 'uri')
-      )
-      return unless source
-
-      request.dig('params', 'positions').filter_map do |position|
-        SelectionRangeProvider.call(
-          position: Position.from_vscode_position(position),
-          source: source
-        )
-      end
+    # @param message [Hash]
+    # @return [void]
+    def write_server_response(message)
+      @writer.write(message)
     end
   end
 end

data/lib/rucoa/source.rb

@@ -23,13 +23,13 @@ module Rucoa
       end
     end
 
-    private
-
     # @return [Rucoa::Nodes::Base, nil]
     def root_node
       @root_node ||= Parser.call(@content)
     end
 
+    private
+
     # @return [Array<Rucoa::Nodes::Base>]
     def root_and_descendant_nodes
       return [] unless root_node

data/lib/rucoa/source_store.rb

@@ -25,13 +25,19 @@ module Rucoa
       )
     end
 
+    # @yieldparam uri [String]
+    # @return [Enumerable<String>]
+    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
+        ::URI.parse(uri).path || 'untitled'
       )
     end
   end

data/lib/rucoa/version.rb

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

data/lib/rucoa.rb

@@ -4,17 +4,21 @@ require_relative 'rucoa/version'
 
 module Rucoa
   autoload :Cli, 'rucoa/cli'
+  autoload :Configuration, 'rucoa/configuration'
   autoload :Errors, 'rucoa/errors'
-  autoload :DiagnosticProvider, 'rucoa/diagnostic_provider'
+  autoload :HandlerConcerns, 'rucoa/handler_concerns'
+  autoload :Handlers, 'rucoa/handlers'
   autoload :MessageReader, 'rucoa/message_reader'
   autoload :MessageWriter, 'rucoa/message_writer'
+  autoload :NodeConcerns, 'rucoa/node_concerns'
   autoload :Nodes, 'rucoa/nodes'
-  autoload :ParserBuilder, 'rucoa/parser_builder'
   autoload :Parser, 'rucoa/parser'
+  autoload :ParserBuilder, 'rucoa/parser_builder'
   autoload :Position, 'rucoa/position'
   autoload :Range, 'rucoa/range'
-  autoload :RubocopRunner, 'rucoa/rubocop_runner'
-  autoload :SelectionRangeProvider, 'rucoa/selection_range_provider'
+  autoload :RubocopAutocorrector, 'rucoa/rubocop_autocorrector'
+  autoload :RubocopConfigurationChecker, 'rucoa/rubocop_configuration_checker'
+  autoload :RubocopInvestigator, 'rucoa/rubocop_investigator'
   autoload :Server, 'rucoa/server'
   autoload :Source, 'rucoa/source'
   autoload :SourceStore, 'rucoa/source_store'