scripto 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4303784647ebd8ea25f1231f1c457490a15aebb8
-  data.tar.gz: 8503790cde1ec50455970da18a6d038ad6699cf1
+  metadata.gz: bd230249468a8975ef75cad139685d21a535842b
+  data.tar.gz: f9c7c8a34a06b1892b2302a70dbf09ce8c6be066
 SHA512:
-  metadata.gz: 5d9162c98b08f8f027d9233f5eca62db3485616dccecbb42a502e2d38db6734296575642a2f31563a39d04f0789a745ce62d5acfe95e1cb86a7c85bc74605b98
-  data.tar.gz: d047ea1eca14ef498dc563cb26c20b1864763d509a5649e798390193825a4e1031fd6554d8ab77803847d0e2ed68c301523873db23735c3256d869b3d97a24f2
+  metadata.gz: 353e0017433d1a40c4a02c31543a174774f3261d70ec722af53703499f24e65a94cd7d024ef41de9479522865f70907c292e783f72f444b8fccf0831e3ae262c
+  data.tar.gz: 22d9cae0e3a74b4aa41e410cd1cb9d6671481d58a61477e7c1af681311abd0c04db79365f025122b6b6fd92bed1aff37bfc2436e09d9bd42257527f99615fced

data/.gitignore

@@ -2,6 +2,7 @@
 *.rbc
 .bundle
 .config
+.vagrant
 .yardoc
 Gemfile.lock
 InstalledFiles

data/README.md

@@ -1,29 +1,151 @@
 # Scripto
 
-TODO: Write a gem description
+Scripto is a framework for writing command line applications. It fills in many of the blanks that Ruby's standard library is missing:
 
-## Installation
+* **print to $stderr** - Colored banners and a verbose mode to make your scripts louder.
+* **file operations** - Mkdir, cp, mv, ln. These operations can take care of common edge cases, like creating the target directory before copying a file.
+* **csv** - Read and write CSV files from hashes, Structs, or OpenStructs.
+* **run commands** - Run external commands and raise errors on failure.
 
-Add this line to your application's Gemfile:
+## Getting Started
 
-    gem 'scripto'
+You can call Scripto directly:
 
-And then execute:
+```ruby
+require "scripto"
 
-    $ bundle
+Scripto.banner("Starting installation...")
+Scripto.cp("here.txt", "there.txt")
+Scripto.mv("there.txt", "and_back.txt")
 
-Or install it yourself as:
+rows = [ ]
+rows << { name: "Adam", score: 100 }
+rows << { name: "Patrick", score: 99 }
+Scripto.csv_write("scores.csv", rows)
 
-    $ gem install scripto
+if Scripto.fails("which git")
+  Scripto.run("brew install git")
+end
 
-## Usage
+Scripto.run("touch script_complete.txt")
+```
 
-TODO: Write usage instructions here
+You can also subclass `Scripto::Main`:
 
-## Contributing
+```ruby
+#!/usr/bin/env ruby
 
-1. Fork it ( http://github.com/<my-github-username>/scripto/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+require "scripto"
+
+class Install < Scripto::Main
+  def initialize(options = {})
+    verbose! if options[:verbose]
+
+    banner("Starting installation...")
+    cp("here.txt", "there.txt")
+    mv("there.txt", "and_back.txt")
+
+    rows = [ ]
+    rows << { name: "Adam", score: 100 }
+    rows << { name: "Patrick", score: 99 }
+    csv_write("scores.csv", rows)
+
+    if fails("which git")
+      run("brew install git")
+    end
+
+    run("touch script_complete.txt")
+  end
+end
+
+Install.new(verbose: true)
+```
+
+## Methods
+
+### Print to $stderr
+
+```
+banner(str)  - print a banner in green
+warning(str) - print a warning in yellow
+fatal(str)   - print a fatal error in red, then exit(1)
+
+verbose!     - turn on verbose mode
+vbanner(str) - print a colored banner in green if verbose is on
+vprintf(str) - printf if verbose is on
+vputs(str)   - puts if verbose is on
+```
+
+### File operations
+
+These operations are silent by default. If verbose is turned on, each command will be echoed first.
+
+```
+mkdir(dir)                 - mkdir -p dir
+cp(src, dst, mkdir: false) - cp -p src dst, mkdir if necessary
+mv(src, dst, mkdir: false) - mv src dst, mkdir if necessary
+ln(src, dst, mkdir: false) - ln -sf src dst, mkdir if necessary
+rm(file)                   - rm -f file
+```
+
+Each of these operations also has an "if_necessary" variant that only runs the operation if necessary. For example, `mkdir_if_necessary` only calls `mkdir` if the directory doesn't exist. When combined with verbose mode, this produces **a nice changelog** as the operations are run. You can run your script repeatedly and it'll only output actual changes.
+
+Plus a few more:
+
+```
+chown(file, user)       - chown user:user file
+chmod(file, mode)       - chmod mode file
+rm_and_mkdir(dir)       - rm -rf dir && mkdir -p dir (for tmp dirs)
+copy_metadata(src, dst) - copy mode/atime/mtime from src to dst
+```
+
+### Run external commands (system, backtick, etc)
+
+Each of these methods takes a `command` and an optional array of `args`. Use it like so:
+
+```
+run("echo hello world")        # this will use a shell
+run("echo, ["hello", "world"]) # NO shell, runs echo directly
+```
+
+This is like `Kernel#system` works - you can use the second variant (the array of arguments) to sidestep shell escaping issues. For example, these are the same but the second variant doesn't require those pesky single quotes:
+
+```
+run("cp file 'hello world")
+run("cp, ["file", "hello world"])
+```
+
+Here are the various run commands:
+
+```
+run(command, args = nil)           - run a command, raise an error
+run_capture(command, args = nil)   - capture the output similar to backtick, raise on error
+run_quietly(command, args = nil)   - redirect stdout/stderr to /dev/null, raise on error
+
+run_succeeds?(command, args = nil) - return true if command succeeds
+run_fails?(command, args = nil)    - return true if command fails
+```
+
+### CSV read/write
+
+Light wrappers around the CSV class built into Ruby. Used exclusively with hash-like objects, not arrays. The header row turns into the keys for the hash.
+
+```
+csv_read(path)        - read a CSV, returns an array of Structs. Path can be a .gz.
+csv_write(path, rows) - write rows to a CSV. Rows can be hashes, Structs or OpenStructs.
+csv_to_stdout(rows)   - write rows to stdout, like csv_write
+csv_to_s(rows)        - write rows to a string, like csv_write
+```
+
+### Misc
+
+There are a few more useful tidbits in here:
+
+```
+whoami             - just like the command
+root?              - return true if we're running as root
+md5_file(path)     - calculate md5 for a file
+md5_string(str)    - calculate md5 for a string
+prompt?(question)  - ask the user a question, return true if they say yes
+random_string(len) - calculate a random alphanumeric string
+```

data/Rakefile

@@ -10,5 +10,7 @@ task default: :test
 RDoc::Task.new do |rdoc|
   rdoc.rdoc_dir = "rdoc"
   rdoc.title = "scripto #{Scripto::VERSION}"
+  rdoc.main = "README.md"
   rdoc.rdoc_files.include("lib/**/*.rb")
+  rdoc.rdoc_files.include("README.md")
 end

data/Vagrantfile

@@ -0,0 +1,121 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# Vagrantfile API/syntax version. Don't touch unless you know what you're doing!
+VAGRANTFILE_API_VERSION = "2"
+
+Vagrant.configure(VAGRANTFILE_API_VERSION) do |config|
+  # All Vagrant configuration is done here. The most common configuration
+  # options are documented and commented below. For a complete reference,
+  # please see the online documentation at vagrantup.com.
+
+  # Every Vagrant virtual environment requires a box to build off of.
+  config.vm.box = "precise32"
+
+  # The url from where the 'config.vm.box' box will be fetched if it
+  # doesn't already exist on the user's system.
+  config.vm.box_url = "http://files.vagrantup.com/precise32.box"
+
+  # amd
+  config.vm.provision :shell, path: "vagrant_provision", privileged: false
+
+  # Create a forwarded port mapping which allows access to a specific port
+  # within the machine from a port on the host machine. In the example below,
+  # accessing "localhost:8080" will access port 80 on the guest machine.
+  # config.vm.network :forwarded_port, guest: 80, host: 8080
+
+  # Create a private network, which allows host-only access to the machine
+  # using a specific IP.
+  # config.vm.network :private_network, ip: "192.168.33.10"
+
+  # Create a public network, which generally matched to bridged network.
+  # Bridged networks make the machine appear as another physical device on
+  # your network.
+  # config.vm.network :public_network
+
+  # If true, then any SSH connections made will enable agent forwarding.
+  # Default value: false
+  # config.ssh.forward_agent = true
+
+  # Share an additional folder to the guest VM. The first argument is
+  # the path on the host to the actual folder. The second argument is
+  # the path on the guest to mount the folder. And the optional third
+  # argument is a set of non-required options.
+  # config.vm.synced_folder "../data", "/vagrant_data"
+
+  # Provider-specific configuration so you can fine-tune various
+  # backing providers for Vagrant. These expose provider-specific options.
+  # Example for VirtualBox:
+  #
+  # config.vm.provider :virtualbox do |vb|
+  #   # Don't boot with headless mode
+  #   vb.gui = true
+  #
+  #   # Use VBoxManage to customize the VM. For example to change memory:
+  #   vb.customize ["modifyvm", :id, "--memory", "1024"]
+  # end
+  #
+  # View the documentation for the provider you're using for more
+  # information on available options.
+
+  # Enable provisioning with Puppet stand alone.  Puppet manifests
+  # are contained in a directory path relative to this Vagrantfile.
+  # You will need to create the manifests directory and a manifest in
+  # the file precise32.pp in the manifests_path directory.
+  #
+  # An example Puppet manifest to provision the message of the day:
+  #
+  # # group { "puppet":
+  # #   ensure => "present",
+  # # }
+  # #
+  # # File { owner => 0, group => 0, mode => 0644 }
+  # #
+  # # file { '/etc/motd':
+  # #   content => "Welcome to your Vagrant-built virtual machine!
+  # #               Managed by Puppet.\n"
+  # # }
+  #
+  # config.vm.provision :puppet do |puppet|
+  #   puppet.manifests_path = "manifests"
+  #   puppet.manifest_file  = "site.pp"
+  # end
+
+  # Enable provisioning with chef solo, specifying a cookbooks path, roles
+  # path, and data_bags path (all relative to this Vagrantfile), and adding
+  # some recipes and/or roles.
+  #
+  # config.vm.provision :chef_solo do |chef|
+  #   chef.cookbooks_path = "../my-recipes/cookbooks"
+  #   chef.roles_path = "../my-recipes/roles"
+  #   chef.data_bags_path = "../my-recipes/data_bags"
+  #   chef.add_recipe "mysql"
+  #   chef.add_role "web"
+  #
+  #   # You may also specify custom JSON attributes:
+  #   chef.json = { :mysql_password => "foo" }
+  # end
+
+  # Enable provisioning with chef server, specifying the chef server URL,
+  # and the path to the validation key (relative to this Vagrantfile).
+  #
+  # The Opscode Platform uses HTTPS. Substitute your organization for
+  # ORGNAME in the URL and validation key.
+  #
+  # If you have your own Chef Server, use the appropriate URL, which may be
+  # HTTP instead of HTTPS depending on your configuration. Also change the
+  # validation key to validation.pem.
+  #
+  # config.vm.provision :chef_client do |chef|
+  #   chef.chef_server_url = "https://api.opscode.com/organizations/ORGNAME"
+  #   chef.validation_key_path = "ORGNAME-validator.pem"
+  # end
+  #
+  # If you're using the Opscode platform, your validator client is
+  # ORGNAME-validator, replacing ORGNAME with your organization name.
+  #
+  # If you have your own Chef Server, the default validation client name is
+  # chef-validator, unless you changed the configuration.
+  #
+  #   chef.validation_client_name = "ORGNAME-validator"
+end

data/lib/scripto/csv_commands.rb

@@ -1,9 +1,10 @@
 require "csv"
-require "ostruct"
 require "zlib"
 
 module Scripto
   module CsvCommands
+    # Read a csv from +path+. Returns an array of Structs, using the keys from
+    # the csv header row.
     def csv_read(path)
       lines = if path =~ /\.gz$/
         Zlib::GzipReader.open(path) do |f|
@@ -17,7 +18,10 @@ module Scripto
       lines.map { |i| klass.new(*i) }
     end
 
-    # write rows to path as CSV
+    # Write +rows+ to +path+ as csv. Rows can be an array of hashes, Structs,
+    # OpenStructs, or anything else that responds to to_h. The keys from the
+    # first row are used as the csv header. If +cols+ is specified, it will be
+    # used as the column keys instead.
     def csv_write(path, rows, cols: nil)
       begin
         tmp = "/tmp/_scripto_csv.csv"
@@ -28,10 +32,12 @@ module Scripto
       end
     end
 
+    # Write +rows+ to $stdout as a csv. Similar to csv_write.
     def csv_to_stdout(rows, cols: nil)
       CSV($stdout) { |f| csv_write0(f, rows, cols: cols) }
     end
 
+    # Returns a string containing +rows+ as a csv. Similar to csv_write.
     def csv_to_s(rows, cols: nil)
       string = ""
       f = CSV.new(StringIO.new(string))
@@ -41,6 +47,7 @@ module Scripto
 
     protected
 
+    # :nodoc:
     def csv_write0(csv, rows, cols: nil)
       # cols
       cols ||= rows.first.to_h.keys

data/lib/scripto/file_commands.rb

@@ -3,12 +3,21 @@ require "fileutils"
 
 module Scripto
   module FileCommands
+    # Like mkdir -p +dir+. If +owner+ is specified, the directory will be
+    # chowned to owner. If +mode+ is specified, the directory will be chmodded
+    # to mode. Like all file commands, the operation will be printed out if
+    # verbose?.
     def mkdir(dir, owner: nil, mode: nil)
       FileUtils.mkdir_p(dir, verbose: verbose?)
       chown(dir, owner) if owner
       chmod(dir, mode) if mode
     end
 
+    # Like cp -pr +src+ +dst. If +mkdir+ is true, the dst directoy will be
+    # created if necessary before the copy. If +owner+ is specified, the
+    # directory will be chowned to owner. If +mode+ is specified, the
+    # directory will be chmodded to mode. Like all file commands, the
+    # operation will be printed out if verbose?.
     def cp(src, dst, mkdir: false, owner: nil, mode: nil)
       mkdir_if_necessary(File.dirname(dst)) if mkdir
       FileUtils.cp_r(src, dst, preserve: true, verbose: verbose?)
@@ -16,11 +25,16 @@ module Scripto
       chmod(dst, mode) if mode
     end
 
+    # Like mv +src+ +dst. If +mkdir+ is true, the dst directoy will be created
+    # if necessary before the copy. Like all file commands, the operation will
+    # be printed out if verbose?.
     def mv(src, dst, mkdir: false)
       mkdir_if_necessary(File.dirname(dst)) if mkdir
       FileUtils.mv(src, dst, verbose: verbose?)
     end
 
+    # Like ln -sf +src+ +dst. The command will be printed out if
+    # verbose?.
     def ln(src, dst)
       begin
         FileUtils.ln_sf(src, dst, verbose: verbose?)
@@ -31,10 +45,15 @@ module Scripto
       end
     end
 
+    # Like rm -f +file+. Like all file commands, the operation will be printed
+    # out if verbose?.
     def rm(file)
       FileUtils.rm_f(file, verbose: verbose?)
     end
 
+    # Runs #mkdir, but ONLY if +dir+ doesn't already exist. Returns true if
+    # directory had to be created. This is useful with verbose?, to get an
+    # exact changelog.
     def mkdir_if_necessary(dir, owner: nil, mode: nil)
       if !(File.exists?(dir) || File.symlink?(dir))
         mkdir(dir, owner: owner, mode: mode)
@@ -42,6 +61,9 @@ module Scripto
       end
     end
 
+    # Runs #cp, but ONLY if +dst+ doesn't exist or differs from +src+. Returns
+    # true if the file had to be copied. This is useful with verbose?, to get
+    # an exact changelog.
     def cp_if_necessary(src, dst, mkdir: false, owner: nil, mode: nil)
       if !(File.exists?(dst) && FileUtils.compare_file(src, dst))
         cp(src, dst, mkdir: mkdir, owner: owner, mode: mode)
@@ -49,6 +71,9 @@ module Scripto
       end
     end
 
+    # Runs #ln, but ONLY if +dst+ isn't a symlink or differs from +src+.
+    # Returns true if the file had to be symlinked. This is useful with
+    # verbose?, to get an exact changelog.
     def ln_if_necessary(src, dst)
       ln = if !File.symlink?(dst)
         true
@@ -62,6 +87,8 @@ module Scripto
       end
     end
 
+    # Runs #rm, but ONLY if +file+ exists. Return true if the file had to be
+    # removed. This is useful with verbose?, to get an exact changelog.
     def rm_if_necessary(file)
       if File.exists?(file)
         rm(file)
@@ -69,6 +96,8 @@ module Scripto
       end
     end
 
+    # Like chown user:user file. Like all file commands, the operation will be printed
+    # out if verbose?.
     def chown(file, user)
       # who is the current owner?
       @scripto_uids ||= {}
@@ -79,18 +108,24 @@ module Scripto
       end
     end
 
+    # Like chmod mode file. Like all file commands, the operation will be
+    # printed out if verbose?.
     def chmod(file, mode)
       if File.stat(file).mode != mode
         FileUtils.chmod(mode, file, verbose: verbose?)
       end
     end
 
+    # Like rm -rf && mkdir -p. Like all file commands, the operation will be
+    # printed out if verbose?.
     def rm_and_mkdir(dir)
       raise "don't do this" if dir == ""
       FileUtils.rm_rf(dir, verbose: verbose?)
       mkdir(dir)
     end
 
+    # Copy mode, atime and mtime from +src+ to +dst+. This one is rarely used
+    # and doesn't echo.
     def copy_metadata(src, dst)
       stat = File.stat(src)
       File.chmod(stat.mode, dst)

data/lib/scripto/main.rb

@@ -1,4 +1,6 @@
 module Scripto
+  # A convenient superclass for using Scripto. Just subclass Main and you have
+  # access to all the Scripto goodies.
   class Main
     include CsvCommands
     include FileCommands

data/lib/scripto/misc_commands.rb

@@ -5,14 +5,17 @@ module Scripto
   module MiscCommands
     BASE_62 = ("0".."9").to_a + ("A".."Z").to_a + ("a".."z").to_a
 
+    # Who is the current user?
     def whoami
       @scripto_whoami ||= Etc.getpwuid(Process.uid).name
     end
 
+    # Return true if the current user is "root".
     def root?
       whoami == "root"
     end
 
+    # Return the md5 checksum for the file at +path+.
     def md5_file(path)
       File.open(path) do |f|
         digest, buf = Digest::MD5.new, ""
@@ -23,16 +26,20 @@ module Scripto
       end
     end
 
-    def md5_string(s)
-      Digest::MD5.hexdigest(s.to_s)
+    # Return the md5 checksum for +str+.
+    def md5_string(str)
+      Digest::MD5.hexdigest(str.to_s)
     end
 
+    # Ask the user a question via stderr, then return true if they enter YES,
+    # yes, y, etc.
     def prompt?(question)
       $stderr.write("#{question} (y/n) ")
       $stderr.flush
       $stdin.gets =~ /^y/i
     end
 
+    # Return a random alphanumeric string of length +len+.
     def random_string(len)
       (1..len).map { BASE_62.sample }.join
     end

data/lib/scripto/print_commands.rb

@@ -7,38 +7,47 @@ module Scripto
 
     attr_accessor :verbose
 
+    # Is verbose mode turned on?
     def verbose?
       !!@verbose
     end
 
+    # Turn on verbose mode. #vbanner, #vputs and #vprintf will start printing
+    # now, and file ops will be printed too.
     def verbose!
       @verbose = true
     end
 
-    def vbanner(s = nil)
-      banner(s) if verbose?
+    # Print a colored banner to $stderr, but only if #verbose?.
+    def vbanner(str = nil)
+      banner(str) if verbose?
     end
 
-    def vputs(s = nil)
-      $stderr.puts(s) if verbose?
+    # Puts to $stderr, but only if #verbose?.
+    def vputs(str = nil)
+      $stderr.puts(str) if verbose?
     end
 
-    def vprintf(s, *args)
-      $stderr.printf(s, *args) if verbose?
+    # Printf to $stderr, but only if #verbose?.
+    def vprintf(str, *args)
+      $stderr.printf(str, *args) if verbose?
     end
 
-    def banner(s, color: GREEN)
+    # Print a colored banner to $stderr in green.
+    def banner(str, color: GREEN)
       now = Time.new.strftime("%H:%M:%S")
-      s = "#{s} ".ljust(72, " ")
+      s = "#{str} ".ljust(72, " ")
       $stderr.puts "#{color}[#{now}] #{s}#{RESET}"
     end
 
-    def warning(msg)
-      banner("Warning: #{msg}", color: YELLOW)
+    # Print a yellow warning banner to $stderr.
+    def warning(str)
+      banner("Warning: #{str}", color: YELLOW)
     end
 
-    def fatal(msg)
-      banner(msg, color: RED)
+    # Print a red error banner to $stderr, then exit.
+    def fatal(str)
+      banner(str, color: RED)
       exit(1)
     end
   end

data/lib/scripto/run_commands.rb

@@ -1,25 +1,38 @@
-require "english"
+require "English"
 require "shellwords"
 
 module Scripto
 	module RunCommands
-    class Error < StandardError ; end
+    # The error thrown by #run, #run_capture and #run_quietly on failure.
+    class Error < StandardError
+    end
 
+    # Run an external command. Raise Error if something goes wrong. The
+    # command will be echoed if verbose?.
+    #
+    # Usage is similar to Kernel#system. If +args+ is nil, +command+ will be
+    # passed to the shell. If +args+ are included, the +command+ and +args+
+    # will be run directly without the shell.
     def run(command, args = nil)
       cmd = CommandLine.new(command, args)
       vputs(cmd)
       cmd.run
     end
 
+    # Run a command and capture the output like backticks. See #run
+    # for details.
     def run_capture(command, args = nil)
       CommandLine.new(command, args).capture
     end
 
+    # Run a command and suppress output by redirecting to /dev/null. See #run
+    # for details.
     def run_quietly(command, args = nil)
       cmd = CommandLine.new(command, args)
       run("#{cmd} > /dev/null 2> /dev/null")
     end
 
+    # Returns true if the command succeeds. See #run for details.
     def run_succeeds?(command, args = nil)
       begin
         run_quietly(command, args)
@@ -29,16 +42,19 @@ module Scripto
       end
     end
 
+    # Returns true if the command fails. See #run for details.
     def run_fails?(command, args = nil)
       !run_succeeds?(command, args)
     end
 
-    def shellescape(s)
-      Shellwords.escape(s)
+    # Escape str if necessary. Useful for passing arguments to a shell.
+    def shellescape(str)
+      Shellwords.escape(str)
     end
 
     protected
 
+    # :nodoc:
     class CommandLine
       attr_accessor :command, :args
 

data/lib/scripto/version.rb

@@ -1,3 +1,4 @@
 module Scripto
-  VERSION = "0.0.1"
+  # current Scripto version
+  VERSION = "0.0.2"
 end

data/scripto.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.0.0"
   spec.authors       = ["Adam Doppelt"]
   spec.email         = ["amd@gurge.com"]
-  spec.summary       = "Helpers for writing command line scripts."
+  spec.summary       = "Helpers for writing command line scripts. An extraction from Dwellable."
   spec.homepage      = "http://github.com/gurgeous/scripto"
   spec.license       = "MIT"
 

data/test/test_print.rb

@@ -11,14 +11,14 @@ class TestPrint < Minitest::Test
 
   def test_quiet
     assert_silent { Scripto.vbanner "gub" }
-    assert_silent { Scripto.vprintf "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 "gub" }
+    assert_output(nil, /gub/) { Scripto.vprintf("zub %s", "gub") }
     assert_output(nil, /gub/) { Scripto.vputs "gub" }
   end
 

data/vagrant_provision

@@ -0,0 +1,50 @@
+#!/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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scripto
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Adam Doppelt
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-11 00:00:00.000000000 Z
+date: 2014-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,6 +64,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- Vagrantfile
 - lib/scripto.rb
 - lib/scripto/csv_commands.rb
 - lib/scripto/file_commands.rb
@@ -79,6 +80,7 @@ files:
 - test/test_misc.rb
 - test/test_print.rb
 - test/test_run.rb
+- vagrant_provision
 homepage: http://github.com/gurgeous/scripto
 licenses:
 - MIT
@@ -102,7 +104,7 @@ rubyforge_project:
 rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
-summary: Helpers for writing command line scripts.
+summary: Helpers for writing command line scripts. An extraction from Dwellable.
 test_files:
 - test/helper.rb
 - test/test_csv.rb