jumpup 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0ed0c9528c69588fdb4ceeb4c0903e2a1d3031a3
-  data.tar.gz: f97154f489694aacfa37c24c85b4b8be5c493523
+  metadata.gz: ff68a671a142a27009322cfb38911217cf84f588
+  data.tar.gz: 691e3f44c7dcfbf8f6c30145b7605bb54a973722
 SHA512:
-  metadata.gz: 1fd5bc4b91d8d3f279d4f0618009b3475d60a8e5dcf7c3056f9db4965b43ceda7e3b8579ef5221032c17e91f4afe3634f288f49af3ad5d22c39c0023a140e8f4
-  data.tar.gz: f769f6316fc344fddc4e025016fc4e9fd24d38248688e5ce6057d87a267b78379c1184a4ca31c8f9311ead56d559d3e379349a12577e967bf61a244ea8eca80d
+  metadata.gz: 47dd5dd1d4dfd1f973e10143b65a5c5b0aed496a4b5166c205a09d6ef3340e6f5bd6d30ebbf10f97499b8eea2e7d22801905f7016524afc7e919b7020678b7d9
+  data.tar.gz: 33ba51c18acbe2b644e35c704333f17fb1610ea8c705e48e7376b3a1286a8fc9e8168e7a3b61aa965823f425397f8a3d0233d2e5042215f4e268e3e726d8e2b9

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Style/Documentation:
+  Enabled: false

data/.ruby-gemset

@@ -0,0 +1 @@
+jumpup

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 2.1.2
+before_script:
+  - git config --global user.email "johndoe@example.com"
+  - git config --global user.name "John Doe"

data/CHANGELOG.md

@@ -1,12 +1,17 @@
 # Changelog
 
-## 0.0.7 (unreleased)
+## 0.0.7 (September 15, 2014)
 
 ### features
+- Implements tasks jumpup:integration:check, jumpup:integration:lock, jumpup:integration:unlock to block a user from integrating while another one is already integrating at same time. It is useful when the project have a lot of tests because it avoids the second user to receive the reject message from git, and have to run all tests again.
+- Add quiet git messages on rake integrate.
 
 ### improvements
+- Add tests with rspec and aruba
 
 ### bug fixes
+- Delete integrating local tag before fetching remote tags
+- Fix "uninitialized constant Jumpup::GitCommand::Rake"
 
 ## 0.0.6 (July 11, 2014)
 

data/README.mkdn

@@ -1,109 +1,132 @@
 # Jumpup
+[![Build Status][travis_badge]][travis]
 [![RubyGems][gem_version_badge]][ruby_gems]
 
-## What
+Jumpup is a gem that provides a set of tasks to automate all steps of a [synchronous continuous integration][sci] process for [Ruby on Rails][ror] apps, that is, [continuous integration][ci] without a server such as [Travis][travis].
 
-Jumpup is a [Ruby on Rails][ror] gem that provides a set of tasks to automate all steps of a [synchronous continuous integration][sci] process, that is, [continuous integration][ci] without a server such as [Travis][travis]. Why? Because that's the way we like it!
+## Why?
 
-## Installing
+Because that's the way [we][helabs] like it!
 
-Add it to your Gemfile:
+## Installation
 
-    group :development do
-      gem 'jumpup'
-    end
+Add the gem to the `development` section of your `Gemfile` and run `bundle install`:
 
-After installing the gem is ready to be used and you will need to execute only one task in order to integrate your code safely:
+```ruby
+group :development do
+  gem 'jumpup'
+end
+```
 
-    rake integrate
+## Usage
 
-## Dependencies
-
-* Git
-* [Rcov][rc](Ruby 1.8) or [Simplecov][sc](Ruby 1.9) (optional)
-
-## [ProTip] Using Simplecov
-
-Using simplecov on your test suite will make your tests to run slower. You can fix it using an environment variable called "coverage" on test_helper.rb/spec_helper.rb to turn on/off the simplecov. See below:
-
-spec_helper.rb or test_helper.rb
-
-    if ENV['coverage'] == 'on'
-      require 'simplecov'
-      SimpleCov.start 'rails'
-    end
-
-The "coverage" variable is set to "on" by the integration process. When running tests/specs while you're developing, simplecov doesn't run, unless you set "coverage" environment variable by hand.
+After installing the gem, you'll need to configure the set of tasks you'll want to run as part of your integration process before using it. The configuration is done by setting an array of Rake task names as the `INTEGRATION_TASKS` constant on your `lib/tasks/jumpup.rake`. For example:
 
-## Integration Steps
-
-The integration process is composed of several steps that are explained ahead. It's possible to skip one or more steps and add other steps of your own. This will be demonstrated shortly. The complete set of steps are:
-
-1. task git:status_check
+```ruby
+INTEGRATION_TASKS = %w(
+  jumpup:start
+  jumpup:bundle_install
+  db:migrate
+  spec
+  jumpup:finish
+)
+```
 
-  Check if all local files are under control of your scm.
+With that in place, you can execute a single task in order to integrate your code safely:
 
-* task log:clear
+```
+rake integrate
+```
 
-  Remove log files.
+For more information, please have a look at the "[Integration Steps](#integration-steps)" section below.
 
-* task tmp:clear
+## Plugins
 
-  Remove temporary files.
+* [jumpup-heroku][jumpup-heroku]
+* [jumpup-hipchat][jumpup-hipchat]
 
-* task git:pull
+## Dependencies
 
-  Update local files from your remote scm repository.
+* Git
+* [Rcov][rc] (Ruby 1.8) or [Simplecov][sc] (Ruby 1.9+) (optional)
 
-* task db:migrate
+## [ProTip] Using Simplecov
 
-  Execute any new database migration created by other team members since the last integration.
+Using Simplecov on your test suite will make your tests run slower. You can fix it using an environment variable called `coverage` on your test / spec helper files to enable Simplecov when needed like:
 
-* Your test/spec suite
+```ruby
+# On your spec_helper.rb / test_helper.rb
+if ENV['coverage'] == 'on'
+  require 'simplecov'
+  SimpleCov.start 'rails'
+end
+```
 
-  Set the rake task your test/spec suite needs to run. Use a command that generate the coverage files.
+The `coverage` variable is set to "on" automatically by the integration process. When running tests while you're developing, Simplecov will not run unless you set the `coverage` environment variable yourself.
 
-* git:push
+## Integration Steps
 
-  Push your changes. If any of the previous tasks break, because one test failed, for instance, the script won't push. Actually this task runs only if every checking done before work well.
+The integration process is composed of several Rake tasks that are explained below. It's possible to skip one or more steps and add other steps of your own. The complete set of tasks we normally use are:
+
+| Rake Task | Description |
+| --------- | ----------- |
+| `jumpup:integration:check`   | Check if other user is already integrating, to avoid reject message from git after runing all tests. |
+| `jumpup:integration:lock`    | Lock the integration to current user. |
+| `git:status_check`           | Check if all local files have been commited to the local git repository. |
+| `log:clear`                  | Remove log files. |
+| `tmp:clear`                  | Remove temporary files. |
+| `git:pull`                   | Update local files from the remote git repository. |
+| `jumpup:start`               | Run all the previous tasks on this order |
+| `jumpup:bundle_install`      | Run `bundle install` on quiet mode |
+| `db:migrate`                 | Execute any new database migration created by other team members since the last integration. |
+| `test` or `spec`             | Set the rake task your test/spec suite needs to run. Use a command that generate the coverage files. |
+| `git:push`                   | Push your changes. If any of the previous tasks break, because one test failed, for instance, the script won't push. Actually this task runs only if every checking done before work well. |
+| `jumpup:integration:unlock`  | Unlock the integration to current user. |
+| `jumpup:finish`              | Run tasks: `git:push` and `jumpup:integration:unlock` |
 
 Using this almost paranoid sequence of steps it will be hard to check in bad code in your repository, which is good, very good. The idea is that you should treat your repository as a sacred place, where only good code should ever enter.
 
 ### More examples
 
-* Reckless programmer
+#### Reckless programmer
 
-  So you don't have tests, nor specs but you still want to use the jumpup. You might get away with this customized lib/tasks/integration.rake:
+Let's say your project don't have tests but you still want to use jumpup. You might get away with this `lib/tasks/jumpup.rake`:
 
-        INTEGRATION_TASKS = %w(
-          jumpup:start
-          db:migrate
-          jumpup:finish
-        )
+```ruby
+INTEGRATION_TASKS = %w(
+  jumpup:start
+  jumpup:bundle_install
+  db:migrate
+  jumpup:finish
+)
+```
 
-  The fact that you can get away with this doesn't mean you should. Don't you think it's already time to grow up and become more professional about software development? I know you believe you have a great excuse to avoid writing those tests or specs. Still it's just an excuse. Write tests or write specs and make a better world!
+The fact that you can get away with this doesn't mean you should. Don't you think it's already time to grow up and become more professional about software development? I know you believe you have a great excuse to avoid writing those tests. Still it's just an excuse. Write tests and make a better world!
 
-* Test conscious programmer
+#### Test conscious programmer
 
-   You haven't jumped on the [BDD][BDD] bandwagon yet. Instead, you write tests, which is good, but they don't cover all of your code yet, which is bad. We believe you will improve it and make sure your tests cover 100% of your code. In the meantime you might need to skip coverage checkings. Oh, you also don't use [Selenium][sor]. Shame on you! Try this:
+You haven't jumped on the [BDD][BDD] bandwagon yet. Instead, you write tests, which is good, but they don't cover all of your code yet, which is bad. We believe you will improve it and make sure your tests cover 100% of your code. In the meantime you might need to skip coverage checkings. Try this:
 
-        INTEGRATION_TASKS = %w(
-          jumpup:start
-          db:migrate
-          test
-          jumpup:finish
-        )
+```ruby
+INTEGRATION_TASKS = %w(
+  jumpup:start
+  jumpup:bundle_install
+  db:migrate
+  spec
+  jumpup:finish
+)
+```
 
-* Spec infected programmer
+#### Spec infected programmer
 
-  So you used to [TDD][TDD] all around but then someone told you that this is for gramma. The new wave has a name on it: [BDD][BDD]. So, of course, you now have specs covering 100% of your code and doesn't have any more tests. Great! Just change your test_helper.rb/spec_helper.rb with:
+So you used to [TDD][TDD] all around but then someone told you that this is for gramma. The new wave has a name on it: [BDD][BDD]. So, of course, you now have specs covering 100% of your code and doesn't have any more tests. Great! Just change your test_helper.rb/spec_helper.rb with:
 
-  ```ruby
-  require 'simplecov'
-  SimpleCov.start 'rails' do
-    minimum_coverage 100
-  end
-  ```
+```ruby
+require 'simplecov'
+SimpleCov.start 'rails' do
+  minimum_coverage 100
+end
+```
 
 ## Versioning
 
@@ -158,25 +181,22 @@ This gem was created and is maintained by [HE:labs](https://github.com/Helabs).
 
 [gem_version_badge]: https://badge.fury.io/rb/jumpup.png
 [ruby_gems]: http://rubygems.org/gems/jumpup
-[piston]:  http://piston.rubyforge.org/
 [mt]:    https://github.com/tapajos
 [sm]:   https://github.com/mergulhao
 [vt]:    http://www.improveit.com.br/vinicius
-[f]:    http://rubyforge.org/forum/?group_id=4662
-[s]:    http://subversion.tigris.org
-[git]:  http://git.or.cz/
 [rc]:    http://eigenclass.org/hiki.rb?rcov
 [sc]:    https://github.com/colszowka/simplecov
-[sor]:  http://selenium-on-rails.openqa.org
 [rs]:    http://rspec.info
-[rz]:    http://rubyzip.sourceforge.net/
 [ror]:  http://www.rubyonrails.org
 [sci]:  http://jamesshore.com/Blog/Why%20I%20Dont%20Like%20CruiseControl.html
-[co]:    http://www.improveit.com.br/en/contact
 [mit]:  http://www.opensource.org/licenses/mit-license.php
 [ci]:   http://martinfowler.com/articles/continuousIntegration.html
 [travis]: http://travis-ci.org
-[tar]:  http://en.wikipedia.org/wiki/Tar_%28file_format%29
 [BDD]:  http://en.wikipedia.org/wiki/Behavior_driven_development
 [TDD]:  http://en.wikipedia.org/wiki/Test-driven_development
 [ii]:   http://www.improveit.com.br
+[helabs]: http://helabs.com.br/en/
+[jumpup-heroku]: https://github.com/Helabs/jumpup-heroku
+[jumpup-hipchat]: https://github.com/Helabs/jumpup-hipchat
+[travis]: https://travis-ci.org/Helabs/jumpup
+[travis_badge]: https://travis-ci.org/Helabs/jumpup.svg?branch=master

data/Rakefile

@@ -1 +1,10 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+Cucumber::Rake::Task.new
+task default: [:spec, :cucumber]

data/features/bundler.feature

@@ -0,0 +1,14 @@
+Feature: Coverage
+  Scenario: run jumpup:bundle_install
+    Given an empty file named "Gemfile"
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:bundle_install
+      )
+      """
+    When I run `rake integrate`
+    Then the following files should exist:
+      | Gemfile.lock |

data/features/git.feature

@@ -0,0 +1,67 @@
+Feature: Git
+  Scenario: running jumpup:git:status_check task with dirty files
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:git:status_check
+      )
+      """
+    When I setup a git repo
+    And I run `rake integrate`
+    Then the stdout should contain:
+      """
+      On branch master
+      """
+  Scenario: running jumpup:git:status_check task without dirty files
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:git:status_check
+      )
+      """
+    When I setup a git repo
+    And I run `git add .`
+    And I run `git commit -m "Initial commit" -q`
+    And I run `rake integrate`
+    Then the stdout should not contain:
+      """
+      On branch master
+      """
+
+  Scenario: jumpup:git:pull task
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:git:pull
+      )
+      """
+    # TODO Use "When I setup a git repo" instead
+    When I run `git init -q`
+    And I run `rake integrate`
+    Then the stderr should contain:
+      """
+      No remote repository specified
+      """
+
+  Scenario: jumpup:git:push task
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:git:push
+      )
+      """
+    # TODO Use "When I setup a git repo" instead
+    When I run `git init -q`
+    And I run `rake integrate`
+    Then the stderr should contain:
+      """
+      No configured push destination
+      """

data/features/integration.feature

@@ -0,0 +1,60 @@
+Feature: Integration
+  Scenario: running jumpup:integration:check task with no one integrating
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:integration:check
+      )
+      """
+    When I setup a git repo
+    And I run `rake integrate`
+    Then the stdout should contain "--> Checking if there's someone integrating..."
+    Then the stdout should contain "--> No, go ahead!"
+  Scenario: running jumpup:integration:check task when the same user is integrating
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:integration:check
+      )
+      """
+    When I setup a git repo
+    And I run `git commit --allow-empty -am 'first commit'`
+    And I run `git tag -a integrating -m ''`
+    And I run `git push -f origin integrating`
+    And I run `rake integrate`
+    Then the stdout should contain "--> Checking if there's someone integrating..."
+    Then the stdout should contain "--> Project is locked to you"
+  Scenario: running jumpup:integration:lock task
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:integration:lock
+      )
+      """
+    When I setup a git repo
+    And I run `git commit --allow-empty -am 'first commit'`
+    And I run `rake integrate`
+    Then the stdout should contain "--> Locking integration..."
+    Then the stdout should contain "--> OK!"
+  Scenario: running jumpup:integration:unlock task
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:integration:unlock
+      )
+      """
+    When I setup a git repo
+    And I run `git commit --allow-empty -am 'first commit'`
+    And I run `git tag -a -f integrating -m "Integration started"`
+    And I run `rake integrate`
+    Then the stdout should contain "--> Unlocking integration..."
+    Then the stdout should contain "Deleted tag 'integrating'"
+    Then the stdout should contain "--> OK!"

data/features/lifecycle.feature

@@ -0,0 +1,74 @@
+Feature: Lifecycle tasks
+  Scenario: running jumpup:start task without dirty files
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      # dummy rails rake tasks
+      namespace :log do
+        task :clear do
+          puts "Clearing log files"
+        end
+      end
+
+      namespace :tmp do
+        task :clear do
+          puts "Clearing tmp files"
+        end
+      end
+
+      INTEGRATION_TASKS = %w(
+        jumpup:start
+      )
+      """
+    # TODO Use "When I setup a git repo" instead
+    When I run `git init -q`
+    And I run `git add .`
+    And I run `git commit -m "Initial commit" -q`
+    And I run `rake integrate`
+    Then the stdout should contain "Clearing log files"
+    Then the stdout should contain "Clearing tmp files"
+    Then the stderr should contain "No remote repository specified"
+
+  Scenario: running jumpup:start task with dirty files should abort after jumpup:git:status_check task
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      # dummy rails rake tasks
+      namespace :log do
+        task :clear do
+          puts "Clearing log files"
+        end
+      end
+
+      namespace :tmp do
+        task :clear do
+          puts "Clearing tmp files"
+        end
+      end
+
+      INTEGRATION_TASKS = %w(
+        jumpup:start
+      )
+      """
+    When I setup a git repo
+    And I run `rake integrate`
+    Then the stdout should contain "On branch master"
+    Then the stdout should not contain "Clearing log files"
+    Then the stdout should not contain "Clearing tmp files"
+    Then the stdout should not contain "No remote repository specified"
+
+  Scenario: running jumpup:finish task does a git push
+    Given a file named "Rakefile" with:
+      """
+      require "jumpup"
+
+      INTEGRATION_TASKS = %w(
+        jumpup:finish
+      )
+      """
+    # TODO Use "When I setup a git repo" instead
+    When I run `git init -q`
+    And I run `rake integrate`
+    Then the stderr should contain "No configured push destination"

data/features/step_definitions/setup_git_repo.rb

@@ -0,0 +1,8 @@
+Given(/^I setup a git repo$/) do
+  steps %(
+    When I run `git init -q`
+    And a directory named "/tmp/jumpup-git-repo"
+    And I run `git init --bare -q /tmp/jumpup-git-repo`
+    And I run `git remote add origin /tmp/jumpup-git-repo`
+  )
+end

data/features/support/env.rb

@@ -0,0 +1,11 @@
+require 'aruba/cucumber'
+require 'pry'
+
+Before do
+  @aruba_timeout_seconds = 60 * 5
+end
+
+After do
+  system 'rm -rf tmp/aruba'
+  system 'rm -rf /tmp/jumpup-git-repo'
+end

data/jumpup.gemspec

@@ -4,20 +4,24 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'jumpup/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "jumpup"
+  spec.name          = 'jumpup'
   spec.version       = Jumpup::VERSION
-  spec.authors       = ["HE:labs"]
-  spec.email         = ["contato@helabs.com.br"]
-  spec.description   = %q{A synchronous continuous integration gem.}
-  spec.summary       = %q{Jumpup gem help people that want to do synchronous continuous integration on their ruby projects.}
-  spec.homepage      = "https://github.com/Helabs/jumpup"
-  spec.license       = "MIT"
+  spec.authors       = ['HE:labs']
+  spec.email         = ['contato@helabs.com.br']
+  spec.description   = 'A synchronous continuous integration gem.'
+  spec.summary       = 'Jumpup gem help people that want to do synchronous continuous integration on their ruby projects.'
+  spec.homepage      = 'https://github.com/Helabs/jumpup'
+  spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake",    "~> 0"
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rspec',   '~> 3.0'
+  spec.add_development_dependency 'aruba'
+  spec.add_development_dependency 'pry'
+  spec.add_dependency 'rake'
+  spec.add_dependency 'colorize'
 end

data/lib/jumpup.rb

@@ -1 +1,49 @@
-Dir["#{Gem::Specification.find_by_name('jumpup').full_gem_path}/lib/tasks/*.rake"].each { |ext| load ext } if defined?(Rake)
+
+module Jumpup
+  class << self
+    MISSING_INTEGRATION_TASKS_CONSTANT_MESSAGE = %{
+    You should define INTEGRATION_TASKS constant. We recommend that you define it on lib/tasks/jumpup.rake file. The file doesn't exists. You should create it in your project.
+
+    You'll probably want to add coverage/ to your .gitignore file.
+
+    A sample content look like this:
+
+    INTEGRATION_TASKS = %w(
+      jumpup:start
+      jumpup:bundle_install
+      db:migrate
+      spec
+      jumpup:finish
+    )
+
+    }
+
+    def perform_integration
+      unless defined?(INTEGRATION_TASKS)
+        Jumpup::UI.header MISSING_INTEGRATION_TASKS_CONSTANT_MESSAGE
+        exit
+      end
+
+      invoke_tasks
+    end
+
+    def load_tasks
+      Dir["#{Gem::Specification.find_by_name('jumpup').full_gem_path}/lib/tasks/*.rake"].each { |ext| load ext } if defined?(Rake)
+    end
+
+    private
+
+    def invoke_tasks
+      INTEGRATION_TASKS.each do |subtask|
+        Jumpup::UI.header("--> Executing #{subtask}...".white) do
+          Rake::Task[subtask].invoke
+        end
+      end
+    end
+  end
+end
+
+Jumpup.load_tasks
+
+require 'jumpup/ui'
+require 'jumpup/commands'

data/lib/jumpup/commands.rb

@@ -0,0 +1,2 @@
+require 'jumpup/commands/git_command'
+require 'jumpup/commands/bundler_command'

data/lib/jumpup/commands/bundler_command.rb

@@ -0,0 +1,15 @@
+require 'rake'
+
+module Jumpup
+  module BundlerCommand
+    extend ::Rake::DSL
+
+    class << self
+      def install_with_clean_env
+        Bundler.with_clean_env do
+          sh 'bundle install --quiet'
+        end
+      end
+    end
+  end
+end

data/lib/jumpup/commands/git_command.rb

@@ -0,0 +1,64 @@
+require 'rake'
+
+module Jumpup
+  module GitCommand
+    extend ::Rake::DSL
+
+    class << self
+      def status_check
+        result = `git status`
+        return unless result.include?('Untracked files:') || result.include?('unmerged:') || result.include?('modified:')
+        Jumpup::UI.say result
+        exit
+      end
+
+      def pull
+        sh 'git pull --rebase --quiet'
+      end
+
+      def push
+        sh 'git push --quiet'
+      end
+
+      def check_integration
+        Jumpup::UI.say "  --> Checking if there's someone integrating...".yellow
+        Jumpup::UI.say `git tag -d integrating`
+        Jumpup::UI.say `git fetch --tags --quiet`
+
+        tags = `git tag`.strip.split("\n")
+        if tags.include?('integrating')
+          tag_info = `git show integrating`
+          integrating_by = /Tagger: (.*) <.*>/.match(tag_info)[1]
+          if integrating_by == user
+            Jumpup::UI.say "  --> Project is locked to you ('#{integrating_by}'), go ahead!".green
+          else
+            Jumpup::UI.say "  --> Project is already being integrated by '#{integrating_by}', halting!".red
+            exit
+          end
+        else
+          Jumpup::UI.say '  --> No, go ahead!'.green
+        end
+      end
+
+      def lock_integration
+        Jumpup::UI.say '  --> Locking integration...'.yellow
+        Jumpup::UI.say `git tag -a -f integrating -m "Integration started at #{Time.now.strftime('%d/%m/%Y %T %Z')}"`
+        Jumpup::UI.say `git push -f origin integrating --quiet`
+        Jumpup::UI.say '  --> OK!'.green
+      end
+
+      def unlock_integration
+        Jumpup::UI.say '  --> Unlocking integration...'.yellow
+        Jumpup::UI.say `git tag -d integrating`
+        Jumpup::UI.say `git push origin :refs/tags/integrating`
+        Jumpup::UI.say '  --> OK!'.green
+      end
+
+      private
+
+      def user
+        @user = `git config --get user.name`.strip
+      end
+    end
+  end
+end

data/lib/jumpup/ui.rb

@@ -0,0 +1,18 @@
+require 'colorize'
+
+module Jumpup
+  module UI
+    class << self
+      def header(message)
+        separator = '-' * 80
+        puts separator.white
+        puts message if message
+        yield if block_given?
+      end
+
+      def say(message)
+        puts message
+      end
+    end
+  end
+end

data/lib/jumpup/version.rb

@@ -1,3 +1,3 @@
 module Jumpup
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

data/lib/tasks/integrate.rake

@@ -1,73 +1,52 @@
-require 'find'
-
 namespace :jumpup do
 
-  def p80(message)
-    puts "-"*80
-    puts message if message
-    yield if block_given?
-  end
-
   namespace :git do
     desc 'Check if project can be committed to the repository.'
     task :status_check do
-      result = `git status`
-      if result.include?('Untracked files:') || result.include?('unmerged:') || result.include?('modified:')
-        puts result
-        exit
-      end
+      Jumpup::GitCommand.status_check
     end
 
     desc 'Update files from repository.'
     task :pull do
-      sh "git pull --rebase"
+      Jumpup::GitCommand.pull
     end
 
     desc 'Push project.'
     task :push do
-      sh "git push"
+      Jumpup::GitCommand.push
+    end
+  end
+
+  namespace :integration do
+    desc 'Checks if there\'s someone integrating.'
+    task :check do
+      Jumpup::GitCommand.check_integration
+    end
+
+    desc 'Lock integration.'
+    task :lock do
+      Jumpup::GitCommand.lock_integration
+    end
+
+    desc 'Unlock integration.'
+    task :unlock do
+      Jumpup::GitCommand.unlock_integration
     end
   end
 
-  task :start => ["git:status_check", "log:clear", "tmp:clear", "git:pull"] do
+  task start: ['integration:check', 'integration:lock', 'git:status_check', 'log:clear', 'tmp:clear', 'git:pull'] do
     ENV['coverage'] = 'on'
   end
-  task :finish => ["git:push"]
+  task finish: ['git:push', 'integration:unlock']
 
   desc 'Run bundle install'
   task :bundle_install do
-    Bundler.with_clean_env do
-      sh 'bundle install --quiet'
-    end
+    Jumpup::BundlerCommand.install_with_clean_env
   end
 
 end
 
 desc 'Integrate new code to repository'
 task :integrate do
-  if !defined?(INTEGRATION_TASKS)
-    p80 %{
-You should define INTEGRATION_TASKS constant. We recommend that you define it on lib/tasks/jumpup.rake file. The file doesn't exists. You should create it in your project.
-
-You'll probably want to add coverage/ to your .gitignore file.
-
-A sample content look like this:
-
-INTEGRATION_TASKS = %w(
-  jumpup:start
-  jumpup:bundle_install
-  db:migrate
-  spec
-  jumpup:finish
-)
-
-}
-    exit
-  end
-
-  INTEGRATION_TASKS.each do |subtask|
-    p80("Executing #{subtask}...") do
-      Rake::Task[subtask].invoke
-    end
-  end
+  Jumpup.perform_integration
 end

data/spec/fixtures/integration.rake

@@ -0,0 +1,17 @@
+task :one do
+  puts 'One'
+end
+
+task :two do
+  puts 'Two'
+end
+
+task :three do
+  puts 'Three'
+end
+
+INTEGRATION_TASKS = %w(
+  one
+  two
+  three
+)

data/spec/jumpup/integration_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe Jumpup do
+  include_examples 'capture stdout'
+
+  before do
+    Object.send(:remove_const, :INTEGRATION_TASKS) if Object.const_defined?(:INTEGRATION_TASKS)
+  end
+
+  describe 'INTEGRATION_TASKS is not defined'  do
+    it { expect { rake_integrate }.to raise_exception(SystemExit) }
+    it 'show a help message about the missing constant' do
+      begin
+        rake_integrate
+      rescue SystemExit
+        expect(@output.string).to include('You should define INTEGRATION_TASKS constant.')
+      end
+    end
+  end
+
+  describe 'INTEGRATION_TASKS is defined'  do
+    before { load_tasks }
+    before { rake_integrate }
+
+    it { expect(@output.string).to include('One') }
+    it { expect(@output.string).to include('Two') }
+    it { expect(@output.string).to include('Three') }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'bundler/setup'
+
+require 'pry'
+require 'rake'
+require 'jumpup'
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.order = :random
+  Kernel.srand config.seed
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+    mocks.verify_partial_doubles = true
+  end
+  config.default_formatter = 'doc' if config.files_to_run.one?
+end

data/spec/support/rake_helpers.rb

@@ -0,0 +1,21 @@
+def rake_integrate
+  begin
+    [:one, :two, :three].each do |task|
+      Rake::Task[task].reenable
+    end
+  rescue RuntimeError
+    # TODO: improve this
+    # Ignore the tasks if not defined
+    false
+  end
+  Rake::Task['integrate'].reenable
+  Rake::Task['integrate'].invoke
+end
+
+def load_tasks
+  load File.expand_path('../../fixtures/integration.rake', __FILE__)
+
+  [:one, :two, :three].each do |task|
+    Rake::Task.define_task(task)
+  end
+end

data/spec/support/shared_examples.rb

@@ -0,0 +1,11 @@
+RSpec.shared_examples 'capture stdout' do
+  before do
+    require 'stringio'
+    $stdout = StringIO.new
+    @output = $stdout
+  end
+
+  after do
+    $stdout = STDOUT
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jumpup
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - HE:labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-11 00:00:00.000000000 Z
+date: 2014-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,17 +25,73 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: aruba
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: colorize
+  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'
 description: A synchronous continuous integration gem.
@@ -46,16 +102,36 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
 - MIT-LICENSE
 - README.mkdn
 - Rakefile
+- features/bundler.feature
+- features/git.feature
+- features/integration.feature
+- features/lifecycle.feature
+- features/step_definitions/setup_git_repo.rb
+- features/support/env.rb
 - jumpup.gemspec
 - lib/jumpup.rb
+- lib/jumpup/commands.rb
+- lib/jumpup/commands/bundler_command.rb
+- lib/jumpup/commands/git_command.rb
+- lib/jumpup/ui.rb
 - lib/jumpup/version.rb
 - lib/tasks/integrate.rake
+- spec/fixtures/integration.rake
+- spec/jumpup/integration_spec.rb
+- spec/spec_helper.rb
+- spec/support/rake_helpers.rb
+- spec/support/shared_examples.rb
 homepage: https://github.com/Helabs/jumpup
 licenses:
 - MIT
@@ -81,4 +157,15 @@ signing_key:
 specification_version: 4
 summary: Jumpup gem help people that want to do synchronous continuous integration
   on their ruby projects.
-test_files: []
+test_files:
+- features/bundler.feature
+- features/git.feature
+- features/integration.feature
+- features/lifecycle.feature
+- features/step_definitions/setup_git_repo.rb
+- features/support/env.rb
+- spec/fixtures/integration.rake
+- spec/jumpup/integration_spec.rb
+- spec/spec_helper.rb
+- spec/support/rake_helpers.rb
+- spec/support/shared_examples.rb