solargraph 0.51.2 → 0.53.0

data/lib/solargraph/rbs_map.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'rbs'
-require 'set'
 
 module Solargraph
   class RbsMap
@@ -19,19 +18,24 @@ module Solargraph
     attr_reader :library
 
     # @param library [String]
-    def initialize library
+    def initialize library, version = nil
       @library = library
+      @version = version
+      @collection = nil
       loader = RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
-      add_library loader, library
+      add_library loader, library, version
       return unless resolved?
-      environment = RBS::Environment.from_loader(loader).resolve_type_names
-      environment.declarations.each { |decl| convert_decl_to_pin(decl, Solargraph::Pin::ROOT_PIN) }
+      load_environment_to_pins(loader)
     end
 
+    # @param path [String]
+    # @return [Pin::Base, nil]
     def path_pin path
       pins.find { |p| p.path == path }
     end
 
+    # @param path [String]
+    # @return [Array<Pin::Base>]
     def path_pins path
       pins.select { |p| p.path == path }
     end
@@ -40,14 +44,18 @@ module Solargraph
       @resolved
     end
 
+    def repository
+      @repository ||= RBS::Repository.new(no_stdlib: false)
+    end
+
     # @param library [String]
     # @return [RbsMap]
     def self.load library
       @@rbs_maps_hash[library] ||= RbsMap.new(library)
     end
 
-    def repository
-      @repository ||= RBS::Repository.new(no_stdlib: true)
+    def self.from_gemspec(gemspec)
+      RbsMap.new(gemspec.name, gemspec.version)
     end
 
     private
@@ -55,17 +63,18 @@ module Solargraph
     # @param loader [RBS::EnvironmentLoader]
     # @param library [String]
     # @return [Boolean] true if adding the library succeeded
-    def add_library loader, library
-      @resolved = if loader.has_library?(library: library, version: nil)
-        loader.add library: library
+    def add_library loader, library, version
+      @resolved = if loader.has_library?(library: library, version: version)
+        loader.add library: library, version: version
         Solargraph.logger.info "#{short_name} successfully loaded library #{library}"
         true
       else
-        Solargraph.logger.info "#{short_name} failed to load library #{library}"
+        Solargraph.logger.debug "#{short_name} failed to load library #{library}"
         false
       end
     end
 
+    # @return [String]
     def short_name
       self.class.name.split('::').last
     end

data/lib/solargraph/shell.rb

@@ -1,14 +1,21 @@
 # frozen_string_literal: true
 
 require 'thor'
+require 'yard'
 
 module Solargraph
   class Shell < Thor
     include Solargraph::ServerMethods
 
+    # Tell Thor to ensure the process exits with status 1 if any error happens.
+    def self.exit_on_failure?
+      true
+    end
+
     map %w[--version -v] => :version
 
     desc "--version, -v", "Print the version"
+    # @return [void]
     def version
       puts Solargraph::VERSION
     end
@@ -16,6 +23,7 @@ module Solargraph
     desc 'socket', 'Run a Solargraph socket server'
     option :host, type: :string, aliases: :h, desc: 'The server host', default: '127.0.0.1'
     option :port, type: :numeric, aliases: :p, desc: 'The server port', default: 7658
+    # @return [void]
     def socket
       require 'backport'
       port = options[:port]
@@ -33,6 +41,7 @@ module Solargraph
     end
 
     desc 'stdio', 'Run a Solargraph stdio server'
+    # @return [void]
     def stdio
       require 'backport'
       Backport.run do
@@ -49,6 +58,8 @@ module Solargraph
 
     desc 'config [DIRECTORY]', 'Create or overwrite a default configuration file'
     option :extensions, type: :boolean, aliases: :e, desc: 'Add installed extensions', default: true
+    # @param directory [String]
+    # @return [void]
     def config(directory = '.')
       matches = []
       if options[:extensions]
@@ -71,43 +82,11 @@ module Solargraph
       STDOUT.puts "Configuration file initialized."
     end
 
-    desc 'download-core [VERSION]', 'Download core documentation [deprecated]', hide: true
-    long_desc %(
-      The `download-core` command is deprecated. Current versions of Solargraph
-      use RBS for core and stdlib documentation.
-    )
-    # @deprecated
-    def download_core _version = nil
-      puts 'The `download-core` command is deprecated.'
-      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
-    end
-
-    desc 'list-cores', 'List the local documentation versions [deprecated]', hide: true
-    long_desc %(
-      The `list-cores` command is deprecated. Current versions of Solargraph use
-      RBS for core and stdlib documentation.
-    )
-    # @deprecated
-    def list_cores
-      puts 'The `list-cores` command is deprecated.'
-      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
-    end
-
-    desc 'available-cores', 'List available documentation versions [deprecated]', hide: true
-    long_desc %(
-      The `available-cores` command is deprecated. Current versions of Solargraph
-      use RBS for core and stdlib documentation.
-    )
-    # @deprecated
-    def available_cores
-      puts 'The `available-cores` command is deprecated.'
-      puts 'Current versions of Solargraph use RBS for core and stdlib documentation.'
-    end
-
     desc 'clear', 'Delete all cached documentation'
     long_desc %(
       This command will delete all core and gem documentation from the cache.
     )
+    # @return [void]
     def clear
       puts "Deleting the cached documentation"
       Solargraph::Cache.clear
@@ -115,18 +94,45 @@ module Solargraph
     map 'clear-cache' => :clear
     map 'clear-cores' => :clear
 
+    desc 'cache', 'Cache a gem', hide: true
+    # @return [void]
+    # @param gem [String]
+    # @param version [String, nil]
+    def cache gem, version = nil
+      spec = Gem::Specification.find_by_name(gem, version)
+      pins = GemPins.build(spec)
+      Cache.save('gems', "#{spec.name}-#{spec.version}.ser", pins)
+    end
+
     desc 'uncache GEM [...GEM]', "Delete cached gem documentation"
+    # @return [void]
     def uncache *gems
       raise ArgumentError, 'No gems specified.' if gems.empty?
       gems.each do |gem|
-        Dir[File.join(Solargraph::YardMap::CoreDocs.cache_dir, 'gems', "#{gem}-*")].each do |dir|
-          puts "Deleting cache: #{dir}"
-          FileUtils.remove_entry_secure dir
+        spec = Gem::Specification.find_by_name(gem)
+        Cache.uncache('gems', "#{spec.name}-#{spec.version}.ser")
+        Cache.uncache('gems', "#{spec.name}-#{spec.version}.yardoc")
+      end
+    end
+
+    desc 'gems [GEM[=VERSION]]', 'Cache documentation for installed gems'
+    option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
+    # @return [void]
+    def gems *names
+      if names.empty?
+        Gem::Specification.to_a.each { |spec| do_cache spec }
+      else
+        names.each do |name|
+          spec = Gem::Specification.find_by_name(*name.split('='))
+          do_cache spec
+        rescue Gem::MissingSpecError
+          warn "Gem '#{name}' not found"
         end
       end
     end
 
     desc 'reporters', 'Get a list of diagnostics reporters'
+    # @return [void]
     def reporters
       puts Solargraph::Diagnostics.reporters
     end
@@ -140,9 +146,10 @@ module Solargraph
     )
     option :level, type: :string, aliases: [:mode, :m, :l], desc: 'Type checking level', default: 'normal'
     option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
+    # @return [void]
     def typecheck *files
       directory = File.realpath(options[:directory])
-      api_map = Solargraph::ApiMap.load(directory)
+      api_map = Solargraph::ApiMap.load_with_cache(directory)
       if files.empty?
         files = api_map.source_maps.map(&:filename)
       else
@@ -160,6 +167,7 @@ module Solargraph
         probcount += problems.length
       end
       puts "#{probcount} problem#{probcount != 1 ? 's' : ''} found#{files.length != 1 ? " in #{filecount} of #{files.length} files" : ''}."
+      # "
       exit 1 if probcount > 0
     end
 
@@ -172,12 +180,13 @@ module Solargraph
     )
     option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
     option :verbose, type: :boolean, aliases: :v, desc: 'Verbose output', default: false
+    # @return [void]
     def scan
       require 'benchmark'
       directory = File.realpath(options[:directory])
       api_map = nil
       time = Benchmark.measure {
-        api_map = Solargraph::ApiMap.load(directory)
+        api_map = Solargraph::ApiMap.load_with_cache(directory)
         api_map.pins.each do |pin|
           begin
             puts pin_description(pin) if options[:verbose]
@@ -197,32 +206,13 @@ module Solargraph
     desc 'list', 'List the files in the workspace and the total count'
     option :count, type: :boolean, aliases: :c, desc: 'Display the file count only', default: false
     option :directory, type: :string, aliases: :d, desc: 'The directory to read', default: '.'
+    # @return [void]
     def list
       workspace = Solargraph::Workspace.new(options[:directory])
-      unless options[:count]
-        workspace.filenames.each { |f| puts f }
-      end
+      puts workspace.filenames unless options[:count]
       puts "#{workspace.filenames.length} files total."
     end
 
-    desc 'bundle', 'Generate documentation for bundled gems [deprecated]', hide: true
-    long_desc %(
-      The `bundle` command is deprecated. Solargraph currently uses RBS instead.
-    )
-    option :directory, type: :string, aliases: :d, desc: 'The workspace directory', default: '.'
-    option :rebuild, type: :boolean, aliases: :r, desc: 'Rebuild existing documentation', default: false
-    def bundle
-      puts 'The `bundle` command is deprecated. Solargraph currently uses RBS instead.'
-    end
-
-    desc 'rdoc GEM [VERSION]', 'Use RDoc to cache documentation [deprecated]', hide: true
-    long_desc %(
-      The `rdoc` command is deprecated. Solargraph currently uses RBS instead.
-    )
-    def rdoc _gem, _version = '>= 0'
-      puts 'The `rdoc` command is deprecated. Solargraph currently uses RBS instead.'
-    end
-
     private
 
     # @param pin [Solargraph::Pin::Base]
@@ -240,5 +230,18 @@ module Solargraph
       desc += " (#{pin.location.filename} #{pin.location.range.start.line})" if pin.location
       desc
     end
+
+    # @param gemspec [Gem::Specification]
+    # @return [void]
+    def do_cache gemspec
+      cached = Yardoc.cached?(gemspec)
+      if cached && !options.rebuild
+        puts "Cache already exists for #{gemspec.name} #{gemspec.version}"
+      else
+        puts "#{cached ? 'Rebuilding' : 'Caching'} gem documentation for #{gemspec.name} #{gemspec.version}"
+        pins = GemPins.build(gemspec)
+        Cache.save('gems', "#{gemspec.name}-#{gemspec.version}.ser", pins)
+      end
+    end
   end
 end

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

@@ -0,0 +1,32 @@
+module Solargraph
+  class Source
+    class Chain
+      class Array < Literal
+        # @param children [::Array<Chain>]
+        def initialize children
+          super('::Array')
+          @children = children
+        end
+
+        def word
+          @word ||= "<#{@type}>"
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [Enumerable<Pin::LocalVariable>]
+        def resolve api_map, name_pin, locals
+          child_types = @children.map do |child|
+            child.infer(api_map, name_pin, locals).tag
+          end
+          type = if child_types.uniq.length == 1 && child_types.first != 'undefined'
+                   "::Array<#{child_types.first}>"
+                 else
+                   '::Array'
+                 end
+          [Pin::ProxyType.anonymous(ComplexType.try_parse(type))]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class BlockSymbol < Link
+        def resolve api_map, name_pin, locals
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('Proc'))]
+        end
+      end
+    end
+  end
+end

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

@@ -7,28 +7,32 @@ module Solargraph
         # @return [String]
         attr_reader :word
 
-        # @return [Array<Chain>]
+        # @return [::Array<Chain>]
         attr_reader :arguments
 
+        # @return [Chain, nil]
+        attr_reader :block
+
         # @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, arguments = [], with_block = false
+        # @param arguments [::Array<Chain>]
+        # @param block [Chain, nil]
+        def initialize word, arguments = [], block = nil
           @word = word
           @arguments = arguments
-          @with_block = with_block
+          @block = block
+          fix_block_pass
         end
 
         def with_block?
-          @with_block
+          !!@block
         end
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @param locals [Array<Pin::Base>]
+        # @param locals [::Array<Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
           return super_pins(api_map, name_pin) if word == 'super'
+          return yield_pins(api_map, name_pin) if word == 'yield'
           found = if head?
             locals.select { |p| p.name == word }
           else
@@ -37,7 +41,7 @@ module Solargraph
           return inferred_pins(found, api_map, name_pin.context, locals) unless found.empty?
           # @param [ComplexType::UniqueType]
           pins = name_pin.binder.each_unique_type.flat_map do |context|
-            api_map.get_method_stack(context.namespace, word, scope: context.scope)
+            api_map.get_method_stack(context.namespace == '' ? '' : context.tag, word, scope: context.scope)
           end
           return [] if pins.empty?
           inferred_pins(pins, api_map, name_pin.context, locals)
@@ -45,58 +49,58 @@ module Solargraph
 
         private
 
-        # @param pins [Array<Pin::Base>]
+        # @param pins [::Enumerable<Pin::Method>]
         # @param api_map [ApiMap]
         # @param context [ComplexType]
-        # @param locals [Pin::LocalVariable]
-        # @return [Array<Pin::Base>]
+        # @param locals [::Array<Pin::LocalVariable>]
+        # @return [::Array<Pin::Base>]
         def inferred_pins pins, api_map, context, locals
           result = pins.map do |p|
             next p unless p.is_a?(Pin::Method)
             overloads = p.signatures
             # next p if overloads.empty?
             type = ComplexType::UNDEFINED
-            overloads.each do |ol|
-              next unless arguments_match(arguments, ol)
-              # next if ol.parameters.last && ol.parameters.last.first.start_with?('&') && ol.parameters.last.last.nil? && !with_block?
+            # start with overloads that require blocks; if we are
+            # passing a block, we want to find a signature that will
+            # use it.  If we didn't pass a block, the logic below will
+            # reject it regardless
+
+            sorted_overloads = overloads.sort { |ol| ol.block? ? -1 : 1 }
+            new_signature_pin = nil
+            sorted_overloads.each do |ol|
+              next unless arity_matches?(arguments, ol)
               match = true
+
+              atypes = []
               arguments.each_with_index do |arg, idx|
                 param = ol.parameters[idx]
                 if param.nil?
-                  match = false unless ol.parameters.any?(&:restarg?)
+                  match = ol.parameters.any?(&:restarg?)
                   break
                 end
-                atype = arg.infer(api_map, Pin::ProxyType.anonymous(context), locals)
+                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(context), locals)
                 # @todo Weak type comparison
                 # unless atype.tag == param.return_type.tag || api_map.super_and_sub?(param.return_type.tag, atype.tag)
-                unless param.return_type.undefined? || atype.name == param.return_type.name || api_map.super_and_sub?(param.return_type.name, atype.name)
+                unless param.return_type.undefined? || atype.name == param.return_type.name || api_map.super_and_sub?(param.return_type.name, atype.name) || param.return_type.generic?
                   match = false
                   break
                 end
               end
               if match
-                type = extra_return_type(p.docstring, context)
-                break if type
-                type = with_params(ol.return_type.self_to(context.to_s), context).qualify(api_map, context.namespace) if ol.return_type.defined?
+                if ol.block && with_block?
+                  block_atypes = ol.block.parameters.map(&:return_type)
+                  blocktype = block_call_type(api_map, context, block_atypes, locals)
+                end
+                new_signature_pin = ol.resolve_generics_from_context_until_complete(ol.generics, atypes, nil, nil, blocktype)
+                new_return_type = new_signature_pin.return_type
+                type = with_params(new_return_type.self_to(context.to_s), context).qualify(api_map, context.namespace) if new_return_type.defined?
                 type ||= ComplexType::UNDEFINED
               end
               break if type.defined?
             end
+            p = p.with_single_signature(new_signature_pin) unless new_signature_pin.nil?
             next p.proxy(type) if type.defined?
-            type = extra_return_type(p.docstring, context)
-            if type
-              next Solargraph::Pin::Method.new(
-                location: p.location,
-                closure: p.closure,
-                name: p.name,
-                comments: "@return [#{context.subtypes.first.to_s}]",
-                scope: p.scope,
-                visibility: p.visibility,
-                parameters: p.parameters,
-                node: p.node
-              )
-            end
-            if p.is_a?(Pin::Method) && !p.macros.empty?
+            if !p.macros.empty?
               result = process_macro(p, api_map, context, locals)
               next result unless result.return_type.undefined?
             elsif !p.directives.empty?
@@ -116,13 +120,19 @@ module Solargraph
           end
         end
 
-        # @param pin [Pin::Method]
+        # @param pin [Pin::Base]
         # @param api_map [ApiMap]
         # @param context [ComplexType]
-        # @param locals [Pin::Base]
+        # @param locals [Enumerable<Pin::Base>]
         # @return [Pin::Base]
         def process_macro pin, api_map, context, locals
           pin.macros.each do |macro|
+            # @todo 'Wrong argument type for
+            #   Solargraph::Source::Chain::Call#inner_process_macro:
+            #   macro expected YARD::Tags::MacroDirective, received
+            #   generic<Elem>' is because we lose 'rooted' information
+            #   in the 'Chain::Array' class internally, leaving
+            #   ::Array#each shadowed when it shouldn't be.
             result = inner_process_macro(pin, macro, api_map, context, locals)
             return result unless result.return_type.undefined?
           end
@@ -132,7 +142,7 @@ module Solargraph
         # @param pin [Pin::Method]
         # @param api_map [ApiMap]
         # @param context [ComplexType]
-        # @param locals [Pin::Base]
+        # @param locals [Enumerable<Pin::Base>]
         # @return [Pin::ProxyType]
         def process_directive pin, api_map, context, locals
           pin.directives.each do |dir|
@@ -144,11 +154,11 @@ module Solargraph
           Pin::ProxyType.anonymous ComplexType::UNDEFINED
         end
 
-        # @param pin [Pin]
+        # @param pin [Pin::Base]
         # @param macro [YARD::Tags::MacroDirective]
         # @param api_map [ApiMap]
         # @param context [ComplexType]
-        # @param locals [Array<Pin::Base>]
+        # @param locals [Enumerable<Pin::Base>]
         # @return [Pin::ProxyType]
         def inner_process_macro pin, macro, api_map, context, locals
           vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals)) }
@@ -172,20 +182,20 @@ module Solargraph
 
         # @param docstring [YARD::Docstring]
         # @param context [ComplexType]
-        # @return [ComplexType]
+        # @return [ComplexType, nil]
         def extra_return_type docstring, context
-          if docstring.has_tag?(:return_single_parameter) #&& context.subtypes.one?
+          if docstring.has_tag?('return_single_parameter') #&& context.subtypes.one?
             return context.subtypes.first || ComplexType::UNDEFINED
-          elsif docstring.has_tag?(:return_value_parameter) && context.value_types.one?
+          elsif docstring.has_tag?('return_value_parameter') && context.value_types.one?
             return context.value_types.first
           end
           nil
         end
 
-        # @param arguments [Array<Chain>]
+        # @param arguments [::Array<Chain>]
         # @param signature [Pin::Signature]
         # @return [Boolean]
-        def arguments_match arguments, signature
+        def arity_matches? arguments, signature
           parameters = signature.parameters
           argcount = arguments.length
           parcount = parameters.length
@@ -197,18 +207,61 @@ module Solargraph
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @return [Array<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.context.scope)
           pins.reject{|p| p.path == name_pin.path}
         end
 
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @return [::Array<Pin::Base>]
+        def yield_pins api_map, name_pin
+          method_pin = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.context.scope).first
+          return [] if method_pin.nil?
+
+          method_pin.signatures.map(&:block).compact
+        end
+
         # @param type [ComplexType]
         # @param context [ComplexType]
+        # @return [ComplexType]
         def with_params type, context
           return type unless type.to_s.include?('$')
           ComplexType.try_parse(type.to_s.gsub('$', context.value_types.map(&:tag).join(', ')).gsub('<>', ''))
         end
+
+        # @return [void]
+        def fix_block_pass
+          argument = @arguments.last&.links&.first
+          @block = @arguments.pop if argument.is_a?(BlockSymbol) || argument.is_a?(BlockVariable)
+        end
+
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param block_parameter_types [::Array<ComplexType>]
+        # @param locals [::Array<Pin::LocalVariable>]
+        # @return [ComplexType, nil]
+        def block_call_type(api_map, context, block_parameter_types, locals)
+          return nil unless with_block?
+
+          # @todo Handle BlockVariable
+          if block.links.map(&:class) == [BlockSymbol]
+            # Ruby's shorthand for sending the passed in method name
+            # to the first yield parameter with no arguments
+            block_symbol_name = block.links.first.word
+            block_symbol_call_path = "#{block_parameter_types.first}##{block_symbol_name}"
+            callee = api_map.get_path_pins(block_symbol_call_path).first
+            return_type = callee&.return_type
+            # @todo: Figure out why we get unresolved generics at
+            #   this point and need to assume method return types
+            #   based on the generic type
+            return_type ||= api_map.get_path_pins("#{context.subtypes.first}##{block.links.first.word}").first&.return_type
+            return_type || ComplexType::UNDEFINED
+          else
+            block.infer(api_map, Pin::ProxyType.anonymous(context), locals)
+          end
+        end
       end
     end
   end

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

@@ -19,8 +19,14 @@ module Solargraph
           end
           parts = base.split('::')
           gates.each do |gate|
+            # @todo 'Wrong argument type for
+            #   Solargraph::Source::Chain::Constant#deep_constant_type:
+            #   gate expected String, received generic<Elem>' is because
+            #   we lose 'rooted' information in the 'Chain::Array' class
+            #   internally, leaving ::Array#each shadowed when it
+            #   shouldn't be.
             type = deep_constant_type(gate, api_map)
-            # Use deep inference to resolve root 
+            # Use deep inference to resolve root
             parts[0..-2].each do |sym|
               pins = api_map.get_constants('', type.namespace).select{ |pin| pin.name == sym }
               type = first_pin_type(pins, api_map)
@@ -35,6 +41,8 @@ module Solargraph
 
         private
 
+        # @param pin [Pin::Base]
+        # @return [::Array<String>]
         def crawl_gates pin
           clos = pin
           until clos.nil?
@@ -48,6 +56,9 @@ module Solargraph
           ['']
         end
 
+        # @param pins [::Array<Pin::Base>]
+        # @param api_map [ApiMap]
+        # @return [ComplexType]
         def first_pin_type(pins, api_map)
           type = ComplexType::UNDEFINED
           pins.each do |pin|
@@ -59,6 +70,9 @@ module Solargraph
           type
         end
 
+        # @param gate [String]
+        # @param api_map [ApiMap]
+        # @return [ComplexType]
         def deep_constant_type(gate, api_map)
           type = ComplexType::ROOT
           return type if gate == ''