holistic-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aca9fe7ec2638ae0f1b641f4a0ea62befe91fb6c77820112cf4d8def6287c9d1
+  data.tar.gz: f2a89f2821815944c584307994e671d0203dd097f2301bccc652385f68100eb7
+SHA512:
+  metadata.gz: 5a8d65f2ed3816391a706015588856ca5c4a92c3bf6490b505328135765530b68243fec0231c5fea38fbfc97c494255fd23865bddde59db52d7d47a910d4d887
+  data.tar.gz: a1bc0c055c364692c1ae6de33bb1a270234af95c99e6be708dac6ac069b58b29ca24802f419de1328a9aabb133417c750592a7375b144d349bbfe86fe4dcbf41

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/testdouble/standard
+ruby_version: 2.6

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in holistic.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    holistic-ruby (0.1.0)
+      activesupport (~> 7.0)
+      syntax_tree (~> 6.0)
+      zeitwerk (~> 2.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (7.0.7)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    concurrent-ruby (1.2.2)
+    diff-lcs (1.5.0)
+    i18n (1.14.1)
+      concurrent-ruby (~> 1.0)
+    minitest (5.19.0)
+    prettier_print (1.2.1)
+    rake (13.0.6)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.1)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    syntax_tree (6.1.1)
+      prettier_print (>= 1.2.0)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.6.11)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  holistic-ruby!
+  rake (~> 13.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.4.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Luiz Vasconcellos
+
+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/README.md

@@ -0,0 +1,35 @@
+# holistic-ruby
+
+`holistic-ruby` is a toy language server for the Ruby programming language.
+
+## Installation for Sublime Text
+
+1. Make sure you have the [LSP package installed](https://github.com/sublimelsp/LSP).
+2. Install the gem `$ gem install holistic-ruby`
+3. Go to `Preferences > Package Settings > LSP > Settings` and add:
+
+```json
+{
+  "clients": {
+    "holistic-ruby": {
+      "enabled": true,
+      "command": ["holistic-ruby"],
+      "selector": "source.ruby | text.html.ruby",
+      "initializationOptions": {}
+    }
+  }
+}
+```
+
+## Features
+
+* Go to definition.
+* Find references.
+* Autocompletion for namespaces, methods and local variables.
+* Syntax highlighting boundaries based on packwerk.
+* Outline dependencies.
+* Glossary.
+
+## Why is it a toy language server?
+
+I use `holistic-ruby` on a daily basis in a faily large Ruby codebase. It seems stable and speedy. But... I built it for myself and I'm the only one using it :smile:

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: %i[spec standard]

data/config/logging.rb

@@ -0,0 +1,6 @@
+::ActiveSupport::Notifications.subscribe("holistic.language_server.request") do |name, started, finished, id, data|
+  ::Holistic.logger.info({
+    message: data[:request].message.method,
+    response: data[:request].response.inspect
+  }.to_json)
+end

data/exe/holistic-ruby

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "holistic"
+
+::Holistic::LanguageServer::Stdio::Start.call
+

data/holistic-ruby.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "lib/holistic/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "holistic-ruby"
+  spec.version = Holistic::VERSION
+  spec.authors = ["Luiz Vasconcellos"]
+  spec.email = ["luizpvasc@gmail.com"]
+
+  spec.summary = "Static analysis for Ruby"
+  spec.description = "Static analysis for Ruby"
+  spec.homepage = "https://github.com/luizpvas/holistic-ruby"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  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|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 "syntax_tree", "~> 6.0"
+  spec.add_dependency "zeitwerk", "~> 2.6"
+  spec.add_dependency "activesupport", "~> 7.0"
+end

data/lib/holistic/application.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Holistic
+  class Application
+    attr_reader :name, :root_directory, :root_scope
+
+    def initialize(name:, root_directory:)
+      @name = name
+      @root_directory = root_directory
+      @root_scope = Ruby::Scope::Record.new(kind: Ruby::Scope::Kind::ROOT, name: "::", parent: nil)
+    end
+
+    def extensions
+      @extensions ||= Extensions::Events.new
+    end
+
+    def scopes
+      @scopes ||= Ruby::Scope::Repository.new
+    end
+
+    def references
+      @references ||= Ruby::Reference::Repository.new
+    end
+
+    def unsaved_documents
+      @unsaved_documents ||= Document::Unsaved::Collection.new
+    end
+  end
+end

data/lib/holistic/background_process.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Holistic::BackgroundProcess
+  extend self
+
+  def run(&block)
+    ::Thread.new(&block).tap do |thread|
+      thread.abort_on_exception = true
+    end
+  end
+end

data/lib/holistic/database/table.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+class Holistic::Database::Table
+  attr_reader :primary_attribute, :primary_index, :secondary_indices
+
+  def initialize(primary_attribute:, indices: [])
+    @primary_attribute = primary_attribute
+
+    @primary_index = ::Hash.new
+
+    @secondary_indices = indices.map do |attribute_name|
+      [attribute_name, ::Hash.new { |hash, key| hash[key] = ::Set.new }]
+    end.to_h
+  end
+
+  RecordNotUniqueError = ::Class.new(::StandardError)
+
+  def insert(record)
+    primary_key = record.fetch(primary_attribute)
+
+    if primary_index.key?(primary_key)
+      raise RecordNotUniqueError, "record already inserted: #{record.inspect}"
+    end
+
+    primary_index[primary_key] = record
+
+    secondary_indices.each do |attribute_name, secondary_index|
+      Array(record[attribute_name]).each do |value|
+        secondary_index[value].add(primary_key)
+      end
+    end
+  end
+
+  def find(identifier)
+    primary_index[identifier]
+  end
+
+  def filter(name, value)
+    return [] unless secondary_indices[name].key?(value)
+
+    secondary_indices.dig(name, value).to_a.map { find(_1) }
+  end
+
+  def update(record)
+    primary_key = record.fetch(primary_attribute)
+
+    delete(primary_key)
+
+    insert(record)
+  end
+
+  def delete(primary_key)
+    record = find(primary_key)
+
+    return if record.nil?
+
+    primary_index.delete(primary_key)
+
+    secondary_indices.each do |attribute_name, index_data|
+      Array(record[attribute_name]).each do |value|
+        index_data[value].delete(primary_key)
+        index_data.delete(value) if index_data[value].empty?
+      end
+    end
+
+    record
+  end
+
+  concerning :TestHelpers do
+    def all
+      primary_index.values
+    end
+
+    def size
+      primary_index.size
+    end
+  end
+end

data/lib/holistic/document/cursor.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Holistic::Document
+  Cursor = ::Data.define(
+    :file_path,
+    :line,
+    :column
+  )
+end

data/lib/holistic/document/file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Holistic::Document
+  class File
+    attr_reader :path
+
+    def initialize(path:)
+      @path = path
+    end
+
+    def read
+      ::File.read(path)
+    end
+
+    def write(content)
+      ::File.write(path, content)
+    end
+
+    class Fake
+      attr_reader :path
+
+      def initialize(path:, content:)
+        @path = path
+        @content = content
+      end
+
+      def read
+        @content
+      end
+
+      def write(content) 
+        @content = content
+      end
+    end
+  end
+end

data/lib/holistic/document/location.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Holistic::Document
+  Location = ::Data.define(
+    :file_path,
+    :start_line,
+    :start_column,
+    :end_line,
+    :end_column
+  ) do
+    def self.beginning_of_file(file_path)
+      new(file_path, 0, 0, 0, 0)
+    end
+
+    def identifier = "#{file_path}[#{start_line},#{start_column},#{end_line},#{end_column}]"
+
+    def contains?(cursor)
+      same_file = cursor.file_path == file_path
+      contains_line = cursor.line >= start_line && cursor.line <= end_line
+      
+      contains_column =
+        if start_line == end_line
+          cursor.column > start_column && cursor.column <= end_column
+        elsif start_line == cursor.line
+          cursor.column > start_column
+        elsif end_line == cursor.line
+          cursor.column <= end_column
+        else
+          true
+        end
+
+      same_file && contains_line && contains_column
+    end
+  end
+end

data/lib/holistic/document/unsaved/change.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Holistic::Document::Unsaved
+  Change = ::Data.define(
+    :range_length,
+    :text,
+    :start_line,
+    :start_column,
+    :end_line,
+    :end_column
+  ) do
+    def insertion?
+      text.size.positive? && start_line == end_line && start_column == end_column
+    end
+
+    def deletion?
+      text.empty? && (start_line != end_line || start_column != end_column)
+    end
+
+    def starts_on?(line, column)
+      start_line == line && start_column == column
+    end
+  end
+end

data/lib/holistic/document/unsaved/collection.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Holistic::Document
+  class Unsaved::Collection
+    def initialize
+      @items = {}
+    end
+
+    def add(path:, content:)
+      @items[path] = Unsaved::Record.new(path:, content:)
+    end
+
+    def delete(path)
+      @items.delete(path)
+    end
+
+    def find(path)
+      @items[path]
+    end
+  end
+end

data/lib/holistic/document/unsaved/record.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Holistic::Document
+  class Unsaved::Record
+    attr_reader :path, :content
+
+    def initialize(path:, content:)
+      @path = path
+      @content = content
+      @original_content = content.dup
+    end
+
+    def expand_code(cursor)
+      line = 0
+      column = 0
+
+      @content.each_char.with_index do |char, index|
+        if cursor.line == line && cursor.column == column + 1
+          token_index = index
+
+          while @content[token_index].match?(/[a-zA-Z0-9_\.:]/)
+            token_index -= 1
+          end
+
+          return @content[token_index+1..index]
+        end
+
+        if char == LINE_BREAK
+          line += 1
+          column = 0
+        else
+          column += 1
+        end
+      end
+
+      nil
+    end
+
+    def mark_as_saved!
+      @original_content = @content.dup
+    end
+
+    def restore_original_content!
+      @content = @original_content.dup
+    end
+
+    def has_unsaved_changes?
+      @original_content != @content
+    end
+
+    LINE_BREAK = "\n"
+
+    def apply_change(change)
+      line = 0
+      column = 0
+
+      @content.each_char.with_index do |char, index|
+        if change.insertion? && change.starts_on?(line, column)
+          content.insert(index, change.text)
+
+          return
+        end
+
+        if change.deletion? && change.starts_on?(line, column)
+          content[index..index + change.range_length - 1] = ""
+
+          return
+        end
+
+        if char == LINE_BREAK
+          line += 1
+          column = 0
+        else
+          column += 1
+        end
+      end
+    end
+
+    def to_file
+      File::Fake.new(path:, content:)
+    end
+  end
+end

data/lib/holistic/extensions/events.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Holistic::Extensions::Events
+  TOPICS = {
+    resolve_method_call_known_scope: {
+      params: [:reference, :referenced_scope, :method_call_clue],
+      output: ::Holistic::Ruby::Scope::Record
+    }
+  }.freeze
+
+  UnknownEvent         = ::Class.new(::StandardError)
+  MissingRequiredParam = ::Class.new(::StandardError)
+  UnexpectedOutput     = ::Class.new(::StandardError)
+
+  def initialize
+    @listeners = Hash.new { |hash, key| hash[key] = [] }
+  end
+
+  def bind(event, &callback)
+    raise UnknownEvent, event unless TOPICS.key?(event)
+
+    @listeners[event] << callback
+  end
+
+  def dispatch(event, params)
+    required_params = TOPICS.dig(event, :params)
+    expected_output = TOPICS.dig(event, :output)
+
+    raise MissingRequiredParam, required_params if (required_params - params.keys).any?
+
+    result = @listeners[event].lazy.filter_map { |callback| callback.call(params) }.first
+
+    raise UnexpectedOutput, result if result.present? && !result.is_a?(expected_output)
+
+    result
+  end
+end

data/lib/holistic/extensions/ruby/stdlib.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Holistic::Extensions::Ruby
+  module Stdlib
+    extend self
+
+    ResolveClassConstructor = ->(application, params) do
+      method_call_clue, referenced_scope = params[:method_call_clue], params[:referenced_scope]
+
+      if method_call_clue.method_name == "new" && referenced_scope.class?
+        initialize_method = "#{referenced_scope.fully_qualified_name}#initialize"
+
+        return application.scopes.find_by_fully_qualified_name(initialize_method)
+      end
+
+      nil
+    end
+
+    ResolveStaticMethods = ->(application, params) do
+      method_call_clue, referenced_scope = params[:method_call_clue], params[:referenced_scope]
+
+      self_method_name = "#{referenced_scope.fully_qualified_name}#self.#{method_call_clue.method_name}"
+
+      application.scopes.find_by_fully_qualified_name(self_method_name)
+    end
+
+    LAMBDA_METHODS = ["call", "curry"]
+
+    ResolveCallToLambda = ->(application, params) do
+      method_call_clue, referenced_scope = params[:method_call_clue], params[:referenced_scope]
+
+      if LAMBDA_METHODS.include?(method_call_clue.method_name) && referenced_scope.lambda?
+        return referenced_scope
+      end
+    end
+
+    def register(application)
+      application.extensions.bind(:resolve_method_call_known_scope, &ResolveClassConstructor.curry[application])
+      application.extensions.bind(:resolve_method_call_known_scope, &ResolveStaticMethods.curry[application])
+      application.extensions.bind(:resolve_method_call_known_scope, &ResolveCallToLambda.curry[application])
+    end
+  end
+end

data/lib/holistic/language_server/current.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "active_support/isolated_execution_state"
+require "active_support/code_generator"
+require "active_support/current_attributes"
+
+module Holistic::LanguageServer
+  class Current < ::ActiveSupport::CurrentAttributes
+    attribute :application, :lifecycle
+  end
+end

data/lib/holistic/language_server/format/file_uri.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Holistic::LanguageServer::Format
+  module FileUri
+    extend self
+
+    def extract_path(file_uri)
+      uri = URI(file_uri)
+
+      return uri.path if uri.is_a?(URI::File)
+
+      nil
+    end
+
+    def from_path(file_path)
+      "file://#{file_path}"
+    end
+  end
+end