ruby_language_server 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 403609bb04e3734281518bc6a175b6e839e6b731d684dd5716f31e91bb7e1d98
+  data.tar.gz: b7c597616a85977982dc2ddbcb8b8c7d896a1829904fa19dfbb52951da6895b6
+SHA512:
+  metadata.gz: cfbd3c60687d08b1f9e19bc632e9d8f4ceb0f5e579e8d6b9edd7e7cf81403dac9b0c7a795fac403b550950b7c1ef615095ad94bbbefe80662390edbdd16f13b7
+  data.tar.gz: 784a22cdadad7ebdf6f25ce35a78e2cff90aa148dbf62c88e650ba42e7ce522df59e9758e9de166f99308e5226b9100505c73a7f9ee7c470575435072926afae

data/CHANGELOG.txt

@@ -0,0 +1,67 @@
+# Changelog
+
+#### 0.2.0 Mon Dec 24 18:19:55 PST 2018
+
+* Support for rake files
+* Support for rspec files
+* Removed ripper tags & refactoring
+* Better handling of parameter variables
+* Probably better performance (not measured, but reasonably sure)
+
+#### 0.1.1 Fri Dec 21 16:48:46 PST 2018
+
+* Fix a few little issues that came to light while updating ide-ruby
+
+#### 0.1.0 Fri Dec 21 15:19:00 PST 2018
+
+* Refactor server & project_manager
+* fix bugs with def self.method and class << self  (https://github.com/kwerle/ide-ruby/issues/19)
+* Add support for additional rubocop gems (https://github.com/kwerle/ide-ruby/issues/17)
+
+#### 0.0.9 Thu Oct 18 17:48:35 PDT 2018
+
+* Refactor & some RuboCop
+* Fix most of https://github.com/kwerle/ide-ruby/issues/18
+* * Rubocop issues: no inline support,
+* * invalid snake_case warnings,
+* * NOT missing "rubocop failed to load" indicator
+* More work on completion stuff
+
+#### 0.0.8 Thu Jul 19 00:01:25 PDT 2018
+
+* Bump ruby version
+* Fix the initial background thread
+* Refactor
+* Ignore setting text to the same
+
+#### 0.0.7 Thu Jul 12 16:11:26 PDT 2018
+
+* Whoops - forgot to merge changes in.
+
+#### 0.0.6 Thu Jul 12 16:11:26 PDT 2018
+
+* Fix RuboCop again.  Sigh.
+
+#### 0.0.5 Thu Jul 12 15:07:58 PDT 2018
+
+* Parse all project files on startup
+* Fix possible issue with RuboCop config
+
+#### 0.0.4 Tue Mar 20 19:39:06 PDT 2018
+
+* Provide support for .rubocop.yml.  This will work once I update ide-ruby.
+
+#### 0.0.3
+
+* Uhh.  What did I do?  Looks like a bunch.
+
+#### 0.0.2 Mon Nov 13 20:49:54 PST 2017
+
+* Fix rails has_one(etc) so it gets the right parent
+
+#### Sat Nov 11 07:59:25 PST 2017
+
+* Outline working but buggy (double listing for parents)
+* Go to definition working but lazy (have to visit a file before definitions 'known')
+* Completions working in a very basic way - local scope context only
+* Linter not working (not being called, NYI)

data/FAQ_ROADMAP.md

@@ -0,0 +1,30 @@
+# Why docker?
+
+Docker guarantees me a target environment.  I don't have to wonder which version of ruby you have installed or if you can build all the gems.  I may also scale this thing to multiple processes and a database and a cache server.
+
+One requirement: docker.
+
+# Why not [language_server-ruby](https://github.com/mtsmfm/language_server-ruby)
+
+My goals are not as high.  I just want this stuff working now.  I hope some day there will be merging.
+
+# A little light on tests?
+
+Oh yeah.  Tests are mostly for when you know where you're going.  I'm doing a whole lot of this by the seat of my pants.  OMG, please write tests.
+
+# Next?
+
+* Getting a definition just looks at the tags - but tags do not include parameters passed in a method - which seems like it should.  We are functional, right?
+* Guess a symbol's class.
+  * `def some_method(parent)` should guess that parent is a Parent.
+* Be smarter about context and completions
+* `class << self` is busted.  Fix it.
+* Fix the outline.  Seriously - why isn't it working as expected?
+* Symbol pairs.  If I have typed 'foo.bar' a thousand times in my project, the next time I type 'foo.' the IDE had damn well ought to show me 'bar' as a completion option.
+* It makes me very sad that I could not get this working using sockets.  Tried and tried and failed.
+
+# Then?
+
+* Pay special attention to the project's Gemfile.  Install all the gems (we can).  Integrate with gem server?
+  * Full scan of installed gems?
+* Integrate class based scope logic.  If I'm in Foo < Bar then I should see Bar's methods at just slightly lower priority than Foo's.

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in ruby_language_server.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,111 @@
+PATH
+  remote: .
+  specs:
+    ruby_language_server (0.2.0)
+      amatch
+      bundler
+      etc
+      fuzzy_match
+      json
+      rubocop
+      rubocop-rspec
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    amatch (0.4.0)
+      mize
+      tins (~> 1.0)
+    ast (2.4.0)
+    byebug (10.0.2)
+    coderay (1.1.2)
+    etc (1.0.1)
+    ffi (1.9.25)
+    formatador (0.2.5)
+    fuzzy_match (2.1.0)
+    guard (2.15.0)
+      formatador (>= 0.2.4)
+      listen (>= 2.7, < 4.0)
+      lumberjack (>= 1.0.12, < 2.0)
+      nenv (~> 0.1)
+      notiffany (~> 0.0)
+      pry (>= 0.9.12)
+      shellany (~> 0.0)
+      thor (>= 0.18.1)
+    guard-compat (1.2.1)
+    guard-minitest (2.4.6)
+      guard-compat (~> 1.2)
+      minitest (>= 3.0)
+    guard-rubocop (1.3.0)
+      guard (~> 2.0)
+      rubocop (~> 0.20)
+    jaro_winkler (1.5.1)
+    json (2.1.0)
+    listen (3.1.5)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+      ruby_dep (~> 1.2)
+    lumberjack (1.0.13)
+    method_source (0.9.2)
+    minitest (5.11.3)
+    minitest-color (0.0.2)
+      minitest (~> 5)
+    mize (0.3.5)
+      protocol
+    nenv (0.3.0)
+    notiffany (0.1.1)
+      nenv (~> 0.1)
+      shellany (~> 0.0)
+    parallel (1.12.1)
+    parser (2.5.3.0)
+      ast (~> 2.4.0)
+    powerpack (0.1.2)
+    protocol (1.0.1)
+      ruby_parser (~> 3.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
+    rainbow (3.0.0)
+    rake (12.3.2)
+    rb-fsevent (0.10.3)
+    rb-inotify (0.10.0)
+      ffi (~> 1.0)
+    rubocop (0.61.1)
+      jaro_winkler (~> 1.5.1)
+      parallel (~> 1.10)
+      parser (>= 2.5, != 2.5.1.1)
+      powerpack (~> 0.1)
+      rainbow (>= 2.2.2, < 4.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.4.0)
+    rubocop-rspec (1.30.1)
+      rubocop (>= 0.60.0)
+    ruby-progressbar (1.10.0)
+    ruby_dep (1.5.0)
+    ruby_parser (3.12.0)
+      sexp_processor (~> 4.9)
+    sexp_processor (4.11.0)
+    shellany (0.0.1)
+    thor (0.20.3)
+    tins (1.20.2)
+    unicode-display_width (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  guard
+  guard-minitest
+  guard-rubocop
+  minitest
+  minitest-color
+  pry
+  pry-byebug
+  rake
+  ruby_language_server!
+
+BUNDLED WITH
+   1.17.3

data/Guardfile

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest, all_after_pass: true do
+  # with Minitest::Unit
+  # watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  # watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  # watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  watch(%r{^spec/**/(.*)_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})          { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^spec/spec_helper\.rb$})  { 'spec' }
+end
+
+guard :rubocop, cli: ['-c', '.rubocop_ruby_language_parser.yml'] do
+  watch('.rubocop_ruby_language_parser.yml')
+  watch(/.+\.rb$/)
+  watch(%r{(?:.+/)?\.rubocop(?:_todo)?\.yml$}) { |m| File.dirname(m[0]) }
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Kurt Werle
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Makefile

@@ -0,0 +1,35 @@
+PROJECT_NAME=ruby_language_server
+LOCAL_LINK=-v $(PWD):/tmp/src -w /tmp/src
+
+build:
+	docker build -t $(PROJECT_NAME) .
+
+guard: build
+	docker run -it $(LOCAL_LINK) $(PROJECT_NAME) sh -c 'bundle && guard'
+
+continuous_development: build
+	echo "You are going to want to set the ide-ruby 'Image Name' to local_ruby_language_server"
+	sleep 15
+	while (true) ; \
+	do \
+	  docker build -t local_ruby_language_server . ; \
+	  sleep 2 ; \
+	done
+
+console: build
+	docker run -it $(LOCAL_LINK) $(PROJECT_NAME) bin/console
+
+shell: build
+	docker run -it $(LOCAL_LINK) $(PROJECT_NAME) sh
+
+# Just to make sure it works.
+server: build
+	docker run -it $(LOCAL_LINK) $(PROJECT_NAME)
+
+gem: build
+	rm -f $(PROJECT_NAME)*.gem
+	docker run $(LOCAL_LINK) $(PROJECT_NAME) gem build $(PROJECT_NAME)
+
+# Requires rubygems be installed on host
+gem_release: gem
+	gem push $(PROJECT_NAME)*.gem

data/README.md

@@ -0,0 +1,55 @@
+# Overview
+
+https://github.com/kwerle/ruby_language_server
+
+The goal of this project is to provide a [language server](https://microsoft.github.io/language-server-protocol/) implementation for ruby in ruby.
+
+# Status
+
+Beta.  It does some stuff.  Pretty stable.  Used day-to-day.
+
+Help wanted.
+
+# Features
+
+* Definitions
+* Completions
+* Lint - thanks to [RuboCop](https://github.com/bbatsov/rubocop)
+* Please see the [FAQ_ROADMAP.md](./FAQ_ROADMAP.md)
+
+# Editor Integrations
+
+* You probably want to use one of the developed integrations:
+  * Atom - https://github.com/kwerle/ide-ruby
+  * Theia - https://github.com/kwerle/theia_ruby_language_server
+
+# Running
+
+`ruby_language_server` will start the program and wait for activity using LSP's STDIO interface
+
+# Development
+
+Clone.  I love git [HubFlow](https://datasift.github.io/gitflow/).
+
+Check out the [Makefile](Makefile).  You are going to want to do
+`make guard` and `make continuous_development`.
+
+* In Atom: install the ide-ruby.  
+* Settings > Packages > ide-ruby > Image Name > local_ruby_language_server
+* CMD-ALT-CTRL-l (that's an L) will reload the window
+* CMD-ALT-i will show debugging info
+
+Write tests and guard will run them.  Make changes and reload the window.  Test them out.
+
+# Similar
+
+* [mtsmfm/language_server-ruby](https://github.com/mtsmfm/language_server-ruby)
+* [castwide/solargraph](https://github.com/castwide/solargraph)
+
+# Authors
+
+* [Kurt Werle](kurt@CircleW.org)
+
+# Contributors
+
+* *Your name here!*

data/Rakefile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'spec'
+  t.libs << 'lib'
+  t.test_files = FileList['spec/**/*_spec.rb']
+end
+
+desc 'Run guard'
+task guard: [] do
+  `guard`
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'ruby_language_server'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/ruby_language_server

@@ -0,0 +1,9 @@
+#!/usr/local/bin/ruby
+# frozen_string_literal: true
+
+$LOAD_PATH << File.join(__dir__, '..', 'lib')
+
+require 'ruby_language_server'
+
+server = RubyLanguageServer::Server.new
+RubyLanguageServer::IO.new(server)

data/lib/ruby_language_server/code_file.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative 'scope_data/base'
+require_relative 'scope_data/scope'
+require_relative 'scope_data/variable'
+
+module RubyLanguageServer
+  class CodeFile
+    attr_reader :uri
+    attr_reader :text
+    attr_reader :lint_found
+
+    def initialize(uri, text)
+      RubyLanguageServer.logger.debug("CodeFile initialize #{uri}")
+      @uri = uri
+      @text = text
+      @refresh_root_scope = true
+    end
+
+    def text=(new_text)
+      RubyLanguageServer.logger.debug("text= for #{uri}")
+      if @text == new_text
+        RubyLanguageServer.logger.debug('IT WAS THE SAME!!!!!!!!!!!!')
+        return
+      end
+      @text = new_text
+      @refresh_root_scope = true
+    end
+
+    SYMBOL_KIND = {
+      file: 1,
+      'module': 5, # 2,
+      namespace: 3,
+      package: 4,
+      'class': 5,
+      'method': 6,
+      'singleton method': 6,
+      property: 7,
+      field: 8,
+      constructor: 9,
+      enum: 10,
+      interface: 11,
+      function: 12,
+      variable: 13,
+      constant: 14,
+      string: 15,
+      number: 16,
+      boolean: 17,
+      array: 18
+    }.freeze
+
+    # Find the ancestor of this scope with a name and return that.  Or nil.
+    def ancestor_scope_name(scope)
+      return_scope = scope
+      while (return_scope = return_scope.parent)
+        return return_scope.name unless return_scope.name.nil?
+      end
+    end
+
+    def tags
+      RubyLanguageServer.logger.debug("Asking about tags for #{uri}")
+      return @tags = {} if text.nil? || text == ''
+
+      tags = []
+      root_scope.self_and_descendants.each do |scope|
+        next if scope.type == ScopeData::Base::TYPE_BLOCK
+
+        name = scope.name
+        kind = SYMBOL_KIND[scope.type] || 7
+        kind = 9 if name == 'initialize' # Magical special case
+        scope_hash = {
+          name: name,
+          kind: kind,
+          location: Location.hash(uri, scope.top_line)
+        }
+        container_name = ancestor_scope_name(scope)
+        scope_hash[:containerName] = container_name if container_name
+        tags << scope_hash
+
+        scope.variables.each do |variable|
+          name = variable.name
+          # We only care about counstants
+          next unless name =~ /^[A-Z]/
+
+          variable_hash = {
+            name: name,
+            kind: SYMBOL_KIND[:constant],
+            location: Location.hash(uri, variable.line),
+            containerName: scope.name
+          }
+          tags << variable_hash
+        end
+      end
+      # byebug
+      tags.reject! { |tag| tag[:name].nil? }
+      # RubyLanguageServer.logger.debug("Raw tags for #{uri}: #{tags}")
+      # If you don't reverse the list then atom? won't be able to find the
+      # container and containers will get duplicated.
+      @tags = tags.reverse_each do |tag|
+        child_tags = tags.select { |child_tag| child_tag[:containerName] == tag[:name] }
+        max_line = child_tags.map { |child_tag| child_tag[:location][:range][:end][:line].to_i }.max || 0
+        tag[:location][:range][:end][:line] = [tag[:location][:range][:end][:line], max_line].max
+      end
+      # RubyLanguageServer.logger.debug("Done with tags for #{uri}: #{@tags}")
+      # RubyLanguageServer.logger.debug("tags caller #{caller * ','}")
+      @tags
+    end
+
+    def diagnostics
+      # Maybe we should be sharing this GoodCop across instances
+      @good_cop ||= GoodCop.new
+      @good_cop.diagnostics(@text, @uri)
+    end
+
+    def root_scope
+      # RubyLanguageServer.logger.error("Asking about root_scope with #{text}")
+      if @refresh_root_scope
+        new_root_scope = ScopeParser.new(text).root_scope
+        @root_scope ||= new_root_scope # In case we had NONE
+        return @root_scope if new_root_scope.children.empty?
+
+        @root_scope = new_root_scope
+        @refresh_root_scope = false
+        @tags = nil
+      end
+      @root_scope
+    end
+  end
+end

data/lib/ruby_language_server/completion.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  module Completion
+    COMPLETION_ITEM_KIND = {
+      text: 1,
+      method: 2,
+      function: 3,
+      constructor: 4,
+      field: 5,
+      variable: 6,
+      class: 7,
+      interface: 8,
+      module: 9,
+      property: 10,
+      unit: 11,
+      value: 12,
+      enum: 13,
+      keyword: 14,
+      snippet: 15,
+      color: 16,
+      file: 17,
+      reference: 18
+    }.freeze
+
+    class << self
+      def completion(context, context_scope, scopes)
+        RubyLanguageServer.logger.debug("completion(#{context}, #{context_scope.self_and_ancestors.map(&:name)}, #{scopes.map(&:name)})")
+        completions =
+          if context.length < 2
+            scope_completions(context.last, context_scope.self_and_ancestors)
+          else
+            scope_completions_in_target_context(context, context_scope, scopes)
+          end
+        {
+          isIncomplete: true,
+          items: completions.uniq.map do |word, hash|
+            {
+              label: word,
+              kind: COMPLETION_ITEM_KIND[hash[:type]]
+            }
+          end
+        }
+      end
+
+      def scope_with_name(name, scopes)
+        scopes.detect { |scope| scope.name == name }
+      end
+
+      def scope_completions_in_target_context(context, context_scope, scopes)
+        working_array = context.dup
+        context_word = working_array[-2]
+        if context_word.match?(/^[A-Z]/)
+          scope = scope_with_name(context_word, scopes)
+        else
+          context_word = context_word.split(/_/).map(&:capitalize).join('')
+          scope = scope_with_name(context_word, scopes)
+          RubyLanguageServer.logger.debug("scope_with_name: #{scope}")
+        end
+        scope ||= context_scope
+        RubyLanguageServer.logger.debug("scope: #{scope}")
+        scope_completions(context.last, scope.self_and_ancestors)
+      end
+
+      def scope_completions(word, scopes)
+        words = {}
+        scopes.each_with_object(words) do |scope, words_hash|
+          scope.children.each do |function|
+            words_hash[function.name] ||= {
+              depth: scope.depth,
+              type: function.type
+            }
+          end
+          scope.variables.each do |variable|
+            words_hash[variable.name] ||= {
+              depth: scope.depth,
+              type: variable.type
+            }
+          end
+        end
+        # words = words.sort_by{|word, hash| hash[:depth] }.to_h
+        good_words = FuzzyMatch.new(words.keys, threshold: 0.01).find_all(word).slice(0..10) || []
+        words = good_words.map { |w| [w, words[w]] }.to_h
+      end
+    end
+  end
+end

data/lib/ruby_language_server/gem_installer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'bundler/inline'
+
+module RubyLanguageServer
+  # Sole purpose is to install gems
+  module GemInstaller
+    class << self
+      def install_gems(gem_names)
+        gem_names&.compact!
+        gem_names&.reject! { |name| name.strip == '' }
+        return if gem_names.nil? || gem_names.empty?
+
+        RubyLanguageServer.logger.info("Trying to install gems #{gem_names}")
+        gemfile do
+          source 'https://rubygems.org'
+          gem_names.each do |gem_name|
+            gem gem_name
+          end
+        end
+      end
+    end
+  end
+end