hsume2-cap-taffy 0.0.2 → 1.0.0

data/History.txt

@@ -1,8 +1,4 @@
-== 0.0.2 / 2009-09-14
-* 1 minor enhancement
-  * Added authorizing SSH public keys on remote server(s).
-
-== 0.0.1 / 2009-09-14
+== 1.0.0 / 2009-09-14
 
 * 1 major enhancement
   * Initial release.

data/README.md

@@ -7,7 +7,6 @@ Features
 ------------------------------------------------
 
 * Adds database transfer recipes (via [`Taps`]("http://github.com/ricardochimal/taps"))
-* Authorize SSH access
 * Manage `database.yml` (Soon.)
 
 [`Taps`]("http://github.com/ricardochimal/taps") is great, but having to SSH into my deployment to run the `Taps` server, as well as 
@@ -21,9 +20,11 @@ Installation
 
     gem install cap-taffy
 
-Database Transfer
+Usage
 ------------------------------------------------
 
+### `Taffy`: Database Transfer
+
 > _Dependency:_ The [`Taps`]("http://github.com/ricardochimal/taps") gem is required on any server(s) you'll be transferring databases to (`:app` role) including your development machine (where you'll be running `cap` tasks from). Run:
 
 >     gem install taps
@@ -32,8 +33,6 @@ Database Transfer
 
 >     gem install heroku
 
-### Usage
-
 To start, add the following to your `Capfile`
 
     require 'cap-taffy/db'
@@ -59,22 +58,7 @@ Then you can use:
 > >     ssh -N -L4321:127.0.0.1:4321 henry@load-test
 > >     cap db:push -s taps_port=4321 -s local=true
 
-SSH Access
-------------------------------------------------
-
-#### Usage
-
-Add the following to your `Capfile`
-
-    require 'cap-taffy/ssh'
-
-Using a public key generated from `ssh-keygen` (e.g. `ssh-keygen -t rsa`), to authorize access:
-
-    cap ssh:authorize       # authorizes local public key for SSH access to remote server(s)
-
-
-Managing `database.yml`
-------------------------------------------------
+### Managing `database.yml`
 
 > Much needed and coming soon.
 

data/Rakefile

@@ -26,7 +26,6 @@ PROJ.version = CapTaffy::VERSION
 PROJ.rubyforge.name = 'cap-taffy'
 PROJ.readme_file = "README.md"
 PROJ.gem.dependencies = ['heroku', 'taps', 'capistrano']
-PROJ.gem.development_dependencies << ["mocha"]
 PROJ.description = "Capistrano recipes for deploying databases and other common tasks."
 PROJ.summary = "Capistrano recipes for deploying databases (managing database.yml, importing/exporting/transfering databases, etc.)"
 PROJ.ignore_file = '.gitignore'

data/cap-taffy.gemspec

@@ -2,15 +2,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cap-taffy}
-  s.version = "0.0.2"
+  s.version = "1.0.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Henry Hsu"]
-  s.date = %q{2009-09-17}
+  s.date = %q{2009-09-14}
   s.description = %q{Capistrano recipes for deploying databases and other common tasks.}
   s.email = %q{henry@qlane.com}
   s.extra_rdoc_files = ["History.txt"]
-  s.files = ["History.txt", "README.md", "Rakefile", "cap-taffy.gemspec", "lib/cap-taffy.rb", "lib/cap-taffy/db.rb", "lib/cap-taffy/parse.rb", "lib/cap-taffy/ssh.rb", "spec/cap-taffy/db_spec.rb", "spec/cap-taffy/parse_spec.rb", "spec/cap-taffy/ssh_spec.rb", "spec/cap-taffy_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  s.files = ["History.txt", "README.md", "Rakefile", "cap-taffy.gemspec", "lib/cap-taffy.rb", "lib/cap-taffy/db.rb", "lib/cap-taffy/parse.rb", "spec/cap-taffy/db_spec.rb", "spec/cap-taffy/parse_spec.rb", "spec/cap-taffy_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
   s.homepage = %q{http://by.qlane.com}
   s.rdoc_options = ["--main", "README.md"]
   s.require_paths = ["lib"]
@@ -27,19 +27,16 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<taps>, [">= 0"])
       s.add_runtime_dependency(%q<capistrano>, [">= 0"])
       s.add_development_dependency(%q<bones>, [">= 2.5.1"])
-      s.add_development_dependency(%q<mocha>, [">= 0"])
     else
       s.add_dependency(%q<heroku>, [">= 0"])
       s.add_dependency(%q<taps>, [">= 0"])
       s.add_dependency(%q<capistrano>, [">= 0"])
       s.add_dependency(%q<bones>, [">= 2.5.1"])
-      s.add_dependency(%q<mocha>, [">= 0"])
     end
   else
     s.add_dependency(%q<heroku>, [">= 0"])
     s.add_dependency(%q<taps>, [">= 0"])
     s.add_dependency(%q<capistrano>, [">= 0"])
     s.add_dependency(%q<bones>, [">= 2.5.1"])
-    s.add_dependency(%q<mocha>, [">= 0"])
   end
 end

data/lib/cap-taffy/db.rb

@@ -6,49 +6,30 @@ rescue LoadError
   error "Install the Taps gem to use db commands. On most systems this will be:\nsudo gem install taps"
 end
 
-require File.join(File.dirname(__FILE__), %w[.. cap-taffy]) unless defined?(CapTaffy)
 require File.join(File.dirname(__FILE__), 'parse')
 require 'digest/sha1'
 
 module CapTaffy::Db
   extend self
 
-  # Detects the local database url for +env+.
-  #
-  # Looks for <tt>config/database.yml</tt>.
-  def local_database_url(env)
+  def local(env)
     return "" unless File.exists?(Dir.pwd + '/config/database.yml')
     db_config = YAML.load(File.read(Dir.pwd + '/config/database.yml'))
 
     CapTaffy::Parse.database_url(db_config, env)
   end
 
-  # Detects the remote database url for +env+ and the current Capistrano +instance+.
-  #
-  # Looks for <tt>config/database.yml</tt> in the +current_path+.
-  def remote_database_url(instance, env)
+  def remote(instance, env)
     db_yml = instance.capture "cat #{instance.current_path}/config/database.yml"
     db_config = YAML::load(db_yml)
 
     CapTaffy::Parse.database_url(db_config, env)
   end
 
-  # The default server port the Taps server is started on.
   def default_server_port
     5000
   end
 
-  # Generates the remote url used by Taps push/pull.
-  #
-  # ==== Parameters
-  # 
-  # * <tt>:login, :password, :host, :port</tt> - See #run.
-  #
-  # ==== Examples
-  #
-  #   login = fetch(:user)
-  #   password = tmp_pass(login)                                               # returns asdkf239udjhdaks (for example)
-  #   remote_url(:login => login, :password => password, :host => 'load-test') # returns http://henry:asdkf239udjhdaks@load-test:5000
   def remote_url(options={})
     host = options[:host]
     port = options[:port] || default_server_port
@@ -58,15 +39,11 @@ module CapTaffy::Db
     url.sub(/\/$/, '')
   end
 
-  # Generates a temporary password to be used for the Taps server command.
   def tmp_pass(user)
     Digest::SHA1.hexdigest("--#{Time.now.to_s}--#{user}--")
   end
 
-  # A quick start for a Taps client.
-  #
-  # <tt>local_database_url</tt> and <tt>remote_url</tt> refer to the options for the Taps gem (see #run).
-  def taps_client(local_database_url, remote_url, &blk) # :yields: client
+  def taps_client(local_database_url, remote_url, &blk)
     Taps::Config.chunksize = 1000
     Taps::Config.database_url = local_database_url
     Taps::Config.remote_url = remote_url
@@ -77,11 +54,7 @@ module CapTaffy::Db
     end
   end
 
-  # Generates the server command used to start a Taps server
-  #
-  # ==== Parameters
-  # * <tt>:remote_database_url, :login, :password</tt> - See #run.
-  # * <tt>:port</tt> - The +port+ the Taps server is on. If given and different from #default_server_port, appends <tt>--port=[port]</tt> to command.
+  # server <local_database_url> <login> <password> [--port=N]
   def server_command(options={})
     remote_database_url, login, password, port = options[:remote_database_url], options[:login], options[:password], options[:port]
     port_argument = ''
@@ -90,37 +63,7 @@ module CapTaffy::Db
     "taps server #{remote_database_url} #{login} #{password}#{port_argument}"
   end
 
-  # The meat of the operation. Runs operations after setting up the Taps server.
-  # 
-  # 1. Runs the <tt>taps</tt> taps command to start the Taps server (assuming Sinatra is running on Thin)
-  # 2. Wait until the server is ready 
-  # 3. Execute block on Taps client
-  # 4. Close the connection(s) and bid farewell.
-  #
-  # ==== Parameters
-  # * <tt>:remote_database_url</tt> - Refers to local database url in the options for the Taps server command (see Taps Options).
-  # * <tt>:login</tt> - The login for +host+. Usually what's in <tt>set :user, "the user"</tt> in <tt>deploy.rb</tt>
-  # * <tt>:password</tt> - The temporary password for the Taps server.
-  # * <tt>:port</tt> - The +port+ the Taps server is on. If not given, defaults to #default_server_port.
-  # * <tt>:local_database_url</tt> - Refers to the local database url in the options for Taps client commands (see Taps Options).
-  #
-  # ==== Taps Options
-  #
-  # <tt>taps</tt>
-  #   server <local_database_url> <login> <password> [--port=N]        Start a taps database import/export server
-  #   pull <local_database_url> <remote_url> [--chunksize=N]           Pull a database from a taps server
-  #   push <local_database_url> <remote_url> [--chunksize=N]           Push a database to a taps server
-  #
-  # ==== Examples
-  #
-  #   task :push do
-  #     login = fetch(:user)
-  #     password = Time.now.to_s
-  #     CapTaffy.Db.run(self, { :login => login, :password => password, :remote_database_url => "sqlite://test_production", :local_database_url => "sqlite://test_development" }) do |client|
-  #       client.cmd_send
-  #     end
-  #   end
-  def run(instance, options = {} , &blk) # :yields: client
+  def run(instance, options = {} , &blk)
     options[:port] ||= default_server_port
     remote_database_url, login, password, port, local_database_url = options[:remote_database_url], options[:login], options[:password], options[:port], options[:local_database_url]
     force_local = options.delete(:local)
@@ -143,16 +86,12 @@ module CapTaffy::Db
     end
   end
 
-  class InvalidURL < RuntimeError # :nodoc:
-  end
+  class InvalidURL < RuntimeError; end
 end
 
 Capistrano::Configuration.instance.load do
   namespace :db do
-    # Executes given block.
-    # If this is a dry run, any raised exceptions will be caught and +returning+ is returned.
-    # If this is not a dry run, any exceptions will be raised as expected.
-    def dry_run_safe(returning = nil, &block) # :yields:
+    def dry_run_safe(returning = nil, &block)
       begin
         yield
       rescue Exception => e
@@ -162,8 +101,8 @@ Capistrano::Configuration.instance.load do
     end
 
     task :detect, :roles => :app do
-      @remote_database_url = dry_run_safe('') { CapTaffy::Db.remote_database_url(self, 'production') }
-      @local_database_url = dry_run_safe('') { CapTaffy::Db.local_database_url('development') }
+      @remote_database_url = dry_run_safe('') { CapTaffy::Db.remote(self, 'production') }
+      @local_database_url = dry_run_safe('') { CapTaffy::Db.local('development') }
     end
 
     desc <<-DESC

data/lib/cap-taffy/parse.rb

@@ -13,8 +13,6 @@ module CapTaffy
       attr_accessor :instance
 
       # Modified from :parse_database_yml in heroku/command/db.rb
-      #
-      # Accepts a complete +db_config+ hash and +env+ and parses for a database_url accordingly.
       def database_url(db_config, env)
         raise Invalid, "please pass me a valid Hash loaded from a database YAML file" unless db_config
         conf = db_config[env]
@@ -35,19 +33,17 @@ module CapTaffy
       end
     end
 
-    # Override to do nothing on #new
-    def initialize # :nodoc:
+    def initialize
 
     end
 
-    # Override to pass-through on #escape
+    # Do nothing
     def escape(string)
       string
     end
 
     public :uri_hash_to_url, :conf_to_uri_hash
 
-    class Invalid < RuntimeError # :nodoc:
-    end
+    class Invalid < RuntimeError; end
   end
 end

data/lib/cap-taffy.rb

@@ -2,7 +2,7 @@
 module CapTaffy
 
   # :stopdoc:
-  VERSION = '0.0.2'
+  VERSION = '1.0.0'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/spec/cap-taffy/db_spec.rb

@@ -22,69 +22,64 @@ module CapTaffy
         load 'lib/cap-taffy/db.rb'
       end
 
-      for_task :detect, :roles => :app, :in => :Db, :it => "should be defined" do
-        @mod.expects(:remote_database_url).returns("remote_db_url")
-        @mod.expects(:local_database_url).returns("local_db_url")
+      for_task :detect, :roles => :app, :it => "should be defined" do
+        @db_mod.expects(:remote).returns("remote_db_url")
+        @db_mod.expects(:local).returns("local_db_url")
         
         load 'lib/cap-taffy/db.rb'
         
-        @namespace.instance_variable_get(:@remote_database_url).should == "remote_db_url"
-        @namespace.instance_variable_get(:@local_database_url).should == "local_db_url"
+        @namespace_db.instance_variable_get(:@remote_database_url).should == "remote_db_url"
+        @namespace_db.instance_variable_get(:@local_database_url).should == "local_db_url"
       end
 
-      def load_taffy_db # :nodoc:
-        with_logger do
-          load 'lib/cap-taffy/db.rb'
-        end
-      end
-
-      for_task :push, :roles => :app, :in => :Db, :it => "should send taps client cmd_send" do
+      for_task :push, :roles => :app, :it => "should send taps client cmd_send" do
         options = {:remote_database_url => "remote", :local_database_url => "local", :port => nil, :login => "a_user", :password => "a_pass"}
-        @namespace.expects(:detect)
+        @namespace_db.expects(:detect)
         namespace_with_variables(:taps_port => nil)
-        db_with_expected_options(options)
-        @mod.expects(:tmp_pass).with(@namespace.fetch(:user)).returns(options[:password])
-        @mod.expects(:run).with(@namespace, options).yields(taps_client_who(:expects, :cmd_send))
+        namespace_with_expected_options(options)
+
+        @db_mod.expects(:tmp_pass).with(@namespace_db.fetch(:user)).returns(options[:password])
+        @db_mod.expects(:run).with(@namespace_db, options).yields(taps_client_who(:expects, :cmd_send))
 
-        load_taffy_db
+        load_taffy
       end
 
-      for_task :push, :roles => :app, :in => :Db, :it => "should use cli argument for port" do
+      for_task :push, :roles => :app, :it => "should use cli argument for port" do
         options = {:remote_database_url => "remote", :local_database_url => "local", :port => 1234, :login => "a_user", :password => "a_pass"}
-        @namespace.expects(:detect)
+        @namespace_db.expects(:detect)
         namespace_with_variables(:taps_port => 1234)
-        db_with_expected_options(options)
-        @mod.expects(:tmp_pass).with(@namespace.fetch(:user)).returns(options[:password])
-        @mod.expects(:run).with(@namespace, options)
+        namespace_with_expected_options(options)
+        @db_mod.expects(:tmp_pass).with(@namespace_db.fetch(:user)).returns(options[:password])
+        @db_mod.expects(:run).with(@namespace_db, options)
 
-        load_taffy_db
+        load_taffy
       end
 
-      for_task :push, :roles => :app, :in => :Db, :it => "should force 127.0.0.1 (local) for ssh local forwarding" do
+      for_task :push, :roles => :app, :it => "should force 127.0.0.1 (local) for ssh local forwarding" do
         options = {:remote_database_url => "remote", :local_database_url => "local", :port => 1234, :login => "a_user", :password => "a_pass"}
-        @namespace.expects(:detect)
+        @namespace_db.expects(:detect)
         namespace_with_variables(:taps_port => 1234, :local => true)
-        db_with_expected_options(options)
-        @mod.expects(:tmp_pass).with(@namespace.fetch(:user)).returns(options[:password])
-        @mod.expects(:run).with(@namespace, options.merge(:local => true))
+        namespace_with_expected_options(options)
+        @db_mod.expects(:tmp_pass).with(@namespace_db.fetch(:user)).returns(options[:password])
+        @db_mod.expects(:run).with(@namespace_db, options.merge(:local => true))
 
-        load_taffy_db
+        load_taffy
       end
       
-      for_task :pull, :roles => :app, :in => :Db, :it => "should send taps client cmd_receive" do
+      for_task :pull, :roles => :app, :it => "should send taps client cmd_receive" do
         options = {:remote_database_url => "remote", :local_database_url => "local", :port => nil, :login => "a_user", :password => "a_pass"}
-        @namespace.expects(:detect)
+        @namespace_db.expects(:detect)
         namespace_with_variables(:taps_port => nil)
-        db_with_expected_options(options)
-        @mod.expects(:tmp_pass).with(@namespace.fetch(:user)).returns(options[:password])
-        @mod.expects(:run).with(@namespace, options).yields(taps_client_who(:expects, :cmd_receive))
+        namespace_with_expected_options(options)
 
-        load_taffy_db
+        @db_mod.expects(:tmp_pass).with(@namespace_db.fetch(:user)).returns(options[:password])
+        @db_mod.expects(:run).with(@namespace_db, options).yields(taps_client_who(:expects, :cmd_receive))
+
+        load_taffy
       end
     end
 
     context "after capistrano" do
-      include CapistranoHelpers
       include TaffyHelpers
 
       before do
@@ -112,7 +107,7 @@ module CapTaffy
         env = 'test'
         Parse.expects(:database_url).with(@conf, env)
 
-        Db.local_database_url(env)
+        Db.local(env)
       end
 
       it "should detect remote database url" do
@@ -123,7 +118,7 @@ module CapTaffy
         env = 'test'
         Parse.expects(:database_url).with(@conf, env)
 
-        Db.remote_database_url(instance, env)
+        Db.remote(instance, env)
       end
 
       it "should create temporary password from time and user" do
@@ -179,12 +174,12 @@ module CapTaffy
         parser = mock()
         Parse.expects(:new).at_least_once.returns(parser)
         parser.expects(:uri_hash_to_url).
-          with('username' => login, 'password' => password, 'host' => host, 'scheme' => 'http', 'path' => '')
+          with('username' => login, 'password' => password, 'host' => host, 'scheme' => 'http', 'path' => '').returns("remote_url")
       end
 
       it "should build remote url (with some help)" do
         @options[:host] = "127.0.0.1"        
-        parser_expects_uri_hash_to_url_with(@options[:login], @options[:password], "#{@options[:host]}:#{Db.default_server_port}").returns("remote_url/")
+        parser_expects_uri_hash_to_url_with(@options[:login], @options[:password], "#{@options[:host]}:#{Db.default_server_port}")
 
         Db.remote_url(@options)
       end
@@ -192,7 +187,7 @@ module CapTaffy
       it "should build remote url with different port" do
         @options[:host] = "127.0.0.1"
         @options[:port] = 1234
-        parser_expects_uri_hash_to_url_with(@options[:login], @options[:password], "#{@options[:host]}:#{@options[:port]}").returns("remote_url")
+        parser_expects_uri_hash_to_url_with(@options[:login], @options[:password], "#{@options[:host]}:#{@options[:port]}")
 
         Db.remote_url(@options)
       end
@@ -204,15 +199,15 @@ module CapTaffy
         Db.remote_url(@options).should == "remote_url"
       end
 
-      running_db_it "should run with capistrano" do
-        capistrano_run_with(Db.server_command(@options))
+      running_taffy_it "should run with capistrano" do
+        run_capistrano_with(Db.server_command(@options))
 
         Db.run(@capistrano, @options)
       end
 
-      running_db_it "should do something to taps client" do
+      running_taffy_it "should do something to taps client" do
         channel, stream, data = simulating_run_loop_with :data => ">> Listening on 0.0.0.0:5000, CTRL+C to stop\r\n" do
-          capistrano_run_with(Db.server_command(@options))
+          run_capistrano_with(Db.server_command(@options))
         end
         channel.expects(:close)
 
@@ -225,11 +220,11 @@ module CapTaffy
         channel[:status].should == 0
       end
 
-      running_db_it "should run taffy on different port" do
+      running_taffy_it "should run taffy on different port" do
         @options[:port] = 1234
 
         channel, stream, data = simulating_run_loop_with :data => ">> Listening on 0.0.0.0:1234, CTRL+C to stop\r\n" do
-          capistrano_run_with(Db.server_command(@options))
+          run_capistrano_with(Db.server_command(@options))
         end
         channel.expects(:close)
         Db.expects(:remote_url).with(@options.merge(:host => channel[:host])).returns("remote_url")
@@ -242,9 +237,9 @@ module CapTaffy
         channel[:status].should == 0
       end
 
-      running_db_it "should not do anything until taps sinatra server is running" do
+      running_taffy_it "should not do anything until taps sinatra server is running" do
         simulating_run_loop_with :data => "asdfasdf" do
-          capistrano_run_with(Db.server_command(@options))
+          run_capistrano_with(Db.server_command(@options))
         end
 
         client = mock()
@@ -255,7 +250,7 @@ module CapTaffy
         end
 
         channel, stream, data = simulating_run_loop_with :data => ">> Listening on 0.0.0.0:5000, CTRL+C to stop\r\n" do
-          capistrano_run_with(Db.server_command(@options))
+          run_capistrano_with(Db.server_command(@options))
         end
         channel.expects(:close)
         Db.expects(:remote_url).with(@options.merge(:host => channel[:host], :port => 5000)).returns("remote_url")
@@ -268,9 +263,9 @@ module CapTaffy
         channel[:status].should == 0
       end
 
-      running_db_it "should force 127.0.0.1 (local) for remote url" do
+      running_taffy_it "should force 127.0.0.1 (local) for remote url" do
         channel, stream, data = simulating_run_loop_with :data => ">> Listening on 0.0.0.0:5000, CTRL+C to stop\r\n" do
-          capistrano_run_with(Db.server_command(@options))
+          run_capistrano_with(Db.server_command(@options))
         end
         channel.expects(:close)
 

data/spec/cap-taffy_spec.rb

@@ -1,4 +1,7 @@
+
 require File.join(File.dirname(__FILE__), %w[spec_helper])
 
 describe CapTaffy do
 end
+
+# EOF

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib cap-taffy]))
 
-module Capistrano # :nodoc:
+module Capistrano
 end
 
 Spec::Runner.configure do |config|
@@ -34,19 +34,12 @@ Capistrano::Configuration.class_eval do
   end
 end
 
-class String # :nodoc:
-  def demodulize
-    gsub(/^.*::/, '')
-  end
-end
-
 module CapistranoHelpers
-  def self.included(base) # :nodoc:
+  def self.included(base)
     base.extend CapistranoHelpers::ClassMethods
   end
 
-  # Stubs the Capistrano Logger and yields to the block
-  def with_logger(&blk) # :yields:
+  def with_logger(&blk)
     logger_class = Class.new
     logger = mock()
     logger.stub_everything
@@ -57,83 +50,41 @@ module CapistranoHelpers
     Capistrano.send(:remove_const, "Logger") rescue nil
   end
 
-  # Helper for common operations in db tasks
-  def db_with_expected_options(options) # :nodoc:
-    @namespace.stubs(:fetch).with(:user).returns(options[:login])
-    @namespace.instance_variable_set(:@remote_database_url, options[:remote_database_url])
-    @namespace.instance_variable_set(:@local_database_url, options[:local_database_url])
+  def load_taffy
+    with_logger do
+      load 'lib/cap-taffy/db.rb'
+    end
   end
 
-  # Stubs the variables hash used by Capistrano to accept command-line parameters
-  def namespace_with_variables(variables) # :nodoc:
-    @namespace.stubs(:variables).returns(variables)
+  def namespace_with_expected_options(options)
+    @namespace_db.stubs(:fetch).with(:user).returns(options[:login])
+    @namespace_db.instance_variable_set(:@remote_database_url, options[:remote_database_url])
+    @namespace_db.instance_variable_set(:@local_database_url, options[:local_database_url])
   end
 
-  # Creates an expectation for the Capistrano namespace/task <tt>instance</tt> for the <tt>:run</tt> action with <tt>*args</tt>.
-  def run_with(instance, *args)
-    instance.expects(:run).with(*args)
+  def namespace_with_variables(variables)
+    @namespace_db.stubs(:variables).returns(variables)
   end
 
-  # The Capistrano <tt>:run</tt> action loops with <tt>channel</tt>, <tt>stream</tt>, and <tt>data</tt> until the channel is closed.
-  # 
-  # Passing in a <tt>:run</tt> expectation, modifies the expectation such that each subsequent invocation ("loop") yields <tt>channel</tt>, <tt>stream</tt>, and <tt>data</tt>
-  #
-  # ==== Parameters
-  #
-  # * <tt>:channel</tt> - A hash containing <tt>:host</tt>.
-  # * <tt>:stream</tt> - A stream object.
-  # * <tt>:data</tt> - A data object, usually a String.
-  def simulating_run_loop_with(options={}, &blk) # :yields:
-    channel = options[:channel] || {:host => "192.168.1.20"}
-    stream = options[:stream]
-    data = options[:data]
-
-    blk.call.then.yields(channel, stream, data)
-    [channel, stream, data]
-  end
 
   module ClassMethods
-    # Used in specs to test Capistrano tasks.
-    #
-    # 
-    # Code defined in the task will be executed automatically on load. (Note the <tt>yields</tt>, see Mocha#yields[http://mocha.rubyforge.org/classes/Mocha/Expectation.html#M000043])
-    #
-    # ==== Parameters
-    #
-    # * <tt>:it</tt> - The description for the current example group.
-    # * <tt>:in</tt> - Specifies the module under test (as well as the namespace the task is defined in). The namespace will be deduced with the downcase of <tt>:in</tt>
-    #
-    # ==== Examples
-    #
-    #   for_task :detect, :roles => :app, :in => :Somewhere, :it => "should so something" do
-    #     @namespace # refers to the current task under test (in Capistrano tasks are executed on Capistrano::Namespaces::Namespace instances)
-    #     @mod       # refers to module CapTaffy::Somewhere
-    #   end
-    def for_task(task_name, options, &block)
-      description = options.delete(:it)
-      namespace = options.delete(:in)
-
+    def for_task(task_name, options = {}, &block)
+      message = options.delete(:it)
       context ":#{task_name.to_s} task" do
         before do
-          @namespace = Capistrano::Configuration.instance.namespaces[namespace.to_s.downcase.to_sym] = mock()
-          @namespace.stubs(:desc)
-          @namespace.stubs(:task)
-          args = [task_name, options]
-          unless options.empty?
-            @namespace.expects(:task).with(*args).yields
-          else
-            @namespace.expects(:task).with(task_name).yields
-          end
-
-          @mod = Module.new # The module under test
-          CapTaffy.const_set(namespace, @mod)
+          @namespace_db = Capistrano::Configuration.instance.namespaces[:db] = mock()
+          @namespace_db.stubs(:desc)
+          @namespace_db.stubs(:task)
+          @namespace_db.expects(:task).with(task_name, options).yields
+
+          @db_mod = Module.new
+          CapTaffy.const_set("Db", @db_mod)
         end
 
-        it description, &block
+        it message, &block
 
         after do
-          const_name = @mod.to_s.demodulize
-          CapTaffy.send(:remove_const, const_name)
+          CapTaffy.send(:remove_const, "Db")
         end
       end
     end
@@ -141,14 +92,10 @@ module CapistranoHelpers
 end
 
 module TaffyHelpers
-  def self.included(base) # :nodoc:
+  def self.included(base)
     base.extend TaffyHelpers::ClassMethods
   end
 
-  # A simple helper for mocking a quick object
-  # 
-  # Usage:
-  #   taps_client_who(:expects, :do_something)
   def taps_client_who(method_symbol, *args)
     client = mock()
     client.send(method_symbol, *args)
@@ -156,16 +103,24 @@ module TaffyHelpers
   end
 
   module ClassMethods
-    # A wrapper for running CapTaffy::Db::run
-    def running_db_it(message, &blk)
-      context "when running db" do
+    def running_taffy_it(message, &blk)
+      context "when running taffy" do
         before do
           @capistrano = mock()
         end
 
-        # See CapistranoHelpers
-        def capistrano_run_with(*args)
-          run_with(@capistrano, *args) 
+        def run_capistrano_with(*args)
+          @capistrano.expects(:run).with(*args)
+        end
+
+        # invokes one loop of block, passing in channel, stream, data as arguments
+        def simulating_run_loop_with(options={}, &blk)
+          channel = options[:channel] || {:host => "192.168.1.20"}
+          stream = options[:stream]
+          data = options[:data]
+
+          blk.call.then.yields(channel, stream, data)
+          [channel, stream, data]
         end
 
         it message, &blk

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hsume2-cap-taffy
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 1.0.0
 platform: ruby
 authors: 
 - Henry Hsu
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-17 00:00:00 -07:00
+date: 2009-09-14 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -52,16 +52,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.5.1
     version: 
-- !ruby/object:Gem::Dependency 
-  name: mocha
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 description: Capistrano recipes for deploying databases and other common tasks.
 email: henry@qlane.com
 executables: []
@@ -78,16 +68,13 @@ files:
 - lib/cap-taffy.rb
 - lib/cap-taffy/db.rb
 - lib/cap-taffy/parse.rb
-- lib/cap-taffy/ssh.rb
 - spec/cap-taffy/db_spec.rb
 - spec/cap-taffy/parse_spec.rb
-- spec/cap-taffy/ssh_spec.rb
 - spec/cap-taffy_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 has_rdoc: false
 homepage: http://by.qlane.com
-licenses: 
 post_install_message: 
 rdoc_options: 
 - --main
@@ -109,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: cap-taffy
-rubygems_version: 1.3.5
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 3
 summary: Capistrano recipes for deploying databases (managing database.yml, importing/exporting/transfering databases, etc.)

data/lib/cap-taffy/ssh.rb

@@ -1,18 +0,0 @@
-require File.join(File.dirname(__FILE__), %w[.. cap-taffy]) unless defined?(CapTaffy)
-
-module CapTaffy::SSH
-
-end
-
-Capistrano::Configuration.instance.load do
-  namespace :ssh do
-    desc <<-DESC
-      Authorize SSH access for local computer on remote computers(s).
-    DESC
-    task :authorize do
-      public_key = File.read(File.expand_path(File.join(%w[~/ .ssh id_rsa.pub]))).chop
-
-      run %Q[if [ ! -f ~/.ssh/authorized_keys ]; then mkdir -p ~/.ssh && touch ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys; fi && if [ -z "$(grep "^#{public_key}$" ~/.ssh/authorized_keys)" ]; then echo "#{public_key}" >> ~/.ssh/authorized_keys && echo "Public key on '$CAPISTRANO:HOST$' authorized at '#{Time.now.to_s}'"; else echo "Public key on '$CAPISTRANO:HOST$' is already authorized."; fi]
-    end
-  end
-end

data/spec/cap-taffy/ssh_spec.rb

@@ -1,37 +0,0 @@
-require File.join(File.dirname(__FILE__), %w[.. spec_helper])
-
-module CapTaffy
-  describe 'SSH' do
-    include CapistranoHelpers
-
-    before do
-      CapTaffy.send(:remove_const, "SSH") rescue nil
-    end
-
-    it "should load in capistrano configuration instance" do;
-      Capistrano::Configuration.instance.expects(:load)
-
-      load 'lib/cap-taffy/ssh.rb'
-    end
-
-    it "should define :db namespace" do
-      Capistrano::Configuration.instance.expects(:namespace).with(:ssh)
-
-      load 'lib/cap-taffy/ssh.rb'
-    end
-
-    def simulating_line(line, &blk)
-      blk.call.then.yields(line)
-      line
-    end
-
-    for_task :authorize, :in => :SSH, :it => "should authorize on each server" do
-      public_key = "ssh-key2\n"
-      File.expects(:read).with(File.expand_path(File.join(%w[~/ .ssh id_rsa.pub]))).returns(public_key)
-
-      run_with(@namespace, anything) # Don't rly wna test bash scripts
-
-      load 'lib/cap-taffy/ssh.rb'
-    end
-  end
-end