fourchette 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a982a6a3feff7322d9d0ae4aac49bcbcaf9f4b2
-  data.tar.gz: 71313a343027783c2dc9e57ebb1030eb25f5451b
+  metadata.gz: a81c926b6fccb25d10111bbd826e6f12ac1b4925
+  data.tar.gz: b99d9faac8fc580772d1c5e45517343b9ae07427
 SHA512:
-  metadata.gz: fd909b27ceaaa68a09ce47d1b15054c31418aaddddd4f559587e7801f1bee6c83feaced2a62f7ed8ab6d034436b230e9c671ce09aa3d0748d06385eefe7f4176
-  data.tar.gz: 13e6b839fc87727fb7a3e7dd5a9cac45531ff5d621887db81e6896b3b6b5c1d4e8be92f5368a225f011a19b7bc0efd1f4e0302465ff4c283dffe88eac0c5d586
+  metadata.gz: 486ac1c0d082e82aab0483acb3acfa34abbbc339c916962fa0bb38c1ef8a01299a9ece417bf3b526bf4f52d9abd06b780415f002e60fd83da721fb39f314f965
+  data.tar.gz: e833fb94778d18cf6621d9e96524be64779119bb554796d7a50c3531dac281ae889f9c6b7e3da5dbf4632c5203039758d91c9a8f7facfc89a49a1b907483ae3d

data/.gitignore

@@ -15,3 +15,11 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.ruby-version
+
+# Mac specific
+.DS_Store
+
+# ngrok is for having tunnels to localhost, for local dev
+ngrok
+tags

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0-p353
+  - 2.1.0
+  - 2.1.1

data/Gemfile

@@ -1,4 +1,3 @@
-source 'https://rubygems.org'
+source 'http://rubygems.org'
 
-# Specify your gem's dependencies in fourchette.gemspec
-gemspec
+gemspec

data/Procfile

@@ -0,0 +1 @@
+web: bundle exec rackup -s puma -p $PORT

data/README.md

@@ -1,29 +1,115 @@
-# Fourchette
+<p align="center">
+  <a href="https://github.com/jipiboily/fourchette">
+    <img src="http://i.imgur.com/967yX36.png" alt="Fourchette" />
+  </a>
+  <br />
+  <b>Your new best friend for isolated testing environments on Heroku</b>
+  <br />
+  <a href="https://codeclimate.com/github/jipiboily/fourchette"><img src="https://codeclimate.com/github/jipiboily/fourchette.png" /></a>
+  <a href="https://github.com/jipiboily/fourchette"><img src="https://travis-ci.org/jipiboily/fourchette.png?branch=master" /></a>
+  <a href='https://coveralls.io/r/jipiboily/fourchette'><img src='https://coveralls.io/repos/jipiboily/fourchette/badge.png' alt='Coverage Status' /></a>
+</p>
 
-TODO: Write a gem description
+**IMPORTANT: this is a work in progress, use at your own risk.**
+
+Fourchette is your new best friend for having isolated testing environements. It will help you test your GitHub PRs against a fork of one your Heroku apps. You will have one Heroku app per PR now. Isn't that amazing? It will make testing way easier and you won't have the (maybe) broken code from other PRs on staging but only the code that requires testing.
+
+**IMPORTANT: Please note that forking your Heroku app means it will copy the same addon plans and that you will pay for multiple apps and their addons. Watch out!**
+
+## Flow
+
+- a PR is created against your GitHub project
+- Fourchette receives an event via GitHub Hooks
+  - it [forks](https://devcenter.heroku.com/articles/fork-app) an environement making it available to you
+  - any new commit against that PR will update the code
+- closing the PR will delete the forked app
+- re-opening the PR will re-create a fork
+
+## Diagram
+
+Seriously? You need a diagram for that? Nope. Not going to do this. PRs accepted...I guess.
+
+## Features
+- single project
+- configuration is made via environement variables
+- async processing
+- it works, but that's about it for now
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Those steps could be made way easier, but this is a really minimal implementation.
+
+1. Add `gem 'fourchette'` to your `Gemfile`
+2. Run `bundle install`
+3. Add `require 'fourchette/rake_tasks'` to your `Rakefile`
+4. Create a `Procfile` and a `config.ru` (using the ones from this repo as example)
+5. push to Heroku
+6. configure the right environement variables (see [#configuration](#configuration))
+7. Enable your Fourchette instance
+
+### Configuration
+
+- `export FOURCHETTE_GITHUB_PROJECT="jipiboily/fourchette"`
+- `export FOURCHETTE_GITHUB_USERNAME="jipiboily"`
+- `export FOURCHETTE_GITHUB_PERSONAL_TOKEN='a token here...'` # You can create one here: https://github.com/settings/applications
+- `export FOURCHETTE_HEROKU_USERNAME='me@domain'`
+- `export FOURCHETTE_HEROKU_API_KEY='API key here'`
+- `export FOURCHETTE_HEROKU_APP_TO_FORK='the name of the app to fork from'`
+- `export FOURCHETTE_APP_URL="http://fourchette-app.herokuapp.com"`
+- `export FOURCHETTE_HEROKU_APP_PREFIX="fourchette"` # This is basically to namespace your forks. In that example, they would be named "fourchette-pr-1234" where "1234" is the PR number. Beware, the name can't be more than 30 characters total! It will be changed to be lowercase only, so you should probably just use lowercase characters anyways.
+
+**IMPORTANT**: the GitHub user needs to be an admin of the repo to be able to add, enable or disable the web hook used by Fourchette. You could create it by hand if you prefer.
+
+### Enable your Fourchette instance
+
+run `bundle exec rake fourchette:enable`
+
+### Enable, disable, update or delete the hook
+
+`bundle exec rake -T` will tell you the rake tasks available. There are tasks to enable, disable or delete the GitHub hook to your Fourchette instance. There is also one to update the hook. That last one is mostly for development, if your local tunnel URl changed and you want to update the hook's URL.
+
+### Before & after steps, aka, callbacks
+
+You need to run steps before and/or after the creation of your new Heroku app? Let's say you want to run mirgations after deploying new code. There is a simple (and primitive) way of doing it. It might not be perfect but can work until there is a cleaner and more flexible way of doing so, if required.
+
+Create a file in your project to override the `Fourchette::Callbacks` class and include it after Fourchette.
+
+You just want to override the `before` or `after` methods of `Fourchette::Callbacks` (`lib/fourchette/callbacks.rb`) to suit your needs. In those methods, you have access to GitHub's hook data via the `@param` instance variable.
+
+## Rake tasks
+
+```
+rake fourchette:console  # Brings up a REPL with the code loaded
+rake fourchette:delete   # This deletes the Fourchette hook
+rake fourchette:disable  # This disables Fourchette hook
+rake fourchette:enable   # This enables Fourchette hook
+rake fourchette:update   # This updates the Fourchette hook with the current URL of the app
+```
+
+## Async processing note
 
-    gem 'fourchette'
+Fourchette uses [Sucker Punch](https://github.com/brandonhilkert/sucker_punch), "a single-process Ruby asynchronous processing library". No need for redis or extra processes. It also mean it can run for free on Heroku, if this is what you want.
 
-And then execute:
+## Contribute
 
-    $ bundle
+- fork & clone
+- `bundle install`
+- `foreman start`
+- You now have the app running on port 9292
 
-Or install it yourself as:
+Bonus: if you need a tunnel to your local dev machine to work with GitHub hooks, you might want to look at https://ngrok.com/.
 
-    $ gem install fourchette
+## It needs some love...
 
-## Usage
+What needs to be improved?
 
-TODO: Write usage instructions here
+- currently, it is assuming everything goes well, very little to no error management. This needs to improved.
+- make it simpler to bootstrap a Fourchette app (possibily a rake task to generate the required files and callback overrides)
+- it is not serious until there are specs for it, so add specs for that once we have a solid direction
+- security improvements (we should not accept hooks from anyone else than GitHub)
+- oAuth instead of GitHub token?
+- multi project would be great
 
-## Contributing
+# Contributors
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+Thanks to [@jpsirois](https://github.com/jpsirois/) for the logo!

data/Rakefile

@@ -1 +1,16 @@
-require "bundler/gem_tasks"
+require "fourchette/rake_tasks"
+
+begin
+  require 'rspec/core/rake_task'
+  # Set default Rake task to spec
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => :spec
+rescue LoadError => ex
+  # That's ok, it just means we don't have RSpec loaded
+end
+
+desc 'Brings up a REPL with the code loaded'
+task :console do
+  require './lib/fourchette'
+  Pry.start
+end

data/config.ru

@@ -0,0 +1,3 @@
+require './lib/fourchette'
+
+run Sinatra::Application

data/fourchette.gemspec

@@ -8,16 +8,28 @@ Gem::Specification.new do |spec|
   spec.version       = Fourchette::VERSION
   spec.authors       = ["Jean-Philippe Boily"]
   spec.email         = ["j@jipi.ca"]
-  spec.description   = %q{Fourchette is your new best friend for having isolated testing environements.}
-  spec.summary       = %q{Fourchette is your new best friend for having isolated testing environements.}
-  spec.homepage      = ""
+  spec.summary       = %q{Your new best friend for isolated testing environments on Heroku.}
+  spec.description   = %q{Fourchette is your new best friend for having isolated testing environements. It will help you test your GitHub PRs against a fork of one your Heroku apps. You will have one Heroku app per PR now. Isn't that amazing? It will make testing way easier and you won't have the (maybe) broken code from other PRs on staging but only the code that requires testing.}
+  spec.homepage      = "https://github.com/jipiboily/fourchette"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files`.split($/)
+  spec.files         = `git ls-files -z`.split("\x0")
   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.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_dependency "bundler", "~> 1.5"
+  spec.add_dependency "rake"
+  spec.add_dependency "sinatra", "~> 1.4.4"
+  spec.add_dependency "sinatra-contrib", "~> 1.4.2"
+  spec.add_dependency "octokit", "~> 3.0.0"
+  spec.add_dependency "git", "~> 1.2.6"
+  spec.add_dependency "heroics", "0.0.2"
+  spec.add_dependency "heroku", "~> 3.3.0" # Deprecated, but best/easiest solution for the pgbackups...
+  spec.add_dependency "sucker_punch", "~> 1.0.2"
+
+  spec.add_development_dependency 'foreman', '~> 0.63.0'
+  spec.add_development_dependency 'pry-debugger'
+  spec.add_development_dependency 'rspec', '~> 2.14.1'
+  spec.add_development_dependency 'coveralls'
 end

data/lib/fourchette.rb

@@ -1,5 +1,41 @@
 require "fourchette/version"
+require 'sinatra'
+require 'json'
+require 'cgi' # Required for Heroics
+require 'heroics'
+require 'octokit'
+require 'git'
+require 'sucker_punch'
+
+# TODO: Extract this to development.rb and production.rb
+if development?
+  require "sinatra/reloader"
+  
+  begin
+    require "pry"
+  rescue LoadError => ex
+    # That's ok, we don't care...it was probably loaded from another project
+    # and not to hack on Fourchette anyways!
+  end
+  
+  FOURCHETTE_CONFIG = {
+    env_name: 'fourchette-dev'
+  }
+else
+  FOURCHETTE_CONFIG = {
+    env_name: 'fourchette'
+  }
+end
+
 
 module Fourchette
-  # Your code goes here...
 end
+
+require_relative 'fourchette/logger'
+require_relative 'fourchette/web'
+require_relative 'fourchette/github'
+require_relative 'fourchette/pull_request'
+require_relative 'fourchette/fork'
+require_relative 'fourchette/heroku'
+require_relative 'fourchette/pgbackups'
+require_relative 'fourchette/callbacks'

data/lib/fourchette/callbacks.rb

@@ -0,0 +1,15 @@
+class Fourchette::Callbacks
+  include Fourchette::Logger
+
+  def initialize params
+    @params = params
+  end
+
+  def before
+    logger.info 'Running before steps...'
+  end
+
+  def after
+    logger.info 'Running after steps...'
+  end
+end

data/lib/fourchette/fork.rb

@@ -0,0 +1,108 @@
+class Fourchette::Fork
+  include Fourchette::Logger
+
+  def initialize params
+    @params = params
+    @heroku = Fourchette::Heroku.new
+  end
+
+  def update
+    create_unless_exists
+
+    heroku_git_url = @heroku.git_url(fork_name)
+
+    FileUtils.rm_rf('tmp/')
+
+    # Add key to current
+    logger.info "Creating an SSH key"
+    key_path = "~/.ssh/id_rsa-fourchette"
+    public_key_path = "#{key_path}.pub"
+    `ssh-keygen -t rsa -C "temporary@fourchetteapp" -N "" -f #{key_path} -q`
+    public_key_content = `cat #{public_key_path}`
+
+    # Create SSH config file, so that it uses the right SSH key
+    ssh_config_path = "~/.ssh/config"
+    if `cat #{ssh_config_path}`.length == 0
+      # Set the SSH key used, and disable strict host key checking
+      `echo "Host heroku.com\n IdentityFile #{key_path}\n StrictHostKeyChecking no" >> ~/.ssh/config`
+    end
+
+    # Add SSH key to the Heroku account
+    logger.info "Adding the SSH key to your Heroku account"
+    heroku_public_key = @heroku.client.key.create(public_key: public_key_content)
+
+    # Clone & push
+    logger.info "Cloning repository..."
+    repo = Git.clone(github_git_url, 'tmp')
+    repo.checkout(branch_name)
+
+    # TODO - HACK ALERT - Next couple lines are really hacky, and used
+    # instead of calling `git push heroku my_branch_name:master`
+    begin
+      repo.branch('master').delete
+    rescue Git::GitExecuteError
+      # There is no master branch? Hmmm
+    end
+    
+    begin
+      repo.branch('master').merge(branch_name)
+    rescue Git::GitExecuteError
+      # TODO - HACK ALERT! There is certainly a cleaner way to do this...
+    end
+    repo.add_remote('heroku', heroku_git_url)
+
+    logger.info "Pushing to Heroku..."
+    repo.push(repo.remote('heroku'))
+    logger.info "Done pushing to Heroku, apparently!"
+
+    # REMOVE key to the Heroku account
+    logger.info "Removing SSH key from your Heroku account"
+    @heroku.client.key.delete(heroku_public_key['id'])
+
+    # Remove ssh key
+    logger.info "Removing SSH key for file system"
+    FileUtils.rm_rf("~./ssh/id_rsa-fourchette*")
+  end
+
+  def create
+    github.comment_pr(pr_number, "Fourchette is initializing a new fork.")
+    create_unless_exists
+    update
+  end
+
+  def delete
+    @heroku.delete(fork_name)
+
+    # Update PR with URL
+    github.comment_pr(pr_number, "Test app deleted!")
+  end
+
+  private
+  def github
+    @github ||= Fourchette::GitHub.new
+  end
+
+  def create_unless_exists
+    unless @heroku.app_exists?(fork_name)
+      @heroku.fork(ENV['FOURCHETTE_HEROKU_APP_TO_FORK'] ,fork_name)
+      # Update PR with URL
+      github.comment_pr(pr_number, "Test URL: #{@heroku.client.app.info(fork_name)['web_url']}")
+    end
+  end
+
+  def fork_name
+    "#{ENV['FOURCHETTE_HEROKU_APP_PREFIX']}-PR-#{pr_number}".downcase # It needs to be lowercase only.
+  end
+
+  def github_git_url
+    @params['pull_request']['head']['repo']['clone_url'].gsub("//github.com", "//#{ENV['FOURCHETTE_GITHUB_USERNAME']}:#{ENV['FOURCHETTE_GITHUB_PERSONAL_TOKEN']}@github.com")
+  end
+
+  def branch_name
+    @branch_name ||= "remotes/origin/#{@params['pull_request']['head']['ref']}"
+  end
+
+  def pr_number
+    @pr_number ||= @params['pull_request']['number']
+  end
+end

data/lib/fourchette/github.rb

@@ -0,0 +1,101 @@
+class Fourchette::GitHub
+  include Fourchette::Logger
+
+  def enable_hook
+    logger.info 'Enabling the hooks for your app...'
+    if fourchette_hook
+      enable(fourchette_hook)
+    else
+      create_hook
+    end
+  end
+
+  def disable_hook
+    logger.info 'Disabling the hook for your app...'
+    if fourchette_hook && fourchette_hook.active == true
+      disable(fourchette_hook)
+    else
+      logger.error 'Nothing to disable, move along!'
+    end
+  end
+
+  def update_hook
+    logger.info 'Updating the hook for your app...'
+    toggle_active_state_to fourchette_hook, fourchette_hook.active
+  end
+
+  def delete_hook
+    logger.info 'Removing the hook for your app...'
+    octokit.remove_hook(ENV['FOURCHETTE_GITHUB_PROJECT'], fourchette_hook.id)
+  end
+
+  def comment_pr pr_number, comment
+    comment = "****** FOURCHETTE COMMENT ******\n\n#{comment}\n\n****** END OF FOURCHETTE COMMENT ******"
+    octokit.add_comment(ENV['FOURCHETTE_GITHUB_PROJECT'], pr_number, comment)
+  end
+
+  private
+  def octokit
+    @octokit_client ||= Octokit::Client.new(login: ENV['FOURCHETTE_GITHUB_USERNAME'], password: ENV['FOURCHETTE_GITHUB_PERSONAL_TOKEN'])
+  end
+
+  def create_hook
+    logger.info 'Creating a new hook...'
+    octokit.create_hook(
+      ENV['FOURCHETTE_GITHUB_PROJECT'],
+      'web',
+      {
+        url: "#{ENV['FOURCHETTE_APP_URL']}/hooks",
+        content_type: 'json',
+        fourchette_env: FOURCHETTE_CONFIG[:env_name]
+      },
+      {
+        :events => ['pull_request'],
+        :active => true
+      }
+    )
+  end
+
+  def hooks
+    octokit.hooks(ENV['FOURCHETTE_GITHUB_PROJECT'])
+  end
+
+  def fourchette_hook
+    existing_hook = nil
+
+    hooks.each do |hook|
+      existing_hook = hook unless hook.config && hook.config.fourchette_env.nil?
+    end
+
+    existing_hook
+  end
+
+  def enable(hook)
+    if hook.active
+      logger.error 'The hook is already active, dude!'
+    else
+      toggle_active_state_to hook, true
+    end
+  end
+
+  def disable(hook)
+    toggle_active_state_to hook, false
+  end
+
+  def toggle_active_state_to hook, active_value
+    octokit.edit_hook(
+      ENV['FOURCHETTE_GITHUB_PROJECT'],
+      hook.id,
+      'web',
+      {
+        url: "#{ENV['FOURCHETTE_APP_URL']}/hooks",
+        content_type: 'json',
+        fourchette_env: FOURCHETTE_CONFIG[:env_name]
+      },
+      {
+        :events => ['pull_request'],
+        :active => active_value
+      }
+    )
+  end
+end

data/lib/fourchette/heroku.rb

@@ -0,0 +1,74 @@
+class Fourchette::Heroku
+  include Fourchette::Logger
+
+  def app_exists? name
+    client.app.list.collect { |app| app if app['name'] == name }.reject(&:nil?).any?
+  end
+
+  def fork from, to
+    create_app(to)
+    copy_config(from, to)
+    copy_add_ons(from, to)
+    copy_pg(from, to)
+  end
+
+  def delete app_name
+    logger.info "Deleting #{app_name}"
+    client.app.delete(app_name)
+  end
+
+  def client
+    # TODO: add caching... https://github.com/heroku/heroics/#client-side-caching
+    unless @heroku_client
+      username = CGI.escape(ENV['FOURCHETTE_HEROKU_USERNAME'])
+      token = ENV['FOURCHETTE_HEROKU_API_KEY']
+      url = "https://#{username}:#{token}@api.heroku.com/schema"
+      options = {default_headers: {'Accept' => 'application/vnd.heroku+json; version=3'}}
+      @heroku_client = Heroics.client_from_schema_url(url, options)
+    end
+    @heroku_client
+  end
+
+  def config_vars app_name
+    client.config_var.info(app_name)
+  end
+
+  def git_url app_name
+    client.app.info(app_name)['git_url']
+  end
+
+  private
+  def create_app name
+    logger.info "Creating #{name}"
+    client.app.create({ name: name })
+  end
+
+  def copy_config from, to
+    logger.info "Copying configs from #{from} to #{to}"
+    from_congig_vars = config_vars(from)
+    # WE SHOULD NOT MOVE THE HEROKU_POSTGRES_*_URL...
+    from_congig_vars.reject! { |k, v| k.start_with?('HEROKU_POSTGRESQL_') && k.end_with?('_URL') }
+    client.config_var.update(to, from_congig_vars)
+  end
+
+  def copy_add_ons from, to
+    logger.info "Copying addons from #{from} to #{to}"
+    from_addons = client.addon.list(from)
+    from_addons.each do |addon|
+      name = addon['plan']['name']
+      begin
+        logger.info "Adding #{name} to #{to}"
+        client.addon.create(to, { plan: name })
+      rescue Excon::Errors::UnprocessableEntity => e
+        logger.error "Failed to copy addon #{name}"
+        logger.error e
+      end
+    end
+  end
+
+  def copy_pg from, to
+    logger.info "Copying Postgres's data from #{from} to #{to}"
+    backup = Fourchette::Pgbackups.new
+    backup.copy(from, to)
+  end
+end

data/lib/fourchette/logger.rb

@@ -0,0 +1,12 @@
+require 'logger'
+
+module Fourchette::Logger
+  def logger
+    unless @logger
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+    end
+
+    @logger
+  end
+end

data/lib/fourchette/pgbackups.rb

@@ -0,0 +1,39 @@
+require "heroku/client/pgbackups"
+class Fourchette::Pgbackups
+  include Fourchette::Logger
+
+  def initialize
+    @heroku = Fourchette::Heroku.new
+  end
+
+  def copy from, to
+    ensure_pgbackups_is_present(from)
+    ensure_pgbackups_is_present(to)
+
+    from_url, from_name = pg_details_for(from)
+    to_url, to_name = pg_details_for(to)
+
+    @client =  Heroku::Client::Pgbackups.new pgbackup_url(from)+'/api'
+    @client.create_transfer(from_url, from_name, to_url, to_name)
+  end
+
+  private
+  def ensure_pgbackups_is_present heroku_app_name
+    unless @heroku.client.addon.list(heroku_app_name).select { |addon| addon['name'] == 'pgbackups' }.any?
+      logger.info "Adding pgbackups to #{heroku_app_name}"
+      @heroku.client.addon.create(heroku_app_name, { plan: 'pgbackups' })
+    end
+  end
+
+  def pg_details_for app_name
+    @heroku.config_vars(app_name).each do |key, value|
+      return [value, key] if key.start_with?('HEROKU_POSTGRESQL_') && key.end_with?('_URL')
+    end
+  end
+
+  def pgbackup_url app_name
+    @heroku.config_vars(app_name).each do |k, v|
+      return v if k == 'PGBACKUPS_URL'
+    end
+  end
+end

data/lib/fourchette/pull_request.rb

@@ -0,0 +1,31 @@
+class Fourchette::PullRequest
+  include SuckerPunch::Job
+
+  def perform params
+    callbacks = Fourchette::Callbacks.new(params)
+    @params = params
+
+    callbacks.before
+
+    case action
+    when 'synchronize' # new push against the PR
+      fork.update
+    when 'closed'
+      fork.delete
+    when 'reopened'
+      fork.create
+    when 'opened'
+      fork.create
+    end
+
+    callbacks.after
+  end
+
+  def action
+    @params['action']
+  end
+
+  def fork
+    @fork ||= Fourchette::Fork.new(@params)
+  end
+end

data/lib/fourchette/rake_tasks.rb

@@ -0,0 +1,23 @@
+require 'fourchette'
+
+namespace :fourchette do
+  desc 'This enables Fourchette hook'
+  task :enable do
+    Fourchette::GitHub.new.enable_hook
+  end
+
+  desc 'This disables Fourchette hook'
+  task :disable do
+    Fourchette::GitHub.new.disable_hook
+  end
+
+  desc 'This updates the Fourchette hook with the current URL of the app'
+  task :update do
+    Fourchette::GitHub.new.update_hook
+  end
+
+  desc 'This deletes the Fourchette hook'
+  task :delete do
+    Fourchette::GitHub.new.delete_hook
+  end
+end

data/lib/fourchette/version.rb

@@ -1,3 +1,3 @@
 module Fourchette
-  VERSION = "0.0.0"
-end
+  VERSION = "0.0.1"
+end

data/lib/fourchette/web.rb

@@ -0,0 +1 @@
+require_relative 'web/hooks'

data/lib/fourchette/web/hooks.rb

@@ -0,0 +1,5 @@
+post '/hooks' do
+  params = JSON.parse(request.env["rack.input"].read)
+  Fourchette::PullRequest.new.async.perform(params)
+  "Got it, thanks!"
+end

data/spec/lib/fourchette/heroku_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+
+describe Fourchette::Heroku do
+  let(:heroku) { Fourchette::Heroku.new }
+  let(:from_app_name) { 'awesome app' }
+  let(:to_app_name) { 'awesomer app!' }
+
+  before do
+    client = double('client')
+    client_app = double('client')
+    app_list = [ { 'name' => 'fourchette-pr-7' }, { 'name' => 'fourchette-pr-8' } ]
+    client_app.stub(:list).and_return(app_list)
+    client.stub(:app).and_return(client_app)
+
+    config_var = double('config_var')
+    client.stub(:config_var).and_return(config_var)
+
+    client.app.stub(:info).and_return( { 'git_url' => 'git@heroku.com/something.git' } )
+
+    heroku.stub(:client).and_return(client)
+  end
+
+  describe '#app_exists?' do
+    it { expect(heroku.app_exists?('fourchette-pr-7')).to eq true }
+    it { expect(heroku.app_exists?('fourchette-pr-8')).to eq true }
+    it { expect(heroku.app_exists?('fourchette-pr-333')).to eq false }
+  end
+
+  describe '#fork' do
+    before do
+      heroku.stub(:create_app)
+      heroku.stub(:copy_config)
+      heroku.stub(:copy_add_ons)
+      heroku.stub(:copy_pg)
+    end
+
+    ['create_app', 'copy_config', 'copy_add_ons', 'copy_pg'].each do |method_name|
+      it "calls `#{method_name}'" do
+        heroku.should_receive(method_name)
+        heroku.fork(from_app_name, to_app_name)
+      end
+    end
+  end
+
+  describe '#git_url' do
+    it { expect(heroku.git_url(to_app_name)).to eq 'git@heroku.com/something.git' }
+  end
+
+  describe '#delete' do
+    it 'calls delete on the Heroku client' do
+      heroku.client.app.should_receive(:delete).with(to_app_name)
+      heroku.delete(to_app_name)
+    end
+  end
+
+  describe '#config_vars' do
+    it 'calls config_var.info on the Heroku client' do
+      heroku.client.config_var.should_receive(:info).with(from_app_name)
+      heroku.config_vars(from_app_name)
+    end
+  end
+
+  describe 'private functions' do
+    describe '#create_app' do
+      it 'calls app.create on the Heroku client' do
+        heroku.client.app.should_receive(:create).with({ name: to_app_name })
+        heroku.send(:create_app, to_app_name)
+      end
+    end
+
+    describe '#copy_config' do
+      let(:vars) { { 'WHATEVER' => 'ok', 'HEROKU_POSTGRESQL_SOMETHING_URL' => 'FAIL@POSTGRES/DB' } }
+      let(:cleaned_vars) { { 'WHATEVER' => 'ok'} }
+
+      it 'calls #config_vars' do
+        heroku.client.config_var.stub(:update)
+        heroku.should_receive(:config_vars).with(from_app_name).and_return(vars)
+        heroku.send(:copy_config, from_app_name, to_app_name)
+      end
+
+      it 'updates config vars without postgres URLs' do
+        heroku.client.config_var.should_receive(:update).with(to_app_name, cleaned_vars )
+        heroku.stub(:config_vars).and_return(vars)
+        heroku.send(:copy_config, 'from', to_app_name)
+      end
+    end
+
+    describe '#copy_add_ons' do
+      let(:addon_list) { [ { 'plan' => { 'name' => 'redistogo' } } ] }
+
+      before do
+        heroku.client.stub(:addon).and_return( double('addon') )
+        heroku.client.addon.stub(:create)
+        heroku.client.addon.stub(:list).and_return(addon_list)
+      end
+
+      it 'gets the addon list' do
+        heroku.client.addon.should_receive(:list).with(from_app_name).and_return(addon_list)
+        heroku.send(:copy_add_ons, from_app_name, to_app_name)
+      end
+
+      it 'creates addons' do
+        heroku.client.addon.should_receive(:create).with(to_app_name, { plan: 'redistogo' })
+        heroku.send(:copy_add_ons, from_app_name, to_app_name)
+      end
+    end
+
+    describe '#copy_pg' do
+      it 'calls Fourchette::Pgbackups#copy' do
+        Fourchette::Pgbackups.any_instance.should_receive(:copy).with(from_app_name, to_app_name)
+        heroku.send(:copy_pg, from_app_name, to_app_name)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'coveralls'
+Coveralls.wear!
+
+require_relative '../lib/fourchette'
+
+support_include_path = "#{Dir.pwd}/spec/support/**/*.rb"
+Dir[support_include_path].each {|f| require f}

data/spec/support/silent-logger.rb

@@ -0,0 +1,4 @@
+Logger.class_eval do
+  def info(*args)
+  end
+end

metadata

@@ -1,59 +1,234 @@
 --- !ruby/object:Gem::Specification
 name: fourchette
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Jean-Philippe Boily
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-30 00:00:00.000000000 Z
+date: 2014-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
+        version: '1.5'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.5'
 - !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: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.4
+- !ruby/object:Gem::Dependency
+  name: sinatra-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+- !ruby/object:Gem::Dependency
+  name: octokit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.6
+- !ruby/object:Gem::Dependency
+  name: heroics
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: heroku
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.3.0
+- !ruby/object:Gem::Dependency
+  name: sucker_punch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: foreman
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.63.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.63.0
+- !ruby/object:Gem::Dependency
+  name: pry-debugger
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Fourchette is your new best friend for having isolated testing environements.
+  It will help you test your GitHub PRs against a fork of one your Heroku apps. You
+  will have one Heroku app per PR now. Isn't that amazing? It will make testing way
+  easier and you won't have the (maybe) broken code from other PRs on staging but
+  only the code that requires testing.
 email:
 - j@jipi.ca
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
+- Procfile
 - README.md
 - Rakefile
+- config.ru
 - fourchette.gemspec
 - lib/fourchette.rb
+- lib/fourchette/callbacks.rb
+- lib/fourchette/fork.rb
+- lib/fourchette/github.rb
+- lib/fourchette/heroku.rb
+- lib/fourchette/logger.rb
+- lib/fourchette/pgbackups.rb
+- lib/fourchette/pull_request.rb
+- lib/fourchette/rake_tasks.rb
 - lib/fourchette/version.rb
-homepage: ''
+- lib/fourchette/web.rb
+- lib/fourchette/web/hooks.rb
+- spec/lib/fourchette/heroku_spec.rb
+- spec/spec_helper.rb
+- spec/support/silent-logger.rb
+homepage: https://github.com/jipiboily/fourchette
 licenses:
 - MIT
 metadata: {}
@@ -63,18 +238,21 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.2
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
-summary: Fourchette is your new best friend for having isolated testing environements.
-test_files: []
+summary: Your new best friend for isolated testing environments on Heroku.
+test_files:
+- spec/lib/fourchette/heroku_spec.rb
+- spec/spec_helper.rb
+- spec/support/silent-logger.rb