borg-rb 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YmUyMjY1NWY1ZGQxY2IzMWI0NWY5OGJiZDA4ZWY1NzczM2ZhYzBkZA==
+  data.tar.gz: !binary |-
+    NjQ2ZjUwN2I1MzU0ZGM3NmViNzFkY2QzNjZjNTMyMGNlMWRkNzQ5MA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    MTMxMDRmYTQ1ZWY2ZDk2NTEwMWM5NjhmNzExYjVlOWU0MGEyNmMzZDRhZWU5
+    ZWQ4YTgyMGY3ZTAyZTUwY2Q0ZGJiN2I5N2ZiMGQ5YjE2NWQ2N2U5NTk4N2Fk
+    ODJmZTNlZjhhYTAxMzFmOWI3NmVlMmQ3ZGU0ZjU4MWFjNWE4YzQ=
+  data.tar.gz: !binary |-
+    YzBkOTZjZmIyM2NiNGM5NDE2NDA2OGJlMDdiZjc3MmE5NmQyMmQ4Yjk3ODVh
+    NTJmMjQ5ODYxNWI1ZWQzODRjOGJlYTBlNmVjYTA4MDZhMGM3Y2ZhYTgxNjlj
+    MmIwMjA4NDQ5ZjY4MTQ2Yzk5YWIyYmNkNzhhYzk5NGFlNWEwZDg=

data/.gitignore

@@ -0,0 +1,41 @@
+*.gem
+*.rbc
+.bundle
+.config
+Gemfile.lock
+InstalledFiles
+coverage
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# Local Ruby Dev Configs
+.rvmrc
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+# JetBrains IDE files
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# OS X
+.DS_Store
+.AppleDouble
+.LSOverride
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear on external disk
+.Spotlight-V100
+.Trashes

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode
+script: bundle exec rspec spec

data/Capfile

@@ -0,0 +1 @@
+load 'lib/borg'

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,85 @@
+# Borg
+This is a project inspired by Caphub. It expands on the concept and makes it into a framework for multi application
+deployment.
+
+[![Build Status](https://travis-ci.org/B0RG/borg.png?branch=master)](https://travis-ci.org/B0RG/borg)
+[![Dependency Status](https://gemnasium.com/B0RG/borg.png)](https://gemnasium.com/B0RG/borg)
+[![Code Climate](https://codeclimate.com/github/B0RG/borg.png)](https://codeclimate.com/github/B0RG/borg)
+
+# Setup
+## Deployer Package
+
+`borgify` Sets up the following structure
+
+```
+my-deployer-package
+├── cap
+|   ├── applications
+|   |   ├── application1.rb
+│   |   └── application2.rb
+|   ├── initilizers
+|   |   ├── initilizer1.rb
+│   |   └── initilizer2.rb
+|   └── recipies
+|       ├── recipie1.rb
+│       └── recipie2.rb
+├── Capfile
+├── Gemfile
+└── Gemfile.lock
+```
+
+### Default Capfile contents
+```
+# provides a performance report at the end of execution
+# set :borg_performance_reports, true
+
+# runs on :exit events when ctrl-c is hit
+# set :borg_sigint_triggers_exit, true
+
+load 'borg'
+# load any other borg gems here.
+# NOTE: require ends up causing the initializers to be called every time a config is loaded.
+
+```
+
+## Services Package
+`borgify plugin` Sets up the following structure
+
+```
+my-service-package
+├── cap
+|   ├── initilizers
+|   |   ├── initilizer1.rb
+│   |   └── initilizer2.rb
+|   └── recipies
+|       ├── recipie1.rb
+│       └── recipie2.rb
+├── my-service-package.gemspec
+├── Gemfile
+└── Gemfile.lock
+```
+
+### Guidelines
+* While working on this there was a realization that the if you write a "on :exit" event then make sure it is executable
+even if it is called when ctrl-c is hit.
+
+## Borg Application Config
+Borg provides a application and stage config setup.
+One can define applications with the format.
+``` ruby
+application :app_name do
+  do things needed to setup the application environment.
+end
+
+stage :app_name, :stage_name do
+  do things for specific stage for the applications.
+end
+```
+
+By default borg looks for application confi files in cap/applications and loads all those files.
+If multiple application and stage blocks with the same parameters are defined 
+then all the blocks will be run for that application/stage.
+
+The CLI enforces that all configs be specified at the start. Consider the command `borg app1:stage1 app2 deploy`
+will result in config app1:stage1, all configs for app2 (1 config for each stage, if there is no stage it assumes the app is the only stage)
+to be load and the deploy task be run against all of them.

data/bin/borg

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+
+require 'capistrano/cli'
+require 'borg/cli/applications'
+require 'borg/configuration/applications'
+require 'borg/configuration/stages'
+require 'borg/configuration/assimilator'
+require 'erb'
+
+require 'borg/errors'
+require 'borg/server/base'
+require 'borg/servers/base'
+
+# Ensure ruby 1.9.X
+raise "Ruby 1.9.X required" unless RUBY_VERSION =~ /^1\.9\.\d$/
+
+Capistrano::CLI.execute

data/bin/borgify

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+plugin = (ARGV.count == 1 and ARGV[0] == "plugin")
+
+if ARGV.empty? or plugin
+  skeleton_dir = File.expand_path('../../skeleton', __FILE__)
+  gem_name = File.basename(Dir.pwd)
+
+  puts "Copying Skeleton"
+  FileUtils.cp_r("#{skeleton_dir}/.", ".")
+
+  puts "Creating lib/#{gem_name}.rb"
+  File.open("lib/#{gem_name}.rb", 'w') { |file| file.write("assimilate '#{gem_name}'") }
+
+  puts "Removing unnecessary files and folders"
+  if plugin
+    FileUtils.rm_r "cap/applications"
+    FileUtils.rm_r "Capfile"
+    FileUtils.rm_r "Gemfile"
+    puts "Setting up gemspec file"
+    FileUtils.mv "mygem.gemspec.skeleton", "#{gem_name}.gemspec"
+  else
+    FileUtils.rm_r "mygem.gemspec.skeleton"
+  end
+
+else
+  # display help if parameters input
+  puts <<-HELP
+borgify only supports to ways of calling it.
+borgify         # to setup deployment project
+borgify plugin  # to setup a pluging for borg
+  HELP
+end

data/borg.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'borg/version'
+
+Gem::Specification.new do |s|
+  s.name        = "borg-rb"
+  s.version     = Borg::VERSION
+  s.authors     = ["Identified"]
+  s.email       = ["phil@identified.com", "tejas@identified.com"]
+  s.description   = %q{Ruby-based software provisioning and deployment framework}
+  s.summary       = %q{Ruby-based software provisioning and deployment framework}
+  s.homepage      = "https://github.com/B0RG/borg"
+  s.license       = "MIT"
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_dependency "capistrano"
+  s.add_dependency "capistrano_colors"
+  s.add_dependency "colored"
+  s.add_dependency "term-ansicolor"
+
+  s.add_development_dependency "rspec"
+end

data/cap/applications/app1.rb

@@ -0,0 +1,15 @@
+application :app1 do
+  puts "application = app1"
+end
+
+stage :app1, :prd do
+  puts "stage = prd"
+end
+
+stage :app1, :stg do
+  puts "stage = stg"
+end
+
+stage :app1, :alf do
+  puts "stage = alf"
+end

data/cap/initializers/output.rb

@@ -0,0 +1,4 @@
+# Colors 
+require 'colored'
+require 'term/ansicolor'
+require 'capistrano_colors'

data/cap/initializers/performance.rb

@@ -0,0 +1,42 @@
+_cset :borg_performance_reports, true
+if borg_performance_reports
+  # source: https://github.com/PagerDuty/pd-cap-recipes/blob/master/lib/pd-cap-recipes/tasks/performance.rb
+  start_times = {}
+  end_times = {}
+  order = []
+
+  on :before do
+    order << [:start, current_task]
+    start_times[current_task] = Time.now
+  end
+
+  on :after do
+    order << [:end, current_task]
+    end_times[current_task] = Time.now
+  end
+
+  on :exit do
+    print_report(start_times, end_times, order) if order.count > 0
+  end
+
+  def print_report(start_times, end_times, order)
+    def l(s)
+      logger.info s
+    end
+
+    l " Performance Report"
+    l "=========================================================="
+    indent = 0
+    (order + [nil]).each_cons(2) do |payload1, payload2|
+      action, task = payload1
+      if action == :start
+        l "#{".." * indent}#{task.fully_qualified_name}" unless task == payload2.last
+        indent += 1
+      else
+        indent -= 1
+        l "#{".." * indent}#{task.fully_qualified_name} #{(end_times[task] - start_times[task]).to_i}s"
+      end
+    end
+    l "=========================================================="
+  end
+end

data/cap/initializers/role_reset.rb

@@ -0,0 +1,12 @@
+# Added for convenience allowing dynamic
+
+module ::Capistrano
+  class Role
+    def reset!
+      @dynamic_servers.each(&:reset!)
+    end
+  end
+end
+
+desc "Resets all dynamic capistrano roles."
+task(:reset_roles) { roles.each {|k,v| v.reset!} }

data/cap/initializers/sigint.rb

@@ -0,0 +1,9 @@
+_cset :borg_sigint_triggers_exit, true
+
+if borg_sigint_triggers_exit
+  __cap = Capistrano::Configuration.instance
+  ::Signal.trap "SIGINT" do
+    __cap.trigger :exit
+    exit 1
+  end
+end

data/lib/borg/cli/applications.rb

@@ -0,0 +1,66 @@
+module Borg
+  module CLI
+    module Applications
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :execute_requested_actions_without_applications, :execute_requested_actions
+        base.send :alias_method, :execute_requested_actions, :execute_requested_actions_with_applications
+      end
+
+      def execute_requested_actions_with_applications(config)
+
+        load_applications config
+
+        separate_actions_and_applications config
+
+        if options[:applications].empty? or Thread.current[:borg_application]
+          Thread.current[:borg_application].load_into config if Thread.current[:borg_application]
+          execute_requested_actions_without_applications(config)
+        else
+          options[:applications].each do |app|
+            puts "Executing commands in context of #{app.name}"
+            Thread.current[:borg_application] = app
+            execute!
+          end
+        end
+      end
+
+      private
+
+      def load_applications config
+        # load applications
+        unless @apps_loaded
+          Dir["./cap/applications/**/*.rb"].each do |file|
+            config.load file
+          end
+          @apps_loaded = true
+        end
+      end
+
+      def separate_actions_and_applications config
+        options[:applications] = []
+        found_non_application = false
+        options[:actions] = Array(options[:actions]).keep_if do |action|
+          app, stg = action.split(":").map(&:to_sym)
+          ret = if config.applications[app] and config.applications[app].stages[stg]
+            options[:applications] << config.applications[app].stages[stg]
+            false
+          elsif config.applications[app] and stg.nil?
+            if config.applications[app].stages.empty?
+              options[:applications] << config.applications[app]
+            else
+              config.applications[app].stages.each{|name, stg| options[:applications] << stg}
+            end
+            false
+          else
+            found_non_application = true
+            true
+          end
+          raise ArgumentError, "Can not have non application configs between application configs" if !ret and found_non_application
+          ret
+        end
+      end
+    end
+  end
+end
+
+Capistrano::CLI.send :include, Borg::CLI::Applications

data/lib/borg/configuration/applications.rb

@@ -0,0 +1,49 @@
+module Borg
+  module Configuration
+    module Applications
+
+      def self.included(base) #:nodoc:
+        base.send :alias_method, :initialize_without_applications, :initialize
+        base.send :alias_method, :initialize, :initialize_with_applications
+      end
+      attr_reader :applications
+
+      def initialize_with_applications(*args) #:nodoc:
+        initialize_without_applications(*args)
+        @applications = {}
+      end
+      private :initialize_with_applications
+
+      def application (name, &block)
+        name = name.to_sym
+        namespace name do
+          desc "Load Application #{name} (All Stages if any)"
+          task :default do
+            @applications[name].execute
+          end
+        end
+        @applications[name] ||= Application.new(name, @namespaces[name])
+        @applications[name].execution_blocks << block if block_given?
+      end
+
+      class Application
+        attr_accessor :execution_blocks
+        attr_accessor :stages
+        attr_reader   :name
+
+        def initialize name, namespace
+          @execution_blocks = []
+          @name = name
+          @namespace = namespace
+          @stages = {}
+        end
+
+        def load_into config
+          @execution_blocks.each {|blk| config.load &blk}
+        end
+      end
+    end
+  end
+end
+
+Capistrano::Configuration.send :include, Borg::Configuration::Applications

data/lib/borg/configuration/assimilator.rb

@@ -0,0 +1,14 @@
+module Borg
+  module Configuration
+    module Assimilator
+      def assimilate gem_name
+        gem_home = Gem::Specification.find_by_name(gem_name).gem_dir
+        Dir["#{gem_home}/cap/initializers/**/*.rb"].each do |file|
+          load file
+        end
+        @load_paths << "#{gem_home}/cap"
+      end
+    end
+  end
+end
+Capistrano::Configuration.send :include, Borg::Configuration::Assimilator

data/lib/borg/configuration/stages.rb

@@ -0,0 +1,42 @@
+module Borg
+  module Configuration
+    module Stages
+
+      def stage (app, name, &block)
+        app = app.to_sym
+        name = name.to_sym
+        application app unless @applications[app]
+
+        namespace app do
+          desc "Load Application #{app} and Stage #{name}"
+          task name do
+            @applications[app].stages[name].execute
+          end
+        end
+        @applications[app].stages[name] ||= Stage.new(name, @applications[app])
+        @applications[app].stages[name].execution_blocks << block
+      end
+
+      class Stage
+        attr_accessor :execution_blocks
+        attr_accessor :parent
+        def name
+          "#{parent.name}:#{@name}"
+        end
+
+        def initialize name, parent
+          @execution_blocks = []
+          @name = name
+          @parent = parent
+        end
+
+        def load_into config
+          parent.load_into config
+          @execution_blocks.each {|blk| config.load &blk}
+        end
+      end
+    end
+  end
+end
+
+Capistrano::Configuration.send :include, Borg::Configuration::Stages

data/lib/borg/errors.rb

@@ -0,0 +1,4 @@
+module Borg
+  class BaseError < StandardError; end
+  class UnimplementedError < BaseError; end
+end

data/lib/borg/server/base.rb

@@ -0,0 +1,29 @@
+module Borg
+  module Server
+    class Base < ::Capistrano::ServerDefinition
+
+      def self.create opts
+        unimplemented "Use a subclass of Borg::Server::Base that implements the create functionality."
+      end
+
+      def start
+        unimplemented "Use a subclass of Borg::Server::Base that implements the start functionality."
+      end
+
+      def stop
+        unimplemented "Use a subclass of Borg::Server::Base that implements the stop functionality."
+      end
+
+      def destroy
+        unimplemented "Use a subclass of Borg::Server::Base that implements the destroy functionality."
+      end
+
+      private
+
+      def unimplemented msg
+        raise Borg::UnimplementedError.new msg
+      end
+
+    end
+  end
+end

data/lib/borg/servers/base.rb

@@ -0,0 +1,21 @@
+module Borg
+  module Servers
+    class Base
+      class << self
+        def all
+          unimplemented "Use a subclass of Borg::Servers::Base that implements the all functionality."
+        end
+
+        def [] name
+          all.select{|s| s.name == name}.first
+        end
+
+        private
+
+        def unimplemented msg
+          raise Borg::UnimplementedError.new msg
+        end
+      end
+    end
+  end
+end

data/lib/borg/version.rb

@@ -0,0 +1,3 @@
+module Borg
+  VERSION = "0.0.1"
+end

data/lib/borg.rb

@@ -0,0 +1,8 @@
+# source capistrano/deploy.rb
+def _cset(name, *args, &block)
+  unless exists?(name)
+    set(name, *args, &block)
+  end
+end
+
+assimilate "borg-rb"

data/skeleton/Capfile

@@ -0,0 +1,9 @@
+# provides a performance report at the end of execution
+# set :borg_performance_reports, true
+
+# runs on :exit events when ctrl-c is hit
+# set :borg_sigint_triggers_exit, true
+
+load 'borg.rb'
+# load any other borg gems here.
+# NOTE: require ends up causing the initializers to be called every time a config is loaded.

data/skeleton/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem 'borg-rb'

data/skeleton/mygem.gemspec.skeleton

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift 'lib'
+
+Gem::Specification.new do |s|
+  s.name              = raise "fill gem name here"
+  s.version           = raise "fill gem version here"
+  s.date              = Time.now.strftime('%Y-%m-%d')
+  s.summary           = raise "fill gem summary here"
+  s.homepage          = raise "fill gem homepage here"
+  s.email             = raise "fill gem contact emails here"
+  s.authors           = raise "fill gem author names here"
+  s.has_rdoc          = false
+
+  s.files             = %w( README.md Rakefile LICENSE )
+  s.files            += Dir.glob("lib/**/*")
+  s.files            += Dir.glob("cap/**/*")
+
+  s.description       = raise "fill gem description here"
+
+  s.add_dependency "borg-rb"
+end

data/spec/lib/borg/cli/applications_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+require 'borg/cli/applications'
+
+describe Borg::CLI::Applications do
+  before :each do
+    @config = double("config1")
+    @files = %w{cap/applications/app1.rb cap/applications/app1/stg1.rb cap/applications/app1/stg2.rb}
+    Dir.stub("[]").and_return(@files)
+    @cli = Capistrano::CLI.new([])
+  end
+
+  context "#load_applications when called" do
+    before do
+      @files.each { |f| @config.should_receive(:load).with(f) }
+    end
+
+    it "should load all files in ./cap/applications/**/*.rb" do
+      @cli.send :load_applications, @config
+    end
+
+    context "with a second call" do
+      before do
+        @cli.send :load_applications, @config
+        @config2 = double("config2")
+        @files.each { |f| @config2.should_not_receive(:load).with(f) }
+      end
+
+      it "should not load all files in ./cap/applications/**/*.rb for further calls" do
+        @cli.send :load_applications, @config2
+      end
+    end
+  end
+
+  context "#separate_actions_and_applications when called" do
+    before do
+      @cli.instance_eval do
+        @options = {}
+        @options[:actions] = %w{app1 app2:stg1 app2:stg3 test test2}
+      end
+      @config.stub(:applications).and_return({
+                                                 app1: double("app1"),
+                                                 app2: double("app2")
+                                             })
+      @config.applications[:app1].stub(:stages).and_return({})
+      @config.applications[:app2].stub(:stages).and_return({
+                                                              stg1: double("stg1"),
+                                                              stg2: double("stg2")
+                                                          })
+    end
+    it "should remove all applications from actions" do
+      @cli.send :separate_actions_and_applications, @config
+      @cli.options[:actions].should == %w{app2:stg3 test test2}
+      @cli.options[:applications].should == [
+          @config.applications[:app1],
+          @config.applications[:app2].stages[:stg1]
+      ]
+    end
+
+    it "should queue both stages if app2" do
+      @cli.instance_eval do
+        @options[:actions] = %w{app1 app2 test test2}
+      end
+
+      @cli.send :separate_actions_and_applications, @config
+
+      @cli.options[:actions].should == %w{test test2}
+      @cli.options[:applications].should == [
+          @config.applications[:app1],
+          @config.applications[:app2].stages[:stg1],
+          @config.applications[:app2].stages[:stg2]
+      ]
+    end
+
+    it "should raise exception if configs are not isolated to start of the actions list" do
+      @cli.instance_eval do
+        @options[:actions] << "app2:stg2"
+      end
+      expect{ @cli.send(:separate_actions_and_applications, @config)}.to raise_error(ArgumentError, "Can not have non application configs between application configs")
+    end
+
+  end
+
+  context "#execute_requested_actions_with_applications when called" do
+    before do
+
+      @cli.instance_eval do
+        @apps_loaded = true
+        @options = {}
+        @options[:actions] = %w{app1 app2:stg1 app2:stg3 test test2}
+        @options[:applications] = []
+      end
+      @config.stub(:applications).and_return({})
+
+      @cli.stub(:execute_requested_actions_without_applications)
+
+    end
+
+    it "should load applications" do
+      @cli.should_receive(:load_applications).with(@config)
+      @cli.execute_requested_actions_with_applications @config
+    end
+
+    it "should separate actions and applications" do
+      @cli.should_receive(:separate_actions_and_applications).with(@config)
+      @cli.execute_requested_actions_with_applications @config
+    end
+
+    it "should call #execute_requested_actions_without_applications when there is an empty applications list" do
+      @cli.should_receive(:execute_requested_actions_without_applications).with(@config)
+      @cli.execute_requested_actions_with_applications @config
+    end
+
+    context "when applications exist" do
+      before do
+        apps = [double(:app1), double(:app2)]
+        apps[0].stub(:name).and_return(:app1)
+        apps[1].stub(:name).and_return(:app2)
+        @cli.instance_eval do
+          @options[:applications] = apps
+        end
+        @cli.stub(:puts)
+      end
+
+      after do
+        Thread.current[:borg_application] = nil
+      end
+
+      it "should call call execute! for each application" do
+        @cli.stub(:load_applications)
+        @cli.stub(:separate_actions_and_applications)
+        @cli.should_receive(:execute!).with().twice
+        @cli.execute_requested_actions_with_applications @config
+      end
+
+      it "should set Thread's borg_application" do
+        @cli.stub(:load_applications)
+        @cli.stub(:separate_actions_and_applications)
+        @cli.stub(:execute!) do
+          @cli.options[:applications].should include Thread.current[:borg_application]
+        end
+        @cli.execute_requested_actions_with_applications @config
+      end
+
+      it "should call #execute_requested_actions_without_applications when Thread's borg_application is set" do
+        Thread.current[:borg_application] = @cli.options[:applications][0]
+        @cli.stub(:load_applications)
+        @cli.stub(:separate_actions_and_applications)
+        @cli.should_receive(:execute_requested_actions_without_applications).with(@config)
+        @cli.options[:applications][0].stub(:load_into)
+        @cli.execute_requested_actions_with_applications @config
+      end
+
+      it "should load the application's config when Thread's borg_application is set" do
+        Thread.current[:borg_application] = @cli.options[:applications][0]
+        @cli.stub(:load_applications)
+        @cli.stub(:separate_actions_and_applications)
+        @cli.stub(:execute_requested_actions_without_applications)
+        @cli.options[:applications][0].should_receive(:load_into)
+        @cli.execute_requested_actions_with_applications @config
+      end
+
+    end
+  end
+end

data/spec/lib/borg/configuration/applications_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'borg/configuration/applications'
+
+describe Borg::Configuration::Applications do
+  it "should be included into Capistrano::Configuration" do
+    Capistrano::Configuration.ancestors.should include Borg::Configuration::Applications
+  end
+
+  context "when a new Capistrano::Configuration is initialized" do
+    subject { Capistrano::Configuration.new }
+    it "should initialize the applications hash" do
+      expect(subject.applications).to eq({})
+    end
+  end
+
+  context "when an applications is defined" do
+    before do
+      @config = Capistrano::Configuration.new
+      @config.load do
+        application "app1" do
+          test_notice "You have called app1"
+        end
+      end
+    end
+    subject { @config }
+
+    it "should symobolize the name" do
+      expect(subject.applications[:app1].name).to eq :app1
+    end
+
+    it "should create a namespace app1 with task default and a description" do
+      expect(subject.namespaces[:app1]).to be_true
+      expect(subject.namespaces[:app1].tasks[:default]).to be_true
+      expect(subject.namespaces[:app1].tasks[:default].desc).to be_true
+    end
+
+    it "should add it to applications hash and have a block" do
+      expect(subject.applications[:app1].class).to eq Borg::Configuration::Applications::Application
+      expect(subject.applications[:app1].execution_blocks.count).to eq 1
+    end
+  end
+end
+
+describe Borg::Configuration::Applications::Application do
+  it "should be initialize all variables" do
+    app1 = Borg::Configuration::Applications::Application.new(:app1, double("namespace app1"))
+    expect(app1.stages).to eq({})
+    expect(app1.name).to eq(:app1)
+    expect(app1.execution_blocks).to eq([])
+  end
+
+  context "an applications with 2 blocks" do
+    before do
+      @app1 = Borg::Configuration::Applications::Application.new(:app1, double("namespace app1"))
+      @app1.execution_blocks << -> {
+        raise "block 1 called"
+      }
+      @app1.execution_blocks << -> {
+        raise "block 2 called"
+      }
+    end
+    context "when #load_into is called" do
+      it "should all blocks into the provided config" do
+        config  = double("test config")
+        config.should_receive(:load).twice
+        @app1.load_into config
+      end
+    end
+  end
+end

data/spec/lib/borg/configuration/assimilator_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'borg/configuration/assimilator'
+
+describe Borg::Configuration::Assimilator do
+  it "should be included into Capistrano::Configuration" do
+    Capistrano::Configuration.new.should respond_to :assimilate
+  end
+
+  context "when assimilate('borg') is called" do
+    subject { Capistrano::Configuration.new }
+    it "should loads all the initializers" do
+      Dir["cap/initializers/**/*.rb"].each do |file|
+        subject.should_receive(:load).with(File.expand_path(file))
+      end
+      subject.assimilate ('borg-rb')
+    end
+
+    it "should add the cap directory to teh load path" do
+      Dir.stub("[]").and_return([])
+      lambda { subject.assimilate ('borg-rb') }.should change(subject.load_paths, :count).by 1
+    end
+  end
+end

data/spec/lib/borg/configuration/stages_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'borg/configuration/applications'
+require 'borg/configuration/stages'
+
+describe Borg::Configuration::Stages do
+  it "should be included into Capistrano::Configuration" do
+    Capistrano::Configuration.ancestors.should include Borg::Configuration::Stages
+  end
+
+  context "when an applications is defined" do
+    before do
+      @config = Capistrano::Configuration.new
+      @config.load do
+        stage "app1", "stg1" do
+          test_notice "You have called app1 stg1"
+        end
+      end
+    end
+    subject { @config }
+
+    it "should create application since it does not exist" do
+      expect(subject.applications[:app1]).to be_true
+    end
+
+    it "should symobolize the name" do
+      expect(subject.applications[:app1].stages.keys.first).to eq :stg1
+    end
+
+    it "should create a namespace app1 with task stg1 and a description" do
+      expect(subject.namespaces[:app1]).to be_true
+      expect(subject.namespaces[:app1].tasks[:stg1]).to be_true
+      expect(subject.namespaces[:app1].tasks[:stg1].desc).to be_true
+    end
+
+    it "should add it to applications hash and have a block" do
+      expect(subject.applications[:app1].stages[:stg1].class).to eq Borg::Configuration::Stages::Stage
+      expect(subject.applications[:app1].stages[:stg1].execution_blocks.count).to eq 1
+    end
+  end
+end
+
+describe Borg::Configuration::Stages::Stage do
+  it "should be initialize all variables" do
+    parent = double "app1"
+    parent.stub(:name).and_return :app1
+    stg1 = Borg::Configuration::Stages::Stage.new(:stg1, parent)
+    expect(stg1.name).to eq("app1:stg1")
+    expect(stg1.parent).to eq(parent)
+    expect(stg1.execution_blocks).to eq([])
+  end
+
+  context "a stage with 2 blocks" do
+    before do
+      @stg1 = Borg::Configuration::Stages::Stage.new(:stg1, double("app1"))
+      @stg1.execution_blocks << -> {
+        raise "block 1 called"
+      }
+      @stg1.execution_blocks << -> {
+        raise "block 2 called"
+      }
+    end
+    context "when #load_into is called" do
+      it "should all blocks into the provided config" do
+        config  = double("test config")
+        @stg1.parent.should_receive(:load_into).with(config)
+        config.should_receive(:load).twice
+        @stg1.load_into config
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'capistrano/cli'
+
+require 'yaml'

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: borg-rb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Identified
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: capistrano
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capistrano_colors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: term-ansicolor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby-based software provisioning and deployment framework
+email:
+- phil@identified.com
+- tejas@identified.com
+executables:
+- borg
+- borgify
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Capfile
+- Gemfile
+- README.md
+- bin/borg
+- bin/borgify
+- borg.gemspec
+- cap/applications/app1.rb
+- cap/initializers/output.rb
+- cap/initializers/performance.rb
+- cap/initializers/role_reset.rb
+- cap/initializers/sigint.rb
+- lib/borg.rb
+- lib/borg/cli/applications.rb
+- lib/borg/configuration/applications.rb
+- lib/borg/configuration/assimilator.rb
+- lib/borg/configuration/stages.rb
+- lib/borg/errors.rb
+- lib/borg/server/base.rb
+- lib/borg/servers/base.rb
+- lib/borg/version.rb
+- skeleton/Capfile
+- skeleton/Gemfile
+- skeleton/cap/applications/.gitkeep
+- skeleton/cap/initializers/.gitkeep
+- skeleton/cap/recipies/.gitkeep
+- skeleton/lib/.gitkeep
+- skeleton/mygem.gemspec.skeleton
+- spec/lib/borg/cli/applications_spec.rb
+- spec/lib/borg/configuration/applications_spec.rb
+- spec/lib/borg/configuration/assimilator_spec.rb
+- spec/lib/borg/configuration/stages_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/B0RG/borg
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby-based software provisioning and deployment framework
+test_files:
+- spec/lib/borg/cli/applications_spec.rb
+- spec/lib/borg/configuration/applications_spec.rb
+- spec/lib/borg/configuration/assimilator_spec.rb
+- spec/lib/borg/configuration/stages_spec.rb
+- spec/spec_helper.rb
+has_rdoc: