marcosgz-cap-recipe 0.0.8 → 0.0.9

data/.gitignore

@@ -3,3 +3,5 @@
 Gemfile.lock
 pkg/*
 .DS_Store
+.rvmrc
+/examples

data/Gemfile

@@ -1 +1,7 @@
 source "http://rubygems.org"
+
+gem "pry"
+gem "rails"
+
+# Specify your gem's dependencies in capistrano-template.gemspec
+gemspec

data/README.md

@@ -5,3 +5,126 @@ Under development
 ```ruby
 require 'capistrano/recipe'
 ```
+
+## Required configs
+```ruby
+set :user, 'admin'
+set :group, 'admin'
+set :domain, 'www.example.com'
+```
+
+### Unicorn
+```ruby
+set :unicorn_setup_settings, {
+  port: 80
+}
+```
+
+### Passenger
+```ruby
+set :passenger_setup_settings, {
+  port: 80
+}
+```
+
+### Thin
+```ruby
+set :thin_setup_settings, {
+  port: 80
+}
+```
+
+### Database
+```ruby
+set :db_setup_settings, {
+  common: {
+    host: '127.0.0.1',
+    database: 'db_name'
+  }
+}
+```
+
+### Gateways
+```ruby
+set :gateways_setup_settings, {
+  common: {
+    example: {
+      username: 'foo',
+      password: 'bar'
+    }
+  }
+}
+```
+
+### Mailers
+```ruby
+set :mailer_setup_settings, {
+  common: {
+    user_name: "email@example.com",
+    password: "secret"
+  }
+}
+```
+
+### Newrelic
+```ruby
+set :newrelic_setup_settings, {
+  common: {
+    app_name: 'AppName',
+    license_key: 'secret'
+  },
+  staging: {
+    app_name: 'AppName (Staging)'
+  }
+}
+```
+
+### Settler
+```ruby
+set :settler_setup_settings, {
+  name: 'String Text',      # "name"        =>  {"alt"=>"name", "value"=>"String Text"}
+  price: 100.0,             # "price"       =>  {"alt"=>"price", "value"=>"100.0", "typecast"=>"float"}
+  views: 9,                 # "views"       =>  {"alt"=>"views", "value"=>"9", "typecast"=>"integer"}
+  approved: true,           # "approved"    =>  {"alt"=>"approved", "value"=>"true", "typecast"=>"boolean"}
+  deleted: false,           # "deleted"     =>  {"alt"=>"deleted", "value"=>"false", "typecast"=>"boolean"}
+  published_at: Time.now,   # "published_at"=>  {"alt"=>"published_at", "value"=>"2013-04-03 16:25:26 -0300", "typecast"=>"datetime"}
+  password: {               # "password"    =>  {"alt"=>"Password", "value"=>"secret", "typecast"=>"password"}
+    alt: 'Password',
+    value: 'secret',
+    typecast: 'password'
+  }
+}
+
+```
+
+### Shards
+```ruby
+set :shards_setup_settings, {
+  databases: {
+    production:{
+      slave1: {}
+    }
+  }
+}
+```
+
+### Tire
+```ruby
+set :tire_setup_settings, {
+  common: {
+    url: "http://localhost:9200"
+  }
+}
+```
+
+### Uploader
+```ruby
+set :uploader_setup_settings, {
+  common: {
+    fog_credentials: {
+      provider: 'Rackspace'
+    },
+    fog_directory: 'public_assets'
+  }
+}
+```

data/lib/capistrano/recipe.rb

@@ -1,5 +1,18 @@
 require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/core_ext/hash/slice'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/hash/indifferent_access'
 require 'capistrano'
 
 Dir.glob(File.join(File.dirname(__FILE__), '/recipes/*.rb')).sort.each { |f| load f }
+
+class DeepToHash
+  def self.to_hash(value)
+    case value
+    when Hash
+      Hash[value.to_hash.map { |key, value| [key, to_hash(value)] }]
+    else
+      value
+    end
+  end
+end

data/lib/capistrano/recipes/application.rb

@@ -1,14 +1,10 @@
 Capistrano::Configuration.instance(:must_exist).load do
 
   set :app_setup_defaults, %w(app:create:dirs app:create:application_server db:setup)
-  set :app_setup_aditional, [] unless exists?(:app_setup_aditional)
-
-  set :user, 'app' unless exists?(:user)
-  set :group, 'app' unless exists?(:group)
 
   namespace :app do
     task :setup, :roles => :app do
-      (fetch(:app_setup_defaults)+fetch(:app_setup_aditional)).each do |name|
+      (fetch(:app_setup_defaults)+_app_setup_aditional).each do |name|
         if (t=top.find_task(name))
           execute_task(t)
         end
@@ -74,4 +70,23 @@ Capistrano::Configuration.instance(:must_exist).load do
 
   end
 
+  def _app_setup_aditional
+    fetch(:app_setup_aditional, [])
+  end
+
+  def fetch_user
+    fetch(:user, 'app')
+  end
+
+  def fetch_group
+    fetch(:group, 'app')
+  end
+
+  def default_rails_environments_hash
+    default_rails_environments.inject({}){|r, v| r.merge Hash[v, {}] }
+  end
+
+  def default_rails_environments
+    fetch(:rails_environments, %w(production development staging test))
+  end
 end

data/lib/capistrano/recipes/database.rb

@@ -1,53 +1,14 @@
-# Example
-# =======
-#
-# db_setup_settings:
-#   common:
-#     host: 127.0.0.1
-#     database: db_name
-
 Capistrano::Configuration.instance(:must_exist).load do
-  set(:database_remote_file) { File.join(shared_path, 'config/database.yml') } unless exists?(:database_remote_file)
-  set(:database_template, 'database.yml.erb') unless exists?(:database_template)
-
-  def database_setup_defaults
-    {
-      'common'      => {
-        'adapter'   => fetch(:database_adapter, 'mysql2'),
-        'encoding'  => fetch(:database_encoding, 'utf8'),
-        'reconnect' => fetch(:database_reconnect, false),
-        'pool'      => fetch(:database_pool, 2),
-        'username'  => fetch(:database_username) { user },
-        'password'  => self[:database_password],
-        'host'      => self[:database_host]
-      },
-      'development' => {},
-      'staging'     => {},
-      'production'  => {},
-      'test'        => {}
-    }
-  end
-
-  # task: `database:setup'
-  def database_template_settings
-    fetch(:db_setup_settings, {}).reverse_merge(
-      database_setup_defaults.keys.inject({}) {|r, e| r.merge Hash[e, Hash.new] }
-    ).inject({}) do |r, (k,v)|
-      r.merge Hash[k, v.reverse_merge(database_setup_defaults[k] || {})]
-    end
-  end
-
   # Required attributes
   # ===================
   # *database_name* prod_db
   namespace :db do
-
     namespace :setup do
       desc "Upload configs"
       task :default, :roles => :app do
         if exists?(:db_setup_settings)
           set(:recipe_settings, database_template_settings)
-          put template.render(fetch(:database_template)), fetch(:database_remote_file)
+          put template.render(_database_template), _database_remote_path
         else
           puts "[FATAL] - Database template settings were not found"
           abort
@@ -56,9 +17,38 @@ Capistrano::Configuration.instance(:must_exist).load do
 
       desc "Download configs"
       task :get, :roles => :db do
-        download fetch(:database_remote_file), File.join(local_rails_root, 'config/database.yml')
+        download _database_remote_path, _database_local_path
       end
     end
+  end
 
+  def database_setup_defaults
+    HashWithIndifferentAccess.new({
+      'common'      => {
+        'adapter'   => fetch(:database_adapter, 'mysql2'),
+        'encoding'  => fetch(:database_encoding, 'utf8'),
+        'reconnect' => fetch(:database_reconnect, false),
+        'username'  => fetch(:database_username) { fetch_user },
+        'password'  => self[:database_password],
+        'host'      => fetch(:database_host, '127.0.1.1')
+      }
+    }.reverse_merge(default_rails_environments_hash))
+  end
+
+  def database_template_settings
+    DeepToHash.to_hash database_setup_defaults.deep_merge(fetch(:db_setup_settings, {}))
+  end
+
+  def _database_remote_path
+    File.join(shared_path, fetch(:database_remote_path, 'config/database.yml'))
+  end
+
+  def _database_local_path
+    File.join(local_rails_root, fetch(:database_local_path, 'config/database.yml'))
+  end
+
+  def _database_template
+    fetch(:database_template, 'database.yml.erb')
   end
+
 end

data/lib/capistrano/recipes/gateways.rb

@@ -1,36 +1,42 @@
-# Example
-# =======
-#
-# gateways_setup_settings:
-#   example1:
-#     login: 'username'
-#     password: 'secret'
-
 Capistrano::Configuration.instance(:must_exist).load do
-  set(:gateways_remote_file) { File.join(shared_path, 'config/gateways.yml') } unless exists?(:gateways_remote_file)
-  set(:gateways_template, 'gateways.yml.erb') unless exists?(:gateways_template)
-
 
-  # Required attributes
-  # ===================
-  # *gateways_name* prod_db
   namespace :gateways do
     namespace :setup do
       desc "Upload configs"
       task :default, :roles => :app do
         if exists?(:gateways_setup_settings)
-          set(:recipe_settings) { fetch(:gateways_setup_settings, {}) }
-          put template.render(fetch(:gateways_template)), fetch(:gateways_remote_file)
+          set(:recipe_settings) { gateways_template_settings }
+          put template.render(_gateways_template), _gateways_remote_file
         else
-          puts "[FATAL] - Gateway template settings were not found"
+          puts "[FATAL] - Gateways template settings were not found"
           abort
         end
       end
 
       desc "Download configs"
       task :get, :roles => :db do
-        download fetch(:gateways_remote_file), File.join(local_rails_root, 'config/gateways.yml')
+        download _gateways_remote_file, _gateways_local_file
       end
     end
   end
+
+  def gateways_setup_defaults
+    HashWithIndifferentAccess.new({'common'=>{}}.reverse_merge(default_rails_environments_hash))
+  end
+
+  def gateways_template_settings
+    DeepToHash.to_hash gateways_setup_defaults.deep_merge(fetch(:gateways_setup_settings, {}))
+  end
+
+  def _gateways_remote_file
+    File.join(shared_path, fetch(:gateways_remote_file, 'config/gateways.yml'))
+  end
+
+  def _gateways_local_file
+    File.join(local_rails_root, fetch(:gateways_local_file, 'config/gateways.yml'))
+  end
+
+  def _gateways_template
+    fetch(:gateways_template, 'gateways.yml.erb')
+  end
 end

data/lib/capistrano/recipes/mailer.rb

@@ -1,22 +1,11 @@
-# Example
-# =======
-#
-# mailer_setup_settings:
-#   user_name: "email@example.com"
-#   password: "secret"
-
 Capistrano::Configuration.instance(:must_exist).load do
-
-  set(:mailer_remote_file) { File.join(shared_path, 'config/mailers.yml') } unless exists?(:mailer_remote_file)
-  set(:mailer_template, 'mailers.yml.erb') unless exists?(:mailer_template)
-
   namespace :mailer do
     namespace :setup do
       desc "Upload configs"
       task :default, :roles => :app do
         if exists?(:mailer_setup_settings)
-          set :recipe_settings, fetch(:mailer_setup_settings, {})
-          put template.render(fetch(:mailer_template)), fetch(:mailer_remote_file)
+          set(:recipe_settings) { mailer_template_settings }
+          put template.render(_mailer_template), _mailer_remote_file
         else
           puts "[FATAL] - Mailers template settings were not found"
           abort
@@ -25,8 +14,28 @@ Capistrano::Configuration.instance(:must_exist).load do
 
       desc "Download configs"
       task :get, :roles => :db do
-        download fetch(:mailer_remote_file), File.join(local_rails_root, 'config/mailers.yml')
+        download _mailer_remote_file, _mailer_local_file
       end
     end
   end
+
+  def mailer_setup_defaults
+    HashWithIndifferentAccess.new({'common'=>{}}.reverse_merge(default_rails_environments_hash))
+  end
+
+  def mailer_template_settings
+    DeepToHash.to_hash mailer_setup_defaults.deep_merge(fetch(:mailer_setup_settings, {}))
+  end
+
+  def _mailer_remote_file
+    File.join(shared_path, fetch(:mailer_remote_file, 'config/mailers.yml'))
+  end
+
+  def _mailer_local_file
+    File.join(local_rails_root, fetch(:mailer_local_file, 'config/mailers.yml'))
+  end
+
+  def _mailer_template
+    fetch(:mailer_template, 'mailers.yml.erb')
+  end
 end

data/lib/capistrano/recipes/newrelic.rb

@@ -1,19 +1,30 @@
-# Example
-# =======
-#
-# newrelic_setup_settings:
-#   common:
-#     app_name: AppName
-#     license_key: secret
-#   staging:
-#     app_name: AppName (Staging)
-
 Capistrano::Configuration.instance(:must_exist).load do
-  set(:newrelic_remote_file) { File.join(shared_path, 'config/newrelic.yml') } unless exists?(:newrelic_remote_file)
-  set(:newrelic_template, 'newrelic.yml.erb') unless exists?(:newrelic_template)
+  # Required attributes
+  # ===================
+  # *license_key*  123xyz
+  # *app_name* Production App
+  namespace :newrelic do
+    namespace :setup do
+      desc "Upload configs"
+      task :default, :roles => :app do
+        if exists?(:newrelic_setup_settings)
+          set(:recipe_settings) { newrelic_template_settings }
+          put template.render(_newrelic_template), _newrelic_remote_path
+        else
+          puts "[FATAL] - Newrelic template settings were not found"
+          abort
+        end
+      end
+
+      desc "Download configs"
+      task :get, :roles => :db do
+        download _newrelic_remote_path, _newrelic_local_path
+      end
+    end
+  end
 
   def newrelic_setup_defaults
-    {
+    HashWithIndifferentAccess.new({
       'common'      => {
         # ============================== LICENSE KEY ===============================
 
@@ -175,39 +186,22 @@ Capistrano::Configuration.instance(:must_exist).load do
       'staging'     => {'developer_mode'  => true},
       'test'        => {},
       'production'  => {'monitor_mode'    => true}
-    }
+    }.reverse_merge(default_rails_environments_hash))
   end
 
-  # task: `newrelic:setup'
   def newrelic_template_settings
-    fetch(:newrelic_setup_settings, {}).reverse_merge(
-      newrelic_setup_defaults.keys.inject({}) {|r, e| r.merge Hash[e, Hash.new] }
-    ).inject({}) do |r, (k,v)|
-      r.merge Hash[k, v.reverse_merge(newrelic_setup_defaults[k] || {})]
-    end
+    DeepToHash.to_hash newrelic_setup_defaults.deep_merge(fetch(:newrelic_setup_settings, {}))
   end
 
-  # Required attributes
-  # ===================
-  # *license_key*  123xyz
-  # *app_name* Production App
-  namespace :newrelic do
-    namespace :setup do
-      desc "Upload configs"
-      task :default, :roles => :app do
-        if exists?(:newrelic_setup_settings)
-          set(:recipe_settings) { newrelic_template_settings }
-          put template.render(fetch(:newrelic_template)), fetch(:newrelic_remote_file)
-        else
-          puts "[FATAL] - Newrelic template settings were not found"
-          abort
-        end
-      end
+  def _newrelic_remote_path
+    File.join(shared_path, fetch(:newrelic_remote_path, 'config/newrelic.yml'))
+  end
 
-      desc "Download configs"
-      task :get, :roles => :db do
-        download fetch(:newrelic_remote_file), File.join(local_rails_root, 'config/newrelic.yml')
-      end
-    end
+  def _newrelic_local_path
+    File.join(local_rails_root, fetch(:newrelic_local_path, 'config/newrelic.yml'))
+  end
+
+  def _newrelic_template
+    fetch(:newrelic_template, 'newrelic.yml.erb')
   end
 end

data/lib/capistrano/recipes/passenger.rb

@@ -1,33 +1,5 @@
-# Example
-# =======
-#
-# passenger_setup_settings:
-#   port: 80
-#   auth_user_file: '/path/to/htpasswd'
-
 Capistrano::Configuration.instance(:must_exist).load do
 
-  # task: `passenger:setup'
-  def passenger_template_settings
-    fetch(:passenger_setup_settings, {}).reverse_merge({
-      'sites_available'   => fetch(:apache_sites_available, "/home/#{user}/configs/apache/sites-available"),
-      'sites_enabled'     => fetch(:apache_sites_enabled, "/home/#{user}/configs/apache/sites-enabled"),
-      'vhost_filename'    => fetch(:apache_vhost_filename) { "#{application}.conf" },
-      'template_filename' => fetch(:apache_template_filename) { 'passenger.conf.erb' },
-      'server_name'       => fetch(:domain),
-      'document_root'     => File.join(fetch(:current_path), 'public'),
-      'rails_env'         => fetch(:rails_env, 'production')
-    })
-  end
-
-  def apache_available_vhost
-    File.join(*passenger_template_settings.slice('sites_available', 'vhost_filename').values)
-  end
-
-  def apache_enabled_vhost
-    File.join(*passenger_template_settings.slice('sites_enabled', 'vhost_filename').values)
-  end
-
   namespace :passenger do
     desc "Restart Rails app running under Phusion Passenger by touching restart.txt"
     task :restart, :roles => :app, :except => { :no_release => true } do
@@ -47,26 +19,26 @@ Capistrano::Configuration.instance(:must_exist).load do
     desc "Remove passenger config"
     task :remove, :roles => :app, :except => { :no_release => true } do
       passenger.disable
-      run "rm #{apache_available_vhost}"
+      run "rm #{_passenger_available_vhost}"
     end
 
     desc "Disable passenger config"
     task :disable, :roles => :app, :except => { :no_release => true } do
-      run "rm #{apache_enabled_vhost}"
+      run "rm #{_passenger_enabled_vhost}"
     end
 
     desc "Enable passenger config"
     task :enable, :roles => :app, :except => { :no_release => true } do
-      run "ln -nsf #{apache_available_vhost} #{apache_enabled_vhost}"
+      run "ln -nsf #{_passenger_available_vhost} #{_passenger_enabled_vhost}"
     end
 
     namespace :setup do
       desc "Upload configs"
       task :default, :roles => :app do
         if exists?(:passenger_setup_settings)
-          run "mkdir -p #{ passenger_template_settings.slice('sites_available', 'sites_enabled').map{|k,v| v}.join(' ') }"
+          run "mkdir -p #{_passenger_sites_available} #{_passenger_sites_enabled}"
           set(:recipe_settings) { passenger_template_settings }
-          put template.render( passenger_template_settings['template_filename'] ), apache_available_vhost
+          put template.render(_passenger_template), _passenger_available_vhost
           passenger.enable
         else
           puts "[FATAL] - Passenger template settings were not found"
@@ -81,4 +53,40 @@ Capistrano::Configuration.instance(:must_exist).load do
     end
 
   end
+
+  def passenger_setup_defaults
+    HashWithIndifferentAccess.new({
+      'server_name'       => fetch(:domain),
+      'document_root'     => File.join(current_path, 'public'),
+      'rails_env'         => fetch(:rails_env, 'production')
+    })
+  end
+
+  def passenger_template_settings
+    DeepToHash.to_hash passenger_setup_defaults.deep_merge(fetch(:passenger_setup_settings, {}))
+  end
+
+  def _passenger_available_vhost
+    File.join(_passenger_sites_available, _passenger_vhost_filename)
+  end
+
+  def _passenger_enabled_vhost
+    File.join(_passenger_sites_enabled, _passenger_vhost_filename)
+  end
+
+  def _passenger_vhost_filename
+    fetch(:passenger_vhost_filename) { "#{application}.conf" }
+  end
+
+  def _passenger_sites_available
+    fetch(:passenger_sites_available, "/home/#{fetch_user}/configs/apache/sites-available")
+  end
+
+  def _passenger_sites_enabled
+    fetch(:passenger_sites_enabled, "/home/#{fetch_user}/configs/apache/sites-enabled")
+  end
+
+  def _passenger_template
+    fetch(:passenger_template, 'passenger.conf.erb')
+  end
 end

data/lib/capistrano/recipes/settler.rb

@@ -1,32 +1,11 @@
-# Example
-# =======
-#
-# settler_setup_settings:
-#   host: example.com
-#   partner_name: FooBar
-
 Capistrano::Configuration.instance(:must_exist).load do
-  set(:settler_remote_file) { File.join(shared_path, 'config/settler.yml') } unless exists?(:settler_remote_file)
-  set(:settler_template, 'settler.yml.erb') unless exists?(:settler_template)
-
-  # task: `settler:setup'
-  def settler_template_settings
-    fetch(:settler_setup_settings, {}).inject({}) do |r, (k,v)|
-      r.merge Hash[k, {'alt' => k, 'value' => v}]
-    end
-  end
-
-
-  # Required attributes
-  # ===================
-  # *settler_name* prod_db
   namespace :settler do
     namespace :setup do
       desc "Upload configs"
       task :default, :roles => :app do
         if exists?(:settler_setup_settings)
            set(:recipe_settings) { settler_template_settings }
-           put template.render(fetch(:settler_template)), fetch(:settler_remote_file)
+           put template.render(_settler_template), _settler_remote_file
          else
            puts "[FATAL] - Settler template settings were not found"
            abort
@@ -35,8 +14,40 @@ Capistrano::Configuration.instance(:must_exist).load do
 
       desc "Download configs"
       task :get, :roles => :db do
-        download fetch(:settler_remote_file), File.join(local_rails_root, 'config/settler.yml')
+        download _settler_remote_file, _settler_local_file
+      end
+    end
+  end
+
+  def settler_template_settings
+    fetch(:settler_setup_settings, {}).inject({}) do |r, (k,v)|
+      case v.class.name
+      when 'Hash', 'ActiveSupport::HashWithIndifferentAccess'
+        r[k] = v
+      when 'Float'
+        r[k] = {'alt' => k.to_s, 'value' => v.to_s, 'typecast' => 'float'}
+      when 'Fixnum'
+        r[k] = {'alt' => k.to_s, 'value' => v.to_s, 'typecast' => 'integer'}
+      when 'TrueClass', 'FalseClass'
+        r[k] = {'alt' => k.to_s, 'value' => v.to_s, 'typecast' => 'boolean'}
+      when 'DateTime', 'Date', 'Time'
+        r[k] = {'alt' => k.to_s, 'value' => v.to_s, 'typecast' => 'datetime'}
+      else
+        r[k] = {'alt' => k.to_s, 'value' => v.to_s}
       end
+      r
     end
   end
+
+  def _settler_remote_file
+    File.join(shared_path, fetch(:settler_remote_file, 'config/settler.yml'))
+  end
+
+  def _settler_local_file
+    File.join(local_rails_root, fetch(:settler_local_file, 'config/settler.yml'))
+  end
+
+  def _settler_template
+    fetch(:settler_template, 'settler.yml.erb')
+  end
 end

data/lib/capistrano/recipes/shards.rb

@@ -1,40 +1,16 @@
-# Example
-# =======
-#
-# shards_setup_settings:
-#   databases:
-#     production:
-#       slave1: {}
 Capistrano::Configuration.instance(:must_exist).load do
-  set(:shards_remote_file) { File.join(shared_path, 'config/shards.yml') } unless exists?(:shards_remote_file)
-  set(:shards_template, 'shards.yml.erb') unless exists?(:shards_template)
-
-  def shards_setup_defaults
-    {
-      'replicated'        => true,
-      'verify_connection' => true,
-      'environments'      => %w(production),
-      'databases'         => {}
-    }
-  end
-
-  # task: `shards:setup'
-  def shards_template_settings
-    fetch(:shards_setup_settings, {}).reverse_merge(shards_setup_defaults)
-  end
-
   namespace :shards do
     namespace :setup do
       desc "Upload configs"
       task :default, :roles => :app do
         if exists?(:shards_setup_settings)
           set(:recipe_settings) do
-            {
+            HashWithIndifferentAccess.new({
               'main' => database_template_settings,
               'shards' => shards_template_settings
-            }
+            })
           end
-          put template.render(fetch(:shards_template)), fetch(:shards_remote_file)
+          put template.render(_shards_template), _shards_remote_path
         else
           puts "[FATAL] - Shards template settings were not found"
           abort
@@ -43,9 +19,34 @@ Capistrano::Configuration.instance(:must_exist).load do
 
       desc "Download configs"
       task :get, :roles => :db do
-        download fetch(:shards_remote_file), File.join(local_rails_root, "config/shards.yml")
+        download _shards_remote_path, _shards_local_path
       end
     end
 
   end
+
+  def shards_setup_defaults
+    HashWithIndifferentAccess.new({
+      'replicated'        => true,
+      'verify_connection' => true,
+      'environments'      => %w(production),
+      'databases'         => {}
+    })
+  end
+
+  def shards_template_settings
+    DeepToHash.to_hash shards_setup_defaults.deep_merge(fetch(:shards_setup_settings, {}))
+  end
+
+  def _shards_remote_path
+    File.join(shared_path, fetch(:shards_remote_path, 'config/shards.yml'))
+  end
+
+  def _shards_local_path
+    File.join(local_rails_root, fetch(:shards_local_path, 'config/shards.yml'))
+  end
+
+  def _shards_template
+    fetch(:shards_template, 'shards.yml.erb')
+  end
 end

data/lib/capistrano/recipes/thin.rb

@@ -1,52 +1,26 @@
 Capistrano::Configuration.instance(:must_exist).load do
-  set(:thin_remote_file) { File.join(shared_path, 'config/thin.yml') } unless exists?(:thin_remote_file)
-  set(:thin_template, 'thin.yml.erb') unless exists?(:thin_template)
-
-
-  # The wrapped bin to start thin
-  # This is necessary if you're using rvm
-  set :thin_bin, 'bundle exec thin' unless exists?(:thin_bin)
-
-  # The remote location of thin's config file. Used by god to fire it up
-  set(:thin_remote_config) { File.join(current_path, 'config', 'thin.yml') }
-
-  # task: `thin:setup'
-  def thin_template_settings
-    fetch(:thin_setup_settings, {}).reverse_merge({
-      'chdir'       => fetch(:current_path),
-      'timeout'     => fetch(:thin_timeout, 30),
-      'servers'     => fetch(:thin_servers, 4),
-      'rails_env'   => fetch(:rails_env, 'production')
-    })
-  end
-
-  def thin_cmd(action)
-    "cd #{current_path}; #{thin_bin} -C #{thin_remote_config} #{action}"
-  end
-
   namespace :thin do
     desc "Thin restart"
     task :restart, :roles => :app, :except => { :no_release => true } do
-      run thin_cmd('restart')
+      run _thin_cmd('restart')
     end
 
     desc "Thin start"
     task :start, :roles => :app, :except => { :no_release => true } do
-      run thin_cmd('start')
+      run _thin_cmd('start')
     end
 
     desc "Thin stop"
     task :stop, :roles => :app, :except => { :no_release => true } do
-      run thin_cmd('stop')
+      run _thin_cmd('stop')
     end
 
-
     namespace :setup do
       desc "Upload configs"
       task :default, :roles => :app do
         if exists?(:thin_setup_settings)
           set(:recipe_settings) { thin_template_settings }
-          put template.render(fetch(:thin_template)), fetch(:thin_remote_file)
+          put template.render(_thin_template), _thin_remote_path
         else
           puts "[FATAL] - Thin template settings were not found"
           abort
@@ -55,10 +29,49 @@ Capistrano::Configuration.instance(:must_exist).load do
 
       desc "Download configs"
       task :get, :roles => :db do
-        download fetch(:thin_remote_file), File.join(local_rails_root, "config/thin.yml")
+        download _thin_remote_path, _thin_local_path
       end
     end
+  end
+
+  def thin_setup_defaults
+    HashWithIndifferentAccess.new({
+      'chdir'       => fetch(:current_path),
+      'timeout'     => fetch(:thin_timeout, 30),
+      'servers'     => fetch(:thin_servers, 4),
+      'rails_env'   => fetch(:rails_env, 'production')
+    })
+  end
+
+  def thin_template_settings
+    DeepToHash.to_hash thin_setup_defaults.deep_merge(fetch(:thin_setup_settings, {}))
+  end
+
+  def _thin_cmd(action)
+    "cd #{current_path}; #{_thin_bin} -C #{_thin_current_config_path} #{action}"
+  end
+
+  # The wrapped bin to start thin
+  # This is necessary if you're using rvm
+  def _thin_bin
+    fetch(:thin_bin, 'bundle exec thin')
+  end
+
+  # The remote location of thin's config file. Used by god to fire it up
+  def _thin_current_config_path
+    File.join(current_path, 'config', 'thin.yml')
+  end
+
+  def _thin_remote_path
+    File.join(shared_path, fetch(:thin_remote_path, 'config/thin.yml'))
+  end
+
+  def _thin_local_path
+    File.join(local_rails_root, fetch(:thin_local_path, 'config/thin.yml'))
+  end
 
+  def _thin_template
+    fetch(:thin_template, 'thin.yml.erb')
   end
 
 end

data/lib/capistrano/recipes/tire.rb

@@ -1,23 +1,11 @@
-# Example
-# =======
-#
-# tire_setup_settings:
-#   url: "http://localhost:9200"
-
 Capistrano::Configuration.instance(:must_exist).load do
-  set(:tire_remote_file) { File.join(shared_path, 'config/tire.yml') } unless exists?(:tire_remote_file)
-  set(:tire_template, 'tire.yml.erb') unless exists?(:tire_template)
-
-  # Required attributes
-  # ===================
-  # *url* http://localhost:9200
   namespace :tire do
     namespace :setup do
       desc "Upload configs"
       task :default, :roles => :app do
         if exists?(:tire_setup_settings)
-          set :recipe_settings, fetch(:tire_setup_settings, {})
-          put template.render(fetch(:tire_template)), fetch(:tire_remote_file)
+          set(:recipe_settings) { tire_template_settings }
+          put template.render(_tire_template), _tire_remote_file
         else
           puts "[FATAL] - Tire template settings were not found"
           abort
@@ -26,8 +14,32 @@ Capistrano::Configuration.instance(:must_exist).load do
 
       desc "Download configs"
       task :get, :roles => :db do
-        download fetch(:tire_remote_file), File.join(local_rails_root, "config/tire.yml")
+        download _tire_remote_file, _tire_local_file
       end
     end
   end
+
+  def tire_setup_defaults
+    HashWithIndifferentAccess.new({
+      'common'=>{
+        'url' => 'http://localhost:9200'
+      }
+    }.reverse_merge(default_rails_environments_hash))
+  end
+
+  def tire_template_settings
+    DeepToHash.to_hash tire_setup_defaults.deep_merge(fetch(:tire_setup_settings, {}))
+  end
+
+  def _tire_remote_file
+    File.join(shared_path, fetch(:tire_remote_file, 'config/tire.yml'))
+  end
+
+  def _tire_local_file
+    File.join(local_rails_root, fetch(:tire_local_file, 'config/tire.yml'))
+  end
+
+  def _tire_template
+    fetch(:tire_template, 'tire.yml.erb')
+  end
 end

data/lib/capistrano/recipes/unicorn.rb

@@ -1,59 +1,4 @@
-# Example
-# =======
-#
-# unicorn_setup_settings:
-#   port: 80
 Capistrano::Configuration.instance(:must_exist).load do
-  set(:monit_root){ "/home/#{user}/monit/metromix" }
-
-  # The wrapped bin to start unicorn
-  # This is necessary if you're using rvm
-  set :unicorn_bin, 'bundle exec unicorn' unless exists?(:unicorn_bin)
-
-  # The remote location of unicorn's config file. Used by god to fire it up
-  set(:unicorn_remote_config) { "#{current_path}/config/unicorn.rb" }
-
-  set(:unicorn_template, 'unicorn.rb.erb') unless exists?(:unicorn_template)
-  set(:unicorn_monit_template, 'unicorn_monit.erb') unless exists?(:unicorn_monit_template)
-
-  # Defines where the unicorn pid will live.
-  set(:unicorn_pid) { File.join(shared_path, "pids", "unicorn.pid") } unless exists?(:unicorn_pid)
-
-  # task: `unicorn:setup'
-  def unicorn_template_settings
-    fetch(:unicorn_setup_settings, {}).reverse_merge({
-      # Number of workers (Rule of thumb is 2 per CPU)
-      # Just be aware that every worker needs to cache all classes and thus eat some
-      # of your RAM.
-      'workers'          => fetch(:unicorn_workers, 4),
-      # Workers timeout in the amount of seconds below, when the master kills it and
-      # forks another one.
-      'workers_timeout'  => fetch(:unicorn_workers_timeout, 30),
-      # Workers are started with this user/group
-      # By default we get the user/group set in capistrano.
-      'user'              => fetch(:unicorn_user) { user },
-      'group'             => fetch(:unicorn_group) { group },
-      'rails_env'         => fetch(:rails_env, 'production'),
-      # configs for the monit template
-      'pids_root'         => fetch(:unicorn_pids_root) { File.join(shared_path, "pids") },
-      'application'       => fetch(:application),
-      'current_path'      => fetch(:current_path),
-      'remote_config'     => fetch(:unicorn_remote_config)
-    })
-  end
-
-  def unicorn_start_cmd
-    "cd #{current_path} && #{unicorn_bin} -c #{unicorn_remote_config} -E #{rails_env} -D"
-  end
-
-  def unicorn_stop_cmd
-    "kill -QUIT `cat #{unicorn_pid}`"
-  end
-
-  def unicorn_restart_cmd
-    "kill -USR2 `cat #{unicorn_pid}`"
-  end
-
   namespace :unicorn do
     desc "Starts unicorn directly"
     task :start, :roles => :app, :except => { :no_release => true } do
@@ -62,12 +7,12 @@ Capistrano::Configuration.instance(:must_exist).load do
 
     desc "Stops unicorn directly"
     task :stop, :roles => :app, :except => { :no_release => true } do
-      run unicorn_stop_cmd
+      run unicorn_kill_cmd('QUIT')
     end
 
     desc "Restarts unicorn directly"
     task :restart, :roles => :app, :except => { :no_release => true } do
-      run unicorn_restart_cmd
+      run unicorn_kill_cmd('USR2')
     end
 
     # Required attributes
@@ -78,7 +23,7 @@ Capistrano::Configuration.instance(:must_exist).load do
       task :default, :roles => :app do
         if exists?(:unicorn_setup_settings)
           set(:recipe_settings) { unicorn_template_settings }
-          put template.render(fetch(:unicorn_template)), File.join(shared_path, 'config/unicorn.rb')
+          put template.render(_unicorn_template), _unicorn_shared_file
         else
           puts "[FATAL] - Unicorn template settings were not found"
           abort
@@ -87,18 +32,18 @@ Capistrano::Configuration.instance(:must_exist).load do
 
       desc "Download configs"
       task :get, :roles => :db do
-        download File.join(shared_path, 'config/unicorn.rb'), File.join(local_rails_root, "config/unicorn.rb")
+        download _unicorn_shared_file, _unicorn_local_file
       end
     end
 
     namespace :monit do
       namespace :setup do
         desc "Upload configs"
-        task :default, :roles => :db do
+        task :default, :roles => :app do
           if exists?(:unicorn_setup_settings)
-            run "mkdir -p #{monit_root}"
+            run "mkdir -p #{_monit_root}"
             set(:recipe_settings) { unicorn_template_settings }
-            put template.render(fetch(:unicorn_monit_template)), File.join(monit_root, application)
+            put template.render(_unicorn_monit_template), _monit_remote_file
           else
             puts "[FATAL] - Unicorn/Monit template settings were not found"
             abort
@@ -107,10 +52,89 @@ Capistrano::Configuration.instance(:must_exist).load do
 
         desc "Download configs"
         task :get, :roles => :db do
-          download File.join(monit_root, application), File.join(local_rails_root, "config/#{application}-monit")
+          download _monit_remote_file, File.join(local_rails_root, "config/#{application}-monit")
         end
       end
 
     end
   end
+
+  def unicorn_setup_defaults
+    HashWithIndifferentAccess.new({
+      # Number of workers (Rule of thumb is 2 per CPU)
+      # Just be aware that every worker needs to cache all classes and thus eat some
+      # of your RAM.
+      'workers'          => fetch(:unicorn_workers, 4),
+      # Workers timeout in the amount of seconds below, when the master kills it and
+      # forks another one.
+      'workers_timeout'  => fetch(:unicorn_workers_timeout, 30),
+      # Workers are started with this user/group
+      # By default we get the user/group set in capistrano.
+      'user'              => fetch(:unicorn_user) { fetch_user },
+      'group'             => fetch(:unicorn_group) { fetch_group },
+      'rails_env'         => fetch(:rails_env, 'production'),
+      # configs for the monit template
+      'pids_root'         => _unicorn_pids_root,
+      'application'       => fetch(:application),
+      'current_path'      => current_path,
+      'remote_config'     => _unicorn_current_file
+    })
+  end
+
+  def unicorn_template_settings
+    DeepToHash.to_hash unicorn_setup_defaults.deep_merge(fetch(:unicorn_setup_settings, {}))
+  end
+
+  def unicorn_start_cmd
+    "cd #{current_path} && #{_unicorn_bin} -c #{_unicorn_current_file} -E #{rails_env} -D"
+  end
+
+  def unicorn_kill_cmd(arg)
+    "kill -#{arg} `cat #{_unicorn_pid}`"
+  end
+
+  # The wrapped bin to start unicorn
+  # This is necessary if you're using rvm
+  def _unicorn_bin
+    fetch(:unicorn_bin, 'bundle exec unicorn')
+  end
+
+  # Defines where the unicorn pid will live.
+  def _unicorn_pid
+    fetch(:unicorn_pid) { File.join(shared_path, "pids", "unicorn.pid") }
+  end
+
+  def _unicorn_pids_root
+    _unicorn_pid.split('/').tap{|x| x.pop }.join('/')
+  end
+
+  # The remote location of unicorn's config file. Used by god to fire it up
+  def _unicorn_current_file
+    File.join(current_path, fetch(:unicorn_remote_file, 'config/unicorn.rb'))
+  end
+
+  def _unicorn_shared_file
+    File.join(shared_path, fetch(:unicorn_remote_file, 'config/unicorn.rb'))
+  end
+
+  def _unicorn_local_file
+    File.join(local_rails_root, fetch(:unicorn_local_file, 'config/unicorn.rb'))
+  end
+
+  def _unicorn_template
+    fetch(:unicorn_template, 'unicorn.rb.erb')
+  end
+
+  def _unicorn_monit_template
+    fetch(:unicorn_monit_template, 'unicorn_monit.erb')
+  end
+
+  def _monit_root
+    fetch(:monit_root) { "/home/#{fetch_user}/monit" }
+  end
+
+  def _monit_remote_file
+    File.join(_monit_root, application)
+  end
+
 end

data/lib/capistrano/recipes/uploader.rb

@@ -1,25 +1,11 @@
-# Example
-# =======
-#
-# uploader_setup_settings:
-#   fog_credentials:
-#     provider: Rackspace
-#     rackspace_username: username
-#     rackspace_api_key: secret
-#   fog_directory: frontend
-#   fog_host: http://123.rackcdn.com
-
 Capistrano::Configuration.instance(:must_exist).load do
-  set(:uploader_remote_file) { File.join(shared_path, 'config/uploader.yml') } unless exists?(:uploader_remote_file)
-  set(:uploader_template, 'uploader.yml.erb') unless exists?(:uploader_template)
-
   namespace :uploader do
     namespace :setup do
       desc "Upload configs"
       task :default, :roles => :app do
         if exists?(:uploader_setup_settings)
-          set :recipe_settings, fetch(:uploader_setup_settings, {})
-          put template.render(fetch(:uploader_template)), fetch(:uploader_remote_file)
+          set(:recipe_settings) { uploader_template_settings }
+          put template.render(_uploader_template), _uploader_remote_file
         else
           puts "[FATAL] - Uploader template settings were not found"
           abort
@@ -28,9 +14,30 @@ Capistrano::Configuration.instance(:must_exist).load do
 
       desc "Download configs"
       task :get, :roles => :db do
-        download fetch(:uploader_remote_file), File.join(local_rails_root, "config/uploader.yml")
+        download _uploader_remote_file, _uploader_local_file
       end
     end
 
   end
+
+  def uploader_setup_defaults
+    HashWithIndifferentAccess.new({'common'=>{}}.reverse_merge(default_rails_environments_hash))
+  end
+
+  def uploader_template_settings
+    DeepToHash.to_hash uploader_setup_defaults.deep_merge(fetch(:uploader_setup_settings, {}))
+  end
+
+  def _uploader_remote_file
+    File.join(shared_path, fetch(:uploader_remote_file, 'config/uploader.yml'))
+  end
+
+  def _uploader_local_file
+    File.join(local_rails_root, fetch(:uploader_local_file, 'config/uploader.yml'))
+  end
+
+  def _uploader_template
+    fetch(:uploader_template, 'uploader.yml.erb')
+  end
+
 end

data/marcosgz-cap-recipe.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
   s.name        = "marcosgz-cap-recipe"
-  s.version     = "0.0.8"
+  s.version     = "0.0.9"
   s.authors     = ["Marcos G. Zimmermann"]
   s.email       = ["mgzmaster@gmail.com"]
   s.homepage    = "https://github.com/marcosgz/capistrano-recipe"
@@ -17,5 +17,5 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_dependency "capistrano", "> 2.0.0"
-  s.add_development_dependency "pry", "~> 0.9.11.4"
+  s.add_dependency "marcosgz-cap-template", "~> 0.0.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marcosgz-cap-recipe
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-18 00:00:00.000000000 Z
+date: 2013-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -28,21 +28,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.0.0
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: marcosgz-cap-template
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.11.4
-  type: :development
+        version: 0.0.3
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.11.4
+        version: 0.0.3
 description: 
 email:
 - mgzmaster@gmail.com
@@ -93,4 +93,3 @@ signing_key:
 specification_version: 3
 summary: Capistrano recipe
 test_files: []
-has_rdoc: