raygun-gl 0.10.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8befec715f877059eebe18fe8c774b2726219dce
+  data.tar.gz: dbd5c72f9c8dadffc9eaac6d770ff62f27d1bbb3
+SHA512:
+  metadata.gz: e294778971ecc3792f8fd54f76980bd22855241d803c5cfb7a3e480d6bd0fe729676514893a0b2050936899b800c63906cf73891d6fab074eab5658171b4be37
+  data.tar.gz: 0dfd5f7b8d359109fab0bb21e137e7fa40a8de3ba392a3db6100b2a9895116eb31eeadb694f6f69d53a15cbd4ff05531439770dcec973c091f6dfb9be485a072

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+.local
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+tmp
+Vagrantfile
+.vagrant
+app/prototype/tmp
+app/prototype/log/*.log

data/.ruby-gemset

@@ -0,0 +1 @@
+raygun

data/.ruby-version

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

data/CHANGES.md

@@ -0,0 +1,149 @@
+# Change Log
+
+## 0.9.4 [2014-02-11]
+
+* Don't use patchlevels with ruby v2.1.0+, now that ruby has adopted semantic versioning.
+* Fixed a typo (#124 , thanks redpoptarts!).
+
+## 0.9.3 [2014-01-21]
+
+* Use curl instead of wget, it's available by default on mavericks (wget is not).
+
+## 0.9.2 [2013-12-03]
+
+* Support custom project templates with the -p command line arg (#122, thanks @drogar!).
+* Remove the stranded and useless .raygun-version from the generated app.
+* Rename the rails prototype repo to raygun-rails (#123).
+
+## 0.9.1 [2013-11-12]
+
+* Fixed a bug that fouled up fetching tags from github (#118).
+* Specify the license in the gemspec (#117).
+
+## 0.9.0 [2013-11-11]
+
+Note: All future changes to the application prototype (sample app) will be made in the [raygun-rails](https://github.com/carbonfive/raygun-rails) repo.
+
+* Raygun no longer bundles the application prototype, it's fetched from github (https://github.com/carbonfive/raygun-rails) instead (#112).
+* Drop support for Rails 3 (#116).
+* Better bootstrap 3 support (#115, thanks @felafelwaffle!).
+
+## 0.0.34 [2013-10-15]
+
+* Nudge bundler to use guard v2.x (defaults to 1.x otherwise).
+* Upgrade to bootstrap 3.0 (#114, thanks @drtoast!).
+* RSpec's rake task patterns use globs, and don't work with regular expressions as one might expect (#107, thanks @wless1!).
+* Include a deployment script for heroku and configuration for circleci for easy continuous deployment (#109, thanks @jonah-carbonfive!).
+
+## 0.0.33 [2013-07-08]
+
+* Raygun defaults to generating Rails 4 apps now (use -r 32 for Rails 3.2).
+* Incluide a recipe for rack-canonical-host (#105). Set ENV['HOSTNAME'] to enable.
+
+## 0.0.32 [2013-06-18]
+
+* Rails 4: enable guard-livereload with a tweak to support .less files.
+* Rails 4: enable guard-jasmine (with a sample spec).
+
+## 0.0.31 [2013-06-16]
+
+* For Heroku, default to serving static assets and the logger is synchronous by default (we don't have to set it) (#103).
+* Less duplication in acceptance.rb, since it's basicially the same as production.rb.
+* Fixed a regression where new apps might be configured with a non-existent ruby (#104).
+
+## 0.0.30 [2013-06-14]
+
+* Bug fix.
+
+## 0.0.29 [2013-06-14]
+
+* Migrate from ```.rvmrc``` to ```.ruby-version``` and ```.ruby-gemset``` (#93).
+* Use database_cleaner instead of the shared connection (#101).
+* Support generating rails 4.0 apps (beta!) using the ```-r 40``` command line flag.
+* Improve and colorize output (#86).
+
+## 0.0.28 [2013-03-26]
+
+* Use unicorn by default instead of thin, as per heroku's recommendation.
+* Suppress schema dumping unless run in development mode to eliminate pg_dump errors on heroku during db:migrate.
+* Tweak mailcatcher configuration so that it only sets smtp_settings when mailcatcher is running.
+ray
+## 0.0.27 [2013-02-27]
+
+* Make sure the target directory is empty, otherwise misfire.
+* Use ruby-1.9.3-p392 for the project (new apps still use the version that invoked raygun) (thanks @rpak).
+* Better detection of BSD vs GNU sed (thanks @orangejulius).
+
+## 0.0.26 [2013-02-24]
+
+* Validate presense of name on User.
+* Drop rspec and capybara version constraints from the Gemfile.
+
+## 0.0.25 [2013-02-20]
+
+* Generated controller specs now pass without intervention.
+* Generated view specs use factory_girl's build_stubbed instead of rspec's stub_model, expect() syntax, and 1.9 hash syntax.
+* Initialize git and create an initial commit (thanks @blakeeb).
+
+## 0.0.24 [2013-02-14]
+
+* Upgrade to ruby-1.9.3-p385 (thanks @mechfish).
+* Upgrade to rails ~> 3.2.12 (thanks @mechfish).
+* Pay attention to shelled command's exit status and bail with a message if a command fails.
+
+## 0.0.23 [2013-02-07]
+
+* Fixed a bug with detecting whether we're on darwin or not.
+* Remove some dead code (thanks @bemurphy).
+
+## 0.0.22 [2013-02-07]
+
+* Support ubuntu and darwin (sed has slightly different syntax for in-place substitution).
+* Take lib off the load path by default.
+
+## 0.0.21 [2013-02-01]
+
+* Turn off threadsafe when running rake tasks (thanks @subakva).
+
+## 0.0.20 [unreleased]
+
+* Bug fix and minor output tweak.
+
+## 0.0.19 [2013-01-29]
+
+* Pull the rails secret token from the environment so it can be easily set in server environments.
+* Dump the static index.html for a dynamic version.
+
+## 0.0.18 [2013-01-24]
+
+* Support generating an app in the current directory (thanks @subakva).
+* Better handling of command line arguments (thanks @subakva).
+* Include support for cane quality checks via ```rake spec:cane``` (thanks @subakva).
+
+## 0.0.17 [2013-01-17]
+
+* Configure .ruby-version, .rvmrc, and Gemfile with the version of ruby used to execute raygun.
+* Improve the default email content.
+* Improve the raygun and app_prototype READMEs.
+* Use $PORT to set the server port for Heroku compatibility, with default set in .env.
+* .ruby-version instead of .rbenv-version (as recommended by rbenv).
+* Add a unique database constraint on users.email.
+
+## 0.0.16 [2013-01-04]
+
+* Improved authorization rules so that users can't delete themselves and non-admin can't access users controller :new.
+
+## 0.0.15 [2012-12-26]
+
+* Handle cases where raygun is given a name with dashes (e.g wonder-pets).
+* Replace all instances of app_prototype with the real app name.
+
+## 0.0.14 [2012-12-26]
+
+* Basic usage information.
+* Added guard-livereload to Guardfile.
+* Better specs for auth flows (register, password reset, sign in) (~98% coverage).
+* Use the new rspec expect(...).to syntax ([more info](http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax)).
+* Hardcode 1.9.3-p327 so that app_prototype is executable without futzing.
+* Consistent hostnames across environments.
+* Use mailcatcher when it's running locally ([more info](http://www.mikeperham.com/2012/12/09/12-gems-of-christmas-4-mailcatcher-and-mail_view/)).

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Carbon Five
+
+MIT License
+
+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/NEXTSTEPS.taskpaper

@@ -0,0 +1,5 @@
+Next:
+	- open gitlab api
+
+Resources:
+ 

data/README.md

@@ -0,0 +1,86 @@
+[![Gem Version](https://badge.fury.io/rb/raygun-gl.png)](http://badge.fury.io/rb/raygun-gl)
+<img src="https://raw.github.com/lastobelus/raygun-gl/master/marvin.jpg" align="right"/>
+
+# Raygun GL
+
+Rails application generator that builds a new project skeleton from prototype app repos which can live either on github or a private gitlab instance.
+
+Raygun-gl generates Rails 4 projects by copying a sample app and massaging it gently into shape. It is a fork of https://github.com/carbonfive/raygun but does not supply an app prototype. Instead it allows you to use (your own) app prototype repos that are hosted either on github or a private gitlab instance. If you want to us Carbon Five's app prototype, raygun-gl does not provide any extra functionality over Carbon Five's original version (except for the `--embed_as` option)
+
+## Projects Goals
+
+Raygun GL...
+
+* Generates a new rails application that's ready for immediate feature development.
+* Generates an application that has YOUR best practices that apply to most projects baked in.
+
+## Installation
+
+    $ gem install raygun-gl
+
+## Prerequisites
+
+To generate an application, you only need the raygun-gl gem and network connectivity.
+
+The generated app will be configured to use the ruby version that was used to invoke raygun. If you're using
+another ruby, just change the ```Gemfile``` and ```.ruby-version``` as necessary.
+
+## Usage
+
+    $ raygun-gl your-project
+
+## Using  Project Template
+
+The default is to use the project at [carbonfive/raygun-rails](https://github.com/carbonfive/raygun-rails) as a
+starting point. You can use another repo as the project template with the ```-p```  and/or ```-g``` command line options.
+
+If you invoke raygun-gl with the ```-p``` option, you can specify your own github repository.
+
+    $ raygun -p githubid/repo your-project
+
+The repository must:
+
+* Not have any binary files. Raygun runs a 'sed' command on all files, which will fail on binaries, such as jar files.
+
+For github repos, the repository must have been tagged. Raygun chooses the "greatest" tag and downloads the repository as of that tag -- this is the original way the Carbon Five version. For gitlab repos you can (must) supply a ref (branch or tag) with `-r`
+
+If your project template requires a minimum version of raygun, include the version in a file called
+```.raygun-version``` at the root. Raygun will make sure it's new enough for your repo.
+
+If you want to use a project template that lives on a gitlab instance, invoke raygun-gl with the ```-g``` option or set the `GITLAB_API_ENDPOINT` environment variable to your gitlab instance url. Currently, you must also use the `-r` option to specify a ref (branch or tag). You must either set your private token in env `GITLAB_API_PRIVATE_TOKEN`,  or, if using OS X you can store it in your keychain in a generic password named `[gitlab endpoint host]-private-token`
+
+    $ raygun -g https://gitlab.mydomain.com -p gitlabid/repo -r v1.0.0 your-project
+
+## Embed As
+
+If the rails app you are generating is a part of another project (example: the backend in an Ember app), you can use the `--embed_as` option to specify what its directory should be called:
+
+    $ raygun -g https://gitlab.mydomain.com -p gitlabid/repo -r v1.0.0 -e rails /path/to/ember-project
+
+This example will generate a rails app in `/path/to/ember-project/rails`, creating `/path/to/ember-project` if it doesn't exist, and doing `git init` in `/path/to/ember-project` **IF** `/path/to/ember-projec/.git` doesn't already exist before committing the generated app.
+
+## Internal Mechanics
+
+Raygun fetches the greatest tag from the [carbonfive/raygun-rails](https://github.com/carbonfive/raygun-rails)
+repo, or the specified branch/tag from the specified repo, unless it already has it cached in ~/.raygun, extracts the contents of the tarball, and runs a series of search-and-replaces on the code to customize it accordingly.
+
+This approach is fast, simple, and makes raygun development very easy. Make changes to the application
+prototype (which is a valid rails app) and tag them when they should be used for new applications.
+
+## Contributing
+
+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
+
+### Development
+
+Generate an example app using your local development version of raygun-gl:
+
+    $ ./bin/raygun-gl tmp/example_app
+
+## Changes
+
+[View the Change Log](https://github.com/lastobelus/raygun-gl/tree/master/CHANGES.md)

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/raygun

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+File.expand_path('../../lib', __FILE__).tap do |lib|
+  $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+end
+
+require 'raygun/raygun'
+
+raygun = Raygun::Runner.parse(ARGV)
+
+raygun.check_target
+raygun.print_plan
+raygun.fetch_prototype
+raygun.check_raygun_version
+raygun.copy_prototype
+raygun.rename_new_app
+raygun.configure_new_app
+raygun.print_next_steps

data/lib/colorize.rb

@@ -0,0 +1,194 @@
+#
+# Colorize String class extension.
+#
+# Borrowed directly from the colorize gem. It hasn't changed in 4 years and I didn't
+# want to add a gem dependency.
+
+class String
+
+  #
+  # Colors Hash
+  #
+  COLORS = {
+    :black          => 0,
+    :red            => 1,
+    :green          => 2,
+    :yellow         => 3,
+    :blue           => 4,
+    :magenta        => 5,
+    :cyan           => 6,
+    :white          => 7,
+    :default        => 9,
+
+    :light_black    => 10,
+    :light_red      => 11,
+    :light_green    => 12,
+    :light_yellow   => 13,
+    :light_blue     => 14,
+    :light_magenta  => 15,
+    :light_cyan     => 16,
+    :light_white    => 17
+  }
+
+  #
+  # Modes Hash
+  #
+  MODES = {
+    :default        => 0, # Turn off all attributes
+    #:bright        => 1, # Set bright mode
+    :underline      => 4, # Set underline mode
+    :blink          => 5, # Set blink mode
+    :swap           => 7, # Exchange foreground and background colors
+    :hide           => 8  # Hide text (foreground color would be the same as background)
+  }
+
+  protected
+
+  #
+  # Set color values in new string intance
+  #
+  def set_color_parameters( params )
+    if (params.instance_of?(Hash))
+      @color = params[:color]
+      @background = params[:background]
+      @mode = params[:mode]
+      @uncolorized = params[:uncolorized]
+      self
+    else
+      nil
+    end
+  end
+
+  public
+
+  #
+  # Change color of string
+  #
+  # Examples:
+  #
+  #   puts "This is blue".colorize( :blue )
+  #   puts "This is light blue".colorize( :light_blue )
+  #   puts "This is also blue".colorize( :color => :blue )
+  #   puts "This is light blue with red background".colorize( :color => :light_blue, :background => :red )
+  #   puts "This is light blue with red background".colorize( :light_blue ).colorize( :background => :red )
+  #   puts "This is blue text on red".blue.on_red
+  #   puts "This is red on blue".colorize( :red ).on_blue
+  #   puts "This is red on blue and underline".colorize( :red ).on_blue.underline
+  #   puts "This is blue text on red".blue.on_red.blink
+  #   puts "This is uncolorized".blue.on_red.uncolorize
+  #
+  def colorize( params )
+    return self unless STDOUT.isatty
+
+    begin
+      require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
+    rescue LoadError
+      raise 'You must gem install win32console to use colorize on Windows'
+    end
+
+    color_parameters = {}
+
+    if (params.instance_of?(Hash))
+      color_parameters[:color] = COLORS[params[:color]]
+      color_parameters[:background] = COLORS[params[:background]]
+      color_parameters[:mode] = MODES[params[:mode]]
+    elsif (params.instance_of?(Symbol))
+      color_parameters[:color] = COLORS[params]
+    end
+
+    color_parameters[:color] ||= @color ||= COLORS[:default]
+    color_parameters[:background] ||= @background ||= COLORS[:default]
+    color_parameters[:mode] ||= @mode ||= MODES[:default]
+
+    color_parameters[:uncolorized] ||= @uncolorized ||= self.dup
+
+    # calculate bright mode
+    color_parameters[:color] += 50 if color_parameters[:color] > 10
+
+    color_parameters[:background] += 50 if color_parameters[:background] > 10
+
+    "\033[#{color_parameters[:mode]};#{color_parameters[:color]+30};#{color_parameters[:background]+40}m#{color_parameters[:uncolorized]}\033[0m".set_color_parameters( color_parameters )
+  end
+
+  #
+  # Return uncolorized string
+  #
+  def uncolorize
+    @uncolorized || self
+  end
+
+  #
+  # Return true if sting is colorized
+  #
+  def colorized?
+    !defined?(@uncolorized).nil?
+  end
+
+  #
+  # Make some color and on_color methods
+  #
+  COLORS.each_key do | key |
+    next if key == :default
+
+    define_method key do
+      self.colorize( :color => key )
+    end
+
+    define_method "on_#{key}" do
+      self.colorize( :background => key )
+    end
+  end
+
+  #
+  # Methods for modes
+  #
+  MODES.each_key do | key |
+    next if key == :default
+
+    define_method key do
+      self.colorize( :mode => key )
+    end
+  end
+
+  class << self
+
+    #
+    # Return array of available modes used by colorize method
+    #
+    def modes
+      keys = []
+      MODES.each_key do | key |
+        keys << key
+      end
+      keys
+    end
+
+    #
+    # Return array of available colors used by colorize method
+    #
+    def colors
+      keys = []
+      COLORS.each_key do | key |
+        keys << key
+      end
+      keys
+    end
+
+    #
+    # Display color matrix with color names.
+    #
+    def color_matrix( txt = "[X]" )
+      size = String.colors.length
+      String.colors.each do | color |
+        String.colors.each do | back |
+          print txt.colorize( :color => color, :background => back )
+        end
+        puts " < #{color}"
+      end
+      String.colors.reverse.each_with_index do | back, index |
+        puts "#{"|".rjust(txt.length)*(size-index)} < #{back}"
+      end
+      ""
+    end
+  end
+end

data/lib/raygun/gitlab_client.rb

@@ -0,0 +1,24 @@
+require 'gitlab'
+
+module Raygun
+  class GitlabClient
+
+    attr_accessor :uri, :endpoint, :token
+    def initialize(endpoint)
+      @endpoint = URI.parse(endpoint)
+      @token = ENV['GITLAB_API_PRIVATE_TOKEN']
+      unless `which security`.empty?
+        cmd = "security 2>&1 >/dev/null find-generic-password -g -l#{@endpoint.host}-private-token"
+        @token ||= `#{cmd}`.gsub(/password: *"([^"]+)"\n/, '\1')
+      end
+      Gitlab.configure do |config|
+        config.endpoint       = endpoint
+        config.private_token  = @token
+      end
+    end
+    
+    def domain
+      endpoint.host
+    end
+  end
+end

data/lib/raygun/raygun.rb

@@ -0,0 +1,413 @@
+require 'optparse'
+require 'ostruct'
+require 'fileutils'
+require 'securerandom'
+require 'net/http'
+require 'json'
+require 'colorize'
+
+require_relative 'version'
+require_relative 'gitlab_client'
+
+module Raygun
+  class Runner
+    CARBONFIVE_REPO = 'carbonfive/raygun-rails'
+
+    attr_accessor :target_dir, :app_dir, :app_name, :dash_name, :snake_name, :camel_name, :title_name, :prototype_repo,
+                  :gitlab_endpoint, :ref, :embed_as, :current_ruby_version, :current_ruby_patch_level
+
+    def initialize(target_dir, prototype_repo, gitlab_endpoint, ref, embed_as)
+      @target_dir     = target_dir
+      @app_dir        = File.expand_path(target_dir.strip.to_s)
+      @app_name       = File.basename(app_dir).gsub(/\s+/, '-')
+      @dash_name      = app_name.gsub('_', '-')
+      @snake_name     = app_name.gsub('-', '_')
+      @camel_name     = camelize(snake_name)
+      @title_name     = titleize(snake_name)
+      @prototype_repo = prototype_repo
+      @gitlab_endpoint = gitlab_endpoint
+      @ref = ref
+      @embed_as = embed_as
+      if embed_as
+        FileUtils.mkdir_p(app_dir) unless File.exist?(app_dir)
+        @app_dir = File.join(app_dir, embed_as)
+      end
+      
+      @current_ruby_version     = RUBY_VERSION
+      @current_ruby_patch_level = if RUBY_VERSION < '2.1.0' # Ruby adopted semver starting with 2.1.0.
+                                   "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+                                  else
+                                    "#{RUBY_VERSION}"
+                                  end
+    end
+
+    def check_target
+      unless Dir["#{@app_dir}/*"].empty?
+        puts "Misfire! The target directory isn't empty... aim elsewhere."
+        exit 1
+      end
+    end
+
+
+    def gitlab?
+      !!@gitlab_endpoint
+    end
+    
+    def gitlab_client
+      @gitlab_client ||= GitlabClient.new(gitlab_endpoint)
+    end
+    
+    def gitlab_project_id
+      @gitlab_project_id ||= parse_gitlab_project_id
+    end
+    
+    def parse_gitlab_project_id
+      if prototype_repo.to_i == prototype_repo
+        prototype_repo
+      else
+        
+      end
+    end
+    
+    def fetch_prototype
+      if gitlab?
+        fetch_prototype_from_gitlab
+      else
+        fetch_prototype_from_github
+      end
+    end
+
+    def cached_prototypes_dir; File.join(Dir.home, ".raygun"); end
+    
+    def fetch_prototype_from_gitlab
+      print "Checking for the latest application prototype on gitlab...".colorize(:yellow)
+      $stdout.flush
+      
+      latest_tag = ref || fetch_latest_tag_gitlab(prototype_repo)
+      
+      gitlab_cached_prototypes_dir = File.join(cached_prototypes_dir, gitlab_client.domain)
+      @prototype = File.join(gitlab_cached_prototypes_dir, "#{prototype_repo.sub('/', '--')}-#{latest_tag}.tar.gz")
+      
+      
+
+      if File.exists?(@prototype)
+        puts " Using cached version.".colorize(:yellow)
+      else
+        print " Downloading...".colorize(:yellow)
+        $stdout.flush
+
+        # Download the tarball and install in the cache.
+        Dir.mkdir(gitlab_cached_prototypes_dir, 0755) unless Dir.exists?(gitlab_cached_prototypes_dir)
+        tarball_url = URI([gitlab_endpoint, prototype_repo, "repository", "archive.tar.gz"].join('/'))
+        tarball_url.query = URI.encode_www_form(private_token: gitlab_client.token, ref: latest_tag)
+
+        shell "curl -s -L '#{tarball_url.to_s}' -o #{@prototype}"
+        puts " done!".colorize(:yellow)
+      end
+      
+      $stdout.flush
+    end
+    
+    
+    def fetch_prototype_from_github
+      print "Checking for the latest application prototype...".colorize(:yellow)
+      $stdout.flush
+
+      # Check if we can connect, or fail gracefully and use the latest cached version.
+      latest_tag_obj = fetch_latest_tag(prototype_repo)
+      latest_tag     = latest_tag_obj['name']
+      tarball_url    = latest_tag_obj['tarball_url']
+
+      print " #{latest_tag}.".colorize(:white)
+      $stdout.flush
+
+      @prototype = "#{cached_prototypes_dir}/#{prototype_repo.sub('/', '--')}-#{latest_tag}.tar.gz"
+
+      # Do we already have the tarball cached under ~/.raygun?
+      if File.exists?(@prototype)
+        puts " Using cached version.".colorize(:yellow)
+      else
+        print " Downloading...".colorize(:yellow)
+        $stdout.flush
+
+        # Download the tarball and install in the cache.
+        Dir.mkdir(cached_prototypes_dir, 0755) unless Dir.exists?(cached_prototypes_dir)
+
+        shell "curl -s -L #{tarball_url} -o #{@prototype}"
+        puts " done!".colorize(:yellow)
+      end
+    end
+
+    def check_raygun_version
+      required_raygun_version =
+        %x{tar xfz #{@prototype} --include "*.raygun-version" -O 2> /dev/null}.chomp ||
+          ::Raygun::VERSION
+
+      if Gem::Version.new(required_raygun_version) > Gem::Version.new(::Raygun::VERSION)
+        puts  ""
+        print "Hold up!".colorize(:red)
+        print " This version of the raygun gem (".colorize(:light_red)
+        print "#{::Raygun::VERSION})".colorize(:white)
+        print " is too old to generate this application (needs ".colorize(:light_red)
+        print "#{required_raygun_version}".colorize(:white)
+        puts  " or newer).".colorize(:light_red)
+        puts  ""
+        print "Please update the gem by running ".colorize(:light_red)
+        print "gem update raygun".colorize(:white)
+        puts  ", and try again. Thanks!".colorize(:light_red)
+        puts  ""
+        exit 1
+      end
+    end
+
+    def copy_prototype
+      FileUtils.mkdir_p(app_dir)
+
+      shell "tar xfz #{@prototype} -C #{app_dir}"
+
+      # Github includes an extra directory layer in the tag tarball.
+      extraneous_dir = Dir.glob("#{app_dir}/*").first
+      dirs_to_move   = Dir.glob("#{extraneous_dir}/*", File::FNM_DOTMATCH)
+                          .reject { |d| %w{. ..}.include?(File.basename(d)) }
+
+      FileUtils.mv         dirs_to_move, app_dir
+      FileUtils.remove_dir extraneous_dir
+    end
+
+    def rename_new_app
+      Dir.chdir(app_dir) do
+        {
+          'AppPrototype'  => camel_name,
+          'app-prototype' => dash_name,
+          'app_prototype' => snake_name,
+          'App Prototype' => title_name
+        }.each do |proto_name, new_name|
+          shell "find . -type f -print | xargs #{sed_i} 's/#{proto_name}/#{new_name}/g'"
+        end
+      end
+    end
+
+    def configure_new_app
+      clean_up_unwanted_files
+
+      update_ruby_version
+
+      initialize_git
+    end
+
+    def clean_up_unwanted_files
+      FileUtils.rm "#{app_dir}/.raygun-version", force: true
+    end
+
+    def update_ruby_version
+      prototype_ruby_patch_level = File.read(File.expand_path("#{app_dir}/.ruby-version", __FILE__)).strip
+      prototype_ruby_version     = prototype_ruby_patch_level.match(/(\d\.\d\.\d).*/)[1]
+
+      Dir.chdir(app_dir) do
+        shell "#{sed_i} 's/#{prototype_ruby_patch_level}/#{@current_ruby_patch_level}/g' .ruby-version README.md"
+        shell "#{sed_i} 's/#{prototype_ruby_version}/#{@current_ruby_version}/g' Gemfile"
+      end
+    end
+
+    def initialize_git
+      dir = app_dir
+      dir = File.join(dir, '..') if embed_as
+      Dir.chdir(dir) do
+        shell "git init" unless (embed_as && File.exist?('.git'))
+        shell "git add -A ."
+        shell "git commit -m 'Raygun-zapped skeleton.'"
+      end
+    end
+
+    def print_plan
+      puts '     ____ '.colorize(:light_yellow)
+      puts '    / __ \____ ___  ______ ___  ______ '.colorize(:light_yellow)
+      puts '   / /_/ / __ `/ / / / __ `/ / / / __ \ '.colorize(:light_yellow)
+      puts '  / _, _/ /_/ / /_/ / /_/ / /_/ / / / / '.colorize(:light_yellow)
+      puts ' /_/ |_|\__,_/\__, /\__, /\__,_/_/ /_/ '.colorize(:light_yellow)
+      puts '             /____//____/ '.colorize(:light_yellow)
+      puts
+      puts "Raygun will create new app in directory:".colorize(:yellow) + " #{target_dir}".colorize(:yellow) + "...".colorize(:yellow)
+      puts
+      puts "-".colorize(:blue) +   " Application Name:".colorize(:light_blue) + " #{title_name}".colorize(:light_green)
+      if gitlab?
+        puts "-".colorize(:blue) + " Gitlab Endpoint: ".colorize(:light_blue) + " #{gitlab_endpoint}".colorize(:light_green)
+      end
+      puts "-".colorize(:blue) +   " Project Template:".colorize(:light_blue) + " #{prototype_repo}".colorize(:light_green)
+      if ref
+        puts "-".colorize(:blue) + " Branch/Tag:      ".colorize(:light_blue) + " #{ref}".colorize(:light_green)
+      end
+      if embed_as
+        puts "-".colorize(:blue) + " Embed as:        ".colorize(:light_blue) + " #{embed_as}".colorize(:light_green)
+      end
+      puts "-".colorize(:blue) +   " Ruby Version:    ".colorize(:light_blue) + " #{@current_ruby_patch_level}".colorize(:light_green)
+      puts
+    end
+
+    def print_next_steps
+      if @prototype_repo == CARBONFIVE_REPO
+        print_next_steps_carbon_five
+      else
+        print_next_steps_for_custom_repo
+      end
+    end
+    
+    def print_next_steps_carbon_five
+      puts ""
+      puts "Zap! Your application is ready. Next steps...".colorize(:yellow)
+      puts ""
+      puts "# Install updated dependencies".colorize(:light_green)
+      puts "$".colorize(:blue) + " cd #{target_dir}".colorize(:light_blue)
+      puts "$".colorize(:blue) + " gem install bundler".colorize(:light_blue)
+      puts "$".colorize(:blue) + " bundle".colorize(:light_blue)
+      puts ""
+      puts "# Prepare the database: schema and reference / sample data".colorize(:light_green)
+      puts "$".colorize(:blue) + " rake db:setup db:sample_data".colorize(:light_blue)
+      puts ""
+      puts "# Run the specs (they should all pass)".colorize(:light_green)
+      puts "$".colorize(:blue) + " rake".colorize(:light_blue)
+      puts ""
+      puts "# Run the app and check things out".colorize(:light_green)
+      puts "$".colorize(:blue) + " foreman start".colorize(:light_blue)
+      puts "$".colorize(:blue) + " open http://localhost:3000".colorize(:light_blue)
+      puts ""
+      puts "Enjoy your Carbon Five flavored Rails application!".colorize(:yellow)
+    end
+    
+    def print_next_steps_for_custom_repo
+      puts ""
+      puts "Zap! Your application is ready.".colorize(:yellow)
+      puts ""
+      puts "Enjoy your raygun generated application!".colorize(:yellow)
+    end
+
+    protected
+
+    
+    # Fetch the tags for the repo (e.g. 'carbonfive/raygun-rails') and return the latest as JSON.
+    def fetch_latest_tag(repo)
+      url          = "https://api.github.com/repos/#{repo}/tags"
+      uri          = URI.parse(url)
+      http         = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      request      = Net::HTTP::Get.new(URI.encode(url))
+
+      response     = http.request(request)
+
+      unless response.code == "200" 
+        puts  ""
+        print "Whoops - need to try again!".colorize(:red)
+        puts  ""
+        print "We could not find (".colorize(:light_red)
+        print "#{repo}".colorize(:white)
+        print ") on github.".colorize(:light_red)
+        puts  ""
+        print "The response from github was a (".colorize(:light_red)
+        print "#{response.code}".colorize(:white)
+        puts  ") which I'm sure you can fix right up!".colorize(:light_red)
+        puts  ""
+        exit 1
+      end
+
+      result = JSON.parse(response.body).first
+      unless result
+        puts  ""
+        print "Whoops - need to try again!".colorize(:red)
+        puts  ""
+        print "We could not find any tags in the repo (".colorize(:light_red)
+        print "#{repo}".colorize(:white)
+        print ") on github.".colorize(:light_red)
+        puts  ""
+        print "Raygun uses the 'largest' tag in a repository, where tags are sorted alphanumerically.".colorize(:light_red)
+        puts  ""
+        print "E.g., tag 'v.0.10.0' > 'v.0.9.9' and 'x' > 'a'.".colorize(:light_red)
+        print ""
+        puts  ""
+        exit 1
+      end
+      
+      result
+    end
+
+    def fetch_latest_tag_gitlab(repo)
+      puts "latest tag not implemented. Please supply a ref with -r".colorize(:red)
+      exit 1
+    end
+    
+    def camelize(string)
+      result = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      result.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }
+    end
+
+    def titleize(underscored_string)
+      result = underscored_string.gsub(/_/, ' ')
+      result.gsub(/\b('?[a-z])/) { $1.capitalize }
+    end
+
+    # Distinguish BSD vs GNU sed with the --version flag (only present in GNU sed).
+    def sed_i
+      @sed_format ||= begin
+        %x{sed --version &> /dev/null}
+        $?.success? ? "sed -i" : "sed -i ''"
+      end
+    end
+
+    # Run a shell command and raise an exception if it fails.
+    def shell(command)
+      %x{#{command}}
+      raise "#{command} failed with status #{$?.exitstatus}." unless $?.success?
+    end
+
+    def self.parse(args)
+      raygun = nil
+
+      options = OpenStruct.new
+      options.target_dir     = nil
+      options.prototype_repo = CARBONFIVE_REPO
+      options.gitlab_endpoint = nil
+
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: raygun [options] NEW_APP_DIRECTORY"
+
+        opts.on('-h', '--help', "Show raygun usage") do
+          usage_and_exit(opts)
+        end
+        opts.on('-p', '--prototype [github_repo]', "Prototype github repo (e.g. carbonfive/raygun-rails).") do |prototype|
+          options.prototype_repo = prototype
+        end
+        opts.on('-g', '--gitlab [gitlab_endpoint]', "Gitlab instance where the prototype repo can be found.") do |gitlab|
+          gitlab ||= ENV['GITLAB_API_ENDPOINT']
+          if gitlab.nil? || gitlab.empty?
+            raise "--gitlab specified with no endpoint and $GITLAB_API_ENDPOINT was empty"
+          end
+          options.gitlab_endpoint = gitlab
+        end
+        opts.on('-r', '--ref [branch-or-tag]', "Git ref on prototype-repo (defaults to 'greatest' tag).") do |ref|
+          options.ref = ref
+        end
+        opts.on('-e', '--embed [sub-dir-name]', "App is sub-dir in existing project.") do |embed_as|
+          options.embed_as = embed_as
+        end
+      end
+
+      begin
+        parser.parse!
+        options.target_dir = ARGV.first
+
+        raise OptionParser::InvalidOption if options.target_dir.nil?
+
+        raygun = Raygun::Runner.new(options.target_dir, options.prototype_repo, options.gitlab_endpoint, options.ref, options.embed_as)
+
+      rescue OptionParser::InvalidOption
+        usage_and_exit(parser)
+      end
+
+      raygun
+    end
+
+    def self.usage_and_exit(parser)
+      puts parser
+      exit 1
+    end
+  end
+end

data/lib/raygun/version.rb

@@ -0,0 +1,3 @@
+module Raygun
+  VERSION = "0.10.1"
+end

data/raygun.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+File.expand_path('../lib', __FILE__).tap do |lib|
+  $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+end
+
+require 'raygun/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "raygun-gl"
+  gem.version       = Raygun::VERSION
+  gem.authors       = ["Christian Nelson", "Jonah Williams", "Jason Wadsworth", "Michael Johnston"]
+  gem.email         = ["lastobelus@gmail.com"]
+  gem.description   = %q{Rails application generator}
+  gem.summary       = %q{Generates and customizes Rails applications from prototype repos which can live either on github or on private gitlab instances.}
+  gem.homepage      = "https://github.com/lastobelus/raygun-gl"
+  gem.license       = 'MIT'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency "gitlab", "~> 3"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "awesome_print"
+  gem.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: raygun-gl
+version: !ruby/object:Gem::Version
+  version: 0.10.1
+platform: ruby
+authors:
+- Christian Nelson
+- Jonah Williams
+- Jason Wadsworth
+- Michael Johnston
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gitlab
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !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: awesome_print
+  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: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rails application generator
+email:
+- lastobelus@gmail.com
+executables:
+- raygun
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- CHANGES.md
+- Gemfile
+- LICENSE.txt
+- NEXTSTEPS.taskpaper
+- README.md
+- Rakefile
+- bin/raygun
+- lib/colorize.rb
+- lib/raygun/gitlab_client.rb
+- lib/raygun/raygun.rb
+- lib/raygun/version.rb
+- marvin.jpg
+- raygun.gemspec
+homepage: https://github.com/lastobelus/raygun-gl
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Generates and customizes Rails applications from prototype repos which can
+  live either on github or on private gitlab instances.
+test_files: []