heroploy 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 356baf2c9b896ba5dddc86702c4b549e7af81824
-  data.tar.gz: 79fb1cea8d3206b14e22c37f087bf967702bcd99
+  metadata.gz: de74cf40268ad2d31c7e06ef60d7f8312ee936a6
+  data.tar.gz: e2257f2a4f5d83970c43942db5e4b16d95c963d7
 SHA512:
-  metadata.gz: c0963dd5196fffa11e2307f5481dbd02bd0d75b794bba7427a487fa2657a5154c524fa1d7639c080862d29da35bc199dca2c7007fdcde3df1cf26444c7458960
-  data.tar.gz: 14460f37d4ebe158c98d8a3c4dce756f83064a1b9d96cd8dc10658a1a0cf5d763ffe4fc846fdbc5771542066dfe9e88aa5ba8a6d76aa23c175b3271fe0a69c3e
+  metadata.gz: 87a969dad8ff6d44f9370fcb78fb15151ba6abcd2a6401938244c2fb323ec0f05fec7ab6717b5e2825d6b427ea48b23242918f38936955e8032f09e9cf4ef0e5
+  data.tar.gz: 1c9678265b500863c37074c97ed9b4fe897915554d236ed8f509387ad1c3e27e2ad67e624a1e5041287533a7dccecedb044f351e43397e0b18676e6b1eae0ea5

data/README.md

@@ -52,6 +52,7 @@ environments:
 ```
 
 This file:
+
 * Describes ```development```, ```staging``` and ```production``` deployment rules for three Heroku apps (named ```my-development-app```, ```my-staging-app``` and ```my-production-app``` on Heroku).
 * Allows any branch to be pushed directly to ```development```.
 * Only allows ```master``` to be pushed to ```staging```, and requires all changes to have first been pushed to ```origin```.

data/lib/generators/heroploy/install/install_generator.rb

@@ -1,9 +1,11 @@
 module Heroploy
-  class InstallGenerator < Rails::Generators::Base
-    source_root File.expand_path('../templates', __FILE__)
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
 
-    def copy_config
-      copy_file "config/heroploy.yml"
-    end  
+      def copy_config
+        copy_file "config/heroploy.yml"
+      end  
+    end
   end
 end

data/lib/heroploy/commands/checks.rb

@@ -1,30 +1,32 @@
-module Commands
-  module Checks
-    def check_remote(remote)
-      unless git_remote_exists?(remote)
-        raise "Could not find remote '#{remote}'"
+module Heroploy
+  module Commands
+    module Checks
+      def check_remote(remote)
+        unless git_remote_exists?(remote)
+          raise "Could not find remote '#{remote}'"
+        end
       end
-    end
     
-    def check_pushed(branch_name)
-      unless git_remote_has_branch?('origin', branch_name)
-        raise "Branch #{branch_name} doesn't exist in origin"
-      end
+      def check_pushed(branch_name)
+        unless git_remote_has_branch?('origin', branch_name)
+          raise "Branch #{branch_name} doesn't exist in origin"
+        end
 
-      if git_remote_behind?('origin', branch_name) then
-        raise "Branch #{branch_name} is behind origin/#{branch_name}"
+        if git_remote_behind?('origin', branch_name) then
+          raise "Branch #{branch_name} is behind origin/#{branch_name}"
+        end
       end
-    end
     
-    def check_branch(branch_name, valid_branch, env_name)
-      unless branch_name == valid_branch
-        raise "Cannot deploy branch #{branch_name} to #{env_name}"
+      def check_branch(branch_name, valid_branch, env_name)
+        unless branch_name == valid_branch
+          raise "Cannot deploy branch #{branch_name} to #{env_name}"
+        end
       end
-    end
     
-    def check_staged(remote, branch_name, env_name)
-      unless git_staged?(remote, branch_name)
-        raise "Changes not yet staged on #{env_name}"
+      def check_staged(remote, branch_name, env_name)
+        unless git_staged?(remote, branch_name)
+          raise "Changes not yet staged on #{env_name}"
+        end
       end
     end
   end

data/lib/heroploy/commands/git.rb

@@ -1,46 +1,48 @@
 require 'heroploy/commands/shell'
 
-module Commands
-  module Git
-    def git_fetch
-      Shell.exec "git fetch"
-    end
-  
-    def current_branch
-      branch = Shell.eval "git rev-parse --abbrev-ref HEAD"
-      branch.strip
-    end
-  
-    def git_push_to_master(remote, local_branch)
-      if ENV['force'] == 'true' then opts = "--force " end
-      Shell.exec "git push #{opts}#{remote} #{local_branch}:master"
-    end
-  
-    def git_remote_exists?(name)
-      remotes = Shell.eval("git remote").strip.split(/\s+/)
-      remotes.include?(name)
-    end
-  
-    def git_remote_has_branch?(remote, branch_name)
-      branches = Shell.eval("git branch -r").strip.split(/\s+/)
-      branches.include?("#{remote}/#{branch_name}")
-    end
-  
-    def git_remote_behind?(remote, remote_branch_name, local_branch_name = nil)
-      if local_branch_name.nil? then local_branch_name = remote_branch_name end
-      !Shell.eval("git log #{remote}/#{remote_branch_name}..#{local_branch_name}").empty?
-    end
-  
-    def git_staged?(remote, local_branch)
-      !git_remote_behind?(remote, 'master', local_branch)
-    end
-  
-    def git_tag(tag, message)
-      Shell.exec("git tag -a #{tag} -m \"#{message}\"")
-    end
-  
-    def git_push_tag(tag)
-      Shell.exec("git push origin #{tag}")
+module Heroploy
+  module Commands
+    module Git
+      def git_fetch
+        Shell.exec "git fetch"
+      end
+  
+      def current_branch
+        branch = Shell.eval "git rev-parse --abbrev-ref HEAD"
+        branch.strip
+      end
+  
+      def git_push_to_master(remote, local_branch)
+        if ENV['force'] == 'true' then opts = "--force " end
+        Shell.exec "git push #{opts}#{remote} #{local_branch}:master"
+      end
+  
+      def git_remote_exists?(name)
+        remotes = Shell.eval("git remote").strip.split(/\s+/)
+        remotes.include?(name)
+      end
+  
+      def git_remote_has_branch?(remote, branch_name)
+        branches = Shell.eval("git branch -r").strip.split(/\s+/)
+        branches.include?("#{remote}/#{branch_name}")
+      end
+  
+      def git_remote_behind?(remote, remote_branch_name, local_branch_name = nil)
+        if local_branch_name.nil? then local_branch_name = remote_branch_name end
+        !Shell.eval("git log #{remote}/#{remote_branch_name}..#{local_branch_name}").empty?
+      end
+  
+      def git_staged?(remote, local_branch)
+        !git_remote_behind?(remote, 'master', local_branch)
+      end
+  
+      def git_tag(tag, message)
+        Shell.exec("git tag -a #{tag} -m \"#{message}\"")
+      end
+  
+      def git_push_tag(tag)
+        Shell.exec("git push origin #{tag}")
+      end
     end
   end
 end

data/lib/heroploy/commands/heroku.rb

@@ -1,18 +1,20 @@
 require 'heroploy/commands/shell'
 
-module Commands
-  module Heroku
-    def heroku_exec(cmd, app_name)
-      Shell.exec "heroku #{cmd} --app #{app_name}"
-    end
+module Heroploy
+  module Commands
+    module Heroku
+      def heroku_exec(cmd, app_name)
+        Shell.exec "heroku #{cmd} --app #{app_name}"
+      end
   
-    def heroku_run(cmd, app_name)
-      heroku_exec("run #{cmd}", app_name)
-    end
+      def heroku_run(cmd, app_name)
+        heroku_exec("run #{cmd}", app_name)
+      end
   
-    def heroku_migrate(app_name)
-      Bundler.with_clean_env do
-        heroku_run("rake db:migrate", app_name)
+      def heroku_migrate(app_name)
+        Bundler.with_clean_env do
+          heroku_run("rake db:migrate", app_name)
+        end
       end
     end
   end

data/lib/heroploy/commands/shell.rb

@@ -1,11 +1,13 @@
-class Shell
-  extend FileUtils
-  
-  def self.eval(cmd)
-    `#{cmd}`
-  end
-  
-  def self.exec(cmd)
-    sh cmd
+module Heroploy
+  class Shell
+    extend FileUtils
+
+    def self.eval(cmd)
+      `#{cmd}`
+    end
+
+    def self.exec(cmd)
+      sh cmd
+    end
   end
 end

data/lib/heroploy/config/deployment_config.rb

@@ -0,0 +1,24 @@
+require 'heroploy/config/deployment_config'
+require 'heroploy/config/environment'
+
+module Heroploy
+  module Config
+    class DeploymentConfig
+      attr_accessor :environments
+
+      def [](env_name)
+        environments.select{ |env| env.name == env_name }.first
+      end
+
+      def initialize(attrs = {})
+        unless attrs['environments'].nil?
+          @environments = attrs['environments'].map { |name, attrs| Environment.new(name, attrs) }
+        end
+      end
+  
+      def self.load
+        DeploymentConfig.new(YAML::load(File.open('config/heroploy.yml')))
+      end
+    end
+  end
+end

data/lib/heroploy/config/environment.rb

@@ -0,0 +1,21 @@
+require 'heroploy/config/environment_checks'
+
+module Heroploy
+  module Config  
+    class Environment
+      attr_accessor :name
+      attr_accessor :remote
+      attr_accessor :app
+      attr_accessor :tag
+      attr_accessor :checks
+      
+      def initialize(name = nil, attrs = {})
+        @name = name
+        @remote = attrs['remote'] || name
+        @app = attrs['app']
+        @tag = attrs['tag']
+        @checks = EnvironmentChecks.new(attrs['checks'])
+      end
+    end
+  end
+end

data/lib/heroploy/config/environment_checks.rb

@@ -0,0 +1,16 @@
+module Heroploy
+  module Config
+    class EnvironmentChecks
+      attr_accessor :pushed
+      attr_accessor :branch
+      attr_accessor :staged
+      
+      def initialize(attrs = {})
+        attrs ||= {}
+        @pushed = attrs['pushed']
+        @branch = attrs['branch']
+        @staged = attrs['staged'] == true ? 'staging' : attrs['staged']
+      end  
+    end
+  end
+end

data/lib/heroploy/tasks/check_task_lib.rb

@@ -4,80 +4,80 @@ require 'heroploy/commands/heroku'
 require 'heroploy/commands/git'
 require 'heroploy/commands/checks'
 
-require 'heroploy/config/deploy_config'
-
 module Heroploy
-  class CheckTaskLib < ::Rake::TaskLib
-    include ::Rake::DSL if defined?(::Rake::DSL)
-    
-    include Commands::Git
-    include Commands::Heroku
-    include Commands::Checks
+  module Tasks
+    class CheckTaskLib < ::Rake::TaskLib
+      include ::Rake::DSL if defined?(::Rake::DSL)
     
-    attr_accessor :deploy_config
-    attr_accessor :env_config
-    attr_accessor :defined_tasks
+      include Commands::Git
+      include Commands::Heroku
+      include Commands::Checks
     
-    def initialize(deploy_config, env_config)
-      @deploy_config = deploy_config
-      @env_config = env_config
-      @defined_tasks = []
-      define      
-    end
+      attr_accessor :deploy_config
+      attr_accessor :env_config
+      attr_accessor :defined_tasks
     
-    def define
-      define_remote_check
-      define_pushed_check
-      define_branch_check
-      define_staged_check
-      define_all_check
-    end
+      def initialize(deploy_config, env_config)
+        @deploy_config = deploy_config
+        @env_config = env_config
+        @defined_tasks = []
+        define      
+      end
     
-    def define_remote_check
-      desc "check remote exists for #{env_config.name}"
-      task :remote do
-        remote = env_config.remote
-        check_remote(remote)
+      def define
+        define_remote_check
+        define_pushed_check
+        define_branch_check
+        define_staged_check
+        define_all_check
       end
+    
+      def define_remote_check
+        desc "check remote exists for #{env_config.name}"
+        task :remote do
+          remote = env_config.remote
+          check_remote(remote)
+        end
       
-      @defined_tasks << :remote
-    end
+        @defined_tasks << :remote
+      end
     
-    def define_pushed_check
-      if env_config.checks.pushed then
-        desc "check changes have been pushed to origin"
-        task :pushed do
-          check_pushed(current_branch)
+      def define_pushed_check
+        if env_config.checks.pushed then
+          desc "check changes have been pushed to origin"
+          task :pushed do
+            check_pushed(current_branch)
+          end
+          @defined_tasks << :pushed
         end
-        @defined_tasks << :pushed
       end
-    end
     
-    def define_branch_check
-      if env_config.checks.branch then
-        desc "check we can deploy to #{env_config.name} from the current branch"
-        task :branch do
-          valid_branch = env_config.checks.branch
-          check_branch(current_branch, valid_branch, env_config.name)
+      def define_branch_check
+        if env_config.checks.branch then
+          desc "check we can deploy to #{env_config.name} from the current branch"
+          task :branch do
+            valid_branch = env_config.checks.branch
+            check_branch(current_branch, valid_branch, env_config.name)
+          end
+          @defined_tasks << :branch
         end
-        @defined_tasks << :branch
       end
-    end
     
-    def define_staged_check
-      if env_config.checks.staged then
-        desc "check the changes have already been staged"
-        task :staged do
-          staging_env_config = deploy_config[env_config.checks.staged]
-          check_staged(staging_env_config.remote, current_branch, staging_env_config.name)
+      def define_staged_check
+        if env_config.checks.staged then
+          desc "check the changes have already been staged"
+          task :staged do
+            staging_env_config = deploy_config[env_config.checks.staged]
+            check_staged(staging_env_config.remote, current_branch, staging_env_config.name)
+          end
+          @defined_tasks << :staged
         end
-        @defined_tasks << :staged
       end
-    end
     
-    def define_all_check
-      desc "do all the checks for #{env_config.name}"
-      task :all => @defined_tasks
+      def define_all_check
+        desc "do all the checks for #{env_config.name}"
+        task :all => @defined_tasks
+      end
     end
   end
 end

data/lib/heroploy/tasks/deploy_task_lib.rb

@@ -1,38 +1,37 @@
 require 'rake/tasklib'
 
-require 'heroploy/commands/heroku'
 require 'heroploy/commands/git'
-require 'heroploy/commands/checks'
-
-require 'heroploy/config/deploy_config'
 require 'heroploy/tasks/env_task_lib'
 
 module Heroploy
-  class DeployTaskLib < ::Rake::TaskLib
-    include ::Rake::DSL if defined?(::Rake::DSL)
+  module Tasks
+    class DeployTaskLib < ::Rake::TaskLib
+      include ::Rake::DSL if defined?(::Rake::DSL)
+      include Commands::Git
     
-    attr_accessor :deploy_config
+      attr_accessor :deployment_config
     
-    def initialize(deploy_config)
-      @deploy_config = deploy_config
-      define
-    end
+      def initialize(deployment_config)
+        @deployment_config = deployment_config
+        define
+      end
 
-    def define
-      define_fetch_task
-      define_env_tasks
-    end
+      def define
+        define_fetch_task
+        define_env_tasks
+      end
     
-    def define_fetch_task
-      desc 'do a git fetch'
-      task :fetch do
-        git_fetch
+      def define_fetch_task
+        desc 'do a git fetch'
+        task :fetch do
+          git_fetch
+        end
       end
-    end
     
-    def define_env_tasks
-      deploy_config.environments.each do |env_config|
-        EnvTaskLib.new(deploy_config, env_config)
+      def define_env_tasks
+        deployment_config.environments.each do |env|
+          EnvTaskLib.new(deployment_config, env)
+        end
       end
     end
   end

data/lib/heroploy/tasks/env_task_lib.rb

@@ -4,64 +4,65 @@ require 'heroploy/commands/heroku'
 require 'heroploy/commands/git'
 require 'heroploy/commands/checks'
 
-require 'heroploy/config/deploy_config'
 require 'heroploy/tasks/check_task_lib'
 
 module Heroploy
-  class EnvTaskLib < ::Rake::TaskLib
-    include ::Rake::DSL if defined?(::Rake::DSL)
+  module Tasks
+    class EnvTaskLib < ::Rake::TaskLib
+      include ::Rake::DSL if defined?(::Rake::DSL)
     
-    include Commands::Git
-    include Commands::Heroku
-    include Commands::Checks
+      include Commands::Git
+      include Commands::Heroku
+      include Commands::Checks
     
-    attr_accessor :deploy_config
-    attr_accessor :env_config
+      attr_accessor :deployment_config
+      attr_accessor :env
     
-    def initialize(deploy_config, env_config)
-      @deploy_config = deploy_config
-      @env_config = env_config
-      define
-    end
+      def initialize(deployment_config, env)
+        @deployment_config = deployment_config
+        @env = env
+        define
+      end
 
-    def define
-      namespace env_config.name do
-        define_check_tasks
-        define_git_tasks
-        define_heroku_tasks
+      def define
+        namespace env.name do
+          define_check_tasks
+          define_git_tasks
+          define_heroku_tasks
+        end
       end
-    end
     
-    def define_check_tasks
-      namespace :check do
-        CheckTaskLib.new(deploy_config, env_config)
+      def define_check_tasks
+        namespace :check do
+          CheckTaskLib.new(deployment_config, env)
+        end
       end
-    end
     
-    def define_git_tasks
-      desc "push the current branch to master on #{env_config.name}"
-      task :push do
-        git_push_to_master(env_config.remote, current_branch)
-      end
+      def define_git_tasks
+        desc "push the current branch to master on #{env.name}"
+        task :push do
+          git_push_to_master(env.remote, current_branch)
+        end
 
-      desc "tag the deployment to #{env_config.name}"
-      task :tag do
-        if env_config.tag then
-          tag = DateTime.now.strftime(env_config.tag)
-          git_tag(tag, "Deployed #{current_branch} to #{env_config.name}")
-          git_push_tag(tag)
+        desc "tag the deployment to #{env.name}"
+        task :tag do
+          if env.tag then
+            tag = DateTime.now.strftime(env.tag)
+            git_tag(tag, "Deployed #{current_branch} to #{env.name}")
+            git_push_tag(tag)
+          end
         end
       end
-    end
     
-    def define_heroku_tasks
-      desc "run database migrations on #{env_config.name}"
-      task :migrate do
-        heroku_migrate(env_config.app)
-      end
+      def define_heroku_tasks
+        desc "run database migrations on #{env.name}"
+        task :migrate do
+          heroku_migrate(env.app)
+        end
 
-      desc "deploy to #{env_config.name}"
-      task :deploy => ['check:all', :push, :migrate, :tag]
+        desc "deploy to #{env.name}"
+        task :deploy => ['check:all', :push, :migrate, :tag]
+      end
     end
   end
 end

data/lib/heroploy/tasks/tasks.rake

@@ -1,9 +1,10 @@
+require 'heroploy/config/deployment_config'
 require 'heroploy/tasks/deploy_task_lib'
 
 namespace :heroploy do
   begin
-    deploy_config = DeployConfig.load  
-    Heroploy::DeployTaskLib.new(deploy_config)
+    deployment_config = Heroploy::Config::DeploymentConfig.load  
+    Heroploy::Tasks::DeployTaskLib.new(deployment_config)
   rescue Errno::ENOENT
     puts "Warning: no config file present for Heroploy.  Run 'rails generate heroploy:install' or add a heroploy.yml file to your project."
   end

data/lib/heroploy/version.rb

@@ -1,3 +1,3 @@
 module Heroploy
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/heroploy.rb

@@ -2,9 +2,3 @@ require "rails"
 
 require "heroploy/version"
 require "heroploy/engine" if defined?(Rails) && Rails::VERSION::MAJOR >= 3
-
-module Heroploy
-  def self.root
-    Pathname.new(File.expand_path '../..', __FILE__)
-  end
-end

data/spec/factories.rb

@@ -1,5 +1,5 @@
 FactoryGirl.define do
-  factory :checks_config do
+  factory :environment_checks, :class => Heroploy::Config::EnvironmentChecks do
     pushed false
     staged false
     branch nil
@@ -23,24 +23,24 @@ FactoryGirl.define do
     end
   end
   
-  factory :env_config do    
-    checks { build(:checks_config) }
+  factory :environment, :class => Heroploy::Config::Environment do    
+    checks { build(:environment_checks) }
     
     [:development, :staging, :production].each do |t|
       trait t do
         name t.to_s
         remote t.to_s
-        checks { build(:checks_config, t) }
+        checks { build(:environment_checks, t) }
       end
     end
   end
   
-  factory :deploy_config do
+  factory :deployment_config, :class => Heroploy::Config::DeploymentConfig do
     environments {
       [
-        build(:env_config, :development),
-        build(:env_config, :staging),
-        build(:env_config, :production)
+        build(:environment, :development),
+        build(:environment, :staging),
+        build(:environment, :production)
       ]
     }
   end

data/spec/lib/generators/heroploy/install_generator_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require File.expand_path('../../../../../lib/generators/heroploy/install/install_generator', __FILE__)
 
-describe Heroploy::InstallGenerator do
+describe Heroploy::Generators::InstallGenerator do
   include_context "generator"
 
   it "copies the heroploy.yml template" do

data/spec/lib/heroploy/commands/checks_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Commands::Checks do
+describe Heroploy::Commands::Checks do
   before(:each) do
     stub_shell
   end
   
-  let(:commands) { Object.new.extend(Commands::Checks) }
+  let(:commands) { Object.new.extend(Heroploy::Commands::Checks) }
 
   describe "#check_remote" do
     it "invokes git_remote_exists? to check the remote" do

data/spec/lib/heroploy/commands/git_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Commands::Git do
+describe Heroploy::Commands::Git do
   before(:each) do
     stub_shell
   end
   
-  let(:commands) { Object.new.extend(Commands::Git) }
+  let(:commands) { Object.new.extend(Heroploy::Commands::Git) }
   
   context "#git_fetch" do
     it "executes a git fetch" do
@@ -115,4 +115,11 @@ describe Commands::Git do
       commands.git_tag("my-tag", "my message")
     end
   end
+  
+  context "#git_push_tag" do
+    it "pushes the tag to origin" do
+      expect_command("git push origin my-tag")
+      commands.git_push_tag("my-tag")
+    end
+  end
 end

data/spec/lib/heroploy/commands/heroku_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Commands::Heroku do
+describe Heroploy::Commands::Heroku do
   before(:each) do
     stub_shell
   end
   
-  let(:commands) { Object.new.extend(Commands::Heroku) }
+  let(:commands) { Object.new.extend(Heroploy::Commands::Heroku) }
   
   context "#heroku_exec" do
     it "executes the heroku command for the given app" do

data/spec/lib/heroploy/commands/shell_spec.rb

@@ -1,16 +1,23 @@
 require 'spec_helper'
 
-describe Shell do
+describe Heroploy::Shell do
   context "#eval" do
     it "evaluates the given command using backticks" do
-      expect(Shell).to receive(:`).with('date')
-      Shell.eval('date')
+      expect(Heroploy::Shell).to receive(:`).with('date')
+      Heroploy::Shell.eval('date')
     end
 
     it "returns the standard output from the shell command" do
       expected_output = "Sun 19 Jan 2014 01:20:23 GMT\n"
-      expect(Shell).to receive(:`).and_return(expected_output)
-      expect(Shell.eval('date')).to eq(expected_output)
+      expect(Heroploy::Shell).to receive(:`).and_return(expected_output)
+      expect(Heroploy::Shell.eval('date')).to eq(expected_output)
+    end
+  end
+  
+  context "#exec" do
+    it "executes the given command on the shell" do
+      expect(Heroploy::Shell).to receive(:sh).with('puts "foo"')
+      Heroploy::Shell.exec('puts "foo"')
     end
   end
 end

data/spec/lib/heroploy/config/deployment_config_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Heroploy::Config::DeploymentConfig do
+  before(:each) { stub_shell }
+  
+  let(:attrs) { {'environments' => {'staging' => {}, 'production' => {}}} }
+  
+  subject(:deployment_config) { Heroploy::Config::DeploymentConfig.new(attrs) }
+  
+  context "#initialize" do
+    context "it initializes its environments" do
+      its(:environments) { should include an_environment_named(:staging) }
+      its(:environments) { should include an_environment_named(:production) }
+    end
+  end
+  
+  context "#[]" do
+    it "returns the environment with the given name, if one exists" do
+      expect(deployment_config['staging']).to be_an_environment_named(:staging)
+    end
+    
+    it "returns nil otherwise" do
+      expect(deployment_config['development']).to be_nil
+    end
+  end
+  
+  context ".load" do
+    let(:yaml_config) do
+      <<-END
+      environments:
+        heroku:
+          app: my-app
+      END
+    end
+    
+    it "returns a new instance of DeploymentConfig initialized by the heroploy config file" do
+      File.stub(:open).with('config/heroploy.yml').and_return(yaml_config)
+      deployment_config = Heroploy::Config::DeploymentConfig.load
+      expect(deployment_config.environments).to include an_environment_named(:heroku)
+    end
+  end
+end

data/spec/lib/heroploy/config/environment_checks_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Heroploy::Config::EnvironmentChecks do
+  attr_accessor :pushed
+  attr_accessor :branch
+  attr_accessor :staged
+  
+  describe "#initialize" do
+    context "it initializes the accessors" do
+      let(:pushed) { true }
+      let(:branch_name) { 'my-branch' }
+      let(:staging_env_name) { 'my-staging-environment' }
+      let(:attrs) { {'pushed' => pushed, 'branch' => branch_name, 'staged' => staging_env_name} }
+      
+      subject(:environment_checks) { Heroploy::Config::EnvironmentChecks.new(attrs) }
+
+      its(:pushed) { should eq(pushed) }
+      its(:branch) { should eq(branch_name) }
+      its(:staged) { should eq(staging_env_name) }
+    end
+    
+    context "if no staging environment name is given" do
+      subject(:environment_checks) { Heroploy::Config::EnvironmentChecks.new({'staged' => true}) }
+      
+      it "assumed the staging environment is called 'staging'" do
+        expect(environment_checks.staged).to eq('staging')
+      end
+    end
+  end
+end

data/spec/lib/heroploy/config/environment_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Heroploy::Config::Environment do
+  let(:env_name) { 'production' }
+
+  describe "#initialize" do
+    context "it initializes the accessors" do
+      let(:remote_name) { 'my-remote' }
+      let(:app_name) { 'my-app' }
+      let(:tag) { 'my-tag' }
+      let(:attrs) { {'remote' => remote_name, 'app' => app_name, 'tag' => tag} }
+      
+      subject(:environment) { Heroploy::Config::Environment.new(env_name, attrs) }
+
+      its(:name) { should eq(env_name) }
+      its(:remote) { should eq(remote_name) }
+      its(:app) { should eq(app_name) }
+      its(:tag) { should eq(tag) }
+      its(:checks) { should be_instance_of(Heroploy::Config::EnvironmentChecks) }      
+    end
+    
+    context "if no remote name is given" do
+      subject(:environment) { Heroploy::Config::Environment.new(env_name, {}) }
+      
+      it "uses the environment name for the remote" do
+        expect(environment.remote).to eq(env_name)
+      end
+    end
+  end
+end

data/spec/lib/heroploy/tasks/check_all_spec.rb

@@ -1,5 +1,5 @@
 describe "check:all" do
-  let(:environment) { build(:env_config, :production) }
+  let(:environment) { build(:environment, :production) }
 
   context "in all cases" do
     include_context "rake"

data/spec/lib/heroploy/tasks/check_branch_spec.rb

@@ -1,10 +1,10 @@
 describe "check:branch" do
-  let(:environment) { build(:env_config, :production) }
+  let(:environment) { build(:environment, :production) }
   include_context "rake"
   
   it "invokes :check_branch" do
-    Heroploy::CheckTaskLib.any_instance.stub(:current_branch).and_return("my-branch")
-    expect_any_instance_of(Heroploy::CheckTaskLib).to receive(:check_branch).with("my-branch", "master", "production")
+    Heroploy::Tasks::CheckTaskLib.any_instance.stub(:current_branch).and_return("my-branch")
+    expect_any_instance_of(Heroploy::Tasks::CheckTaskLib).to receive(:check_branch).with("my-branch", "master", "production")
     task.invoke
   end
 end

data/spec/lib/heroploy/tasks/check_pushed_spec.rb

@@ -1,10 +1,10 @@
 describe "check:pushed" do
-  let(:environment) { build(:env_config, :production) }
+  let(:environment) { build(:environment, :production) }
   include_context "rake"
   
   it "invokes :check_pushed" do
-    Heroploy::CheckTaskLib.any_instance.stub(:current_branch).and_return("my-branch")
-    expect_any_instance_of(Heroploy::CheckTaskLib).to receive(:check_pushed).with("my-branch")
+    Heroploy::Tasks::CheckTaskLib.any_instance.stub(:current_branch).and_return("my-branch")
+    expect_any_instance_of(Heroploy::Tasks::CheckTaskLib).to receive(:check_pushed).with("my-branch")
     task.invoke
   end
 end

data/spec/lib/heroploy/tasks/check_remote_spec.rb

@@ -1,9 +1,9 @@
 describe "check:remote" do
-  let(:environment) { build(:env_config, :production) }
+  let(:environment) { build(:environment, :production) }
   include_context "rake"
   
   it "invokes :check_remote" do
-    expect_any_instance_of(Heroploy::CheckTaskLib).to receive(:check_remote).with("production")
+    expect_any_instance_of(Heroploy::Tasks::CheckTaskLib).to receive(:check_remote).with("production")
     task.invoke
   end
 end

data/spec/lib/heroploy/tasks/check_staged_spec.rb

@@ -1,6 +1,6 @@
 describe "check:staged" do
-  let(:production) { build(:env_config, :production) }
-  let(:staging) { build(:env_config, :staging, remote: "my-staging-remote") }
+  let(:production) { build(:environment, :production) }
+  let(:staging) { build(:environment, :staging, remote: "my-staging-remote") }
   let(:environments) { [production, staging] }
   
   include_context "rake"
@@ -9,9 +9,9 @@ describe "check:staged" do
     before { production.checks.staged = 'staging' }
 
     it "invokes :check_pushed" do
-      Heroploy::CheckTaskLib.any_instance.stub(:current_branch).and_return("my-branch")
+      Heroploy::Tasks::CheckTaskLib.any_instance.stub(:current_branch).and_return("my-branch")
 
-      expect_any_instance_of(Heroploy::CheckTaskLib).to receive(:check_staged).with("my-staging-remote", "my-branch", "staging")
+      expect_any_instance_of(Heroploy::Tasks::CheckTaskLib).to receive(:check_staged).with("my-staging-remote", "my-branch", "staging")
 
       task.invoke
     end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require 'coveralls'
 Coveralls.wear! do
   add_filter '/spec/'
+  add_filter 'lib/heroploy/engine.rb'
 end
     
 require 'factory_girl'
@@ -11,11 +12,16 @@ require "generator_spec/matcher"
 
 require 'heroploy'
 require 'heroploy/tasks/deploy_task_lib'
+require 'heroploy/config/deployment_config'
+require 'heroploy/config/environment'
+require 'heroploy/config/environment_checks'
 
 require 'support/shell_support'
 require 'support/shared_contexts/rake'
 require 'support/shared_contexts/generator'
 
+require 'support/customer_matchers/environment_matcher'
+
 FactoryGirl.find_definitions
 
 TMP_ROOT = Pathname.new(File.expand_path('../tmp', __FILE__))
@@ -26,4 +32,7 @@ RSpec.configure do |config|
   config.include FactoryGirl::Syntax::Methods
   
   config.include ShellSupport
+  config.include CustomMatchers
 end
+
+

data/spec/support/customer_matchers/environment_matcher.rb

@@ -0,0 +1,36 @@
+module CustomMatchers
+  class EnvironmentMatcher
+    def initialize(expected_name)
+      @expected_name = expected_name
+    end
+  
+    def matches_type?
+      @actual.is_a?(Heroploy::Config::Environment)
+    end
+  
+    def matches_name?
+      @actual.name == @expected_name.to_s
+    end
+  
+    def matches?(actual)
+      @actual = actual
+      matches_type? && matches_name?
+    end
+  
+    def failure_message_for_should
+      if !matches_type?
+        "expected type to be Heroploy::Config::Environment"
+      elsif !matches_name?
+        "expected '#{@actual.name}' to be '#{@expected_name.to_s}'"
+      end
+    end
+  end
+
+  def an_environment_named(expected_name)  
+    EnvironmentMatcher.new(expected_name)  
+  end
+
+  def be_an_environment_named(expected_name)
+    EnvironmentMatcher.new(expected_name)
+  end
+end

data/spec/support/shared_contexts/rake.rb

@@ -11,7 +11,7 @@ shared_context "rake" do
     elsif defined?(environments)
       env_name = environments[0].name
     else
-      env_name = deploy_config.environments[0].name
+      env_name = deployment_config.environments[0].name
     end
 
     "#{env_name}:#{self.class.top_level_description}"
@@ -26,15 +26,15 @@ shared_context "rake" do
     
     unless defined?(deploy_config)
       if defined?(environment)
-        deploy_config = build(:deploy_config, environments: [environment])
+        deployment_config = build(:deployment_config, environments: [environment])
       elsif defined?(environments)
-        deploy_config = build(:deploy_config, environments: environments)
+        deployment_config = build(:deployment_config, environments: environments)
       else
-        deploy_config = build(:deploy_config)
+        deployment_config = build(:deployment_config)
       end
     end
 
-    Heroploy::DeployTaskLib.new(deploy_config) 
+    Heroploy::Tasks::DeployTaskLib.new(deployment_config) 
 
     Rake::Task.tasks.each do |task|
       if task.name != task_name

data/spec/support/shell_support.rb

@@ -1,22 +1,22 @@
 module ShellSupport
   def stub_shell
-    Shell.stub(:eval).and_return("")
-    Shell.stub(:exec)
+    Heroploy::Shell.stub(:eval).and_return("")
+    Heroploy::Shell.stub(:exec)
   end
   
   def expect_command(cmd = nil)
     if cmd.nil?
-      expect(Shell).to receive(:exec)
+      expect(Heroploy::Shell).to receive(:exec)
     else
-      expect(Shell).to receive(:exec).with(cmd)
+      expect(Heroploy::Shell).to receive(:exec).with(cmd)
     end
   end
   
   def expect_eval(cmd = nil)
     if cmd.nil?
-      expect(Shell).to receive(:eval)
+      expect(Heroploy::Shell).to receive(:eval)
     else
-      expect(Shell).to receive(:eval).with(cmd)
+      expect(Heroploy::Shell).to receive(:eval).with(cmd)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: heroploy
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - John Brunton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-01 00:00:00.000000000 Z
+date: 2014-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -132,9 +132,9 @@ files:
 - lib/heroploy/commands/git.rb
 - lib/heroploy/commands/heroku.rb
 - lib/heroploy/commands/shell.rb
-- lib/heroploy/config/checks_config.rb
-- lib/heroploy/config/deploy_config.rb
-- lib/heroploy/config/env_config.rb
+- lib/heroploy/config/deployment_config.rb
+- lib/heroploy/config/environment.rb
+- lib/heroploy/config/environment_checks.rb
 - lib/heroploy/engine.rb
 - lib/heroploy/tasks/check_task_lib.rb
 - lib/heroploy/tasks/deploy_task_lib.rb
@@ -147,12 +147,16 @@ files:
 - spec/lib/heroploy/commands/git_spec.rb
 - spec/lib/heroploy/commands/heroku_spec.rb
 - spec/lib/heroploy/commands/shell_spec.rb
+- spec/lib/heroploy/config/deployment_config_spec.rb
+- spec/lib/heroploy/config/environment_checks_spec.rb
+- spec/lib/heroploy/config/environment_spec.rb
 - spec/lib/heroploy/tasks/check_all_spec.rb
 - spec/lib/heroploy/tasks/check_branch_spec.rb
 - spec/lib/heroploy/tasks/check_pushed_spec.rb
 - spec/lib/heroploy/tasks/check_remote_spec.rb
 - spec/lib/heroploy/tasks/check_staged_spec.rb
 - spec/spec_helper.rb
+- spec/support/customer_matchers/environment_matcher.rb
 - spec/support/helpers/deploy_config_helper.rb
 - spec/support/shared_contexts/generator.rb
 - spec/support/shared_contexts/rake.rb
@@ -188,13 +192,18 @@ test_files:
 - spec/lib/heroploy/commands/git_spec.rb
 - spec/lib/heroploy/commands/heroku_spec.rb
 - spec/lib/heroploy/commands/shell_spec.rb
+- spec/lib/heroploy/config/deployment_config_spec.rb
+- spec/lib/heroploy/config/environment_checks_spec.rb
+- spec/lib/heroploy/config/environment_spec.rb
 - spec/lib/heroploy/tasks/check_all_spec.rb
 - spec/lib/heroploy/tasks/check_branch_spec.rb
 - spec/lib/heroploy/tasks/check_pushed_spec.rb
 - spec/lib/heroploy/tasks/check_remote_spec.rb
 - spec/lib/heroploy/tasks/check_staged_spec.rb
 - spec/spec_helper.rb
+- spec/support/customer_matchers/environment_matcher.rb
 - spec/support/helpers/deploy_config_helper.rb
 - spec/support/shared_contexts/generator.rb
 - spec/support/shared_contexts/rake.rb
 - spec/support/shell_support.rb
+has_rdoc: 

data/lib/heroploy/config/checks_config.rb

@@ -1,16 +0,0 @@
-class ChecksConfig
-  attr_accessor :pushed
-  attr_accessor :branch
-  attr_accessor :staged
-  
-  def self.parse(attrs)
-    config = ChecksConfig.new
-    
-    attrs ||= {}
-    config.pushed = attrs['pushed']
-    config.branch = attrs['branch']
-    config.staged = attrs['staged'] == true ? 'staging' : attrs['staged']
-    
-    config
-  end
-end

data/lib/heroploy/config/deploy_config.rb

@@ -1,24 +0,0 @@
-require 'heroploy/config/env_config'
-
-class DeployConfig
-  attr_accessor :environments
-  
-  def [](env_name)
-    environments.select{ |env_config| env_config.name == env_name}.first
-  end
-  
-  def self.parse(attrs)
-    config = DeployConfig.new
-    
-    config.environments = [] 
-    attrs['environments'].each do |name, attrs|
-      config.environments << EnvConfig.parse(name, attrs)
-    end
-    
-    config
-  end
-  
-  def self.load
-    DeployConfig.parse(YAML::load(File.open('config/heroploy.yml')))
-  end
-end

data/lib/heroploy/config/env_config.rb

@@ -1,21 +0,0 @@
-require 'heroploy/config/checks_config'
-
-class EnvConfig
-  attr_accessor :name
-  attr_accessor :remote
-  attr_accessor :app
-  attr_accessor :tag
-  attr_accessor :checks
-  
-  def self.parse(name, attrs)
-    config = EnvConfig.new
-    
-    config.name = name
-    config.remote = attrs['remote'] || name
-    config.app = attrs['app']
-    config.tag = attrs['tag']
-    config.checks = ChecksConfig.parse(attrs['checks'])
-
-    config
-  end
-end