raygun 1.0.0 → 1.1.0

data/lib/raygun/raygun.rb

@@ -1,43 +1,47 @@
-require 'optparse'
-require 'ostruct'
-require 'fileutils'
-require 'securerandom'
-require 'net/http'
-require 'json'
-require 'colorize'
-
-require_relative 'version'
+require "optparse"
+require "ostruct"
+require "fileutils"
+require "securerandom"
+require "net/http"
+require "open-uri"
+require "json"
+require "colorize"
+
+require_relative "version"
+require_relative "template_repo"
 
 module Raygun
   class Runner
-    CARBONFIVE_REPO = 'carbonfive/raygun-rails'
+    CARBONFIVE_REPO = "carbonfive/raygun-rails"
+    C5_CONVENTIONS_REPO = "carbonfive/c5-conventions"
 
-    attr_accessor :target_dir, :app_dir, :app_name, :dash_name, :snake_name, :camel_name, :title_name, :prototype_repo,
+    attr_accessor :target_dir, :app_dir, :app_name, :dash_name, :snake_name,
+                  :camel_name, :title_name, :prototype_repo,
                   :current_ruby_version, :current_ruby_patch_level
 
     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('-', '_')
+      @app_name       = File.basename(app_dir).gsub(/\s+/, "-")
+      @dash_name      = app_name.tr("_", "-")
+      @snake_name     = app_name.tr("-", "_")
       @camel_name     = camelize(snake_name)
       @title_name     = titleize(snake_name)
       @prototype_repo = prototype_repo
 
       @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}"
+      @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}"
+                                    RUBY_VERSION.to_s
                                   end
     end
 
     def check_target
-      unless Dir["#{@app_dir}/*"].empty?
-        puts "Misfire! The target directory isn't empty... aim elsewhere."
-        exit 1
-      end
+      return if Dir["#{@app_dir}/*"].empty?
+
+      puts "Misfire! The target directory isn't empty... aim elsewhere.".colorize(:light_red)
+      exit 1
     end
 
     def fetch_prototype
@@ -45,26 +49,26 @@ module Raygun
       $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']
+      repo        = TemplateRepo.new(prototype_repo)
+      name        = repo.name
+      tarball_url = repo.tarball
+      sha         = repo.sha
 
-      print " #{latest_tag}.".colorize(:white)
+      print " #{name}.".colorize(:white)
       $stdout.flush
 
       cached_prototypes_dir = File.join(Dir.home, ".raygun")
-      @prototype = "#{cached_prototypes_dir}/#{prototype_repo.sub('/', '--')}-#{latest_tag}.tar.gz"
+      @prototype = "#{cached_prototypes_dir}/#{name.gsub("/", "--")}-#{sha}.tar.gz"
 
       # Do we already have the tarball cached under ~/.raygun?
-      if File.exists?(@prototype)
+      if File.exist?(@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)
-
+        Dir.mkdir(cached_prototypes_dir, 0o755) unless Dir.exist?(cached_prototypes_dir)
         shell "curl -s -L #{tarball_url} -o #{@prototype}"
         puts " done!".colorize(:yellow)
       end
@@ -72,50 +76,56 @@ module Raygun
 
     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
+        `tar xfz #{@prototype} --include "*.raygun-version" -O 2> /dev/null`.chomp ||
+        ::Raygun::VERSION
+      return unless 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.to_s.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
 
     def copy_prototype
       FileUtils.mkdir_p(app_dir)
 
-      shell "tar xfz #{@prototype} -C #{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)) }
+        .reject { |d| %w[. ..].include?(File.basename(d)) }
 
       FileUtils.mv         dirs_to_move, app_dir
       FileUtils.remove_dir extraneous_dir
+
+      fetch_rubocop_file if @prototype_repo == CARBONFIVE_REPO
     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
+          "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
+
+        %w[d f].each do |find_type|
+          shell "find . -depth -type #{find_type} -name '*app_prototype*' " \
+                "-exec bash -c 'mv $0 ${0/app_prototype/#{snake_name}}' {} \\;"
+        end
       end
     end
 
@@ -144,26 +154,33 @@ module Raygun
     def initialize_git
       Dir.chdir(app_dir) do
         shell "git init"
+        shell "git checkout -q -b main"
         shell "git add -A ."
         shell "git commit -m 'Raygun-zapped skeleton.'"
       end
     end
 
+    # rubocop:disable Metrics/AbcSize
     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 ' /_/ |_|\__,_/\__, /\__, /\__,_/_/ /_/ '.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 "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_reen)
-      puts "-".colorize(:blue) + " Project Template:".colorize(:light_blue) + " #{prototype_repo}".colorize(:light_reen)
-      puts "-".colorize(:blue) + " Ruby Version:    ".colorize(:light_blue) + " #{@current_ruby_patch_level}".colorize(:light_reen)
+      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) +
+           " #{@current_ruby_patch_level}".colorize(:light_reen)
       puts
     end
+    # rubocop:enable Metrics/AbcSize
 
     def print_next_steps
       if @prototype_repo == CARBONFIVE_REPO
@@ -172,29 +189,30 @@ module Raygun
         print_next_steps_for_custom_repo
       end
     end
-    
+
+    # rubocop:disable Metrics/AbcSize
     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 "# Install updated dependencies and prepare the database".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 "$".colorize(:blue) + " bin/setup".colorize(:light_blue)
       puts ""
       puts "# Run the specs (they should all pass)".colorize(:light_green)
-      puts "$".colorize(:blue) + " rake".colorize(:light_blue)
+      puts "$".colorize(:blue) + " bin/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) + " heroku local".colorize(:light_blue)
       puts "$".colorize(:blue) + " open http://localhost:3000".colorize(:light_blue)
       puts ""
+      puts "# For some suggested next steps, check out the raygun README".colorize(:light_green)
+      puts "$".colorize(:blue) + " open https://github.com/carbonfive/raygun/#next-steps".colorize(:light_blue)
+      puts ""
       puts "Enjoy your Carbon Five flavored Rails application!".colorize(:yellow)
     end
-    
+    # rubocop:enable Metrics/AbcSize
+
     def print_next_steps_for_custom_repo
       puts ""
       puts "Zap! Your application is ready.".colorize(:yellow)
@@ -204,111 +222,104 @@ module Raygun
 
     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
+    def fetch_rubocop_file
+      sha = shell("git ls-remote https://github.com/#{C5_CONVENTIONS_REPO} master") || ""
+      sha = sha.slice(0..6)
 
-      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
+      rubocop_file = "https://raw.githubusercontent.com/#{C5_CONVENTIONS_REPO}/master/rubocop/rubocop.yml"
+      begin
+        rubocop_contents = URI.open(rubocop_file)
+        IO.write("#{@app_dir}/.rubocop.yml", <<~RUBOCOP_YML)
+          # Sourced from #{C5_CONVENTIONS_REPO} @ #{sha}
+          #
+          # If you make changes to this file, consider opening
+          # a PR to backport them to the c5-conventions repo:
+          # https://github.com/#{C5_CONVENTIONS_REPO}/blob/master/rubocop/rubocop.yml
+
+          #{rubocop_contents.string}
+        RUBOCOP_YML
+      rescue Errno::ENOENT, OpenURI::HTTPError => e
+        puts ""
+        puts "Failed to find the CarbonFive conventions rubocop file at #{rubocop_file}".colorize(:light_red)
+        puts "Error: #{e}".colorize(:light_red)
+        puts "You'll have to manage you're own `.rubocop.yml` setup".colorize(:light_red)
       end
-      
-      result
     end
 
     def camelize(string)
       result = string.sub(/^[a-z\d]*/) { $&.capitalize }
-      result.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }
+      result.gsub(%r{(?:_|(/))([a-z\d]*)}) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
     end
 
     def titleize(underscored_string)
-      result = underscored_string.gsub(/_/, ' ')
-      result.gsub(/\b('?[a-z])/) { $1.capitalize }
+      result = underscored_string.tr("_", " ")
+      result.gsub(/\b('?[a-z])/) { Regexp.last_match(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
+      @sed_i ||= begin
+                   `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}}
+      output = `#{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
-
-      parser = OptionParser.new do |opts|
-        opts.banner = "Usage: raygun [options] NEW_APP_DIRECTORY"
+      output
+    end
 
-        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
+    class << self
+      # rubocop:disable Metrics/MethodLength
+      def parse(_args)
+        raygun = nil
+
+        options = OpenStruct.new
+        options.target_dir     = nil
+        options.prototype_repo = CARBONFIVE_REPO
+
+        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("-v", "--version", "Print the version number") do
+            puts Raygun::VERSION
+            exit 1
+          end
         end
-      end
 
-      begin
-        parser.parse!
-        options.target_dir = ARGV.first
+        begin
+          parser.parse!
+          options.target_dir = ARGV.first
 
-        raise OptionParser::InvalidOption if options.target_dir.nil?
+          raise OptionParser::InvalidOption if options.target_dir.nil?
 
-        raygun = Raygun::Runner.new(options.target_dir, options.prototype_repo)
+          raygun = Raygun::Runner.new(options.target_dir, options.prototype_repo)
+        rescue OptionParser::InvalidOption
+          usage_and_exit(parser)
+        end
 
-      rescue OptionParser::InvalidOption
-        usage_and_exit(parser)
+        raygun
       end
+      # rubocop:enable Metrics/MethodLength
 
-      raygun
-    end
-
-    def self.usage_and_exit(parser)
-      puts parser
-      exit 1
+      def usage_and_exit(parser)
+        puts parser
+        exit 1
+      end
     end
   end
 end

data/lib/raygun/template_repo.rb

@@ -0,0 +1,78 @@
+module Raygun
+  class TemplateRepo
+    attr_reader :name, :branch, :tarball, :sha
+
+    def initialize(repo)
+      @name, @branch = repo.split("#").map(&:strip)
+      fetch
+    end
+
+    private
+
+    def fetch
+      return if @branch && @sha
+
+      @branch ? fetch_branches : fetch_tags
+    end
+
+    def handle_github_error(response)
+      puts  ""
+      print "Whoops - need to try again!".colorize(:red)
+      puts  ""
+      print "We could not find (".colorize(:light_red)
+      print name.to_s.colorize(:white)
+      print "##{branch}".colorize(:white) if @branch
+      print ") on github.".colorize(:light_red)
+      puts  ""
+      print "The response from github was a (".colorize(:light_red)
+      print response.code.to_s.colorize(:white)
+      puts  ") which I'm sure you can fix right up!".colorize(:light_red)
+      puts  ""
+      exit 1
+    end
+
+    def handle_missing_tag_error
+      puts  ""
+      print "Whoops - need to try again!".colorize(:red)
+      puts  ""
+      print "We could not find any tags in the repo (".colorize(:light_red)
+      print name.to_s.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
+
+    def fetch_branches
+      response = http_get("https://api.github.com/repos/#{name}/branches/#{branch}")
+      handle_github_error(response) unless response.code == "200"
+      result = JSON.parse(response.body)
+      @sha = result["commit"]["sha"]
+      @tarball = result["_links"]["html"].gsub(%r{/tree/#{branch}}, "/archive/#{branch}.tar.gz")
+    end
+
+    def fetch_tags
+      response = http_get("https://api.github.com/repos/#{name}/tags")
+      handle_github_error(response) unless response.code == "200"
+
+      result = JSON.parse(response.body).first
+      handle_missing_tag_error unless result
+      @sha = result["commit"]["sha"]
+      @tarball = result["tarball_url"]
+    end
+
+    def http_get(url)
+      uri          = URI(url)
+      http         = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      request      = Net::HTTP::Get.new(uri)
+
+      http.request(request)
+    end
+  end
+end