peony 0.1.9 → 0.3.0

data/recipes/db/mysql.rake

@@ -1,47 +1,65 @@
-set_default :mysql_home,        `brew --prefix mysql`.strip
-set_default :mysqld,            '/usr/local/bin/mysqld_safe'
-set_default :mysqladmin,        '/usr/local/bin/mysqladmin'
-set_default :mysql_install_db,  '/usr/local/bin/mysql_install_db'
+scope :mysql do
+  set_default :home,              `brew --prefix mysql`.strip
+  set_default :server,            '/usr/local/bin/mysql.server'
+  set_default :mysqld,            '/usr/local/bin/mysqld_safe'
+  set_default :mysqladmin,        '/usr/local/bin/mysqladmin'
+  set_default :mysql_install_db,  '/usr/local/bin/mysql_install_db'
 
-set_default :mysql_dir,         ->{ "#{data_dir}/mysql/#{mysql_port}" }
-set_default :mysql_log_dir,     ->{ "#{log_dir}/mysql/#{mysql_port}" }
-set_default :mysql_conf,        ->{ "#{etc_dir}/my.cnf" }
+  set_default :data_dir,          ->{ "#{data_dir}/mysql/#{mysql.port}" }
+  set_default :log_dir,           ->{ "#{log_dir}/mysql/#{mysql.port}" }
+  set_default :config_file,       ->{ "/etc/my.cnf" }
 
-set_default :mysql_user,        'root'
-set_default :mysql_password,    '123456'
+  set_default :log_error,         ->{ "#{mysql.log_dir}/error.log" }
 
-set_default :mysql_pid_file,    ->{ "#{run_dir}/mysql/#{mysql_port}.pid" }
-set_default :mysql_port,        '3306'
-set_default :mysql_socket,      '/tmp/mysql.sock'
-set_default :mysql_charset,     'UTF8'
-set_default :mysql_general_log, 'ON'
-set_default :mysql_slow_query_log, 'ON'
+  set_default :user,              'root'
+  set_default :password,          '123456'
 
-set_default :mysql_start,       ->{ "#{mysqld}  --defaults-file=#{mysql_conf} --datadir=#{mysql_dir} --basedir=#{mysql_home} &" }
-set_default :mysql_stop,        ->{ "#{mysqladmin} --verbose --user=#{mysql_user} --password=#{mysql_password} shutdown" }
-set_default :mysql_status,      ->{ "#{mysqladmin} --verbose status variables" }
+  set_default :pid_file,          ->{ "#{run_dir}/mysql/#{mysql.port}.pid" }
+  set_default :port,              '3306'
+  set_default :socket,            '/tmp/mysql.sock'
+  set_default :charset,           'UTF8'
+  set_default :general_log,       'ON'
+  set_default :slow_query_log,    'ON'
+
+  set_default :run_cmd,      ->{ ->(cmd){"#{mysql.server} #{cmd} --basedir=#{mysql.home} --datadir=#{mysql.data_dir} --pid-file=#{mysql.pid_file} --user=#{user}"} }
+
+  #set_default :start,         ->{ "#{mysql.mysqld}  --defaults-file=#{mysql.config_file} --datadir=#{mysql.data_dir} --basedir=#{mysql.home} &" }
+  #set_default :stop,        ->{ "#{mysql.mysqladmin} --verbose --user=#{mysql.user} --password=#{mysql.password} shutdown" }
+  #set_default :status,      ->{ "#{mysql.mysqladmin} --verbose status variables" }
+end
 
 namespace :db do
-  
   namespace :mysql do
-    
     desc 'Create mysql directorys, config file and run mysql_install_db'
     task :init do
-      mkdir_p(mysql_dir, mysql_log_dir, "#{run_dir}/mysql/")
-      template('mysql/my.cnf.erb', mysql_conf, true)
-      run "#{mysql_install_db} --defaults-file=#{mysql_conf} --datadir=#{mysql_dir} --basedir=#{mysql_home}" if Dir["#{mysql_dir}/*"].empty?
+      mkdir_p(mysql.data_dir, mysql.log_dir, "#{run_dir}/mysql/")
+      template('mysql/my.cnf.erb', mysql.config_file, true)
+      inside mysql.home do
+        unless File.exist? "#{mysql.data_dir}/mysql/user.frm"
+          ENV['TMPDIR'] = nil
+          run "#{mysql.mysql_install_db} --verbose --user=#{mysql.user} --basedir=#{mysql.home} --datadir=#{mysql.data_dir} --tmpdir=/tmp"
+        end
+        #run "#{mysql.mysql_install_db} --defaults-file=#{mysql.config_file} --datadir=#{mysql.data_dir} --basedir=#{mysql.home}" if Dir["#{mysql.data_dir}/*"].empty?
+      end
     end
-    
-    [:start, :stop, :status].each do|t|
+
+    [:start, :stop, :restart, :reload, :"force-reload", :status].each do|t|
       desc "#{t} mysql instance."
       task t do
-        run self.send("mysql_#{t}")
+        run mysql.run_cmd.call(t)
       end
     end
-    
+=begin
+    [:start].each do|t|
+      desc "#{t} mysql instance."
+      task t do
+        run mysql.send(t)
+      end
+    end
+=end
     desc 'Set mysql root user password.'
     task :set_root_pass do
-      run "mysqladmin --no-defaults --port=#{mysql_port} --user=root --protocol=tcp password '#{mysql_password}'"
+      run "#{mysql.mysqladmin} --no-defaults --port=#{mysql.port} --user=root --protocol=tcp password '#{mysql.password}'"
     end
     
     namespace :web do

data/recipes/db/pg.rake

@@ -1,33 +1,36 @@
-set_default :pg_home,     ->{ `brew --prefix postgresql`.strip }
-set_default :pg_initdb,   '/usr/local/bin/initdb'
-set_default :pg_ctl,      '/usr/local/bin/pg_ctl'
+scope :pg do
+  set_default :home,        ->{ `brew --prefix postgresql`.strip }
+  set_default :initdb,      '/usr/local/bin/initdb'
+  set_default :pg_ctl,      '/usr/local/bin/pg_ctl'
 
-set_default :pg_data_dir,   ->{ "#{data_dir}/pgsql" }
-set_default :pg_init,       ->{ "#{pg_initdb} -D #{pg_data_dir} --debug" }
-set_default :pg_start,      ->{ "#{pg_ctl} -D #{pg_data_dir} -l #{log_dir}/pgsql.log start" }
-set_default :pg_stop,       ->{ "#{pg_ctl} -D #{pg_data_dir} stop" }
-set_default :pg_reload,     ->{ "#{pg_ctl} -D #{pg_data_dir} reload" }
-set_default :pg_restart,    ->{ "#{pg_ctl} -D #{pg_data_dir} -l #{log_dir}/pgsql.log restart" }
+  set_default :data_dir,    ->{ "#{data_dir}/pgsql" }
+  set_default :run_cmd,     ->{ lambda{|cmd| "#{pg.pg_ctl} #{cmd} -D #{pg.data_dir} -l #{log_dir}/pgsql.log" }}
+  set_default :init,        ->{ "#{pg.pg_ctl} -D #{pg.data_dir} --debug init" }
+  #set_default :start,       ->{ "#{pg.pg_ctl} -D #{pg.data_dir} -l #{log_dir}/pgsql.log start" }
+  #set_default :stop,        ->{ "#{pg.pg_ctl} -D #{pg.data_dir} stop" }
+  #set_default :reload,      ->{ "#{pg.pg_ctl} -D #{pg.data_dir} reload" }
+  #set_default :restart,     ->{ "#{pg.pg_ctl} -D #{pg.data_dir} -l #{log_dir}/pgsql.log restart" }
 
-set_default :pg_super_users, {
-  pgsql: '123456'
-}
+  set_default :super_users, {
+      pgsql: '123456'
+  }
+end
 
 namespace :db do
   namespace :pg do
     
     desc 'Execute postgres initdb.'
     task :init do
-      if File.exists?("#{pg_data_dir}/postgresql.conf")
+      if File.exists?("#{pg.data_dir}/postgresql.conf")
         say 'Postgresql database has already initialized.', :magenta, true
       else
-        run pg_init
+        run pg.run_cmd.call(:init)
       end
     end
     
     desc 'Set super users for postgresql.'
     task :set_super_users do
-      pg_super_users.each do|user, password|
+      pg.super_users.each do|user, password|
         sqls = ["CREATE USER #{user} WITH PASSWORD '#{password}';", "ALTER USER #{user} WITH SUPERUSER;"]
         sqls.each do|sql|
           run "psql -d postgres -c \"#{sql}\""
@@ -35,10 +38,10 @@ namespace :db do
       end
     end
     
-    [:start, :stop, :restart, :reload].each do|cmd|
+    [:start, :stop, :restart, :reload, :status].each do|cmd|
       desc "#{cmd} postgresql instance."
       task cmd do
-        run self.send("pg_#{cmd}")
+        run pg.run_cmd.call(cmd)
       end
     end
   end

data/recipes/db/redis.rake

@@ -1,35 +1,37 @@
-set_default :redis_conf,      ->{ "#{etc_dir}/redis.conf" }
-set_default :redis_dir,       ->{ "#{data_dir}/redis" }
-set_default :redis_pid,       ->{ "#{run_dir}/redis.pid" }
-set_default :redis_port,      6379
+scope :redis do
+  set_default :config_file,       ->{ "#{etc_dir}/redis.conf" }
+  set_default :data_dir,          ->{ "#{data_dir}/redis" }
+  set_default :pid_file,          ->{ "#{run_dir}/redis.pid" }
+  set_default :port,              6379
 
-set_default :redis_start,     ->{ "redis-server #{redis_conf}" }
-set_default :redis_stop,      ->{ "redis-cli -p #{redis_port} shutdown" }
-set_default :redis_restart,   ->{ "kill -2 `#{redis_pid}` && #{redis_start}" }
+  set_default :start,             ->{ "redis-server #{redis.config_file}" }
+  set_default :stop,              ->{ "redis-cli -p #{redis.port} shutdown" }
+  set_default :restart,           ->{ "kill -2 `#{redis.pid_file}` && #{redis.start}" }
 
-set_default :redis_daemonize,         'yes'
-set_default :redis_timeout,           0
-set_default :redis_loglevel,          'notice'
-set_default :redis_logfile,           'stdout'
-set_default :redis_databases,         16
-set_default :rdbcompression,          'yes'
-set_default :rdbchecksum,             'yes'
-set_default :redis_dbfilename,        'dump.rdb'
-set_default :redis_appendonly,        'yes'
-set_default :redis_activerehashing,   'yes'
+  set_default :daemonize,         'yes'
+  set_default :timeout,           0
+  set_default :loglevel,          'notice'
+  set_default :logfile,           'stdout'
+  set_default :databases,         16
+  set_default :rdbcompression,    'yes'
+  set_default :rdbchecksum,       'yes'
+  set_default :dbfilename,        'dump.rdb'
+  set_default :appendonly,        'yes'
+  set_default :activerehashing,   'yes'
+end
 
 namespace :db do
   namespace :redis do
     desc 'Initialize redis directory and copy redis.conf to etc directory.'
     task :init do
-      mkdir_p(redis_dir)
-      template('redis.conf.erb', redis_conf)
+      mkdir_p(redis.data_dir)
+      template('redis.conf.erb', redis.config_file)
     end
     
     [:start, :stop, :restart].each do|cmd|
       desc "#{cmd} redis"
       task cmd do     
-        run self.send("redis_#{cmd}")
+        run redis.send(cmd)
       end
     end
   end

data/recipes/elasticsearch.rake

@@ -1,28 +1,30 @@
-set_default :es_plugins_dir,  '/usr/local/var/lib/elasticsearch/plugins'
-set_default :es_cluster_name, 'default_cluster'
-set_default :es_data_dir,     ->{ "#{data_dir}/elasticsearch/" }
-set_default :es_network_host, '127.0.0.1'
-set_default :es_config,       ->{ "#{etc_dir}/elasticsearch/config.yml" }
+scope :es do
+  set_default :plugins_dir,  '/usr/local/var/lib/elasticsearch/plugins'
+  set_default :cluster_name, 'default_cluster'
+  set_default :data_dir,     ->{ "#{data_dir}/elasticsearch/" }
+  set_default :network_host, '127.0.0.1'
+  set_default :config_file,  ->{ "#{etc_dir}/elasticsearch/config.yml" }
 
-#-f can let elasticsearch running in the foreground
-set_default :elasticsearch_start, ->{ "elasticsearch -D es.config=#{es_config} -p #{run_dir}/elasticsearch.pid" }
-#set_default :elasticsearch_stop, ->{"elasticsearch -D es.config=#{es_config} -p #{run_dir}/elasticsearch.pid stop"}
-set_default :elasticsearch_stop,  ->{ "kill `cat #{run_dir}/elasticsearch.pid`" }
-set_default :elasticsearch_shutdown, ->{ "curl -XPOST 'http://#{es_network_host}:9200/_shutdown'" }
+  #-f can let elasticsearch running in the foreground
+  set_default :start, ->{ "elasticsearch -d --config=#{es.config_file} -p #{run_dir}/elasticsearch.pid" }
+  #set_default :elasticsearch_stop, ->{"elasticsearch -D es.config=#{es_config} -p #{run_dir}/elasticsearch.pid stop"}
+  set_default :stop,  ->{ "kill `cat #{run_dir}/elasticsearch.pid`" }
+  set_default :shutdown, ->{ "curl -XPOST 'http://#{es.network_host}:9200/_shutdown'" }
+end
 
 namespace :elasticsearch do
   
   desc "Initialize elasticsearch directory and copy it's config files to etc path."
   task :init do  
     mkdir_p("#{etc_dir}/elasticsearch")
-    template('elasticsearch/config.yml.erb', es_config)
+    template('elasticsearch/config.yml.erb', es.config_file)
     template('elasticsearch/logging.yml.erb', "#{etc_dir}/elasticsearch/logging.yml")
   end
   
   [:start, :stop, :shutdown].each do|cmd|
     desc "#{cmd} elasticsearch."
     task cmd do     
-      run self.send("elasticsearch_#{cmd}")
+      run es.send("#{cmd}")
     end
   end
 end

data/recipes/httpd.rake

@@ -1,26 +1,28 @@
-set_default :httpd,               '/usr/sbin/httpd'
-set_default :httpd_server_root,   '/usr'
-set_default :httpd_share_dir,     '/usr/share/httpd'
+scope :httpd do
+  set_default :bin,                 '/usr/sbin/httpd'
+  set_default :server_root,         '/usr'
+  set_default :share_dir,           '/usr/share/httpd'
 
-set_default :httpd_etc_dir,       ->{ "#{etc_dir}/httpd" }
-set_default :httpd_conf,          ->{ "#{httpd_etc_dir}/httpd.conf" }
+  set_default :etc_dir,             ->{ "#{etc_dir}/httpd" }
+  set_default :config_file,           ->{ "#{httpd.etc_dir}/httpd.conf" }
 
-set_default :httpd_log_dir,       ->{ "#{log_dir}/httpd" }
-set_default :webdav_dir,          ->{ "#{var_dir}/webdav" }
-set_default :auth_user_file,      ->{ "#{httpd_etc_dir}/user.passwd" }
-set_default :httpd_server_admin,  'zhiqiangzhan@gmail.com'
-set_default :httpd_port,          8888
-set_default :httpd_server_name,   ->{ "localhost:#{httpd_port}" }
+  set_default :log_dir,             ->{ "#{log_dir}/httpd" }
+  set_default :webdav_dir,          ->{ "#{var_dir}/webdav" }
+  set_default :auth_user_file,      ->{ "#{httpd.etc_dir}/user.passwd" }
+  set_default :server_admin,        'zhiqiangzhan@gmail.com'
+  set_default :port,                6789
+  set_default :server_name,         ->{ "localhost:#{httpd.port}" }
 
-set_default :auth_user,           'admin'
+  set_default :auth_user,           'admin'
+end
 
 namespace :httpd do 
   desc 'Initialize httpd config files.'
   task :init do
-    mkdir_p(httpd_etc_dir, "#{httpd_etc_dir}/extra", httpd_log_dir, webdav_dir)
-    search_paths.each do|sp|
-      Dir["#{sp}/httpd/conf/*.erb"].each do|fn|
-        target = fn.sub("#{sp}/httpd", "#{httpd_etc_dir}").sub(/.erb$/, "")
+    mkdir_p(httpd.etc_dir, "#{httpd.etc_dir}/extra", httpd.log_dir, httpd.webdav_dir)
+    template_paths.each do|tp|
+      Dir["#{tp}/httpd/**/*.erb"].each do|fn|
+        target = fn.sub("#{tp}/httpd", "#{httpd.etc_dir}").sub(/.erb$/, '')
         template(fn, target) unless File.exists?(target)
       end
     end
@@ -28,14 +30,14 @@ namespace :httpd do
   
   desc 'Create AuthUserFile.'
   task :auth_user_file do
-    run "htpasswd -c #{auth_user_file} #{auth_user}"
+    run "htpasswd -c #{httpd.auth_user_file} #{httpd.auth_user}"
   end
   
   namespace :webdav do
     [:start, :restart, :stop].each do|t|
       desc "#{t} httpd instance."
       task t do
-        run "#{httpd} -f #{httpd_conf} -k #{t}"
+        run "#{httpd.bin} -f #{httpd.config_file} -k #{t}"
       end
     end
   end

data/recipes/nginx/www.rake

@@ -1,14 +1,16 @@
-set_default :www_http_port, 80
-set_default :www_https_port, 443
-set_default :www_paths, {}
+scope :nginx do
+  set_default :www_http_port, 80
+  set_default :www_https_port, 443
+  set_default :www_paths, {}
+end
 
 namespace :nginx do
   namespace :www do
     desc 'Create www config files.'
     task :init do
-      template('nginx/www.conf.erb', "#{nginx_etc_dir}/www.conf", true)
-      template('nginx/sites-enabled/static.conf.erb', "#{nginx_etc_dir}/sites-enabled/static.http.conf", true) unless www_paths.empty?
-      template('nginx/sites-enabled/php.conf.erb', "#{nginx_etc_dir}/sites-enabled/php.http.conf", true)
+      template('nginx/www.conf.erb', "#{nginx.etc_dir}/www.conf", true)
+      template('nginx/sites-enabled/static.conf.erb', "#{nginx.etc_dir}/sites-enabled/static.http.conf", true) unless nginx.www_paths.empty?
+      template('nginx/sites-enabled/php.conf.erb', "#{nginx.etc_dir}/sites-enabled/php.http.conf", true)
     end
     
     [:start, :stop, :reload].each do|t|

data/recipes/nginx.rake

@@ -1,38 +1,40 @@
-set_default :nginx,         ->{ '/usr/local/bin/nginx' }
-set_default :nginx_home,    ->{ `brew --prefix nginx`.strip }
-set_default :nginx_etc_dir, ->{ "#{etc_dir}/nginx" }
-set_default :nginx_run_dir, ->{ "#{run_dir}/nginx" }
-set_default :nginx_prefix,  ->{ "#{log_dir}/nginx" }
+scope :nginx do
+  set_default :bin,     ->{ '/usr/local/bin/nginx' }
+  set_default :home,    ->{ `brew --prefix nginx`.strip }
+  set_default :etc_dir, ->{ "#{etc_dir}/nginx" }
+  set_default :run_dir, ->{ "#{run_dir}/nginx" }
+  set_default :prefix,  ->{ "#{log_dir}/nginx" }
 
-set_default :worker_processes, 8
-            
-set_default :upstreams, [
-  {name: :fastcgi_server, servers: ['127.0.0.1:6666']},
-  {name: :catalina_server, servers: ['127.0.0.1:8080']}
-]
+  set_default :worker_processes, 8
 
-set_default :server_name, 'localhost'
+  set_default :upstreams, [
+      {name: :fastcgi_server, servers: ['127.0.0.1:6666']},
+      {name: :catalina_server, servers: ['127.0.0.1:8080']}
+  ]
 
-set_default :use_ssl, false
-set_default :ssl_certificate,	    ->{"#{etc_dir}/ssl/server.crt"}	  
-set_default :ssl_certificate_key, ->{"#{etc_dir}/ssl/server.key"}
+  set_default :server_name, 'localhost'
 
+  set_default :use_ssl,     true
+  set_default :ssl_certificate,	    ->{"#{etc_dir}/ssl/server.crt"}
+  set_default :ssl_certificate_key, ->{"#{etc_dir}/ssl/server.key"}
+end
 
 def nginx_start_cmd(name)
-  "#{nginx} -c #{nginx_etc_dir}/#{name}.conf -p #{nginx_prefix}"
+  "#{nginx.bin} -c #{nginx.etc_dir}/#{name}.conf -p #{nginx.prefix}"
 end
 
 def nginx_stop_cmd(name)
-  "#{nginx} -s quit -c #{nginx_etc_dir}/#{name}.conf -p #{nginx_prefix}"
+  "#{nginx.bin} -s quit -c #{nginx.etc_dir}/#{name}.conf -p #{nginx.prefix}"
 end
 
 def nginx_reload_cmd(name)
-  "#{nginx} -s reload -c #{nginx_etc_dir}/#{name}.conf -p #{nginx_prefix}"
+  "#{nginx.bin} -s reload -c #{nginx.etc_dir}/#{name}.conf -p #{nginx.prefix}"
 end
 
 def nginx_restart(name)
+  say_status :restart, 'restart nginx', :green
   invoke "nginx:#{name}:stop"
-  puts 'Start nginx......'
+  say 'Start nginx......', :yellow
   sleep 5
   invoke "nginx:#{name}:start"
 end
@@ -40,10 +42,10 @@ end
 namespace :nginx do
   desc "Initialize nginx directory and create it's config files."
   task :init do
-    mkdir_p(nginx_etc_dir, nginx_run_dir, nginx_prefix, nginx_log_dir)
-    unless File.exists?("#{nginx_etc_dir}/conf")
-      FileUtils.cp_r(find_templates("nginx/conf", false).first, nginx_etc_dir)
+    mkdir_p(nginx.etc_dir, nginx.run_dir, nginx.prefix)
+    unless File.exists?("#{nginx.etc_dir}/conf")
+      FileUtils.cp_r(find_templates("nginx/conf", false).first, nginx.etc_dir)
     end
-    FileUtils.mkdir_p("#{nginx_etc_dir}/sites-enabled") unless File.exists?("#{nginx_etc_dir}/sites-enabled")
+    FileUtils.mkdir_p("#{nginx.etc_dir}/sites-enabled") unless File.exists?("#{nginx.etc_dir}/sites-enabled")
   end
 end

data/recipes/php.rake

@@ -1,7 +1,12 @@
-set_default :php_home, ->{"#{share_dir}/php5"}
-set_default :php_cgi, ->{"#{php_home}/bin/php-cgi"}
-set_default :spawn_fcgi, "/usr/local/bin/spawn-fcgi"
-set_default :fcgi_run_dir, ->{"#{run_dir}/fcgi"}
+scope :php do
+  set_default :home,          ->{ "#{share_dir}/php5" }
+  set_default :php_cgi,       ->{ "#{php.home}/bin/php-cgi" }
+  set_default :spawn_fcgi,    '/usr/local/bin/spawn-fcgi'
+  set_default :fcgi_run_dir,  ->{ "#{run_dir}/fcgi" }
+  set_default :fcgi_address,  '127.0.0.1'
+  set_default :fcgi_port,     6666
+  set_default :fcgi_children, 6
+end
 
 namespace :php do
   namespace :fcgi do
@@ -12,7 +17,7 @@ namespace :php do
     
     desc 'Start fcgi.'
     task :start => :init do
-      run "#{spawn_fcgi} -a 127.0.0.1 -p 6666 -C 6 -f #{php_cgi} -u #{user} -P #{fcgi_run_dir}/spawn_fcgi.pid > /dev/null"
+      run "#{php.spawn_fcgi} -a #{php.fcgi_address} -p #{php.fcgi_port} -C #{php.fcgi_children} -f #{php.php_cgi} -u #{user} -d #{php.fcgi_run_dir} -P #{php.fcgi_run_dir}/spawn_fcgi.pid > /dev/null"
     end
     
     desc 'Kill fcgi.'

data/spec/peony_spec.rb

@@ -25,6 +25,9 @@ describe Peony do
     it 'should can run command' do
       peony do
         run "echo 'Hello World!'"
+        with_padding do
+          run "echo 'Hello World!'"
+        end
         run 'ls -l'
 
         inside 'lib/peony' do

data/spec/scope_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Peony do
+  describe 'Scope' do
+    it 'should can set and get value' do
+      root_scope = Peony::Scope.new(:root)
+      scope = Peony::Scope.new(:my, root_scope)
+      root_scope[:a], scope[:b] = 1, 2
+
+      scope.has_key?(:a).should be_true
+      scope.key?(:a).should be_true
+      scope.include?(:a).should be_true
+      scope.local?(:a).should be_false
+
+      scope[:a].should == 1
+      scope.set(:a, 2)
+      scope[:a].should == 2
+      root_scope[:a].should == 2
+
+      scope[:b].should == 2
+      root_scope[:b].should == nil
+      scope.set(:b, 3)
+      scope[:b].should == 3
+      root_scope[:b].should == nil
+
+      root_scope.set(:b, 5)
+      scope[:b].should == 3
+      root_scope[:b].should == 5
+
+      scope.local(:a, 6)
+      scope[:a].should == 6
+      root_scope[:a].should == 2
+      scope[:a] = 8
+      scope[:a].should == 8
+      root_scope[:a].should == 2
+
+      scope.a.should == 8
+      root_scope.a.should == 2
+      scope.a?.should be_true
+
+      scope.delete(:a)
+      scope[:a] = 9
+      scope[:a].should == 9
+      root_scope[:a].should == 9
+
+    end
+  end
+end

data/spec/settings_in_rake_spec.rb

@@ -34,6 +34,66 @@ describe 'Settings in rake tasks' do
         set :path, lambda { "/var/www/#{settings.version!}" }
       }
       peony.path
-    }.to raise_error(Peony::Error, /version/)
+    }.to raise_error(KeyError, /version/)
   end
+
+  it '#settings with default value' do
+      peony {
+        set :a, '100'
+        set_default :a, 3000
+        set_default :b, 6000
+      }
+      peony.a.should == '100'
+      peony.b.should == 6000
+  end
+
+  it '#settings with scope' do
+    peony {
+      set :a, 1
+      set 'e', 1
+      set 'f', 1
+      set 'g', 1
+      scope 'scope1' do
+        set :a, 2
+        set :b, 2
+        set :u, 2
+        set :v, 2
+        set :w, 2
+        scope 'scope2' do
+          set 'a', 3
+          set 'b', 3
+          set 'c', 3
+          set :x, 3
+          set :y, 3
+          set :z, 3
+        end
+      end
+    }
+
+    peony.a.should == 1
+    peony.e.should == 1
+    peony.f.should == 1
+    peony.g.should == 1
+    peony.scope1.a.should == 2
+    peony.scope1.b.should == 2
+    peony.scope1.a.should == 2
+    peony.scope1.u.should == 2
+    peony.scope1.v.should == 2
+    peony.scope1.w.should == 2
+    peony.scope1.scope2.a.should == 3
+    peony.scope1.scope2.b.should == 3
+    peony.scope1.scope2.c.should == 3
+    peony.scope1.scope2.x.should == 3
+    peony.scope1.scope2.y.should == 3
+    peony.scope1.scope2.z.should == 3
+
+    peony.scope1.e.should == 1
+    peony.scope1.f.should == 1
+    peony.scope1.g.should == 1
+    peony.scope1.scope2.u.should == 2
+    peony.scope1.scope2.v.should == 2
+    peony.scope1.scope2.w.should == 2
+  end
+
+
 end

data/spec/settings_spec.rb

@@ -46,7 +46,7 @@ describe Peony::Settings do
     end
     
     it 'question mark should work with nils' do
-      @settings.deploy_to = nil
+      @settings.deploy_to = '/var/www'
       @settings.deploy_to?.should be_true
       @settings.foobar?.should be_false
     end
@@ -63,7 +63,7 @@ describe Peony::Settings do
     end
     
     it 'bangs should check for settings' do
-      expect { @settings.non_existent_setting! }.to raise_error(Peony::Error, /non_existent_setting/)
+      expect { @settings.non_existent_setting! }.to raise_error(KeyError, /non_existent_setting/)
     end
 
     it 'bangs should return settings' do

data/spec/spec_helper.rb

@@ -11,11 +11,9 @@ require 'bundler/setup'
 require 'rake'
 require 'peony'
 
-puts "Peony, version v#{Peony::Version}"
-
 class PeonyScope
   include Rake::DSL  if Rake.const_defined?(:DSL)
-  include Peony::Utils
+  include Peony::Configure
   include Peony::Shell
   include Peony::Actions
 end