boxen 2.9.0 → 3.0.0.beta1

data/lib/boxen/preflight/os.rb

@@ -1,7 +1,7 @@
 require "boxen/preflight"
 
 class Boxen::Preflight::OS < Boxen::Preflight
-  SUPPORTED_RELEASES = %w(10.8 10.9 10.10 10.11 10.12)
+  SUPPORTED_RELEASES = %w(10.8 10.9)
 
   def ok?
     osx? && supported_release?

data/lib/boxen/preflight/update.rb

@@ -0,0 +1,109 @@
+require "boxen/preflight"
+
+class Boxen::Preflight::Update < Boxen::Preflight
+  def ok?
+    if config.offline?
+      warn "Skipping update because we're offline."
+
+    elsif no_pull?
+      debug "Skipping update because we were asked to by the --no-pull flag"
+
+    elsif !on_branch?
+      warn "Boxen not on a branch (ref: #{ref}), cannot update!"
+
+    elsif !on_master_branch?
+      local_branch = current_branch.rpartition("/").last
+      warn "Boxen on a non-master branch '#{local_branch}', cannot update!"
+
+    elsif !fast_forwardable?
+      warn "Boxen has unpushed changes, cannot update!"
+
+    elsif !clean_tree?
+      warn "Boxen repo has untracked or uncommitted changes, cannot update!"
+
+    else
+      update!
+    end
+
+    true
+  end
+
+  def run
+    abort "Auto-update of Boxen FAILED, please fix manually."
+  end
+
+  private
+
+  def ref
+    %x(git log -1 --pretty=format:%h)
+  end
+
+  def fetch
+    "git fetch --quiet origin"
+  end
+
+  def reset_hard
+    "git reset --hard origin/master 2>&1 >/dev/null"
+  end
+
+  def clean
+    "git clean -qdf"
+  end
+
+  def update_boxen_checkout
+    %x(#{reset} && #{clean})
+    $? == 0
+  end
+
+  def on_branch?
+    !current_branch.empty?
+  end
+
+  def on_master_branch?
+    current_branch == "refs/heads/master"
+  end
+
+  def clean_tree?
+    %x(git status --porcelain).chomp.empty?
+  end
+
+  def upstream_changes?
+    %x(git rev-list --count HEAD..origin/master).chomp != "0"
+  end
+
+  def no_pull?
+    ARGV.any? { |arg| arg == "--no-pull" }
+  end
+
+  def fast_forwardable?
+    %x(git rev-list --count origin/master..master).chomp == "0"
+  end
+
+  def current_branch
+    @current_branch ||= %x(git symbolic-ref HEAD).chomp
+  end
+
+  def update!
+    info "Updating boxen..."
+    fetch
+
+    if !upstream_changes?
+      info "Boxen is up-to-date with origin/master"
+
+    elsif update_boxen_checkout
+      info "Successfully updated to #{ref}"
+      rerun_boxen
+
+    else
+      warn "Failed to auto-update!"
+      false
+    end
+  end
+
+  def rerun_boxen
+    command = "#{$0} #{ARGV.join ' '} --no-pull"
+    debug "Re-running boxen:"
+    debug "  #{command.inspect}"
+    exec command
+  end
+end

data/lib/boxen/util/logging.rb

@@ -0,0 +1,59 @@
+require "ansi"
+
+module Boxen
+  module Util
+    module Logging
+
+      # A fancier `abort` and `warn`. This will probably really annoy
+      # someone at some point because it's overriding a Kernel method,
+      # but it's limited to checks.
+
+      alias :fail :abort
+
+      def abort(message, *extras)
+        extras << { :color => :red, :stream => $stderr }
+        log "FAIL: #{message}", *extras
+        exit 1
+      end
+
+      def warn(message, *extras)
+        extras << { :color => :yellow, :stream => $stderr }
+        log "--> #{message}", *extras
+      end
+
+      def info(message, *extras)
+        extras << { :color => :cyan }
+        log "--> #{message}", *extras
+      end
+
+      def debug(message, *extras)
+        if debug?
+          extras << { :color => :white }
+          log "    DEBUG: #{message}", *extras
+        end
+      end
+
+      def log(message, *extras)
+        options = Hash === extras.last ? extras.pop : {}
+
+        stream = options[:stream] || $stdout
+
+        if color = options[:color]
+          stream.puts ANSI.send(color) { message }
+        else
+          stream.puts message
+        end
+
+        unless extras.empty?
+          extras.each { |line| stream.puts "    #{line}" }
+        end
+      end
+
+      def debug?
+        false
+      end
+
+
+    end
+  end
+end

data/lib/boxen/version.rb

@@ -0,0 +1,3 @@
+module Boxen
+  VERSION = "3.0.0.beta1"
+end

data/script/bootstrap

@@ -4,4 +4,4 @@
 cd "$(dirname $0)"/..
 
 rm -f .bundle/config
-bundle install --binstubs bin --path .bundle --quiet
+bundle install --binstubs .bundle/bin --path .bundle --quiet

data/script/tests

@@ -6,5 +6,6 @@ cd "$(dirname $0)"/..
 script/bootstrap &&
   ruby -rubygems -Ilib:test \
     -e 'require "bundler/setup"' \
+    -e 'require "minitest/autorun"' \
     -e 'tests = ARGV.empty? ? Dir["test/**/*_test.rb"] : ARGV' \
     -e 'tests.each { |f| load f }' "$@"

data/test/boxen/test.rb

@@ -2,6 +2,6 @@ require "minitest/autorun"
 require "mocha/setup"
 
 module Boxen
-  class Test < MiniTest::Unit::TestCase
+  class Test < MiniTest::Test
   end
 end

data/test/boxen_cli_test.rb

@@ -1,39 +1,16 @@
-require "boxen/test"
 require "boxen/cli"
 
-class BoxenCLITest < Boxen::Test
-  def setup
-    @config = Boxen::Config.new
-    @flags  = Boxen::Flags.new
-    @cli    = Boxen::CLI.new(@config, @flags)
-  end
-
-  def test_initialize
-    config = Boxen::Config.new
-    flags  = Boxen::Flags.new
-
-    cli = Boxen::CLI.new config, flags
+require "boxen/command_status"
 
-    assert_equal config, cli.config
-    assert_equal flags,  cli.flags
+describe Boxen::CLI do
 
-    assert_equal config, cli.runner.config
-    assert_equal flags,  cli.runner.flags
-  end
+  it "is a fancy way of reinvoking commands at this time" do
+    config = mock("config")
+    Boxen::Config.expects(:load).returns(config)
+    Boxen::Command.expects(:invoke).with("foo", config).
+      returns(Boxen::CommandStatus.new(0))
 
-  def test_run
-    @cli.runner.expects(:run)
-    @cli.run
+    Boxen::CLI.run("foo")
   end
 
-  def test_help
-    $stdout.stubs(:write)
-
-    flags = Boxen::Flags.new('--help')
-    cli   = Boxen::CLI.new(@config, flags)
-    cli.runner.expects(:run).never
-    assert_raises SystemExit do
-      cli.run
-    end
-  end
 end

data/test/boxen_command_test.rb

@@ -0,0 +1,93 @@
+require "boxen/command"
+
+class Failing < Boxen::Check
+  def initialize(*args); end
+  def ok?; false; end
+  def run; warn "lol this fails in ur face"; end
+end
+
+class Boxen::Command::Foo < Boxen::Command
+  def run
+    puts "foo"
+    Boxen::CommandStatus.new(0)
+  end
+end
+
+class Boxen::Command::Barnette < Boxen::Command
+  preflight Failing
+
+  def run
+    puts "bar"
+    Boxen::CommandStatus.new(0)
+  end
+end
+
+class Boxen::Command::Atmos < Boxen::Command
+  postflight Failing
+
+  def run
+    puts "hello, cindarella"
+    Boxen::CommandStatus.new(0)
+  end
+end
+
+describe Boxen::Command do
+  before do
+    @config = Minitest::Mock.new
+    def @config.debug?; false; end
+  end
+
+  it "registers commands and shoves them into a hash, and can invoke them" do
+    Boxen::Command.register :foo, Boxen::Command::Foo
+
+    stdout, _ = capture_io do
+      Boxen::Command.invoke :foo, @config
+    end
+
+    assert_match "foo", stdout
+  end
+
+  it "fails with UnknownCommandError if the invoked command is not registered" do
+    assert_raises Boxen::Command::UnknownCommandError do
+      Boxen::Command.invoke :random_command
+    end
+  end
+
+  it "fails with UnknownCommandError if the invoked command is nil" do
+    assert_raises Boxen::Command::UnknownCommandError do
+      Boxen::Command.invoke nil
+    end
+  end
+
+  it "registers command aliases" do
+    Boxen::Command.register :foo, Boxen::Command::Foo, :bar
+
+    stdout, _ = capture_io do
+      Boxen::Command.invoke :bar, @config
+    end
+
+    assert_match "foo", stdout
+  end
+
+  it "executes preflight hooks" do
+    Boxen::Command.register :barnette, Boxen::Command::Barnette
+
+    stdout, stderr = capture_io do
+      Boxen::Command.invoke :barnette, @config
+    end
+
+    assert_match "lol this fails in ur face", stderr
+    refute_match "bar", stdout
+  end
+
+  it "executes postflight hooks" do
+    Boxen::Command.register :atmos, Boxen::Command::Atmos
+
+    stdout, stderr = capture_io do
+      Boxen::Command.invoke :atmos, @config
+    end
+
+    assert_match "lol this fails in ur face", stderr
+    assert_match "hello, cindarella", stdout
+  end
+end

data/test/boxen_config_test.rb

@@ -7,13 +7,6 @@ class BoxenConfigTest < Boxen::Test
     @config.repodir = "test/fixtures/repo"
   end
 
-  def test_debug?
-    refute @config.debug?
-
-    @config.debug = true
-    assert @config.debug?
-  end
-
   def test_email
     assert_nil @config.email
 
@@ -96,27 +89,6 @@ class BoxenConfigTest < Boxen::Test
     assert_equal "foo", @config.name
   end
 
-  def test_pretend?
-    refute @config.pretend?
-
-    @config.pretend = true
-    assert @config.pretend?
-  end
-
-  def test_profile?
-    refute @config.profile?
-
-    @config.profile = true
-    assert @config.profile?
-  end
-
-  def test_future_parser?
-    refute @config.future_parser?
-
-    @config.future_parser = true
-    assert @config.future_parser?
-  end
-
   def test_projects
     files = Dir["#{@config.repodir}/modules/projects/manifests/*.pp"]
     assert_equal files.size, @config.projects.size
@@ -324,8 +296,6 @@ class BoxenConfigTest < Boxen::Test
   end
 
   def test_token
-    assert_nil @config.token
-
     @config.token = "foo"
     assert_equal "foo", @config.token
   end
@@ -382,7 +352,7 @@ class BoxenConfigTest < Boxen::Test
     ENV["BOXEN_S3_BUCKET"] = val
   end
 
-  def test_s3host_env_var
+  def test_s3bucket_env_var
     val = ENV["BOXEN_S3_BUCKET"]
 
     ENV["BOXEN_S3_BUCKET"] = "my-bucket"

data/test/boxen_directories_test.rb

@@ -12,25 +12,25 @@ class BoxenPreflightDirectoriesTest < Boxen::Test
   end
 
   def test_not_okay_if_homedir_group_wrong
-    directories = Boxen::Preflight::Directories.new(@config)
+    directories = Boxen::Preflight::Directories.new(@config, :command)
     directories.stubs(:homedir_group).returns(false)
     refute directories.ok?
   end
 
   def test_not_okay_if_homedir_owner_wrong
-    directories = Boxen::Preflight::Directories.new(@config)
+    directories = Boxen::Preflight::Directories.new(@config, :command)
     directories.stubs(:homedir_owner).returns(false)
     refute directories.ok?
   end
 
   def test_not_okay_unless_homedir_exists
-    directories = Boxen::Preflight::Directories.new(@config)
+    directories = Boxen::Preflight::Directories.new(@config, :command)
     directories.stubs(:homedir_directory_exists?).returns(false)
     refute directories.ok?
   end
 
   def test_okay_if_allchecks_fine
-    directories = Boxen::Preflight::Directories.new(@config)
+    directories = Boxen::Preflight::Directories.new(@config, :command)
     directories.stubs(:homedir_directory_exists?).returns(true)
     directories.stubs(:homedir_owner).returns("foobar")
     directories.stubs(:homedir_group).returns("staff")

data/test/boxen_hook_test.rb

@@ -0,0 +1,25 @@
+require "boxen/hook"
+
+class DatHook < Boxen::Hook
+  def enabled?
+    true
+  end
+
+  def run
+    puts "yolo"
+  end
+end
+
+describe Boxen::Hook do
+
+  it "registers hooks and executes them" do
+    Boxen::Hook.register DatHook
+
+    stdout, _ = capture_io do
+      Boxen::Hook.run
+    end
+
+    assert_equal "yolo\n", stdout
+  end
+
+end