niman 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 682d81bb6d3d26767ef1640ce8bc1b527e33ad4b
-  data.tar.gz: efb8f24f8f09a7be9d098eec9bc3d37818e78ebd
+  metadata.gz: f4b4fbde2c69d5428cdeef5956a0781eded47766
+  data.tar.gz: cc99ba94749c533e2d0a953695a4b03ec0aec32e
 SHA512:
-  metadata.gz: 6429cc5c5299a9af8fe2ce1ad3198481037835edea8493882a366b87028dd11c6adeaeb5d8b8a9054c861f49ba9988f140bca2ddddcc8c0cbae439f7666f0f1d
-  data.tar.gz: 67d965a729bb8f1a84a78943f347394866af3aa9fb2383542e33229813890bc242f7929125c521ff4a91cc6d3b4e289e9847d96cd81a2bf501b6656513d02353
+  metadata.gz: 25581ac834d6daa7134e5ecf6708a22bd5e7e7bc74568325fd3389bafa7f2e9b7d3079115beed68848f69222933c7da194c70903360a24fae1909595e872c0ea
+  data.tar.gz: a98b0c0aa0417876e61c269aa8c203181ea74ae28194a397f6c79593c0d3ff39bf27af2152d170baf9be62378695e01c394ca538fa92211824abd276da2bc7fc

data/.gitignore

@@ -12,3 +12,5 @@
 *.o
 *.a
 mkmf.log
+*.gem
+.vagrant/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format doc
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+rvm:
+- "1.9.3"
+- "2.0.0"
+- "2.1.5"
+- "2.2.0"
+- jruby-19mode # JRuby in 1.9 mode
+- rbx
+env:
+- RUN=rspec

data/Gemfile

@@ -2,3 +2,11 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in niman.gemspec
 gemspec
+
+group :development do
+  gem "vagrant", git: "https://github.com/mitchellh/vagrant.git"
+end
+
+group :plugins do
+  gem "niman", path: "."
+end

data/README.md

@@ -1,6 +1,6 @@
 # Niman
 
-TODO: Write a gem description
+Niman is a proof-of-concept provisioner.
 
 ## Installation
 
@@ -20,7 +20,61 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+It starts with a `Nimanfile`:
+
+```ruby
+Niman::Recipe.configure do |config|
+  config.file do |file|
+    file.path = '/home/bob/hello.txt'
+    file.content = 'hello from alice'
+    file.mode = '0600'
+  end
+end
+```
+This places a new file `hello.txt` in `/home/bob` with rights 0600.
+
+A `Nimanfile` contains all necessary commands for `niman` to run.
+
+### Packages
+
+Use a concrete package in your script:
+
+```ruby
+Niman::Recipe.configure do |config|
+  config.package do |package|
+    package.name = "vim"
+    package.version = "7.4"
+  end
+end
+```
+
+Custom packages live in `packages/`. Every package gets its own file.
+Package description:
+```ruby
+#packages/ruby.rb
+require 'niman'
+class RubyPackage < Niman::Package
+  package :ubuntu, "ruby1.9.1"
+  package :centos, "ruby1.9.1"
+end
+```
+In your `Nimanfile`:
+```ruby
+Niman::Recipe.configure do |config|
+  config.package do |package|
+    package.name "ruby"
+    package.path = "packages/ruby"
+  end
+end
+```
+
+### Apply `Nimanfile`
+
+To apply a `Nimanfile` run:
+
+```bash
+$ niman apply
+```
 
 ## Contributing
 

data/bin/niman

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'niman'
+
+Niman::CLI::Application.start(ARGV)

data/lib/niman/cli/application.rb

@@ -0,0 +1,48 @@
+require 'thor'
+require 'niman/recipe'
+require 'niman/provisioner'
+require "niman/shell"
+require "niman/installer"
+
+module Niman
+  module CLI
+    class Application < Thor
+      attr_accessor :client_shell, :silent
+
+      def initialize(*args)
+        super
+        @client_shell= Niman::Shell.new
+        @silent = false
+      end
+
+      desc "apply", "Applies a Nimanfile"
+      def apply
+        Niman::Recipe.from_file
+        config = Niman::Recipe.configuration
+        installer = Niman::Installer.new(shell: client_shell, managers:{
+          debian: 'apt-get -y',
+          redhat: 'yum -y'
+        })
+        provisioner = Niman::Provisioner.new(installer, config.instructions)
+        this = self
+        provisioner.run do |instruction|
+          this.say "Executing task #{instruction.description}" unless @quiet
+        end
+      rescue LoadError => e
+        error e.message
+      end
+
+      desc "setup", "Generates an empty Nimanfile"
+      def setup
+        content = <<-EOS
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+Niman::Recipe.configure do |config|
+end
+        EOS
+        File.open(Niman::Recipe::DEFAULT_FILENAME, "w") { |handle| handle.write(content) }
+        say "Created new file #{Niman::Recipe::DEFAULT_FILENAME}"
+      end
+    end
+  end
+end

data/lib/niman/exceptions.rb

@@ -0,0 +1,10 @@
+module Niman
+  class ConfigError < StandardError
+  end
+
+  class InstallError < StandardError
+  end
+
+  class UnsupportedOSError < StandardError
+  end
+end

data/lib/niman/installer.rb

@@ -0,0 +1,18 @@
+require 'virtus'
+require 'niman/exceptions'
+
+module Niman
+  class Installer
+    include Virtus.model
+
+    attribute :managers, Hash[Symbol=>String], default: Hash.new
+    attribute :shell, Object
+
+    def install(packages)
+      package_manager = managers.fetch(shell.os.to_sym) { raise Niman::InstallError, shell.os }
+      Array(packages).each do |package|
+        shell.exec("#{package_manager} install #{package.name}", true)
+      end
+    end
+  end
+end

data/lib/niman/library/file.rb

@@ -0,0 +1,24 @@
+require 'virtus'
+
+module Niman
+  module Library
+    class File
+      include Virtus.model
+
+      attribute :path, String, default: ''
+      attribute :content, String, default: ''
+
+      def valid?
+        !self.path.nil? && !self.path.empty?
+      end
+
+      def run
+        ::File.open(::File.expand_path(path), "w") { |handle| handle.write(content) }
+      end
+
+      def description
+        "File #{path}"
+      end
+    end
+  end
+end

data/lib/niman/library/package.rb

@@ -0,0 +1,18 @@
+module Niman
+  module Library
+    class Package
+      include Virtus.model
+
+      attribute :name, String, default: ""
+      attribute :version, String, default: ""
+
+      def description
+        name
+      end
+
+      def valid?
+        !name.empty?
+      end
+    end
+  end
+end

data/lib/niman/nimanfile.rb

@@ -0,0 +1,23 @@
+require 'niman/library/file'
+
+module Niman
+  class Nimanfile
+    attr_reader :instructions
+
+    def initialize
+      @instructions = []
+    end
+
+    def file
+      f = Niman::Library::File.new
+      yield(f)
+      @instructions.push(f)
+    end
+
+    def package
+      package = Niman::Library::Package.new
+      yield(package)
+      @instructions.push(package)
+    end
+  end
+end

data/lib/niman/platform.rb

@@ -0,0 +1,43 @@
+module Niman
+  class Platform
+    def initialize(platform)
+      @platform = platform
+    end
+
+    def windows?
+      (/cygwin|mswin|mingw|bccwin|wince|emx/ =~ @platform) != nil
+    end
+
+    def mac?
+      (/darwin/ =~ @platform) != nil
+    end
+
+    def unix?
+      !windows?
+    end
+
+    def linux?
+      unix? && !mac?
+    end
+
+    def linux_variant(exists_block, read_block)
+      variant = { :distro => nil, :family => nil }
+
+      if exists_block.('/etc/lsb-release')
+        lsb_release = read_block.('/etc/lsb-release') 
+        variant = { :distro => $1 } if lsb_release =~ /^DISTRIB_ID=(.*)/
+      end
+
+      if exists_block.('/etc/debian_version')
+        variant[:distro] = :debian if variant[:distro].nil?
+        variant[:family] = :debian if variant[:variant].nil?
+      elsif exists_block.('/etc/redhat-release') or exists_block.('/etc/centos-release')
+        variant[:family] = :redhat if variant[:family].nil?
+        variant[:distro] = :centos if exists_block.('/etc/centos-release')
+      elsif exists_block.('/etc/SuSE-release')
+        variant[:distro] = :sles if variant[:distro].nil?
+      end
+      variant
+    end
+  end
+end

data/lib/niman/provisioner.rb

@@ -0,0 +1,28 @@
+require 'niman/exceptions'
+
+module Niman
+  class Provisioner
+    attr_reader :instructions
+
+    def initialize(installer, instructions)
+      @installer    = installer
+      @instructions = Array(instructions)
+    end
+
+    def valid?
+      @instructions.all?(&:valid?)
+    end
+
+    def run
+      raise Niman::ConfigError unless self.valid?
+      @instructions.each do |instruction|
+        yield(instruction) if block_given?
+        if instruction.respond_to?(:run)
+          instruction.run
+        else
+          @installer.install(instruction)
+        end
+      end
+    end
+  end
+end

data/lib/niman/recipe.rb

@@ -0,0 +1,28 @@
+require 'niman/nimanfile'
+
+module Niman
+  class Recipe
+    DEFAULT_FILENAME = 'Nimanfile'
+    class << self
+      attr_writer :configuration
+    end
+
+    def self.configure
+      @configuration ||= Niman::Nimanfile.new
+      yield(@configuration)
+    end
+
+    def self.configuration
+      @configuration
+    end
+
+    def self.reset!
+      @configuration = Niman::Nimanfile.new
+    end
+
+    def self.from_file
+      path = File.join(Dir.pwd, DEFAULT_FILENAME)
+      load DEFAULT_FILENAME
+    end
+  end
+end

data/lib/niman/shell.rb

@@ -0,0 +1,27 @@
+require 'niman/platform'
+
+module Niman
+  class Shell
+    def initialize
+      @platform = Niman::Platform.new(RUBY_PLATFORM)
+    end
+
+    def os
+      if @platform.linux?
+        variant = @platform.linux_variant(-> (fn){ File.exists?(fn)}, 
+                                -> (fn){ File.read(fn)})
+        variant[:family]
+      else
+        raise Niman::UnsupportedOSError
+      end
+    end
+
+    def exec(command, use_sudo=false)
+      if use_sudo
+        `sudo #{command}`
+      else
+        `#{command}`
+      end
+    end
+  end
+end

data/lib/niman/vagrant/plugin.rb

@@ -0,0 +1,10 @@
+module VagrantPlugins
+  class Plugin < Vagrant.plugin("2")
+    name "niman"
+
+    provisioner "niman" do
+      require_relative 'provisioner'
+      Provisioner
+    end
+  end
+end

data/lib/niman/vagrant/provisioner.rb

@@ -0,0 +1,24 @@
+require "vagrant/util/retryable"
+require 'niman/vagrant/shell'
+
+module VagrantPlugins
+  class Provisioner < Vagrant.plugin("2", :provisioner)
+    include Vagrant::Util::Retryable
+    def configure(root_config)
+    end
+
+    def provision
+      require 'niman'
+      @machine.communicate.tap do |comm|
+        vagrant_shell = VagrantPlugins::RemoteShell.new(comm, @machine)
+        app = Niman::CLI::Application.new
+        app.client_shell  = vagrant_shell
+        app.silent = true
+        app.apply
+      end
+    end
+
+    def cleanup
+    end
+  end
+end

data/lib/niman/vagrant/shell.rb

@@ -0,0 +1,46 @@
+module VagrantPlugins
+  class RemoteShell
+    def initialize(communication, machine)
+      @channel = communication
+      @machine = machine
+      @platform = Niman::Platform.new(ruby_platform)
+    end
+
+    def os
+      if @platform.linux?
+        variant = @platform.linux_variant(-> (fn){ @machine.communicate.test("cat #{fn}")}, 
+                                -> (fn){ @channel.execute("cat #{fn}") do |type, data|
+                                           data.chomp
+                                         end})
+        variant[:family]
+      else
+        raise Niman::UnsupportedOSError
+      end
+    end
+
+    def exec(command, use_sudo=false)
+      @machine.ui.info(command, {color: :green})
+      opts = { error_check: false, elevated: true }
+      @channel.sudo(command, opts) do |type, data|
+        if [:stderr, :stdout].include?(type)
+          #Output the data with the proper color based on the stream.
+          color = type == :stdout ? :green : :red
+          # Clear out the newline since we add one
+          data = data.chomp
+          next if data.empty?
+          options = {}
+          options[:color] = :green
+          @machine.ui.info(data.chomp, options)
+        end
+      end
+    end
+
+    private
+
+    def ruby_platform
+      @channel.execute("ruby -e 'puts RUBY_PLATFORM'") do |type, data|
+        return data.chomp
+      end
+    end
+  end
+end

data/lib/niman/version.rb

@@ -1,3 +1,3 @@
 module Niman
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/niman.rb

@@ -1,5 +1,9 @@
 require "niman/version"
+require "niman/cli/application"
+require "niman/library/package"
 
 module Niman
-  # Your code goes here...
+  if defined?(::Vagrant)
+    require 'niman/vagrant/plugin'
+  end
 end

data/niman.gemspec

@@ -17,6 +17,10 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency 'thor', '~> 0.19'
+  spec.add_dependency "virtus", "~> 1.0.4"
+  spec.add_development_dependency "fakefs", "~> 0.5"
+  spec.add_development_dependency "rspec", "3.1"
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 end

data/spec/lib/installer_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'niman/installer'
+
+describe Niman::Installer do
+  describe '#initialize' do
+    it 'accepts a hash of package managers' do
+      managers = {
+        ubuntu: 'apt-get',
+        centos: 'yum'
+      }
+      installer = Niman::Installer.new(managers: managers)
+      expect(installer.managers).to eq managers
+    end
+
+    it 'accepts a shell' do
+      shell = double()
+      installer = Niman::Installer.new(shell: shell)
+      expect(installer.shell).to eq shell
+    end
+  end
+
+  describe "#managers" do
+    it 'defaults to empty hash' do
+      installer = Niman::Installer.new
+      expect(installer.managers).to eq Hash.new
+    end
+  end
+
+  describe "#install" do
+    let(:shell) { double() }
+    subject(:installer) { Niman::Installer.new(managers: {
+        debian: 'apt-get',
+        redhat: 'yum'
+    }, shell: shell)}
+    let(:vim_package) { Niman::Library::Package.new(name: 'vim') }
+    let(:ssh_package) { Niman::Library::Package.new(name: 'ssh') }
+    let(:packages) { [vim_package, ssh_package] }
+
+    context 'with valid operating system' do
+      before do
+        allow(shell).to receive(:os).and_return(:debian)
+        allow(shell).to receive(:exec)
+        installer.install(packages)
+      end
+
+      ['vim', 'ssh'].each do |package|
+        it "calls shell for #{package}" do
+          expect(shell).to have_received(:exec).with("apt-get install #{package}", true)
+        end
+      end
+    end
+
+    it 'raises for unknown operating system' do
+      allow(shell).to receive(:os).and_return(:freebsd)
+      expect { installer.install(packages) }.to raise_error(Niman::InstallError)
+    end
+  end
+end

data/spec/lib/library/file_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'niman/library/file'
+require 'fakefs'
+
+describe Niman::Library::File do
+  subject(:file) { Niman::Library::File.new }
+  [:path, :content].each do |attribute|
+    it "responds to #{attribute}" do
+      expect(file.respond_to?(attribute)).to be true
+    end
+  end
+
+  describe '#initialize' do
+    it 'accepts path' do
+      f = Niman::Library::File.new(path: '/foo/bar')
+      expect(f.path).to eq '/foo/bar'
+    end
+
+    it 'accepts content' do
+      f = Niman::Library::File.new(content: 'Alice likes Bob')
+      expect(f.content).to eq 'Alice likes Bob'
+    end
+  end
+
+  describe '#content' do
+    it 'defaults to empty string' do
+      expect(file.content).to eq ''
+    end
+  end
+
+  describe '#path' do
+    it 'defaults to empty string' do
+      expect(file.path).to eq ''
+    end
+  end
+
+  describe "#valid?" do
+    specify 'if it has path' do
+      file.path = '/foo/bar'
+      expect(file.valid?).to be true
+    end
+
+    it 'is not valid when path is empty' do
+      expect(file.valid?).to be false
+    end
+
+    it 'is not valid when path is nil' do
+      file.path = nil 
+      expect(file.valid?).to be false
+    end
+  end
+
+  describe "#run" do
+    let(:path) { 'hello.txt' }
+    let(:content) { 'FooBar' }
+    subject(:file) { Niman::Library::File.new(path: path, content: content) }
+    before do
+      file.run
+    end
+
+    it 'creates a file at path' do
+      expect(File.exists?(path)).to be true
+    end
+
+    it 'file has expected content' do
+      expect(File.read(path)).to eq content
+    end
+  end
+
+  describe "#description" do
+    let(:path) { 'hello.txt' }
+    subject(:file) { Niman::Library::File.new(path: path) }
+    it 'contains path' do
+      expect(file.description).to eq "File #{path}"
+    end
+  end
+end

data/spec/lib/library/package_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'niman/library/package'
+
+describe Niman::Library::Package do
+  subject(:package) { Niman::Library::Package.new }
+  [:name, :version, :description].each do |attribute|
+    it "responds to #{attribute}" do
+      expect(package.respond_to?(attribute)).to be true
+    end
+  end
+
+  describe "#name" do
+    it "defaults to empty string" do
+      expect(package.name).to eq ""
+    end
+  end
+
+  describe "#version" do
+    it "defaults to empty string" do
+      expect(package.version).to eq ""
+    end
+  end
+
+  describe '#valid?' do
+    it 'is true when name is present' do
+      package = Niman::Library::Package.new(name: 'vim')
+      expect(package.valid?).to be true
+    end
+
+    it 'is false when name is not present' do
+      package = Niman::Library::Package.new
+      expect(package.valid?).to be false
+    end
+  end
+end

data/spec/lib/nimanfile_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'niman/nimanfile'
+require 'niman/library/file'
+
+describe Niman::Nimanfile do
+  subject(:niman_file) { Niman::Nimanfile.new }
+
+  it 'has no instructions' do
+    expect(niman_file.instructions.length).to eq 0
+  end
+
+  [:file, :package].each do |attribute|
+    it "has #{attribute} method" do
+      expect(niman_file.respond_to?(attribute)).to be true
+    end
+  end
+
+  specify 'file calls block with config object' do
+    expect { |b| niman_file.file(&b) }.to yield_with_args(Niman::Library::File)
+  end
+
+  specify 'package calls block with config object' do
+    expect { |b| niman_file.package(&b) }.to yield_with_args(Niman::Library::Package)
+  end
+
+  describe '#instructions' do
+    before do
+      niman_file.file {}
+    end
+
+    specify 'increases when #file is being called' do
+      expect(niman_file.instructions.length).to eq 1
+    end
+
+    specify 'contains file object' do
+      expect(niman_file.instructions.first).to be_kind_of(Niman::Library::File)
+    end
+  end
+
+end

data/spec/lib/provisioner_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'niman/provisioner'
+require 'niman/installer'
+require 'niman/exceptions'
+
+describe Niman::Provisioner do
+  let(:file)         { Niman::Library::File.new(path: '~/hello.txt', content: 'ohai') }
+  let(:vim_package)  { Niman::Library::Package.new(name: 'vim') }
+  let(:instructions) { [file, vim_package] }
+  let(:installer)    { double(Niman::Installer) }
+  subject(:provisioner) { Niman::Provisioner.new(installer, instructions) }
+
+  describe "#initialize" do
+    it 'accepts a list of instructions' do
+      expect(provisioner.instructions).to eq [file, vim_package]
+    end
+
+    it 'accepts a single instruction' do
+      provisioner = Niman::Provisioner.new(installer, file)
+      expect(provisioner.instructions).to eq [file]
+    end
+  end
+
+  describe "#valid?" do
+    context 'with valid instructions' do
+      it 'returns true' do
+        expect(provisioner.valid?).to be true
+      end
+    end
+
+    context 'with invalid instructions' do
+      let(:invalid_file) { Niman::Library::File.new() }
+      let(:instructions) { [file, invalid_file] }
+      it 'returns false' do
+        expect(provisioner.valid?).to be false
+      end
+    end
+  end
+
+  describe "#run" do
+    context 'with invalid instructions' do
+      it 'raises when instruction is invalid' do
+        allow(provisioner).to receive(:valid?).and_return(false)
+        expect { provisioner.run }.to raise_error(Niman::ConfigError)
+      end
+    end
+
+    context 'with valid instructions' do
+      before do
+        allow(file).to receive(:run)
+        allow(installer).to receive(:install)
+        provisioner.run
+      end
+
+      it 'calls run for runable instructions' do
+        expect(file).to have_received(:run)
+      end
+
+      it 'calls installer for package' do
+        expect(installer).to have_received(:install).with(vim_package)
+      end
+
+      it 'calls block for every instruction' do
+        expect { |b| provisioner.run(&b) }.to yield_successive_args(file, vim_package)
+      end
+    end
+  end
+end

data/spec/lib/recipe_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'niman/recipe'
+
+describe Niman::Recipe do
+  describe '.configure' do
+    before do
+      Niman::Recipe.configure do |config|
+        config.file do |file|
+          file.path = '/home/bob/hello.txt'
+          file.content = 'hello from alice'
+        end
+      end
+    end
+
+    specify 'configuration has a file call' do
+      expect(Niman::Recipe.configuration.instructions.length).to eq 1
+    end
+  end
+
+  describe '.reset' do
+    before do
+      Niman::Recipe.configure do |config|
+        config.file do |file|
+          file.path = '/home/bob/hello.txt'
+          file.content = 'hello from alice'
+        end
+      end
+      Niman::Recipe.reset!
+    end
+
+    it 'erases current configuration' do
+      expect(Niman::Recipe.configuration.instructions.length).to eq 0
+    end
+  end
+
+  describe '.from_file' do
+    before do
+      FakeFS.deactivate!
+      content = <<-EOS
+      Niman::Recipe.configure do |config|
+        config.file do |file|
+          file.path = '/home/bob/hello.txt'
+          file.content = 'hello from alice'
+        end
+      end
+      EOS
+      File.open(Niman::Recipe::DEFAULT_FILENAME, "w") {|handle| handle.write(content) }
+    end
+    after do
+      File.delete(Niman::Recipe::DEFAULT_FILENAME)
+      FakeFS.activate!
+    end
+
+    it 'loads "Nimanfile" by default' do
+      Niman::Recipe.from_file
+      expect(Niman::Recipe.configuration.instructions.length).to eq 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,89 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -1,15 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: niman
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Jan Schulte
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2015-02-08 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.4
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -41,18 +97,42 @@ dependencies:
 description: 
 email:
 - hello@unexpected-co.de
-executables: []
+executables:
+- niman
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/niman
 - lib/niman.rb
+- lib/niman/cli/application.rb
+- lib/niman/exceptions.rb
+- lib/niman/installer.rb
+- lib/niman/library/file.rb
+- lib/niman/library/package.rb
+- lib/niman/nimanfile.rb
+- lib/niman/platform.rb
+- lib/niman/provisioner.rb
+- lib/niman/recipe.rb
+- lib/niman/shell.rb
+- lib/niman/vagrant/plugin.rb
+- lib/niman/vagrant/provisioner.rb
+- lib/niman/vagrant/shell.rb
 - lib/niman/version.rb
 - niman.gemspec
+- spec/lib/installer_spec.rb
+- spec/lib/library/file_spec.rb
+- spec/lib/library/package_spec.rb
+- spec/lib/nimanfile_spec.rb
+- spec/lib/provisioner_spec.rb
+- spec/lib/recipe_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses:
 - MIT
@@ -77,4 +157,11 @@ rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: Provisions your machine
-test_files: []
+test_files:
+- spec/lib/installer_spec.rb
+- spec/lib/library/file_spec.rb
+- spec/lib/library/package_spec.rb
+- spec/lib/nimanfile_spec.rb
+- spec/lib/provisioner_spec.rb
+- spec/lib/recipe_spec.rb
+- spec/spec_helper.rb