solargraph 0.27.1 → 0.28.0

data/lib/solargraph/pin/reference/extend.rb

@@ -0,0 +1,11 @@
+module Solargraph
+  module Pin
+    class Reference
+      class Extend < Reference
+        def kind
+          Pin::EXTEND_REFERENCE
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference/include.rb

@@ -0,0 +1,11 @@
+module Solargraph
+  module Pin
+    class Reference
+      class Include < Reference
+        def kind
+          Pin::INCLUDE_REFERENCE
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference/require.rb

@@ -0,0 +1,15 @@
+module Solargraph
+  module Pin
+    class Reference
+      class Require < Reference
+        def initialize location, name
+          super(location, '', name)
+        end
+
+        def kind
+          Pin::REQUIRE_REFERENCE
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/reference/superclass.rb

@@ -0,0 +1,11 @@
+module Solargraph
+  module Pin
+    class Reference
+      class Superclass < Reference
+        def kind
+          Pin::SUPERCLASS_REFERENCE
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/symbol.rb

@@ -20,10 +20,6 @@ module Solargraph
         ''
       end
 
-      def identifier
-        name
-      end
-
       def completion_item_kind
         Solargraph::LanguageServer::CompletionItemKinds::KEYWORD
       end

data/lib/solargraph/pin/yard_pin/namespace.rb

@@ -9,20 +9,20 @@ module Solargraph
           # @todo This method of superclass detection is a bit of a hack. If
           #   the superclass is a Proxy, it is assumed to be undefined in its
           #   yardoc and converted to a fully qualified namespace.
-          if code_object.is_a?(YARD::CodeObjects::ClassObject) && code_object.superclass
-            if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
-              superclass = "::#{code_object.superclass}"
-            else
-              superclass = code_object.superclass.to_s
-            end
-          end
-          super(location, code_object.namespace.to_s, code_object.name.to_s, comments_from(code_object), namespace_type(code_object), code_object.visibility, superclass)
-          code_object.class_mixins.each do |m|
-            extend_references.push Pin::Reference.new(location, path, m.path)
-          end
-          code_object.instance_mixins.each do |m|
-            include_references.push Pin::Reference.new(location, path, m.path)
-          end
+          # if code_object.is_a?(YARD::CodeObjects::ClassObject) && code_object.superclass
+          #   if code_object.superclass.is_a?(YARD::CodeObjects::Proxy)
+          #     superclass = "::#{code_object.superclass}"
+          #   else
+          #     superclass = code_object.superclass.to_s
+          #   end
+          # end
+          super(location, code_object.namespace.to_s, code_object.name.to_s, comments_from(code_object), namespace_type(code_object), code_object.visibility)
+          # code_object.class_mixins.each do |m|
+          #   extend_references.push Pin::Reference.new(location, path, m.path)
+          # end
+          # code_object.instance_mixins.each do |m|
+          #   include_references.push Pin::Reference.new(location, path, m.path)
+          # end
         end
 
         private

data/lib/solargraph/pin/yard_pin/yard_mixin.rb

@@ -2,10 +2,6 @@ module Solargraph
   module Pin
     module YardPin
       module YardMixin
-        def yard_pin?
-          true
-        end
-
         private
 
         def comments_from code_object

data/lib/solargraph/position.rb

@@ -89,6 +89,13 @@ module Solargraph
       Position.new(line, character)
     end
 
+    # A helper method for generating positions from arrays of integers. The
+    # original parameter is returned if it is already a position.
+    #
+    # @raise [ArgumentError] if the object cannot be converted to a position.
+    #
+    # @param object [Position, Array(Integer, Integer)]
+    # @return [Position]
     def self.normalize object
       return object if object.is_a?(Position)
       return Position.new(object[0], object[1]) if object.is_a?(Array)

data/lib/solargraph/source.rb

@@ -97,24 +97,19 @@ module Solargraph
     def synchronize updater
       raise 'Invalid synchronization' unless updater.filename == filename
       real_code = updater.write(@code)
-      incr_code = updater.write(@code, true)
       if real_code == @code
         @version = updater.version
         return self
       end
-      synced = Source.new(incr_code, filename)
+      synced = Source.new(real_code, filename)
       if synced.parsed?
-        synced.code = real_code
-        if synced.repaired?
-          synced.error_ranges.concat combine_errors(error_ranges + updater.changes.map(&:range))
-        end
-      else
-        new_repair = updater.repair(@repaired)
-        synced = Source.new(new_repair, filename)
-        synced.error_ranges.concat combine_errors(error_ranges + updater.changes.map(&:range))
-        synced.parsed = false
-        synced.code = real_code
+        synced.version = updater.version
+        return synced
       end
+      incr_code = updater.repair(@repaired)
+      synced = Source.new(incr_code, filename)
+      synced.error_ranges.concat (error_ranges + updater.changes.map(&:range))
+      synced.code = real_code
       synced.version = updater.version
       synced
     end
@@ -226,22 +221,6 @@ module Solargraph
       result
     end
 
-    # @param ranges [Array<Range>]
-    # @return [Array<Range>]
-    def combine_errors ranges
-      result = []
-      lines = []
-      ranges.sort{|a, b| a.start.line <=> b.start.line}.each do |rng|
-        next if rng.nil? || lines.include?(rng.start.line)
-        lines.push rng.start.line
-        next if comment_at?(rng.start) || rng.start.line >= code.lines.length
-        fcol = code.lines[rng.start.line].index(/[^\s]/) || 0
-        ecol = code.lines[rng.start.line].length
-        result.push Range.from_to(rng.start.line, fcol, rng.start.line, ecol)
-      end
-      result
-    end
-
     protected
 
     # @return [Integer]

data/lib/solargraph/source/chain.rb

@@ -12,7 +12,6 @@ module Solargraph
       autoload :InstanceVariable, 'solargraph/source/chain/instance_variable'
       autoload :GlobalVariable,   'solargraph/source/chain/global_variable'
       autoload :Literal,          'solargraph/source/chain/literal'
-      autoload :Definition,       'solargraph/source/chain/definition'
       autoload :Head,             'solargraph/source/chain/head'
 
       UNDEFINED_CALL = Chain::Call.new('<undefined>')

data/lib/solargraph/source/chain/call.rb

@@ -61,7 +61,7 @@ module Solargraph
         end
 
         def external_constructor? pin, context
-          pin.path == 'Class#new' || (pin.name == 'new' && pin.scope == :class && pin.context != context)
+          pin.path == 'Class#new' || (pin.name == 'new' && pin.scope == :class && pin.return_type != context)
         end
 
         # @param pin [Pin::Method]

data/lib/solargraph/source/chain/constant.rb

@@ -8,10 +8,19 @@ module Solargraph
 
         def resolve api_map, name_pin, locals
           return [Pin::ROOT_PIN] if word.empty?
-          parts = word.split('::')
-          last = parts.pop
-          first = parts.join('::').to_s
-          api_map.get_constants(first, name_pin.context.namespace).select{|p| p.name == last}
+          if word.start_with?('::')
+            context = ''
+            bottom = word[2..-1]
+          else
+            context = name_pin.context.namespace
+            bottom = word
+          end
+          if bottom.include?('::')
+            ns = bottom.split('::')[0..-2].join('::')
+          else
+            ns = ''
+          end
+          api_map.get_constants(ns, context).select{|p| p.path.end_with?(bottom)}
         end
       end
     end

data/lib/solargraph/source/change.rb

@@ -55,7 +55,13 @@ module Solargraph
         if range.nil?
           fixed
         else
-          commit text, fixed
+          result = commit text, fixed
+          off = Position.to_offset(text, range.start)
+          match = result[0..off].match(/[\.:]+\z/)
+          if match
+            result = result[0..off].sub(/#{match[0]}\z/, ' ' * match[0].length) + result[off..-1]
+          end
+          result
         end
       end
 

data/lib/solargraph/source/cursor.rb

@@ -14,11 +14,7 @@ module Solargraph
       # @param position [Position, Array(Integer, Integer)]
       def initialize source, position
         @source = source
-        @position = if position.is_a?(Array)
-                      Position.new(position[0], position[1])
-                    else
-                      position
-                    end
+        @position = Position.normalize(position)
       end
 
       # @return [String]

data/lib/solargraph/source/node_chainer.rb

@@ -73,10 +73,11 @@ module Solargraph
         elsif n.type == :const
           # result.push Chain::Constant.new(unpack_name(n))
           const = unpack_name(n)
-          parts = const.split('::')
-          last = parts.pop
-          result.push Chain::Constant.new(parts.join('::')) unless parts.empty?
-          result.push Chain::Constant.new(last)
+          # parts = const.split('::')
+          # last = parts.pop
+          # result.push Chain::Constant.new(parts.join('::')) unless parts.empty?
+          # result.push Chain::Constant.new(last)
+          result.push Chain::Constant.new(const)
         elsif [:lvar, :lvasgn].include?(n.type)
           result.push Chain::Call.new(n.children[0].to_s)
         elsif [:ivar, :ivasgn].include?(n.type)
@@ -86,8 +87,6 @@ module Solargraph
         elsif [:gvar, :gvasgn].include?(n.type)
           result.push Chain::GlobalVariable.new(n.children[0].to_s)
         elsif [:class, :module, :def, :defs].include?(n.type)
-          # location = Solargraph::Location.new(@filename, Range.from_to(n.loc.expression.line, n.loc.expression.column, n.loc.expression.last_line, n.loc.expression.last_column))
-          # result.push Chain::Definition.new(location)
           # @todo Undefined or what?
           result.push Chain::UNDEFINED_CALL
         else

data/lib/solargraph/source/source_chainer.rb

@@ -35,13 +35,15 @@ module Solargraph
       # @return [Source::Chain]
       def chain
         return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
+        # return Chain.new([Chain::UNDEFINED_CALL]) unless infer_literal_node_type(source.node_at(position.line, position.column)).nil?
         begin
-          if source.repaired? && source.parsed?
-            node = source.node_at(fixed_position.line, fixed_position.column)
-          elsif source.parsed?
+          return Chain.new([]) if phrase.end_with?('..')
+          if !source.repaired? && source.parsed?
             node = source.node_at(position.line, position.column)
           else
-            node = Source.parse(fixed_phrase)
+            node = nil
+            node = source.node_at(fixed_position.line, fixed_position.column) unless source.error_ranges.any?{|r| r.include?(fixed_position)}
+            node = Source.parse(fixed_phrase) if node.nil?
           end
         rescue Parser::SyntaxError
           return Chain.new([Chain::UNDEFINED_CALL])
@@ -54,15 +56,13 @@ module Solargraph
           elsif end_of_phrase.strip == '::'
             chain.links.push Chain::UNDEFINED_CONSTANT
           end
-        elsif end_of_phrase.strip == '::'
-          chain.links.pop
-          chain.links.push Chain::UNDEFINED_CONSTANT
         end
         chain
       end
 
       private
 
+      # @return [Position]
       attr_reader :position
 
       # The zero-based line number of the fragment's location.
@@ -78,18 +78,22 @@ module Solargraph
       # @return [Solargraph::Source]
       attr_reader :source
 
+      # @return [String]
       def phrase
         @phrase ||= source.code[signature_data[0]..offset-1]
       end
 
+      # @return [String]
       def fixed_phrase
         @fixed_phrase ||= phrase[0..-(end_of_phrase.length+1)]
       end
 
+      # @return [Position]
       def fixed_position
         @fixed_position ||= Position.from_offset(source.code, offset - end_of_phrase.length)
       end
 
+      # @return [String]
       def end_of_phrase
         @end_of_phrase ||= begin
           match = phrase.match(/[\s]*(\.{1}|::)[\s]*$/)
@@ -108,11 +112,6 @@ module Solargraph
         @column
       end
 
-      # @return [Position]
-      def position
-        @position ||= Position.new(line, column)
-      end
-
       # True if the current offset is inside a string.
       #
       # @return [Boolean]
@@ -126,6 +125,9 @@ module Solargraph
         @offset ||= get_offset(line, column)
       end
 
+      # @param line [Integer]
+      # @param column [Integer]
+      # @return [Integer]
       def get_offset line, column
         Position.line_char_to_offset(@source.code, line, column)
       end

data/lib/solargraph/source_map.rb

@@ -15,16 +15,11 @@ module Solargraph
     # @return [Array<Pin::Base>]
     attr_reader :locals
 
-    # @return [Array<Pin::Reference>]
-    attr_reader :requires
-
-    def initialize source, pins, locals, requires, symbols
+    def initialize source, pins, locals
       # HACK: Keep the library from changing this
       @source = source.dup
       @pins = pins
       @locals = locals
-      @requires = requires
-      @pins.concat symbols
     end
 
     def filename
@@ -35,6 +30,10 @@ module Solargraph
       source.code
     end
 
+    def requires
+      @requires ||= pins.select{|p| p.kind == Pin::REQUIRE_REFERENCE}
+    end
+
     # @param position [Position]
     # @return [Boolean]
     def string_at? position

data/lib/solargraph/source_map/clip.rb

@@ -1,11 +1,12 @@
 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
-        # @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
@@ -36,7 +37,7 @@ module Solargraph
             elsif cursor.word.start_with?('$')
               return package_completions(api_map.get_global_variable_pins)
             end
-            result.concat prefer_non_nil_variables(locals)
+            result.concat 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')
@@ -53,17 +54,11 @@ module Solargraph
         clip.define.select{|pin| pin.kind == Pin::METHOD}
       end
 
+      # @return [ComplexType]
       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.
@@ -93,31 +88,23 @@ module Solargraph
         @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
       end
 
-      # @param cursor [cursor]
+      # 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
+
       # @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))}
+        filtered = result.uniq(&:name).select { |s|
+          s.name.downcase.start_with?(frag_start) &&
+            (s.kind != Pin::METHOD || 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