gitlab-faraday 5.1.0

data/lib/gitlab/client.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'cgi/escape'
+
+module Gitlab
+  class Client < API
+    Dir[File.expand_path('client/*.rb', __dir__)].each { |f| require f }
+
+    include AccessRequests
+    include ApplicationSettings
+    include Avatar
+    include AwardEmojis
+    include Boards
+    include Branches
+    include BroadcastMessages
+    include BuildVariables
+    include Builds
+    include Commits
+    include ContainerRegistry
+    include Deployments
+    include Environments
+    include EpicIssues
+    include Epics
+    include Events
+    include Features
+    include GroupBadges
+    include GroupBoards
+    include GroupLabels
+    include GroupMilestones
+    include Groups
+    include IssueLinks
+    include Issues
+    include Jobs
+    include Keys
+    include Labels
+    include Lint
+    include Markdown
+    include MergeRequestApprovals
+    include MergeRequests
+    include MergeTrains
+    include Milestones
+    include Namespaces
+    include Notes
+    include Packages
+    include PipelineSchedules
+    include PipelineTriggers
+    include Pipelines
+    include ProjectBadges
+    include ProjectClusters
+    include ProjectExports
+    include ProjectReleaseLinks
+    include ProjectReleases
+    include Projects
+    include ProtectedTags
+    include RemoteMirrors
+    include Repositories
+    include RepositoryFiles
+    include RepositorySubmodules
+    include ResourceLabelEvents
+    include ResourceStateEvents
+    include Runners
+    include Search
+    include Services
+    include Sidekiq
+    include Snippets
+    include SystemHooks
+    include Tags
+    include Templates
+    include Todos
+    include Users
+    include UserSnippets
+    include Versions
+    include Wikis
+
+    def inspect
+      inspected = super
+      inspected = redact_private_token(inspected, @private_token) if @private_token
+      inspected
+    end
+
+    def url_encode(url)
+      CGI.escapeURIComponent(url.to_s)
+    end
+
+    def redact_private_token(inspected, private_token)
+      redacted = only_show_last_four_chars(private_token)
+      inspected.sub(%(@private_token="#{private_token}"), %(@private_token="#{redacted}"))
+    end
+
+    def only_show_last_four_chars(token)
+      return '****' if token.size <= 4
+
+      "#{'*' * (token.size - 4)}#{token[-4..]}"
+    end
+  end
+end

data/lib/gitlab/configuration.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Configuration
+    VALID_OPTIONS_KEYS = %i[endpoint private_token user_agent sudo httparty pat_prefix body_as_json].freeze
+
+    DEFAULT_USER_AGENT = "Gitlab Ruby Gem #{Gitlab::VERSION}"
+
+    attr_accessor(*VALID_OPTIONS_KEYS)
+    alias auth_token= private_token=
+
+    def self.extended(base)
+      base.reset
+    end
+
+    def configure
+      yield self
+    end
+
+    def options
+      VALID_OPTIONS_KEYS.each_with_object({}) do |key, option|
+        option[key] = send(key)
+      end
+    end
+
+    def reset
+      self.endpoint       = ENV['GITLAB_API_ENDPOINT'] || ENV.fetch('CI_API_V4_URL', nil)
+      self.private_token  = ENV['GITLAB_API_PRIVATE_TOKEN'] || ENV.fetch('GITLAB_API_AUTH_TOKEN', nil)
+      self.pat_prefix     = nil
+      self.httparty       = nil
+      self.sudo           = nil
+      self.user_agent     = DEFAULT_USER_AGENT
+      self.body_as_json   = false
+    end
+  end
+end

data/lib/gitlab/error.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Error
+    class Error < StandardError; end
+
+    class MissingCredentials < Error; end
+
+    class Parsing < Error; end
+
+    class ResponseError < Error
+      POSSIBLE_MESSAGE_KEYS = %i[message error_description error].freeze
+
+      def initialize(response)
+        @response = response
+        super(build_error_message)
+      end
+
+      def response_status
+        @response.status
+      end
+
+      def response_message
+        parsed = parsed_response
+        parsed.respond_to?(:message) ? parsed.message : parsed.to_s
+      end
+
+      def error_code
+        ''
+      end
+
+      def build_error_message
+        parsed = parsed_response
+        message = check_error_keys(parsed)
+        "Server responded with code #{@response.status}, message: " \
+          "#{handle_message(message)}. " \
+          "Request URI: #{@response.env.url}"
+      end
+
+      def check_error_keys(resp)
+        return resp unless resp.is_a?(Gitlab::ObjectifiedHash)
+
+        key = POSSIBLE_MESSAGE_KEYS.find { |k| resp.respond_to?(k) }
+        key ? resp.send(key) : resp
+      end
+
+      def parsed_response
+        return @parsed_response if defined?(@parsed_response)
+
+        body = @response.body
+        return {} if body.nil? || body.empty?
+
+        parsed = JSON.parse(body)
+        @parsed_response = if parsed.is_a?(Hash)
+                             Gitlab::ObjectifiedHash.new(parsed)
+                           else
+                             parsed
+                           end
+      rescue JSON::ParserError
+        @parsed_response = @response.body
+      end
+
+      def handle_message(message)
+        case message
+        when Gitlab::ObjectifiedHash
+          message.to_h.sort.map do |key, val|
+            "'#{key}' #{(val.is_a?(Hash) ? val.sort.map { |k, v| "(#{k}: #{v.join(' ')})" } : [val].flatten).join(' ')}"
+          end.join(', ')
+        when Array
+          message.join(' ')
+        else
+          message
+        end
+      end
+    end
+
+    class BadRequest < ResponseError; end
+    class Unauthorized < ResponseError; end
+    class Forbidden < ResponseError; end
+    class NotFound < ResponseError; end
+    class MethodNotAllowed < ResponseError; end
+    class NotAcceptable < ResponseError; end
+    class Conflict < ResponseError; end
+    class Unprocessable < ResponseError; end
+    class TooManyRequests < ResponseError; end
+    class InternalServerError < ResponseError; end
+    class BadGateway < ResponseError; end
+    class ServiceUnavailable < ResponseError; end
+    class ConnectionTimedOut < ResponseError; end
+
+    STATUS_MAPPINGS = {
+      400 => BadRequest,
+      401 => Unauthorized,
+      403 => Forbidden,
+      404 => NotFound,
+      405 => MethodNotAllowed,
+      406 => NotAcceptable,
+      409 => Conflict,
+      422 => Unprocessable,
+      429 => TooManyRequests,
+      500 => InternalServerError,
+      502 => BadGateway,
+      503 => ServiceUnavailable,
+      522 => ConnectionTimedOut
+    }.freeze
+
+    def self.klass(response)
+      error_klass = STATUS_MAPPINGS[response.status]
+      return error_klass if error_klass
+
+      ResponseError if response.status >= 400
+    end
+  end
+end

data/lib/gitlab/file_response.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Gitlab
+  class FileResponse
+    HEADER_CONTENT_DISPOSITION = 'content-disposition'
+
+    attr_reader :filename
+
+    def initialize(file)
+      @file = file
+    end
+
+    def empty?
+      false
+    end
+
+    def to_hash
+      { filename: @filename, data: @file }
+    end
+    alias to_h to_hash
+
+    def inspect
+      "#<#{self.class}:#{object_id} {filename: #{filename.inspect}}>"
+    end
+
+    def method_missing(name, *, &)
+      if @file.respond_to?(name)
+        @file.send(name, *, &)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      super || @file.respond_to?(method_name, include_private)
+    end
+
+    def parse_headers!(headers)
+      @filename = headers[HEADER_CONTENT_DISPOSITION].split('filename=')[1]
+      @filename = @filename[1...-1] if @filename[0] == '"'
+    end
+  end
+end

data/lib/gitlab/headers/page_links.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Headers
+    class PageLinks
+      HEADER_LINK = 'link'
+      DELIM_LINKS = ','
+      LINK_REGEX = /<([^>]+)>; rel="([^"]+)"/
+      METAS = %w[last next first prev].freeze
+
+      attr_accessor(*METAS)
+
+      def initialize(headers)
+        link_header = headers[HEADER_LINK]
+
+        extract_links(link_header) if link_header && link_header =~ /(next|first|last|prev)/
+      end
+
+      def extract_links(header)
+        header.split(DELIM_LINKS).each do |link|
+          LINK_REGEX.match(link.strip) do |match|
+            url = match[1]
+            meta = match[2]
+            next if !url || !meta || METAS.index(meta).nil?
+
+            send("#{meta}=", url)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/headers/total.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Headers
+    class Total
+      HEADER_TOTAL = 'x-total'
+      TOTAL_REGEX = /^\d+$/
+
+      attr_accessor :total
+
+      def initialize(headers)
+        header_total = headers[HEADER_TOTAL]
+
+        extract_total(header_total) if header_total
+      end
+
+      def extract_total(header_total)
+        TOTAL_REGEX.match(header_total.strip) do |match|
+          @total = match[0]
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/objectified_hash.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Gitlab
+  class ObjectifiedHash
+    def initialize(hash)
+      @hash = hash
+      @data = hash.each_with_object({}) do |(key, value), data|
+        value = self.class.new(value) if value.is_a?(Hash)
+        value = value.map { |v| v.is_a?(Hash) ? self.class.new(v) : v } if value.is_a?(Array)
+        data[key.to_s] = value
+      end
+    end
+
+    def to_hash
+      hash
+    end
+    alias to_h to_hash
+
+    def inspect
+      "#<#{self.class}:#{object_id} {hash: #{hash.inspect}}"
+    end
+
+    def [](key)
+      data[key]
+    end
+
+    attr_reader :hash, :data
+
+    def method_missing(method_name, *, &)
+      if data.key?(method_name.to_s)
+        data[method_name.to_s]
+      elsif data.respond_to?(method_name)
+        warn 'WARNING: Please convert ObjectifiedHash object to hash before calling Hash methods on it.'
+        data.send(method_name, *, &)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      hash.keys.map(&:to_sym).include?(method_name.to_sym) || super
+    end
+  end
+end

data/lib/gitlab/paginated_response.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Gitlab
+  class PaginatedResponse
+    attr_accessor :client
+
+    def initialize(array)
+      @array = array
+    end
+
+    def ==(other)
+      @array == other
+    end
+
+    def inspect
+      @array.inspect
+    end
+
+    def method_missing(name, *, &)
+      if @array.respond_to?(name)
+        @array.send(name, *, &)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      super || @array.respond_to?(method_name, include_private)
+    end
+
+    def parse_headers!(headers)
+      @links = Headers::PageLinks.new(headers)
+      @total = Headers::Total.new(headers)
+    end
+
+    def each_page
+      current = self
+      yield current
+      while current.has_next_page?
+        current = current.next_page
+        yield current
+      end
+    end
+
+    def lazy_paginate
+      to_enum(:each_page).lazy.flat_map(&:to_ary)
+    end
+
+    def auto_paginate(&block)
+      return lazy_paginate.to_a unless block
+
+      lazy_paginate.each(&block)
+    end
+
+    def paginate_with_limit(limit, &block)
+      return lazy_paginate.take(limit).to_a unless block
+
+      lazy_paginate.take(limit).each(&block)
+    end
+
+    def total
+      @total.total
+    end
+
+    def last_page?
+      !(@links.nil? || @links.last.nil?)
+    end
+    alias has_last_page? last_page?
+
+    def last_page
+      return nil if @client.nil? || !has_last_page?
+
+      @client.get(client_relative_path(@links.last))
+    end
+
+    def first_page?
+      !(@links.nil? || @links.first.nil?)
+    end
+    alias has_first_page? first_page?
+
+    def first_page
+      return nil if @client.nil? || !has_first_page?
+
+      @client.get(client_relative_path(@links.first))
+    end
+
+    def next_page?
+      !(@links.nil? || @links.next.nil?)
+    end
+    alias has_next_page? next_page?
+
+    def next_page
+      return nil if @client.nil? || !has_next_page?
+
+      @client.get(client_relative_path(@links.next))
+    end
+
+    def prev_page?
+      !(@links.nil? || @links.prev.nil?)
+    end
+    alias has_prev_page? prev_page?
+
+    def prev_page
+      return nil if @client.nil? || !has_prev_page?
+
+      @client.get(client_relative_path(@links.prev))
+    end
+
+    def client_relative_path(link)
+      client_endpoint_path = URI.parse(@client.endpoint).request_uri
+      URI.parse(link).request_uri.sub(client_endpoint_path, '')
+    end
+  end
+end

data/lib/gitlab/request.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+module Gitlab
+  class Request
+    attr_accessor :private_token, :endpoint, :pat_prefix, :body_as_json
+
+    def self.parse(body)
+      body = decode(body)
+
+      if body.is_a?(Hash)
+        ObjectifiedHash.new(body)
+      elsif body.is_a?(Array)
+        PaginatedResponse.new(body.map { |e| ObjectifiedHash.new(e) })
+      elsif body
+        true
+      elsif !body
+        false
+      else
+        raise Error::Parsing, "Couldn't parse a response body"
+      end
+    end
+
+    def self.decode(response)
+      response ? JSON.parse(response) : {}
+    rescue JSON::ParserError
+      raise Error::Parsing, 'The response is not a valid JSON'
+    end
+
+    %w[get post put patch delete].each do |method|
+      define_method(method) do |path, options = {}|
+        params = options.dup
+
+        unless params[:unauthenticated]
+          params[:headers] ||= {}
+          params[:headers].merge!(authorization_header)
+        end
+        params.delete(:unauthenticated)
+
+        jsonify_body_content(params) if body_as_json
+
+        retries_left = params.delete(:ratelimit_retries) || 3
+        begin
+          response = make_request(method, 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
+
+    def validate(response)
+      error_klass = Error.klass(response)
+      raise error_klass, response if error_klass
+
+      parsed = self.class.parse(response.body)
+      parsed.client = self if parsed.respond_to?(:client=)
+      parsed.parse_headers!(response.headers) if parsed.respond_to?(:parse_headers!)
+      parsed
+    end
+
+    def request_defaults(sudo = nil)
+      raise Error::MissingCredentials, 'Please set an endpoint to API' unless endpoint
+
+      @sudo = sudo
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: endpoint) do |conn|
+        conn.request :url_encoded
+        conn.options.open_timeout = 30
+        conn.options.timeout = 60
+      end
+    end
+
+    def make_request(method, path, params)
+      headers = default_headers.merge(params[:headers] || {})
+      headers['Sudo'] = @sudo if @sudo
+      query = params[:query] || {}
+      body = params[:body]
+
+      connection.send(method) do |req|
+        req.url(path)
+        req.headers = headers
+
+        if %w[post put patch].include?(method)
+          if body.is_a?(Hash) && headers['Content-Type'] == 'application/json'
+            req.body = body.to_json
+          elsif body.is_a?(Hash)
+            req.body = URI.encode_www_form(body)
+          else
+            req.body = body
+          end
+          query.each { |k, v| req.params[k] = v }
+        else
+          query.each { |k, v| req.params[k] = v }
+        end
+      end
+    end
+
+    def default_headers
+      {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/x-www-form-urlencoded',
+        'User-Agent' => user_agent
+      }
+    end
+
+    def user_agent
+      @user_agent || Configuration::DEFAULT_USER_AGENT
+    end
+
+    def user_agent=(value)
+      @user_agent = value
+    end
+
+    def authorization_header
+      raise Error::MissingCredentials, 'Please provide a private_token or auth_token for user' unless private_token
+
+      if private_token.size >= 64
+        { 'Authorization' => "Bearer #{private_token}" }
+      elsif private_token.start_with?(pat_prefix.to_s)
+        { 'PRIVATE-TOKEN' => private_token }
+      else
+        { 'JOB-TOKEN' => private_token }
+      end
+    end
+
+    def jsonify_body_content(params)
+      return unless params[:body] && params[:multipart] != true
+      return if params[:headers]&.key?('Content-Type')
+
+      params[:headers] ||= {}
+      params[:headers]['Content-Type'] = 'application/json'
+    end
+  end
+end

data/lib/gitlab/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Gitlab
+  VERSION = '5.1.0'
+end

data/lib/gitlab.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'gitlab/version'
+require 'gitlab/objectified_hash'
+require 'gitlab/configuration'
+require 'gitlab/error'
+require 'gitlab/headers/page_links'
+require 'gitlab/headers/total'
+require 'gitlab/paginated_response'
+require 'gitlab/file_response'
+require 'gitlab/request'
+require 'gitlab/api'
+require 'gitlab/client'
+
+module Gitlab
+  extend Configuration
+
+  def self.client(options = {})
+    Gitlab::Client.new(options)
+  end
+
+  def self.method_missing(method, *, **keywargs, &)
+    return super unless client.respond_to?(method)
+
+    client.send(method, *, **keywargs, &)
+  end
+
+  def self.respond_to_missing?(method_name, include_private = false)
+    client.respond_to?(method_name) || super
+  end
+
+  def self.actions
+    hidden = /endpoint|private_token|auth_token|user_agent|sudo|get|post|put|patch|\Adelete\z|validate\z|request_defaults/
+    (Gitlab::Client.instance_methods - Object.methods).reject { |e| e[hidden] }
+  end
+end