yoda-language-server 0.7.0 → 0.8.0

data/lib/yoda/ast/vnode.rb

@@ -0,0 +1,170 @@
+module Yoda
+  module AST
+    # @abstract
+    class Vnode
+      include NamespaceTraversable
+      include MethodTraversable
+      include Traversable
+
+      # @return [Vnode, nil]
+      attr_reader :parent
+
+      # @return [Hash{Parser::AST::Node => Array<Parser::Source::Comment>}]
+      attr_reader :comments_by_node
+
+      # @param parent [Vnode, nil]
+      # @param comment_by_node [Hash{Parser::AST::Node => Array<Parser::Source::Comment>}]
+      def initialize(parent: nil, comments_by_node: {})
+        @parent = parent
+        @comments_by_node = comments_by_node
+      end
+
+      # @return [Array<Vnode>] all nodes between root and self.
+      def nesting
+        @nesting ||= (parent&.nesting || []) + [self]
+      end
+
+      # @param [Parser::AST::Node]
+      # @return [Vnode]
+      def wrap_child(child_node)
+        AST.wrap(child_node, parent: self, comments_by_node: comments_by_node)
+      end
+
+      # @return [Array<Vnode>]
+      def children
+        fail NotImplementedError
+      end
+
+      # @return [boolean]
+      def empty?
+        false
+      end
+
+      # @return [boolean]
+      def present?
+        !empty?
+      end
+
+      def constant?
+        false
+      end
+
+      # @return [Symbol]
+      def type
+        fail NotImplementedError
+      end
+
+      # @return [String]
+      def identifier
+        "#{type}:#{object_id}"
+      end
+
+      # @return [String]
+      def inspect
+        "(#{[identifier, inspect_content].join(' ')})"
+      end
+
+      # @return [String]
+      def inspect_content
+        children.map(&:inspect).join(' ')
+      end
+
+      def try(method_name, *args)
+        respond_to?(method_name) ? send(method_name, *args) : nil
+      end
+      
+      module CommentAssociation
+        # @param comments [Array<::Parser::Source::Comment>]
+        # @return [Hash{Vnode => Array<Parser::Source::Comment>}]
+        def associate_comments(comments)
+          if node = try(:node)
+            Parser::Source::Comment.associate(node, comments).map do |ast_key_node, comments|
+              [all_nodes_lazy.find { |node| node.wrapping?(ast_key_node) }, comments]
+            end.to_h
+          else
+            {}
+          end
+        end
+
+        # @param node [::AST::Node]
+        # @return [boolean]
+        def wrapping?(node)
+          try(:node) && try(:node) == node
+        end
+
+        # @return [Enumerable<Vnode>]
+        def all_nodes_lazy
+          [self, *children].lazy.flat_map { |el| self == el ? self : el.all_nodes_lazy }
+        end
+
+        # @param comment_by_node [Array<Parser::Source::Comment>]
+        def comments
+          @comments ||= comments_by_node[node] || []
+        end
+      end
+      include CommentAssociation
+      
+      module Positional
+        # @return [Parsing::Location, nil]
+        def location
+          source_map && Parsing::Location.of_ast_location(source_map)
+        end
+        
+        # @return [Range, nil]
+        def range
+          source_map && Parsing::Range.of_ast_location(source_map)
+        end
+        
+        # @return [Parser::Source::Map, nil]
+        def source_map
+          nil
+        end
+
+        # @param target [Parsing::Location, Parsing::Range, nil]
+        # @return [boolean]
+        def positionally_include?(target)
+          range && range.include?(target)
+        end
+
+        # @param target [Location, Range, nil]
+        # @return [Vnode]
+        def positionally_nearest_child(target)
+          if positionally_include?(target)
+            children.find { |child| child.positionally_include?(target) }&.positionally_nearest_child(target) || self
+          else
+            nil
+          end
+        end
+      end
+      include Positional
+
+      module CommentPositional
+        # @return [Hash{Vnode => CommentBlock}]
+        def comments_by_vnode
+          @comments_by_vnode ||= begin
+            node_map = all_nodes_lazy.map { |vnode| vnode.respond_to?(:node) ? [vnode.node, vnode] : nil }.to_a.compact.to_h
+            comments_by_node.map do |node, comments|
+              vnode = node_map[node]
+              vnode ? [vnode, CommentBlock.new(comments, node: vnode)] : nil
+            end.compact.to_h
+          end
+        end
+
+        # @param location [Location]
+        # @return [CommentBlock, nil]
+        def positionally_nearest_comment(location)
+          comments_by_vnode.find do |(node, comment_block)|
+            comment_block.range.include?(location)
+          end&.last
+        end
+
+        # @param location [Location]
+        # @return [Vnode, nil]
+        def positionally_nearest_commenting_node(location)
+          positionally_nearest_comment(location)&.node
+        end
+      end
+      include CommentPositional
+    end
+  end
+end

data/lib/yoda/ast/when_node.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module AST
+    class WhenNode < Node
+      # @return [Array<Node>]
+      def matchers
+        children.slice(0..-2) || []
+      end
+
+      # @return [Node]
+      def body
+        children.last
+      end
+    end
+  end
+end

data/lib/yoda/ast.rb

@@ -0,0 +1,140 @@
+module Yoda
+  module AST
+    require 'yoda/ast/traversable'
+    require 'yoda/ast/method_traversable'
+    require 'yoda/ast/namespace_traversable'
+    require 'yoda/ast/namespace'
+    require 'yoda/ast/vnode'
+    require 'yoda/ast/node'
+    require 'yoda/ast/comment_block'
+
+    require 'yoda/ast/array_node'
+    require 'yoda/ast/assignment_node'
+    require 'yoda/ast/block_call_node'
+    require 'yoda/ast/block_node'
+    require 'yoda/ast/case_node'
+    require 'yoda/ast/center_operator_node'
+    require 'yoda/ast/class_node'
+    require 'yoda/ast/conditional_loop_node'
+    require 'yoda/ast/constant_assignment_node'
+    require 'yoda/ast/constant_node'
+    require 'yoda/ast/def_node'
+    require 'yoda/ast/def_singleton_node'
+    require 'yoda/ast/empty_vnode'
+    require 'yoda/ast/ensure_node'
+    require 'yoda/ast/for_node'
+    require 'yoda/ast/hash_node'
+    require 'yoda/ast/if_node'
+    require 'yoda/ast/interpolation_text_node'
+    require 'yoda/ast/kwsplat_node'
+    require 'yoda/ast/left_operator_node'
+    require 'yoda/ast/literal_node'
+    require 'yoda/ast/module_node'
+    require 'yoda/ast/multiple_left_hand_side_node'
+    require 'yoda/ast/name_vnode'
+    require 'yoda/ast/optional_parameter_node'
+    require 'yoda/ast/pair_node'
+    require 'yoda/ast/parameter_node'
+    require 'yoda/ast/parameters_node'
+    require 'yoda/ast/rescue_node'
+    require 'yoda/ast/rescue_clause_node'
+    require 'yoda/ast/root_vnode'
+    require 'yoda/ast/send_node'
+    require 'yoda/ast/singleton_class_node'
+    require 'yoda/ast/special_call_node'
+    require 'yoda/ast/value_vnode'
+    require 'yoda/ast/variable_node'
+    require 'yoda/ast/when_node'
+
+    class << self
+      # @param node [::AST::Node]
+      # @param parent [Vnode]
+      # @param comment_by_node [Hash{Parser::AST::Node => Array<Parser::Source::Comment>}]
+      # @return [Yoda::AST::Node]
+      def wrap(node, parent: nil, comments_by_node: {})
+        if parent
+          wrapper_class_for(node).new(node, parent: parent, comments_by_node: comments_by_node)
+        else
+          RootVnode.new(node, comments_by_node: comments_by_node).content
+        end
+      end
+
+      # @param node [::AST::Node]
+      def wrapper_class_for(node)
+        return EmptyVnode unless node
+        return NameVnode if node.is_a?(Symbol)
+        return ValueVnode unless node.respond_to?(:type)
+        case node.type
+        when :lvasgn, :ivasgn, :cvasgn, :gvasgn, :masgn, :op_asgn, :or_asgn, :and_asgn
+          AssignmentNode
+        when :casgn
+          ConstantAssignmentNode
+        when :not
+          LeftOperatorNode
+        when :and, :or
+          CenterOperatorNode
+        when :if
+          IfNode
+        when :case
+          CaseNode
+        when :const
+          ConstantNode
+        when :while, :until, :while_post, :until_post
+          ConditionalLoopNode
+        when :for
+          ForNode
+        when :super, :zsuper, :yield, :return, :break, :next, :self, :defined?, :redo, :undef
+          SpecialCallNode
+        when :ensure
+          EnsureNode
+        when :rescue
+          RescueNode
+        when :resbody
+          RescueClauseNode
+        when :csend, :send
+          SendNode
+        when :block
+          BlockCallNode
+        when :const
+          ConstantNode
+        when :lvar, :cvar, :ivar, :gvar
+          VariableNode
+        when :begin, :kwbegin, :block
+          BlockNode
+        when :dstr, :dsym, :xstr
+          InterpolationTextNode
+        when :args
+          ParametersNode
+        when :arg, :shadowarg, :restarg, :blockarg, :kwarg, :kwrestarg
+          ParameterNode
+        when :optarg, :kwoptarg
+          OptionalParameterNode
+        when :mlhs
+          MultipleLeftHandSideNode
+        when :def
+          DefNode
+        when :defs
+          DefSingletonNode
+        when :hash
+          HashNode
+        when :array
+          ArrayNode
+        when :pair
+          PairNode
+        when :module
+          ModuleNode
+        when :class
+          ClassNode
+        when :sclass
+          SingletonClassNode
+        when :kwsplat
+          KwsplatNode
+        when :int, :float, :complex, :rational, :str, :string, :sym
+          LiteralNode
+        else
+          Node
+        end
+      end
+    end
+  end
+end

data/lib/yoda/cli/analyze_deps.rb

@@ -0,0 +1,102 @@
+module Yoda
+  module Cli
+    class AnalyzeDeps
+      # @param root_path [String]
+      def self.run(root_path)
+        require 'json'
+        require 'bundler'
+
+        builder = Builder.new(root_path)
+        puts JSON.dump(builder)
+      end
+
+      class Builder
+        # @return [String]
+        attr_reader :root_path
+
+        # @param root_path [String]
+        def initialize(root_path)
+          @root_path = root_path
+        end
+
+        # @return [Array<Yoda::Store::Objects::Library::Gem>]
+        def gems
+          @gems ||= dependency_specs.map { |spec| Yoda::Store::Objects::Library::Gem.from_gem_spec(spec) }
+        end
+
+        def to_h
+          {
+            path: root_path,
+            dependencies: gems.map(&:to_h),
+          }
+        end
+
+        def to_json(*)
+          to_h.to_json
+        end
+
+        private
+
+        # @return [Array<Bundler::StubSpecification>]
+        def dependency_specs
+          @dependency_specs ||= begin
+            (gem_specs || [])
+              .reject { |spec| self_spec?(spec) || metadata?(spec) }
+          end
+        end
+
+        # @return [Array<Bundler::LazySpecification>, nil]
+        def gem_specs
+          @gem_specs ||= begin
+            Dir.chdir(root_path) do
+              with_unbundled_env do
+                # Suppress bundler outputs to stdout.
+                Bundler.ui = Bundler::UI::Silent.new
+
+                Bundler.reset!
+
+                if File.exists?("Gemfile")
+                  # Resolve dependencies of uninstalled gems and ensure remote sources are available.
+                  Bundler.definition.resolve_remotely!
+                  spec_set = Bundler.definition.resolve
+
+                  if Gem::Version.new(Bundler::VERSION) >= Gem::Version.new('2.2.25')
+                    deps = Bundler.definition.requested_dependencies
+                    spec_set.materialize(deps).to_a
+                  else
+                    # For backward compatibility (Ref: https://github.com/rubygems/rubygems/pull/4788)
+                    deps = Bundler.definition.send(:requested_dependencies)
+                    missing = []
+                    materialized = spec_set.materialize(deps, missing)
+                    materialized.to_a + missing
+                  end
+                else
+                  []
+                end
+              end
+            end
+          end
+        end
+
+        # @param [Gem::Specification]
+        def metadata?(spec)
+          spec.source.is_a?(Bundler::Source::Metadata)
+        end
+
+        # @param [Gem::Specification]
+        def self_spec?(spec)
+          spec.source.is_a?(Bundler::Source::Path) && (File.expand_path(spec.source.path) == File.expand_path(root_path))
+        end
+
+        def with_unbundled_env(&block)
+          if Bundler.respond_to?(:with_unbundled_env)
+            Bundler.with_unbundled_env(&block)
+          else
+            # For backward compatibility (This method is introduced at bundler 2.1.0: https://github.com/rubygems/bundler/pull/6843)
+            Bundler.with_clean_env(&block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yoda/{commands → cli}/base.rb

@@ -1,5 +1,5 @@
 module Yoda
-  module Commands
+  module Cli
     # @abstract
     class Base
       def self.run(*args)

data/lib/yoda/{commands → cli}/complete.rb

@@ -1,5 +1,5 @@
 module Yoda
-  module Commands
+  module Cli
     class Complete < Base
       include FileCursorParsable
 
@@ -11,25 +11,28 @@ module Yoda
       end
 
       def run
-        project.build_cache
-        puts create_signature_help(worker.current_node_signature)
+        project.setup
+        puts create_completions(worker.candidates)
       end
 
       private
 
-      # @param signature [Model::NodeSignature, nil]
+      # @param completion_item [Model::CompletionItem]
       # @return [String, nil]
-      def create_signature_help(signature)
-        return nil unless signature
-        signature.descriptions.map(&:title).join("\n")
+      def create_completions(completion_item)
+        completion_item.join("\n")
       end
 
       def worker
-        @worker ||= Evaluation::CurrentNodeExplain.new(project.registry, File.read(filename), position)
+        @worker ||= Services::CodeCompletion.new(project.environment, source, position)
       end
 
       def project
-        @project ||= Store::Project.new(Dir.pwd)
+        @project ||= Store::Project.for_path(Dir.pwd)
+      end
+
+      def source
+        Parsing.fix_parse_error(source: File.read(filename), location: position)
       end
     end
   end

data/lib/yoda/cli/console.rb

@@ -0,0 +1,17 @@
+module Yoda
+  module Cli
+    class Console < Base
+      def run
+        require "pry"
+        project.setup
+        project.pry
+      end
+
+      private
+
+      def project
+        @project ||= Store::Project.for_path(Dir.pwd)
+      end
+    end
+  end
+end

data/lib/yoda/{commands → cli}/file_cursor_parsable.rb

@@ -1,5 +1,5 @@
 module Yoda
-  module Commands
+  module Cli
     # Provide parsing methods of positon representation with the format `path/to/file:line_num:character_num`
     module FileCursorParsable
       private

data/lib/yoda/{commands → cli}/infer.rb

@@ -1,5 +1,5 @@
 module Yoda
-  module Commands
+  module Cli
     class Infer < Base
       attr_reader :filename_with_position
 
@@ -9,7 +9,7 @@ module Yoda
       end
 
       def run
-        project.build_cache
+        project.setup
         puts create_signature_help(worker.current_node_signature)
       end
 
@@ -23,11 +23,11 @@ module Yoda
       end
 
       def worker
-        @worker ||= Evaluation::CurrentNodeExplain.new(project.registry, File.read(filename), position)
+        @worker ||= Services::CurrentNodeExplain.from_source(registry: project.registry, source: File.read(filename), location: position)
       end
 
       def project
-        @project ||= Store::Project.new(Dir.pwd)
+        @project ||= Store::Project.for_path(Dir.pwd)
       end
 
       def filename

data/lib/yoda/cli.rb

@@ -0,0 +1,117 @@
+require 'thor'
+
+module Yoda
+  # Cli module has handler for each cli command.
+  module Cli
+    require 'yoda/cli/analyze_deps'
+    require 'yoda/cli/base'
+    require 'yoda/cli/file_cursor_parsable'
+    require 'yoda/cli/infer'
+    require 'yoda/cli/complete'
+    require 'yoda/cli/console'
+
+    class << self
+      # @return [String]
+      def exe_dir
+        File.expand_path('../../exe', __dir__)
+      end
+
+      # @return [String]
+      def yoda_exe
+        File.expand_path('./yoda', exe_dir)
+      end
+    end
+
+    class Top < Thor
+      class_option :log_level, type: :string, desc: 'Set log level (debug info warn error fatal)'
+      class_option :profile, type: :boolean, desc: 'Set log level (debug info warn error fatal)'
+      class_option :help, type: :boolean, desc: 'Show help', aliases: :h,  hide: true
+
+      desc 'setup', 'Setup indexes for current Ruby version and project gems'
+      option :force_build, type: :boolean, desc: "If enabled, (re)build current project's index forcibly"
+      def setup
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Instrument.instance.hear(initialization_progress: method(:on_progress), registry_dump: method(:on_progress)) do
+          Store.setup(dir: Dir.pwd, force_build: options[:force_build])
+        end
+      end
+
+      desc 'infer POSITION', 'Infer the type of value at the specified position'
+      def infer(position)
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Cli::Infer.run(position)
+      end
+
+      desc 'complete POSITION', 'Provide completion candidates for the specified position'
+      def complete(position)
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Cli::Complete.run(position)
+      end
+
+      desc 'console', 'Launch debug console'
+      def console
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Cli::Console.run
+      end
+
+      desc 'server', 'Start Language Server'
+      def server
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Server.new.run
+      end
+
+      desc 'analyze-deps PATH', 'Analyze dependencies of the given path'
+      def analyze_deps(path)
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        Cli::AnalyzeDeps.run(path)
+      end
+
+      desc 'version', 'show current version'
+      def version
+        process_class_options
+        return self.class.command_help(shell, __method__) if options[:help]
+        say "#{Yoda::VERSION}"
+      end
+
+      private
+
+      def process_class_options
+        set_log_level
+        use_profiler_if_enabled
+      end
+
+      def set_log_level
+        Yoda::Logger.log_level = options[:log_level].to_sym if options[:log_level]
+      end
+
+      def use_profiler_if_enabled
+        if options[:profile]
+          require 'stackprof'
+          require 'securerandom'
+          Logger.info('Enabled profiler')
+          StackProf.start(mode: :wall, raw: true)
+
+          at_exit do
+            StackProf.stop
+            tmpfile_path = File.expand_path(SecureRandom.hex(12), Dir.tmpdir)
+            StackProf.results(tmpfile_path)
+            Logger.fatal("Dumped file to: #{tmpfile_path}")
+          end
+        end
+      end
+
+      def on_progress(phase: :save_keys, index: nil, length: nil, **params)
+        return unless index
+        @bars ||= {}
+        @bar = @bars[phase] ||= ProgressBar.create(format: "%t: %c/%C |%w>%i| %e ", title: phase.to_s.gsub('_', ' '), starting_at: index, total: length)
+        @bar.progress = index if index <= @bar.total
+      end
+    end
+  end
+end

data/lib/yoda/has_services.rb

@@ -0,0 +1,40 @@
+module Yoda
+  module HasServices
+    module ClassMethods
+      # Register a service with the specified name
+      # @params name [String]
+      def service(name, &block)
+        service_hub_class.register_service(name, &block)
+        define_method(:"#{name}_service") { services.public_send(name) }
+      end
+
+      # @return [Class<ServiceHub>]
+      def service_hub_class
+        @service_hub_class ||= Class.new(ServiceHub)
+      end
+    end
+
+    class ServiceHub
+      attr_reader :instance
+
+      def initialize(instance)
+        @instance = instance
+      end
+
+      def self.register_service(name, &block)
+        define_method(name) do
+          instance.instance_exec(instance, &block)
+        end
+      end
+    end
+
+    # @return [ServiceHub]
+    def services
+      @services ||= self.class.service_hub_class.new(self)
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+  end
+end