webbynode-mason 0.1.0

data/README.md

@@ -0,0 +1,72 @@
+# Mason
+
+Build things
+
+	$ gem install mason
+
+### Install buildpacks locally
+
+	$ mason buildpacks
+	* buildpacks (~/.mason/buildpacks)
+	  = nodejs: https://github.com/heroku/heroku-buildpack-nodejs.git
+	  = ruby: https://github.com/ddollar/heroku-buildpack-ruby.git
+
+	$ mason buildpacks:install https://github.com/heroku/heroku-buildpack-python.git
+	* installing buildpack https://github.com/heroku/heroku-buildpack-python.git
+
+### Use buildpacks to build things
+
+	$ mason build /tmp/app
+	* detecting buildpack... done
+	  = name: Ruby
+	  = url: https://github.com/heroku/heroku-buildpack-ruby.git
+	* compiling:
+	... COMPILE OUTPUT
+	* packaging... done
+	  = type: dir
+	  = file: /tmp/mason.out
+
+	$ mason build /tmp/app -t dir -o /tmp/compiledapp
+	* detecting buildpack... done
+	  = name: Ruby
+	  = url: https://github.com/heroku/heroku-buildpack-ruby.git
+	* compiling...
+	... COMPILE OUTPUT
+	* packaging... done
+	  = type: dir
+	  = dir: /tmp/compiledapp
+
+	$ mason build /tmp/app -b https://github.com/ddollar/buildpack-other.git -t tgz
+	* detecting buildpack... done
+	  = name: Other
+	  = url: https://github.com/ddollar/buildpack-other.git
+	* compiling...
+	... COMPILE OUTPUT
+	* packaging... done
+	  = type: tgz
+	  = file: /tmp/app.tgz
+
+### Build things for other platforms using Vagrant
+
+You will need [VirtualBox](https://www.virtualbox.org/wiki/Downloads) for Vagrant to function.
+
+	$ gem install vagrant
+
+	$ vagrant box add lucid64 http://files.vagrantup.com/lucid64.box
+
+    $ mason stacks:create lucid64
+    * creating stack lucid64... done
+
+    $ mason stacks:up lucid64
+    * booting stack lucid64 (this may take a while)... done
+
+    $ mason:build /tmp/app -t tgz -o /tmp/compiled.tgz -s lucid64
+    * booting stack lucid64 (this may take a while)... done
+	* detecting buildpack... done
+	  = name: Baz
+	  = url: https://github.com/ddollar/buildpack-baz.git
+	* compiling...
+	... COMPILE OUTPUT
+	* packaging... done
+	  = type: tgz
+	  = dir: /tmp/compiled.tgz

data/bin/mason

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path("../../lib", __FILE__)
+
+require "mason/cli"
+
+begin
+  Mason::CLI.run
+rescue Errno::EPIPE
+rescue Mason::CommandFailed => ex
+end

data/data/Vagrantfile.template

@@ -0,0 +1,5 @@
+Vagrant::Config.run do |config|
+  config.vagrant.dotfile_name = File.expand_path("~/.mason/vagrant")
+
+BOXES
+end

data/lib/mason.rb

@@ -0,0 +1,5 @@
+module Mason
+
+  class CommandFailed < StandardError; end
+
+end

data/lib/mason/buildpack.rb

@@ -0,0 +1,98 @@
+require "mason"
+require "tmpdir"
+require "yaml"
+require "foreman/engine"
+
+class Mason::Buildpack
+
+  attr_reader :dir, :name, :url
+
+  def initialize(dir)
+    @dir = dir
+    Dir.chdir(@dir) do
+      @name = File.basename(@dir)
+      @url  = %x{ git config remote.origin.url }.chomp
+    end
+  end
+
+  def <=>(other)
+    self.name <=> other.name
+  end
+
+  def detect(app)
+    mkchtmpdir do
+      output = %x{ #{script("detect")} "#{app}" }
+      $?.exitstatus.zero? ? output.chomp : nil
+    end
+  end
+
+  def compile(app, env_file=nil, cache=nil)
+    cache_dir = cache || "#{app}/.git/cache"
+    puts "  caching in #{cache_dir}"
+    compile_dir = Dir.mktmpdir
+    FileUtils.rm_rf compile_dir
+    FileUtils.cp_r app, compile_dir, :preserve => true
+    FileUtils.mkdir_p cache_dir
+    Dir.chdir(compile_dir) do
+      IO.popen(%{ #{script("compile")} "#{compile_dir}" "#{cache_dir}" }) do |io|
+        until io.eof?
+          data = io.gets
+          data.gsub!(/^-----> /, "  + ")
+          data.gsub!(/^       /, "      ")
+          data.gsub!(/^\s+\!\s+$/, "")
+          data.gsub!(/^\s+\!\s+/, "  ! ")
+          data.gsub!(/^\s+$/, "")
+          print data
+        end
+      end
+      raise "compile failed" unless $?.exitstatus.zero?
+    end
+    release = YAML.load(`#{script('release')} "#{compile_dir}"`)
+    write_env(compile_dir, release, env_file)
+    write_procfile(compile_dir, release)
+    compile_dir
+  end
+
+private
+
+  def write_env(compile_dir, release, env_file)
+    env = env_file ? Foreman::Engine.new.load_env(env_file) : {}
+    config = release["config_vars"].merge(env)
+
+    File.open(File.join(compile_dir, ".env"), "w") do |f|
+      f.puts config.map{|k, v| "#{k}=#{v}"}.join("\n")
+    end
+  end
+
+  def write_procfile(compile_dir, release)
+    filename = File.join(compile_dir, "Procfile")
+    process_types = release["default_process_types"] || {}
+
+    if File.exists? filename
+      Foreman::Procfile.new(filename).entries do |name, command|
+        process_types[name] = command
+      end
+    end
+
+    File.open(filename, "w") do |f|
+      process_types.each do |name, command|
+        f.puts "#{name}: #{command}"
+      end
+    end
+  end
+
+  def mkchtmpdir
+    ret = nil
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) do
+        ret = yield(dir)
+      end
+    end
+    ret
+  end
+
+  def script(name)
+    File.join(dir, "bin", name)
+  end
+end
+

data/lib/mason/buildpacks.rb

@@ -0,0 +1,75 @@
+require "fileutils"
+require "mason"
+require "mason/buildpack"
+require "uri"
+require "digest/sha1"
+
+class Mason::Buildpacks
+
+  def self.install(url, ad_hoc=false)
+    root_dir = ad_hoc ? ad_hoc_root : root
+    FileUtils.mkdir_p root_dir
+
+    Dir.chdir(root_dir) do
+      uri = URI.parse(url)
+      if uri.path =~ /buildpack-(\w+)/
+        name = $1
+        name += "-#{Digest::SHA1.hexdigest(url).to_s[0 .. 8]}" if ad_hoc
+        branch = uri.fragment || "master"
+        if File.exists?(name)
+          # Can't do a fetch here as it won't update local branches
+          system "cd #{name} && git checkout master && git pull"
+          raise "failed to update buildpack checkout" unless $?.exitstatus.zero?
+        else
+          system "git clone #{url.split('#').first} #{name} >/dev/null 2>&1"
+          raise "failed to clone buildpack" unless $?.exitstatus.zero?
+        end
+        system "cd #{name} && git checkout #{branch} 2> /dev/null"
+        raise "failed to check out branch #{branch}" unless $?.exitstatus.zero?
+        File.expand_path(root_dir + "/" + name)
+      else
+        raise "BUILDPACK should be a url containing buildpack-NAME.git"
+      end
+    end
+  end
+
+  def self.uninstall(name)
+    Dir.chdir(root) do
+      raise "#{name} buildpack is not installed" unless File.exists?(name)
+      FileUtils.rm_rf name
+    end
+  end
+
+  def self.root(ad_hoc=false, expand=true)
+    dir = "~/.mason/buildpacks"
+    expand ? File.expand_path(dir) : dir
+  end
+
+  def self.ad_hoc_root(expand=true)
+    dir = "~/.mason/buildpacks-ad-hoc"
+    expand ? File.expand_path(dir) : dir
+  end
+
+  def self.buildpacks
+    @buildpacks ||= begin
+      Dir[File.join(root, "*")].map do |buildpack_dir|
+        Mason::Buildpack.new(buildpack_dir)
+      end
+    end
+  end
+
+  def self.detect(app, buildpack_url)
+    if buildpack_url
+      puts "Using $BUILDPACK_URL: #{buildpack_url}"
+      buildpack_dir = install(buildpack_url, true)
+      return Mason::Buildpack.new(buildpack_dir)
+    else
+      buildpacks.each do |buildpack|
+        ret = buildpack.detect(app)
+        return [buildpack, ret] if ret
+      end
+    end
+    nil
+  end
+
+end

data/lib/mason/cli.rb

@@ -0,0 +1,279 @@
+require "mason"
+require "mason/buildpacks"
+require "mason/stacks"
+require "mason/version"
+require "thor"
+require "thor/shell/basic"
+
+class Mason::CLI < Thor
+
+  class_option :debug, :type => :boolean, :desc => "show backtraces"
+  class_option :help, :type => :boolean, :aliases => "-h", :desc => "help for this command"
+
+  map %w( -v -V --version ) => :version
+
+  desc "version", "display version"
+
+  def version
+    puts "mason v#{Mason::VERSION}"
+  end
+
+  desc "build APP", "build an app"
+
+  method_option :buildpack, :type => :string, :aliases => "-b", :desc => "use a custom buildpack"
+  method_option :output,    :type => :string, :aliases => "-o", :desc => "output location"
+  method_option :quiet,     :type => :boolean, :aliases => "-q", :desc => "quiet packaging output"
+  method_option :stack,     :type => :string, :aliases => "-s", :desc => "use a stack for building"
+  method_option :type,      :type => :string, :aliases => "-t", :desc => "output type (dir, img, tgz)"
+  method_option :env_file,  :type => :string, :aliases => "-e", :desc => "config environment file"
+  method_option :cache,     :type => :string, :aliases => "-c", :desc => "cache directory"
+
+  def build(app)
+    app = File.expand_path(app)
+
+    raise "no such directory: #{app}" unless File.exists?(app)
+
+    type = options[:type]
+    output = options[:output]
+
+    type = File.extname(output)[1..-1] if !type && output
+    output = "#{app}.#{type}" if !output && type
+
+    type   ||= "dir"
+    output ||= "/tmp/mason.out"
+
+    output = File.expand_path(output)
+
+    raise "no such output format: #{type}" unless %w( dir img tgz ).include?(type)
+
+    if stack = options[:stack]
+      if Mason::Stacks.state(stack) == :up
+        puts "* using stack #{stack}"
+      else
+        print "* booting stack #{stack} (this may take a while)... "
+        Mason::Stacks.up(stack)
+        puts "done"
+      end
+
+      buildpacks_dir = File.expand_path("~/.mason/share/#{stack}/buildpacks")
+      compile_dir = File.expand_path("~/.mason/share/#{stack}/app")
+      mason_dir = File.expand_path("~/.mason/share/#{stack}/mason")
+
+      FileUtils.rm_rf buildpacks_dir
+      FileUtils.rm_rf compile_dir
+      FileUtils.rm_rf mason_dir
+
+      FileUtils.cp_r(File.expand_path("~/.mason/buildpacks"), buildpacks_dir,
+                     :preserve => true)
+      FileUtils.cp_r(File.expand_path("../../../", __FILE__), mason_dir,
+                     :preserve => true)
+      FileUtils.cp_r(app, compile_dir, :preserve => true)
+
+      mason_args =  %{ /share/app -q -o /share/output -t #{type} }
+      mason_args += %{ -b "#{options[:buildpack]}" } if options[:buildpack]
+
+      Mason::Stacks.run(stack, <<-COMMAND)
+        gem spec thor 2>&1 >/dev/null || sudo gem install thor
+        /usr/bin/env ruby -rubygems /share/mason/bin/mason build #{mason_args}
+      COMMAND
+
+      FileUtils.rm_rf output
+      FileUtils.cp_r(File.expand_path("~/.mason/share/#{stack}/output"), output,
+                     :preserve => true)
+
+      puts "* packaging"
+      puts "  = type: #{type}"
+      puts "  = location: #{output}"
+    else
+      print "* detecting buildpack... "
+
+      buildpack_url = ENV["BUILDPACK_URL"] || options[:buildpack]
+      buildpack, ret = Mason::Buildpacks.detect(app, buildpack_url)
+      raise "no valid buildpack detected" unless buildpack
+
+      puts "done"
+      puts "  = name: #{buildpack.name}"
+      puts "  = url: #{buildpack.url}"
+      puts "  = display: #{ret}"
+
+      puts "* compiling..."
+      compile_dir = buildpack.compile(app, options[:env_file], options[:cache])
+
+      print "* packaging... " unless options[:quiet]
+      case type.to_sym
+      when :tgz then
+        Dir.chdir(compile_dir) do
+          system %{ tar czf "#{output}" . }
+        end
+      when :img then
+        raise "img not supported yet"
+      when :dir then
+        FileUtils.rm_rf output
+        FileUtils.cp_r compile_dir, output, :preserve => true
+      else
+        raise "no such output type: #{type}"
+      end
+
+      unless options[:quiet]
+        puts "done"
+        puts "  = type: #{type}"
+        puts "  = location: #{output}"
+      end
+    end
+
+  end
+
+  desc "vagrant COMMAND", "run a vagrant command in the mason environment"
+
+  def vagrant(*args)
+    Mason::Stacks.vagrant(args)
+  end
+
+  desc "buildpacks", "list installed buildpacks"
+
+  def buildpacks
+    buildpacks = Mason::Buildpacks.buildpacks
+
+    puts "* buildpacks (#{Mason::Buildpacks.root(false)})"
+    buildpacks.sort.each do |buildpack|
+      puts "  = #{buildpack.name}: #{buildpack.url}"
+    end
+
+    puts "  - no buildpacks installed, use buildpacks:install" if buildpacks.length.zero?
+  end
+
+  class Buildpacks < Thor
+
+    desc "buildpacks:install URL", "install a buildpack"
+
+    def install(url)
+      puts "* installing buildpack #{url}"
+      Mason::Buildpacks.install url
+    end
+
+    desc "buildpacks:uninstall NAME", "uninstall a buildpack"
+
+    def uninstall(name)
+      puts "* uninstalling buildpack #{name}"
+      Mason::Buildpacks.uninstall name
+    end
+
+  end
+
+  desc "stacks", "list available stacks"
+
+  def stacks
+    stacks = Mason::Stacks.stacks
+
+    puts "* available stacks"
+    stacks.keys.each do |name|
+      puts "  - #{name} [#{Mason::Stacks.state(name)}]"
+    end
+
+    puts "  - no stacks created, use stacks:create" if stacks.length.zero?
+  end
+
+  class Stacks < Thor
+
+    # Hackery. Take the run method away from Thor so that we can redefine it.
+    class << self
+      def is_thor_reserved_word?(word, type)
+        return false if word == 'run'
+        super
+      end
+    end
+
+    desc "stacks:create VAGRANT_BOX_NAME", "create a new stack"
+
+    method_option :name, :type => :string, :aliases => "-n", :desc => "use an alternate stack name"
+
+    def create(box)
+      name = options[:name] || box
+      print "* creating stack #{name}... "
+      Mason::Stacks.create(name, box)
+      puts "done"
+    end
+
+    desc "stacks:destroy STACK", "destroy a stack"
+
+    def destroy(name)
+      print "* destroying stack #{name}... "
+      Mason::Stacks.destroy(name)
+      puts "done"
+    end
+
+    desc "stacks:up STACK", "boot a stack"
+
+    def up(name)
+      print "* booting stack #{name} (this will take a while)..."
+      Mason::Stacks.up(name)
+      puts "done"
+    end
+
+    desc "stacks:down STACK", "suspend a stack"
+
+    def down(name)
+      print "* stopping stack #{name}..."
+      Mason::Stacks.down(name)
+      puts "done"
+    end
+
+    desc "stacks:run STACK COMMAND", "run a command on a stack"
+
+    def run(name, *args)
+      Mason::Stacks.run(name, args.join(" "))
+    end
+
+  end
+
+  # hack thor
+  def self.run
+    args   = ARGV.dup
+    parts  = args.first.to_s.split(":")
+    method = parts.pop
+    ns     = parts.pop
+
+    args[0] = method
+
+    klass = case ns
+      when "buildpacks" then Buildpacks
+      when "stacks"     then Stacks
+      else self
+    end
+
+    unless (args & %w( -h --help )).empty?
+      klass.task_help(Thor::Shell::Basic.new, args.first)
+      return
+    end
+
+    klass.start(args)
+  rescue StandardError => ex
+    $stderr.puts "  ! #{ex}"
+    $stderr.puts "  " + ex.backtrace.join("\n  ") if ARGV.include?("--debug")
+    exit 1
+  end
+
+private
+
+  def vagrantfile
+    FileUtils.mkdir_p File.expand_path("~/.mason")
+    file = File.expand_path("~/.mason/Vagrantfile")
+    build_vagrantfile unless File.exists?(file)
+    file
+  end
+
+  def build_vagrantfile(boxes={})
+    data = File.read(File.expand_path("../../../data/Vagrantfile.template", __FILE__))
+    data.gsub! "BOXES", (boxes.map do |name, box|
+      <<-BOX
+        config.vm.define :#{name} do |config|
+          config.vm.box = "#{box}"
+        end
+      BOX
+    end.join("\n"))
+    File.open(File.expand_path("~/.mason/Vagrantfile"), "w") do |file|
+      file.puts data
+    end
+  end
+
+end

data/lib/mason/stacks.rb

@@ -0,0 +1,113 @@
+require "fileutils"
+require "mason"
+
+class Mason::Stacks
+
+  def self.load_vagrant!
+    require "vagrant"
+    if Gem::Version.new(Vagrant::VERSION) < Gem::Version.new("1.0.1")
+      raise "mason requires vagrant 1.0.1 or higher"
+    end
+    build_vagrantfile unless File.exists?(vagrantfile)
+  end
+
+  def self.vagrant_env(display=false)
+    load_vagrant!
+    ui = display ? Vagrant::UI::Basic : nil
+    Vagrant::Environment.new(:vagrantfile_name => vagrantfile, :ui_class => ui)
+  end
+
+  def self.vms
+    vagrant_env.vms
+  end
+
+  def self.vagrant(args)
+    vagrant_env(true).cli(args)
+  end
+
+  def self.stacks
+    @stacks ||= begin
+      vms.inject({}) do |hash, (name, vm)|
+        next(hash) if name == :default
+        hash.update(name => vm.box ? vm.box.name : "")
+      end
+    end
+  end
+
+  def self.create(name, box)
+    raise "stack already exists: #{name}" if stacks.keys.include?(name.to_sym)
+    raise "vagrant box does not exist: #{box}" unless vagrant_env.boxes.map(&:name).include?(box)
+    build_vagrantfile(stacks.update(name => box))
+  end
+
+  def self.destroy(name)
+    raise "no such stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    vm = vms[name.to_sym]
+    vm.halt rescue nil
+    vm.destroy rescue nil
+    s = stacks
+    s.delete(name.to_sym)
+    build_vagrantfile(s)
+  end
+
+  def self.state(name)
+    raise "no such stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    case vms[name.to_sym].state.to_sym
+      when :running then :up
+      else               :down
+    end
+  end
+
+  def self.up(name)
+    raise "no such stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    return if state(name) == :up
+    vms[name.to_sym].up
+  end
+
+  def self.down(name)
+    raise "no such stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    return if state(name) == :down
+    vms[name.to_sym].suspend
+  end
+
+  def self.run(name, command)
+    raise "no suck stack: #{name}" unless stacks.keys.include?(name.to_sym)
+    vms[name.to_sym].channel.execute(command, :error_check => false) do |type, data|
+      print data
+    end
+  end
+
+  def self.vagrantfile
+    File.expand_path("~/.mason/Vagrantfile")
+  end
+
+  def self.vagrantfile_template
+    File.expand_path("../../../data/Vagrantfile.template", __FILE__)
+  end
+
+  def self.share_dir(name)
+    dir = File.expand_path("~/.mason/share/#{name}")
+    FileUtils.mkdir_p dir unless File.exists?(dir)
+    dir
+  end
+
+  def self.build_vagrantfile(stacks={})
+    data = File.read(vagrantfile_template)
+    ip_base = 3
+    data.gsub! "BOXES", (stacks.map do |name, box|
+      ip_base += 1
+      <<-BOX
+  config.vm.define :#{name} do |config|
+    config.vm.box = "#{box}"
+    config.vm.base_mac = "080027706AA#{ip_base}"
+    config.vm.network :hostonly, "33.33.33.#{ip_base}"
+    config.vm.share_folder "share", "/share", "#{share_dir(name)}"
+  end
+      BOX
+    end.join("\n").chomp)
+    File.open(vagrantfile, "w") do |file|
+      file.puts data
+    end
+  end
+
+end

data/lib/mason/version.rb

@@ -0,0 +1,3 @@
+module Mason
+  VERSION = "0.1.0"
+end

data/spec/buildpack_spec.rb

@@ -0,0 +1,23 @@
+require './lib/mason/buildpack'
+
+describe Mason::Buildpack do
+  let(:tempdir) { Dir.tmpdir }
+
+  subject { Mason::Buildpack.new("/tmp") }
+
+  before do
+    FileUtils.mkdir_p tempdir
+  end
+
+  after do
+    FileUtils.rm_rf tempdir
+  end
+
+  describe "#write_procfile" do
+    it "uses Foreman to create the Procfile" do
+      File.open("#{tempdir}/Procfile", "w+") { |f| f.puts "web: ls -la" }
+      subject.send :write_procfile, tempdir, {}
+      File.read("#{tempdir}/Procfile").should =~ /web: ls -la/
+    end
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: webbynode-mason
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- David Dollar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: foreman
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.53.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.53.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+description: Build things
+email: ddollar@gmail.com
+executables:
+- mason
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/mason
+- data/Vagrantfile.template
+- lib/mason/buildpack.rb
+- lib/mason/buildpacks.rb
+- lib/mason/cli.rb
+- lib/mason/stacks.rb
+- lib/mason/version.rb
+- lib/mason.rb
+- README.md
+- spec/buildpack_spec.rb
+homepage: http://github.com/ddollar/mason
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Build things
+test_files: []