gitlab 4.2.0 → 4.18.0

data/lib/gitlab/request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'httparty'
 require 'json'
 
@@ -6,8 +8,9 @@ module Gitlab
   class Request
     include HTTParty
     format :json
+    maintain_method_across_redirects true
     headers 'Accept' => 'application/json', 'Content-Type' => 'application/x-www-form-urlencoded'
-    parser proc { |body, _| parse(body) }
+    parser(proc { |body, _| parse(body) })
 
     attr_accessor :private_token, :endpoint
 
@@ -23,61 +26,49 @@ module Gitlab
         true
       elsif !body
         false
-      elsif body.nil?
-        false
       else
-        raise Error::Parsing.new "Couldn't parse a response body"
+        raise Error::Parsing, "Couldn't parse a response body"
       end
     end
 
     # Decodes a JSON response into Ruby object.
     def self.decode(response)
-      JSON.load response
+      response ? JSON.load(response) : {}
     rescue JSON::ParserError
-      raise Error::Parsing.new "The response is not a valid JSON"
+      raise Error::Parsing, 'The response is not a valid JSON'
     end
 
-    def get(path, options={})
-      set_httparty_config(options)
-      set_authorization_header(options)
-      validate self.class.get(@endpoint + path, options)
-    end
+    %w[get post put delete].each do |method|
+      define_method method do |path, options = {}|
+        params = options.dup
 
-    def post(path, options={})
-      set_httparty_config(options)
-      set_authorization_header(options)
-      validate self.class.post(@endpoint + path, options)
-    end
+        httparty_config(params)
 
-    def put(path, options={})
-      set_httparty_config(options)
-      set_authorization_header(options)
-      validate self.class.put(@endpoint + path, options)
-    end
+        unless params[:unauthenticated]
+          params[:headers] ||= {}
+          params[:headers].merge!(authorization_header)
+        end
 
-    def delete(path, options={})
-      set_httparty_config(options)
-      set_authorization_header(options)
-      validate self.class.delete(@endpoint + path, options)
+        retries_left = params[:ratelimit_retries] || 3
+        begin
+          response = self.class.send(method, endpoint + path, params)
+          validate response
+        rescue Gitlab::Error::TooManyRequests => e
+          retries_left -= 1
+          raise e if retries_left.zero?
+
+          wait_time = response.headers['Retry-After'] || 2
+          sleep(wait_time.to_i)
+          retry
+        end
+      end
     end
 
     # Checks the response code for common errors.
     # Returns parsed response for successful requests.
     def validate(response)
-      error_klass = case response.code
-      when 400 then Error::BadRequest
-      when 401 then Error::Unauthorized
-      when 403 then Error::Forbidden
-      when 404 then Error::NotFound
-      when 405 then Error::MethodNotAllowed
-      when 409 then Error::Conflict
-      when 422 then Error::Unprocessable
-      when 500 then Error::InternalServerError
-      when 502 then Error::BadGateway
-      when 503 then Error::ServiceUnavailable
-      end
-
-      fail error_klass.new(response) if error_klass
+      error_klass = Error::STATUS_MAPPINGS[response.code]
+      raise error_klass, response if error_klass
 
       parsed = response.parsed_response
       parsed.client = self if parsed.respond_to?(:client=)
@@ -87,33 +78,31 @@ module Gitlab
 
     # Sets a base_uri and default_params for requests.
     # @raise [Error::MissingCredentials] if endpoint not set.
-    def set_request_defaults(sudo=nil)
+    def request_defaults(sudo = nil)
+      raise Error::MissingCredentials, 'Please set an endpoint to API' unless endpoint
+
       self.class.default_params sudo: sudo
-      raise Error::MissingCredentials.new("Please set an endpoint to API") unless @endpoint
       self.class.default_params.delete(:sudo) if sudo.nil?
     end
 
     private
 
-    # Sets a PRIVATE-TOKEN or Authorization header for requests.
+    # Returns an Authorization header hash
     #
-    # @param [Hash] options A customizable set of options.
-    # @option options [Boolean] :unauthenticated true if the API call does not require user authentication.
     # @raise [Error::MissingCredentials] if private_token and auth_token are not set.
-    def set_authorization_header(options)
-      unless options[:unauthenticated]
-        raise Error::MissingCredentials.new("Please provide a private_token or auth_token for user") unless @private_token
-        if @private_token.length <= 20
-          options[:headers] = { 'PRIVATE-TOKEN' => @private_token }
-        else
-          options[:headers] = { 'Authorization' => "Bearer #{@private_token}" }
-        end
+    def authorization_header
+      raise Error::MissingCredentials, 'Please provide a private_token or auth_token for user' unless private_token
+
+      if private_token.size < 21
+        { 'PRIVATE-TOKEN' => private_token }
+      else
+        { 'Authorization' => "Bearer #{private_token}" }
       end
     end
 
     # Set HTTParty configuration
     # @see https://github.com/jnunemaker/httparty
-    def set_httparty_config(options)
+    def httparty_config(options)
       options.merge!(httparty) if httparty
     end
   end

data/lib/gitlab/shell.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'gitlab'
 require 'gitlab/help'
 require 'gitlab/cli_helpers'
@@ -15,7 +17,7 @@ class Gitlab::Shell
       trap('INT') { quit_shell } # capture ctrl-c
       setup
 
-      while buffer = Readline.readline('gitlab> ')
+      while (buffer = Readline.readline('gitlab> '))
         begin
           parse_input buffer
 
@@ -34,7 +36,7 @@ class Gitlab::Shell
             data = execute command, arguments
             output_table command, arguments, data
           end
-        rescue => e
+        rescue StandardError => e
           puts e.message
         end
       end
@@ -46,7 +48,7 @@ class Gitlab::Shell
       buf = Shellwords.shellwords(buffer)
 
       @command = buf.shift
-      @arguments = buf.count > 0 ? buf : []
+      @arguments = buf.count.positive? ? buf : []
     end
 
     def setup
@@ -62,14 +64,11 @@ class Gitlab::Shell
     end
 
     # Execute a given command with arguements
-    def execute(cmd=command, args=arguments)
-      if actions.include?(cmd.to_sym)
-        confirm_command(cmd)
-        gitlab_helper(cmd, args)
-      else
-        fail "Unknown command: #{cmd}. " \
-             "See the 'help' for a list of valid commands."
-      end
+    def execute(cmd = command, args = arguments)
+      raise "Unknown command: #{cmd}. See the 'help' for a list of valid commands." unless actions.include?(cmd.to_sym)
+
+      confirm_command(cmd)
+      gitlab_helper(cmd, args)
     end
 
     def quit_shell
@@ -80,5 +79,5 @@ class Gitlab::Shell
     def history
       @history ||= History.new
     end
-  end # class << self
+  end
 end

data/lib/gitlab/shell_history.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class Gitlab::Shell
   class History
     DEFAULT_HISTFILESIZE = 200
     DEFAULT_FILE_PATH = File.join(Dir.home, '.gitlab_shell_history')
 
-    def initialize(options={})
+    def initialize(options = {})
       @file_path = options[:file_path] || DEFAULT_FILE_PATH
       Readline::HISTORY.clear
     end
@@ -13,13 +15,13 @@ class Gitlab::Shell
     end
 
     def save
-      lines.each { |line| history_file.puts line if history_file }
+      lines.each { |line| history_file&.puts line }
     end
 
     def push(line)
       Readline::HISTORY << line
     end
-    alias_method :<<, :push
+    alias << push
 
     def lines
       Readline::HISTORY.to_a.last(max_lines)
@@ -28,12 +30,8 @@ class Gitlab::Shell
     private
 
     def history_file
-      if defined?(@history_file)
-        @history_file
-      else
-        @history_file = File.open(history_file_path, 'w', 0600).tap do |file|
-          file.sync = true
-        end
+      @history_file ||= File.open(history_file_path, 'w', 0o600).tap do |file|
+        file.sync = true
       end
     rescue Errno::EACCES
       warn 'History not saved; unable to open your history file for writing.'
@@ -44,12 +42,12 @@ class Gitlab::Shell
       File.expand_path(@file_path)
     end
 
-    def read_from_file
+    def read_from_file(&block)
       path = history_file_path
 
-      File.foreach(path) { |line| yield(line) } if File.exist?(path)
-    rescue => error
-      warn "History file not loaded: #{error.message}"
+      File.foreach(path, &block) if File.exist?(path)
+    rescue StandardError => e
+      warn "History file not loaded: #{e.message}"
     end
 
     def max_lines

data/lib/gitlab/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Gitlab
-  VERSION = "4.2.0"
+  VERSION = '4.18.0'
 end

data/lib/gitlab.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'gitlab/version'
 require 'gitlab/objectified_hash'
 require 'gitlab/configuration'
@@ -15,23 +17,31 @@ module Gitlab
   # Alias for Gitlab::Client.new
   #
   # @return [Gitlab::Client]
-  def self.client(options={})
+  def self.client(options = {})
     Gitlab::Client.new(options)
   end
 
-  # Delegate to Gitlab::Client
-  def self.method_missing(method, *args, &block)
-    return super unless client.respond_to?(method)
-    client.send(method, *args, &block)
+  if Gem::Version.new(RUBY_VERSION).release >= Gem::Version.new('3.0.0')
+    def self.method_missing(method, *args, **keywargs, &block)
+      return super unless client.respond_to?(method)
+
+      client.send(method, *args, **keywargs, &block)
+    end
+  else
+    def self.method_missing(method, *args, &block)
+      return super unless client.respond_to?(method)
+
+      client.send(method, *args, &block)
+    end
   end
 
   # Delegate to Gitlab::Client
-  def respond_to_missing?(method_name, include_private = false)
+  def self.respond_to_missing?(method_name, include_private = false)
     client.respond_to?(method_name) || super
   end
 
   # Delegate to HTTParty.http_proxy
-  def self.http_proxy(address=nil, port=nil, username=nil, password=nil)
+  def self.http_proxy(address = nil, port = nil, username = nil, password = nil)
     Gitlab::Request.http_proxy(address, port, username, password)
   end
 
@@ -39,7 +49,8 @@ module Gitlab
   #
   # @return [Array<Symbol>]
   def self.actions
-    hidden = /endpoint|private_token|auth_token|user_agent|sudo|get|post|put|\Adelete\z|validate|set_request_defaults|httparty/
+    hidden =
+      /endpoint|private_token|auth_token|user_agent|sudo|get|post|put|\Adelete\z|validate\z|request_defaults|httparty/
     (Gitlab::Client.instance_methods - Object.methods).reject { |e| e[hidden] }
   end
 end