taketo 0.0.5 → 0.0.6

data/README.md

@@ -78,11 +78,37 @@ Destination resolving works intelligently. Given the following config:
 
 ```taketo my_project:staging``` will ssh to s1 with host = 1.2.3.4  
 ```taketo my_project2``` will ssh to s2 with host = 2.3.4.5   
-```taketo mps2``` will ssh to s2 with host = 3.4.5.6 - note the use of global alias
+```taketo mps1``` will ssh to ps1 with host = 3.4.5.6 - note the use of global alias
 
 Note that default destination can be specified via ```default_destination``` config option
 
-  
+You can use shared server configs to reduce duplication:
+
+```ruby
+  shared_server_config :my_staging do
+    command :console do
+      execute "rails c"
+      desc "Launch rails console"
+    end
+  end
+
+  project :my_project do
+    environment :staging do
+      server :s1 do
+        host "1.2.3.4"
+        include_shared_server_config(:my_staging)
+      end
+
+      server :s2 do
+        host :s2 do
+        include_shared_server_config(:my_staging)
+      end
+    end
+  end
+```
+
+This will give you ```console``` commands available both on s1 and s2  
+
 To-Do:
 ------
 
@@ -92,6 +118,10 @@ To-Do:
 The Changelog:
 --------------
 
+### v0.0.6 (26.07.2012) ###
+* Add identity_file server config option
+* Add shared server config support
+
 ### v0.0.5 (24.07.2012) ###
 * Add --directory option, which enables specifying directory on remote server upon launch
 * Add global_alias config option for servers

data/Rakefile

@@ -15,7 +15,14 @@ require 'rspec/core/rake_task'
 require 'cucumber'
 require 'cucumber/rake/task'
 
-RSpec::Core::RakeTask.new
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/lib/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/integration/**/*_spec.rb'
+  t.name = :integration_spec
+end
 
 Cucumber::Rake::Task.new(:features) do |t|
   t.cucumber_opts = "features --tags ~@wip --format pretty -x"

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/bin/taketo

@@ -31,7 +31,7 @@ def parse_options
 
   OptionParser.new do |opts|
     opts.banner = "Usage: taketo [destination] [options]"
-    opts.version = VERSION
+    opts.version = ::Taketo::VERSION
     opts.separator ""
     opts.separator "Common options:"
 

data/features/config.feature

@@ -0,0 +1,90 @@
+Feature: taketo config
+  In order to get rid of routineous ssh command calls
+  As a user
+  I want to be able configure taketo
+
+  Scenario: Shared server configs
+    When I have the following config in "/tmp/taketo_test_cfg.rb"
+      """
+      shared_server_config :shared_config_example do
+        port 9999 #can contain any server config options
+      end
+
+      project :slots do
+        environment :staging do
+          server(:s1) { host "1.2.3.4"; include_shared_server_config(:shared_config_example) }
+        end
+      end
+      """
+    And I successfully run `taketo slots:staging:s1 --config=/tmp/taketo_test_cfg.rb --dry-run`
+    Then the output should contain
+      """
+      ssh -t -p 9999 1.2.3.4 "RAILS_ENV=staging bash"
+      """
+
+  Scenario: Set environment variables
+    When I have the following config in "/tmp/taketo_test_cfg.rb"
+      """
+      project :slots do
+        environment :staging do
+          server do
+            host "1.2.3.4"
+            location "/var/apps/slots"
+            env :FOO => "the value"
+          end
+        end
+      end
+      """
+    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run`
+    Then the output should contain
+      """
+      RAILS_ENV=staging
+      """
+    And the output should contain
+      """
+      FOO=the\ value
+      """
+      
+  Scenario: Reopen config scopes
+    When I have the following config in "/tmp/taketo_test_cfg.rb"
+      """
+      project :slots do
+        environment :staging do
+          server do
+            host "1.2.3.4"
+          end
+        end
+      end
+
+      project :slots do
+        environment :staging do
+          server do
+            env :FOO => "bar"
+          end
+        end
+      end
+      """
+    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb slots:staging --dry-run`
+    Then the output should match /ssh -t 1\.2\.3\.4 "(RAILS_ENV=staging FOO=bar|FOO=bar RAILS_ENV=staging) bash"/
+
+  Scenario: Unique server alias
+    When I have the following config in "/tmp/taketo_test_cfg.rb"
+      """
+      project :slots do
+        environment :staging do
+          server :s1 do
+            host "1.2.3.4"
+          end
+          server :s2 do
+            global_alias :ss2
+            host "2.3.4.5"
+          end
+        end
+      end
+      """
+    And I successfully run `taketo ss2 --config=/tmp/taketo_test_cfg.rb --dry-run`
+    Then the output should contain
+      """
+      ssh -t 2.3.4.5 "RAILS_ENV=staging bash"
+      """
+

data/features/connect_to_server.feature

@@ -46,51 +46,6 @@ Feature:
       ssh -t 1.2.3.4 "cd /var/apps/slots; RAILS_ENV=staging bash"
       """
 
-  Scenario: Set environment variables
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
-      """
-      project :slots do
-        environment :staging do
-          server do
-            host "1.2.3.4"
-            location "/var/apps/slots"
-            env :FOO => "the value"
-          end
-        end
-      end
-      """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run`
-    Then the output should contain
-      """
-      RAILS_ENV=staging
-      """
-    And the output should contain
-      """
-      FOO=the\ value
-      """
-      
-  Scenario: Reopen config scopes
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
-      """
-      project :slots do
-        environment :staging do
-          server do
-            host "1.2.3.4"
-          end
-        end
-      end
-
-      project :slots do
-        environment :staging do
-          server do
-            env :FOO => "bar"
-          end
-        end
-      end
-      """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb slots:staging --dry-run`
-    Then the output should match /ssh -t 1\.2\.3\.4 "(RAILS_ENV=staging FOO=bar|FOO=bar RAILS_ENV=staging) bash"/
-
   Scenario: Default destination
     When I have the following config in "/tmp/taketo_test_cfg.rb"
       """
@@ -111,23 +66,21 @@ Feature:
       ssh -t 2.3.4.5 "RAILS_ENV=staging bash"
       """
 
-  Scenario: Unique server alias
+  Scenario: SSH key file
     When I have the following config in "/tmp/taketo_test_cfg.rb"
       """
       project :slots do
         environment :staging do
-          server :s1 do
-            host "1.2.3.4"
-          end
-          server :s2 do
-            global_alias :ss2
+          server do
+            identity_file "/home/gor/.ssh/foo bar"
             host "2.3.4.5"
           end
         end
       end
       """
-    And I successfully run `taketo ss2 --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run`
     Then the output should contain
       """
-      ssh -t 2.3.4.5 "RAILS_ENV=staging bash"
+      ssh -t -i /home/gor/.ssh/foo\ bar 2.3.4.5 "RAILS_ENV=staging bash"
       """
+

data/lib/taketo/commands/ssh_command.rb

@@ -13,7 +13,7 @@ module Taketo
       end
 
       def render(rendered_command)
-        %Q[ssh -t #{port} #{username}#{host} "#{rendered_command}"].squeeze(" ")
+        %Q[ssh -t #{port} #{identity_file} #{username}#{host} "#{rendered_command}"].squeeze(" ")
       end
 
       def host
@@ -30,6 +30,10 @@ module Taketo
       def username
         %Q[#{shellescape @server.username}@] if @server.username
       end
+
+      def identity_file
+        %Q[-i #{shellescape @server.identity_file}] if @server.identity_file
+      end
     end
   end
 end

data/lib/taketo/constructs/server.rb

@@ -7,7 +7,7 @@ module Taketo
   module Constructs
     class Server < BaseConstruct
       attr_reader :environment_variables
-      attr_accessor :host, :port, :username, :default_location, :environment, :global_alias
+      attr_accessor :host, :port, :username, :default_location, :environment, :global_alias, :identity_file
       
       has_nodes :commands, :command
 

data/lib/taketo/dsl.rb

@@ -2,7 +2,8 @@ require 'taketo/constructs_factory'
 
 module Taketo
   class DSL
-    class ScopeError < StandardError; end
+    class ScopeError < StandardError;  end
+    class ConfigError < StandardError; end
 
     class << self
       def define_scope(scope, parent_scope, options = {})
@@ -19,23 +20,25 @@ module Taketo
         end
       end
 
-      def define_attribute(name, parent_scope, &block)
-        define_method name do |attribute|
+      def define_method_in_scope(name, parent_scope, &block)
+        define_method name do |*args, &blk|
           unless current_scope?(parent_scope)
             raise ScopeError,
               "#{name} can't be defined in #{current_scope} scope"
           end
-          instance_exec(attribute, &block)
+          args.push blk if blk
+          instance_exec(*args, &block)
         end
       end
     end
 
-    attr_reader :current_scope_object, :config
+    attr_reader :current_scope_object, :config, :shared_server_configs
 
     def initialize(factory = Taketo::ConstructsFactory.new)
       @factory = factory
       @scope = [:config]
       @config = @current_scope_object = factory.create_config
+      @shared_server_configs = Hash.new { |h, k| raise ConfigError, "Shared server config '#{k}' is not defined!"}
     end
 
     def configure(filename = nil, &block)
@@ -56,15 +59,24 @@ module Taketo
     define_scope :server, :environment, :default_name => :default
     define_scope :command, :server
 
-    define_attribute(:default_destination, :config) { |destination| current_scope_object.default_destination = destination }
-    define_attribute(:host, :server)                { |hostname|    current_scope_object.host = hostname                   }
-    define_attribute(:port, :server)                { |port_number| current_scope_object.port = port_number                }
-    define_attribute(:user, :server)                { |username|    current_scope_object.username = username               }
-    define_attribute(:location, :server)            { |path|        current_scope_object.default_location = path           }
-    define_attribute(:global_alias,:server)         { |alias_name|  current_scope_object.global_alias = alias_name         }
-    define_attribute(:env, :server)                 { |env|         current_scope_object.env(env)                          }
-    define_attribute(:execute, :command)            { |command|     current_scope_object.command = command                 }
-    define_attribute(:desc, :command)               { |description| current_scope_object.description = description         }
+    define_method_in_scope(:default_destination, :config) { |destination|   current_scope_object.default_destination = destination }
+    define_method_in_scope(:host, :server)                { |hostname|      current_scope_object.host = hostname                   }
+    define_method_in_scope(:port, :server)                { |port_number|   current_scope_object.port = port_number                }
+    define_method_in_scope(:user, :server)                { |username|      current_scope_object.username = username               }
+    define_method_in_scope(:location, :server)            { |path|          current_scope_object.default_location = path           }
+    define_method_in_scope(:global_alias,:server)         { |alias_name|    current_scope_object.global_alias = alias_name         }
+    define_method_in_scope(:env, :server)                 { |env|           current_scope_object.env(env)                          }
+    define_method_in_scope(:identity_file, :server)       { |identity_file| current_scope_object.identity_file = identity_file     }
+    define_method_in_scope(:execute, :command)            { |command|       current_scope_object.command = command                 }
+    define_method_in_scope(:desc, :command)               { |description|   current_scope_object.description = description         }
+
+    define_method_in_scope(:shared_server_config, :config) do |name, blk|
+      @shared_server_configs.store(name.to_sym, blk)
+    end
+
+    define_method_in_scope(:include_shared_server_config, :server) do |name, *args|
+      instance_exec(*args, &shared_server_configs[name])
+    end
 
     private
 

data/lib/taketo/support/named_nodes_collection.rb

@@ -7,7 +7,7 @@ module Taketo
       include Enumerable
       extend Forwardable
 
-      def_delegators :@nodes, :each, :length, :size, :empty?
+      def_delegators :@nodes, :each, :length, :size, :empty?, :first, :last
 
       def initialize(nodes = [])
         @nodes = nodes

data/lib/taketo.rb

@@ -1,6 +1,6 @@
 module Taketo
   version_file = File.expand_path('../VERSION', File.dirname(__FILE__))
-  VERSION = File.read(version_file).freeze unless defined? VERSION
+  VERSION = File.read(version_file).freeze
 end
 
 require 'taketo/support'

data/spec/integration/dsl_integration_spec.rb

@@ -5,6 +5,13 @@ describe "Taketo DSL" do
   it "should parse config and instantiate objects" do
     factory = Taketo::ConstructsFactory.new
     config = Taketo::DSL.new(factory).configure do
+      shared_server_config(:commands) do
+        command :console do
+          execute "rails c"
+          desc "Rails console"
+        end
+      end
+
       project :slots do
         environment :staging do
           server do
@@ -12,9 +19,7 @@ describe "Taketo DSL" do
             user "deployer"
             location "/var/app"
             env :FOO => "bar"
-            command :console do
-              execute "rails c"
-            end
+            include_shared_server_config :commands
           end
         end
 
@@ -26,6 +31,7 @@ describe "Taketo DSL" do
             server server_name do
               host host_name
               location "/var/app"
+              include_shared_server_config :commands
             end
           end
         end
@@ -46,11 +52,15 @@ describe "Taketo DSL" do
     staging_server.username.should == "deployer"
     staging_server.default_location.should == "/var/app"
     staging_server.environment_variables.should == { :RAILS_ENV => "staging", :FOO => "bar" }
-    staging_server.commands.length.should == 1
-    staging_server.commands[:console].command.should == "rails c"
 
     production = project.environments[:production]
     production.servers.length.should == 2
+    production_server_1, production_server_2 = production.servers.first, production.servers.last
+
+    [staging_server, production_server_1, production_server_2].each do |s|
+      s.commands.length.should == 1
+      s.commands[:console].command.should == "rails c"
+    end
   end
 end
 

data/spec/lib/taketo/commands/ssh_command_spec.rb

@@ -11,6 +11,7 @@ describe "SSH Command" do
                   :port => 22,
                   :username => "deployer", 
                   :default_location => "/var/app",
+                  :identity_file => "/home/gor/.ssh/qqq",
                   :environment => environment,
                   :environment_variables => {})
   end
@@ -19,12 +20,13 @@ describe "SSH Command" do
   let(:ssh_command) { SSHCommand.new(server) }
 
   it "should compose command based on provided server object" do
-    ssh_command.render("foobar").should == %q[ssh -t -p 22 deployer@1.2.3.4 "foobar"]
+    ssh_command.render("foobar").should == %q[ssh -t -p 22 -i /home/gor/.ssh/qqq deployer@1.2.3.4 "foobar"]
   end
 
   it "should ignore absent parts" do
     server.stub(:port => nil)
     server.stub(:username => nil)
+    server.stub(:identity_file => nil)
     ssh_command.render("foobar").should == %q[ssh -t 1.2.3.4 "foobar"]
   end
 

data/spec/lib/taketo/constructs/server_spec.rb

@@ -16,6 +16,7 @@ describe "Server" do
   it { should have_accessor(:username) }
   it { should have_accessor(:default_location) }
   it { should have_accessor(:global_alias) }
+  it { should have_accessor(:identity_file) }
 
   describe "#environment=" do
     let(:environment) { environment = stub(:Environment, :name => :the_environment) }

data/spec/lib/taketo/dsl_spec.rb

@@ -48,7 +48,7 @@ describe "DSL" do
     end                                                                                        # end
   end
 
-  shared_examples "an attribute" do |attribute_name, parent_scope_name, parent_scope_method, example_value|
+  shared_examples "a scoped method" do |attribute_name, parent_scope_name, parent_scope_method, example_value|
     parent_scope = scopes[parent_scope_name]
 
     it { should be_appropriate_construct(attribute_name, example_value).under(parent_scope) }
@@ -66,7 +66,41 @@ describe "DSL" do
   end
 
   describe "#default_destination" do
-    it_behaves_like "an attribute", :default_destination, :config, :default_destination=, "foo:bar:baz"
+    it_behaves_like "a scoped method", :default_destination, :config, :default_destination=, "foo:bar:baz"
+  end
+
+  describe "Shared server config" do
+    specify "#shared_server_config should store a block" do
+      dsl(scopes[:config], factory.create(:config)) do |c|
+        cfg = proc { any_method_call_here }
+        c.shared_server_config(:foo, &cfg)
+        c.shared_server_configs[:foo].should == cfg
+      end
+    end
+
+    describe "#include_shared_server_config" do
+      it "should execute the block on dsl object in server scope" do
+        dsl(scopes[:server], factory.create(:server)) do |c|
+          c.stub(:shared_server_configs => { :foo => proc { any_method_call_here } })
+          c.should_receive(:any_method_call_here)
+          c.include_shared_server_config(:foo)
+        end
+      end
+
+      it "should accept arguments" do
+        dsl(scopes[:server], factory.create(:server)) do |c|
+          c.stub(:shared_server_configs => { :foo => proc { |qux| any_method_call_here(qux) } })
+          c.should_receive(:any_method_call_here).with(321)
+          c.include_shared_server_config(:foo, 321)
+        end
+      end
+
+      it "should raise ConfigError if non-existent config included" do
+        dsl(scopes[:server], factory.create(:server)) do |c|
+          expect { c.include_shared_server_config(:foo) }.to raise_error(Taketo::DSL::ConfigError, "Shared server config 'foo' is not defined!")
+        end
+      end
+    end
   end
 
   describe "#project" do
@@ -88,38 +122,42 @@ describe "DSL" do
         end
 
         describe "#host" do
-          it_behaves_like "an attribute", :host, :server, :host=, "127.0.0.2"
+          it_behaves_like "a scoped method", :host, :server, :host=, "127.0.0.2"
         end
 
         describe "#port" do
-          it_behaves_like "an attribute", :port, :server, :port=, 4096
+          it_behaves_like "a scoped method", :port, :server, :port=, 4096
         end
 
         describe "#user" do
-          it_behaves_like "an attribute", :user, :server, :username=, "deployer"
+          it_behaves_like "a scoped method", :user, :server, :username=, "deployer"
         end
 
         describe "#location" do
-          it_behaves_like "an attribute", :location, :server, :default_location=, "/var/app/"
+          it_behaves_like "a scoped method", :location, :server, :default_location=, "/var/app/"
         end
 
         describe "#env" do
-          it_behaves_like "an attribute", :env, :server, :env, { :FOO => "bar" }
+          it_behaves_like "a scoped method", :env, :server, :env, { :FOO => "bar" }
         end
 
         describe "#global_alias" do
-          it_behaves_like "an attribute", :global_alias, :server, :global_alias=, "foobared"
+          it_behaves_like "a scoped method", :global_alias, :server, :global_alias=, "foobared"
+        end
+
+        describe "#identity_file" do
+          it_behaves_like "a scoped method", :identity_file, :server, :identity_file=, "/home/gor/.ssh/qqq"
         end
 
         describe "#command" do
           it_behaves_like "a scope", :command, :server
 
           describe "#execute" do
-            it_behaves_like "an attribute", :execute, :command, :command=, "rails c"
+            it_behaves_like "a scoped method", :execute, :command, :command=, "rails c"
           end
 
           describe "#desc" do
-            it_behaves_like "an attribute", :desc, :command, :description=, "Run rails console"
+            it_behaves_like "a scoped method", :desc, :command, :description=, "Run rails console"
           end
         end
       end

data/spec/lib/taketo/support/named_nodes_collection_spec.rb

@@ -18,6 +18,8 @@ describe "NamedNodesCollection" do
     collection.map(&:name).should == [:foo, :bar]
     collection.length.should == 2
     collection.size.should == 2
+    collection.first.should == node1
+    collection.last.should == node2
   end
 
   it "should raise error if element not found" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taketo
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-24 00:00:00.000000000 Z
+date: 2012-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -124,6 +124,7 @@ files:
 - spec/support/matchers/enclose_scope_matcher.rb
 - spec/support/matchers/have_accessor_matcher.rb
 - features/commands.feature
+- features/config.feature
 - features/config_validation.feature
 - features/connect_to_server.feature
 - features/error_handling.feature