blazing 0.4.2 → 0.5.0

data/lib/blazing/hook.rb

@@ -1,8 +1,8 @@
 require 'erb'
+require_relative 'target'
 
 module Blazing
   class Hook
-
     include Blazing::Logger
 
     attr_accessor :target
@@ -20,16 +20,21 @@ module Blazing
     end
 
     def rake_command
-      rake_config = @config.instance_variable_get("@rake") || {}
-      rails_env = "RAILS_ENV=#{@options[:rails_env]}" if @options[:rails_env]
-
-      if rake_config[:task]
-        "#{rake_config[:env]} #{rails_env} bundle exec rake #{rake_config[:task]}"
-      end
+      "#{options_as_vars}bundle exec rake #{@config.rake_task}" if @config.rake_task
     end
 
     private
 
+    def options_as_vars
+      keys = @options.keys
+      options = ''
+      keys.each do |key|
+        options << "#{key.to_s.upcase}=#{@options[key]} "
+      end
+
+      options
+    end
+
     def load_template(template_name)
       ::ERB.new(File.read(find_template(template_name))).result(binding)
     end
@@ -55,7 +60,7 @@ module Blazing
     end
 
     def write(hook)
-      File.open(Blazing::TMP_HOOK, "wb") do |f|
+      File.open(Blazing::TMP_HOOK, 'wb') do |f|
         f.puts hook
       end
     end
@@ -69,7 +74,7 @@ module Blazing
     end
 
     def copy_hook
-      debug "Making hook executable"
+      debug 'Making hook executable'
       # TODO: handle missing user?
       if @target.host
         @shell.run "scp #{Blazing::TMP_HOOK} #{@target.user}@#{@target.host}:#{@target.path}/.git/hooks/post-receive"
@@ -79,9 +84,8 @@ module Blazing
     end
 
     def make_hook_executable
-      debug "Making hook executable"
+      debug 'Making hook executable'
       "chmod +x #{@target.path}/.git/hooks/post-receive"
     end
   end
 end
-

data/lib/blazing/logger.rb

@@ -2,38 +2,34 @@ require 'logging'
 
 module Blazing
   module Logger
-
     # include Logging.globally
 
     # here we setup a color scheme called 'bright'
-    Logging.color_scheme( 'bright',
-      :levels => {
-        :debug => :green,
-        :info  => :green,
-        :warn  => :yellow,
-        :error => [:white, :on_red],
-        :fatal => [:white, :on_red]
-      }
-    )
+    Logging.color_scheme('bright',
+                         levels: {
+                           debug: :green,
+                           info: :green,
+                           warn: :yellow,
+                           error: [:white, :on_red],
+                           fatal: [:white, :on_red]
+                         }
+                        )
 
     Logging.appenders.stdout(
       'stdout',
-      :layout => Logging.layouts.pattern(
-        :pattern => ' ------> [blazing] %-5l: %m\n',
-        :color_scheme => 'bright'
+      layout: Logging.layouts.pattern(
+        pattern: ' ------> [blazing] %-5l: %m\n',
+        color_scheme: 'bright'
       )
     )
 
     Logging.logger.root.appenders = 'stdout'
     Logging.logger.root.level = :info
-    Logging.consolidate :root
 
-    %w[debug info warn error fatal].each do |level|
+    %w(debug info warn error fatal).each do |level|
       define_method level do |message|
         Logging.logger[self].send(level, message)
       end
     end
-
   end
 end
-

data/lib/blazing/repository.rb

@@ -1,8 +1,12 @@
+#
+# Handles local repository settings
+#
 require 'grit'
+require_relative './shell'
+require_relative './logger'
 
 module Blazing
   class Repository
-
     include Blazing::Logger
 
     def initialize(target)

data/lib/blazing/shell.rb

@@ -1,7 +1,7 @@
-class Blazing::Shell
-
-  def run(command)
-    `#{command}`
+module Blazing
+  class Shell
+    def run(command)
+      `#{command}`
+    end
   end
-
 end

data/lib/blazing/target.rb

@@ -1,7 +1,8 @@
-module Blazing
+require_relative 'repository'
+require_relative 'hook'
 
+module Blazing
   class Target
-
     include Blazing::Logger
 
     attr_accessor :name, :location, :options, :config
@@ -49,4 +50,3 @@ module Blazing
     end
   end
 end
-

data/lib/blazing/templates/config.erb

@@ -12,59 +12,24 @@
 #   rails_env: used when calling the rake task after deployment
 
 target :staging, 'user@server:/var/www/someproject.com',
-       :recipe_specific_option => 'foo', :rails_env => 'production'
+       :rails_env => 'production'
 
-
-# Sample rvm setup:
+# Sample rvm/rbenv/chruby/other setup:
 #
-#    rvm <rvm-string>
+#    env_sript <your rvm setup scripts>
 #
-# Setting the rvm string will make sure that the correct rvm ruby and
-# gemset is used before the post-receive hook does anything at all.
-# Use :rvmrc as rvm string if you want blazing to use the rvm
-# environment specified in your project's .rvmrc file.
-
-rvm 'ruby-1.9.3@some-gemset'
-
-
-# Sample config for custom rvm location:
-#
-#    rvm_scripts <path_to_rvm_scripts>
-#
-# If you have installed rvm to a custom location, use this method to
-# specify where the rvm scripts are located.
-
-rvm_scripts '/opt/rvm/scripts/rvm'
-
-# Sample rbenv/chruby/other setup:
-#
-#    env_scripts <path_to_version_manager_script>
-#
-# If you need to source a file for your non-rvm version manager to
-# you can do that with env_scripts. You should also remove the
-# rvm/rvm_scripts options above.
-
-env_scripts '/etc/profile.d/rbenv.sh'
-
-# Sample recipe setup:
-#
-#     recipe <recipe_name>, [options]
-#
-# The given recipe will be called with the provided options. Refer to each
-# recipe's documentation for available options. Options provided here
-# may be overridden by target specific options.
-# Recipes will be executed in the order they are defined!yy
-
-recipe :precompile_assets, :recipe_specific_option => 'bar'
-
+# Setting an env_script path makes sure it is sourced before the hook
+# does anything at all. That way you can setup any environment things
+# you need to. Most commonly this will be sourcing rvm and setting a
+# ruby, or doing something with rbenv or chruby.
+env_script '/etc/profile.d/rbenv.sh'
 
 # Sample rake file config:
 #
 #     rake <task>, [environment variables]
 #
-# The provided rake task will be run after all recipes have run.
+# The provided rake task will be run after blazing has done its stuff.
 # Note: you can only call a single rake task. If you need to run several
 # tasks just create one task that wrapps all the others.
 
-rake :post_deploy, 'RAILS_ENV=production'
-
+rake :post_deploy

data/lib/blazing/templates/hook/base.erb

@@ -1,8 +1,5 @@
 <%= load_template 'hook/setup' %>
 <%= load_template 'hook/git-reset' %>
 <%= load_template 'hook/env-scripts' %>
-<%= load_template 'hook/rvm' %>
 <%= load_template 'hook/bundler' %>
-<%= load_template 'hook/recipes' %>
 <%= load_template 'hook/rake' %>
-

data/lib/blazing/templates/hook/bundler.erb

@@ -1,3 +1,4 @@
-echo "------> [blazing] Bundling gems"
-bundle --deployment --quiet --without development test
-
+if [ -f "Gemfile" ] ; then
+  echo "------> [blazing] Bundling gems"
+  bundle --deployment --quiet --without development test
+fi

data/lib/blazing/templates/hook/env-scripts.erb

@@ -1,6 +1,6 @@
-<% if @config.env_scripts %>
+<% if @config.env_script %>
 
-  source <%= @config.env_scripts %>
-  echo "------> [blazing] Loading environment scripts from custom location"
+  source <%= @config.env_script %>
+  echo "------> [blazing] Sourcing environment script"
 
 <% end %>

data/lib/blazing/templates/hook/rake.erb

@@ -2,4 +2,3 @@
   echo "------> [blazing] running <%= rake_command %>"
   <%= rake_command %>
 <% end %>
-

data/lib/blazing/templates/hook/rvm.erb

@@ -1,35 +1,7 @@
-<% if @config.rvm %>
+<% if @config.rvm? %>
 
-  #
-  # Normal RVM installation
-  #
-  <% unless @config.rvm_scripts %>
-    # 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"
-
-    elif [[ -s "/usr/local/rvm/scripts/rvm" ]] ; then
-
-      # Then try to load from a root install
-      source "/usr/local/rvm/scripts/rvm"
-
-    else
-      echo '------> [blazing] ERROR: RVM was enabled in config but no RVM installation was not found\n'
-    fi
-  <% end %>
-
-  #
-  # Apply rvm env
-  #
-  <% if @config.rvm == :rvmrc %>
-    echo "------> [blazing] Loading rvm from .rvmrc"
-    source .rvmrc
-  <% else %>
-    echo "------> [blazing] Loading rvm string: <%= @config.rvm %>"
-    rvm use <%= @config.rvm %>
-  <% end %>
+  echo "------> [blazing] Loading rvm from .rvmrc"
+  source .rvmrc
 
 <% end %>
 

data/lib/blazing/templates/hook/setup.erb

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 echo "------"
 echo "------  [blazing] ENTERING POST RECEIVE HOOK FOR: <%= @target.name %>"

data/lib/blazing/version.rb

@@ -0,0 +1,3 @@
+module Blazing
+  VERSION = '0.5.0'
+end

data/spec/blazing/cli_spec.rb

@@ -1,9 +1,8 @@
 require 'spec_helper'
+require 'blazing/cli'
 
 module Blazing
-
   describe CLI do
-
     let(:cli) { CLI.new }
     it 'has an init method' do
       cli.respond_to? :init
@@ -17,17 +16,8 @@ module Blazing
       cli.respond_to? :update
     end
 
-    it 'has a recipes method' do
-      cli.respond_to? :recipes
-    end
-
-    it 'has a list method' do
-      cli.respond_to? :list
-    end
-
     it 'has a help method' do
       cli.respond_to? :help
     end
   end
 end
-

data/spec/blazing/commands_spec.rb

@@ -1,24 +1,18 @@
 require 'spec_helper'
-require 'blazing/commands'
+require_relative '../../lib/blazing/commands'
+require_relative '../../lib/blazing/config'
 
 module Blazing
-
   describe Commands do
-
     let(:config_instance) { Blazing::Config.new }
 
-    let(:target_a) { double('target_a', :name => 'target_a', :update => nil, :setup => nil) }
-    let(:target_b) { double('target_b', :name => 'target_b', :update => nil, :setup => nil) }
+    let(:target_a) { double('target_a', name: 'target_a', update: nil, setup: nil) }
+    let(:target_b) { double('target_b', name: 'target_b', update: nil, setup: nil) }
     let(:targets)  { [target_a, target_b] }
 
-    let(:recipe_a) { double('recipe_a', :name => 'recipe_a', :run => nil) }
-    let(:recipe_b) { double('recipe_b', :name => 'recipe_b', :run => nil) }
-    let(:recipes)  { [recipe_a, recipe_b] }
-
     let(:config) do
       config = config_instance
       config.targets = targets
-      config.recipes = recipes
 
       config
     end
@@ -27,118 +21,94 @@ module Blazing
     let(:commands_instance) { commands.new }
 
     before :each do
-      Config.stub(:parse).and_return(config)
+      allow(Config).to receive(:parse).and_return config
     end
 
     describe '.new' do
       it 'reads the config file when the command requires it' do
-        Config.should_receive(:parse).and_return(config)
-        commands.new(:command => :setup)
+        expect(Config).to receive(:parse).and_return config
+        commands.new(command: :setup)
       end
 
       it 'does not read the config file when the command does not need it' do
-        Config.should_not_receive(:parse)
-        commands.new(:command => :init)
+        expect(Config).not_to receive(:parse)
+        commands.new(command: :init)
       end
     end
 
     describe '#run' do
       it 'creates an instance of itself' do
-        commands_instance.stub!(:dummy_command)
-        commands.should_receive(:new).with({ :command => :dummy_command }).and_return(commands_instance)
+        allow(commands_instance).to receive :dummy_command
+        expect(commands).to receive(:new).with(command: :dummy_command).and_return(commands_instance)
         commands.run(:dummy_command)
       end
 
       it 'runs the specified command' do
-        commands_instance.should_receive(:dummy_command)
-        commands.stub(:new).with({ :command => :dummy_command }).and_return(commands_instance)
+        expect(commands_instance).to receive(:dummy_command)
+        allow(commands).to receive(:new).with(command: :dummy_command).and_return(commands_instance)
         commands.run(:dummy_command)
       end
-
-      it 'raises an exception if the command does not exist' do
-        pending 'Implement after reading exceptional Ruby ;-)'
-      end
     end
 
     describe '#init' do
       it 'creates a config directory if it does not exist' do
-        Dir.should_receive(:mkdir).with('config')
-        File.stub(:exists?).and_return(false)
-        File.stub(:open)
+        expect(Dir).to receive(:mkdir).with('config')
+        allow(File).to receive(:exist?).and_return(false)
+        allow(File).to receive(:open)
         commands.run(:init)
       end
 
       it 'creates a config file' do
         file = double('file').as_null_object
-        File.should_receive(:open).with("config/blazing.rb", "wb").and_yield(file)
+        expect(File).to receive(:open).with('config/blazing.rb', 'wb').and_yield(file)
         commands.run(:init)
       end
     end
 
     describe '#setup' do
       it 'runs the setup method on the specified target' do
-        target_a.should_receive(:setup)
-        target_b.should_not_receive(:setup)
-        commands.run(:setup, :target_name => target_a.name)
+        expect(target_a).to receive(:setup)
+        expect(target_b).not_to receive(:setup)
+        commands.run(:setup, target_name: target_a.name)
       end
 
       it 'does nothing when no target is specified' do
-        target_a.should_not_receive(:setup)
-        target_b.should_not_receive(:setup)
+        expect(target_a).not_to receive(:setup)
+        expect(target_b).not_to receive(:setup)
         commands.run(:setup)
       end
 
       it 'runs setup on all targets if "all" is specified' do
-        target_a.should_receive(:setup)
-        target_b.should_receive(:setup)
-        commands.run(:setup, :target_name => 'all')
+        expect(target_a).to receive(:setup)
+        expect(target_b).to receive(:setup)
+        commands.run(:setup, target_name: 'all')
       end
 
       it 'runs the update command' do
-        commands_instance.should_receive(:update)
-        commands.stub(:new).and_return(commands_instance)
+        expect(commands_instance).to receive(:update)
+        allow(commands).to receive(:new).and_return(commands_instance)
         commands.run(:setup)
       end
     end
 
     describe '#update' do
       it 'runs the update method on the specified target' do
-        target_a.should_receive(:update)
-        target_b.should_not_receive(:update)
-        commands.run(:update, :target_name => target_a.name)
+        expect(target_a).to receive(:update)
+        expect(target_b).not_to receive(:update)
+        commands.run(:update, target_name: target_a.name)
       end
 
       it 'does nothing when no target is specified' do
-        target_a.should_not_receive(:update)
-        target_b.should_not_receive(:update)
+        expect(target_a).not_to receive(:update)
+        expect(target_b).not_to receive(:update)
         commands.run(:update)
       end
 
       it 'runs update on all targets if "all" is specified' do
-        target_a.should_receive(:update)
-        target_b.should_receive(:update)
-        commands.run(:update, :target_name => 'all')
-      end
-    end
-
-    describe '#recipes' do
-      it 'runs each recipe' do
-        recipes.each { |r| r.should_receive(:run) }
-        commands.run(:recipes)
-      end
-
-      it 'passes in target_name' do
-        recipes.each { |r| r.should_receive(:run).with({:target_name => :testing}) }
-        commands.run(:recipes, :target_name => :testing)
-      end
-    end
-
-    describe '#list' do
-      it 'lists each recipe' do
-        Blazing::Recipe.should_receive(:pretty_list)
-        commands.run(:list)
+        expect(target_a).to receive(:update)
+        expect(target_b).to receive(:update)
+        commands.run(:update, target_name: 'all')
       end
     end
   end
 end
-