doo 0.1.0

data/README.md

@@ -0,0 +1,38 @@
+## Just Doo It
+
+Doo is an experiment in taking a relentlessly polymorphic approach to deployment scripting. Like most deployment tools, doo lets you define executable blocks of deployment code independent of the configuration particulars that get bound into them at runtime. Where doo is different is in its succinctness (its core is just shy of 100 LoC), and in its use of polymorphism to realize stacking contexts. This lets you do useful things like defining configuration parameters on a project-wide, server-specific, and even task-specific level without having to rewrite (or doctor the hell out of) your deployment code.
+
+Because executable blocks are also polymorphic, you can mix and match provider blocks into your recipes. Want to have one deployment recipe for local and remote targets? No problem. Want to abstract away the particulars of your server's OS? We can do that, too.
+ 
+Doo layers a thin DSL on top of bare Ruby that facilitates polymorphic behaviour, and leans on a small number of built-in (and optional) deployment recipes to provide useful functionality.
+
+## Play With It
+
+    gem install doo
+
+Check out examples/sample.rb to get started.
+
+## LICENSE
+
+(The MIT License)
+
+Copyright (c) 2010 Mat Trudel
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,24 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.version
+    gem.name            = "doo"
+    gem.summary         = %Q{Doo - an stacked-cotnext approach to deployment scripting }
+    gem.description     = %Q{Doo is a deployment scripting tool in the vein of capistrano and sprinkle that uses stacked contexts and a aspect-ish data model}
+    gem.homepage        = "http://github.com/mtrudel/doo"
+    gem.authors         = [ "Mat Trudel" ]
+    gem.email           = [ "mat@geeky.net" ]
+    gem.executables     = %W(doo)
+    gem.files           = FileList["[A-Z]*", "{bin,examples,lib,spec}/**/*", 'lib/jeweler/templates/.gitignore']
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+desc "Run all tests"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+end
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/doo

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'doo/cli'
+
+Doo::CLI.start

data/examples/sample.rb

@@ -0,0 +1,37 @@
+# You can set options like so
+set :web, { :server => "example.com", :production => true }
+set :arg, "foo"
+
+# options can also be blocks, in which case they become callable
+set :show_uptime do
+  run "uptime"
+end
+
+# You can bind a variable's content into the current context like so
+using web # Now 'server' and 'production' will be top-level variables
+
+# You can run local commands inside a block
+run_locally do
+  run "echo #{arg}" # Will output 'foo'
+end
+
+# optionally giving the blocks overriding arguments
+run_locally :arg => "bar" do
+  run "echo #{arg}"# Will output 'bar'
+end
+
+# You can run a set of commands on a remote server like so
+run_on_server web do
+  run "whoami"  
+end
+# You can define servers as hashes or bare hostnames...
+run_on_server [web, "otherhost.com"] do
+  run "hostname"
+  # This runs the show_uptime block with the current set of variables
+  show_uptime  
+end
+
+# You can run a block into a file like so
+render_to_file 'sample.out' do
+  run "echo #{arg}" # Will ouput 'echo foo' to sample.out
+end

data/lib/doo/base.rb

@@ -0,0 +1,41 @@
+module Doo
+  class Base    
+    def load(filename)
+      instance_eval(File.read(filename), filename)
+    end
+
+    def initialize(variables = {})
+      using variables
+    end
+            
+    def using(variables = {})
+      variables.each { |k,v| set k, v }
+    end
+    
+    def set(k, v=nil, &block)
+      singleton_class.class_eval do
+        define_method k, (block_given?)? Proc.new { |*args|
+          if args.empty?
+            instance_eval &block
+          else
+            with_clone(args[0], &block)
+          end
+        } : lambda {v}
+      end
+    end
+    
+    def with_clone(variables = {}, &block)
+      obj = clone
+      obj.using variables
+      obj.instance_eval &block if block_given?
+      obj
+    end
+    
+    private
+    def singleton_class
+      class << self
+        self
+      end
+    end
+  end
+end

data/lib/doo/cli.rb

@@ -0,0 +1,55 @@
+require 'optparse'
+require 'doo'
+
+module Doo
+  module CLI
+    module Options
+      def self.parse!(args)
+        options = {}
+        optparse = OptionParser.new do |opts|
+          opts.banner = "Usage: doo [options] file1 file2 ..."
+          
+          options[:verbose] = false
+          opts.on( '-v', '--verbose', 'Output more information' ) do
+            options[:verbose] = true
+          end
+          
+          opts.on( '-s', '--set key=value', 'Set runtime values' ) do |arg|            
+            options[arg.split('=')[0]] = arg.split('=')[1]
+          end
+          
+          options[:dry_run] = false
+          opts.on( '-d', '--dry-run', 'Do a dry-run' ) do
+            options[:dry_run] = true
+          end
+          
+          opts.on( '-h', '--help', 'Display this screen' ) do
+            puts opts
+            exit
+          end
+        end
+        begin
+          optparse.parse!(args)
+          raise "You need to specify one or more files to process" if args.empty?
+        rescue 
+          puts $!
+          puts optparse
+          exit
+        end
+        
+        options
+      end
+    end
+  end
+end
+
+module Doo
+  module CLI
+    def self.start
+      inst = Doo::Base.new(Options.parse!(ARGV))
+      ARGV.each do |filename|
+        inst.load(filename)
+      end
+    end
+  end
+end

data/lib/doo/stock/prereqs.rb

@@ -0,0 +1,13 @@
+Doo::Base.class_eval do
+  def prereq(cmd)
+    raise PrerequisiteFailure unless run cmd == true
+  end
+  
+  def check_prereqs
+    begin
+      yield
+    rescue PrerequisiteFailure
+      puts "Pre-requisite test failed: ##{$!}"
+    end
+  end
+end

data/lib/doo/stock/render_to_file.rb

@@ -0,0 +1,16 @@
+Doo::Base.class_eval do
+  def render_to_file(filename, variables = {}, &block)
+    File.open(filename, 'w') do |file|
+      with_clone(variables) do
+        @file = file
+        def run(cmd)
+          puts "Rendering #{cmd}" if verbose
+          @file.puts cmd
+        end
+        check_prereqs do
+          instance_eval &block if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/doo/stock/run_locally.rb

@@ -0,0 +1,12 @@
+Doo::Base.class_eval do
+  def run_locally(variables = {}, &block)
+    with_clone(variables) do
+      def run(cmd)
+        puts "Running #{cmd}" if verbose
+        system cmd unless dry_run
+        $?
+      end
+      instance_eval &block if block_given?
+    end
+  end
+end

data/lib/doo/stock/run_on_server.rb

@@ -0,0 +1,38 @@
+SshCommand = "ssh -S '~/.ssh/master-%l-%r@%h:%p'"
+Doo::Base.class_eval do
+  def run_on_server(servers, variables = {}, &block)
+    [servers].flatten.each do |server|
+      with_clone(server.is_a?(Hash)? variables.merge(server) : variables) do
+        @host = server.is_a?(Hash)? server[:server] : server
+        def run(cmd, opt = {})
+          puts "Running ssh #{(!opt.include? :pty || opt[:pty])? '-t' : ''} #{@host} \"#{cmd}\"" if verbose
+          system("#{SshCommand} #{(!opt.include? :pty || opt[:pty])? '-t' : ''} #{@host} \"#{cmd}\"") || raise("SSH Error") unless dry_run
+          $?
+        end
+      
+        def put(local, remote)
+          puts "scp -r \"#{local}\" \"#{@host}:#{remote}\"" if verbose
+          system("scp -r \"#{local}\" \"#{@host}:#{remote}\"") || raise("SSH Error") unless dry_run
+          $?
+        end
+      
+        begin
+          system("#{SshCommand} -MNf #{@host}") || raise("SSH Error") unless dry_run
+          instance_eval &block if block_given?
+        ensure
+          system("#{SshCommand} -Oexit #{@host}") || raise("SSH Error") unless dry_run
+        end
+      end
+    end
+  end
+end
+
+Array.class_eval do
+  def with_role(role)
+    select { |obj| [obj[:role]].flatten.member? role }
+  end
+  
+  def except_role(role)
+    reject { |obj| [obj[:role]].flatten.member? role }
+  end
+end

data/lib/doo.rb

@@ -0,0 +1,7 @@
+require "doo/base"
+
+require 'doo/stock/common'
+require 'doo/stock/prereqs'
+require 'doo/stock/render_to_file'
+require 'doo/stock/run_locally'
+require 'doo/stock/run_on_server'

data/spec/doo/base_spec.rb

@@ -0,0 +1,73 @@
+require 'tempfile'
+require 'doo/base'
+
+describe Doo::Base do
+  
+  before :each do
+    @inst = Doo::Base.new
+  end
+  
+  it "can read in other files" do
+    @inst.should_receive("spamcan").once
+    Tempfile.open(nil) do |tmpfile|
+      tmpfile.puts("spamcan")
+      tmpfile.rewind
+      @inst.load(tmpfile.path)
+    end    
+  end
+  
+  it "sets itself up properly" do
+    inst = Doo::Base.new(:extra => "cheeps")    
+    inst.should respond_to :extra
+    inst.extra.should == "cheeps"
+  end  
+
+  it "knows how to add context to itself" do
+    @inst.using(:extra => "ham")
+    @inst.should respond_to :extra
+    @inst.extra.should == "ham"
+  end
+  
+  it "knows how to set a variable" do
+    @inst.set :extra, "bologna"
+    @inst.should respond_to :extra
+    @inst.extra.should == "bologna"
+  end
+  
+  it "knows how to set a block" do
+    @inst.set :extra do
+      its_not_real_meat
+    end
+    @inst.should respond_to :extra
+    @inst.should_receive(:its_not_real_meat).exactly(1).times
+    @inst.extra
+  end
+  
+  it "returns a clone of itself" do
+    @inst.instance_eval do
+      def something_extra
+        "bacon"
+      end
+    end
+    @inst.with_clone.something_extra.should == "bacon"
+  end
+  
+  it "runs code in a clone" do
+    @inst.instance_eval do
+      def something_extra
+        "bacon"
+      end
+    end
+    @inst.with_clone do      
+      something_extra.should == "bacon"
+    end
+    @inst.should_receive(:something_extra).exactly(0).times
+  end
+  
+  it "sets variables in the clone but not in itself" do
+    @inst.with_clone(:extra => "fries") do
+      extra.should == "fries"
+    end
+    @inst.should_not respond_to :extra
+  end
+end

data/spec/doo/cli_spec.rb

@@ -0,0 +1,38 @@
+require 'doo/cli'
+
+describe Doo::CLI::Options do
+  it "should message and error on no args" do
+    lambda { Doo::CLI::Options.parse!([]) }.should raise_error SystemExit
+  end
+
+  it "should message and error on --help" do
+    lambda { Doo::CLI::Options.parse!(["--help"]) }.should raise_error SystemExit
+  end
+
+  it "should set on --dry-run" do
+    Doo::CLI::Options.parse!(["-d", "foo"]).member?(:dry_run).should == true
+  end
+
+  it "should set on --verbose" do
+    Doo::CLI::Options.parse!(["-v", "foo"]).member?(:verbose).should == true
+  end
+
+  it "should set variables" do
+    Doo::CLI::Options.parse!(["-swoz=bar", "foo"])["woz"].should == "bar"
+  end
+
+  it "should pull off varialbes and leave files" do
+    args = ["-d", "foo", "bar"]
+    Doo::CLI::Options.parse!(args)
+    args.should == ["foo", "bar"]
+  end
+
+  it "should run all files" do
+    ARGV = ["-d", "foo", "bar"]
+    inst = Doo::Base.new
+    Doo::Base.should_receive(:new).and_return inst
+    inst.should_receive(:load).with("foo")
+    inst.should_receive(:load).with("bar")        
+    Doo::CLI.start
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: doo
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mat Trudel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-15 00:00:00 -04:00
+default_executable: doo
+dependencies: []
+
+description: Doo is a deployment scripting tool in the vein of capistrano and sprinkle that uses stacked contexts and a aspect-ish data model
+email: 
+- mat@geeky.net
+executables: 
+- doo
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- Rakefile
+- VERSION
+- bin/doo
+- examples/sample.rb
+- lib/doo.rb
+- lib/doo/base.rb
+- lib/doo/cli.rb
+- lib/doo/stock/common.rb
+- lib/doo/stock/prereqs.rb
+- lib/doo/stock/render_to_file.rb
+- lib/doo/stock/run_locally.rb
+- lib/doo/stock/run_on_server.rb
+- spec/doo/base_spec.rb
+- spec/doo/cli_spec.rb
+has_rdoc: true
+homepage: http://github.com/mtrudel/doo
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Doo - an stacked-cotnext approach to deployment scripting
+test_files: 
+- spec/doo/base_spec.rb
+- spec/doo/cli_spec.rb
+- examples/sample.rb