yoda-language-server 0.4.0

data/client/vscode/package.json

@@ -0,0 +1,39 @@
+{
+    "name": "yoda",
+    "displayName": "yoda",
+    "description": "Static analytics tool for Ruby",
+    "version": "0.0.1",
+    "publisher": "nemunemu",
+    "engines": {
+        "vscode": "^1.19.0"
+    },
+    "categories": [
+        "Other"
+    ],
+    "activationEvents": [
+        "onLanguage:ruby"
+    ],
+    "main": "./out/extension",
+    "contributes": {
+        "commands": [
+            {
+                "command": "extension.sayHello",
+                "title": "Hello World"
+            }
+        ]
+    },
+    "scripts": {
+        "vscode:prepublish": "npm run compile",
+        "compile": "tsc -p ./",
+        "watch": "tsc -watch -p ./",
+        "postinstall": "node ./node_modules/vscode/bin/install",
+        "test": "npm run compile && node ./node_modules/vscode/bin/test"
+    },
+    "devDependencies": {
+        "typescript": "^2.6.1",
+        "vscode": "^1.1.6",
+        "vscode-languageclient": "^3.5.0",
+        "@types/node": "^7.0.43",
+        "@types/mocha": "^2.2.42"
+    }
+}

data/client/vscode/src/extension.ts

@@ -0,0 +1,42 @@
+'use strict';
+
+import * as path from 'path';
+
+// The module 'vscode' contains the VS Code extensibility API
+// Import the module and reference it with the alias vscode in your code below
+import * as vscode from 'vscode';
+import { LanguageClient, LanguageClientOptions, ServerOptions, TransportKind } from 'vscode-languageclient';
+import { worker } from 'cluster';
+import { workspace } from 'vscode';
+
+// this method is called when your extension is activated
+// your extension is activated the very first time the command is executed
+export function activate(context: vscode.ExtensionContext) {
+    // Use the console to output diagnostic information (console.log) and errors (console.error)
+    // This line of code will only be executed once when your extension is activated
+    console.log('Congratulations, your extension "yoda" is now active!');
+
+    let execOptions = {
+        command: path.resolve(__dirname, '../../../exe/yoda'),
+        args: ['server'],
+    }
+
+    let serverOptions : ServerOptions = {
+        run: execOptions,
+        debug: execOptions,
+    }
+
+    let clientOptions : LanguageClientOptions = {
+        documentSelector: [{ scheme: 'file', language: 'ruby' }],
+        synchronize: {
+            configurationSection: 'yoda',
+            fileEvents: workspace.createFileSystemWatcher('**/.rb'),
+        }
+    }
+
+    let disposable = new LanguageClient('yoda', 'Yoda Language Server', serverOptions, clientOptions).start();
+}
+
+// this method is called when your extension is deactivated
+export function deactivate() {
+}

data/client/vscode/src/test/extension.test.ts

@@ -0,0 +1,22 @@
+//
+// Note: This example test is leveraging the Mocha test framework.
+// Please refer to their documentation on https://mochajs.org/ for help.
+//
+
+// The module 'assert' provides assertion methods from node
+import * as assert from 'assert';
+
+// You can import and use all API from the 'vscode' module
+// as well as import your extension to test it
+import * as vscode from 'vscode';
+import * as myExtension from '../extension';
+
+// Defines a Mocha test suite to group tests of similar kind together
+suite("Extension Tests", () => {
+
+    // Defines a Mocha unit test
+    test("Something 1", () => {
+        assert.equal(-1, [1, 2, 3].indexOf(5));
+        assert.equal(-1, [1, 2, 3].indexOf(0));
+    });
+});

data/client/vscode/src/test/index.ts

@@ -0,0 +1,22 @@
+//
+// PLEASE DO NOT MODIFY / DELETE UNLESS YOU KNOW WHAT YOU ARE DOING
+//
+// This file is providing the test runner to use when running extension tests.
+// By default the test runner in use is Mocha based.
+//
+// You can provide your own test runner if you want to override it by exporting
+// a function run(testRoot: string, clb: (error:Error) => void) that the extension
+// host can call to run the tests. The test runner is expected to use console.log
+// to report the results back to the caller. When the tests are finished, return
+// a possible error to the callback or null if none.
+
+import * as testRunner from 'vscode/lib/testrunner';
+
+// You can directly control Mocha options by uncommenting the following lines
+// See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
+testRunner.configure({
+    ui: 'tdd', 		// the TDD UI is being used in extension.test.ts (suite, test, etc.)
+    useColors: true // colored output from test results
+});
+
+module.exports = testRunner;

data/client/vscode/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "outDir": "out",
+        "lib": [
+            "es6"
+        ],
+        "sourceMap": true,
+        "rootDir": "src"
+    },
+    "exclude": [
+        "node_modules",
+        ".vscode-test"
+    ]
+}

data/client/vscode/vsc-extension-quickstart.md

@@ -0,0 +1,33 @@
+# Welcome to your VS Code Extension
+
+## What's in the folder
+* This folder contains all of the files necessary for your extension.
+* `package.json` - this is the manifest file in which you declare your extension and command.
+The sample plugin registers a command and defines its title and command name. With this information
+VS Code can show the command in the command palette. It doesn’t yet need to load the plugin.
+* `src/extension.ts` - this is the main file where you will provide the implementation of your command.
+The file exports one function, `activate`, which is called the very first time your extension is
+activated (in this case by executing the command). Inside the `activate` function we call `registerCommand`.
+We pass the function containing the implementation of the command as the second parameter to
+`registerCommand`.
+
+## Get up and running straight away
+* Press `F5` to open a new window with your extension loaded.
+* Run your command from the command palette by pressing (`Ctrl+Shift+P` or `Cmd+Shift+P` on Mac) and typing `Hello World`.
+* Set breakpoints in your code inside `src/extension.ts` to debug your extension.
+* Find output from your extension in the debug console.
+
+## Make changes
+* You can relaunch the extension from the debug toolbar after changing code in `src/extension.ts`.
+* You can also reload (`Ctrl+R` or `Cmd+R` on Mac) the VS Code window with your extension to load your changes.
+
+## Explore the API
+* You can open the full set of our API when you open the file `node_modules/vscode/vscode.d.ts`.
+
+## Run tests
+* Open the debug viewlet (`Ctrl+Shift+D` or `Cmd+Shift+D` on Mac) and from the launch configuration dropdown pick `Launch Tests`.
+* Press `F5` to run the tests in a new window with your extension loaded.
+* See the output of the test result in the debug console.
+* Make changes to `test/extension.test.ts` or create new test files inside the `test` folder.
+    * By convention, the test runner will only consider files matching the name pattern `**.test.ts`.
+    * You can create folders inside the `test` folder to structure your tests any way you want.

data/exe/yoda

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+if Dir.exist?(File.join(__dir__, "..", ".git"))
+  $LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+end
+
+require 'yoda'
+require 'optparse'
+
+opt = OptionParser.new("Usage: yoda [options]") do |opt|
+end
+
+argv = opt.parse(ARGV)
+
+case argv.first
+when 'setup'
+  require 'pry'
+  Pry::rescue { Yoda::Runner::Setup.run(argv[1]) }
+when 'infer'
+  require 'pry'
+  Pry::rescue { Yoda::Runner::Infer.run(argv[1]) }
+when 'server'
+  Yoda::Server.new.run
+else
+  puts opt.help
+  exit 1
+end

data/lib/yoda.rb

@@ -0,0 +1,11 @@
+module Yoda
+  require "yoda/version"
+  require "yoda/evaluation"
+  require "yoda/model"
+  require "yoda/store"
+  require "yoda/server"
+  require "yoda/parsing"
+  require "yoda/typing"
+  require "yoda/runner"
+  require "yoda/yard_extensions"
+end

data/lib/yoda/evaluation.rb

@@ -0,0 +1,9 @@
+module Yoda
+  module Evaluation
+    require 'yoda/evaluation/evaluator'
+    require 'yoda/evaluation/current_node_explain'
+    require 'yoda/evaluation/comment_completion'
+    require 'yoda/evaluation/code_completion'
+    require 'yoda/evaluation/signature_discovery'
+  end
+end

data/lib/yoda/evaluation/code_completion.rb

@@ -0,0 +1,65 @@
+module Yoda
+  module Evaluation
+    class CodeCompletion
+      require 'yoda/evaluation/code_completion/base_provider'
+      require 'yoda/evaluation/code_completion/method_provider'
+      require 'yoda/evaluation/code_completion/variable_provider'
+      require 'yoda/evaluation/code_completion/const_provider'
+
+      # @return [Store::Registry]
+      attr_reader :registry
+
+      # @return [String]
+      attr_reader :source
+
+      # @return [Parsing::Location]
+      attr_reader :location
+
+      # @param registry [Store::Registry]
+      # @param source   [String]
+      # @param location [Parsing::Location]
+      def initialize(registry, source, location)
+        @registry = registry
+        @source = source
+        @location = location
+      end
+
+      # @return [true, false]
+      def valid?
+        providers.any?(&:providable?)
+      end
+
+      # @return [Array<Model::CompletionItem>]
+      def candidates
+        providers.select(&:providable?).map(&:candidates).flatten
+      end
+
+      private
+
+      # @return [Array<CodeCompletion::BaseProvider>]
+      def providers
+        [method_provider, variable_provider, const_provider]
+      end
+
+      # @return [Parsing::SourceAnalyzer]
+      def source_analyzer
+        @source_analyzer ||= Parsing::SourceAnalyzer.from_source(source, location)
+      end
+
+      # @return [MethodProvider]
+      def method_provider
+        @method_provider ||= MethodProvider.new(registry, source_analyzer)
+      end
+
+      # @return [VariableProvider]
+      def variable_provider
+        @variable_provider ||= VariableProvider.new(registry, source_analyzer)
+      end
+
+      # @return [ConstantProvider]
+      def const_provider
+        @constant_provider ||= ConstProvider.new(registry, source_analyzer)
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/code_completion/base_provider.rb

@@ -0,0 +1,57 @@
+module Yoda
+  module Evaluation
+    class CodeCompletion
+      # @abstract
+      # Base class of completion candidates providers for code completion.
+      # This class bridges analysis features such as syntastic analysis {#analyzer} and symbolic execiton {#evaluator}.
+      class BaseProvider
+        # @return [Store::Registry]
+        attr_reader :registry
+
+        # @return [Parsing::SourceAnalyzer]
+        attr_reader :source_analyzer
+
+        # @param registry [Store::Registry]
+        # @param source_analyzer [Parsing::SourceAnalyzer]
+        def initialize(registry, source_analyzer)
+          @registry = registry
+          @source_analyzer = source_analyzer
+        end
+
+        # @abstract
+        # @return [true, false]
+        def providable?
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Array<Model::CompletionItem>]
+        def candidates
+          fail NotImplementedError
+        end
+
+        private
+
+        # @return [SourceAnalyzer]
+        def analyzer
+          @analyzer ||= Parsing::SourceAnalyzer.from_source(source, location)
+        end
+
+        # @return [Evaluator]
+        def evaluator
+          @evaluator ||= Evaluator.from_ast(registry, source_analyzer.ast, location)
+        end
+
+        # @return [::Parser::AST::Node]
+        def ast
+          source_analyzer.ast
+        end
+
+        # @return [Parsing::Location]
+        def location
+          source_analyzer.location
+        end
+      end
+    end
+  end
+end

data/lib/yoda/evaluation/code_completion/const_provider.rb

@@ -0,0 +1,90 @@
+module Yoda
+  module Evaluation
+    class CodeCompletion
+      class ConstProvider < BaseProvider
+        # @return [true, false]
+        def providable?
+          !!current_ancestor_const_node
+        end
+
+        # Returns constant candidates by using the current lexical scope.
+        # @return [Array<Model::CompletionItem>] constant candidates.
+        def candidates
+          const_candidates.map do |const_candidate|
+            Model::CompletionItem.new(
+              description: Model::Descriptions::ValueDescription.new(const_candidate),
+              range: substitution_range,
+              kind: complete_item_kind(const_candidate),
+              prefix: just_after_separator? ? '::' : '',
+            )
+          end
+        end
+
+        private
+
+        # @param object [Store::Objects::Base]
+        # @return [Symbol]
+        def complete_item_kind(object)
+          case object.kind
+          when :class
+            :class
+          when :module
+            :module
+          else
+            :constant
+          end
+        end
+
+        # @return [Range, nil]
+        def substitution_range
+          return nil unless providable?
+          @substitution_range ||=
+            if just_after_separator?
+              Parsing::Range.of_ast_location(current_ancestor_const_node.node.location.double_colon)
+            else
+              Parsing::Range.of_ast_location(current_ancestor_const_node.node.location.name)
+            end
+        end
+
+        # @return [Parsing::NodeObjects::ConstNode, nil]
+        def current_ancestor_const_node
+          @current_ancestor_const_node ||= begin
+            node = source_analyzer.nodes_to_current_location_from_root.reverse.take_while { |el| [:const, :cbase].include?(el.type) }.last
+            return nil if !node || node.type != :const
+            Parsing::NodeObjects::ConstNode.new(node)
+          end
+        end
+
+        # @return [Array<Store::Objects::Base>]
+        def const_candidates
+          return [] unless providable?
+          return [] if const_parent_paths.empty?
+
+          base_path = current_ancestor_const_node.to_path
+          path = just_after_separator? ? Model::Path.from_names([base_path.spacename, '']) : base_path
+          scoped_path = Model::ScopedPath.new(const_parent_paths, path)
+          Store::Query::FindConstant.new(registry).select_with_prefix(scoped_path)
+        end
+
+        # @return [true, false]
+        def just_after_separator?
+          return @is_just_after_separator if instance_variable_defined?(:@is_just_after_separator)
+          @is_just_after_separator = current_ancestor_const_node.just_after_separator?(source_analyzer.location)
+        end
+
+        # @return [Array<Store::Objects::Base>]
+        def const_parent_paths
+          @const_parent_paths ||= begin
+            lexical_scope(source_analyzer.current_namespace)
+          end
+        end
+
+        # @param namespace [Parsing::NodeObjects::Namespace]
+        # @return [Array<Path>]
+        def lexical_scope(namespace)
+          namespace.paths_from_root.reverse.map { |name| Model::Path.build(name.empty? ? 'Object' : name.gsub(/\A::/, '')) }
+        end
+      end
+    end
+  end
+end