ruaur 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 50ebe39558c3e6efd9953ae693863c8d7e7686c5
+  data.tar.gz: f4be7e20aa56a689686470120d08c4a82d6ef496
+SHA512:
+  metadata.gz: 35750a58dd7ba7b56e899b47504db601d8c8d211b6c0464efd5e2b50471eacdc630196b3e47e2e670b78ffd6534cee85869f83f1106d2aee18695fc3b93a6072
+  data.tar.gz: da1963ce9bb15df155d8b012b74d1cca7cb6a24964607fb9623a46838ba2b5e4306a4f7b7916f41497aa1e221bf734273ddc80f554fdcb48c76943fa9ee5371b

data/bin/ruaur

@@ -0,0 +1,201 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "ruaur"
+require "string"
+
+class RuAURExit
+    GOOD = 0
+    INVALID_OPTION = 1
+    INVALID_ARGUMENT = 2
+    MISSING_ARGUMENT = 3
+    INVALID_OPERATION = 4
+    MULTIPLE_OPERATIONS = 5
+    EXCEPTION = 6
+end
+
+class Operation
+    REMOVE = 1
+    SYNC = 2
+end
+
+def parse(args)
+    options = Hash.new
+    options["operation"] = nil
+
+    # Sync options
+    options["clean"] = false
+    options["noconfirm"] = false
+    options["search"] = false
+    options["upgrade"] = false
+
+    # Remove options
+    options["nosave"] = false
+
+    parser = OptionParser.new do |opts|
+        opts.banner =
+            "Usage: #{File.basename($0)} <operation> [OPTIONS] [pkgs]"
+
+        opts.on("", "OPERATIONS")
+
+        opts.on("-h", "--help", "Display this help message") do
+            puts opts
+            exit
+        end
+
+        opts.on("-R", "--remove", "Remove packages") do
+            if (options["operation"])
+                puts opts
+                exit RuAURExit::MULTIPLE_OPERATIONS
+            end
+            options["operation"] = Operation::REMOVE
+        end
+
+        opts.on("-S", "--sync", "Synchronize packages") do
+            if (options["operation"])
+                puts opts
+                exit RuAURExit::MULTIPLE_OPERATIONS
+            end
+            options["operation"] = Operation::SYNC
+        end
+
+        opts.on("", "SYNC OPTIONS")
+
+        opts.on("-c", "--clean", "Remove packages from the cache") do
+            options["clean"] = true
+        end
+
+        opts.on(
+            "--noconfirm",
+            "Bypass any and all \"Are you sure?\" messages."
+        ) do
+            options["noconfirm"] = true
+        end
+
+        opts.on(
+            "-s",
+            "--search",
+            "Search the sync database and AUR for packages"
+        ) do
+            options["search"] = true
+        end
+
+        opts.on("-u", "--sysupgrade", "Upgrade all packages") do
+            options["upgrade"] = true
+        end
+
+        opts.on("", "REMOVE OPTIONS")
+
+        opts.on("-n", "--nosave", "Completely remove package") do
+            options["nosave"] = true
+        end
+    end
+
+    begin
+        parser.parse!
+    rescue OptionParser::InvalidOption => e
+        puts e.message
+        puts parser
+        exit RuAURExit::INVALID_OPTION
+    rescue OptionParser::InvalidArgument => e
+        puts e.message
+        puts parser
+        exit RuAURExit::INVALID_ARGUMENT
+    rescue OptionParser::MissingArgument => e
+        puts e.message
+        puts parser
+        exit RuAURExit::MISSING_ARGUMENT
+    end
+
+    if (!validate(options))
+        puts parser
+        exit RuAURExit::INVALID_OPERATION
+    end
+
+    options["packages"] = args
+
+    return options
+end
+
+def validate(options)
+    case options["operation"]
+    when Operation::REMOVE
+        if (
+            options["clean"] ||
+            options["noconfirm"] ||
+            options["search"] ||
+            options["upgrade"]
+        )
+            return false
+        end
+    when Operation::SYNC
+        return false if (options["nosave"])
+
+        if (options["clean"])
+            if (
+                options["noconfirm"] ||
+                options["search"] ||
+                options["upgrade"]
+            )
+                return false
+            end
+        elsif (options["noconfirm"])
+            if (
+                options["clean"] ||
+                options["search"] ||
+                options["upgrade"]
+            )
+                return false
+            end
+        elsif (options["search"])
+            if (
+                options["clean"] ||
+                options["noconfirm"] ||
+                options["upgrade"]
+            )
+                return false
+            end
+        elsif (options["upgrade"])
+            if (
+                options["clean"] ||
+                options["noconfirm"] ||
+                options["search"]
+            )
+                return false
+            end
+        end
+    else
+        return false
+    end
+
+    return true
+end
+
+# Parse CLI args
+options = parse(ARGV)
+
+begin
+    ruaur = RuAUR.new
+
+    case options["operation"]
+    when Operation::REMOVE
+        ruaur.remove(options["packages"], options["nosave"])
+    when Operation::SYNC
+        if (options["clean"])
+            ruaur.clean(options["noconfirm"])
+        elsif (options["search"])
+            puts ruaur.search(options["packages"].join(" "))
+        elsif (options["upgrade"])
+            ruaur.upgrade(options["noconfirm"])
+        else
+            ruaur.install(options["packages"], options["noconfirm"])
+        end
+    end
+    exit RuAURExit::GOOD
+rescue RuAUR::Error => e
+    puts e.message.red
+    exit RuAURExit::EXCEPTION
+rescue Interrupt => e
+    # ^C
+    puts
+end

data/lib/ruaur/aur.rb

@@ -0,0 +1,263 @@
+require "archive/tar/minitar"
+require "fileutils"
+require "io/wait"
+require "json"
+require "scoobydoo"
+require "typhoeus"
+require "zlib"
+
+class RuAUR::AUR
+    def clean
+        puts "Cleaning AUR cache...".white
+        Dir.chdir(@cache) do
+            FileUtils.rm_rf(Dir["*"])
+        end
+    end
+
+    def compile(package)
+        puts "Compiling #{package.name}...".white
+        if (Process.uid == 0)
+            system("chown -R nobody:nobody .")
+            system("su -s /bin/sh nobody -c \"makepkg -sr\"")
+        else
+            system("makepkg -sr")
+        end
+
+        compiled = Dir["#{package.name}*.pkg.tar.xz"]
+        if (compiled.empty?)
+            raise RuAUR::Error::FailedToCompileError.new(package.name)
+        end
+
+        return compiled
+    end
+    private :compile
+
+    def download(package)
+        FileUtils.rm_f(Dir["#{package.name}.tar.gz*"])
+
+        puts "Downloading #{package.name}...".white
+        tarball(package.name, package.url, "#{package.name}.tar.gz")
+
+        tgz = Pathname.new("#{package.name}.tar.gz").expand_path
+        if (!tgz.exist?)
+            raise RuAUR::Error::FailedToDownloadError.new(
+                package.name
+            )
+        end
+    end
+    private :download
+
+    def edit_pkgbuild(package, noconfirm = false)
+        return false if (noconfirm)
+
+        print "Do you want to edit the PKGBUILD y/[n]/q?: "
+        answer = nil
+        while (answer.nil?)
+            begin
+                system("stty raw -echo")
+                if ($stdin.ready?)
+                    answer = $stdin.getc
+                else
+                    sleep 0.1
+                end
+            ensure
+                system("stty -raw echo")
+            end
+        end
+        puts
+
+        case answer
+        when "y", "Y"
+            editor = ENV["EDITOR"]
+            editor = ScoobyDoo.where_are_you("vim") if (editor.nil?)
+            editor = ScoobyDoo.where_are_you("vi") if (editor.nil?)
+            system("#{editor} PKGBUILD")
+        when "q", "Q", "\x03"
+            # Quit or ^C
+            return true
+        end
+        return false
+    end
+    private :edit_pkgbuild
+
+    def extract(package)
+        FileUtils.rm_rf(package.name)
+
+        puts "Extracting #{package.name}...".white
+        File.open("#{package.name}.tar.gz", "rb") do |tgz|
+            tar = Zlib::GzipReader.new(tgz)
+            Archive::Tar::Minitar.unpack(tar, ".")
+        end
+        FileUtils.rm_f("pax_global_header")
+
+        dir = Pathname.new(package.name).expand_path
+        if (!dir.exist? || !dir.directory?)
+            raise RuAUR::Error::FailedToExtractError.new(package.name)
+        end
+    end
+    private :extract
+
+    def find_upgrades
+        puts "Checking for AUR updates...".white
+
+        upgrades = Hash.new
+        multiinfo(@installed.keys).each do |package|
+            if (
+                @installed.has_key?(package.name) &&
+                package.newer?(@installed[package.name])
+            )
+                upgrades[package.name] = [
+                    @installed[package.name],
+                    package.version
+                ]
+            end
+        end
+
+        return upgrades
+    end
+    private :find_upgrades
+
+    def info(package)
+        return nil if (package.nil? || package.empty?)
+
+        query = "type=info&arg=#{package}"
+        body = JSON.parse(Typhoeus.get("#{@rpc_url}?#{query}").body)
+
+        if (body["type"] == "error")
+            raise RuAUR::Error::AURError.new(body["results"])
+        end
+
+        return nil if (body["results"].empty?)
+        return RuAUR::Package.new(body["results"])
+    end
+
+    def initialize(pacman, cache = "/tmp/ruaur-#{ENV["USER"]}")
+        @cache = Pathname.new(cache).expand_path
+        FileUtils.mkdir_p(@cache)
+        @installed = pacman.query_aur
+        @pacman = pacman
+        @rpc_url = "https://aur.archlinux.org/rpc.php"
+    end
+
+    def install(pkg_name, noconfirm = false)
+        package = info(pkg_name)
+
+        if (package.nil?)
+            raise RuAUR::Error::PackageNotFoundError.new(pkg_name)
+        end
+
+        if (
+            @installed.include?(pkg_name) &&
+            !package.newer?(@installed[pkg_name])
+        )
+            puts "Already installed: #{pkg_name}".yellow
+            return
+        end
+
+        Dir.chdir(@cache) do
+            download(package)
+            extract(package)
+        end
+        Dir.chdir("#{@cache}/#{package.name}") do
+            return if (edit_pkgbuild(package, noconfirm))
+            install_dependencies(package, noconfirm)
+            compiled = compile(package)
+            @pacman.install_local(compiled, noconfirm)
+        end
+
+        @installed.merge!(@pacman.query_aur(pkg_name))
+    end
+
+    def install_dependencies(package, noconfirm)
+        pkgbuild = File.read("PKGBUILD")
+
+        pkgbuild.match(/^depends\=\(([^\)]+)\)/m) do |match|
+            match.captures.each do |cap|
+                cap.gsub(/\n/, " ").scan(/[^' ]+/) do |scan|
+                    dep = scan.gsub(/(\<|\=|\>).*$/, "")
+                    if (!@installed.has_key?(dep))
+                        puts "Installing dependency: #{dep}".purple
+                        if (@pacman.exist?(dep))
+                            @pacman.install(dep, noconfirm)
+                        else
+                            install(dep, noconfirm)
+                        end
+                    end
+                end
+            end
+        end
+    end
+    private :install_dependencies
+
+    def multiinfo(pkgs)
+        results = Array.new
+        return results if (pkgs.nil? || pkgs.empty?)
+
+        query = "type=multiinfo&arg[]=#{pkgs.join("&arg[]=")}"
+        body = JSON.parse(Typhoeus.get("#{@rpc_url}?#{query}").body)
+
+        if (body["type"] == "error")
+            raise RuAUR::Error::AURError.new(body["results"])
+        end
+
+        body["results"].each do |result|
+            results.push(RuAUR::Package.new(result))
+        end
+        return results.sort
+    end
+
+    def search(string)
+        results = Array.new
+        return results if (string.nil? || string.empty?)
+
+        query = "type=search&arg=#{string}"
+        body = JSON.parse(Typhoeus.get("#{@rpc_url}?#{query}").body)
+
+        if (body["type"] == "error")
+            raise RuAUR::Error::AURError.new(body["results"])
+        end
+
+        body["results"].each do |result|
+            results.push(RuAUR::Package.new(result))
+        end
+
+        results.each do |package|
+            if (@installed.has_key?(package.name))
+                package.installed(@installed[package.name])
+            end
+        end
+        return results.sort
+    end
+
+    def tarball(name, url, file)
+        if (url.nil? || url.empty? || file.nil? || file.empty?)
+            return nil
+        end
+
+        tgz = File.open(file, "wb")
+        request = Typhoeus::Request.new(url)
+        request.on_headers do |response|
+            if (response.code != 200)
+                raise RuAUR::Error::FailedToDownloadError.new(name)
+            end
+        end
+        request.on_body do |chunk|
+            tgz.write(chunk)
+        end
+        request.on_complete do
+            tgz.close
+        end
+        request.run
+    end
+    private :tarball
+
+    def upgrade(noconfirm = false)
+        find_upgrades.each do |pkg_name, versions|
+            old, new = versions
+
+            puts "Upgrading #{pkg_name}...".white
+            puts  "#{old.red} -> #{new.green}"
+            install(pkg_name, noconfirm)
+        end
+    end
+end

data/lib/ruaur/error/aur_error.rb

@@ -0,0 +1,5 @@
+class RuAUR::Error::AURError < RuAUR::Error
+    def initialize(msg)
+        super(msg)
+    end
+end

data/lib/ruaur/error/failed_to_compile_error.rb

@@ -0,0 +1,6 @@
+class RuAUR::Error::FailedToCompileError < RuAUR::Error
+    def initialize(package = nil)
+        super("Failed to compile: #{package}") if (package)
+        super("Failed to compile") if (package.nil?)
+    end
+end

data/lib/ruaur/error/failed_to_download_error.rb

@@ -0,0 +1,6 @@
+class RuAUR::Error::FailedToDownloadError < RuAUR::Error
+    def initialize(package = nil)
+        super("Failed to download: #{package}") if (package)
+        super("Failed to download") if (package.nil?)
+    end
+end

data/lib/ruaur/error/failed_to_extract_error.rb

@@ -0,0 +1,6 @@
+class RuAUR::Error::FailedToExtractError < RuAUR::Error
+    def initialize(package = nil)
+        super("Failed to extract: #{package}") if (package)
+        super("Failed to extract") if (package.nil?)
+    end
+end

data/lib/ruaur/error/missing_dependency_error.rb

@@ -0,0 +1,6 @@
+class RuAUR::Error::MissingDependencyError < RuAUR::Error
+    def initialize(dep = nil)
+        super("Dependency not found: #{dep}") if (dep)
+        super("Dependency not found") if (dep.nil?)
+    end
+end

data/lib/ruaur/error/package_not_found_error.rb

@@ -0,0 +1,6 @@
+class RuAUR::Error::PackageNotFoundError < RuAUR::Error
+    def initialize(package = nil)
+        super("Package not found: #{package}") if (package)
+        super("No package was specified") if (package.nil?)
+    end
+end

data/lib/ruaur/error/package_not_installed_error.rb

@@ -0,0 +1,6 @@
+class RuAUR::Error::PackageNotInstalledError < RuAUR::Error
+    def initialize(package = nil)
+        super("Package not installed: #{package}") if (package)
+        super("Package not installed") if (package.nil?)
+    end
+end

data/lib/ruaur/error/ruaur_already_running_error.rb

@@ -0,0 +1,5 @@
+class RuAUR::Error::RuAURAlreadyRunningError < RuAUR::Error
+    def initialize
+        super("RuAUR is already running")
+    end
+end

data/lib/ruaur/error.rb

@@ -0,0 +1,11 @@
+class RuAUR::Error < RuntimeError
+end
+
+require "ruaur/error/aur_error"
+require "ruaur/error/failed_to_compile_error"
+require "ruaur/error/failed_to_download_error"
+require "ruaur/error/failed_to_extract_error"
+require "ruaur/error/missing_dependency_error"
+require "ruaur/error/package_not_found_error"
+require "ruaur/error/package_not_installed_error"
+require "ruaur/error/ruaur_already_running_error"

data/lib/ruaur/package.rb

@@ -0,0 +1,95 @@
+require "string"
+
+class RuAUR::Package
+    attr_accessor :description
+    attr_accessor :installed
+    attr_accessor :json
+    attr_accessor :name
+    attr_accessor :repo
+    attr_accessor :url
+    attr_accessor :version
+    attr_accessor :votes
+
+    def <=>(other)
+        if (self.name.downcase == other.name.downcase)
+            self_version = self.version.split(/\D+/).map(&:to_i)
+            other_version = self.version.split(/\D+/).map(&:to_i)
+
+            [self_version.size, other_version.size].max.times do |i|
+                cmp = self_version[i] <=> other_version[i]
+                return cmp if (cmp != 0)
+            end
+        end
+        return (self.name.downcase <=> other.name.downcase)
+    end
+
+    def initialize(json, repo = "aur")
+        @description = json["Description"]
+        @installed = nil
+        @json = json
+        @name = json["Name"]
+        @repo = repo
+        if (json["URLPath"])
+            @url = "https://aur.archlinux.org#{json["URLPath"]}"
+        else
+            @url = nil
+        end
+        @version = json["Version"]
+        @votes = nil
+        @votes = "(#{json["NumVotes"]})" if (json["NumVotes"])
+    end
+
+    def installed(version = nil)
+        @installed = version if (version)
+        @installed = @version if (version.nil?)
+    end
+
+    def newer?(ver)
+        self_version = @version.split(/\D+/).map(&:to_i)
+        other_version = ver.split(/\D+/).map(&:to_i)
+
+        [self_version.size, other_version.size].max.times do |i|
+            if (self_version[i] > other_version[i])
+                return true
+            end
+        end
+        return false
+    end
+
+    def older?(version)
+        self_version = @version.split(/\D+/).map(&:to_i)
+        other_version = version.split(/\D+/).map(&:to_i)
+
+        [self_version.size, other_version.size].max.times do |i|
+            if (self_version[i] < other_version[i])
+                return true
+            end
+        end
+        return false
+    end
+
+    def tarball(file)
+        return RuAUR::AUR.tarball(@url, file)
+    end
+
+    def to_s
+        out = Array.new
+        header = Array.new
+
+        header.push("#{@repo.blue}#{"/".blue}#{@name.cyan}")
+        if (@installed && newer?(@installed))
+            header.push(@installed.red)
+            header.push("->")
+        end
+        header.push(@version.green)
+        header.push(@votes.white) if (@votes)
+        header.push("[installed]".purple) if (@installed)
+        out.push(header.join(" "))
+
+        @description.word_wrap.each_line do |line|
+            out.push("    #{line.rstrip}")
+        end
+
+        return out.join("\n")
+    end
+end

data/lib/ruaur/pacman.rb

@@ -0,0 +1,124 @@
+class RuAUR::Pacman
+    def clean(noconfirm = false)
+        puts "Cleaning pacman cache...".white
+        system("sudo #{@pac_clr} -Sc") if (!noconfirm)
+        system("sudo #{@pac_clr} -Sc --noconfirm") if (noconfirm)
+    end
+
+    def exist?(pkg_name)
+        return !%x(#{@pac_noclr} -Ss "^#{pkg_name}$").empty?
+    end
+
+    def initialize
+        @pac_noclr = "pacman --color=never"
+        @pac_clr = "pacman --color=always"
+        @installed = query
+    end
+
+    def install(pkg_name, noconfirm = false)
+        if (@installed.include?(pkg_name))
+            puts "Already installed: #{pkg_name}".yellow
+            return
+        end
+
+        puts "Installing #{pkg_name}...".white
+        if (!noconfirm)
+            system("sudo #{@pac_clr} -S #{pkg_name} --needed")
+        else
+            system(
+                "sudo #{@pac_clr} -S #{pkg_name} --needed --noconfirm"
+            )
+        end
+
+        @installed.merge!(query(pkg_name))
+    end
+
+    def install_local(pkgs, noconfirm = false)
+        pkgs.each do |pkg|
+            puts "Installing #{pkg}...".white
+            if (!noconfirm)
+                system("sudo #{@pac_clr} -U #{pkg}") if (!noconfirm)
+            else
+                system("sudo #{@pac_clr} -U #{pkg} --noconfirm")
+            end
+        end
+    end
+
+    def query(pkg_name = "")
+        results = Hash.new
+        %x(#{@pac_noclr} -Q #{pkg_name}).split("\n").map do |line|
+            line = line.split
+            results[line[0]] = line[1]
+        end
+        return results
+    end
+
+    def query_aur(pkg_name = "")
+        community = Pathname.new(
+            "/var/lib/pacman/sync/community"
+        ).expand_path
+
+        results = Hash.new
+        %x(#{@pac_noclr} -Qm #{pkg_name}).split("\n").delete_if do |p|
+            # Skip packages in community
+            Dir["#{community}/#{p.split.join("-")}"].any?
+        end.map do |line|
+            line = line.split
+            results[line[0]] = line[1]
+        end
+        return results
+    end
+
+    def remove(pkg_names, nosave = false)
+        puts "Removing #{pkg_names.join(" ")}...".white
+        if (!nosave)
+            system("sudo #{@pac_clr} -R #{pkg_names.join(" ")}")
+        else
+            system("sudo #{@pac_clr} -Rn #{pkg_names.join(" ")}")
+        end
+    end
+
+    def search(pkg_names)
+        results = Array.new
+        return results if (pkg_names.nil? || pkg_names.empty?)
+
+        %x(#{@pac_noclr} -Ss #{pkg_names}).each_line do |line|
+            reg = "^([^\/ ]+)\/([^ ]+) ([^ ]+)( .*)?$"
+            match = line.match(/#{reg}/)
+            if (match)
+                repo, name, version, trailing = match.captures
+                repo.strip!
+                name.strip!
+                version.strip!
+                trailing = "" if (trailing.nil?)
+                trailing.strip!
+
+                results.push(
+                    RuAUR::Package.new(
+                        {
+                            "Description" => "",
+                            "Name" => name,
+                            "NumVotes" => nil,
+                            "URLPath" => nil,
+                            "Version" => version
+                        },
+                        repo
+                    )
+                )
+                if (trailing.include?("[installed]"))
+                    results.last.installed
+                end
+            elsif (results.any?)
+                results.last.description += " #{line.strip}"
+            end
+        end
+
+        return results
+    end
+
+    def upgrade(noconfirm = false)
+        puts "Updating...".white
+        system("sudo #{@pac_clr} -Syyu") if (!noconfirm)
+        system("sudo #{@pac_clr} -Syyu --noconfirm") if (noconfirm)
+    end
+end

data/lib/ruaur.rb

@@ -0,0 +1,82 @@
+require "fileutils"
+require "scoobydoo"
+
+class RuAUR
+    def check_and_lock
+        if (@lock.exist?)
+            raise RuAUR::Error::RuAURAlreadyRunningError.new
+        end
+
+        FileUtils.touch(@lock)
+    end
+    private :check_and_lock
+
+    def clean(noconfirm)
+        @pacman.clean(noconfirm)
+        @aur.clean
+    end
+
+    def initialize
+        [
+            "makepkg",
+            "pacman",
+            "su",
+            "sudo"
+        ].each do |dep|
+            if (ScoobyDoo.where_are_you(dep).nil?)
+                raise RuAUR::Error::MissingDependencyError.new(dep)
+            end
+        end
+
+        @pacman = RuAUR::Pacman.new
+        @aur = RuAUR::AUR.new(@pacman)
+        @lock = Pathname.new("/tmp/ruaur.lock").expand_path
+    end
+
+    def install(pkg_names, noconfirm = false)
+        if (pkg_names.nil? || pkg_names.empty?)
+            raise RuAUR::Error::PackageNotFoundError.new
+        end
+
+        check_and_lock
+
+        pkg_names.each do |pkg_name|
+            if (@pacman.exist?(pkg_name))
+                @pacman.install(pkg_name, noconfirm)
+            else
+                @aur.install(pkg_name, noconfirm)
+            end
+        end
+    ensure
+        unlock
+    end
+
+    def remove(pkg_names, nosave = false)
+        check_and_lock
+        @pacman.remove(pkg_names, nosave)
+    ensure
+        unlock
+    end
+
+    def search(string)
+        return @pacman.search(string).concat(@aur.search(string))
+    end
+
+    def unlock
+        FileUtils.rm_f(@lock)
+    end
+    private :unlock
+
+    def upgrade(noconfirm = false)
+        check_and_lock
+        @pacman.upgrade(noconfirm)
+        @aur.upgrade(noconfirm)
+    ensure
+        unlock
+    end
+end
+
+require "ruaur/aur"
+require "ruaur/error"
+require "ruaur/package"
+require "ruaur/pacman"

data/lib/string.rb

@@ -0,0 +1,48 @@
+# Redefine String class to allow for colorizing, rsplit, and word wrap
+class String
+    def black
+        return colorize(30)
+    end
+
+    def blue
+        return colorize(34)
+    end
+
+    def colorize(color)
+        return "\e[#{color}m#{self}\e[0m"
+    end
+
+    def cyan
+        return colorize(36)
+    end
+
+    def green
+        return colorize(32)
+    end
+
+    def purple
+        return colorize(35)
+    end
+
+    def red
+        return colorize(31)
+    end
+
+    def rsplit(pattern)
+        ret = rpartition(pattern)
+        ret.delete_at(1)
+        return ret
+    end
+
+    def white
+        return colorize(37)
+    end
+
+    def word_wrap(width = 70)
+        return scan(/\S.{0,#{width}}\S(?=\s|$)|\S+/).join("\n")
+    end
+
+    def yellow
+        return colorize(33)
+    end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: ruaur
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Miles Whittaker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: archive-tar-minitar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.2
+- !ruby/object:Gem::Dependency
+  name: scoobydoo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: typhoeus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+description: RuAUR is a Ruby gem that allows searching and installing packages from
+  the Pacman sync database as well as the Arch User Repository (AUR).
+email: mjwhitta@gmail.com
+executables:
+- ruaur
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ruaur
+- lib/ruaur.rb
+- lib/ruaur/aur.rb
+- lib/ruaur/error.rb
+- lib/ruaur/error/aur_error.rb
+- lib/ruaur/error/failed_to_compile_error.rb
+- lib/ruaur/error/failed_to_download_error.rb
+- lib/ruaur/error/failed_to_extract_error.rb
+- lib/ruaur/error/missing_dependency_error.rb
+- lib/ruaur/error/package_not_found_error.rb
+- lib/ruaur/error/package_not_installed_error.rb
+- lib/ruaur/error/ruaur_already_running_error.rb
+- lib/ruaur/package.rb
+- lib/ruaur/pacman.rb
+- lib/string.rb
+homepage: https://mjwhitta.github.io/ruaur
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Can search and install packages for Arch Linux
+test_files: []