mspac 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f11225e1ee515b02e7fae345ed72edc3ab734635
+  data.tar.gz: 24864d1e8f46ea0092b60766740dbb7c88496d32
+SHA512:
+  metadata.gz: 37d5dbb4644156f768cae5c31accca659b3ef7710d168fe56f631e196e600b4d9785b3e00118d48f1a00c69248fdfb08033d0157729ab2a0dc6dfcc2d82b56dd
+  data.tar.gz: f3260122855734fb191536a3b1db047a33e50f61ca6f4234fe6771659131e38e3becf9d9d55b1359399a310c346a4ed6c3fde7e79a3bc4819f166845eedd489c

data/bin/mspac

@@ -0,0 +1,248 @@
+#!/usr/bin/env ruby
+
+require "mspac"
+require "optparse"
+require "string"
+
+class MsPacExit
+    GOOD = 0
+    INVALID_OPTION = 1
+    INVALID_ARGUMENT = 2
+    MISSING_ARGUMENT = 3
+    INVALID_OPERATION = 4
+    MULTIPLE_OPERATIONS = 5
+    EXCEPTION = 6
+end
+
+class Operation
+    LIST_CACHED = 1
+    LIST_INSTALLED = 2
+    LIST_PELLETS = 3
+    LOCK = 4
+    REMOVE = 5
+    SYNC = 6
+    UNLOCK = 7
+end
+
+def parse(args)
+    options = Hash.new
+    options["clean"] = false
+    options["force"] = false
+    options["nosave"] = false
+    options["operation"] = nil
+    options["refresh"] = false
+    options["upgrade"] = false
+
+    parser = OptionParser.new do |opts|
+        opts.banner =
+            "Usage: #{File.basename($0)} <operation> [OPTIONS] " \
+            "[pellets]"
+
+        opts.on("", "OPERATIONS")
+
+        opts.on("-h", "--help", "Display this help message") do
+            puts opts
+            exit
+        end
+
+        opts.on("--list-cached", "List cached pellets") do
+            options["operation"] = Operation::LIST_CACHED
+        end
+
+        opts.on("--list-installed", "List installed pellets") do
+            options["operation"] = Operation::LIST_INSTALLED
+        end
+
+        opts.on("--list-pellets", "List available pellets") do
+            options["operation"] = Operation::LIST_PELLETS
+        end
+
+        opts.on(
+            "-L",
+            "--lock",
+            "Lock a pellet at it's current version"
+        ) do
+            if (options["operation"])
+                puts opts
+                exit MsPacExit::MULTIPLE_OPERATIONS
+            end
+            options["operation"] = Operation::LOCK
+        end
+
+        opts.on("-R", "--remove", "Remove pellets") do
+            if (options["operation"])
+                puts opts
+                exit MsPacExit::MULTIPLE_OPERATIONS
+            end
+            options["operation"] = Operation::REMOVE
+        end
+
+        opts.on("-S", "--sync", "Synchronize pellets") do
+            if (options["operation"])
+                puts opts
+                exit MsPacExit::MULTIPLE_OPERATIONS
+            end
+            options["operation"] = Operation::SYNC
+        end
+
+        opts.on("-U", "--unlock", "Unlock a pellet") do
+            if (options["operation"])
+                puts opts
+                exit MsPacExit::MULTIPLE_OPERATIONS
+            end
+            options["operation"] = Operation::UNLOCK
+        end
+
+        opts.on("", "SYNC OPTIONS")
+
+        opts.on(
+            "-c",
+            "--clean",
+            "Remove pellets that are no longer installed",
+            "from the cache"
+        ) do
+            if (options["operation"] == Operation::SYNC)
+                options["clean"] = true
+            else
+                puts opts
+                exit MsPacExit::INVALID_OPERATION
+            end
+        end
+
+        opts.on(
+            "-f",
+            "--force",
+            "Force a reinstall/recompilation of the pellet"
+        ) do
+            if (options["operation"] == Operation::SYNC)
+                options["force"] = true
+            else
+                puts opts
+                exit MsPacExit::INVALID_OPERATION
+            end
+        end
+
+        opts.on(
+            "-s",
+            "--search=regex",
+            "Search each pellet for names matching the",
+            "provided regex and display them"
+        ) do |regex|
+            if (
+                (options["operation"] == Operation::SYNC) &&
+                !options["upgrade"]
+            )
+                options["regex"] = regex
+            else
+                puts opts
+                exit MsPacExit::INVALID_OPERATION
+            end
+        end
+
+        opts.on("-u", "--sysupgrade", "Upgrade all pellets") do
+            if (
+                (options["operation"] == Operation::SYNC) &&
+                !options.has_key?("regex")
+            )
+                options["upgrade"] = true
+            else
+                puts opts
+                exit MsPacExit::INVALID_OPERATION
+            end
+        end
+
+        opts.on("-y", "--refresh", "Refresh available pellets") do
+            if (options["operation"] == Operation::SYNC)
+                options["refresh"] = true
+            else
+                puts opts
+                exit MsPacExit::INVALID_OPERATION
+            end
+        end
+
+        opts.on("", "REMOVE OPTIONS")
+
+        opts.on(
+            "-n",
+            "--nosave",
+            "Completely remove pellet"
+        ) do
+            if (options["operation"] == Operation::REMOVE)
+                options["nosave"] = true
+            else
+                puts opts
+                exit MsPacExit::INVALID_OPERATION
+            end
+        end
+    end
+
+    begin
+        parser.parse!
+    rescue OptionParser::InvalidOption => e
+        puts e.message
+        puts parser
+        exit MsPacExit::INVALID_OPTION
+    rescue OptionParser::InvalidArgument => e
+        puts e.message
+        puts parser
+        exit MsPacExit::INVALID_ARGUMENT
+    rescue OptionParser::MissingArgument => e
+        puts e.message
+        puts parser
+        exit MsPacExit::MISSING_ARGUMENT
+    end
+
+    options["pellets"] = args
+
+    if (options.has_key?("regex") && !options["pellets"].empty?)
+        puts parser
+        exit MsPacExit::INVALID_OPERATION
+    end
+
+    return options
+end
+
+# Parse CLI args
+options = parse(ARGV)
+
+begin
+    mspac = MsPac.new
+
+    case options["operation"]
+    when Operation::LIST_CACHED
+        puts mspac.cached
+    when Operation::LIST_INSTALLED
+        puts mspac.installed
+    when Operation::LIST_PELLETS
+        puts mspac.pellets
+    when Operation::LOCK
+        mspac.lock(options["pellets"])
+    when Operation::REMOVE
+        mspac.remove(options["pellets"], options["nosave"])
+    when Operation::SYNC
+        mspac.clean if (options["clean"])
+        mspac.refresh if (options["refresh"])
+
+        if (options.has_key?("regex"))
+            mspac.search(options["regex"])
+        elsif (options["upgrade"])
+            mspac.upgrade
+        else
+            if (
+                !options["refresh"] ||
+                (options["pellets"] && !options["pellets"].empty?)
+            )
+                mspac.install(options["pellets"], options["force"])
+            end
+        end
+    when Operation::UNLOCK
+        mspac.unlock(options["pellets"])
+    end
+    exit MsPacExit::GOOD
+rescue MsPac::Error => e
+    puts e.message.red
+    exit MsPacExit::EXCEPTION
+rescue Interrupt => e
+    # ^C
+    puts
+end

data/lib/mspac.rb

@@ -0,0 +1,177 @@
+require "fileutils"
+require "json"
+require "pathname"
+require "scoobydoo"
+require "string"
+
+class MsPac
+    def cached
+        return @pellets.keys.sort.delete_if do |name|
+            !@pellets[name].cached?
+        end
+    end
+
+    def clean
+        @pellets.each do |name, pellet|
+            pellet.purge if (pellet.cached? && !pellet.installed?)
+        end
+        # FIXME will miss pellets that get deleted by refresh
+    end
+
+    def ensure_pellets_repo
+        @pellets_dir = Pathname.new("~/.mspac/pellets").expand_path
+        return if (@pellets_dir && @pellets_dir.exist?)
+
+        puts "Installing MsPac dependencies...".white
+        @pm.install(["git"]) if (ScoobyDoo.where_are_you("git").nil?)
+        Dir.chdir(@mspac_dir) do
+            @vcs.clone("https://gitlab.com/mjwhitta/pellets.git")
+        end
+
+        @pellets_dir = Pathname.new("~/.mspac/pellets").expand_path
+        if (@pellets_dir.nil? || !@pellets_dir.exist?)
+            raise Error::PelletRepoError.new
+        end
+    end
+    private :ensure_pellets_repo
+
+    def initialize
+        FileUtils.mkdir_p(Pathname.new("~/.mspac").expand_path)
+        @mspac_dir = Pathname.new("~/.mspac").expand_path
+        @pm = PackageManager.new
+        @vcs = VersionControl.new("git")
+        load_pellets
+    end
+
+    def install(pellets, force = false)
+        if (pellets.nil? || pellets.empty?)
+            raise Error::MissingPelletError.new
+        end
+
+        pellets.each do |name|
+            if (@pellets.has_key?(name))
+                pellet = @pellets[name]
+                if (pellet.installed?)
+                    pellet.update(force)
+                elsif (pellet.cached?)
+                    pellet.link
+                    pellet.update(true)
+                else
+                    pellet.fetch
+                    pellet.install
+                end
+            else
+                raise Error::MissingPelletError.new(name)
+            end
+        end
+    end
+
+    def installed
+        return @pellets.keys.sort.delete_if do |name|
+            !@pellets[name].installed?
+        end
+    end
+
+    def load_pellets
+        ensure_pellets_repo
+
+        @pellets = Hash.new
+        Dir["#{@pellets_dir}/*.pellet"].each do |pellet|
+            begin
+                p = Pellet.new(JSON.parse(File.read(pellet)))
+                @pellets[p.name] = p
+            rescue JSON::ParserError => e
+                puts "#{pellet} is not valid JSON!".red
+                puts e.message.red
+            rescue Exception => e
+                puts e.message.red
+            end
+        end
+    end
+    private :load_pellets
+
+    def lock(pellets)
+        if (pellets.nil? || pellets.empty?)
+            raise Error::MissingPelletError.new
+        end
+
+        pellets.each do |name|
+            if (@pellets.has_key?(name))
+                @pellets[name].lock
+            else
+                raise Error::MissingPelletError.new(name)
+            end
+        end
+    end
+
+    def pellets
+        return @pellets.keys.sort
+    end
+
+    def refresh
+        puts "Refreshing pellets...".white
+        Dir.chdir(@pellets_dir) do
+            @vcs.update
+        end
+    end
+
+    def remove(pellets, nosave)
+        if (pellets.nil? || pellets.empty?)
+            raise Error::MissingPelletError.new
+        end
+
+        pellets.each do |name|
+            if (@pellets.has_key?(name))
+                @pellets[name].remove(nosave)
+            else
+                raise Error::MissingPelletError.new(name)
+            end
+        end
+    end
+
+    def search(regex)
+        @pellets.keys.sort.each do |name|
+            pellet = @pellets[name]
+            name_match = pellet.name.match(/#{regex}/)
+            desc_match = pellet.desc.match(/#{regex}/)
+            if (name_match || desc_match)
+                print "#{pellet.name}".white
+                if (pellet.installed?)
+                    puts " [installed]".green
+                elsif (pellet.cached?)
+                    puts " [cached]".blue
+                else
+                    puts
+                end
+                puts "    #{pellet.repo}"
+                puts "    #{pellet.desc}"
+            end
+        end
+    end
+
+    def unlock(pellets)
+        if (pellets.nil? || pellets.empty?)
+            raise Error::MissingPelletError.new
+        end
+
+        pellets.each do |name|
+            if (@pellets.has_key?(name))
+                @pellets[name].unlock
+            else
+                raise Error::MissingPelletError.new(name)
+            end
+        end
+    end
+
+    def upgrade
+        @pellets.keys.sort.each do |name|
+            pellet = @pellets[name]
+            pellet.update if (pellet.installed?)
+        end
+    end
+end
+
+require "mspac/error"
+require "mspac/package_manager"
+require "mspac/pellet"
+require "mspac/version_control"

data/lib/mspac/error.rb

@@ -0,0 +1,10 @@
+class MsPac::Error < RuntimeError
+end
+
+require "mspac/error/invalid_operation_error"
+require "mspac/error/missing_pellet_error"
+require "mspac/error/multiple_operations_error"
+require "mspac/error/pellet_not_installed_error"
+require "mspac/error/pellet_repo_error"
+require "mspac/error/unsupported_package_manager_error"
+require "mspac/error/unsupported_vcs_error"

data/lib/mspac/error/invalid_operation_error.rb

@@ -0,0 +1,5 @@
+class MsPac::Error::InvalidOperationError < MsPac::Error
+    def initialize(op = "")
+        super("Unsupported operation: #{op}")
+    end
+end

data/lib/mspac/error/missing_pellet_error.rb

@@ -0,0 +1,9 @@
+class MsPac::Error::MissingPelletError < MsPac::Error
+    def initialize(pellet = nil)
+        if (pellet)
+            super("Pellet not found: #{pellet}")
+        else
+            super("No pellets specified")
+        end
+    end
+end

data/lib/mspac/error/multiple_operations_error.rb

@@ -0,0 +1,5 @@
+class MsPac::Error::MultipleOperationsError < MsPac::Error
+    def initialize
+        super("Too many operations were specified")
+    end
+end

data/lib/mspac/error/pellet_not_installed_error.rb

@@ -0,0 +1,5 @@
+class MsPac::Error::PelletNotInstalledError < MsPac::Error
+    def initialize(pellet = "unknown")
+        super("Pellet not installed: #{pellet}")
+    end
+end

data/lib/mspac/error/pellet_repo_error.rb

@@ -0,0 +1,5 @@
+class MsPac::Error::PelletRepoError < MsPac::Error
+    def initialize
+        super("Could not update pellet repo")
+    end
+end

data/lib/mspac/error/unsupported_package_manager_error.rb

@@ -0,0 +1,5 @@
+class MsPac::Error::UnsupportedPackageManagerError < MsPac::Error
+    def initialize(pkg_mgr = "unknown")
+        super("Unsupported package manager: #{pkg_mgr}")
+    end
+end

data/lib/mspac/error/unsupported_vcs_error.rb

@@ -0,0 +1,5 @@
+class MsPac::Error::UnsupportedVCSError < MsPac::Error
+    def initialize(vcs = "unknown")
+        super("Unsupported version control system: #{vcs}")
+    end
+end

data/lib/mspac/package_manager.rb

@@ -0,0 +1,57 @@
+require "scoobydoo"
+
+class MsPac::PackageManager
+    attr_reader :pkgmgr
+
+    def alt_install(packages, pkgmgr = @pkgmgr)
+        return if (packages.nil? || packages.empty?)
+        packages.each do |pkg|
+            pkgmgr_install(pkg, pkgmgr)
+        end
+    end
+
+    def initialize
+        if (ScoobyDoo.where_are_you("apt-get"))
+            @pkgmgr = "apt-get"
+        elsif (ScoobyDoo.where_are_you("brew"))
+            raise Error::UnsupportedPackageManagerError.new("brew")
+        elsif (ScoobyDoo.where_are_you("pacman"))
+            @pkgmgr = "pacman"
+        elsif (ScoobyDoo.where_are_you("yum"))
+            raise Error::UnsupportedPackageManagerError.new("yum")
+        elsif (ScoobyDoo.where_are_you("zipper"))
+            raise Error::UnsupportedPackageManagerError.new("zipper")
+        else
+            raise Error::UnsupportedPackageManagerError.new
+        end
+    end
+
+    def install(packages, pkgmgr = @pkgmgr)
+        return if (packages.nil? || packages.empty?)
+        pkgmgr_install(packages.join(" "), pkgmgr)
+    end
+
+    def pkgmgr_install(pkgs, pkgmgr = @pkgmgr)
+        case pkgmgr
+        when "apt-get"
+            system("sudo apt-get install -y #{pkgs}")
+        when "brew"
+            raise Error::UnsupportedPackageManagerError.new("brew")
+        when "pacman"
+            system("sudo pacman --needed --noconfirm -S #{pkgs}")
+        when "perl"
+            system("sudo cpan #{pkgs}")
+        when "python2"
+            system("python2 -m pip install #{pkgs}")
+        when "python3"
+            system("python3 -m pip install #{pkgs}")
+        when "yum"
+            raise Error::UnsupportedPackageManagerError.new("yum")
+        when "zipper"
+            raise Error::UnsupportedPackageManagerError.new("zipper")
+        else
+            raise Error::UnsupportedPackageManagerError.new
+        end
+    end
+    private :pkgmgr_install
+end

data/lib/mspac/pellet.rb

@@ -0,0 +1,170 @@
+require "fileutils"
+require "string"
+
+class MsPac::Pellet < Hash
+    @@cache_dir = Pathname("~/.mspac/cache").expand_path
+    @@install_dir = Pathname("~/.mspac/installed").expand_path
+
+    def initialize(json)
+        json.keys.each do |key|
+            self[key] = json[key]
+        end
+
+        @pm = MsPac::PackageManager.new
+        @vcs = MsPac::VersionControl.new(self["vcs"])
+    end
+
+    def cached?
+        Pathname.new("#{@@cache_dir}/#{name}").expand_path.exist?
+    end
+
+    def compile
+        return if (self["compile"].empty?)
+        puts "Compiling #{name}...".white
+        execute("compile")
+    end
+    private :compile
+
+    def desc
+        return self["desc"]
+    end
+
+    def execute(operation)
+        Dir.chdir("#{@@install_dir}/#{name}") do
+            system(self[operation].join("; "))
+        end if (!self[operation].empty?)
+    end
+    private :execute
+
+    def fetch
+        FileUtils.mkdir_p(@@cache_dir)
+        FileUtils.mkdir_p(@@install_dir)
+
+        get_deps
+
+        puts "Fetching #{name}...".white
+        if (Pathname.new("#{@@cache_dir}/#{name}").expand_path.exist?)
+            Dir.chdir("#{@@cache_dir}/#{name}") do
+                @vcs.update
+            end
+        else
+            Dir.chdir(@@cache_dir) do
+                @vcs.clone(self["repo"])
+            end
+        end
+    end
+
+    def get_deps
+        puts "Installing dependencies...".white
+        @pm.install([self["vcs"]].concat(self["deps"][@pm.pkgmgr]))
+        @pm.install(self["deps"]["perl"], "perl")
+        @pm.install(self["deps"]["python2"], "python2")
+        @pm.install(self["deps"]["python3"], "python3")
+    end
+    private :get_deps
+
+    def install
+        if (!cached?)
+            raise MsPac::Error::PelletNotInstalledError.new(name)
+        end
+
+        link if (!installed?)
+        compile
+
+        puts "Installing #{name}...".white
+        execute("install")
+    end
+
+    def installed?
+        Pathname.new("#{@@install_dir}/#{name}").expand_path.exist?
+    end
+
+    def link
+        if (!cached?)
+            raise MsPac::Error::PelletNotInstalledError.new(name)
+        end
+
+        puts "Linking #{name}...".white
+        FileUtils.ln_sf(
+            "#{@@cache_dir}/#{name}",
+            "#{@@install_dir}/#{name}"
+        )
+    end
+
+    def lock
+        if (!installed?)
+            raise MsPac::Error::PelletNotInstalledError.new(name)
+        end
+
+        puts "Locking #{name}...".white
+        FileUtils.touch("#{@@install_dir}/#{name}/.mspac_lock")
+    end
+
+    def name
+        return self["name"]
+    end
+
+    def purge
+        if (!cached?)
+            raise MsPac::Error::PelletNotInstalledError.new(name)
+        end
+
+        puts "Purging #{name}...".white
+        FileUtils.rm_rf("#{@@cache_dir}/#{name}")
+    end
+
+    def remove(nosave = false)
+        if (!installed?)
+            raise MsPac::Error::PelletNotInstalledError.new(name)
+        end
+
+        puts "Removing #{name}...".white
+        execute("remove")
+        unlink
+        purge if (nosave)
+    end
+
+    def repo
+        return self["repo"]
+    end
+
+    def unlink
+        if (!installed?)
+            raise MsPac::Error::PelletNotInstalledError.new(name)
+        end
+
+        puts "Unlinking #{name}...".white
+        FileUtils.rm_f("#{@@install_dir}/#{name}")
+    end
+
+    def unlock
+        if (!installed?)
+            raise MsPac::Error::PelletNotInstalledError.new(name)
+        end
+
+        puts "Unlocking #{name}...".white
+        FileUtils.rm_f("#{@@install_dir}/#{name}/.mspac_lock")
+    end
+
+    def update(force = false)
+        if (!installed?)
+            raise MsPac::Error::PelletNotInstalledError.new(name)
+        end
+
+        Dir.chdir("#{@@install_dir}/#{name}") do
+            if (Pathname.new(".mspac_lock").expand_path.exist?)
+                puts "Locked: #{name}".red
+                return
+            end
+
+            puts "Updating #{name}...".white
+            tip = @vcs.revision
+            @vcs.update
+            new_tip = @vcs.revision
+
+            if ((tip != new_tip) || force)
+                install
+            end
+        end
+    end
+end

data/lib/mspac/version_control.rb

@@ -0,0 +1,49 @@
+class MsPac::VersionControl
+    def clone(repo)
+        return if (repo.nil? || repo.empty?)
+
+        case @vcs
+        when "git", "hg"
+            system("#{@vcs} clone #{repo}")
+        else
+            raise Error::UnsupportedVCSError.new(@vcs)
+        end
+    end
+
+    def initialize(vcs)
+        case vcs
+        when "bzr"
+            raise Error::UnsupportedVCSError.new(vcs)
+        when "git"
+            @vcs = vcs
+        when "hg"
+            @vcs = vcs
+        when "svn"
+            raise Error::UnsupportedVCSError.new(vcs)
+        else
+            raise Error::UnsupportedVCSError.new
+        end
+    end
+
+    def revision
+        case @vcs
+        when "git"
+            %x(git log --oneline | head -n 1 | awk '{print $1}')
+        when "hg"
+            %(hg tip --template "{node}")
+        else
+            raise Error::UnsupportedVCSError.new(@vcs)
+        end
+    end
+
+    def update
+        case @vcs
+        when "git"
+            system("git reset && git pull")
+        when "hg"
+            system("hg pull && hg update")
+        else
+            raise Error::UnsupportedVCSError.new(@vcs)
+        end
+    end
+end

data/lib/string.rb

@@ -0,0 +1,32 @@
+# Redefine String class to allow for colorizing, rsplit, and word wrap
+class String
+    def blue
+        return colorize(36)
+    end
+
+    def colorize(color)
+        return "\e[#{color}m#{self}\e[0m"
+    end
+
+    def green
+        return colorize(32)
+    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
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: mspac
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Miles Whittaker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-07 00:00:00.000000000 Z
+dependencies:
+- !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
+description: MsPac is a package manager written in ruby which tries to mirror Arch's
+  pacman. It's meant for installing opensource tools from source. It only supports
+  git or hg repos at this time. I hope to add bzr and svn later. It only supports
+  apt-get and pacman for installing dependencies at this time. I hope to add support
+  for brew, yum, and zipper later.
+email: mjwhitta@gmail.com
+executables:
+- mspac
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/mspac
+- lib/mspac.rb
+- lib/mspac/error.rb
+- lib/mspac/error/invalid_operation_error.rb
+- lib/mspac/error/missing_pellet_error.rb
+- lib/mspac/error/multiple_operations_error.rb
+- lib/mspac/error/pellet_not_installed_error.rb
+- lib/mspac/error/pellet_repo_error.rb
+- lib/mspac/error/unsupported_package_manager_error.rb
+- lib/mspac/error/unsupported_vcs_error.rb
+- lib/mspac/package_manager.rb
+- lib/mspac/pellet.rb
+- lib/mspac/version_control.rb
+- lib/string.rb
+homepage: http://mjwhitta.github.io/mspac
+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: Simple package manager for installing from source
+test_files: []