solargraph 0.32.1 → 0.32.2

data/lib/solargraph/bundle.rb

@@ -1,24 +1,24 @@
-module Solargraph
-  # An aggregation of a workspace and additional sources to be cataloged in an
-  # ApiMap.
-  #
-  class Bundle
-    # @return [Workspace]
-    attr_reader :workspace
-
-    # @return [Array<Source>]
-    attr_reader :opened
-
-    # @param workspace [Workspace]
-    # @param opened [Array<Source>]
-    def initialize workspace: Workspace.new, opened: []
-      @workspace = workspace
-      @opened = opened
-    end
-
-    # @return [Array<Source>]
-    def sources
-      @sources ||= (opened + workspace.sources).uniq(&:filename)
-    end
-  end
-end
+module Solargraph
+  # An aggregation of a workspace and additional sources to be cataloged in an
+  # ApiMap.
+  #
+  class Bundle
+    # @return [Workspace]
+    attr_reader :workspace
+
+    # @return [Array<Source>]
+    attr_reader :opened
+
+    # @param workspace [Workspace]
+    # @param opened [Array<Source>]
+    def initialize workspace: Workspace.new, opened: []
+      @workspace = workspace
+      @opened = opened
+    end
+
+    # @return [Array<Source>]
+    def sources
+      @sources ||= (opened + workspace.sources).uniq(&:filename)
+    end
+  end
+end

data/lib/solargraph/complex_type.rb

@@ -1,150 +1,150 @@
-module Solargraph
-  # A container for type data based on YARD type tags.
-  #
-  class ComplexType < Array
-    # @todo Figure out how to add the basic type methods here without actually
-    #   including the module. One possibility:
-    #
-    # @!parse
-    #   include TypeMethods
-
-    autoload :TypeMethods, 'solargraph/complex_type/type_methods'
-    autoload :UniqueType,  'solargraph/complex_type/unique_type'
-
-    # @param types [Array<ComplexType>]
-    def initialize types = [ComplexType::UNDEFINED]
-      super()
-      concat types
-    end
-
-    # @param api_map [ApiMap]
-    # @param context [String]
-    # @return [ComplexType]
-    def qualify api_map, context = ''
-      types = map do |t|
-        t.qualify api_map, context
-      end
-      ComplexType.new(types)
-    end
-
-    def method_missing name, *args, &block
-      return if first.nil?
-      return first.send(name, *args, &block) if respond_to_missing?(name)
-      super
-    end
-
-    def respond_to_missing?(name, include_private = false)
-      TypeMethods.public_instance_methods.include?(name) || super
-    end
-
-    def to_s
-      map(&:tag).join(', ')
-    end
-
-    class << self
-      # Parse type strings into a ComplexType.
-      #
-      # @example
-      #   ComplexType.parse 'String', 'Foo', 'nil' #=> [String, Foo, nil]
-      #
-      # @note
-      #   The `partial` parameter is used to indicate that the method is
-      #   receiving a string that will be used inside another ComplexType.
-      #   It returns arrays of ComplexTypes instead of a single cohesive one.
-      #   Consumers should not need to use this parameter; it should only be
-      #   used internally.
-      #
-      # @param *strings [Array<String>] The type definitions to parse
-      # @param partial [Boolean] True if the string is part of a another type
-      # @return [ComplexType]
-      def parse *strings, partial: false
-        @cache ||= {}
-        unless partial
-          cached = @cache[strings]
-          return cached unless cached.nil?
-        end
-        types = []
-        key_types = nil
-        strings.each do |type_string|
-          point_stack = 0
-          curly_stack = 0
-          paren_stack = 0
-          base = ''
-          subtype_string = ''
-          type_string.each_char do |char|
-            if char == '='
-              #raise ComplexTypeError, "Invalid = in type #{type_string}" unless curly_stack > 0
-            elsif char == '<'
-              point_stack += 1
-            elsif char == '>'
-              if subtype_string.end_with?('=') && curly_stack > 0
-                subtype_string += char
-              elsif base.end_with?('=')
-                raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
-                types.push ComplexType.new([UniqueType.new(base[0..-2].strip)])
-                key_types = types
-                types = []
-                base = ''
-                subtype_string = ''
-                next
-              else
-                point_stack -= 1
-                subtype_string += char if point_stack == 0
-                raise ComplexTypeError, "Invalid close in type #{type_string}" if point_stack < 0
-              end
-              next
-            elsif char == '{'
-              curly_stack += 1
-            elsif char == '}'
-              curly_stack -= 1
-              subtype_string += char
-              raise ComplexTypeError, "Invalid close in type #{type_string}" if curly_stack < 0
-              next
-            elsif char == '('
-              paren_stack += 1
-            elsif char == ')'
-              paren_stack -= 1
-              subtype_string += char if paren_stack == 0
-              raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack < 0
-              next
-            elsif char == ',' && point_stack == 0 && curly_stack == 0 && paren_stack == 0
-              types.push ComplexType.new([UniqueType.new(base.strip, subtype_string.strip)])
-              base = ''
-              subtype_string = ''
-              next
-            end
-            if point_stack == 0 && curly_stack == 0 && paren_stack == 0
-              base += char 
-            else
-              subtype_string += char
-            end
-          end
-          base.strip!
-          subtype_string.strip!
-          raise ComplexTypeError, "Unclosed subtype in #{type_string}" if point_stack != 0 || curly_stack != 0 || paren_stack != 0
-          types.push ComplexType.new([UniqueType.new(base, subtype_string)])
-        end
-        unless key_types.nil?
-          raise ComplexTypeError, "Invalid use of key/value parameters" unless partial
-          return key_types if types.empty?
-          return [key_types, types]
-        end
-        result = partial ? types : ComplexType.new(types)
-        @cache[strings] = result unless partial
-        result
-      end
-
-      def try_parse *strings
-        parse *strings
-      rescue ComplexTypeError => e
-        Solargraph.logger.info "Error parsing complex type: #{e.message}"
-        ComplexType::UNDEFINED
-      end
-    end
-
-    VOID = ComplexType.parse('void')
-    UNDEFINED = ComplexType.parse('undefined')
-    SYMBOL = ComplexType.parse('Symbol')
-    ROOT = ComplexType.parse('Class<>')
-  end
-end
+module Solargraph
+  # A container for type data based on YARD type tags.
+  #
+  class ComplexType < Array
+    # @todo Figure out how to add the basic type methods here without actually
+    #   including the module. One possibility:
+    #
+    # @!parse
+    #   include TypeMethods
+
+    autoload :TypeMethods, 'solargraph/complex_type/type_methods'
+    autoload :UniqueType,  'solargraph/complex_type/unique_type'
+
+    # @param types [Array<ComplexType>]
+    def initialize types = [ComplexType::UNDEFINED]
+      super()
+      concat types
+    end
+
+    # @param api_map [ApiMap]
+    # @param context [String]
+    # @return [ComplexType]
+    def qualify api_map, context = ''
+      types = map do |t|
+        t.qualify api_map, context
+      end
+      ComplexType.new(types)
+    end
+
+    def method_missing name, *args, &block
+      return if first.nil?
+      return first.send(name, *args, &block) if respond_to_missing?(name)
+      super
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      TypeMethods.public_instance_methods.include?(name) || super
+    end
+
+    def to_s
+      map(&:tag).join(', ')
+    end
+
+    class << self
+      # Parse type strings into a ComplexType.
+      #
+      # @example
+      #   ComplexType.parse 'String', 'Foo', 'nil' #=> [String, Foo, nil]
+      #
+      # @note
+      #   The `partial` parameter is used to indicate that the method is
+      #   receiving a string that will be used inside another ComplexType.
+      #   It returns arrays of ComplexTypes instead of a single cohesive one.
+      #   Consumers should not need to use this parameter; it should only be
+      #   used internally.
+      #
+      # @param *strings [Array<String>] The type definitions to parse
+      # @param partial [Boolean] True if the string is part of a another type
+      # @return [ComplexType]
+      def parse *strings, partial: false
+        @cache ||= {}
+        unless partial
+          cached = @cache[strings]
+          return cached unless cached.nil?
+        end
+        types = []
+        key_types = nil
+        strings.each do |type_string|
+          point_stack = 0
+          curly_stack = 0
+          paren_stack = 0
+          base = ''
+          subtype_string = ''
+          type_string.each_char do |char|
+            if char == '='
+              #raise ComplexTypeError, "Invalid = in type #{type_string}" unless curly_stack > 0
+            elsif char == '<'
+              point_stack += 1
+            elsif char == '>'
+              if subtype_string.end_with?('=') && curly_stack > 0
+                subtype_string += char
+              elsif base.end_with?('=')
+                raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
+                types.push ComplexType.new([UniqueType.new(base[0..-2].strip)])
+                key_types = types
+                types = []
+                base = ''
+                subtype_string = ''
+                next
+              else
+                point_stack -= 1
+                subtype_string += char if point_stack == 0
+                raise ComplexTypeError, "Invalid close in type #{type_string}" if point_stack < 0
+              end
+              next
+            elsif char == '{'
+              curly_stack += 1
+            elsif char == '}'
+              curly_stack -= 1
+              subtype_string += char
+              raise ComplexTypeError, "Invalid close in type #{type_string}" if curly_stack < 0
+              next
+            elsif char == '('
+              paren_stack += 1
+            elsif char == ')'
+              paren_stack -= 1
+              subtype_string += char if paren_stack == 0
+              raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack < 0
+              next
+            elsif char == ',' && point_stack == 0 && curly_stack == 0 && paren_stack == 0
+              types.push ComplexType.new([UniqueType.new(base.strip, subtype_string.strip)])
+              base = ''
+              subtype_string = ''
+              next
+            end
+            if point_stack == 0 && curly_stack == 0 && paren_stack == 0
+              base += char 
+            else
+              subtype_string += char
+            end
+          end
+          base.strip!
+          subtype_string.strip!
+          raise ComplexTypeError, "Unclosed subtype in #{type_string}" if point_stack != 0 || curly_stack != 0 || paren_stack != 0
+          types.push ComplexType.new([UniqueType.new(base, subtype_string)])
+        end
+        unless key_types.nil?
+          raise ComplexTypeError, "Invalid use of key/value parameters" unless partial
+          return key_types if types.empty?
+          return [key_types, types]
+        end
+        result = partial ? types : ComplexType.new(types)
+        @cache[strings] = result unless partial
+        result
+      end
+
+      def try_parse *strings
+        parse *strings
+      rescue ComplexTypeError => e
+        Solargraph.logger.info "Error parsing complex type: #{e.message}"
+        ComplexType::UNDEFINED
+      end
+    end
+
+    VOID = ComplexType.parse('void')
+    UNDEFINED = ComplexType.parse('undefined')
+    SYMBOL = ComplexType.parse('Symbol')
+    ROOT = ComplexType.parse('Class<>')
+  end
+end

data/lib/solargraph/complex_type/type_methods.rb

@@ -1,124 +1,124 @@
-module Solargraph
-  class ComplexType
-    # Methods for accessing type data.
-    #
-    module TypeMethods
-      # @return [String]
-      attr_reader :name
-
-      # @return [String]
-      attr_reader :substring
-
-      # @return [String]
-      attr_reader :tag
-
-      # @return [Array<ComplexType>]
-      attr_reader :subtypes
-
-      # @return [Boolean]
-      def duck_type?
-        @duck_type ||= name.start_with?('#')
-      end
-
-      # @return [Boolean]
-      def nil_type?
-        @nil_type ||= (name.downcase == 'nil')
-      end
-
-      # @return [Boolean]
-      def parameters?
-        !substring.empty?
-      end
-
-      def void?
-        name == 'void'
-      end
-
-      def defined?
-        !undefined?
-      end
-
-      def undefined?
-        name == 'undefined'
-      end
-
-      # @return [Boolean]
-      def list_parameters?
-        substring.start_with?('<')
-      end
-
-      # @return [Boolean]
-      def fixed_parameters?
-        substring.start_with?('(')
-      end
-
-      # @return [Boolean]
-      def hash_parameters?
-        substring.start_with?('{')
-      end
-
-      # @return [Array<ComplexType>]
-      def value_types
-        @subtypes
-      end
-
-      # @return [Array<ComplexType>]
-      def key_types
-        @key_types
-      end
-
-      # @return [String]
-      def namespace
-        @namespace ||= 'Object' if duck_type?
-        @namespace ||= 'NilClass' if nil_type?
-        @namespace ||= (name == 'Class' || name == 'Module') && !subtypes.empty? ? subtypes.first.name : name
-      end
-
-      # @return [Symbol] :class or :instance
-      def scope
-        @scope ||= :instance if duck_type? || nil_type?
-        @scope ||= (name == 'Class' || name == 'Module') && !subtypes.empty? ? :class : :instance
-      end
-
-      def == other
-        return false unless self.class == other.class
-        tag == other.tag
-      end
-
-      def rooted?
-        @rooted
-      end
-
-      # Generate a ComplexType that fully qualifies this type's namespaces.
-      #
-      # @param api_map [ApiMap] The ApiMap that performs qualification
-      # @param context [String] The namespace from which to resolve names
-      # @return [ComplexType] The generated ComplexType
-      def qualify api_map, context = ''
-        return ComplexType.new([self]) if duck_type? || void? || undefined?
-        recon = (rooted? ? '' : context)
-        fqns = api_map.qualify(name, recon)
-        if fqns.nil?
-          return ComplexType.parse('Boolean') if tag == 'Boolean'
-          return ComplexType::UNDEFINED
-        end
-        fqns = "::#{fqns}" # Ensure the resulting complex type is rooted
-        ltypes = key_types.map do |t|
-          t.qualify api_map, context
-        end
-        rtypes = value_types.map do |t|
-          t.qualify api_map, context
-        end
-        if list_parameters?
-          Solargraph::ComplexType.parse("#{fqns}<#{rtypes.map(&:tag).join(', ')}>").first
-        elsif fixed_parameters?
-          Solargraph::ComplexType.parse("#{fqns}(#{rtypes.map(&:tag).join(', ')})").first
-        elsif hash_parameters?
-          Solargraph::ComplexType.parse("#{fqns}{#{ltypes.map(&:tag).join(', ')} => #{rtypes.map(&:tag).join(', ')}}").first
-        else
-          Solargraph::ComplexType.parse(fqns).first
-        end
-      end
-    end
-  end
-end
+module Solargraph
+  class ComplexType
+    # Methods for accessing type data.
+    #
+    module TypeMethods
+      # @return [String]
+      attr_reader :name
+
+      # @return [String]
+      attr_reader :substring
+
+      # @return [String]
+      attr_reader :tag
+
+      # @return [Array<ComplexType>]
+      attr_reader :subtypes
+
+      # @return [Boolean]
+      def duck_type?
+        @duck_type ||= name.start_with?('#')
+      end
+
+      # @return [Boolean]
+      def nil_type?
+        @nil_type ||= (name.downcase == 'nil')
+      end
+
+      # @return [Boolean]
+      def parameters?
+        !substring.empty?
+      end
+
+      def void?
+        name == 'void'
+      end
+
+      def defined?
+        !undefined?
+      end
+
+      def undefined?
+        name == 'undefined'
+      end
+
+      # @return [Boolean]
+      def list_parameters?
+        substring.start_with?('<')
+      end
+
+      # @return [Boolean]
+      def fixed_parameters?
+        substring.start_with?('(')
+      end
+
+      # @return [Boolean]
+      def hash_parameters?
+        substring.start_with?('{')
+      end
+
+      # @return [Array<ComplexType>]
+      def value_types
+        @subtypes
+      end
+
+      # @return [Array<ComplexType>]
+      def key_types
+        @key_types
+      end
+
+      # @return [String]
+      def namespace
+        @namespace ||= 'Object' if duck_type?
+        @namespace ||= 'NilClass' if nil_type?
+        @namespace ||= (name == 'Class' || name == 'Module') && !subtypes.empty? ? subtypes.first.name : name
+      end
+
+      # @return [Symbol] :class or :instance
+      def scope
+        @scope ||= :instance if duck_type? || nil_type?
+        @scope ||= (name == 'Class' || name == 'Module') && !subtypes.empty? ? :class : :instance
+      end
+
+      def == other
+        return false unless self.class == other.class
+        tag == other.tag
+      end
+
+      def rooted?
+        @rooted
+      end
+
+      # Generate a ComplexType that fully qualifies this type's namespaces.
+      #
+      # @param api_map [ApiMap] The ApiMap that performs qualification
+      # @param context [String] The namespace from which to resolve names
+      # @return [ComplexType] The generated ComplexType
+      def qualify api_map, context = ''
+        return ComplexType.new([self]) if duck_type? || void? || undefined?
+        recon = (rooted? ? '' : context)
+        fqns = api_map.qualify(name, recon)
+        if fqns.nil?
+          return ComplexType.parse('Boolean') if tag == 'Boolean'
+          return ComplexType::UNDEFINED
+        end
+        fqns = "::#{fqns}" # Ensure the resulting complex type is rooted
+        ltypes = key_types.map do |t|
+          t.qualify api_map, context
+        end
+        rtypes = value_types.map do |t|
+          t.qualify api_map, context
+        end
+        if list_parameters?
+          Solargraph::ComplexType.parse("#{fqns}<#{rtypes.map(&:tag).join(', ')}>").first
+        elsif fixed_parameters?
+          Solargraph::ComplexType.parse("#{fqns}(#{rtypes.map(&:tag).join(', ')})").first
+        elsif hash_parameters?
+          Solargraph::ComplexType.parse("#{fqns}{#{ltypes.map(&:tag).join(', ')} => #{rtypes.map(&:tag).join(', ')}}").first
+        else
+          Solargraph::ComplexType.parse(fqns).first
+        end
+      end
+    end
+  end
+end