solargraph 0.32.5 → 0.33.0

data/lib/solargraph/live_map.rb

@@ -1,126 +0,0 @@
-module Solargraph
-  # The LiveMap allows extensions to add their own completion suggestions.
-  #
-  class LiveMap
-    autoload :Cache, 'solargraph/live_map/cache'
-
-    @@plugin_registry = {}
-
-    # @return [Solargraph::ApiMap]
-    attr_reader :api_map
-
-    # @param api_map [Solargraph::ApiMap]
-    def initialize api_map
-      @api_map = api_map
-      runners
-    end
-
-    def get_path_pin path
-      cache.get_path_pin(path)
-    end
-
-    # @return [Array<Solargraph::Pin::Base>]
-    def get_methods(namespace, root = '', scope = 'instance', with_private = false)
-      fqns = api_map.qualify(namespace, root)
-      params = {
-        namespace: namespace, root: root, scope: scope, with_private: with_private
-      }
-      cached = cache.get_methods(params)
-      return cached unless cached.nil?
-      did_runtime = false
-      result = []
-      runners.each do |p|
-        next if did_runtime and p.runtime?
-        p.get_methods(namespace: namespace, root: root, scope: scope, with_private: with_private).each do |m|
-          result.push Solargraph::Pin::Method.new(nil, namespace, m['name'], YARD::Docstring.new('(defined at runtime)'), scope.to_sym, nil, [])
-        end
-        did_runtime = true if p.runtime?
-      end
-      cache.set_methods(params, result)
-      result
-    end
-
-    # @return [Array<Solargraph::Pin::Base>]
-    def get_constants(namespace, root = '')
-      cached = cache.get_constants(namespace, root)
-      return cached unless cached.nil?
-      did_runtime = false
-      result = []
-      runners.each do |p|
-        next if did_runtime and p.runtime?
-        result.concat p.get_constants(namespace, root)
-        did_runtime = true if p.runtime?
-      end
-      suggestions = []
-      result.uniq.each do |r|
-        path = (r['namespace'].empty? ? '' : "#{r['namespace']}::") + r['name']
-        kind = Pin::CONSTANT
-        if r['class'] == 'Class'
-          suggestions.push Pin::Namespace.new(nil, r['namespace'], r['name'], YARD::Docstring.new("(defined at runtime)"), :class, :public, nil)
-        elsif r['class'] == 'Module'
-          suggestions.push Pin::Namespace.new(nil, r['namespace'], r['name'], YARD::Docstring.new("(defined at runtime)"), :module, :public, nil)
-        else
-          suggestions.push Pin::Constant.new(nil, r['namespace'], r['name'], YARD::Docstring.new("(defined at runtime"), nil, nil, nil, :public)
-        end
-      end
-      cache.set_constants(namespace, root, suggestions)
-      suggestions
-    end
-
-    def get_fqns(namespace, root)
-      did_runtime = false
-      runners.each do |p|
-        next if did_runtime and p.runtime?
-        result = p.get_fqns(namespace, root)
-        return result unless result.nil?
-        did_runtime = true if p.runtime?
-      end
-      nil
-    end
-
-    def self.register name, klass
-      raise ArgumentError.new("A Solargraph plugin named #{name} already exists") if @@plugin_registry.has_key?(name)
-      @@plugin_registry[name] = klass
-    end
-
-    def refresh
-      changed = false
-      runners.each do |p|
-        changed ||= p.refresh
-      end
-      if changed
-        Solargraph::Logging.logger.debug "Resetting LiveMap cache"
-        cache.clear
-        get_constants('')
-        get_methods('', '', 'class')
-        get_methods('', '', 'instance')
-        get_methods('Kernel', '', 'class')
-        get_methods('Kernel', '', 'instance')
-      end
-    end
-
-    private
-
-    # @return [Solargraph::LiveMap::Cache]
-    def cache
-      @cache ||= Solargraph::LiveMap::Cache.new
-    end
-
-    # @return [Array<Solargraph::Plugin::Base>]
-    def runners
-      @runners ||= load_runners
-    end
-
-    # @return [Array<Solargraph::Plugin::Base>]
-    def load_runners
-      result = []
-      api_map.workspace.config.plugins.each do |name|
-        r = @@plugin_registry[name].new(api_map)
-        result.push r
-      end
-      result
-    end
-  end
-end
-
-Solargraph::LiveMap.register 'runtime', Solargraph::Plugin::Runtime

data/lib/solargraph/live_map/cache.rb

@@ -1,38 +0,0 @@
-module Solargraph
-  class LiveMap
-    class Cache
-      def initialize
-        @method_cache = {}
-        @constant_cache = {}
-        @path_cache = {}
-      end
-
-      def get_methods options
-        @method_cache[options]
-      end
-
-      def set_methods options, values
-        @method_cache[options] = values
-        values.each { |pin| @path_cache[pin.path] = pin }
-      end
-
-      def get_constants namespace, root
-        @constant_cache[[namespace, root]]
-      end
-
-      def set_constants namespace, root, values
-        @constant_cache[[namespace, root]] = values
-      end
-
-      def get_path_pin path
-        @path_cache[path]
-      end
-
-      def clear
-        @method_cache.clear
-        @constant_cache.clear
-        @path_cache.clear
-      end
-    end
-  end
-end

data/lib/solargraph/pin/block_parameter.rb

@@ -1,103 +0,0 @@
-module Solargraph
-  module Pin
-    class BlockParameter < Base
-      include Localized
-
-      # @return [Pin::Block]
-      attr_reader :block
-
-      def initialize location, namespace, name, comments, block
-        super(location, namespace, name, comments)
-        @block = block
-        @presence = block.location.range
-      end
-
-      # @return [Integer]
-      def kind
-        Pin::BLOCK_PARAMETER
-      end
-
-      # @return [Integer]
-      def completion_item_kind
-        Solargraph::LanguageServer::CompletionItemKinds::VARIABLE
-      end
-
-      # @return [Integer]
-      def symbol_kind
-        Solargraph::LanguageServer::SymbolKinds::VARIABLE
-      end
-
-      # The parameter's zero-based location in the block's signature.
-      #
-      # @return [Integer]
-      def index
-        block.parameters.index(self)
-      end
-
-      def nearly? other
-        return false unless super
-        block.nearly?(other.block)
-      end
-
-      def try_merge! other
-        return false unless super
-        @block = other.block
-        @presence = other.block.location.range
-        @return_complex_type = nil
-        true
-      end
-
-      # @return [Array<Solargraph::ComplexType>]
-      def return_complex_type
-        if @return_complex_type.nil?
-          @return_complex_type = ComplexType.new
-          found = nil
-          params = block.docstring.tags(:param)
-          params.each do |p|
-            next unless p.name == name
-            found = p
-            break
-          end
-          if found.nil? and !index.nil?
-            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
-          end
-          @return_complex_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
-        end
-        super
-        @return_complex_type
-      end
-
-      def context
-        block
-      end
-
-      # @param api_map [ApiMap]
-      def typify api_map
-        # @todo Does anything need to be eliminated because it's more accurately a probe?
-        type = super
-        return type unless type.undefined?
-        chain = Source::NodeChainer.chain(block.receiver, filename)
-        clip = api_map.clip_at(location.filename, location.range.start)
-        locals = clip.locals - [self]
-        meths = chain.define(api_map, block, locals)
-        meths.each do |meth|
-          if (Solargraph::CoreFills::METHODS_WITH_YIELDPARAM_SUBTYPES.include?(meth.path))
-            bmeth = chain.base.define(api_map, context, locals).first
-            return ComplexType::UNDEFINED if bmeth.nil? or bmeth.return_complex_type.undefined? or bmeth.return_complex_type.subtypes.empty?
-            return bmeth.return_complex_type.subtypes.first.qualify(api_map, bmeth.context.namespace)
-          elsif (Solargraph::CoreFills::METHODS_WITH_YIELDPARAM_SELF.include?(meth.path))
-            bmeth = chain.base.define(api_map, context, locals).first
-            return ComplexType::UNDEFINED if bmeth.nil?
-            return bmeth.typify(api_map)
-          else
-            yps = meth.docstring.tags(:yieldparam)
-            unless yps[index].nil? or yps[index].types.nil? or yps[index].types.empty?
-              return ComplexType.try_parse(yps[index].types.first).qualify(api_map, meth.context.namespace)
-            end
-          end
-        end
-        ComplexType::UNDEFINED
-      end
-    end
-  end
-end

data/lib/solargraph/pin/method_parameter.rb

@@ -1,40 +0,0 @@
-module Solargraph
-  module Pin
-    class MethodParameter < LocalVariable
-      def return_complex_type
-        if @return_complex_type.nil?
-          @return_complex_type = ComplexType.new
-          found = nil
-          params = block.docstring.tags(:param)
-          params.each do |p|
-            next unless p.name == name
-            found = p
-            break
-          end
-          if found.nil? and !index.nil?
-            found = params[index] if params[index] && (params[index].name.nil? || params[index].name.empty?)
-          end
-          @return_complex_type = ComplexType.try_parse(*found.types) unless found.nil? or found.types.nil?
-        end
-        super
-        @return_complex_type
-      end
-
-      # The parameter's zero-based location in the block's signature.
-      #
-      # @return [Integer]
-      def index
-        block.parameter_names.index(name)
-      end
-
-      def try_merge! pin
-        return false unless super
-        # @todo This is a little expensive, but it's necessary because
-        #   parameter data depends on the method's docstring.
-        @return_complex_type = pin.return_complex_type
-        reset_conversions
-        true
-      end
-    end
-  end
-end

data/lib/solargraph/pin/plugin/method.rb

@@ -1,25 +0,0 @@
-module Solargraph
-  module Pin
-    module Plugin
-      class Method < Base
-        attr_reader :name
-        attr_reader :path
-        attr_reader :return_type
-        attr_reader :parameters
-        attr_reader :scope
-        attr_reader :visibility
-
-        def initialize name:, path:, return_type:, parameters:
-          @name = name
-          @path = path
-          @return_type = return_type
-          @parameters = parameters
-        end
-
-        def completion_item_kind
-          Solargraph::LanguageServer::CompletionItemKinds::METHOD
-        end
-      end
-    end
-  end
-end

data/lib/solargraph/plugin.rb

@@ -1,8 +0,0 @@
-module Solargraph
-  module Plugin
-    autoload :Base, 'solargraph/plugin/base'
-    autoload :Runtime, 'solargraph/plugin/runtime'
-    autoload :Canceler, 'solargraph/plugin/canceler'
-    autoload :Process, 'solargraph/plugin/process'
-  end
-end

data/lib/solargraph/plugin/base.rb

@@ -1,41 +0,0 @@
-module Solargraph
-  module Plugin
-    class Base
-      # @return [Solargraph::ApiMap]
-      attr_reader :api_map
-
-      def initialize api_map
-        @api_map = api_map
-        post_initialize
-      end
-
-      def post_initialize
-      end
-
-      # @return [Array<String>]
-      def get_methods namespace:, root:, scope:, with_private: false
-        []
-      end
-
-      # @return [Array<String>]
-      def get_constants namespace, root
-        []
-      end
-
-      # @return [String]
-      def get_fqns namespace, root
-        nil
-      end
-
-      # @return [Boolean]
-      def refresh
-        false
-      end
-
-      # @return [Boolean]
-      def runtime?
-        false
-      end
-    end
-  end
-end

data/lib/solargraph/plugin/canceler.rb

@@ -1,11 +0,0 @@
-module Solargraph
-  module Plugin
-    # A placeholder plugin for disabling the default Runtime plugin.
-    #
-    class Canceler < Base
-      def runtime?
-        true
-      end
-    end
-  end
-end

data/lib/solargraph/plugin/process.rb

@@ -1,172 +0,0 @@
-require 'json'
-
-module Solargraph
-  module Plugin
-    class Process
-      def initialize
-        @required = []
-        post_initialize
-      end
-
-      def post_initialize
-      end
-
-      def run
-        until STDIN.closed?
-          input = gets
-          break if input.nil?
-          args = nil
-          begin
-            args = JSON.parse(input)
-            case args['command']
-            when 'require'
-              STDOUT.puts do_require args['paths']
-            when 'methods'
-              STDOUT.puts get_methods args['params']
-            when 'constants'
-              STDOUT.puts get_constants args['params']
-            when 'fqns'
-              STDOUT.puts get_fqns args['params']
-            else
-              STDOUT.puts respond_err "Unrecognized command #{args['command']}"
-            end
-          rescue JSON::ParserError => e
-            STDOUT.puts respond_err "Error parsing input: #{e.message}"
-          rescue Exception => e
-            STDOUT.puts respond_err "Error processing input: #{e.message}\n#{e.backtrace}"
-          end
-          STDOUT.flush
-        end
-      end
-
-      private
-
-      def do_require paths
-        errors = []
-        paths.each do |p|
-          begin
-            require p
-            @required.push p
-          rescue Exception => e
-            Solargraph::Logging.logger.info "Failed to require #{p}: #{e.message}"
-            errors.push "Failed to require #{p}: #{e.class} #{e.message}"
-          end
-        end
-        if errors.empty?
-          respond_ok
-        else
-          respond_err errors.join('; ')
-        end
-      end
-
-      def get_methods args
-        result = []
-        # @type [Class]
-        con = find_constant(args['namespace'], args['root'])
-        unless con.nil?
-          if (args['scope'] == 'class')
-            result.concat con.methods if args['with_private']
-            result.concat con.public_methods
-          elsif (args['scope'] == 'instance')
-            result.concat con.instance_methods if args['with_private']
-            result.concat con.public_instance_methods
-          end
-        end
-        result.keep_if{|m| m.to_s.match(/^[a-z_]/i)}
-        respond_ok (result.uniq.sort.map do |name|
-          # @type [Method]
-          meth = args['scope'] == 'class' ? con.method(name) : con.instance_method(name)
-          {
-            name: name,
-            parameters: build_parameter_array(meth.parameters)
-          }
-        end)
-      end
-
-      def get_constants args
-        result = []
-        con = find_constant(args['namespace'], args['root'])
-        unless con.nil?
-          #result.concat con.constants
-          con.constants.each do |c|
-            next if c == :Solargraph and !@required.include?('solargraph')
-            here = con.const_get(c)
-            item = { namespace: con.to_s, name: c.to_s }
-            item[:class] = here.class.to_s
-            result.push item
-          end
-        end
-        respond_ok result
-      end
-
-      def get_fqns args
-        con = find_constant(args['namespace'], args['root'])
-        respond_ok (con.nil? ? nil : con.to_s)
-      end
-
-      def find_constant(namespace, root)
-        result = nil
-        unless root.empty?
-          parts = root.split('::')
-          until parts.empty?
-            result = inner_find_constant("#{parts.join('::')}::#{namespace}")
-            parts.pop
-            break unless result.nil?
-          end
-        end
-        result = inner_find_constant(namespace) if result.nil?
-        result
-      end
-
-      def inner_find_constant(namespace)
-        cursor = Object
-        parts = namespace.split('::')
-        until parts.empty?
-          here = parts.shift
-          begin
-            cursor = cursor.const_get(here)
-          rescue NameError
-            return nil
-          end
-        end
-        cursor
-      end
-
-      def respond_ok data = []
-        {
-          status: 'ok',
-          message: nil,
-          data: data
-        }.to_json
-      end
-
-      def respond_err msg
-        {
-          status: 'err',
-          message: msg,
-          data: []
-        }.to_json
-      end
-
-      def build_parameter_array parameters
-        an = 1
-        parameters.map do |p|
-          if p[0] == :rest
-            str = (p[1] ? "*#{p[1]}" : "*args")
-          else
-            str = (p[1] ? p[1].to_s : "arg#{an}")
-            if p[0] == :opt
-              str += ' = ?'
-            elsif p[0] == :key
-              str += ':'
-            elsif p[0] == :keyreq
-              str += ': ?'
-            end
-          end
-          an += 1
-          str
-        end
-      end
-    end
-  end
-end