taketo 0.0.7 → 0.0.8

data/README.md

@@ -66,7 +66,7 @@ Destination resolving works intelligently. Given the following config:
       end
     end
   end
-  
+
   project :my_project2 do
     environment :staging do
       server :s2 do
@@ -76,8 +76,8 @@ Destination resolving works intelligently. Given the following config:
   end
 ```
 
-```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 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 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
@@ -105,29 +105,45 @@ You can use shared server configs to reduce duplication:
 
       server :s2 do
         host :s2 do
-        include_shared_server_config(:my_staging => [], :some_other_shared_config => "qux")
+        include_shared_server_config(:my_staging, :some_other_shared_config => "qux")
       end
     end
   end
 ```
 
-This will give you ```console``` commands available both on s1 and s2  
+This will give you ```console``` commands available both on s1 and s2
 
 The Changelog:
 --------------
 
+### v0.0.8 (17.11.2012) ###
+* Add per-config, per-project and per-environment default server config support, i.e.
+  ```ruby
+    default_server_config { env :TERM => 'xterm-256color' }  # Global default server config
+
+    project :p1 do
+      default_server_config { env :FOO => 'bar' } # global default server config is merged
+      ...
+    end
+  ```
+
+* Shared server configs can be included without redundant empty-array arguments, i.e.
+  ```ruby
+    include_shared_server_configs(:foo, :bar, :baz => [:arg1, :arg2], :qux => :arg3)
+  ```
+
 ### v0.0.7 (08.10.2012) ###
 * Add ability to include several shared server config at once
   Use hash as include_shared_server_config parameter to include
   multiple shared server configs with arguments, like:
   ```ruby
-    include_shared_server_config(:foo => :some_arg, :bar => [:arg1, :arg2])
+    include_shared_server_configs(:foo => :some_arg, :bar => [:arg1, :arg2])
   ```
   or just enumerate them if no arguments needed:
   ```ruby
     include_shared_server_configs(:baz, :quux)
   ```
-  
+
   NOTE: This change will break your config if you've used parametrized
         shared server configs before; rewrite them using hash-form
 
@@ -155,3 +171,14 @@ The Changelog:
 * Initial release
 * Support for simplest configs
 
+
+TO-DO:
+------
+
+* Shared server configs without arguments
+* Global server defaults
+* Override default commands per server
+* Define servers outside projects and environments
+* Export SSH config (i.e. for scp)
+* Destination completion
+* Command completion

data/VERSION

@@ -1 +1 @@
-0.0.7
+0.0.8

data/features/commands.feature

@@ -1,11 +1,11 @@
-Feature: 
+Feature:
   In order to be able to quickly run commands on my servers
   As a developer
   I want to have ability to create command shortcuts via config
   or specify command directly
 
   Background:
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       project :slots do
         environment :staging do
@@ -21,21 +21,21 @@ Feature:
       """
 
   Scenario: Run explicit command
-    When I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --command "TERM=xterm-256color bash"`
+    When I run taketo --dry-run --command "TERM=xterm-256color bash"
     Then the output should contain
       """
       ssh -t 1.2.3.4 "cd /var/apps/slots; RAILS_ENV=staging TERM=xterm-256color bash"
       """
 
   Scenario: Run command defined in config
-    When I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --command console slots:staging`
+    When I run taketo --dry-run --command console slots:staging
     Then the output should contain
       """
       ssh -t 1.2.3.4 "cd /var/apps/slots; RAILS_ENV=staging rails c"
       """
 
   Scenario: Override default location specified for server
-    When I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run --directory /var/www slots:staging`
+    When I run taketo --dry-run --directory /var/www slots:staging
     Then the output should contain
       """
       ssh -t 1.2.3.4 "cd /var/www; RAILS_ENV=staging bash"

data/features/config.feature

@@ -4,7 +4,7 @@ Feature: taketo config
   I want to be able configure taketo
 
   Scenario: Shared server configs
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       shared_server_config :sc1 do
         port 9999 #can contain any server config options
@@ -20,14 +20,14 @@ Feature: taketo config
         end
       end
       """
-    And I successfully run `taketo slots:staging:s1 --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I run taketo slots:staging:s1 --dry-run
     Then the output should contain
       """
       ssh -t -p 9999 1.2.3.4 "cd /var/qux; RAILS_ENV=staging bash"
       """
 
   Scenario: Shared server configs with arguments
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       shared_server_config :sc_args1 do |port_num|
         port port_num
@@ -46,14 +46,14 @@ Feature: taketo config
         end
       end
       """
-    And I successfully run `taketo slots:staging:s1 --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I run taketo slots:staging:s1 --dry-run
     Then the output should contain
       """
       ssh -t -p 9999 1.2.3.4 "cd /var/qux; RAILS_ENV=staging bash"
       """
 
   Scenario: Set environment variables
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       project :slots do
         environment :staging do
@@ -65,7 +65,7 @@ Feature: taketo config
         end
       end
       """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I run taketo --dry-run
     Then the output should contain
       """
       RAILS_ENV=staging
@@ -74,9 +74,9 @@ Feature: taketo config
       """
       FOO=the\ value
       """
-      
+
   Scenario: Reopen config scopes
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       project :slots do
         environment :staging do
@@ -94,11 +94,11 @@ Feature: taketo config
         end
       end
       """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb slots:staging --dry-run`
+    And I run taketo 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"
+    When I have the following config
       """
       project :slots do
         environment :staging do
@@ -112,7 +112,7 @@ Feature: taketo config
         end
       end
       """
-    And I successfully run `taketo ss2 --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I run taketo ss2 --dry-run
     Then the output should contain
       """
       ssh -t 2.3.4.5 "RAILS_ENV=staging bash"

data/features/config_validation.feature

@@ -4,11 +4,11 @@ Feature:
   I want to be guided if there are any errors in my configuration
 
   Scenario Outline: Config validation
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
     """
     <config>
     """
-    And I run `taketo --config=/tmp/taketo_test_cfg.rb`
+    And I run taketo
     Then the stderr should contain "<error>"
 
     Examples:
@@ -19,18 +19,18 @@ Feature:
       | project(:foo) { environment(:bar) { server {} }} | Server foo:bar:default: host is not defined                                 |
 
   Scenario: Global server alias clash
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
     """
     project(:foo) { environment(:bar) {
       server(:s1) { host '1.2.3.4'; global_alias :a1 }
       server(:s2) { host '2.3.4.5'; global_alias :a1 }
     }}
     """
-    And I run `taketo --config=/tmp/taketo_test_cfg.rb`
+    And I run taketo
     Then the stderr should contain "Server foo:bar:s2: global alias 'a1' has already been taken by server foo:bar:s1"
 
   Scenario: Bad command
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
     """
     project(:foo) { environment(:bar) {
       server(:s1) { host '1.2.3.4'
@@ -38,6 +38,6 @@ Feature:
       }
     }}
     """
-    And I run `taketo --config=/tmp/taketo_test_cfg.rb`
+    And I run taketo
     Then the stderr should contain "Don't know what to execute on command foo"
 

data/features/connect_to_server.feature

@@ -5,7 +5,7 @@ Feature:
   configurable with simple DSL
 
   Scenario: SSH to server
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       project :slots do
         environment :staging do
@@ -22,14 +22,14 @@ Feature:
       end
 
       """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run slots:staging:s1`
+    And I run taketo --dry-run slots:staging:s1
     Then the output should contain
       """
       ssh -t deployer@1.2.3.4 "cd /var/apps/slots; RAILS_ENV=staging bash"
       """
 
   Scenario: SSH to the only server
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       project :slots do
         environment :staging do
@@ -40,14 +40,14 @@ Feature:
         end
       end
       """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I run taketo --dry-run
     Then the output should contain
       """
       ssh -t 1.2.3.4 "cd /var/apps/slots; RAILS_ENV=staging bash"
       """
 
   Scenario: Default destination
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       default_destination "slots:staging:s2"
       project :slots do
@@ -61,14 +61,14 @@ Feature:
         end
       end
       """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I run taketo --dry-run
     Then the output should contain
       """
       ssh -t 2.3.4.5 "RAILS_ENV=staging bash"
       """
 
   Scenario: SSH key file
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       project :slots do
         environment :staging do
@@ -79,7 +79,7 @@ Feature:
         end
       end
       """
-    And I successfully run `taketo --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I run taketo --dry-run
     Then the output should contain
       """
       ssh -t -i /home/gor/.ssh/foo\ bar 2.3.4.5 "RAILS_ENV=staging bash"

data/features/default_server_config.feature

@@ -0,0 +1,41 @@
+Feature: taketo config's default server config
+  In order to reduce duplication
+  As a taketo user
+  I want to be able set default configs for servers in particular scopes
+
+  Background:
+    When I have the following config
+      """
+      default_server_config do
+        env :FOO => 'bar'
+      end
+
+      project :slots do
+        default_server_config do
+          location '/mnt/apps'
+        end
+
+        environment :staging do
+          server :s1 do
+            host "1.2.3.4"
+          end
+        end
+      end
+
+      project :shoes do
+        environment :production do
+          server do
+            host "2.3.4.5"
+          end
+        end
+      end
+      """
+
+  Scenario: Global default server config
+    When I run taketo shoes --dry-run
+    Then the output should match /ssh -t 2\.3\.4\.5 "(RAILS_ENV=production FOO=bar|FOO=bar RAILS_ENV=production) bash"/
+
+  Scenario: Project default server config
+    When I run taketo slots --dry-run
+    Then the output should match /ssh -t 1\.2\.3\.4 "cd .mnt.apps; (RAILS_ENV=staging FOO=bar|FOO=bar RAILS_ENV=staging) bash"/
+

data/features/error_handling.feature

@@ -4,7 +4,7 @@ Feature:
   I want to see meaningful errors when I accidentally specify bad location
 
   Background:
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
       """
       default_destination "slots:staging:s2"
       project :slots do
@@ -20,10 +20,10 @@ Feature:
       """
 
   Scenario: Non-existent location
-    And I run `taketo slots:staging:qqq --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I run taketo slots:staging:qqq --dry-run
     Then the stderr should contain "server qqq not found for environment staging"
 
   Scenario: Ambiguous location
-    And I run `taketo slots:staging --config=/tmp/taketo_test_cfg.rb --dry-run`
+    And I run taketo slots:staging --dry-run
     Then the stderr should contain "There are multiple servers for environment staging: s1, s2"
 

data/features/help.feature

@@ -4,7 +4,7 @@ Feature:
   I want to view what's set up in config quickly
 
   Background:
-    When I have the following config in "/tmp/taketo_test_cfg.rb"
+    When I have the following config
     """
     project :foo do
       environment :bar do
@@ -34,7 +34,7 @@ Feature:
     """
 
   Scenario: View full config
-    When I run `taketo --config=/tmp/taketo_test_cfg.rb --view`
+    When I run taketo --view
     Then the output should contain exactly:
       """
 
@@ -55,11 +55,11 @@ Feature:
             Environment: RAILS_ENV=qux
               console
               killall - Kill ALL humans
-      
+
       """
 
   Scenario: View particular server
-    When I run `taketo --config=/tmp/taketo_test_cfg.rb --view foo:bar:default`
+    When I run taketo --view foo:bar:default
     Then the output should contain exactly:
       """
       Server: default

data/features/step_definitions/main_steps.rb

@@ -1,10 +1,16 @@
-When /^I have the following config in "(.*?)"$/ do |path, config|
-  @config_path = path
-  File.open(path, "w") do |f|
+DEFAULT_TEST_CONFIG_PATH = "/tmp/taketo_test_cfg.rb".freeze
+
+When /^I have the following config$/ do |config|
+  @config_path = DEFAULT_TEST_CONFIG_PATH
+  File.open(@config_path, "w") do |f|
     f.write(config)
   end
 end
 
+When /^I run taketo\s?(.*)$/ do |arguments|
+  step "I run `taketo --config=/tmp/taketo_test_cfg.rb #{arguments}`"
+end
+
 Then /^the output should contain$/ do |expected|
   assert_partial_output(expected, all_output)
 end

data/lib/taketo/constructs/base_construct.rb

@@ -6,11 +6,12 @@ module Taketo
     class BaseConstruct
 
       include AssociatedNodes
-      attr_reader :name
+      attr_reader :name, :default_server_config
 
       def initialize(name)
         super
         @name = name
+        @default_server_config = proc {}
       end
 
       def node_type
@@ -18,6 +19,17 @@ module Taketo
         demodulized.gsub(/([a-z])([A-Z])/, '\\1_\\2').downcase.to_sym
       end
 
+      ##
+      # Override in subclasses if needed
+      def parent=(parent)
+        @default_server_config = parent.default_server_config
+      end
+
+      def default_server_config=(config)
+        default = @default_server_config
+        @default_server_config = proc { instance_eval(&default); instance_eval(&config) }
+      end
+
       def qualified_name
         "#{node_type} #{self.name}"
       end

data/lib/taketo/constructs/environment.rb

@@ -15,11 +15,6 @@ module Taketo
       def project_name
         @project.name if defined? @project
       end
-
-      def append_server(server)
-        server.environment = self
-        super
-      end
     end
   end
 end

data/lib/taketo/constructs/server.rb

@@ -19,9 +19,10 @@ module Taketo
         @environment_variables.merge!(env_variables)
       end
 
-      def environment=(environment)
+      def parent=(environment)
         env(:RAILS_ENV => environment.name.to_s)
         @environment = environment
+        super
       end
 
       def default_command

data/lib/taketo/dsl.rb

@@ -2,30 +2,27 @@ 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 = {})
-        define_method scope do |*args, &block|
-          unless current_scope?(parent_scope)
-            raise ScopeError,
-              "#{scope} can't be defined in #{current_scope} scope"
-          end
+      def define_scope(scope, parent_scope, options = {}, &block)
+        define_method scope do |*args, &blk|
+          ensure_nesting_allowed!(scope, parent_scope)
           name = args.shift || options[:default_name] or raise(ArgumentError, "Name not specified")
+
           scope_object = current_scope_object.find(scope, name) { @factory.create(scope, name) }
+
           in_scope(scope, scope_object) do
-            block.call
+            instance_exec(current_scope_object, &block) if block
+            blk.call
           end
         end
       end
 
-      def define_method_in_scope(name, parent_scope, &block)
+      def define_method_in_scope(name, *parent_scopes, &block)
         define_method name do |*args, &blk|
-          unless current_scope?(parent_scope)
-            raise ScopeError,
-              "#{name} can't be defined in #{current_scope} scope"
-          end
+          ensure_nesting_allowed!(name, parent_scopes)
           args.push blk if blk
           instance_exec(*args, &block)
         end
@@ -56,7 +53,11 @@ module Taketo
 
     define_scope :project, :config
     define_scope :environment, :project
-    define_scope :server, :environment, :default_name => :default
+
+    define_scope :server, :environment, :default_name => :default do |s|
+      instance_eval(&s.default_server_config)
+    end
+
     define_scope :command, :server
 
     define_method_in_scope(:default_destination, :config) { |destination|   current_scope_object.default_destination = destination }
@@ -70,20 +71,17 @@ module Taketo
     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(:default_server_config, :config, :project, :environment) do |blk|
+      current_scope_object.default_server_config = blk
+    end
+
     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 |*args|
-      if args.first.is_a?(Hash)
-        configs_and_arguments = args.shift
-        configs_and_arguments.each do |config_name, arguments|
-          instance_exec(*arguments, &shared_server_configs[config_name])
-        end
-      else
-        args.each do |config_name|
-          instance_exec(&shared_server_configs[config_name])
-        end
+      extract_config_names_and_arguments(args).each do |config_name, arguments|
+        instance_exec(*arguments, &shared_server_configs[config_name])
       end
     end
     alias :include_shared_server_configs :include_shared_server_config
@@ -106,12 +104,26 @@ module Taketo
     def in_scope(scope, new_scope_object)
       parent_scope_object, @current_scope_object = @current_scope_object, new_scope_object
       @scope.push(scope)
-      yield
       parent_scope_object.send("append_#{scope}", current_scope_object)
+      current_scope_object.parent = parent_scope_object
+      yield
       @scope.pop
       @current_scope_object = parent_scope_object
     end
 
+    def ensure_nesting_allowed!(scope, parent_scopes)
+      if Array(parent_scopes).none? { |s| current_scope?(s) }
+        raise ScopeError, "#{scope} can't be defined in #{current_scope} scope"
+      end
+    end
+
+    def extract_config_names_and_arguments(args)
+      hashes, names = args.partition { |arg| arg.is_a? Hash }
+      configs_from_hashes = hashes.inject({}, &:merge)
+      configs_from_names = Hash[names.map { |config_name| [config_name.to_sym, []] }]
+      configs_from_hashes.merge(configs_from_names)
+    end
+
   end
 end
 

data/spec/integration/dsl_integration_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 require 'taketo/dsl'
 
 describe "Taketo DSL" do
-  it "should parse config and instantiate objects" do
+  it "parses config and instantiate objects" do
     factory = Taketo::ConstructsFactory.new
     config = Taketo::DSL.new(factory).configure do
       shared_server_config(:commands) do
@@ -44,7 +44,7 @@ describe "Taketo DSL" do
 
     project.environments.length.should == 2
     staging = project.environments[:staging]
-    
+
     staging.servers.length.should == 1
     staging_server = staging.servers[:default]
     staging_server.name.should == :default

data/spec/lib/taketo/config_validator_spec.rb

@@ -7,7 +7,7 @@ describe "ConfigValidator" do
   let(:traverser) { stub(:ConfigTraverser) }
 
   describe "#validate!" do
-    it "should visit all nodes with an instance of ConfigValidator::ConfigValidatorVisitor" do
+    it "visits all nodes with an instance of ConfigValidator::ConfigValidatorVisitor" do
       validator = ConfigValidator.new(traverser)
       traverser.should_receive(:visit_depth_first).with(an_instance_of(ConfigValidator::ConfigValidatorVisitor))
       validator.validate!
@@ -18,7 +18,7 @@ end
 describe "ConfigValidator::ConfigValidatorVisitor" do
   subject(:visitor) { ConfigValidator::ConfigValidatorVisitor.new }
 
-  it "should require config to have projects" do
+  it "requires config to have projects" do
     config = stub(:Config, :has_projects? => false)
     error_message = /no projects/
     expect { visitor.visit_config(config) }.to raise_error ConfigError, error_message
@@ -27,7 +27,7 @@ describe "ConfigValidator::ConfigValidatorVisitor" do
     expect { visitor.visit_config(config) }.not_to raise_error ConfigError, error_message
   end
 
-  it "should require projects to have environments" do
+  it "requires projects to have environments" do
     project = stub(:Project, :has_environments? => false, :path => "my_project")
     error_message = /my_project: no environments/
     expect { visitor.visit_project(project) }.to raise_error ConfigError, error_message
@@ -36,7 +36,7 @@ describe "ConfigValidator::ConfigValidatorVisitor" do
     expect { visitor.visit_project(project) }.not_to raise_error ConfigError, error_message
   end
 
-  it "should require environments to have servers" do
+  it "requires environments to have servers" do
     environment = stub(:Environment, :has_servers? => false, :path => "my_project:my_environment")
     error_message = /my_project:my_environment: no servers/
     expect { visitor.visit_environment(environment) }.to raise_error ConfigError, error_message
@@ -45,7 +45,7 @@ describe "ConfigValidator::ConfigValidatorVisitor" do
     expect { visitor.visit_environment(environment) }.not_to raise_error ConfigError, error_message
   end
 
-  it "should require servers to have host" do
+  it "requires servers to have host" do
     server = stub(:Server, :host => '', :path => "my_project:my_environment:my_server", :global_alias => nil)
     error_message = /my_project:my_environment:my_server: host is not defined/
     expect { visitor.visit_server(server) }.to raise_error ConfigError, error_message
@@ -54,7 +54,7 @@ describe "ConfigValidator::ConfigValidatorVisitor" do
     expect { visitor.visit_server(server) }.not_to raise_error ConfigError, error_message
   end
 
-  it "should require servers to have unique global server aliases" do
+  it "requires servers to have unique global server aliases" do
     server1 = stub(:Server, :host => 'the-host1', :path => "my_project:my_environment:my_server", :global_alias => 'foo')
     server2 = stub(:Server, :host => 'the-host2', :path => "my_project:my_environment2:my_server3", :global_alias => 'foo')
     error_message = /my_project:my_environment2:my_server3: global alias 'foo' has already been taken.*my_project:my_environment:my_server/
@@ -63,7 +63,7 @@ describe "ConfigValidator::ConfigValidatorVisitor" do
     expect { @visitor.visit_server(server2) }.to raise_error ConfigError, error_message
   end
 
-  it "should require commands to have command specified" do
+  it "requires commands to have command specified" do
     command = stub(:Command, :command => '', :name => 'qux')
     error_message = /execute/
     expect { visitor.visit_command(command) }.to raise_error ConfigError, error_message

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

@@ -16,6 +16,36 @@ describe "BaseConstruct" do
     expect(construct.qualified_name).to eq('test_base_construct my_node')
   end
 
+  specify "#parent= sets default server config to parent's default server config" do
+    parent_default_server_config = proc {}
+    construct.parent = stub(:default_server_config => parent_default_server_config)
+    expect(construct.default_server_config).to eq(parent_default_server_config)
+  end
+
+  describe "#default_server_config=" do
+    let(:default_server_config) { proc { call_from_self } }
+    let(:context) { stub }
+
+    it "sets default server config" do
+      construct.default_server_config = default_server_config
+      context.should_receive(:call_from_self)
+      context.instance_eval(&construct.default_server_config)
+    end
+
+    it "merges given config to parent's default server config" do
+      construct.parent = stub(:default_server_config => proc { call_from_parent })
+      construct.default_server_config = default_server_config
+
+      context.should_receive(:call_from_parent).ordered
+      context.should_receive(:call_from_self).ordered
+      context.instance_eval(&construct.default_server_config)
+    end
+  end
+
+  it "has an empty proc as an initial default server config" do
+    expect(construct.default_server_config.call).to eq(nil)
+  end
+
 end
 
 

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

@@ -13,16 +13,10 @@ describe "Environment" do
 
   it_behaves_like "a construct with nodes", :servers, :server
 
-  specify "#append_server sets environment attribute on a server to self" do
-    server = mock(:Server, :name => :foo)
-    server.should_receive(:environment=).with(environment)
-    environment.append_server(server)
-  end
-
   specify "#project_name returns project name" do
     environment.project = stub(:Project, :name => "TheProject")
     expect(environment.project_name).to eq("TheProject")
-  end 
+  end
 end
 
 

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

@@ -10,7 +10,7 @@ describe "Project" do
   it "has name" do
     expect(project.name).to eq(:foo)
   end
-  
+
   specify "#append_environment sets project attribute on an environment to self" do
     environment = mock(:Environment, :name => :bar)
     environment.should_receive(:project=).with(project)

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

@@ -30,14 +30,14 @@ describe "Server" do
     expect(server.default_command).to eq(:qux)
   end
 
-  describe "#environment=" do
-    let(:environment) { environment = stub(:Environment, :name => :the_environment) }
+  describe "#parent=" do
+    let(:environment) { environment = stub(:Environment, :name => :the_environment, :default_server_config => proc {}) }
 
     it { should have_accessor(:environment, environment) }
 
     it "sets RAILS_ENV environment variable" do
       server.environment_variables.should == {}
-      server.environment = environment
+      server.parent = environment
       expect(server.environment_variables[:RAILS_ENV]).to eq(environment.name.to_s)
     end
   end

data/spec/lib/taketo/dsl_spec.rb

@@ -8,11 +8,15 @@ describe "DSL" do
   extend DSLSpec
   include DSLSpec
 
-  shared_examples "a scoped construct" do |name, parent_scope_name, with_block|
-    parent_scope = scopes[parent_scope_name]
-    it { should be_appropriate_construct(name, :foo).with_block(with_block).under(parent_scope) }
+  shared_examples "a scoped construct" do |name, parents, with_block|
+    parents = Array(parents)
+
+    parents.each do |parent_scope_name|
+      parent_scope = scopes[parent_scope_name]
+      it { should be_appropriate_construct(name, :foo).with_block(with_block).under(parent_scope) }
+    end
 
-    scopes.except(parent_scope_name).each do |inappropriate_scope|
+    scopes.except(*parents).each do |inappropriate_scope|
       it { should_not be_appropriate_construct(name, :foo).with_block(with_block).under(inappropriate_scope) }
     end
   end
@@ -52,16 +56,26 @@ describe "DSL" do
         c.send(scope_name, :bar) {}                                                        #     c.project(:bar) {}
       end                                                                                  #   end
     end                                                                                    # end
+
+    it "sets #{scope_name}'s parent to the #{parent_scope_name} scope object" do           # it "sets project's parent to the config scope object" do
+      dsl(parent_scope, factory.create(parent_scope_name)) do |c|                          #   dsl([:config], factory.create(:config)) do |c|
+        stub_find_or_create_scope_object(c, scope_name, :bar)                              #     stub_find_or_create_scope_object(c, :project, :bar)
+        factory.send(scope_name).should_receive(:parent=).with(c.current_scope_object)     #     factory.project.should_receive(:parent=).with(c.current_scope_object)
+        c.send(scope_name, :bar) {}                                                        #     c.project(:bar) {}
+      end                                                                                  #   end
+    end                                                                                    #
   end
 
-  shared_examples "a scoped method" do |attribute_name, parent_scope_name, parent_scope_method, example_value|
-    it_behaves_like "a scoped construct", attribute_name, parent_scope_name, false
+  shared_examples "a scoped method" do |attribute_name, parent_scope_names, parent_scope_method, example_value|
+    it_behaves_like "a scoped construct", attribute_name, parent_scope_names, false
 
-    it "calls #{parent_scope_method} on current #{parent_scope_name}" do                        # it "calls default_location= on current server" do
-      dsl(scopes[parent_scope_name], factory.create(parent_scope_name, :foo)) do |c|            #   dsl([:config, :project, :environment, :server], factory.create(:server, :foo)) do |c|
-        factory.send(parent_scope_name).should_receive(parent_scope_method).with(example_value) #     factory.server.should_receive(:default_location=).with('/var/app/')
-        c.send(attribute_name, example_value)                                                   #   c.location "/var/app"
-      end                                                                                       # end
+    Array(parent_scope_names).each do |parent_scope_name|
+      it "calls #{parent_scope_method} on current #{parent_scope_name}" do                        # it "calls default_location= on current server" do
+        dsl(scopes[parent_scope_name], factory.create(parent_scope_name, :foo)) do |c|            #   dsl([:config, :project, :environment, :server], factory.create(:server, :foo)) do |c|
+          factory.send(parent_scope_name).should_receive(parent_scope_method).with(example_value) #     factory.server.should_receive(:default_location=).with('/var/app/')
+          c.send(attribute_name, example_value)                                                   #   c.location "/var/app"
+        end                                                                                       # end
+      end
     end
   end
 
@@ -69,6 +83,18 @@ describe "DSL" do
     it_behaves_like "a scoped method", :default_destination, :config, :default_destination=, "foo:bar:baz"
   end
 
+  describe "#default_server_config" do
+    it_behaves_like "a scoped construct", :default_server_config, [:config, :project, :environment]
+
+    it "stores a block" do
+      dsl(scopes[:config], factory.create(:config)) do |c|
+        cfg = proc { any_method_call_here }
+        factory.config.should_receive(:default_server_config=).with(cfg)
+        c.default_server_config(&cfg)
+      end
+    end
+  end
+
   describe "#shared_server_config" do
     it_behaves_like "a scoped construct", :shared_server_config, :config
 
@@ -84,14 +110,14 @@ describe "DSL" do
   describe "#include_shared_server_config" do
     it "executes the block on dsl object in server scope for given shared config names" do
       dsl(scopes[:server], factory.create(:server)) do |c|
-        c.stub(:shared_server_configs => { :foo => proc { any_method_call_here }, :bar => proc { second_method_call_here } })
-        c.should_receive(:any_method_call_here)
-        c.should_receive(:second_method_call_here)
+        c.stub(:shared_server_configs => { :foo => proc { call_from_foo }, :bar => proc { call_from_bar } })
+        c.should_receive(:call_from_foo)
+        c.should_receive(:call_from_bar)
         c.include_shared_server_config(:foo, :bar)
       end
     end
 
-    context "when the only argument is hash where shared config names are keys" do
+    context "when the argument is hash where shared config names are keys" do
       context "when hash values are arrays" do
         it "includes config corresponding to hash key and passes exploded arguments" do
           dsl(scopes[:server], factory.create(:server)) do |c|
@@ -113,6 +139,17 @@ describe "DSL" do
       end
     end
 
+    context "whne there are symbol arguments (names of shared configs) and a hash" do
+      it "includes config corresponding to symbol arguments and hash keys" do
+        dsl(scopes[:server], factory.create(:server)) do |c|
+          c.stub(:shared_server_configs => { :foo => proc { call_from_foo }, :bar => proc { |qux| call_from_bar(qux) } })
+          c.should_receive(:call_from_foo)
+          c.should_receive(:call_from_bar).with(123)
+          c.include_shared_server_config(:foo, :bar => 123)
+        end
+      end
+    end
+
     it "raises 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!")
@@ -131,6 +168,20 @@ describe "DSL" do
   describe "#server" do
     it_behaves_like "a scope", :server, :environment
 
+    it "evaluates default_server_config" do
+      dsl(scopes[:environment], factory.create(:environment, :foo)) do |c|
+        stub_find_or_create_scope_object(c, :server, :bar)
+
+        default_server_config = proc { some_setup }
+        factory.server.stub(:default_server_config => default_server_config)
+
+        c.should_receive(:some_setup)
+
+        c.server(:bar) do
+        end
+      end
+    end
+
     it "has name optional" do
       dsl(scopes[:environment], factory.create(:environment, :foo)) do |c|
         stub_find_or_create_scope_object(c, :server, :default)

data/spec/support/helpers/dsl_spec_helper.rb

@@ -7,23 +7,23 @@ module DSLSpec
     end
 
     def create_config(*args)
-      @config ||= RSpec::Mocks::Mock.new(:Config).as_null_object
+      @config ||= RSpec::Mocks::Mock.new(:Config, :default_server_config => proc {}).as_null_object
     end
 
     def create_project(name = :foo)
-      @project ||= RSpec::Mocks::Mock.new(:Project, :name => name).as_null_object
+      @project ||= RSpec::Mocks::Mock.new(:Project, :name => name, :default_server_config => proc {}).as_null_object
     end
 
     def create_environment(name = :foo)
-      @environment ||= RSpec::Mocks::Mock.new(:Environment, :name => name).as_null_object
+      @environment ||= RSpec::Mocks::Mock.new(:Environment, :name => name, :default_server_config => proc {}).as_null_object
     end
 
     def create_server(name = :foo)
-      @server ||= RSpec::Mocks::Mock.new(:Server, :name => name).as_null_object
+      @server ||= RSpec::Mocks::Mock.new(:Server, :name => name, :default_server_config => proc {}).as_null_object
     end
 
     def create_command(name = :the_cmd)
-      @command ||= RSpec::Mocks::Mock.new(:Command, :name => name).as_null_object
+      @command ||= RSpec::Mocks::Mock.new(:Command, :name => name, :default_server_config => proc {}).as_null_object
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: taketo
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-08 00:00:00.000000000 Z
+date: 2012-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -138,6 +138,7 @@ files:
 - features/config.feature
 - features/config_validation.feature
 - features/connect_to_server.feature
+- features/default_server_config.feature
 - features/error_handling.feature
 - features/help.feature
 - features/step_definitions/main_steps.rb