solargraph 0.56.2 → 0.58.0

data/lib/solargraph/bench.rb

@@ -37,6 +37,7 @@ module Solargraph
                                       .to_h
     end
 
+    # @return [Set<SourceMap>]
     def icebox
       @icebox ||= (source_maps - [live_map])
     end

data/lib/solargraph/complex_type/type_methods.rb

@@ -43,6 +43,10 @@ module Solargraph
         @rooted_tag ||= rooted_name + rooted_substring
       end
 
+      def interface?
+        name.start_with?('_')
+      end
+
       # @return [Boolean]
       def duck_type?
         @duck_type ||= name.start_with?('#')
@@ -130,6 +134,7 @@ module Solargraph
         end.call
       end
 
+      # @return [self]
       def namespace_type
         return ComplexType.parse('::Object') if duck_type?
         return ComplexType.parse('::NilClass') if nil_type?
@@ -189,6 +194,7 @@ module Solargraph
       # @param other [Object]
       def == other
         return false unless self.class == other.class
+        # @sg-ignore https://github.com/castwide/solargraph/pull/1114
         tag == other.tag
       end
 

data/lib/solargraph/complex_type/unique_type.rb

@@ -49,11 +49,7 @@ module Solargraph
           parameters_type = PARAMETERS_TYPE_BY_STARTING_TAG.fetch(substring[0])
           if parameters_type == :hash
             raise ComplexTypeError, "Bad hash type: name=#{name}, substring=#{substring}" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
-            # @todo should be able to resolve map; both types have it
-            #   with same return type
-            # @sg-ignore
             key_types.concat(subs[0].map { |u| ComplexType.new([u]) })
-            # @sg-ignore
             subtypes.concat(subs[1].map { |u| ComplexType.new([u]) })
           elsif parameters_type == :list && name == 'Hash'
             # Treat Hash<A, B> as Hash{A => B}
@@ -105,6 +101,7 @@ module Solargraph
         tag
       end
 
+      # @return [self]
       def simplify_literals
         transform do |t|
           next t unless t.literal?
@@ -116,10 +113,12 @@ module Solargraph
         non_literal_name != name
       end
 
+      # @return [String]
       def non_literal_name
         @non_literal_name ||= determine_non_literal_name
       end
 
+      # @return [String]
       def determine_non_literal_name
         # https://github.com/ruby/rbs/blob/master/docs/syntax.md
         #
@@ -139,11 +138,17 @@ module Solargraph
 
       def eql?(other)
         self.class == other.class &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           @name == other.name &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           @key_types == other.key_types &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           @subtypes == other.subtypes &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           @rooted == other.rooted? &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           @all_params == other.all_params &&
+          # @sg-ignore https://github.com/castwide/solargraph/pull/1114
           @parameters_type == other.parameters_type
       end
 
@@ -171,6 +176,7 @@ module Solargraph
         end
       end
 
+      # @return [String]
       def desc
         rooted_tags
       end
@@ -255,7 +261,7 @@ module Solargraph
 
       # @param generics_to_resolve [Enumerable<String>]
       # @param context_type [UniqueType, nil]
-      # @param resolved_generic_values [Hash{String => ComplexType}] Added to as types are encountered or resolved
+      # @param resolved_generic_values [Hash{String => ComplexType, ComplexType::UniqueType}] Added to as types are encountered or resolved
       # @return [UniqueType, ComplexType]
       def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
         if name == ComplexType::GENERIC_TAG_NAME
@@ -280,7 +286,7 @@ module Solargraph
       end
 
       # @param generics_to_resolve [Enumerable<String>]
-      # @param context_type [UniqueType]
+      # @param context_type [UniqueType, nil]
       # @param resolved_generic_values [Hash{String => ComplexType}]
       # @yieldreturn [Array<ComplexType>]
       # @return [Array<ComplexType>]
@@ -353,9 +359,9 @@ module Solargraph
 
       # @param new_name [String, nil]
       # @param make_rooted [Boolean, nil]
-      # @param new_key_types [Array<UniqueType>, nil]
+      # @param new_key_types [Array<ComplexType>, nil]
       # @param rooted [Boolean, nil]
-      # @param new_subtypes [Array<UniqueType>, nil]
+      # @param new_subtypes [Array<ComplexType>, nil]
       # @return [self]
       def recreate(new_name: nil, make_rooted: nil, new_key_types: nil, new_subtypes: nil)
         raise "Please remove leading :: and set rooted instead - #{new_name}" if new_name&.start_with?('::')
@@ -409,12 +415,12 @@ module Solargraph
       # @param api_map [ApiMap] The ApiMap that performs qualification
       # @param context [String] The namespace from which to resolve names
       # @return [self, ComplexType, UniqueType] The generated ComplexType
-      def qualify api_map, context = ''
+      def qualify api_map, *gates
         transform do |t|
           next t if t.name == GENERIC_TAG_NAME
-          next t if t.duck_type? || t.void? || t.undefined?
-          recon = (t.rooted? ? '' : context)
-          fqns = api_map.qualify(t.name, recon)
+          next t if t.duck_type? || t.void? || t.undefined? || t.literal?
+          open = t.rooted? ? [''] : gates
+          fqns = api_map.qualify(t.non_literal_name, *open)
           if fqns.nil?
             next UniqueType::BOOLEAN if t.tag == 'Boolean'
             next UniqueType::UNDEFINED
@@ -446,6 +452,7 @@ module Solargraph
         !can_root_name? || @rooted
       end
 
+      # @param name_to_check [String]
       def can_root_name?(name_to_check = name)
         self.class.can_root_name?(name_to_check)
       end

data/lib/solargraph/complex_type.rb

@@ -33,12 +33,12 @@ module Solargraph
     # @param api_map [ApiMap]
     # @param context [String]
     # @return [ComplexType]
-    def qualify api_map, context = ''
+    def qualify api_map, *gates
       red = reduce_object
       types = red.items.map do |t|
         next t if ['nil', 'void', 'undefined'].include?(t.name)
         next t if ['::Boolean'].include?(t.rooted_name)
-        t.qualify api_map, context
+        t.qualify api_map, *gates
       end
       ComplexType.new(types).reduce_object
     end
@@ -105,6 +105,21 @@ module Solargraph
       any? { |ut| ut.can_assign?(api_map, atype) }
     end
 
+    # @param new_name [String, nil]
+    # @param make_rooted [Boolean, nil]
+    # @param new_key_types [Array<ComplexType>, nil]
+    # @param rooted [Boolean, nil]
+    # @param new_subtypes [Array<ComplexType>, nil]
+    # @return [self]
+    def recreate(new_name: nil, make_rooted: nil, new_key_types: nil, new_subtypes: nil)
+      ComplexType.new(map do |ut|
+                        ut.recreate(new_name: new_name,
+                                    make_rooted: make_rooted,
+                                    new_key_types: new_key_types,
+                                    new_subtypes: new_subtypes)
+                      end)
+    end
+
     # @return [Integer]
     def length
       @items.length
@@ -155,10 +170,12 @@ module Solargraph
       map(&:tag).join(', ')
     end
 
+    # @return [String]
     def tags
       map(&:tag).join(', ')
     end
 
+    # @return [String]
     def simple_tags
       simplify_literals.tags
     end
@@ -172,10 +189,12 @@ module Solargraph
       ComplexType.new(items.map(&:downcast_to_literal_if_possible))
     end
 
+    # @return [String]
     def desc
       rooted_tags
     end
 
+    # @return [String]
     def rooted_tags
       map(&:rooted_tag).join(', ')
     end
@@ -200,6 +219,7 @@ module Solargraph
       any?(&:generic?)
     end
 
+    # @return [self]
     def simplify_literals
       ComplexType.new(map(&:simplify_literals))
     end
@@ -241,6 +261,7 @@ module Solargraph
     def reduce_class_type
       new_items = items.flat_map do |type|
         next type unless ['Module', 'Class'].include?(type.name)
+        next type if type.all_params.empty?
 
         type.all_params
       end
@@ -299,7 +320,6 @@ module Solargraph
       # #  @todo Need ability to use a literal true as a type below
       # #  @param partial [Boolean] True if the string is part of a another type
       # #  @return [Array<UniqueType>]
-      # @sg-ignore
       # @todo To be able to select the right signature above,
       #   Chain::Call needs to know the decl type (:arg, :optarg,
       #   :kwarg, etc) of the arguments given, instead of just having
@@ -319,6 +339,7 @@ module Solargraph
           paren_stack = 0
           base = String.new
           subtype_string = String.new
+          # @param char [String]
           type_string&.each_char do |char|
             if char == '='
               #raise ComplexTypeError, "Invalid = in type #{type_string}" unless curly_stack > 0

data/lib/solargraph/convention/active_support_concern.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Convention
+    # ActiveSupport::Concern is syntactic sugar for a common
+    # pattern to include class methods while mixing-in a Module
+    # See https://api.rubyonrails.org/classes/ActiveSupport/Concern.html
+    class ActiveSupportConcern < Base
+      include Logging
+
+      # @return [Array<Pin::Base>]
+      attr_reader :pins
+
+      # @param api_map [ApiMap]
+      # @param rooted_tag [String]
+      # @param scope [Symbol] :class or :instance
+      # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+      # @param deep [Boolean] whether to include methods from included modules
+      # @param skip [Set<String>]
+      # @param _no_core [Boolean]n whether to skip core methods
+      def object api_map, rooted_tag, scope, visibility, deep, skip, _no_core
+        moo = ObjectProcessor.new(api_map, rooted_tag, scope, visibility, deep, skip)
+        moo.environ
+      end
+
+      # yard-activesupport-concern pulls methods inside
+      # 'class_methods' blocks into main class visible from YARD
+      #
+      # @param _doc_map [DocMap]
+      def global _doc_map
+        Environ.new(yard_plugins: ['activesupport-concern'])
+      end
+
+      # Process an object to add any class methods brought in via
+      # ActiveSupport::Concern
+      class ObjectProcessor
+        include Logging
+
+        attr_reader :environ
+
+        # @param api_map [ApiMap]
+        # @param rooted_tag [String] the tag of the class or module being processed
+        # @param scope [Symbol] :class or :instance
+        # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+        # @param deep [Boolean] whether to include methods from included modules
+        # @param skip [Set<String>] a set of tags to skip
+        def initialize api_map, rooted_tag, scope, visibility, deep, skip
+          @api_map = api_map
+          @rooted_tag = rooted_tag
+          @scope = scope
+          @visibility = visibility
+          @deep = deep
+          @skip = skip
+
+          @environ = Environ.new
+          return unless scope == :class
+
+          @rooted_type = ComplexType.parse(rooted_tag).force_rooted
+          @fqns = rooted_type.namespace
+          @namespace_pin = api_map.get_path_pins(fqns).select { |p| p.is_a?(Pin::Namespace) }.first
+
+          api_map.get_includes(fqns).reverse.each do |include_tag|
+            process_include include_tag
+          end
+        end
+
+        private
+
+        attr_reader :api_map, :rooted_tag, :rooted_type, :scope,
+                    :visibility, :deep, :skip, :namespace_pin,
+                    :fqns
+
+        # @param include_tag [Pin::Reference::Include] the include reference pin
+        #
+        # @return [void]
+        def process_include include_tag
+          rooted_include_tag = api_map.dereference(include_tag)
+          return if rooted_include_tag.nil?
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "Handling class include include_tag=#{include_tag}"
+          end
+          module_extends = api_map.get_extends(rooted_include_tag).map(&:type).map(&:to_s)
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "found module extends of #{rooted_include_tag}: #{module_extends}"
+          end
+          return unless module_extends.include? 'ActiveSupport::Concern'
+          included_class_pins = api_map.inner_get_methods_from_reference(rooted_include_tag, namespace_pin, rooted_type,
+                                                                         :class, visibility, deep, skip, true)
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "Found #{included_class_pins.length} inluded class methods for #{rooted_include_tag}"
+          end
+          environ.pins.concat included_class_pins
+          # another pattern is to put class methods inside a submodule
+          classmethods_include_tag = "#{rooted_include_tag}::ClassMethods"
+          included_classmethods_pins =
+            api_map.inner_get_methods_from_reference(classmethods_include_tag, namespace_pin, rooted_type,
+                                                     :instance, visibility, deep, skip, true)
+          logger.debug do
+            "ActiveSupportConcern#object(#{fqns}, #{scope}, #{visibility}, #{deep}) - " \
+              "Found #{included_classmethods_pins.length} included classmethod " \
+              "class methods for #{classmethods_include_tag}"
+          end
+          environ.pins.concat included_classmethods_pins
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/convention/base.rb

@@ -28,6 +28,23 @@ module Solargraph
       def global doc_map
         EMPTY_ENVIRON
       end
+
+      # Provides any additional method pins based on e the described object.
+      #
+      # @param api_map [ApiMap]
+      # @param rooted_tag [String] A fully qualified namespace, with
+      #   generic parameter values if applicable
+      # @param scope [Symbol] :class or :instance
+      # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+      # @param deep [Boolean]
+      # @param skip [Set<String>]
+      # @param no_core [Boolean] Skip core classes if true
+      #
+      # @return [Environ]
+      def object api_map, rooted_tag, scope, visibility,
+                 deep, skip, no_core
+        EMPTY_ENVIRON
+      end
     end
   end
 end

data/lib/solargraph/convention/data_definition/data_assignment_node.rb

@@ -22,6 +22,7 @@ module Solargraph
           #     s(:def, :foo,
           #       s(:args),
           #       s(:send, nil, :bar))))
+          # @param node [::Parser::AST::Node]
           def match?(node)
             return false unless node&.type == :casgn
             return false if node.children[2].nil?

data/lib/solargraph/convention/data_definition/data_definition_node.rb

@@ -25,6 +25,8 @@ module Solargraph
           #     s(:def, :foo,
           #       s(:args),
           #       s(:send, nil, :bar)))
+          #
+          # @param node [Parser::AST::Node]
           def match?(node)
             return false unless node&.type == :class
 
@@ -46,7 +48,7 @@ module Solargraph
           end
         end
 
-        # @return [Parser::AST::Node]
+        # @param node [Parser::AST::Node]
         def initialize(node)
           @node = node
         end
@@ -74,7 +76,7 @@ module Solargraph
         # @return [Parser::AST::Node]
         attr_reader :node
 
-        # @return [Parser::AST::Node]
+        # @return [Parser::AST::Node, nil]
         def data_node
           node.children[1]
         end

data/lib/solargraph/convention/data_definition.rb

@@ -35,7 +35,7 @@ module Solargraph
               comments: comments_for(node)
             )
 
-            # TODO: Support both arg and kwarg initializers for Data.define
+            # @todo Support both arg and kwarg initializers for Data.define
             # Solargraph::SourceMap::Clip#complete_keyword_parameters does not seem to currently take into account [Pin::Method#signatures] hence we only one for :kwarg
             pins.push initialize_method_pin
 
@@ -88,6 +88,7 @@ module Solargraph
           end
 
           # @param attribute_node [Parser::AST::Node]
+          # @param attribute_name [String]
           # @return [String, nil]
           def attribute_comments(attribute_node, attribute_name)
             data_comments = comments_for(attribute_node)

data/lib/solargraph/convention/gemspec.rb

@@ -4,7 +4,7 @@ module Solargraph
   module Convention
     class Gemspec < Base
       def local source_map
-        return EMPTY_ENVIRON unless File.basename(source_map.filename).end_with?('.gemspec')
+        return Convention::Base::EMPTY_ENVIRON unless File.basename(source_map.filename).end_with?('.gemspec')
         @environ ||= Environ.new(
           requires: ['rubygems'],
           pins: [

data/lib/solargraph/convention/struct_definition/struct_assignment_node.rb

@@ -22,6 +22,7 @@ module Solargraph
           #     s(:def, :foo,
           #       s(:args),
           #       s(:send, nil, :bar))))
+          # @param node [Parser::AST::Node]
           def match?(node)
             return false unless node&.type == :casgn
             return false if node.children[2].nil?

data/lib/solargraph/convention/struct_definition/struct_definition_node.rb

@@ -25,6 +25,8 @@ module Solargraph
           #     s(:def, :foo,
           #       s(:args),
           #       s(:send, nil, :bar)))
+          #
+          # @param node [Parser::AST::Node]
           def match?(node)
             return false unless node&.type == :class
 
@@ -46,7 +48,7 @@ module Solargraph
           end
         end
 
-        # @return [Parser::AST::Node]
+        # @param node [Parser::AST::Node]
         def initialize(node)
           @node = node
         end

data/lib/solargraph/convention/struct_definition.rb

@@ -20,7 +20,8 @@ module Solargraph
               name: struct_definition_node.class_name,
               docstring: docstring,
               visibility: :public,
-              gates: region.closure.gates.freeze
+              gates: region.closure.gates.freeze,
+              source: :struct_definition
             )
             pins.push nspin
 
@@ -32,7 +33,8 @@ module Solargraph
               location: get_node_location(node),
               closure: nspin,
               visibility: :private,
-              docstring: docstring
+              docstring: docstring,
+              source: :struct_definition
             )
 
             pins.push initialize_method_pin
@@ -43,7 +45,8 @@ module Solargraph
                   name: attribute_name,
                   decl: struct_definition_node.keyword_init? ? :kwarg : :arg,
                   location: get_node_location(attribute_node),
-                  closure: initialize_method_pin
+                  closure: initialize_method_pin,
+                  source: :struct_definition
                 )
               )
             end
@@ -53,29 +56,40 @@ module Solargraph
               [attribute_name, "#{attribute_name}="].each do |name|
                 docs = docstring.tags.find { |t| t.tag_name == 'param' && t.name == attribute_name }
 
+                attribute_type = ComplexType.parse(tag_string(docs))
+                return_type_comment = attribute_comment(docs, false)
+                param_comment = attribute_comment(docs, true)
+
                 method_pin = Pin::Method.new(
                   name: name,
                   parameters: [],
                   scope: :instance,
                   location: get_node_location(attribute_node),
                   closure: nspin,
+                  docstring: YARD::Docstring.new(return_type_comment),
                   # even assignments return the value
-                  comments: attribute_comment(docs, false),
-                  visibility: :public
+                  comments: return_type_comment,
+                  return_type: attribute_type,
+                  visibility: :public,
+                  source: :struct_definition
                 )
 
                 if name.end_with?('=')
                   method_pin.parameters << Pin::Parameter.new(
                     name: attribute_name,
                     location: get_node_location(attribute_node),
-                    closure: nspin,
-                    comments: attribute_comment(docs, true)
+                    closure: method_pin,
+                    return_type: attribute_type,
+                    comments: param_comment,
+                    source: :struct_definition
                   )
 
                   pins.push Pin::InstanceVariable.new(name: "@#{attribute_name}",
-                                    closure: method_pin,
-                                    location: get_node_location(attribute_node),
-                                    comments: attribute_comment(docs, false))
+                                                      closure: method_pin,
+                                                      location: get_node_location(attribute_node),
+                                                      return_type: attribute_type,
+                                                      comments: "@type [#{attribute_type.rooted_tags}]",
+                                                      source: :struct_definition)
                 end
 
                 pins.push method_pin
@@ -88,7 +102,7 @@ module Solargraph
 
           private
 
-          # @return [StructDefintionNode, nil]
+          # @return [StructDefintionNode, StructAssignmentNode, nil]
           def struct_definition_node
             @struct_definition_node ||= if StructDefintionNode.match?(node)
                                           StructDefintionNode.new(node)
@@ -113,7 +127,7 @@ module Solargraph
 
               # We should support specific comments for an attribute, and that can be either a @return on an @param
               # But since we merge into the struct_comments, then we should interpret either as a param
-              comment = '@param ' + attr_name + comment[7..] if comment.start_with?('@return')
+              comment = "@param #{attr_name}#{comment[7..]}" if comment.start_with?('@return')
 
               struct_comments += "\n#{comment}"
             end
@@ -121,12 +135,21 @@ module Solargraph
             Solargraph::Source.parse_docstring(struct_comments).to_docstring
           end
 
+          # @param tag [YARD::Tags::Tag, nil] The param tag for this attribute.xtract_
+          #
+          # @return [String]
+          def tag_string(tag)
+            tag&.types&.join(',') || 'undefined'
+          end
+
           # @param tag [YARD::Tags::Tag, nil] The param tag for this attribute. If nil, this method is a no-op
           # @param for_setter [Boolean] If true, will return a @param tag instead of a @return tag
+          #
+          # @return [String] The formatted comment for the attribute
           def attribute_comment(tag, for_setter)
             return "" if tag.nil?
 
-            suffix = "[#{tag.types&.join(',') || 'undefined'}] #{tag.text}"
+            suffix = "[#{tag_string(tag)}] #{tag.text}"
 
             if for_setter
               "@param #{tag.name} #{suffix}"

data/lib/solargraph/convention.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-
 module Solargraph
   # Conventions provide a way to modify an ApiMap based on expectations about
   # one of its sources.
@@ -12,6 +11,7 @@ module Solargraph
     autoload :Rakefile, 'solargraph/convention/rakefile'
     autoload :StructDefinition, 'solargraph/convention/struct_definition'
     autoload :DataDefinition,   'solargraph/convention/data_definition'
+    autoload :ActiveSupportConcern, 'solargraph/convention/active_support_concern'
 
     # @type [Set<Convention::Base>]
     @@conventions = Set.new
@@ -22,6 +22,12 @@ module Solargraph
       @@conventions.add convention.new
     end
 
+    # @param convention [Class<Convention::Base>]
+    # @return [void]
+    def self.unregister convention
+      @@conventions.delete_if { |c| c.is_a?(convention) }
+    end
+
     # @param source_map [SourceMap]
     # @return [Environ]
     def self.for_local(source_map)
@@ -32,7 +38,7 @@ module Solargraph
       result
     end
 
-    # @param yard_map [DocMap]
+    # @param doc_map [DocMap]
     # @return [Environ]
     def self.for_global(doc_map)
       result = Environ.new
@@ -42,8 +48,31 @@ module Solargraph
       result
     end
 
+    # Provides any additional method pins based on the described object.
+    #
+    # @param api_map [ApiMap]
+    # @param rooted_tag [String] A fully qualified namespace, with
+    #   generic parameter values if applicable
+    # @param scope [Symbol] :class or :instance
+    # @param visibility [Array<Symbol>] :public, :protected, and/or :private
+    # @param deep [Boolean]
+    # @param skip [Set<String>]
+    # @param no_core [Boolean] Skip core classes if true
+    #
+    # @return [Environ]
+    def self.for_object api_map, rooted_tag, scope, visibility,
+                        deep, skip, no_core
+      result = Environ.new
+      @@conventions.each do |conv|
+        result.merge conv.object(api_map, rooted_tag, scope, visibility,
+                                 deep, skip, no_core)
+      end
+      result
+    end
+
     register Gemfile
     register Gemspec
     register Rakefile
+    register ActiveSupportConcern
   end
 end

data/lib/solargraph/diagnostics/rubocop.rb

@@ -28,7 +28,12 @@ module Solargraph
         options, paths = generate_options(source.filename, source.code)
         store = RuboCop::ConfigStore.new
         runner = RuboCop::Runner.new(options, store)
-        result = redirect_stdout{ runner.run(paths) }
+        # Ensure only one instance of RuboCop::Runner is running at
+        # a time - it uses 'chdir' to read config files with ERB,
+        # which can conflict with other chdirs.
+        result = Solargraph::CHDIR_MUTEX.synchronize do
+          redirect_stdout{ runner.run(paths) }
+        end
 
         return [] if result.empty?