raygun 0.0.34 → 0.9.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6acc114771dba86c25780ea0592ea570d729882
-  data.tar.gz: 0d1fed637fb1f197c76fef2a8d128df8357f56cf
+  metadata.gz: 0bf921b19fb09a55ca908db00a86230db0f4c69e
+  data.tar.gz: b893b4c80c86b177ce3210b8c672aee415f07815
 SHA512:
-  metadata.gz: fa8b445c23966155b0f8e460ca2566850e52e20b9ce999caefb616e205d33a10d77f32b3efc8d7dce13498ed8fb6f984d7f11e83453cb888a813ef05a6252234
-  data.tar.gz: f3d9e02e425e0885d8721f55695cb5c6864f85f3c91803f618e4c20726f221b3d7b5c773cfb0e37b9f4d0a1d443bb8d5732231af351614614bf5e2d3df2a6104
+  metadata.gz: 71f32414520500f460adeafc9ecc9f7b630971422aa9348c2c1198e740fbb3fcc59fe3bf6e91bcb76b780208896838485e1c59bfeb6e45c3e0bf3683dc9abf94
+  data.tar.gz: bb2be3c6a4451baa90f40bcf9c07a8724ceff764a1cf4c4113a16c626f9e288972652c2adf3b5f45b82f239abd171462c6ee161cde24b50b460d8b7a9aa8b87b

data/.ruby-version

@@ -1 +1 @@
-ruby-2.0.0-p247
+2.0.0-p247

data/CHANGES.md

@@ -1,5 +1,11 @@
 # Change Log
 
+## 0.9.0 [2013-]
+
+* Raygun no longer bundles the application prototype, it's fetched from github (carbonfive/raygun-rails4) 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).
@@ -39,7 +45,7 @@
 * 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.

data/README.md

@@ -7,17 +7,15 @@
 Rails application generator that builds a new project skeleton configured with Carbon Five preferences and
 best practices baked right in. Spend less time configuring and more building cool features.
 
-Raygun generates Rails 4 projects by default. Use ```-r 32``` to generate a Rails 3.2 project.
+Raygun generates Rails 4 projects.
 
 Major tools/libraries:
 
-* Rails (4.0 or 3.2)
+* Rails 4.0
 * PostgreSQL
 * Slim
 * Less
 * Bootstrap
-* Sorcery (rails 3.2 projects only)
-* Cancan (rails 3.2 projects only)
 * RSpec
 * Factory Girl
 * Jasmine
@@ -29,7 +27,7 @@ Raygun includes generator templates for controllers, views, and specs so that ge
 practices. For example, view generation produces bootstrap compatible markup and rspec specs use factory
 girl when appropriate.
 
-Inspired by Xavier Shay and ThoughtBot's Suspenders. Thanks!
+Inspired by Xavier Shay work at Square and ThoughtBot's Suspenders. Thanks!
 
 ## Projects Goals
 
@@ -60,14 +58,12 @@ another ruby, just change the ```Gemfile``` and ```.ruby-version``` as necessary
 
     $ raygun your-project
 
-Try ```raygun -r 32 your-project``` to generate a Rails 3.2 project.
-
 Once your project is baked out, you can easily kick the wheels. Be sure that you have the prerequities
 covered (see above).
 
     $ cd your-project
     $ gem install bundler
-    $ bundle update
+    $ bundle
 
     # Prepare the database: schema and reference / sample data
     $ rake db:setup db:sample_data
@@ -81,9 +77,9 @@ covered (see above).
 
 ## Internal Mechanics
 
-Raygun simply copies the [rails_40](rails_40) (or [rails_32](rails_32)) tree and then runs a small set of
-commands to customize the copied project. So, what you get looks a lot like [rails_40](rails_40)
-([rails_32](rails_32)). Check out [raygun](bin/raygun) to see how it's massaged after being copied.
+Raygun simply copies the [rails_40](rails_40) tree and then runs a small set of commands to customize
+the copied project. So, what you get looks a lot like [rails_40](rails_40). Check out
+[raygun](bin/raygun) to see how it's massaged after being copied.
 
 This approach is fast, simple, and makes raygun developement very easy. Make changes to [rails_40](rails_40),
 run its specs and fire up the server to see what happens.

data/bin/raygun

@@ -4,191 +4,14 @@ File.expand_path('../../lib', __FILE__).tap do |lib|
   $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 end
 
-require 'optparse'
-require 'ostruct'
-require 'fileutils'
-require 'securerandom'
-require 'colorize'
-
-module Raygun
-  class Runner
-    attr_accessor :target_dir, :app_dir, :app_name, :dash_name, :snake_name, :camel_name, :title_name, :prototype
-
-    def initialize(target_dir, prototype)
-      @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  = prototype
-    end
-
-    def check_target
-      unless Dir["#{@app_dir}/*"].empty?
-        puts "Misfire! The target directory isn't empty... aim elsewhere."
-        exit 1
-      end
-    end
-
-    def copy_prototype
-      FileUtils.mkdir_p(app_dir)
-
-      Dir.glob(File.expand_path("../../#{@prototype}/*", __FILE__), File::FNM_DOTMATCH) do |f|
-        next if %w{. ..}.include?(File.basename(f))
-        FileUtils.cp_r(f, app_dir)
-      end
-    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
-      update_ruby_version
-      initialize_git
-    end
-
-    def update_ruby_version
-      prototype_ruby_patch_level  = File.read(File.expand_path("../../#{prototype}/.ruby-version", __FILE__)).strip
-      prototype_ruby_version      = prototype_ruby_patch_level.match(/(\d\.\d\.\d).*/)[1]
-      current_ruby_version        = RUBY_VERSION
-      current_ruby_patch_level    = "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
-
-      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.chdir(app_dir) do
-        shell 'git init'
-        shell 'git add -A .'
-        shell 'git commit -m "raygun-zapped skeleton"'
-      end
-    end
-
-    def print_plan
-
-      project_template = (prototype == 'rails_32') ? '3.2' : '4'
-
-      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 "Creating 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_reen)
-      puts "-".colorize(:blue) + " Project Template:".colorize(:light_blue) + " Rails #{project_template}".colorize(:light_reen)
-      puts "-".colorize(:blue) + " Ruby Version:    ".colorize(:light_blue) + " #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}".colorize(:light_reen)
-      puts
-    end
-
-    def print_next_steps
-      puts "Done! 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 update".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://0.0.0.0:3000".colorize(:light_blue)
-      puts ""
-      puts "Enjoy your Carbon Five flavored Rails application!".colorize(:yellow)
-    end
-
-    protected
-
-    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  = 'rails_40'
-
-      parser = OptionParser.new do |opts|
-        opts.banner = "Usage: raygun [options] NEW_APP_DIRECTORY"
-
-        opts.on('-h', '--help', "Show raygun usage") do |variable|
-          usage_and_exit(opts)
-        end
-
-        opts.on('-r', '--rails (32|40)', "Rails version, 32 for 3.2.x or 40 for 4.0.x") do |ext|
-          ext = '40' if ext == '4'
-          options.prototype = "rails_#{ext}"
-        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)
-
-      rescue OptionParser::InvalidOption
-        usage_and_exit(parser)
-      end
-
-      raygun
-    end
-
-    def self.usage_and_exit(parser)
-      puts parser
-      exit 1
-    end
-  end
-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

data/cleanup.sh

@@ -3,15 +3,10 @@
 # All git ignored files: git ls-files --others -i --exclude-standard
 
 git clean -df
-git checkout rails_32/config/routes.rb app_prototype/db/schema.rb
+git checkout rails_40/config/routes.rb app_prototype/db/schema.rb
 
 find . -name ".DS_Store" -exec rm -f {} \;
 
-rm -rfv rails_32/.DS_Store
-rm -rfv rails_32/log/*
-rm -rfv rails_32/tmp/*
-rm -rfv rails_32/coverage
-
 rm -rfv rails_40/.DS_Store
 rm -rfv rails_40/log/*
 rm -rfv rails_40/tmp/*

data/lib/raygun/raygun.rb

@@ -0,0 +1,238 @@
+require 'optparse'
+require 'ostruct'
+require 'fileutils'
+require 'securerandom'
+require 'net/http'
+require 'json'
+require 'colorize'
+
+require_relative 'version'
+
+module Raygun
+  class Runner
+    attr_accessor :target_dir, :app_dir, :app_name, :dash_name, :snake_name, :camel_name, :title_name, :prototype_repo
+
+    def initialize(target_dir, prototype_repo)
+      @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
+    end
+
+    def check_target
+      unless Dir["#{@app_dir}/*"].empty?
+        puts "Misfire! The target directory isn't empty... aim elsewhere."
+        exit 1
+      end
+    end
+
+    def fetch_prototype
+      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 = JSON.parse(Net::HTTP.get(URI("https://api.github.com/repos/#{@prototype_repo}/tags"))).first
+      latest_tag     = latest_tag_obj['name']
+      tarball_url    = latest_tag_obj['tarball_url']
+
+      print " #{latest_tag}.".colorize(:white)
+      $stdout.flush
+
+      cached_prototypes_dir = File.join(Dir.home, ".raygun")
+      @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 "wget -q #{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}"
+
+      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
+      update_ruby_version
+      initialize_git
+    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]
+      current_ruby_version       = RUBY_VERSION
+      current_ruby_patch_level   = "#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+
+      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.chdir(app_dir) do
+        shell "git init"
+        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 creating 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_reen)
+      puts "-".colorize(:blue) + " Project Template:".colorize(:light_blue) + " #{prototype_repo}".colorize(:light_reen)
+      puts "-".colorize(:blue) + " Ruby Version:    ".colorize(:light_blue) + " #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}".colorize(:light_reen)
+      puts
+    end
+
+    def print_next_steps
+      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://0.0.0.0:3000".colorize(:light_blue)
+      puts ""
+      puts "Enjoy your Carbon Five flavored Rails application!".colorize(:yellow)
+    end
+
+    protected
+
+    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/raygun-rails4'
+
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: raygun [options] NEW_APP_DIRECTORY"
+
+        opts.on('-h', '--help', "Show raygun usage") do |variable|
+          usage_and_exit(opts)
+        end
+        #opts.on('-p', '--prototype', "Prototype github repo (e.g. carbonfive/raygun).") do |prototype|
+        #  options.prototype_repo = prototype_repo
+        #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)
+
+      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

@@ -1,3 +1,3 @@
 module Raygun
-  VERSION = "0.0.34"
+  VERSION = "0.9.0.pre"
 end