solargraph 0.25.1 → 0.26.0

data/lib/solargraph/api_map/source_to_yard.rb

@@ -14,29 +14,29 @@ module Solargraph
       end
 
       # @param sources [Array<Solargraph::Source>] Sources for code objects
-      def rake_yard sources
+      def rake_yard store
         code_object_map.clear
-        sources.each do |s|
-          s.namespace_pins.each do |pin|
-            next if pin.path.empty?
+        #sources.each do |s|
+          store.namespace_pins.each do |pin|
+            next if pin.path.nil? or pin.path.empty?
             if pin.type == :class
               code_object_map[pin.path] ||= YARD::CodeObjects::ClassObject.new(root_code_object, pin.path)
             else
               code_object_map[pin.path] ||= YARD::CodeObjects::ModuleObject.new(root_code_object, pin.path)
             end
             code_object_map[pin.path].docstring = pin.docstring
-            code_object_map[pin.path].files.push pin.location.filename
+            code_object_map[pin.path].files.push pin.location.filename unless pin.location.nil?
           end
-          s.namespace_pins.each do |pin|
+          store.namespace_pins.each do |pin|
             pin.include_references.each do |ref|
               code_object_map[pin.path].instance_mixins.push code_object_map[ref.name] unless code_object_map[ref.name].nil? or code_object_map[pin.path].nil?
             end
           end
-          s.method_pins.each do |pin|
+          store.method_pins.each do |pin|
             code_object_map[pin.path] ||= YARD::CodeObjects::MethodObject.new(code_object_at(pin.namespace), pin.name, pin.scope)
             code_object_map[pin.path].docstring = pin.docstring
             code_object_map[pin.path].visibility = pin.visibility || :public
-            code_object_map[pin.path].files.push pin.location.filename
+            code_object_map[pin.path].files.push pin.location.filename unless pin.location.nil?
             code_object_map[pin.path].parameters = pin.parameters.map do |p|
               n = p.match(/^[a-z0-9_]*:?/i)[0]
               v = nil
@@ -46,7 +46,7 @@ module Solargraph
               [n, v]
             end
           end
-        end
+        #end
       end
 
       private

data/lib/solargraph/api_map/store.rb

@@ -4,8 +4,9 @@ module Solargraph
   class ApiMap
     class Store
       # @param sources [Array<Solargraph::Source>]
+      # @param yard_pins [Array<Solargraph::Pin::Base>]
       def initialize sources, yard_pins
-        inner_update *sources
+        inner_update sources
         pins.concat yard_pins
         index
       end
@@ -15,6 +16,8 @@ module Solargraph
         @pins ||= []
       end
 
+      # @param *sources [Array<Solargraph::Source>]
+      # @return [void]
       def remove *sources
         sources.each do |source|
           pins.delete_if { |pin| !pin.yard_pin? and pin.filename == source.filename }
@@ -23,33 +26,45 @@ module Solargraph
         index
       end
 
+      # @param *sources [Array<Solargraph::Source>]
+      # @return [void]
       def update *sources
-        inner_update *sources
+        inner_update sources
         index
       end
 
+      # @param yard_pins [Array<Solargraph::Pin::Base>]
+      # @return [void]
       def update_yard yard_pins
         pins.delete_if(&:yard_pin?)
         pins.concat yard_pins
         index
       end
 
+      # @param fqns [String]
+      # @param visibility [Array<Symbol>]
       # @return [Array<Solargraph::Pin::Base>]
       def get_constants fqns, visibility = [:public]
-        namespace_pins(fqns).select { |pin|
+        namespace_children(fqns).select { |pin|
           !pin.name.empty? and (pin.kind == Pin::NAMESPACE or pin.kind == Pin::CONSTANT) and visibility.include?(pin.visibility)
         }
       end
 
+      # @param fqns [String]
+      # @param scope [Symbol]
+      # @param visibility [Array<Symbol>]
+      # @return [Array<Solargraph::Pin::Base>]
       def get_methods fqns, scope: :instance, visibility: [:public]
-        namespace_pins(fqns).select{ |pin|
+        namespace_children(fqns).select{ |pin|
           pin.kind == Pin::METHOD and (pin.scope == scope or fqns == '') and visibility.include?(pin.visibility)
         }
       end
 
+      # @param fqns [String]
+      # @param scope [Symbol]
       # @return [Array<Solargraph::Pin::Base>]
       def get_attrs fqns, scope
-        namespace_pins(fqns).select{ |pin| pin.kind == Pin::ATTRIBUTE and pin.scope == scope }
+        namespace_children(fqns).select{ |pin| pin.kind == Pin::ATTRIBUTE and pin.scope == scope }
       end
 
       # @param fqns [String]
@@ -84,22 +99,24 @@ module Solargraph
       # @param path [String]
       # @return [Array<Solargraph::Pin::Base>]
       def get_path_pins path
+        # return [] if path.nil? # @todo Should be '' instead?
+        path ||= ''
         base = path.sub(/(#|\.|::)[a-z0-9_]*(\?|\!)?$/i, '')
         base = '' if base == path
-        namespace_pins(base).select{ |pin| pin.path == path }
+        namespace_children(base).select{ |pin| pin.path == path }
       end
 
       # @param fqns [String]
       # @param scope [Symbol] :class or :instance
       # @return [Array<Solargraph::Pin::Base>]
       def get_instance_variables(fqns, scope = :instance)
-        namespace_pins(fqns).select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.scope == scope}
+        namespace_children(fqns).select{|pin| pin.kind == Pin::INSTANCE_VARIABLE and pin.scope == scope}
       end
 
       # @param fqns [String]
       # @return [Array<Solargraph::Pin::Base>]
       def get_class_variables(fqns)
-        namespace_pins(fqns).select{|pin| pin.kind == Pin::CLASS_VARIABLE}
+        namespace_children(fqns).select{|pin| pin.kind == Pin::CLASS_VARIABLE}
       end
 
       # @return [Array<Solargraph::Pin::Base>]
@@ -118,11 +135,22 @@ module Solargraph
         @namespaces ||= Set.new
       end
 
+      # @return [Array<Solargraph::Pin::Base>]
+      def namespace_pins
+        @namespace_pins ||= pins.select{|p| p.kind == Pin::NAMESPACE}
+      end
+
+      # @return [Array<Solargraph::Pin::Base>]
+      def method_pins
+        @method_pins ||= pins.select{|p| p.kind == Pin::METHOD or p.kind == Pin::ATTRIBUTE}
+      end
+
       private
 
+      # @param fqns [String]
+      # @return [Array<Solargraph::Pin::Namespace>]
       def fqns_pins fqns
-        # @todo We probably want to ignore '' namespace here
-        return [] if fqns.nil? #or fqns.empty?
+        return [] if fqns.nil?
         if fqns.include?('::')
           parts = fqns.split('::')
           name = parts.pop
@@ -131,21 +159,26 @@ module Solargraph
           base = ''
           name = fqns
         end
-        namespace_pins(base).select{|pin| pin.name == name and pin.kind == Pin::NAMESPACE}
+        namespace_children(base).select{|pin| pin.name == name and pin.kind == Pin::NAMESPACE}
       end
 
+      # @return [Array<Solargraph::Pin::Symbol>]
       def symbols
         @symbols ||= []
       end
 
-      def namespace_pins name
+      # @param name [String]
+      # @return [Array<Solargraph::Pin::Namespace>]
+      def namespace_children name
         namespace_map[name] || []
       end
 
+      # @return [Hash]
       def namespace_map
         @namespace_map ||= {}
       end
 
+      # @return [void]
       def index
         namespace_map.clear
         namespaces.clear
@@ -155,9 +188,13 @@ module Solargraph
           namespace_map[pin.namespace].push pin
           namespaces.add pin.path if pin.kind == Pin::NAMESPACE and !pin.path.empty?
         end
+        @namespace_pins = nil
+        @method_pins = nil
       end
 
-      def inner_update *sources
+      # @param sources [Array<Solargraph::Source>]
+      # @return [void]
+      def inner_update sources
         sources.each do |source|
           pins.delete_if { |pin| !pin.yard_pin? and pin.filename == source.filename }
           symbols.delete_if { |pin| pin.filename == source.filename }

data/lib/solargraph/basic_type.rb

@@ -0,0 +1,33 @@
+module Solargraph
+  class BasicType
+    include BasicTypeMethods
+
+    # Create a BasicType with the specified name and an optional substring.
+    # The substring is the parameter section of a parametrized type, e.g., for
+    # the type `Array<String>`, the name is `Array` and the substring is
+    # `<String>`.
+    #
+    # @param name [String] The name of the type
+    # @param substring [String] The substring of the type
+    def initialize name, substring = ''
+      @name = name
+      @substring = substring
+      @tag = name + substring
+      @key_types = []
+      @subtypes = []
+      return unless parameters?
+      subs = ComplexType.parse(substring[1..-2], partial: true)
+      if hash_parameters?
+        raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(ComplexType) and !subs[1].is_a?(ComplexType)
+        @key_types.concat subs[0]
+        @subtypes.concat subs[1]
+      else
+        @subtypes.concat subs
+      end
+    end
+
+    def to_s
+      tag
+    end
+  end
+end

data/lib/solargraph/basic_type_methods.rb

@@ -0,0 +1,111 @@
+module Solargraph
+  module BasicTypeMethods
+    # @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' or name == 'Module') and !subtypes.empty?) ? subtypes.first.name : name
+    end
+
+    # @return [Symbol] :class or :instance
+    def scope
+      @scope ||= :instance if duck_type? or nil_type?
+      @scope ||= ((name == 'Class' or name == 'Module') and !subtypes.empty?) ? :class : :instance
+    end
+
+    def == other
+      return false unless self.class == other.class
+      tag == other.tag
+    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.parse(tag) if duck_type? or void? or undefined?
+      fqns = api_map.qualify(name, context)
+      return ComplexType::UNDEFINED if fqns.nil?
+      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

data/lib/solargraph/complex_type.rb

@@ -1,103 +1,58 @@
 module Solargraph
-  class ComplexType
-    # @return [String]
-    attr_reader :name
-
-    # @return [String]
-    attr_reader :substring
-
-    # @return [String]
-    attr_reader :tag
-
-    # @return [Array<ComplexType>]
-    attr_reader :subtypes
-
-    # Create a ComplexType with the specified name and an optional substring.
-    # The substring is parameter of a parameterized type, e.g., for the type
-    # `Array<String>`, the name is `Array` and the substring is `String`.
+  class ComplexType < Array
+    # @todo Figure out how to add the basic type methods here without actually
+    #   including the module. One possibility:
     #
-    # @param name [String] The name of the type
-    # @param substring [String] The substring of the type
-    def initialize name, substring = ''
-      @name = name
-      @substring = substring
-      @tag = name + substring
-      @key_types = []
-      @subtypes = []
-      if parameters?
-        subs = ComplexType.parse(substring[1..-2])
-        if hash_parameters?
-          raise ComplexTypeError, "Bad hash type" unless subs.length == 2 and subs[0].is_a?(Array) and subs[1].is_a?(Array)
-          @key_types.concat subs[0]
-          @subtypes.concat subs[1]
-        else
-          @subtypes.concat subs
-        end
-      end
-    end
-
-    # @return [Boolean]
-    def duck_type?
-      @duck_type ||= name.start_with?('#')
-    end
-
-    # @return [Boolean]
-    def nil_type?
-      @nil_type ||= (name.downcase == 'nil')
-    end
+    # @!parse
+    #   include BasicTypeMethods
 
-    # @return [Boolean]
-    def parameters?
-      !substring.empty?
+    def initialize types = [ComplexType::UNDEFINED]
+      super()
+      concat types
     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
+    def qualify api_map, context = ''
+      types = map do |t|
+        t.qualify api_map, context
+      end
+      ComplexType.new(types)
     end
 
-    # @return [String]
-    def namespace
-      @namespace ||= 'Object' if duck_type?
-      @namespace ||= 'NilClass' if nil_type?
-      @namespace ||= ((name == 'Class' or name == 'Module') and !subtypes.empty?) ? subtypes.first.name : name
+    def method_missing name, *args, &block
+      return first.send(name, *args, &block) if respond_to_missing?(name)
+      super
     end
 
-    # @return [Symbol] :class or :instance
-    def scope
-      @scope ||= :instance if duck_type? or nil_type?
-      @scope ||= ((name == 'Class' or name == 'Module') and !subtypes.empty?) ? :class : :instance
+    def respond_to_missing?(name, include_private = false)
+      BasicTypeMethods.public_instance_methods.include?(name) || super
     end
 
-    def == other
-      return false unless self.class == other.class
-      tag == other.tag
+    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
-      # @return [Array<ComplexType>]
-      def parse *strings
+      # @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|
@@ -116,7 +71,7 @@ module Solargraph
                 subtype_string += char
               elsif base.end_with?('=')
                 raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
-                types.push ComplexType.new(base[0..-2].strip)
+                types.push ComplexType.new([BasicType.new(base[0..-2].strip)])
                 key_types = types
                 types = []
                 base = ''
@@ -144,7 +99,7 @@ module Solargraph
               raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack < 0
               next
             elsif char == ',' and point_stack == 0 and curly_stack == 0 and paren_stack == 0
-              types.push ComplexType.new base.strip, subtype_string.strip
+              types.push ComplexType.new([BasicType.new(base.strip, subtype_string.strip)])
               base = ''
               subtype_string = ''
               next
@@ -158,14 +113,21 @@ module Solargraph
           base.strip!
           subtype_string.strip!
           raise ComplexTypeError, "Unclosed subtype in #{type_string}" if point_stack != 0 or curly_stack != 0 or paren_stack != 0
-          types.push ComplexType.new(base, subtype_string)
+          types.push ComplexType.new([BasicType.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
-        types
+        result = partial ? types : ComplexType.new(types)
+        @cache[strings] = result unless partial
+        result
       end
     end
+
+    VOID = ComplexType.parse('void')
+    UNDEFINED = ComplexType.parse('undefined')
+    SYMBOL = ComplexType.parse('Symbol')
   end
 end