rucoa 0.1.0

data/lib/rucoa/parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+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
+      end
+    end
+
+    # @param text [String]
+    def initialize(text)
+      @text = text
+    end
+
+    # @return [Rucoa::Nodes::Base]
+    def call
+      parser.parse(
+        ::Parser::Source::Buffer.new(
+          '',
+          source: @text
+        )
+      )
+    end
+
+    private
+
+    # @return [Parser::Base]
+    def parser
+      parser = ::Parser::CurrentRuby.new(ParserBuilder.new)
+      parser.diagnostics.all_errors_are_fatal = true
+      parser.diagnostics.ignore_warnings = true
+      parser
+    end
+  end
+end

data/lib/rucoa/parser_builder.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'parser/current'
+
+module Rucoa
+  class ParserBuilder < ::Parser::Builders::Default
+    NODE_CLASS_BY_TYPE = {
+      str: Nodes::StrNode
+    }.freeze
+
+    # @note Override.
+    def n(type, children, source_map)
+      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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Rucoa
+  class Position
+    class << self
+      # @param range [Parser::Source::Range]
+      # @return [Rucoa::Position]
+      def from_parser_range_beginning(range)
+        new(
+          column: range.column,
+          line: range.line
+        )
+      end
+
+      # @param range [Parser::Source::Range]
+      # @return [Rucoa::Position]
+      def from_parser_range_ending(range)
+        new(
+          column: range.last_column,
+          line: range.last_line
+        )
+      end
+
+      # @param hash [Hash{Symbol => Integer}]
+      # @return [Rucoa::Position]
+      def from_vscode_position(hash)
+        new(
+          column: hash['character'],
+          line: hash['line'] + 1
+        )
+      end
+    end
+
+    # @return [Integer]
+    attr_reader :column
+
+    # @return [Integer]
+    attr_reader :line
+
+    # @param column [Integer] 0-origin column number
+    # @param line [Integer] 1-origin line number
+    def initialize(column:, line:)
+      @column = column
+      @line = line
+    end
+
+    # @return [Hash]
+    def to_vscode_position
+      {
+        character: @column,
+        line: @line - 1
+      }
+    end
+  end
+end

data/lib/rucoa/range.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Rucoa
+  class Range
+    class << self
+      # @param range [Parser::Source::Range]
+      # @return [Rucoa::Range]
+      def from_parser_range(range)
+        new(
+          Position.from_parser_range_beginning(range.begin),
+          Position.from_parser_range_beginning(range.end)
+        )
+      end
+
+      # @param offense [RuboCop::Cop::Offense]
+      # @return [Rucoa::Range]
+      def from_rubocop_offense(offense)
+        new(
+          Position.from_parser_range_beginning(offense.location),
+          Position.from_parser_range_ending(offense.location)
+        )
+      end
+    end
+
+    # @param beginning [Rucoa::Position]
+    # @param ending [Ruoca::Position]
+    def initialize(beginning, ending)
+      @beginning = beginning
+      @ending = ending
+    end
+
+    # @param position [Rucoa::Position]
+    # @return [Boolean]
+    def include?(position)
+      !exclude?(position)
+    end
+
+    # @return [Hash]
+    def to_vscode_range
+      {
+        end: @ending.to_vscode_position,
+        start: @beginning.to_vscode_position
+      }
+    end
+
+    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)
+    end
+  end
+end

data/lib/rucoa/rubocop_runner.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module Rucoa
+  class RubocopRunner < ::RuboCop::Runner
+    class << self
+      # @param path [String]
+      # @return [Array<RuboCop::Cop::Offense>]
+      def call(path:)
+        new(path: path).call
+      end
+    end
+
+    # @param path [String]
+    def initialize(path:)
+      @path = path
+      @offenses = []
+      super(
+        ::RuboCop::Options.new.parse(
+          %w[
+            --stderr
+            --force-exclusion
+            --format RuboCop::Formatter::BaseFormatter
+          ]
+        ).first,
+        ::RuboCop::ConfigStore.new
+      )
+    end
+
+    # @return [Array<RuboCop::Cop::Offense>]
+    def call
+      run([@path])
+      @offenses
+    end
+
+    private
+
+    # @param file [String]
+    # @param offenses [Array<RuboCop::Cop::Offense>]
+    # @return [void]
+    def file_finished(file, offenses)
+      @offenses = offenses
+      super
+    end
+  end
+end

data/lib/rucoa/selection_range_provider.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Rucoa
+  class SelectionRangeProvider
+    class << self
+      # @param source [Rucoa::Source]
+      # @param position [Rucoa::Position]
+      # @return [Hash, nil]
+      def call(position:, source:)
+        new(
+          position: position,
+          source: source
+        ).call
+      end
+    end
+
+    # @param position [Rucoa::Position]
+    # @param source [Rucoa::Source]
+    def initialize(position:, source:)
+      @position = position
+      @source = source
+    end
+
+    # @return [Hash, nil]
+    def call
+      ranges.reverse.reduce(nil) do |result, range|
+        {
+          parent: result,
+          range: range.to_vscode_range
+        }
+      end
+    end
+
+    private
+
+    # @return [Rucoa::Nodes::Base, nil]
+    def node_at_position
+      if instance_variable_defined?(:@node_at_position)
+        @node_at_position
+      else
+        @node_at_position = @source.node_at(@position)
+      end
+    end
+
+    # @return [Array<Rucoa::Range>]
+    def ranges
+      return [] unless node_at_position
+
+      [node_at_position, *node_at_position.ancestors].flat_map do |node|
+        NodeToRangesMapper.call(node)
+      end
+    end
+
+    class NodeToRangesMapper
+      class << self
+        # @param node [Rucoa::Nodes::Base]
+        # @return [Array<Rucoa::Range>]
+        def call(node)
+          new(node).call
+        end
+      end
+
+      # @param node [Rucoa::Nodes::Base]
+      def initialize(node)
+        @node = node
+      end
+
+      # @return [Array<Rucoa::Range>]
+      def call
+        case @node
+        when Nodes::StrNode
+          [
+            inner_range,
+            expression_range
+          ]
+        else
+          []
+        end
+      end
+
+      private
+
+      # @return [Rucoa::Range]
+      def inner_range
+        Range.new(
+          Position.from_parser_range_ending(@node.location.begin),
+          Position.from_parser_range_beginning(@node.location.end)
+        )
+      end
+
+      # @return [Rucoa::Range]
+      def expression_range
+        Range.from_parser_range(@node.location.expression)
+      end
+    end
+  end
+end

data/lib/rucoa/server.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Rucoa
+  class Server
+    # @param reader [IO]
+    # @param writer [IO]
+    def initialize(reader:, writer:)
+      @reader = MessageReader.new(reader)
+      @writer = MessageWriter.new(writer)
+      @source_store = SourceStore.new
+    end
+
+    # @return [void]
+    def start
+      read do |request|
+        result = handle(request)
+        if result
+          write(
+            request: request,
+            result: result
+          )
+        end
+      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)
+      end
+    end
+
+    # @yieldparam request [Hash]
+    # @return [void]
+    def read(&block)
+      @reader.read(&block)
+    end
+
+    # @param request [Hash]
+    # @param result [Object]
+    # @return [void]
+    def write(request:, result:)
+      @writer.write(
+        {
+          id: request['id'],
+          result: result
+        }
+      )
+    end
+
+    # @param uri [String]
+    # @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
+        }
+      )
+    end
+
+    # @param _request [Hash]
+    # @return [Hash]
+    def on_initialize(_request)
+      {
+        capabilities: {
+          textDocumentSync: {
+            change: 1, # Full
+            openClose: true
+          },
+          selectionRangeProvider: true
+        }
+      }
+    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
+    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')
+      )
+      investigate_diagnostics(uri: uri)
+      nil
+    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
+    end
+  end
+end

data/lib/rucoa/source.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Rucoa
+  class Source
+    # @return [String]
+    attr_reader :content
+
+    # @return [String]
+    attr_reader :path
+
+    # @param content [String]
+    # @param path [String, nil]
+    def initialize(content:, path: nil)
+      @content = content
+      @path = path
+    end
+
+    # @param position [Rucoa::Position]
+    # @return [Rucoa::Nodes::Base, nil]
+    def node_at(position)
+      root_and_descendant_nodes.reverse.find do |node|
+        node.include_position?(position)
+      end
+    end
+
+    private
+
+    # @return [Rucoa::Nodes::Base, nil]
+    def root_node
+      @root_node ||= Parser.call(@content)
+    end
+
+    # @return [Array<Rucoa::Nodes::Base>]
+    def root_and_descendant_nodes
+      return [] unless root_node
+
+      [root_node, *root_node.descendants]
+    end
+  end
+end

data/lib/rucoa/source_store.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'cgi'
+require 'uri'
+
+module Rucoa
+  class SourceStore
+    def initialize
+      @data = {}
+    end
+
+    # @param uri [String]
+    # @return [String, nil]
+    def get(uri)
+      @data[uri]
+    end
+
+    # @param uri [String]
+    # @param content [String]
+    # @return [void]
+    def set(uri, content)
+      @data[uri] = Source.new(
+        content: content,
+        path: path_from_uri(uri)
+      )
+    end
+
+    private
+
+    # @param uri [String]
+    # @return [String]
+    def path_from_uri(uri)
+      ::CGI.unescape(
+        ::URI.parse(uri).path
+      )
+    end
+  end
+end

data/lib/rucoa/version.rb

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

data/lib/rucoa.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'rucoa/version'
+
+module Rucoa
+  autoload :Cli, 'rucoa/cli'
+  autoload :Errors, 'rucoa/errors'
+  autoload :DiagnosticProvider, 'rucoa/diagnostic_provider'
+  autoload :MessageReader, 'rucoa/message_reader'
+  autoload :MessageWriter, 'rucoa/message_writer'
+  autoload :Nodes, 'rucoa/nodes'
+  autoload :ParserBuilder, 'rucoa/parser_builder'
+  autoload :Parser, 'rucoa/parser'
+  autoload :Position, 'rucoa/position'
+  autoload :Range, 'rucoa/range'
+  autoload :RubocopRunner, 'rucoa/rubocop_runner'
+  autoload :SelectionRangeProvider, 'rucoa/selection_range_provider'
+  autoload :Server, 'rucoa/server'
+  autoload :Source, 'rucoa/source'
+  autoload :SourceStore, 'rucoa/source_store'
+end

data/rucoa.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lib/rucoa/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'rucoa'
+  spec.version = Rucoa::VERSION
+  spec.authors = ['Ryo Nakamura']
+  spec.email = ['r7kamura@gmail.com']
+
+  spec.summary = 'Language server for Ruby.'
+  spec.homepage = 'https://github.com/r7kamura/rucoa'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.7'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/releases"
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'parser'
+  spec.add_dependency 'rubocop'
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: rucoa
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ryo Nakamura
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- r7kamura@gmail.com
+executables:
+- rucoa
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/rucoa
+- lib/rucoa.rb
+- lib/rucoa/cli.rb
+- lib/rucoa/diagnostic_provider.rb
+- lib/rucoa/errors.rb
+- lib/rucoa/message_reader.rb
+- lib/rucoa/message_writer.rb
+- lib/rucoa/nodes.rb
+- lib/rucoa/nodes/base.rb
+- lib/rucoa/nodes/str_node.rb
+- lib/rucoa/parser.rb
+- lib/rucoa/parser_builder.rb
+- lib/rucoa/position.rb
+- lib/rucoa/range.rb
+- lib/rucoa/rubocop_runner.rb
+- lib/rucoa/selection_range_provider.rb
+- lib/rucoa/server.rb
+- lib/rucoa/source.rb
+- lib/rucoa/source_store.rb
+- lib/rucoa/version.rb
+- rucoa.gemspec
+homepage: https://github.com/r7kamura/rucoa
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/r7kamura/rucoa
+  source_code_uri: https://github.com/r7kamura/rucoa
+  changelog_uri: https://github.com/r7kamura/rucoa/releases
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Language server for Ruby.
+test_files: []