jimeh-solargraph 0.40.4.0

data/lib/solargraph/source_map/clip.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    # A static analysis tool for obtaining definitions, completions,
+    # signatures, and type inferences from a cursor.
+    #
+    class Clip
+      # @param api_map [ApiMap]
+      # @param cursor [Source::Cursor]
+      def initialize api_map, cursor
+        @api_map = api_map
+        @cursor = cursor
+      end
+
+      # @return [Array<Pin::Base>]
+      def define
+        return [] if cursor.comment? || cursor.chain.literal?
+        result = cursor.chain.define(api_map, block, locals)
+        result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
+        result
+      end
+
+      # @return [Completion]
+      def complete
+        return package_completions([]) if !source_map.source.parsed? || cursor.string?
+        return package_completions(api_map.get_symbols) if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+        return Completion.new([], cursor.range) if cursor.chain.literal?
+        if cursor.comment?
+          tag_complete
+        else
+          code_complete
+        end
+      end
+
+      # @return [Array<Pin::Base>]
+      def signify
+        return [] unless cursor.argument?
+        chain = Parser.chain(cursor.recipient_node, cursor.filename)
+        chain.define(api_map, context_pin, locals).select { |pin| pin.is_a?(Pin::Method) }
+      end
+
+      # @return [ComplexType]
+      def infer
+        result = cursor.chain.infer(api_map, block, locals)
+        return result unless result.tag == 'self'
+        ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).namespace)
+      end
+
+      # Get an array of all the locals that are visible from the cursors's
+      # position. Locals can be local variables, method parameters, or block
+      # parameters. The array starts with the nearest local pin.
+      #
+      # @return [Array<Solargraph::Pin::Base>]
+      def locals
+        loc_pos = context_pin.location.range.contain?(cursor.position) ? cursor.position : context_pin.location.range.ending
+        adj_pos = Position.new(loc_pos.line, (loc_pos.column.zero? ? 0 : loc_pos.column - 1))
+        @locals ||= source_map.locals.select { |pin|
+          pin.visible_from?(block, adj_pos)
+        }.reverse
+      end
+
+      def gates
+        block.gates
+      end
+
+      def in_block?
+        return @in_block unless @in_block.nil?
+        @in_block = begin
+          tree = cursor.source.tree_at(cursor.position.line, cursor.position.column)
+          Parser.is_ast_node?(tree[1]) && [:block, :ITER].include?(tree[1].type)
+        end
+      end
+
+      # @param phrase [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def translate phrase
+        chain = Parser.chain(Parser.parse(phrase))
+        chain.define(api_map, block, locals)
+      end
+
+      private
+
+      # @return [ApiMap]
+      attr_reader :api_map
+
+      # @return [Source::Cursor]
+      attr_reader :cursor
+
+      # @return [SourceMap]
+      def source_map
+        @source_map ||= api_map.source_map(cursor.filename)
+      end
+
+      # @return [Solargraph::Pin::Base]
+      def block
+        @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
+      end
+
+      # The context at the current position.
+      #
+      # @return [Pin::Base]
+      def context_pin
+        @context_pin ||= source_map.locate_named_path_pin(cursor.node_position.line, cursor.node_position.character)
+      end
+
+      # @return [Array<Pin::Base>]
+      def yielded_self_pins
+        return [] unless block.is_a?(Pin::Block) && block.receiver
+        chain = Parser.chain(block.receiver, source_map.source.filename)
+        receiver_pin = chain.define(api_map, context_pin, locals).first
+        return [] if receiver_pin.nil?
+        result = []
+        ys = receiver_pin.docstring.tag(:yieldpublic)
+        unless ys.nil? || ys.types.empty?
+          ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
+          result.concat api_map.get_complex_type_methods(ysct, '', false)
+        end
+        result
+      end
+
+      # @return [Array<Pin::KeywordParam]
+      def complete_keyword_parameters
+        return [] unless cursor.argument? && cursor.chain.links.one? && cursor.word =~ /^[a-z0-9_]*:?$/
+        pins = signify
+        result = []
+        done = []
+        pins.each do |pin|
+          pin.parameters.each do |param|
+            next if done.include?(param.name)
+            done.push param.name
+            next unless param.keyword?
+            result.push Pin::KeywordParam.new(pin.location, "#{param.name}:")
+          end
+          if !pin.parameters.empty? && pin.parameters.last.kwrestarg?
+            pin.docstring.tags(:param).each do |tag|
+              next if done.include?(tag.name)
+              done.push tag.name
+              result.push Pin::KeywordParam.new(pin.location, "#{tag.name}:")
+            end
+          end
+        end
+        result
+      end
+
+      # @param result [Array<Pin::Base>]
+      # @return [Completion]
+      def package_completions result
+        frag_start = cursor.start_of_word.to_s.downcase
+        filtered = result.uniq(&:name).select { |s|
+          s.name.downcase.start_with?(frag_start) &&
+            (!s.is_a?(Pin::Method) || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
+        }
+        Completion.new(filtered, cursor.range)
+      end
+
+      def tag_complete
+        result = []
+        match = source_map.code[0..cursor.offset-1].match(/[\[<, ]([a-z0-9_:]*)\z/i)
+        if match
+          full = match[1]
+          if full.include?('::')
+            if full.end_with?('::')
+              result.concat api_map.get_constants(full[0..-3], *gates)
+            else
+              result.concat api_map.get_constants(full.split('::')[0..-2].join('::'), *gates)
+            end
+          else
+            result.concat api_map.get_constants('', full.end_with?('::') ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
+          end
+        end
+        package_completions(result)
+      end
+
+      def code_complete
+        result = []
+        result.concat complete_keyword_parameters
+        if cursor.chain.constant? || cursor.start_of_constant?
+          full = cursor.chain.links.first.word
+          type = if cursor.chain.undefined?
+            cursor.chain.base.infer(api_map, context_pin, locals)
+          else
+            if full.include?('::') && cursor.chain.links.length == 1
+              ComplexType.try_parse(full.split('::')[0..-2].join('::'))
+            elsif cursor.chain.links.length > 1
+              ComplexType.try_parse(full)
+            else
+              ComplexType::UNDEFINED
+            end
+          end
+          if type.undefined?
+            if full.include?('::')
+              result.concat api_map.get_constants(full, *gates)
+            else
+              result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
+            end
+          else
+            result.concat api_map.get_constants(type.namespace, cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
+          end
+        else
+          type = cursor.chain.base.infer(api_map, block, locals)
+          result.concat api_map.get_complex_type_methods(type, block.binder.namespace, cursor.chain.links.length == 1)
+          if cursor.chain.links.length == 1
+            if cursor.word.start_with?('@@')
+              return package_completions(api_map.get_class_variable_pins(context_pin.full_context.namespace))
+            elsif cursor.word.start_with?('@')
+              return package_completions(api_map.get_instance_variable_pins(block.binder.namespace, block.binder.scope))
+            elsif cursor.word.start_with?('$')
+              return package_completions(api_map.get_global_variable_pins)
+            end
+            result.concat locals
+            result.concat api_map.get_constants(context_pin.context.namespace, *gates)
+            result.concat api_map.get_methods(block.binder.namespace, scope: block.binder.scope, visibility: [:public, :private, :protected])
+            result.concat api_map.get_methods('Kernel')
+            # result.concat ApiMap.keywords
+            result.concat api_map.keyword_pins
+            result.concat yielded_self_pins
+          end
+        end
+        package_completions(result)
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/completion.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    # The result of a completion request containing the pins that describe
+    # completion options and the range to be replaced.
+    #
+    class Completion
+      # @return [Array<Solargraph::Pin::Base>]
+      attr_reader :pins
+
+      # @return [Solargraph::Range]
+      attr_reader :range
+
+      # @param pins [Array<Solargraph::Pin::Base>]
+      # @param range [Solargraph::Range]
+      def initialize pins, range
+        @pins = pins
+        @range = range
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/mapper.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    # The Mapper generates pins and other data for SourceMaps.
+    #
+    # This class is used internally by the SourceMap class. Users should not
+    # normally need to call it directly.
+    #
+    class Mapper
+      # include Source::NodeMethods
+
+      private_class_method :new
+
+      MACRO_REGEXP = /(@\!method|@\!attribute|@\!domain|@\!macro|@\!parse|@\!override)/.freeze
+
+      # Generate the data.
+      #
+      # @param source [Source]
+      # @return [Array]
+      def map source
+        @source = source
+        @filename = source.filename
+        @code = source.code
+        @comments = source.comments
+        @pins, @locals = Parser.map(source)
+        process_comment_directives
+        [@pins, @locals]
+      # rescue Exception => e
+      #   Solargraph.logger.warn "Error mapping #{source.filename}: [#{e.class}] #{e.message}"
+      #   Solargraph.logger.warn e.backtrace.join("\n")
+      #   [[], []]
+      end
+
+      # @param filename [String]
+      # @param code [String]
+      # @return [Array]
+      def unmap filename, code
+        s = Position.new(0, 0)
+        e = Position.from_offset(code, code.length)
+        location = Location.new(filename, Range.new(s, e))
+        [[Pin::Namespace.new(location: location, name: '')], []]
+      end
+
+      class << self
+        # @param source [Source]
+        # @return [Array]
+        def map source
+          return new.unmap(source.filename, source.code) unless source.parsed?
+          new.map source
+        end
+      end
+
+      # @return [Array<Solargraph::Pin::Base>]
+      def pins
+        @pins ||= []
+      end
+
+      def closure_at(position)
+        @pins.select{|pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position)}.last
+      end
+
+      def process_comment source_position, comment_position, comment
+        return unless comment =~ MACRO_REGEXP
+        cmnt = remove_inline_comment_hashes(comment)
+        parse = Solargraph::Source.parse_docstring(cmnt)
+        last_line = 0
+        # @param d [YARD::Tags::Directive]
+        parse.directives.each do |d|
+          line_num = find_directive_line_number(cmnt, d.tag.tag_name, last_line)
+          pos = Solargraph::Position.new(comment_position.line + line_num - 1, comment_position.column)
+          process_directive(source_position, pos, d)
+          last_line = line_num + 1
+          # @todo The below call assumes the topmost comment line. The above
+          #   process occasionally emits incorrect comment positions due to
+          #   blank lines in comment blocks, but at least it processes all the
+          #   directives.
+          # process_directive(source_position, comment_position, d)
+        end
+      end
+
+      # @param comment [String]
+      # @return [Integer]
+      def find_directive_line_number comment, tag, start
+        # Avoid overruning the index
+        return start unless start < comment.lines.length
+        num = comment.lines[start..-1].find_index do |line|
+          # Legacy method directives might be `@method` instead of `@!method`
+          # @todo Legacy syntax should probably emit a warning
+          line.include?("@!#{tag}") || (tag == 'method' && line.include?("@#{tag}"))
+        end
+        num.to_i + start
+      end
+
+      # @param source_position [Position]
+      # @param comment_position [Position]
+      # @param directive [YARD::Tags::Directive]
+      # @return [void]
+      def process_directive source_position, comment_position, directive
+        docstring = Solargraph::Source.parse_docstring(directive.tag.text).to_docstring
+        location = Location.new(@filename, Range.new(comment_position, comment_position))
+        case directive.tag.tag_name
+        when 'method'
+          namespace = closure_at(source_position) || @pins.first
+          if namespace.location.range.start.line < comment_position.line
+            namespace = closure_at(comment_position)
+          end
+          begin
+            src = Solargraph::Source.load_string("def #{directive.tag.name};end", @source.filename)
+            region = Parser::Region.new(source: src, closure: namespace)
+            gen_pin = Parser.process_node(src.node, region).first.last
+            return if gen_pin.nil?
+            # Move the location to the end of the line so it gets recognized
+            # as originating from a comment
+            shifted = Solargraph::Position.new(comment_position.line, @code.lines[comment_position.line].to_s.chomp.length)
+            # @todo: Smelly instance variable access
+            gen_pin.instance_variable_set(:@comments, docstring.all.to_s)
+            gen_pin.instance_variable_set(:@location, Solargraph::Location.new(@filename, Range.new(shifted, shifted)))
+            gen_pin.instance_variable_set(:@explicit, false)
+            @pins.push gen_pin
+          rescue Parser::SyntaxError => e
+            # @todo Handle error in directive
+          end
+        when 'attribute'
+          return if directive.tag.name.nil?
+          namespace = closure_at(source_position)
+          t = (directive.tag.types.nil? || directive.tag.types.empty?) ? nil : directive.tag.types.flatten.join('')
+          if t.nil? || t.include?('r')
+            pins.push Solargraph::Pin::Method.new(
+              location: location,
+              closure: namespace,
+              name: directive.tag.name,
+              comments: docstring.all.to_s,
+              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
+              visibility: :public,
+              explicit: false,
+              attribute: true
+            )
+          end
+          if t.nil? || t.include?('w')
+            pins.push Solargraph::Pin::Method.new(
+              location: location,
+              closure: namespace,
+              name: "#{directive.tag.name}=",
+              comments: docstring.all.to_s,
+              scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
+              visibility: :public,
+              attribute: true
+            )
+            pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            if pins.last.return_type.defined?
+              pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+            end
+          end
+        when 'parse'
+          begin
+            ns = closure_at(source_position)
+            src = Solargraph::Source.load_string(directive.tag.text, @source.filename)
+            region = Parser::Region.new(source: src, closure: ns)
+            # @todo These pins may need to be marked not explicit
+            index = @pins.length
+            loff = if @code.lines[comment_position.line].strip.end_with?('@!parse')
+              comment_position.line + 1
+            else
+              comment_position.line
+            end
+            Parser.process_node(src.node, region, @pins)
+            @pins[index..-1].each do |p|
+              # @todo Smelly instance variable access
+              p.location.range.start.instance_variable_set(:@line, p.location.range.start.line + loff)
+              p.location.range.ending.instance_variable_set(:@line, p.location.range.ending.line + loff)
+            end
+          rescue Parser::SyntaxError => e
+            # @todo Handle parser errors in !parse directives
+          end
+        when 'domain'
+          namespace = closure_at(source_position)
+          namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
+        when 'override'
+          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags)
+        end
+      end
+
+      def remove_inline_comment_hashes comment
+        ctxt = ''
+        num = nil
+        started = false
+        comment.lines.each { |l|
+          # Trim the comment and minimum leading whitespace
+          p = l.gsub(/^#/, '')
+          if num.nil? && !p.strip.empty?
+            num = p.index(/[^ ]/)
+            started = true
+          elsif started && !p.strip.empty?
+            cur = p.index(/[^ ]/)
+            num = cur if cur < num
+          end
+          ctxt += "#{p[num..-1]}" if started
+        }
+        ctxt
+      end
+
+      # @return [void]
+      def process_comment_directives
+        return unless @code =~ MACRO_REGEXP
+        code_lines = @code.lines
+        @source.associated_comments.each do |line, comments|
+          src_pos = line ? Position.new(line, code_lines[line].to_s.chomp.index(/[^\s]/) || 0) : Position.new(code_lines.length, 0)
+          com_pos = Position.new(line + 1 - comments.lines.length, 0)
+          process_comment(src_pos, com_pos, comments)
+        end
+      end
+    end
+  end
+end