solargraph 0.26.1 → 0.27.0

data/lib/solargraph/source_map/clip.rb

@@ -0,0 +1,123 @@
+module Solargraph
+  class SourceMap
+    class Clip
+      # @param api_map [ApiMap]
+      # @param cursor [Source::Cursor]
+      def initialize api_map, cursor
+        # @todo Just some temporary stuff while I make sure this works
+        raise "Not a cursor: #{cursor.class}" unless cursor.is_a?(Source::Cursor)
+        @api_map = api_map
+        @cursor = cursor
+      end
+
+      # @return [Array<Pin::Base>]
+      def define
+        return [] if cursor.chain.literal?
+        result = cursor.chain.define(api_map, context_pin, locals)
+        result.concat(source_map.pins.select{ |p| p.location.range.start.line == cursor.position.line }) if result.empty?
+        result
+      end
+
+      # @return [Completion]
+      def complete
+        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? || cursor.comment?
+        result = []
+        type = cursor.chain.base.infer(api_map, context_pin, locals)
+        if cursor.chain.constant? || cursor.start_of_constant?
+          result.concat api_map.get_constants(type.undefined? ? '' : type.namespace, cursor.start_of_constant? ? '' : context_pin.context.namespace)
+        else
+          result.concat api_map.get_complex_type_methods(type, context_pin.context.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.context.namespace))
+            elsif cursor.word.start_with?('@')
+              return package_completions(api_map.get_instance_variable_pins(context_pin.context.namespace, context_pin.context.scope))
+            elsif cursor.word.start_with?('$')
+              return package_completions(api_map.get_global_variable_pins)
+            end
+            result.concat prefer_non_nil_variables(locals)
+            result.concat api_map.get_constants('', context_pin.context.namespace)
+            result.concat api_map.get_methods(context_pin.context.namespace, scope: context_pin.context.scope, visibility: [:public, :private, :protected])
+            result.concat api_map.get_methods('Kernel')
+            result.concat ApiMap.keywords
+          end
+        end
+        package_completions(result)
+      end
+
+      # @return [Array<Pin::Base>]
+      def signify
+        return [] unless cursor.argument?
+        clip = Clip.new(api_map, cursor.recipient)
+        clip.define.select{|pin| pin.kind == Pin::METHOD}
+      end
+
+      def infer
+        cursor.chain.infer(api_map, context_pin, locals)
+      end
+
+      # The context at the current position.
+      #
+      # @return [Pin::Base]
+      def context_pin
+        @context ||= source_map.locate_named_path_pin(cursor.node_position.line, cursor.node_position.character)
+      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
+        @locals ||= source_map.locals.select { |pin|
+          pin.visible_from?(block, Position.new(cursor.position.line, (cursor.position.column.zero? ? 0 : cursor.position.column - 1)))
+        }.reverse
+      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
+
+      # @param cursor [cursor]
+      # @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) and (s.kind != Pin::METHOD or s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))}
+        Completion.new(filtered, cursor.range)
+      end
+
+      # Sort an array of pins to put nil or undefined variables last.
+      #
+      # @param pins [Array<Pin::Base>]
+      # @return [Array<Pin::Base>]
+      def prefer_non_nil_variables pins
+        result = []
+        nil_pins = []
+        pins.each do |pin|
+          if pin.variable? and pin.nil_assignment?
+            nil_pins.push pin
+          else
+            result.push pin
+          end
+        end
+        result + nil_pins
+      end
+    end
+  end
+end

data/lib/solargraph/{source → source_map}/completion.rb

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

data/lib/solargraph/{source → source_map}/mapper.rb

@@ -1,13 +1,12 @@
 module Solargraph
-  class Source
-    # The Mapper generates pins and other data for Sources.
+  class SourceMap
+    # The Mapper generates pins and other data for SourceMaps.
     #
-    # This class is used internally by the Source class on initialization,
-    # e.g., via Source.new or Source.load. Users should not normally need to
-    # call it directly.
+    # This class is used internally by the SourceMap class. Users should not
+    # normally need to call it directly.
     #
     class Mapper
-      include NodeMethods
+      include Source::NodeMethods
 
       private_class_method :new
 
@@ -18,10 +17,11 @@ module Solargraph
         @filename = filename
         @code = code
         @node = node
+        @comments = comments
         @node_stack = []
         @directives = {}
         @comment_ranges = comments.map do |c|
-          Source::Range.from_to(c.loc.expression.line, c.loc.expression.column, c.loc.expression.last_line, c.loc.expression.last_column)
+          Range.from_to(c.loc.expression.line, c.loc.expression.column, c.loc.expression.last_line, c.loc.expression.last_column)
         end
         @node_comments = associate_comments(node, comments)
         @pins = []
@@ -30,25 +30,29 @@ module Solargraph
         @locals = []
         @strings = []
 
-        @used_comment_locs = []
-
         # HACK make sure the first node gets processed
         root = AST::Node.new(:source, [filename])
         root = root.append node
         # @todo Is the root namespace a class or a module? Assuming class for now.
         @pins.push Pin::Namespace.new(get_node_location(nil), '', '', nil, :class, :public, nil)
         process root
-        @node_comments.reject{|k, v| @used_comment_locs.include?(k)}.each do |k, v|
-          @pins.first.comments.concat v
-        end
+        process_comment_directives
+        [@pins, @locals, @requires, @symbols]
+      end
 
-        [@pins, @locals, @requires, @symbols, @strings, @comment_ranges]
+      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, '', '', '', :class, :public, nil)], [], [], []]
       end
 
       class << self
+        # @param source [Source]
         # @return [Array]
-        def map filename, code, node, comments
-          new.map filename, code, node, comments
+        def map source
+          return new.unmap(source.filename, source.code) unless source.parsed?
+          new.map source.filename, source.code, source.node, source.comments
         end
       end
 
@@ -59,8 +63,8 @@ module Solargraph
         #   slightly more efficient than calculating offsets.
         b = node.location.expression.begin.begin_pos
         e = node.location.expression.end.end_pos
-        # b = Source::Position.line_char_to_offset(@code, node.location.line - 1, node.location.column)
-        # e = Source::Position.line_char_to_offset(@code, node.location.last_line - 1, node.location.last_column)
+        # b = Position.line_char_to_offset(@code, node.location.line - 1, node.location.column)
+        # e = Position.line_char_to_offset(@code, node.location.last_line - 1, node.location.last_column)
         frag = source_from_parser[b..e-1].to_s
         frag.strip.gsub(/,$/, '')
       end
@@ -78,10 +82,7 @@ module Solargraph
       # @param node [Parser::AST::Node]
       def process node, tree = [], visibility = :public, scope = :instance, fqn = '', stack = []
         return unless node.is_a?(AST::Node)
-        if node.type == :str
-          @strings.push Source::Range.from_to(node.loc.expression.line, node.loc.expression.column, node.loc.expression.last_line, node.loc.expression.last_column)
-          return
-        end
+        return if node.type == :str
         stack.push node
         if node.kind_of?(AST::Node)
           @node_stack.unshift node
@@ -89,6 +90,7 @@ module Solargraph
             visibility = :public
             if node.children[0].kind_of?(AST::Node) and node.children[0].children[0].kind_of?(AST::Node) and node.children[0].children[0].type == :cbase
               tree = pack_name(node.children[0])
+              tree.shift if tree.first.empty?
             else
               tree = tree + pack_name(node.children[0])
             end
@@ -104,22 +106,22 @@ module Solargraph
             if c.kind_of?(AST::Node)
               if c.type == :ivasgn
                 here = get_node_start_position(c)
-                context = get_named_path_pin(here)
+                named_path = get_named_path_pin(here)
                 if c.children[1].nil?
                   ora = find_parent(stack, :or_asgn)
                   unless ora.nil?
                     u = c.updated(:ivasgn, c.children + ora.children[1..-1], nil)
-                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), context)
-                    if visibility == :module_function and context.kind == Pin::METHOD
-                      other = pins.select{|pin| pin.path == "#{context.namespace}.#{context.name}"}.first
-                      pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), other) unless other.nil?
+                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), named_path.context)
+                    if visibility == :module_function and named_path.kind == Pin::METHOD
+                      other = ComplexType.parse("Module<#{named_path.context.namespace}>")
+                      pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(u), fqn || '', c.children[0].to_s, comments_for(u), u.children[1], infer_literal_node_type(u.children[1]), other) #unless other.nil?
                     end
                   end
                 else
-                  pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), context)
-                  if visibility == :module_function and context.kind == Pin::METHOD
-                    other = pins.select{|pin| pin.path == "#{context.namespace}.#{context.name}"}.first
-                    pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), other)
+                  pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), named_path.context)
+                  if visibility == :module_function and named_path.kind == Pin::METHOD
+                    other = ComplexType.parse("Module<#{named_path.context.namespace}>")
+                     pins.push Solargraph::Pin::InstanceVariable.new(get_node_location(c), fqn || '',c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), other)
                   end
                 end
               elsif c.type == :cvasgn
@@ -138,18 +140,26 @@ module Solargraph
                 here = get_node_start_position(c)
                 context = get_named_path_pin(here)
                 block = get_block_pin(here)
-                presence = Source::Range.new(here, block.location.range.ending)
+                presence = Range.new(here, block.location.range.ending)
                 if c.children[1].nil?
                   ora = find_parent(stack, :or_asgn)
                   unless ora.nil?
                     u = c.updated(:lvasgn, c.children + ora.children[1..-1], nil)
-                    @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(u), fqn, u.children[0].to_s, comments_for(ora), c.children[1], infer_literal_node_type(c.children[1]), context, block, presence)
+                    @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(u), fqn, u.children[0].to_s, comments_for(ora), u.children[1], infer_literal_node_type(c.children[1]), context, block, presence)
                   end
                 else
                   @locals.push Solargraph::Pin::LocalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), context, block, presence)
                 end
               elsif c.type == :gvasgn
-                pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), @pins.first)
+                if c.children[1].nil?
+                  ora = find_parent(stack, :or_asgn)
+                  unless ora.nil?
+                    u = c.updated(:gvasgn, c.children + ora.children[1..-1], nil)
+                    pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(c), fqn, u.children[0].to_s, comments_for(c), u.children[1], infer_literal_node_type(c.children[1]), @pins.first)
+                  end
+                else
+                  pins.push Solargraph::Pin::GlobalVariable.new(get_node_location(c), fqn, c.children[0].to_s, comments_for(c), c.children[1], infer_literal_node_type(c.children[1]), @pins.first)
+                end
               elsif c.type == :sym
                 @symbols.push Solargraph::Pin::Symbol.new(get_node_location(c), ":#{c.children[0]}")
               elsif c.type == :casgn
@@ -224,7 +234,7 @@ module Solargraph
                       mm = Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.comments, :class, :public, ref.parameters)
                       cm = Solargraph::Pin::Method.new(ref.location, ref.namespace, ref.name, ref.comments, :instance, :private, ref.parameters)
                       pins.push mm, cm
-                      pins.select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.context == ref}.each do |ivar|
+                      pins.select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.context == ref.context}.each do |ivar|
                         pins.delete ivar
                         pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.comments, ivar.signature, ivar.instance_variable_get(:@literal), mm)
                         pins.push Solargraph::Pin::InstanceVariable.new(ivar.location, ivar.namespace, ivar.name, ivar.comments, ivar.signature, ivar.instance_variable_get(:@literal), cm)
@@ -268,10 +278,10 @@ module Solargraph
               elsif c.type == :send and [:attr_reader, :attr_writer, :attr_accessor].include?(c.children[1])
                 c.children[2..-1].each do |a|
                   if c.children[1] == :attr_reader or c.children[1] == :attr_accessor
-                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), fqn || '', "#{a.children[0]}", comments_for(c), :reader, scope)
+                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), fqn || '', "#{a.children[0]}", comments_for(c), :reader, scope, visibility)
                   end
                   if c.children[1] == :attr_writer or c.children[1] == :attr_accessor
-                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), fqn || '', "#{a.children[0]}=", comments_for(c), :writer, scope)
+                    pins.push Solargraph::Pin::Attribute.new(get_node_location(c), fqn || '', "#{a.children[0]}=", comments_for(c), :writer, scope, visibility)
                   end
                 end
               elsif c.type == :sclass and c.children[0].type == :self
@@ -296,12 +306,14 @@ module Solargraph
                     here = get_node_start_position(u)
                     context = get_named_path_pin(here)
                     block = get_block_pin(here)
-                    presence = Source::Range.new(here, block.location.range.ending)
+                    presence = Range.new(here, block.location.range.ending)
                     @locals.push Solargraph::Pin::MethodParameter.new(get_node_location(u), fqn, u.children[0].to_s, comments_for(c), resolve_node_signature(u.children[1]), infer_literal_node_type(u.children[1]), context, block, presence)
                   end
                 end
               elsif c.type == :block
-                @pins.push Solargraph::Pin::Block.new(get_node_location(c), fqn || '', '', comments_for(c), c.children[0], scope)
+                here = get_node_start_position(c)
+                named_path = get_named_path_pin(here)
+                @pins.push Solargraph::Pin::Block.new(get_node_location(c), fqn || '', '', comments_for(c), c.children[0], named_path.context)
               end
               process c, tree, visibility, scope, fqn, stack
             end
@@ -329,16 +341,19 @@ module Solargraph
         @pins.select{|pin| [Pin::NAMESPACE, Pin::METHOD].include?(pin.kind) and pin.location.range.contain?(position)}.last
       end
 
+      def get_namespace_pin position
+        @pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.location.range.contain?(position)}.last
+      end
+
       # @return [String]
       def comments_for node
         result = @node_comments[node.loc]
         return nil if result.nil?
-        @used_comment_locs.push node.loc
         result
       end
 
       # @param node [Parser::AST::Node]
-      # @return [Solargraph::Source::Location]
+      # @return [Solargraph::Location]
       def get_node_location(node)
         if node.nil?
           st = Position.new(0, 0)
@@ -382,7 +397,11 @@ module Solargraph
       # @param node [Parser::AST::Node]
       # @return [Solargraph::Pin::Namespace]
       def namespace_for(node)
-        position = Source::Position.new(node.loc.line, node.loc.column)
+        position = Position.new(node.loc.line, node.loc.column)
+        namespace_at(position)
+      end
+
+      def namespace_at(position)
         @pins.select{|pin| pin.kind == Pin::NAMESPACE and pin.location.range.contain?(position)}.last
       end
 
@@ -425,6 +444,89 @@ module Solargraph
       def source_from_parser
         @source_from_parser ||= @code.gsub(/\r\n/, "\n")
       end
+
+      def process_comment position, comment
+        cmnt = remove_inline_comment_hashes(comment)
+        return unless cmnt =~ /(@\!method|@\!attribute|@\!domain|@\!macro)/
+        parse = YARD::Docstring.parser.parse(cmnt)
+        parse.directives.each { |d| process_directive(position, d) }
+      end
+
+      # @param position [Position]
+      # @param directive [YARD::Tags::Directive]
+      def process_directive position, directive
+        docstring = YARD::Docstring.parser.parse(directive.tag.text).to_docstring
+        location = Location.new(@filename, Range.new(position, position))
+        case directive.tag.tag_name
+        when 'method'
+          namespace = namespace_at(position)
+          gen_src = Solargraph::SourceMap.load_string("def #{directive.tag.name};end")
+          gen_pin = gen_src.pins.last # Method is last pin after root namespace
+          @pins.push Solargraph::Pin::Method.new(location, namespace.path, gen_pin.name, docstring.all, :instance, :public, gen_pin.parameters)
+        when 'attribute'
+          namespace = namespace_at(position)
+          t = (directive.tag.types.nil? || directive.tag.types.empty?) ? nil : directive.tag.types.flatten.join('')
+          if t.nil? or t.include?('r')
+            # location, namespace, name, docstring, access
+            pins.push Solargraph::Pin::Attribute.new(location, namespace.path, directive.tag.name, docstring.all, :reader, :instance, :public)
+          end
+          if t.nil? or t.include?('w')
+            pins.push Solargraph::Pin::Attribute.new(location, namespace.path, "#{directive.tag.name}=", docstring.all, :writer, :instance, :public)
+          end
+        when 'domain'
+          namespace = namespace_at(position)
+          namespace.domains.push directive.tag.text
+        when 'macro'
+          nxt_pos = Position.new(position.line + 1, @code.lines[position.line + 1].length)
+          path_pin = get_named_path_pin(nxt_pos)
+          path_pin.macros.push directive
+        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? and !p.strip.empty?
+            num = p.index(/[^ ]/)
+            started = true
+          elsif started and !p.strip.empty?
+            cur = p.index(/[^ ]/)
+            num = cur if cur < num
+          end
+          ctxt += "#{p[num..-1]}\n" if started
+        }
+        ctxt
+      end
+
+      def process_comment_directives
+        current = []
+        last_line = nil
+        @comments.each do |cmnt|
+          if cmnt.inline?
+            if last_line.nil? || cmnt.loc.expression.line == last_line + 1
+              if cmnt.loc.expression.column.zero? || @code.lines[cmnt.loc.expression.line][0..cmnt.loc.expression.column-1].strip.empty?
+                current.push cmnt
+              else
+                # @todo Connected to a line of code. Handle separately
+              end
+            elsif !current.empty?
+              process_comment Position.new(current.last.loc.expression.line, current.last.loc.expression.column), current.map(&:text).join("\n")
+              current.clear
+              current.push cmnt
+            end
+          else
+            # @todo Handle block comments
+          end
+          last_line = cmnt.loc.expression.line
+        end
+        unless current.empty?
+          process_comment Position.new(current.last.loc.expression.line, current.last.loc.expression.column), current.map(&:text).join("\n")
+        end
+      end
     end
   end
 end