yoda-language-server 0.4.0

data/lib/yoda/server/definition_provider.rb

@@ -0,0 +1,36 @@
+module Yoda
+  class Server
+    class DefinitionProvider
+      # @type ClientInfo
+      attr_reader :client_info
+
+      # @param client_info [ClientInfo]
+      def initialize(client_info)
+        @client_info = client_info
+      end
+
+      # @param uri      [String]
+      # @param position [{Symbol => Integer}]
+      # @param include_declaration [Boolean]
+      def provide(uri, position, include_declaration = false)
+        source = client_info.file_store.get(uri)
+        location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
+
+        node_worker = Evaluation::CurrentNodeExplain.new(client_info.registry, source, location)
+        references = node_worker.defined_files
+        references.map { |(path, line, column)| create_location(path, line, column) }
+      end
+
+      # @param path [String]
+      # @param line [Integer]
+      # @param column [Integer]
+      def create_location(path, line, column)
+        location = Parsing::Location.new(row: line - 1, column: column)
+        LSP::Interface::Location.new(
+          uri: client_info.uri_of_path(path),
+          range: LSP::Interface::Range.new(Parsing::Range.new(location, location).to_language_server_protocol_range),
+        )
+      end
+    end
+  end
+end

data/lib/yoda/server/deserializer.rb

@@ -0,0 +1,27 @@
+require 'ostruct'
+
+module Yoda
+  class Server
+    class Deserializer
+      def initialize
+      end
+
+      # @param params [Hash]
+      def deserialize(params)
+        Hash[params.map { |key, value| [snakenize(key), deserialize_value(value)] }]
+      end
+
+      # @param params [any]
+      def deserialize_value(value)
+        return deserialize(value) if value.is_a?(Hash)
+        return value.map { |el| deserialize_value(el) } if value.is_a?(Enumerable)
+        value
+      end
+
+      # @param str [Symbol]
+      def snakenize(str)
+        str.to_s.gsub(/([A-Z])/, '_\1').downcase.to_sym
+      end
+    end
+  end
+end

data/lib/yoda/server/hover_provider.rb

@@ -0,0 +1,38 @@
+module Yoda
+  class Server
+    class HoverProvider
+      attr_reader :client_info
+
+      # @param client_info [ClientInfo]
+      def initialize(client_info)
+        @client_info = client_info
+      end
+
+      # @param uri      [String]
+      # @param position [{Symbol => Integer}]
+      def request_hover(uri, position)
+        source = client_info.file_store.get(uri)
+        location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
+
+        node_worker = Evaluation::CurrentNodeExplain.new(client_info.registry, source, location)
+
+        current_node_signature = node_worker.current_node_signature
+        create_hover(current_node_signature) if current_node_signature
+      end
+
+      # @param signature [Evaluation::NodeSignature]
+      def create_hover(signature)
+        LSP::Interface::Hover.new(
+          contents: signature.descriptions.map { |value| create_hover_text(value) },
+          range: LSP::Interface::Range.new(signature.node_range.to_language_server_protocol_range),
+        )
+      end
+
+      # @param description [Evaluation::Descriptions::Base]
+      # @return [String]
+      def create_hover_text(description)
+        description.to_markdown
+      end
+    end
+  end
+end

data/lib/yoda/server/signature_provider.rb

@@ -0,0 +1,46 @@
+module Yoda
+  class Server
+    class SignatureProvider
+      attr_reader :client_info
+
+      # @param client_info [ClientInfo]
+      def initialize(client_info)
+        @client_info = client_info
+      end
+
+      # @param uri      [String]
+      # @param position [{Symbol => Integer}]
+      def provide(uri, position)
+        source = client_info.file_store.get(uri)
+        location = Parsing::Location.of_language_server_protocol_position(line: position[:line], character: position[:character])
+        cut_source = Parsing::SourceCutter.new(source, location).error_recovered_source
+
+        signature_worker = Evaluation::SignatureDiscovery.new(client_info.registry, cut_source, location)
+
+        functions = signature_worker.method_candidates
+        create_signature_help(functions)
+      end
+
+      # @param code_objects [Array<Model::FunctionSignatures::Base>]
+      def create_signature_help(functions)
+        signatures = functions.map { |func| Model::Descriptions::FunctionDescription.new(func) }
+        LSP::Interface::SignatureHelp.new(
+          signatures: signatures.map { |signature| create_signature_info(signature) },
+        )
+      end
+
+      # @param signature [Evaluation::Descriptions::FunctionDescription]
+      def create_signature_info(signature)
+        LSP::Interface::SignatureInformation.new(
+          label: signature.title.to_s,
+          documentation: signature.to_markdown,
+          parameters: signature.parameter_names.map do |parameter|
+            LSP::Interface::ParameterInformation.new(
+              label: parameter,
+            )
+          end,
+        )
+      end
+    end
+  end
+end

data/lib/yoda/store.rb

@@ -0,0 +1,13 @@
+require 'yard'
+
+module Yoda
+  module Store
+    require 'yoda/store/actions'
+    require 'yoda/store/adapters'
+    require 'yoda/store/project'
+    require 'yoda/store/registry'
+    require 'yoda/store/objects'
+    require 'yoda/store/query'
+    require 'yoda/store/yard_importer'
+  end
+end

data/lib/yoda/store/actions.rb

@@ -0,0 +1,10 @@
+module Yoda
+  module Store
+    module Actions
+      require 'yoda/store/actions/import_core_library'
+      require 'yoda/store/actions/import_gems'
+      require 'yoda/store/actions/read_file'
+      require 'yoda/store/actions/read_project_files'
+    end
+  end
+end

data/lib/yoda/store/actions/import_core_library.rb

@@ -0,0 +1,30 @@
+module Yoda
+  module Store
+    module Actions
+      class ImportCoreLibrary
+        # @return [Registry]
+        attr_reader :registry
+
+        def initialize(registry)
+          @registry = registry
+        end
+
+        def run
+          load_core_patches.each do |patch|
+            registry.add_patch(patch)
+          end
+        end
+
+        private
+
+        def load_core_patches
+          core_doc_files.map { |yardoc_file| YardImporter.import(yardoc_file) }
+        end
+
+        def core_doc_files
+          %W(.yoda/sources/ruby-#{RUBY_VERSION}/.yardoc .yoda/sources/ruby-#{RUBY_VERSION}/.yardoc-stdlib).map { |path| File.expand_path(path, '~') }.select { |path| File.exist?(path) }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/actions/import_gems.rb

@@ -0,0 +1,91 @@
+require 'open3'
+
+module Yoda
+  module Store
+    module Actions
+      class ImportGems
+        # @return [Registry]
+        attr_reader :registry
+
+        # @return [Array<Bundler::LazySpecification>]
+        attr_reader :gem_specs
+
+        # @param registry [Registry]
+        # @param gem_specs [Array<Bundler::LazySpecification>]
+        def initialize(registry, gem_specs)
+          @registry = registry
+          @gem_specs = gem_specs
+        end
+
+        # @return [void]
+        def run
+          create_dependency_docs
+          gem_specs.map do |gem|
+            if yardoc_file = yardoc_file_for_gem(gem)
+              if patch = load_yardoc(yardoc_file, gem_path_for(gem))
+                registry.add_patch(patch)
+              end
+            end
+          end
+        end
+
+        private
+
+        def create_dependency_docs
+          gem_specs.each do |gem|
+            if yardoc_file_for_gem(gem)
+              STDERR.puts "Gem docs for #{gem.name} #{gem.version} already exist"
+              next
+            end
+            STDERR.puts "Building gem docs for #{gem.name} #{gem.version}"
+            begin
+              o, e = Open3.capture2e("yard gems #{gem.name} #{gem.version}")
+              STDERR.puts o unless o.empty?
+              if e.success?
+                STDERR.puts "Done building gem docs for #{gem.name} #{gem.version}"
+              else
+                STDERR.puts "Failed to build #{gem.name} #{gem.version}"
+              end
+            rescue => ex
+              STDERR.puts ex
+              STDERR.puts ex.backtrace
+              STDERR.puts "Failed to build #{gem.name} #{gem.version}"
+            end
+          end
+        end
+
+        # @param gem [Bundler::LazySpecification]
+        # @return [String, nil]
+        def yardoc_file_for_gem(gem)
+          YARD::Registry.yardoc_file_for_gem(gem.name, gem.version)
+        rescue Bundler::BundlerError => ex
+          STDERR.puts ex
+          STDERR.puts ex.backtrace
+          nil
+        end
+
+        # @param yardoc_file [String]
+        # @param gem_source_path [String]
+        # @return [Objects::Patch, nil]
+        def load_yardoc(yardoc_file, gem_source_path)
+          begin
+            YardImporter.import(yardoc_file, root_path: gem_source_path)
+          rescue => ex
+            STDERR.puts ex
+            STDERR.puts ex.backtrace
+            STDERR.puts "Failed to load #{yardoc_file}"
+            nil
+          end
+        end
+
+        # @param gem [Bundler::LazySpecification]
+        # @return [String, nil]
+        def gem_path_for(gem)
+          if spec = Gem.source_index.find_name(gem.name).first
+            spec.full_gem_path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/actions/read_file.rb

@@ -0,0 +1,36 @@
+module Yoda
+  module Store
+    module Actions
+      class ReadFile
+        # @return [Registry]
+        attr_reader :registry
+
+        # @return [String]
+        attr_reader :file
+
+        # @param registry [Registry]
+        # @param file [String]
+        # @return [void]
+        def self.run(registry, file, root_path: nil)
+          self.new(registry, file, root_path: root_path).run
+        end
+
+        # @param registry [Registry]
+        # @param file [String]
+        def initialize(registry, file, root_path: nil)
+          @registry = registry
+          @file = file
+          @root_path = root_path
+        end
+
+        # @return [void]
+        def run
+          YARD::Registry.clear
+          YARD.parse([file])
+          patch = YardImporter.new(file).import(YARD::Registry.all + [YARD::Registry.root]).patch
+          registry.add_patch(patch)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/actions/read_project_files.rb

@@ -0,0 +1,29 @@
+module Yoda
+  module Store
+    module Actions
+      class ReadProjectFiles
+        # @return [Registry]
+        attr_reader :registry
+
+        # @return [String]
+        attr_reader :root_path
+
+        def initialize(registry, root_path)
+          @registry = registry
+          @root_path = root_path
+        end
+
+        def run
+          project_files.each { |file| ReadFile.run(registry, file) }
+        end
+
+        private
+
+        # @return [Array<String>]
+        def project_files
+          Dir.chdir(root_path) { Dir.glob("{lib,app}/**/*.rb\0ext/**/*.c\0.yoda/*.rb").map { |name| File.expand_path(name, root_path) } }
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/adapters.rb

@@ -0,0 +1,14 @@
+module Yoda
+  module Store
+    module Adapters
+      require 'yoda/store/adapters/base'
+      require 'yoda/store/adapters/leveldb_adapter'
+      require 'yoda/store/adapters/lmdb_adapter'
+
+      # @return [Base.class]
+      def self.default_adapter_class
+        LmdbAdapter
+      end
+    end
+  end
+end

data/lib/yoda/store/adapters/base.rb

@@ -0,0 +1,58 @@
+module Yoda
+  module Store
+    module Adapters
+      # @abstract
+      class Base
+        # @abstract
+        def self.for(path)
+          fail NotImplementedError
+        end
+
+        # @abstract
+        def self.type
+          fail NotImplementedError
+        end
+
+        # @abstract
+        def get(address)
+          fail NotImplementedError
+        end
+
+        # @abstract
+        def put(address, object)
+          fail NotImplementedError
+        end
+
+        # @abstract
+        def delete(address)
+          fail NotImplementedError
+        end
+
+        # @abstract
+        def exist?(address)
+          fail NotImplementedError
+        end
+
+        # @abstract
+        def keys
+          fail NotImplementedError
+        end
+
+        # @abstract
+        def stats
+          fail NotImplementedError
+        end
+
+        # @abstract
+        def sync
+          fail NotImplementedError
+        end
+
+        # @abstract
+        def clear
+          fail NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/yoda/store/adapters/leveldb_adapter.rb

@@ -0,0 +1,80 @@
+require 'leveldb'
+require 'json'
+
+module Yoda
+  module Store
+    module Adapters
+      class LeveldbAdapter < Base
+        class << self
+          def for(path)
+            @pool ||= {}
+            @pool[path] || (@pool[path] = new(path))
+          end
+
+          def type
+            :leveldb
+          end
+        end
+
+        # @param path [String] represents the path to store db.
+        def initialize(path)
+          @path = path
+          @db = LevelDB::DB.new(path, compression: true)
+
+          at_exit { @db.closed? || @db.close }
+        end
+
+        # @param address [String]
+        # @return [any]
+        def get(address)
+          JSON.load(@db.get(address.to_s), symbolize_names: true)
+        end
+
+        # @param address [String]
+        # @param object [Object]
+        # @return [void]
+        def put(address, object)
+          @db.put(address.to_s, object.to_json)
+        end
+
+        # @param data [Enumerator<(String, Object)>]
+        # @param bar [ProgressBar, nil]
+        def batch_write(data, bar)
+          data.each do |(k, v)|
+            @db.put(k, v)
+            bar&.increment
+          end
+        end
+
+        # @param address [String]
+        # @return [void]
+        def delete(address)
+          @db.delete(address.to_s)
+        end
+
+        # @param address [String]
+        # @return [true, false]
+        def exist?(address)
+          @db.exists?(address.to_s)
+        end
+
+        # @return [Array<String>]
+        def keys
+          @db.keys
+        end
+
+        def stats
+          @db.stats
+        end
+
+        def clear
+          @db.destroy!
+        end
+
+        def sync
+          # nop
+        end
+      end
+    end
+  end
+end