bricks-deploy 0.6.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 23761d79c1dd42c598f5a2fa0c89207ee15ebaff
+  data.tar.gz: 2984300c55c2848d2dcb19b0b449c7e9e6f22cb1
+SHA512:
+  metadata.gz: 7125ee77947a9290be0e8927d4dc8f48a921c78c2f42d5cd71aef3876843dcac5471545708ef3e4d644c9c27def07e772da1b15d010b947e216d51e25b89c041
+  data.tar.gz: f6ad55bd2b166e9f1c015103a174aea035da2a2c3e118f958663a86abbe4ebe0dbd83309e53e5192b68a237b1b22b43e45d6c951082c488ee0f6a0ab87028537

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2009 Mislav Marohnić
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of 
+this software and associated documentation files (the "Software"), to deal in 
+the Software without restriction, including without limitation the rights to 
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 
+the Software, and to permit persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all 
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,134 @@
+Easy git deployment
+===================
+
+Straightforward, [Heroku][]-style, push-based deployment. Your deploys can become as simple as this:
+
+    $ git push production master
+
+To get started, install the "bricks-deploy" gem.
+
+    gem install bricks-deploy
+
+Only the person who is setting up deployment for the first time needs to install
+the gem. You don't have to add it to your project's Gemfile.
+
+
+Which app languages/frameworks are supported?
+---------------------------------------------
+
+Regardless of the fact that this tool is mostly written in Ruby, bricks-deploy can be useful for any kind of code that needs deploying on a remote server. The default scripts are suited for Ruby web apps, but can be edited to accommodate other frameworks.
+
+Your deployment is customized with per-project callback scripts which can be written in any language.
+
+The assumption is that you're deploying to a single host to which you connect over SSH using public/private key authentication.
+
+
+Initial setup
+-------------
+
+1.  Create a git remote for where you'll push the code on your server. The name of this remote in the examples is "production", but it can be whatever you wish ("online", "website", or other).
+
+    ```sh
+    git remote add production "user@example.com:/apps/mynewapp"
+    ```
+
+    `/apps/mynewapp` is the directory where you want your code to reside on the
+    remote server. If the directory doesn't exist, the next step creates it.
+
+2.  Run the setup task:
+
+    ```sh
+    git deploy setup -r "production"
+    ```
+
+    This will initialize the remote git repository in the deploy directory
+    (`/apps/mynewapp` in the above example) and install the remote git hook.
+
+3.  Run the init task:
+
+    ```sh
+    git deploy init
+    ```
+
+    This generates default deploy callback scripts in the `deploy/` directory.
+    You should check them in git because they are going to be executed on the
+    server during each deploy.
+
+4.  Push the code.
+
+    ```sh
+    git push production master
+    ```
+
+3.  Login to your server and manually perform necessary one-time administrative operations. This might include:
+    * set up the Apache/nginx virtual host for this application;
+    * check your `config/database.yml` and create the production database.
+
+
+Everyday deployments
+--------------------
+
+If you've set your app correctly, visiting <http://example.com> in your browser
+should show it up and running.
+
+Now, subsequent deployments are done simply **by pushing to the branch that is
+currently checked out on the remote**:
+
+    git push production master
+
+Because the deployments are performed with git, nobody else on the team needs to
+install the "bricks-deploy" gem.
+
+On every deploy, the default `deploy/after_push` script performs the following:
+
+1. updates git submodules (if there are any);
+2. runs `bundle install --deployment` if there is a Gemfile;
+3. runs `rake db:migrate` if new migrations have been added;
+4. clears cached CSS/JS assets in "public/stylesheets" and "public/javascripts";
+5. restarts the web application.
+
+You can customize all this by editing generated scripts in the `deploy/`
+directory of your app.
+
+Deployments are logged to `log/deploy.log` in your application's directory.
+
+
+How it works
+------------
+
+The `git deploy setup` command installed a `post-receive` git hook in the remote
+repository. This is how your code on the server is kept up to date. This script
+checks out the latest version of your project from the current branch and
+runs the following callback scripts:
+
+* `deploy/setup` - on first push.
+* `deploy/after_push` - on subsequent pushes. It in turn executes:
+  * `deploy/before_restart`
+  * `deploy/restart`
+  * `deploy/after_restart`
+* `deploy/rollback` - executed for `git deploy rollback`.
+
+All of the callbacks are optional. These scripts are ordinary Unix executables.
+The ones which get generated for you by `git deploy init` are written in shell
+script and Ruby.
+
+
+Extra commands
+--------------
+
+* `git deploy hooks` - Updates git hooks on the remote repository
+
+* `git deploy log [N=20]` - Shows last 20 lines of deploy log on the server
+
+* `git deploy rerun` - Re-runs the `deploy/after_push` callback as if a git push happened
+
+* `git deploy restart` - Runs the `deploy/restart` callback
+
+* `git deploy rollback` - Undo a deploy by checking out the previous revision,
+  runs `deploy/rollback` if exists instead of `deploy/after_push`
+
+* `git deploy upload <files>` - Copy local files to the remote app
+
+
+
+  [heroku]: http://heroku.com/

data/bin/bricks-deploy

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require 'bricks_deploy'
+BricksDeploy.start

data/lib/bricks_deploy/configuration.rb

@@ -0,0 +1,83 @@
+require 'uri'
+require 'cgi'
+require 'forwardable'
+
+class BricksDeploy
+  module Configuration
+    private
+
+    extend Forwardable
+    def_delegator :remote_url, :host
+    def_delegator :remote_url, :port, :remote_port
+    def_delegator :remote_url, :path, :deploy_to
+
+    def remote_user
+      @user ||= begin
+        user = remote_url.user
+        user ? CGI.unescape(user) : `whoami`.chomp
+      end
+    end
+
+    def branch
+      'master'
+    end
+
+    def git_config
+      @git_config ||= Hash.new do |cache, cmd|
+        git = ENV['GIT'] || 'git'
+        out = `#{git} #{cmd}`
+        if $?.success? then cache[cmd] = out.chomp
+        else cache[cmd] = nil
+        end
+        cache[cmd]
+      end
+    end
+
+    def remote_urls(remote)
+      git_config["remote -v"].to_s.split("\n").
+        select {|l| l =~ /^#{remote}\t.+/ }.
+        map {|l| l.split("\t")[1].sub(/\s+\(.+?\)$/, '') }
+    end
+
+    def remote_url(remote = options[:remote])
+      @remote_url ||= {}
+      @remote_url[remote] ||= begin
+        url = remote_urls(remote).first
+        if url.nil?
+          abort "Error: Remote url not found for remote #{remote.inspect}"
+        elsif url =~ /(^|@)github\.com\b/
+          abort "Error: Remote url for #{remote.inspect} points to GitHub. Can't deploy there!"
+        else
+          url = 'ssh://' + url.sub(%r{:/?}, '/') unless url =~ %r{^[\w-]+://}
+          begin
+            url = URI.parse url
+          rescue
+            abort "Error parsing remote url #{url}"
+          end
+        end
+        url
+      end
+    end
+
+    def current_branch
+      git_config['symbolic-ref -q HEAD']
+    end
+
+    def tracked_branch
+      branch = current_branch && tracked_for(current_branch)
+      normalize_branch(branch) if branch
+    end
+
+    def normalize_branch(branch)
+      branch.sub('refs/heads/', '')
+    end
+
+    def remote_for(branch)
+      git_config['config branch.%s.remote' % normalize_branch(branch)]
+    end
+
+    def tracked_for(branch)
+      git_config['config branch.%s.merge' % normalize_branch(branch)]
+    end
+  end
+end

data/lib/bricks_deploy/generator.rb

@@ -0,0 +1,28 @@
+require 'thor/group'
+
+class BricksDeploy::Generator < Thor::Group
+  include Thor::Actions
+
+  def self.source_root
+    File.expand_path('../templates', __FILE__)
+  end
+
+  def copy_main_hook
+    copy_hook 'after_push.sh', 'deploy/after_push'
+  end
+
+  def copy_restart_hook
+    copy_hook 'restart.sh', 'deploy/restart'
+  end
+
+  def copy_restart_callbacks
+    copy_hook 'before_restart.rb', 'deploy/before_restart'
+  end
+
+  private
+
+  def copy_hook(template, destination)
+    copy_file template, destination
+    chmod destination, 0744 unless File.executable? destination
+  end
+end

data/lib/bricks_deploy/ssh_methods.rb

@@ -0,0 +1,102 @@
+class BricksDeploy
+  module SSHMethods
+    private
+
+    def sudo_cmd
+      "sudo -p 'sudo password: '"
+    end
+
+    def system(*args)
+      puts "[local] $ " + args.join(' ').gsub(' && ', " && \\\n  ")
+      super unless options.noop?
+    end
+
+    def run(cmd = nil, opt = {})
+      cmd = yield(cmd) if block_given?
+      cmd = cmd.join(' && ') if Array === cmd
+
+      if opt.fetch(:echo, true)
+        puts "[#{options[:remote]}] $ " + cmd.gsub(' && ', " && \\\n  ")
+      end
+
+      unless options.noop?
+        status, output = ssh_exec cmd do |ch, stream, data|
+          case stream
+          when :stdout then $stdout.print data
+          when :stderr then $stderr.print data
+          end
+          ch.send_data(askpass) if data =~ /^sudo password: /
+        end
+        output
+      end
+    end
+
+    def run_test(cmd)
+      status, output = ssh_exec(cmd) { }
+      status == 0
+    end
+
+    def ssh_exec(cmd, &block)
+      status = nil
+      output = ''
+
+      channel = ssh_connection.open_channel do |chan|
+        chan.exec(cmd) do |ch, success|
+          raise "command failed: #{cmd.inspect}" unless success
+          # ch.request_pty
+
+          ch.on_data do |c, data|
+            output << data
+            yield(c, :stdout, data)
+          end
+
+          ch.on_extended_data do |c, type, data|
+            output << data
+            yield(c, :stderr, data)
+          end
+
+          ch.on_request "exit-status" do |ch, data|
+            status = data.read_long
+          end
+        end
+      end
+
+      channel.wait
+      [status, output]
+    end
+
+    # TODO: use Highline for cross-platform support
+    def askpass
+      tty_state = `stty -g`
+      system 'stty raw -echo -icanon isig' if $?.success?
+      pass = ''
+      while char = $stdin.getbyte and not (char == 13 or char == 10)
+        if char == 127 or char == 8
+          pass[-1,1] = '' unless pass.empty?
+        else
+          pass << char.chr
+        end
+      end
+      pass
+    ensure
+      system "stty #{tty_state}" unless tty_state.empty?
+    end
+
+    def scp_upload(files)
+      channels = []
+      files.each do |local, remote|
+        puts "FILE: [local] #{local.sub(LOCAL_DIR + '/', '')}  ->  [#{options[:remote]}] #{remote}"
+        channels << ssh_connection.scp.upload(local, remote) unless options.noop?
+      end
+      channels.each { |c| c.wait }
+    end
+
+    def ssh_connection
+      @ssh ||= begin
+        ssh = Net::SSH.start(host, remote_user, :port => remote_port)
+        at_exit { ssh.close }
+        ssh
+      end
+    end
+  end
+end

data/lib/bricks_deploy/templates/after_push.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -e
+oldrev=$1
+newrev=$2
+
+run() {
+  [ -x $1 ] && $1 $oldrev $newrev
+}
+
+echo files changed: $(git diff $oldrev $newrev --diff-filter=ACDMR --name-only | wc -l)
+
+umask 002
+
+git submodule sync && git submodule update --init --recursive
+
+run deploy/before_restart
+run deploy/restart && run deploy/after_restart

data/lib/bricks_deploy/templates/before_restart.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+oldrev, newrev = ARGV
+
+def run(cmd)
+  exit($?.exitstatus) unless system "umask 002 && #{cmd}"
+end
+
+RAILS_ENV   = ENV['RAILS_ENV'] || 'production'
+use_bundler = File.file? 'Gemfile'
+rake_cmd    = use_bundler ? 'bundle exec rake' : 'rake'
+
+if use_bundler
+  bundler_args = ['--deployment']
+  BUNDLE_WITHOUT = ENV['BUNDLE_WITHOUT'] || 'development:test'
+  bundler_args << '--without' << BUNDLE_WITHOUT unless BUNDLE_WITHOUT.empty?
+
+  # update gem bundle
+  run "bundle install #{bundler_args.join(' ')}"
+end
+
+if File.file? 'Rakefile'
+  tasks = []
+
+  num_migrations = `git diff #{oldrev} #{newrev} --diff-filter=A --name-only -z -- db/migrate`.split("\0").size
+  # run migrations if new ones have been added
+  tasks << "db:migrate" if num_migrations > 0
+
+  # precompile assets
+  changed_assets = `git diff #{oldrev} #{newrev} --name-only -z -- app/assets`.split("\0")
+  tasks << "assets:precompile" if changed_assets.size > 0
+
+  run "#{rake_cmd} #{tasks.join(' ')} RAILS_ENV=#{RAILS_ENV}" if tasks.any?
+end
+
+# clear cached assets (unversioned/ignored files)
+run "git clean -x -f -- public/stylesheets public/javascripts"
+
+# clean unversioned files from vendor/plugins (e.g. old submodules)
+run "git clean -d -f -- vendor/plugins"

data/lib/bricks_deploy/templates/restart.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+touch tmp/restart.txt
+echo "restarting Passenger app"

data/lib/bricks_deploy.rb

@@ -0,0 +1,104 @@
+require 'thor'
+require 'net/ssh'
+require 'net/scp'
+
+class BricksDeploy < Thor
+  LOCAL_DIR = File.expand_path('..', __FILE__)
+
+  require 'bricks_deploy/configuration'
+  require 'bricks_deploy/ssh_methods'
+  include Configuration
+  include SSHMethods
+
+  class_option :remote, :aliases => '-r', :type => :string, :default => 'origin'
+  class_option :noop, :aliases => '-n', :type => :boolean, :default => false
+
+  desc "init", "Generates deployment customization scripts for your app"
+  def init
+    require 'bricks_deploy/generator'
+    Generator::start([])
+  end
+
+  desc "setup", "Create the remote git repository and install push hooks for it"
+  method_option :shared, :aliases => '-g', :type => :boolean, :default => false
+  method_option :sudo, :aliases => '-s', :type => :boolean, :default => false
+  def setup
+    sudo = options.sudo? ? "#{sudo_cmd} " : ''
+
+    unless run_test("test -x #{deploy_to}")
+      run ["#{sudo}mkdir -p #{deploy_to}"] do |cmd|
+        cmd << "#{sudo}chown $USER #{deploy_to}" if options.sudo?
+        cmd
+      end
+    end
+
+    run [] do |cmd|
+      cmd << "chmod g+ws #{deploy_to}" if options.shared?
+      cmd << "cd #{deploy_to}"
+      cmd << "git init #{options.shared? ? '--shared' : ''}"
+      cmd << "sed -i'' -e 's/master/#{branch}/' .git/HEAD" unless branch == 'master'
+      cmd << "git config --bool receive.denyNonFastForwards false" if options.shared?
+      cmd << "git config receive.denyCurrentBranch ignore"
+    end
+
+    invoke :hooks
+  end
+
+  desc "hooks", "Installs git hooks to the remote repository"
+  def hooks
+    hooks_dir = File.join(LOCAL_DIR, 'hooks')
+    remote_dir = "#{deploy_to}/.git/hooks"
+
+    scp_upload "#{hooks_dir}/post-receive.sh" => "#{remote_dir}/post-receive"
+    run "chmod +x #{remote_dir}/post-receive"
+  end
+  
+  desc "restart", "Restarts the application on the server"
+  def restart
+    run "cd #{deploy_to} && deploy/restart 2>&1 | tee -a log/deploy.log"
+  end
+
+  desc "rerun", "Runs the `deploy/after_push' callback as if a new revision was pushed via git"
+  def rerun
+    run <<-BASH, :echo => false
+      bash -e -c '
+        cd '#{deploy_to}'
+        declare -a revs=( $(git rev-parse HEAD@{1} HEAD) )
+        deploy/after_push ${revs[@]} 2>&1 | tee -a log/deploy.log
+      '
+    BASH
+  end
+
+  desc "rollback", "Rolls back the checkout to before the last push"
+  def rollback
+    run <<-BASH, :echo => false
+      bash -e -c '
+        cd '#{deploy_to}'
+        declare -a revs=( $(git rev-parse HEAD HEAD@{1}) )
+        git reset --hard ${revs[1]}
+        callback=after_push
+        [ -x deploy/rollback ] && callback=rollback
+        deploy/$callback ${revs[@]} 2>&1 | tee -a log/deploy.log
+      '
+    BASH
+  end
+
+  desc "log", "Shows the last part of the deploy log on the server"
+  method_option :tail, :aliases => '-t', :type => :boolean, :default => false
+  method_option :lines, :aliases => '-l', :type => :numeric, :default => 20
+  def log(n = nil)
+    tail_args = options.tail? ? '-f' : "-n#{n || options.lines}"
+    run "tail #{tail_args} #{deploy_to}/log/deploy.log"
+  end
+
+  desc "upload <files>", "Copy local files to the remote app"
+  def upload(*files)
+    files = files.map { |f| Dir[f.strip] }.flatten
+    abort "Error: Specify at least one file to upload" if files.empty?
+
+    scp_upload files.inject({}) { |all, file|
+      all[file] = File.join(deploy_to, file)
+      all
+    }
+  end
+end

data/lib/hooks/post-receive.sh

@@ -0,0 +1,55 @@
+#!/bin/bash
+set -e
+
+if [ "$GIT_DIR" = "." ]; then
+  # The script has been called as a hook; chdir to the working copy
+  cd ..
+  unset GIT_DIR
+fi
+
+# try to obtain the usual system PATH
+if [ -f /etc/profile ]; then
+  PATH=$(source /etc/profile; echo $PATH)
+  export PATH
+fi
+
+# get the current branch
+head="$(git symbolic-ref HEAD)"
+
+# read the STDIN to detect if this push changed the current branch
+while read oldrev newrev refname
+do
+  [ "$refname" = "$head" ] && break
+done
+
+# abort if there's no update, or in case the branch is deleted
+if [ -z "${newrev//0}" ]; then
+  exit
+fi
+
+# check out the latest code into the working copy
+umask 002
+git reset --hard
+
+logfile=log/deploy.log
+restart=tmp/restart.txt
+
+if [ -z "${oldrev//0}" ]; then
+  # this is the first push; this branch was just created
+  mkdir -p log tmp
+  chmod 0775 log tmp
+  touch $logfile $restart
+  chmod 0664 $logfile $restart
+
+  # init submodules
+  git submodule update --recursive --init 2>&1 | tee -a $logfile
+
+  # execute the one-time setup hook
+  [ -x deploy/setup ] && deploy/setup $oldrev $newrev 2>&1 | tee -a $logfile
+else
+  # log timestamp
+  echo ==== $(date) ==== >> $logfile
+
+  # execute the main deploy hook
+  [ -x deploy/after_push ] && deploy/after_push $oldrev $newrev 2>&1 | tee -a $logfile
+fi

data/spec/configuration_spec.rb

@@ -0,0 +1,59 @@
+require 'rspec/autorun'
+require 'bricks_deploy/configuration'
+
+describe BricksDeploy::Configuration do
+
+  subject {
+    mod = described_class
+    obj = Object.new
+    opt = options
+    (class << obj; self; end).class_eval do
+      include mod
+      mod.private_instance_methods.each {|m| public m }
+      define_method(:options) { opt }
+    end
+    obj
+  }
+
+  let(:options) { {:remote => 'production'} }
+
+  def stub_git_config(cmd, value)
+    subject.git_config[cmd] = value
+  end
+
+  def stub_remote_url(url, remote = options[:remote])
+    stub_git_config("remote -v", "#{remote}\t#{url} (fetch)")
+  end
+
+  describe "extracting user/host from remote url" do
+    context "ssh url" do
+      before { stub_remote_url 'ssh://jon%20doe@example.com:88/path/to/app' }
+
+      its(:host)        { should eq('example.com') }
+      its(:remote_port) { should eq(88) }
+      its(:remote_user) { should eq('jon doe') }
+      its(:deploy_to)   { should eq('/path/to/app') }
+    end
+
+    context "scp-style" do
+      before { stub_remote_url 'git@example.com:/path/to/app' }
+
+      its(:host)        { should eq('example.com') }
+      its(:remote_port) { should be_nil }
+      its(:remote_user) { should eq('git') }
+      its(:deploy_to)   { should eq('/path/to/app') }
+    end
+
+    context "pushurl only" do
+      before {
+        remote = options.fetch(:remote)
+        url = 'git@example.com:/path/to/app'
+        stub_git_config("remote -v", "#{remote}\t\n#{remote}\t#{url} (push)")
+      }
+
+      its(:host)        { should eq('example.com') }
+      its(:remote_user) { should eq('git') }
+    end
+  end
+
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: bricks-deploy
+version: !ruby/object:Gem::Version
+  version: 0.6.2
+platform: ruby
+authors:
+- Mislav Marohnić
+- Helmut Hoffer von Ankershoffen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.14.6
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: A tool to install useful git hooks on your remote repository to enable
+  push-based, Heroku-like deployment on your host.
+email: hhva@20steps.de
+executables:
+- bricks-deploy
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.markdown
+- bin/bricks-deploy
+- lib/bricks_deploy.rb
+- lib/bricks_deploy/configuration.rb
+- lib/bricks_deploy/generator.rb
+- lib/bricks_deploy/ssh_methods.rb
+- lib/bricks_deploy/templates/after_push.sh
+- lib/bricks_deploy/templates/before_restart.rb
+- lib/bricks_deploy/templates/restart.sh
+- lib/hooks/post-receive.sh
+- spec/configuration_spec.rb
+homepage: https://github.com/20steps/bricks-deploy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.5
+signing_key: 
+specification_version: 4
+summary: Simple git push-based application deployment
+test_files: []