blazing 0.0.16 → 0.1.0.alpha1

data/lib/blazing/templates/config.erb

@@ -0,0 +1,21 @@
+#
+# Blazing Configuration File
+#
+
+# Specify the location of your repository:
+#   repository 'git@github.com:path/to/your/repository'
+
+# Define possible deploy targets:
+#   target :production, 'blazing@production.server.com:/where/your/code/is/shipped/to'
+#   target :staging, 'blazing@production.server.com:/where/your/code/is/shipped/to', :default => true
+
+# Define which recipes should be used
+#   recipes [:rvm, :bundler]
+
+# Define an rvm ruby/gemset to be used remotely
+#   rvm 'ruby-1.9.2@agemset'
+# Or use the rvm specified in .rvmrc
+#   rvm :rvmrc
+
+# Defina a rake task that should be run after deployment
+#   rake :a_rake_task_to_call_after_deployment

data/lib/blazing/templates/hook.erb

@@ -0,0 +1,43 @@
+#!/bin/bash
+
+cd ..
+GIT_DIR='.git'
+
+git reset --hard HEAD
+
+<% if @config.rvm %>
+  # Load RVM into a shell session *as a function*
+  if [[ -s "$HOME/.rvm/scripts/rvm" ]] ; then
+
+    # First try to load from a user install
+    source "$HOME/.rvm/scripts/rvm"
+
+    <% if @config.rvm == :rvmrc %>
+      source .rvmrc
+    <% else %>
+      rvm use <%= @config.rvm %>
+    <% end %>
+
+  elif [[ -s "/usr/local/rvm/scripts/rvm" ]] ; then
+
+    # Then try to load from a root install
+    source "/usr/local/rvm/scripts/rvm"
+
+    <% if @config.rvm == :rvmrc %>
+      source .rvmrc
+    <% else %>
+      rvm use <%= @config.rvm %>
+    <% end %>
+
+  else
+    printf "ERROR: RVM was enabled in config but no RVM installation was not found.\n"
+  fi
+<% end %>
+
+<% if @config.rake %>
+  rake <%= @config.rake %>
+<% end %>
+
+<%# bundle --deployment%>
+<%# bundle exec rake RAILS_ENV=production RAILS_GROUPS=assets assets:precompile%>
+<%# touch tmp/restart.txt%>

data/lib/blazing/version.rb

@@ -1,3 +1,3 @@
 module Blazing
-  VERSION = "0.0.16"
+  VERSION = "0.1.0.alpha1"
 end

data/spec/blazing/config_spec.rb

@@ -3,80 +3,136 @@ require 'blazing/config'
 
 describe Blazing::Config do
 
-  before :each do
-    @config = Blazing::Config.new
-  end
+  describe '#initialize' do
+    it 'takes the path of the config file as an argument' do
+      config = Blazing::Config.new('/some/where/config.rb')
+      config.file.should == '/some/where/config.rb'
+    end
 
-  describe '#target' do
-    it 'adds a target to the config object' do
-      @config.target(:test_target, :deploy_to => 'smoeone@somewhere:/asdasdasd')
-      @config.targets.size.should == 1
+    it 'takes the default config path if no path is specified' do
+      config = Blazing::Config.new
+      config.file.should == 'config/blazing.rb'
     end
   end
 
-  describe '#use' do
-    it 'adds a recipe to the config object' do
-      @config.use(:rvm)
-      @config.recipes.size.should == 1
+  describe '.parse' do
+
+    it 'returns a config object' do
+      Blazing::Config.parse('spec/support/empty_config.rb').should be_a Blazing::Config
     end
+
   end
 
-  describe '#find_target' do
-    context 'when a target name is given' do
-      it 'returns the target with the given name' do
-        @config.target(:test_target, :deploy_to => 'smoeone@somewhere:/asdasdasd')
-        @config.find_target(:test_target).name.should == 'test_target'
-      end
+  describe '#default_target' do
+
+    it 'retunrs a target object if only one is present' do
+      config = Blazing::Config.new
+      config.target :sometarget, 'somewhere'
+      config.default_target.name.should be :sometarget
     end
 
-    context 'when no target name given' do
-      it 'returns the target defined in config if there is only one' do
-        @config.target(:test_target, :deploy_to => 'smoeone@somewhere:/asdasdasd')
-        @config.find_target.name.should == 'test_target'
-      end
+    context 'when more than 1 target defined in config' do
 
-      it 'returns the default target if there is one' do
-        @config.target(:test_target, :deploy_to => 'smoeone@somewhere:/asdasdasd')
-        @config.target(:default_target, :default => true, :deploy_to => 'smoeone@somewhere:/asdasdasd')
-        @config.find_target.name.should == 'default_target'
+      it 'raises an error when none is default' do
+        config = Blazing::Config.new
+        config.target :sometarget, 'somewhere'
+        config.target :someothertarget, 'somewhere'
+        lambda { config.default_target }.should raise_error
       end
 
-      it 'raises an error if no target could be determined' do
-        lambda { @config.find_target }.should raise_error
+      it 'retunrs the target object with :default => true option if more than 1 target present' do
+        config = Blazing::Config.new
+        config.target :sometarget, 'somewhere', :default => true
+        config.target :someothertarget, 'somewhere'
+        config.default_target.name.should be :sometarget
       end
+
     end
   end
 
-  describe '.dsl_setter' do
+  describe 'DSL' do
+
     before :each do
-      @config.class.class_eval do
-        dsl_setter :foo
+      @config = Blazing::Config.new
+    end
+
+    describe 'target' do
+
+      it 'creates a target object for each target call' do
+        @config.target :somename, 'someuser@somehost:/path/to/deploy/to'
+        @config.target :someothername, 'someuser@somehost:/path/to/deploy/to'
+
+        @config.targets.each { |t| t.should be_a Blazing::Target }
+        @config.targets.size.should be 2
+      end
+
+      it 'does not allow the creation of two targets with the same name' do
+        @config.target :somename, 'someuser@somehost:/path/to/deploy/to'
+        lambda { @config.target :somename, 'someuser@somehost:/path/to/deploy/to' }.should raise_error
       end
     end
 
-    it 'creates a dsl method to set the attribute in the config class' do
-      @config.foo 'something'
-      @config.instance_variable_get('@foo').should == 'something'
+    describe 'repository' do
+      it 'assigns the repository if a value is given' do
+        @config.repository('somewhere')
+        @config.instance_variable_get("@repository").should == 'somewhere'
+      end
+
+      it 'returns the repository string if no value is given' do
+        @config.repository('somewhere')
+        @config.repository.should == 'somewhere'
+      end
     end
 
-    it 'creates a dsl method that allows to read the attribute in the config class' do
-      @config.foo 'something'
-      @config.foo.should == 'something'
+    describe 'recipes' do
+
+      before :each do
+        class Blazing::Recipe::Dummy < Blazing::Recipe
+        end
+      end
+
+      it 'is an empty recipe if nothing was set' do
+        @config.recipes.should be_a Array
+      end
+
+      it 'accepts a single recipe as argument' do
+        @config.recipes :dummy
+        @config.recipes.first.should be_a Blazing::Recipe::Dummy
+      end
+
+      it 'accepts an array of recipes as argument' do
+        @config.recipes [:dummy, :dummy]
+        @config.recipes.size.should be 2
+        @config.recipes.each { |r| r.should be_a Blazing::Recipe::Dummy }
+      end
     end
-  end
 
-  describe '.load' do
-    it 'reads and parses the config file and returns a config object' do
-      Blazing.send(:remove_const, 'CONFIGURATION_FILE')
-      Blazing::CONFIGURATION_FILE = 'spec/support/config.rb'
-      Blazing::Config.parse.should be_a Blazing::Config
+    describe 'rake' do
+
+      it 'takes the name of the rake task as argument' do
+        @config.rake :post_deploy
+        @config.instance_variable_get('@rake').should be :post_deploy
+      end
+
+      it 'returns the name of the task if no argument given' do
+        @config.rake :post_deploy
+        @config.rake.should be :post_deploy
+      end
+
     end
-  end
 
-  describe '.read' do
-    it 'parses the config and returns a config object' do
-      @config.class.read {}.should be_a Blazing::Config
+    describe 'rvm' do
+
+      it 'takes an rvm string as argument' do
+        @config.rvm 'ruby-1.9.2@rails31'
+        @config.instance_variable_get('@rvm').should == 'ruby-1.9.2@rails31'
+      end
+
+      it 'returns the rvm string if no argument given' do
+        @config.rvm 'ruby-1.9.2@rails31'
+        @config.rvm.should == 'ruby-1.9.2@rails31'
+      end
+
     end
   end
-
 end

data/spec/blazing/integration/init_spec.rb

@@ -1,53 +1,24 @@
 require 'spec_helper'
-require 'blazing'
-require 'fileutils'
+require 'blazing/config'
+require 'blazing/runner'
 
 describe 'blazing init' do
 
   before :each do
-    @blazing_root = Dir.pwd
-    @sandbox_directory = File.join(@blazing_root, 'spec/support/sandbox')
-    @blazing =  Blazing::CLI::Base.new
-
-    # Sometimes, when specs failed, the sandbox would stick around
-    FileUtils.rm_rf(@sandbox_directory) if Dir.exists?(@sandbox_directory)
-
-    # Setup Sandbox
-    Dir.mkdir(@sandbox_directory)
-    Dir.chdir(@sandbox_directory)
-
-    # Setup empty repository
-    @repository_dir = 'repo_without_config'
-    Dir.mkdir(@repository_dir)
-    Dir.chdir(@repository_dir)
-    `git init`
+    setup_sandbox
+    capture(:stdout) { Blazing::Runner.new.exec('init') }
   end
 
   after :each do
-    # Teardown Sandbox
-    Dir.chdir(@blazing_root)
-    FileUtils.rm_rf(@sandbox_directory)
+    teardown_sandbox
   end
 
-  it 'creates the config directory if it does not exist' do
-    silence(:stdout) { @blazing.init }
+  it 'creates a config directory if none exists yet' do
     Dir.exists?('config').should be true
   end
 
-  it 'does not fail when config directory exists already' do
-    silence(:stdout) { lambda { @blazing.init }.should_not raise_error }
-  end
-
-  it 'attempts to use the origin remote to setup the repository in the config' do
-    @origin = 'git@github.com:someone/somerepo.git'
-    `git remote add origin #{@origin}`
-    silence(:stdout) { @blazing.init }
-    Blazing::Config.parse.repository.should == @origin
-  end
-
-  it 'sets a dummy repository config when no remote was found' do
-    silence(:stdout) { @blazing.init }
-    Blazing::Config.parse.repository.should == 'user@host:/some/path'
+  it 'creates a config file in config/blazing.rb' do
+    File.exists?('config/blazing.rb').should be true
   end
 
 end

data/spec/blazing/integration/setup_local_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'blazing/config'
+require 'blazing/runner'
+require 'grit'
+
+describe 'blazing setup:local' do
+
+  before :each do
+    setup_sandbox
+    @production_url = 'user@host:/some/where'
+    @staging_url = 'user@host:/some/where/else'
+
+    @config = Blazing::Config.new
+    @config.target :production, @production_url
+    @config.target :staging, @staging_url, :default => true
+    capture(:stdout) { Blazing::Runner.new(@config).exec('setup:local') }
+  end
+
+  after :each do
+    teardown_sandbox
+  end
+
+  it 'adds a git remote for each target' do
+    Grit::Repo.new(Dir.pwd).config['remote.production.url'].should == @production_url
+  end
+
+end

data/spec/blazing/integration/setup_remote_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'blazing/config'
+require 'blazing/runner'
+require 'grit'
+
+describe 'blazing setup:remote' do
+
+  before :each do
+    setup_sandbox
+    @production_url = 'user@host:/some/where'
+    @staging_url = 'user@host:/some/where/else'
+
+    @config = Blazing::Config.new
+    @config.target :production, @production_url
+    @config.target :staging, @staging_url, :default => true
+    @runner = Blazing::Runner.new(@config)
+  end
+
+  after :each do
+    teardown_sandbox
+  end
+
+  it 'clones the repository, configures it and updates the target' do
+    @shell = Blazing::Shell.new
+    @target = @config.default_target
+    @target.instance_variable_set('@shell', @shell)
+    @shell.should_receive(:run).with("ssh user@host 'git clone  /some/where/else && cd /some/where/else && git config receive.denyCurrentBranch ignore'")
+    @target.should_receive(:update)
+    capture(:stdout) { @runner.exec('setup:remote') }
+  end
+
+end

data/spec/blazing/integration/update_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'blazing/config'
+require 'blazing/runner'
+require 'grit'
+
+describe 'blazing update' do
+
+  before :each do
+    setup_sandbox
+    @production_url = 'user@host:/some/where'
+    @staging_url = 'user@host:/some/where/else'
+
+    @config = Blazing::Config.new
+    @config.target :production, @production_url
+    @config.target :staging, @staging_url, :default => true
+    @runner = Blazing::Runner.new(@config)
+  end
+
+  after :each do
+    teardown_sandbox
+  end
+
+  it 'generates the hook' do
+    capture(:stdout) { @runner.exec('update') }
+    File.exists?(Blazing::TMP_HOOK).should be true
+  end
+
+  it 'copies the hook to the targets repository and makes it exectuable' do
+    @shell_double = double('shell')#Blazing::Shell.new
+    @target = @config.default_target
+    @target.instance_variable_set('@shell', @shell_double)
+
+    @shell_double.should_receive(:run).once.with("scp /tmp/post-receive user@host:/some/where/else/.git/hooks/post-receive")
+    @shell_double.should_receive(:run).once.with('ssh user@host chmod +x /some/where/else/.git/hooks/post-receive')
+    capture(:stdout) { @runner.exec('update') }
+  end
+
+end

data/spec/blazing/recipe_spec.rb

@@ -3,76 +3,15 @@ require 'blazing/recipe'
 
 describe Blazing::Recipe do
 
-  context 'initializer' do
-    it 'takes a string as name parameter' do
-      recipe = Blazing::Recipe.new('some_recipe')
-      recipe.name.should == 'some_recipe'
-    end
-
-    it 'takes a symbol as name parameter and converts it to a string' do
-      recipe = Blazing::Recipe.new(:some_recipe)
-      recipe.name.should == 'some_recipe'
-    end
-
-    it 'accepts options' do
-      recipe = Blazing::Recipe.new(:some_recipe, :an_option => 'yeah')
-      recipe.options[:an_option].should == 'yeah'
-    end
-  end
-
-  context 'recipe discovery' do
-
-    around :each do |example|
-      # Make sure specs dont interfere with recipe discovery mechanism
-      recipes = Blazing::Recipe.list
-      recipes.each { |r| Blazing.send(:remove_const, r.name.to_s.gsub(/^.*::/, '')) rescue NameError }
-      example.run
-      recipes.each { |r| Blazing.send(:remove_const, r.name.to_s.gsub(/^.*::/, '')) rescue NameError }
-    end
-
-    it 'before loading them, no recipes are known' do
-      lambda { Blazing::RvmRecipe }.should raise_error NameError
-    end
-
-    it 'can discover available recipes' do
-      recipes = Blazing::Recipe.list
-      recipes.should be_all { |recipe| recipe.superclass.should == Blazing::Recipe }
-    end
-  end
-
-  describe '#recipe_class' do
-    it 'construct the correct classname to use from recipe name' do
-      Blazing::Recipe.load_builtin_recipes
-      Blazing::Recipe.new(:rvm).recipe_class.should == Blazing::RvmRecipe
-    end
-
-    context 'when trying to load an unknown recipe' do
-      it 'does not raise a NameError' do
-        lambda { Blazing::Recipe.new('weirdname').recipe_class }.should_not raise_error NameError
-      end
-
-      it 'logs an error message' do
-        @logger = double('logger')
-        @logger.should_receive(:log).with(:error, "unable to load weirdname recipe")
-        Blazing::Recipe.new('weirdname', :_logger => @logger).recipe_class
+  describe '.init_by_name' do
+    before :each do
+      class Blazing::Recipe::Dummy < Blazing::Recipe
       end
     end
-  end
 
-  describe '#run' do
-    it 'raise an error when a recipe has no run method defined' do
-      class Blazing::BlahRecipe < Blazing::Recipe; end
-      lambda { Blazing::Recipe.new(:blah).run }.should raise_error RuntimeError
+    it 'initializes the correct recipe' do
+      Blazing::Recipe.init_by_name(:dummy).should be_a Blazing::Recipe::Dummy
     end
   end
 
-  context 'builtin recipes' do
-    it 'include an rvm recipe' do
-      lambda { Blazing::RvmRecipe }.should_not raise_error NameError
-    end
-
-    it 'include a bundler recipe' do
-      lambda { Blazing::BundlerRecipe }.should_not raise_error NameError
-    end
-  end
 end