jimeh-solargraph 0.40.4.0

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class GlobalVariable < Link
+        def resolve api_map, name_pin, locals
+          api_map.get_global_variable_pins.select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
+      # either a class (`String`) or a function (`Kernel#String`).
+      #
+      # @note Chain::Head is only intended to handle `self` and `super`.
+      class Head < Link
+        def resolve api_map, name_pin, locals
+          return [Pin::ProxyType.anonymous(name_pin.binder)] if word == 'self'
+          # return super_pins(api_map, name_pin) if word == 'super'
+          []
+        end
+
+        # @todo This is temporary. Chain heads need to handle arguments to
+        #   `super`.
+        # def arguments
+        #   []
+        # end
+
+        private
+
+        # # @param api_map [ApiMap]
+        # # @param name_pin [Pin::Base]
+        # # @return [Array<Pin::Base>]
+        # def super_pins api_map, name_pin
+        #   pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
+        #   pins.reject{|p| p.path == name_pin.path}
+        # end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class InstanceVariable < Link
+        def resolve api_map, name_pin, locals
+          api_map.get_instance_variable_pins(name_pin.binder.namespace, name_pin.binder.scope).select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Link
+        # @return [String]
+        attr_reader :word
+
+        attr_accessor :last_context
+
+        def initialize word = '<undefined>'
+          @word = word
+        end
+
+        def undefined?
+          word == '<undefined>'
+        end
+
+        def constant?
+          is_a?(Chain::Constant)
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [Array<Pin::Base>]
+        # @return [Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          []
+        end
+
+        def head?
+          @head ||= false
+        end
+
+        def == other
+          self.class == other.class and word == other.word
+        end
+
+        # Make a copy of this link marked as the head of a chain
+        #
+        # @return [self]
+        def clone_head
+          clone.mark_head(true)
+        end
+
+        # Make a copy of this link unmarked as the head of a chain
+        #
+        # @return [self]
+        def clone_body
+          clone.mark_head(false)
+        end
+
+        protected
+
+        # Mark whether this link is the head of a chain
+        #
+        # @param bool [Boolean]
+        # @return [self]
+        def mark_head bool
+          @head = bool
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Literal < Link
+        def word
+          @word ||= "<#{@type}>"
+        end
+
+        # @param type [String]
+        def initialize type
+          @type = type
+          @complex_type = ComplexType.try_parse(type)
+        end
+
+        def resolve api_map, name_pin, locals
+          [Pin::ProxyType.anonymous(@complex_type)]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Or < Link
+        def word
+          '<or>'
+        end
+
+        # @param type [String]
+        def initialize links
+          @links = links
+        end
+
+        def resolve api_map, name_pin, locals
+          types = @links.map { |link| link.infer(api_map, name_pin, locals) }
+          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.try_parse(types.map(&:tag).uniq.join(', ')))]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Variable < Link
+        def resolve api_map, name_pin, locals
+          api_map.get_instance_variable_pins(name_pin.context.namespace, name_pin.context.scope).select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class ZSuper < Call
+        # @return [String]
+        attr_reader :word
+
+        # @return [Array<Chain>]
+        attr_reader :arguments
+
+        # @param word [String]
+        # @param arguments [Array<Chain>]
+        # @param with_block [Boolean] True if the chain is inside a block
+        # @param head [Boolean] True if the call is the start of its chain
+        def initialize word, with_block = false
+          super(word, [], with_block)
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          return super_pins(api_map, name_pin)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/change.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    # A change to be applied to text.
+    #
+    class Change
+      include EncodingFixes
+
+      # @return [Range]
+      attr_reader :range
+
+      # @return [String]
+      attr_reader :new_text
+
+      # @param range [Range] The starting and ending positions of the change.
+      #   If nil, the original text will be overwritten.
+      # @param new_text [String] The text to be changed.
+      def initialize range, new_text
+        @range = range
+        @new_text = new_text
+      end
+
+      # Write the change to the specified text.
+      #
+      # @param text [String] The text to be changed.
+      # @param nullable [Boolean] If true, minor changes that could generate
+      #   syntax errors will be repaired.
+      # @return [String] The updated text.
+      def write text, nullable = false
+        if nullable and !range.nil? and new_text.match(/[\.\[\{\(@\$:]$/)
+          [':', '@'].each do |dupable|
+            next unless new_text == dupable
+            offset = Position.to_offset(text, range.start)
+            if text[offset - 1] == dupable
+              p = Position.from_offset(text, offset - 1)
+              r = Change.new(Range.new(p, range.start), ' ')
+              text = r.write(text)
+            end
+            break
+          end
+          commit text, "#{new_text[0..-2]} "
+        elsif range.nil?
+          new_text
+        else
+          commit text, new_text
+        end
+      end
+
+      # Repair an update by replacing the new text with similarly formatted
+      # whitespace.
+      #
+      # @param text [String] The text to be changed.
+      # @return [String] The updated text.
+      def repair text
+        fixed = new_text.gsub(/[^\s]/, ' ')
+        if range.nil?
+          fixed
+        else
+          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
+
+      private
+
+      def commit text, insert
+        start_offset = Position.to_offset(text, range.start)
+        end_offset = Position.to_offset(text, range.ending)
+        (start_offset == 0 ? '' : text[0..start_offset-1].to_s) + normalize(insert) + text[end_offset..-1].to_s
+      end
+    end
+  end
+end

data/lib/solargraph/source/cursor.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    # Information about a position in a source, including the word located
+    # there.
+    #
+    class Cursor
+      # @return [Position]
+      attr_reader :position
+
+      # @return [Source]
+      attr_reader :source
+
+      # @param source [Source]
+      # @param position [Position, Array(Integer, Integer)]
+      def initialize source, position
+        @source = source
+        @position = Position.normalize(position)
+      end
+
+      # @return [String]
+      def filename
+        source.filename
+      end
+
+      # The whole word at the current position. Given the text `foo.bar`, the
+      # word at position(0,6) is `bar`.
+      #
+      # @return [String]
+      def word
+        @word ||= start_of_word + end_of_word
+      end
+
+      # The part of the word before the current position. Given the text
+      # `foo.bar`, the start_of_word at position(0, 6) is `ba`.
+      #
+      # @return [String]
+      def start_of_word
+        @start_of_word ||= begin
+          match = source.code[0..offset-1].to_s.match(start_word_pattern)
+          result = (match ? match[0] : '')
+          # Including the preceding colon if the word appears to be a symbol
+          result = ":#{result}" if source.code[0..offset-result.length-1].end_with?(':') and !source.code[0..offset-result.length-1].end_with?('::')
+          result
+        end
+      end
+
+      # The part of the word after the current position. Given the text
+      # `foo.bar`, the end_of_word at position (0,6) is `r`.
+      #
+      # @return [String]
+      def end_of_word
+        @end_of_word ||= begin
+          match = source.code[offset..-1].to_s.match(end_word_pattern)
+          match ? match[0] : ''
+        end
+      end
+
+      # @return [Boolean]
+      def start_of_constant?
+        source.code[offset-2, 2] == '::'
+      end
+
+      # The range of the word at the current position.
+      #
+      # @return [Range]
+      def range
+        @range ||= begin
+          s = Position.from_offset(source.code, offset - start_of_word.length)
+          e = Position.from_offset(source.code, offset + end_of_word.length)
+          Solargraph::Range.new(s, e)
+        end
+      end
+
+      # @return [Chain]
+      def chain
+        @chain ||= SourceChainer.chain(source, position)
+      end
+
+      # True if the statement at the cursor is an argument to a previous
+      # method.
+      #
+      # Given the code `process(foo)`, a cursor pointing at `foo` would
+      # identify it as an argument being passed to the `process` method.
+      #
+      # If #argument? is true, the #recipient method will return a cursor that
+      # points to the method receiving the argument.
+      #
+      # @return [Boolean]
+      def argument?
+        # @argument ||= !signature_position.nil?
+        @argument ||= !recipient.nil?
+      end
+
+      # @return [Boolean]
+      def comment?
+        @comment ||= source.comment_at?(position)
+      end
+
+      # @return [Boolean]
+      def string?
+        @string ||= source.string_at?(position)
+      end
+
+      # Get a cursor pointing to the method that receives the current statement
+      # as an argument.
+      #
+      # @return [Cursor, nil]
+      def recipient
+        @recipient ||= begin
+          node = recipient_node
+          node ? Cursor.new(source, Range.from_node(node).ending) : nil
+        end
+      end
+      alias receiver recipient
+
+      def node
+        @node ||= source.node_at(position.line, position.column)
+      end
+
+      # @return [Position]
+      def node_position
+        @node_position ||= begin
+          if start_of_word.empty?
+            match = source.code[0, offset].match(/[\s]*(\.|:+)[\s]*$/)
+            if match
+              Position.from_offset(source.code, offset - match[0].length)
+            else
+              position
+            end
+          else
+            position
+          end
+        end
+      end
+
+      def recipient_node
+        @recipient_node ||= Solargraph::Parser::NodeMethods.find_recipient_node(self)
+      end
+
+      # @return [Integer]
+      def offset
+        @offset ||= Position.to_offset(source.code, position)
+      end
+
+      private
+
+      # A regular expression to find the start of a word from an offset.
+      #
+      # @return [Regexp]
+      def start_word_pattern
+        /(@{1,2}|\$)?([a-z0-9_]|[^\u0000-\u007F])*\z/i
+      end
+
+      # A regular expression to find the end of a word from an offset.
+      #
+      # @return [Regexp]
+      def end_word_pattern
+        /^([a-z0-9_]|[^\u0000-\u007F])*[\?\!]?/i
+      end
+    end
+  end
+end