scripto 0.0.3 → 1.0.0

data/test/test_file.rb

@@ -1,200 +0,0 @@
-require_relative "helper"
-
-class TestFile < Minitest::Test
-  include Helper
-
-  DIR = "dir"
-  SRC, DST = "src.txt", "dst.txt"
-  SRC2, DST2 = "src2.txt", "dst2.txt"
-
-  def setup
-    super
-    File.write(SRC, "something")
-    File.write(SRC2, "another thing")
-  end
-
-  #
-  # basics
-  #
-
-  def test_mkdir
-    Scripto.mkdir(DIR)
-    assert(File.directory?(DIR))
-  end
-
-  def test_mkdir_mode
-    Scripto.mkdir(DIR, mode: 0644)
-    assert_equal(0644, File.stat(DIR).mode & 0644)
-  end
-
-  def test_cp
-    Scripto.cp(SRC, DST)
-    assert_equal(File.read(SRC), File.read(DST))
-  end
-
-  def test_cp_mode
-    Scripto.cp(SRC, DST, mode: 0644)
-    assert_equal(0644, File.stat(DST).mode & 0644)
-  end
-
-  def test_cp_mkdir
-    in_dir = "#{DIR}/in_dir"
-    Scripto.cp(SRC, in_dir, mkdir: true)
-    assert_equal(File.read(SRC), File.read(in_dir))
-  end
-
-  def test_mv
-    Scripto.mv(SRC, DST)
-    assert_equal("something", File.read(DST))
-  end
-
-  def test_mv_mkdir
-    in_dir = "#{DIR}/in_dir"
-    Scripto.mv(SRC, in_dir, mkdir: true)
-    assert_equal("something", File.read(in_dir))
-  end
-
-  def test_ln
-    Scripto.ln(SRC, DST)
-    assert_equal(SRC, File.readlink(DST))
-  end
-
-  def test_rm
-    Scripto.rm(SRC)
-    assert(!File.exist?(SRC))
-    Scripto.rm("this_file_doesnt_exist") # shouldn't complain
-  end
-
-  #
-  # if necessary (this is useful for printing)
-  #
-
-  def test_if_necessary
-    # should return true
-    assert Scripto.mkdir_if_necessary(DIR)
-    assert Scripto.cp_if_necessary(SRC, DST)
-    assert Scripto.ln_if_necessary(SRC, DST2)
-
-    assert(File.directory?(DIR))
-    assert_equal(File.read(SRC), File.read(DST))
-    assert_equal(SRC, File.readlink(DST2))
-
-    # should be silent
-    assert_fu_output(nil, "") do
-      assert_nil Scripto.mkdir_if_necessary(DIR)
-      assert_nil Scripto.cp_if_necessary(SRC, DST)
-      assert_nil Scripto.ln_if_necessary(SRC, DST2)
-    end
-  end
-
-  def test_cp_if_necessary_differs
-    File.write(DST, "this is different")
-    assert_fu_output(nil, "cp -rp #{SRC} #{DST}\n") do
-      assert Scripto.cp_if_necessary(SRC, DST)
-    end
-  end
-
-  def test_ln_if_necessary_differs
-    File.symlink(SRC2, DST)
-    assert_fu_output(nil, "rm -f #{DST}\nln -sf #{SRC} #{DST}\n") do
-      assert Scripto.ln_if_necessary(SRC, DST)
-      assert_equal(SRC, File.readlink(DST))
-    end
-  end
-
-  def test_chmod
-    Scripto.chmod(SRC, 0644)
-    assert_equal(0644, File.stat(SRC).mode & 0644)
-  end
-
-  def test_rm_and_mkdir
-    Dir.mkdir(DIR)
-    File.write("#{DIR}/file", "this is a test")
-    assert Dir["#{DIR}/*"].length == 1
-    Scripto.rm_and_mkdir(DIR)
-    assert Dir["#{DIR}/*"].length == 0
-  end
-
-  def test_copy_metadata
-    File.chmod(0644, SRC)
-    File.utime(1234, 5678, SRC)
-    Scripto.copy_metadata(SRC, SRC2)
-    assert_equal(0644, File.stat(SRC2).mode & 0644)
-    assert_equal(1234, File.stat(SRC2).atime.to_i)
-    assert_equal(5678, File.stat(SRC2).mtime.to_i)
-  end
-
-  #
-  # chown rests - must be root
-  #
-
-  def test_mkdir_owner
-    skip if !root?
-    Scripto.mkdir(DIR, owner: "nobody")
-    assert(Etc.getpwnam("nobody").uid, File.stat(DIR).uid)
-  end
-
-  def test_cp_owner
-    skip if !root?
-    Scripto.cp(SRC, DST, owner: "nobody")
-    assert(Etc.getpwnam("nobody").uid, File.stat(DST).uid)
-  end
-
-  def test_chown
-    skip if !root?
-    Scripto.chown(SRC, "nobody")
-    assert(Etc.getpwnam("nobody").uid, File.stat(SRC).uid)
-  end
-
-  #
-  # verbosity
-  #
-
-  def test_mkdir_verbose
-    assert_fu_output(nil, "mkdir -p #{DIR}\n") do
-      Scripto.mkdir(DIR)
-    end
-  end
-
-  def test_cp_verbose
-    assert_fu_output(nil, "cp -rp #{SRC} #{DST}\n") do
-      Scripto.cp(SRC, DST)
-    end
-  end
-
-  def test_mv_verbose
-    assert_fu_output(nil, "mv #{SRC} #{DST}\n") do
-      Scripto.mv(SRC, DST)
-    end
-  end
-
-  def test_ln_verbose
-    assert_fu_output(nil, "ln -sf #{SRC} #{DST}\n") do
-      Scripto.ln(SRC, DST)
-    end
-  end
-
-  def test_rm_verbose
-    assert_fu_output(nil, "rm -f #{SRC}\n") do
-      Scripto.rm(SRC)
-    end
-  end
-
-  protected
-
-  def root?
-    if !defined?(@root)
-      @root = `whoami`.strip == "root"
-    end
-    @root
-  end
-
-  def assert_fu_output(stdout = nil, stderr = nil, &block)
-    Scripto.verbose!
-    assert_output(stdout, stderr) do
-      # FileUtils squirrels this away so we have to set it manually
-      FileUtils.instance_eval("@fileutils_output = $stderr")
-      yield
-    end
-  end
-end

data/test/test_misc.rb

@@ -1,53 +0,0 @@
-require_relative "helper"
-
-class TestMisc < Minitest::Test
-  include Helper
-
-  def test_whoami
-    assert_equal(`whoami`.strip, Scripto.whoami)
-  end
-
-  def test_root?
-    assert_equal(`whoami`.strip == "root", Scripto.root?)
-  end
-
-  def test_md5_string
-    assert_equal("ba73632f801ac2c72d78134722f2cb84", Scripto.md5_string("gub"))
-  end
-
-  def test_md5_file
-    File.write("test.txt", "gub")
-    assert_equal("ba73632f801ac2c72d78134722f2cb84", Scripto.md5_file("test.txt"))
-  end
-
-  def test_prompt?
-    with_fake_stdin("YES") do
-      assert_output(nil, "question (y/n) ") do
-        assert Scripto.prompt?("question")
-      end
-    end
-    with_fake_stdin("y") do
-      assert_output(nil, "question (y/n) ") do
-        assert Scripto.prompt?("question")
-      end
-    end
-    with_fake_stdin("no") do
-      assert_output(nil, "question (y/n) ") do
-        assert !Scripto.prompt?("question")
-      end
-    end
-  end
-
-  protected
-
-  def with_fake_stdin(str, &block)
-    old_stdin = $stdin
-    begin
-      $stdin = StringIO.new(str)
-      $stdin.rewind
-      yield
-    ensure
-      $stdin = old_stdin
-    end
-  end
-end

data/test/test_print.rb

@@ -1,28 +0,0 @@
-require_relative "helper"
-
-class TestPrint < Minitest::Test
-  include Helper
-
-  def test_verbose?
-    assert(!Scripto.verbose?)
-    Scripto.verbose!
-    assert(Scripto.verbose?)
-  end
-
-  def test_quiet
-    assert_silent { Scripto.vbanner "gub" }
-    assert_silent { Scripto.vprintf("gub %d", 123) }
-    assert_silent { Scripto.vputs "gub" }
-  end
-
-  def test_loud
-    Scripto.verbose!
-    assert_output(nil, /gub/) { Scripto.vbanner "gub" }
-    assert_output(nil, /gub/) { Scripto.vprintf("zub %s", "gub") }
-    assert_output(nil, /gub/) { Scripto.vputs "gub" }
-  end
-
-  def test_warning
-    assert_output(nil, /gub/) { Scripto.warning "gub" }
-  end
-end

data/test/test_run.rb

@@ -1,103 +0,0 @@
-require_relative "helper"
-
-class TestRun < Minitest::Test
-  include Helper
-
-  SUCCEEDS = "echo gub"
-  FAILS = "cat scripto_bogus_file 2> /dev/null"
-  BAD_COMMAND = "this_command_doesnt_exist"
-  SRC = "_scripto_src"
-  DST = "_scripto with spaces"
-  ARGS = [ "-f", SRC, DST ]
-
-  def setup
-    super
-    File.write(SRC, "something")
-  end
-
-  #
-  # basic methods
-  #
-
-  def test_run
-    Scripto.run("#{SUCCEEDS} > #{SRC}")
-    assert_equal("gub", File.read(SRC).strip)
-    assert("gub", Scripto.run_capture(SUCCEEDS))
-    Scripto.run_quietly(SUCCEEDS)
-  end
-
-  def test_run_succeeds?
-    assert_succeeds(SUCCEEDS)
-    assert_fails(FAILS)
-    assert_fails(BAD_COMMAND)
-  end
-
-  def test_shellescape
-    assert_equal("gub",       Scripto.shellescape("gub"))
-    assert_equal("gub\\ zub", Scripto.shellescape("gub zub"))
-  end
-
-  # verbosity
-  def test_verbose
-    Scripto.verbose!
-    cmd = "#{SUCCEEDS} > /dev/null"
-    assert_output(nil, "#{cmd}\n") do
-      Scripto.run(cmd)
-    end
-  end
-
-  # commands that fail
-  def test_failures
-    assert_raises(Scripto::RunCommands::Error) { Scripto.run(BAD_COMMAND) }
-    assert_raises(Scripto::RunCommands::Error) { Scripto.run_capture(BAD_COMMAND) }
-    assert_raises(Scripto::RunCommands::Error) { Scripto.run(FAILS) }
-    assert_raises(Scripto::RunCommands::Error) { Scripto.run_capture(FAILS) }
-  end
-
-  #
-  # args
-  #
-
-  def test_run_args
-    # make sure SRC is copied to DST in all cases
-    assert_cp { Scripto.run("cp", ARGS) }
-    assert_cp { Scripto.run_quietly("cp", ARGS) }
-    assert_cp { assert_succeeds("cp", ARGS) }
-  end
-
-  def test_capture_escaping
-    tricky = "\"'!tricky!'\""
-    assert_equal("#{tricky} #{tricky}\n", Scripto.run_capture("echo", [tricky, tricky]))
-  end
-
-  def test_args_succeeds_fails
-    assert_fails(BAD_COMMAND, ARGS)
-  end
-
-  # is output escaped properly with verbose?
-  def test_args_verbose
-    Scripto.verbose!
-    assert_output(nil, "cp -f #{SRC} #{DST.gsub(" ", "\\ ")}\n") do
-      Scripto.run("cp", ARGS)
-    end
-  end
-
-  protected
-
-  def assert_cp(&block)
-    File.unlink(DST) if File.exist?(DST)
-    yield
-    assert_equal(File.read(SRC), File.read(DST))
-    File.unlink(DST)
-  end
-
-  def assert_succeeds(command, args = nil)
-    assert_equal(true,  Scripto.run_succeeds?(command, args))
-    assert_equal(false, Scripto.run_fails?(command, args))
-  end
-
-  def assert_fails(command, args = nil)
-    assert_equal(false, Scripto.run_succeeds?(command, args))
-    assert_equal(true,  Scripto.run_fails?(command, args))
-  end
-end

data/vagrant_provision

@@ -1,50 +0,0 @@
-#!/bin/bash
-
-# bail on errors
-set -eu
-
-function banner() {
-  printf '\e[1;37;43m[%s] %-72s\e[0m\n' `date '+%H:%M:%S'` "vagrant_provision: $1"
-}
-
-# packages needed for building ruby
-banner "Packages..."
-sudo apt-get -y install git-core
-sudo apt-get -y install build-essential checkinstall libffi-dev libreadline-gplv2-dev libncurses5-dev libssl-dev libyaml-dev zlib1g-dev
-
-# rbenv
-banner "Rbenv..."
-if [ ! -d ~/.rbenv ] ; then
-  git clone git://github.com/sstephenson/rbenv.git ~/.rbenv
-fi
-if [ ! -d ~/.rbenv/plugins/ruby-build ] ; then
-  git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
-fi
-
-# add rbenv to .bashrc
-if ! grep -q 'vagrant provisioning' ~/.bashrc ; then
-  cat >> ~/.bashrc <<"EOF"
-# added by vagrant provisioning
-export PATH="$HOME/.rbenv/bin:$PATH"
-eval "$(rbenv init -)"
-EOF
-
-  # make sure we pickup rbenv too!
-  export PATH="$HOME/.rbenv/bin:$PATH"
-  eval "$(rbenv init -)"
-fi
-
-# no rdoc, please
-echo 'gem: --no-ri --no-rdoc' > ~/.gemrc
-
-# now install ruby
-banner "Ruby..."
-rbenv install 2.0.0-p353
-rbenv global 2.0.0-p353
-ruby -v
-
-# and gems
-banner "Gems..."
-gem update --system
-gem install bundler
-rbenv rehash