gitlab-akerl 4.0.0

data/lib/gitlab/file_response.rb

@@ -0,0 +1,46 @@
+module Gitlab
+  # Wrapper class of file response.
+  class FileResponse
+    HEADER_CONTENT_DISPOSITION = 'Content-Disposition'.freeze
+
+    attr_reader :filename
+
+    def initialize(file)
+      @file = file
+    end
+
+    # @return [bool] Always false
+    def empty?
+      false
+    end
+
+    # @return [Hash] A hash consisting of filename and io object
+    def to_hash
+      { filename: @filename, data: @file }
+    end
+    alias_method :to_h, :to_hash
+
+    # @return [String] Formatted string with the class name, object id and filename.
+    def inspect
+      "#<#{self.class}:#{object_id} {filename: #{filename.inspect}}>"
+    end
+
+    def method_missing(name, *args, &block)
+      if @file.respond_to?(name)
+        @file.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      super || @file.respond_to?(method_name, include_private)
+    end
+
+    # Parse filename from the 'Content Disposition' header.
+    def parse_headers!(headers)
+      @filename = headers[HEADER_CONTENT_DISPOSITION].split("filename=")[1]
+      @filename = @filename[1...-1] if @filename[0] == '"' # Unquote filenames
+    end
+  end
+end

data/lib/gitlab/help.rb

@@ -0,0 +1,95 @@
+require 'gitlab'
+require 'gitlab/cli_helpers'
+
+module Gitlab::Help
+  extend Gitlab::CLI::Helpers
+
+  class << self
+    # Returns the (modified) help from the 'ri' command or returns an error.
+    #
+    # @return [String]
+    def get_help(cmd)
+      cmd_namespace = namespace cmd
+
+      if cmd_namespace
+        ri_output = `#{ri_cmd} -T #{cmd_namespace} 2>&1`.chomp
+
+        if $CHILD_STATUS == 0
+          change_help_output! cmd, ri_output
+          yield ri_output if block_given?
+
+          ri_output
+        else
+          "Ri docs not found for #{cmd}, please install the docs to use 'help'."
+        end
+      else
+        "Unknown command: #{cmd}."
+      end
+    end
+
+    # Finds the location of 'ri' on a system.
+    #
+    # @return [String]
+    def ri_cmd
+      which_ri = `which ri`.chomp
+      if which_ri.empty?
+        fail "'ri' tool not found in $PATH. Please install it to use the help."
+      end
+
+      which_ri
+    end
+
+    # A hash map that contains help topics (Branches, Groups, etc.)
+    # and a list of commands that are defined under a topic (create_branch,
+    # branches, protect_branch, etc.).
+    #
+    # @return [Hash<Array>]
+    def help_map
+      @help_map ||= begin
+        actions.each_with_object({}) do |action, hsh|
+          key = client.method(action).
+                owner.to_s.gsub(/Gitlab::(?:Client::)?/, '')
+          hsh[key] ||= []
+          hsh[key] << action.to_s
+        end
+      end
+    end
+
+    # Table with available commands.
+    #
+    # @return [Terminal::Table]
+    def actions_table(topic=nil)
+      rows = topic ? help_map[topic] : help_map.keys
+      table do |t|
+        t.title = topic || "Help Topics"
+
+        # add_row expects an array and we have strings hence the map.
+        rows.sort.map { |r| [r] }.each_with_index do |row, index|
+          t.add_row row
+          t.add_separator unless rows.size - 1 == index
+        end
+      end
+    end
+
+    # Returns full namespace of a command (e.g. Gitlab::Client::Branches.cmd)
+    def namespace(cmd)
+      method_owners.select { |method| method[:name] === cmd }.
+        map { |method| method[:owner] + '.' + method[:name] }.
+        shift
+    end
+
+    # Massage output from 'ri'.
+    def change_help_output!(cmd, output_str)
+      output_str.gsub!(/#{cmd}\((.*?)\)/m, cmd + ' \1')
+      output_str.gsub!(/\,[\s]*/, ' ')
+      
+      # Ensure @option descriptions are on a single line
+      output_str.gsub!(/\n\[/, " \[")
+      output_str.gsub!(/\s(@)/, "\n@")
+      output_str.gsub!(/(\])\n(\:)/, '\1 \2')
+      output_str.gsub!(/(\:.*)(\n)(.*\.)/, '\1 \3')
+      output_str.gsub!(/\{(.+)\}/, '"{\1}"')
+      
+    end
+  end # class << self
+end

data/lib/gitlab/objectified_hash.rb

@@ -0,0 +1,34 @@
+module Gitlab
+  # Converts hashes to the objects.
+  class ObjectifiedHash
+    # Creates a new ObjectifiedHash object.
+    def initialize(hash)
+      @hash = hash
+      @data = hash.inject({}) do |data, (key, value)|
+        value = ObjectifiedHash.new(value) if value.is_a? Hash
+        data[key.to_s] = value
+        data
+      end
+    end
+
+    # @return [Hash] The original hash.
+    def to_hash
+      @hash
+    end
+    alias_method :to_h, :to_hash
+
+    # @return [String] Formatted string with the class name, object id and original hash.
+    def inspect
+      "#<#{self.class}:#{object_id} {hash: #{@hash.inspect}}"
+    end
+
+    # Delegate to ObjectifiedHash.
+    def method_missing(key)
+      @data.key?(key.to_s) ? @data[key.to_s] : nil
+    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/page_links.rb

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

data/lib/gitlab/paginated_response.rb

@@ -0,0 +1,97 @@
+module Gitlab
+  # Wrapper class of paginated response.
+  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, *args, &block)
+      if @array.respond_to?(name)
+        @array.send(name, *args, &block)
+      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 = PageLinks.new headers
+    end
+
+    def each_page
+      current = self
+      yield current
+      while current.has_next_page?
+        current = current.next_page
+        yield current
+      end
+    end
+
+    def auto_paginate
+      response = block_given? ? nil : []
+      each_page do |page|
+        if block_given?
+          page.each do |item|
+            yield item
+          end
+        else
+          response += page
+        end
+      end
+      response
+    end
+
+    def has_last_page?
+      !(@links.nil? || @links.last.nil?)
+    end
+
+    def last_page
+      return nil if @client.nil? || !has_last_page?
+      path = @links.last.sub(/#{@client.endpoint}/, '')
+      @client.get(path)
+    end
+
+    def has_first_page?
+      !(@links.nil? || @links.first.nil?)
+    end
+
+    def first_page
+      return nil if @client.nil? || !has_first_page?
+      path = @links.first.sub(/#{@client.endpoint}/, '')
+      @client.get(path)
+    end
+
+    def has_next_page?
+      !(@links.nil? || @links.next.nil?)
+    end
+
+    def next_page
+      return nil if @client.nil? || !has_next_page?
+      path = @links.next.sub(/#{@client.endpoint}/, '')
+      @client.get(path)
+    end
+
+    def has_prev_page?
+      !(@links.nil? || @links.prev.nil?)
+    end
+
+    def prev_page
+      return nil if @client.nil? || !has_prev_page?
+      path = @links.prev.sub(/#{@client.endpoint}/, '')
+      @client.get(path)
+    end
+  end
+end

data/lib/gitlab/request.rb

@@ -0,0 +1,117 @@
+require 'httparty'
+require 'json'
+
+module Gitlab
+  # @private
+  class Request
+    include HTTParty
+    format :json
+    headers 'Accept' => 'application/json'
+    parser proc { |body, _| parse(body) }
+
+    attr_accessor :private_token, :endpoint
+
+    # Converts the response body to an ObjectifiedHash.
+    def self.parse(body)
+      body = decode(body)
+
+      if body.is_a? Hash
+        ObjectifiedHash.new body
+      elsif body.is_a? Array
+        PaginatedResponse.new(body.collect! { |e| ObjectifiedHash.new(e) })
+      elsif body
+        true
+      elsif !body
+        false
+      elsif body.nil?
+        false
+      else
+        raise Error::Parsing.new "Couldn't parse a response body"
+      end
+    end
+
+    # Decodes a JSON response into Ruby object.
+    def self.decode(response)
+      JSON.load response
+    rescue JSON::ParserError
+      raise Error::Parsing.new "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
+
+    def post(path, options={})
+      set_httparty_config(options)
+      set_authorization_header(options, path)
+      validate self.class.post(@endpoint + path, options)
+    end
+
+    def put(path, options={})
+      set_httparty_config(options)
+      set_authorization_header(options)
+      validate self.class.put(@endpoint + path, options)
+    end
+
+    def delete(path, options={})
+      set_httparty_config(options)
+      set_authorization_header(options)
+      validate self.class.delete(@endpoint + path, options)
+    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
+
+      parsed = response.parsed_response
+      parsed.client = self if parsed.respond_to?(:client=)
+      parsed.parse_headers!(response.headers) if parsed.respond_to?(:parse_headers!)
+      parsed
+    end
+
+    # Sets a base_uri and default_params for requests.
+    # @raise [Error::MissingCredentials] if endpoint not set.
+    def set_request_defaults(sudo=nil)
+      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.
+    # @raise [Error::MissingCredentials] if private_token and auth_token are not set.
+    def set_authorization_header(options, path=nil)
+      unless path == '/session'
+        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
+      end
+    end
+
+    # Set HTTParty configuration
+    # @see https://github.com/jnunemaker/httparty
+    def set_httparty_config(options)
+      options.merge!(httparty) if httparty
+    end
+  end
+end

data/lib/gitlab/shell.rb

@@ -0,0 +1,84 @@
+require 'gitlab'
+require 'gitlab/help'
+require 'gitlab/cli_helpers'
+require 'gitlab/shell_history'
+require 'readline'
+require 'shellwords'
+
+class Gitlab::Shell
+  extend Gitlab::CLI::Helpers
+
+  class << self
+    attr_reader :arguments, :command
+
+    def start
+      trap('INT') { quit_shell } # capture ctrl-c
+      setup
+
+      while buffer = Readline.readline('gitlab> ')
+        begin
+          parse_input buffer
+
+          @arguments.map! { |arg| symbolize_keys(yaml_load(arg)) }
+
+          case buffer
+          when nil, ''
+            next
+          when 'exit'
+            quit_shell
+          when /^\bhelp\b+/
+            puts help(arguments[0]) { |out| out.gsub!(/Gitlab\./, 'gitlab> ') }
+          else
+            history << buffer
+
+            data = execute command, arguments
+            output_table command, arguments, data
+          end
+        rescue => e
+          puts e.message
+        end
+      end
+
+      quit_shell # save history if user presses ctrl-d
+    end
+
+    def parse_input(buffer)
+      buf = Shellwords.shellwords(buffer)
+
+      @command = buf.shift
+      @arguments = buf.count > 0 ? buf : []
+    end
+
+    def setup
+      history.load
+
+      Readline.completion_proc = completion
+      Readline.completion_append_character = ' '
+    end
+
+    # Gets called when user hits TAB key to do completion
+    def completion
+      proc { |str| actions.map(&:to_s).grep(/^#{Regexp.escape(str)}/) }
+    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
+    end
+
+    def quit_shell
+      history.save
+      exit
+    end
+
+    def history
+      @history ||= History.new
+    end
+  end # class << self
+end