raygun 1.0.2 → 1.2.0

data/Rakefile

@@ -1 +1,9 @@
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: %i[rubocop spec]

data/bin/raygun

@@ -1,10 +1,10 @@
 #!/usr/bin/env ruby
 
-File.expand_path('../../lib', __FILE__).tap do |lib|
+File.expand_path("../lib", __dir__).tap do |lib|
   $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 end
 
-require 'raygun/raygun'
+require "raygun/raygun"
 
 raygun = Raygun::Runner.parse(ARGV)
 

data/bin/setup

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install

data/lib/colorize.rb

@@ -5,41 +5,40 @@
 # 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
+    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
+    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)
+    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
@@ -47,16 +46,14 @@ class String
   #
   # 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
+  def color_parameters(params)
+    return unless params.instance_of?(Hash)
+
+    @color = params[:color]
+    @background = params[:background]
+    @mode = params[:mode]
+    @uncolorized = params[:uncolorized]
+    self
   end
 
   public
@@ -77,22 +74,23 @@ class String
   #   puts "This is blue text on red".blue.on_red.blink
   #   puts "This is uncolorized".blue.on_red.uncolorize
   #
-  def colorize( params )
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  def colorize(params)
     return self unless STDOUT.isatty
 
     begin
-      require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/
+      require "Win32/Console/ANSI" if RUBY_PLATFORM.match?(/win32/)
     rescue LoadError
-      raise 'You must gem install win32console to use colorize on Windows'
+      raise "You must gem install win32console to use colorize on Windows"
     end
 
     color_parameters = {}
 
-    if (params.instance_of?(Hash))
+    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))
+    elsif params.instance_of?(Symbol)
       color_parameters[:color] = COLORS[params]
     end
 
@@ -100,15 +98,18 @@ class String
     color_parameters[:background] ||= @background ||= COLORS[:default]
     color_parameters[:mode] ||= @mode ||= MODES[:default]
 
-    color_parameters[:uncolorized] ||= @uncolorized ||= self.dup
+    color_parameters[:uncolorized] ||= @uncolorized ||= 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 )
+    "\033[#{color_parameters[:mode]};#{color_parameters[:color] + 30};"\
+    "#{color_parameters[:background] + 40}m#{color_parameters[:uncolorized]}\033[0m"\
+      .color_parameters(color_parameters)
   end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
   #
   # Return uncolorized string
@@ -127,37 +128,36 @@ class String
   #
   # Make some color and on_color methods
   #
-  COLORS.each_key do | key |
+  COLORS.each_key do |key|
     next if key == :default
 
     define_method key do
-      self.colorize( :color => key )
+      colorize(color: key)
     end
 
     define_method "on_#{key}" do
-      self.colorize( :background => key )
+      colorize(background: key)
     end
   end
 
   #
   # Methods for modes
   #
-  MODES.each_key do | key |
+  MODES.each_key do |key|
     next if key == :default
 
     define_method key do
-      self.colorize( :mode => key )
+      colorize(mode: key)
     end
   end
 
   class << self
-
     #
     # Return array of available modes used by colorize method
     #
     def modes
       keys = []
-      MODES.each_key do | key |
+      MODES.each_key do |key|
         keys << key
       end
       keys
@@ -168,7 +168,7 @@ class String
     #
     def colors
       keys = []
-      COLORS.each_key do | key |
+      COLORS.each_key do |key|
         keys << key
       end
       keys
@@ -177,16 +177,16 @@ class String
     #
     # Display color matrix with color names.
     #
-    def color_matrix( txt = "[X]" )
+    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 )
+      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}"
+      String.colors.reverse.each_with_index do |back, index|
+        puts "#{"|".rjust(txt.length) * (size - index)} < #{back}"
       end
       ""
     end

data/lib/raygun/c5_conventions.rb

@@ -0,0 +1,65 @@
+require "colorize"
+require "open-uri"
+
+module Raygun
+  class C5Conventions
+    REPO = "carbonfive/c5-conventions".freeze
+
+    SOURCES = [
+      "https://raw.githubusercontent.com/#{REPO}/main/rubocop/.rubocop.yml",
+      "https://raw.githubusercontent.com/#{REPO}/main/rubocop/.rubocop-common.yml",
+      "https://raw.githubusercontent.com/#{REPO}/main/rubocop/.rubocop-performance.yml",
+      "https://raw.githubusercontent.com/#{REPO}/main/rubocop/.rubocop-rails.yml",
+      "https://raw.githubusercontent.com/#{REPO}/main/rubocop/.rubocop-rspec.yml"
+    ].freeze
+
+    ATTRIBUTION_HEADER = <<~TEXT
+      # Sourced from #{REPO} @ %<sha>s
+      #
+      # If you make changes to this file, consider opening a PR to backport them to the c5-conventions repo:
+      # https://github.com/#{REPO}
+    TEXT
+
+    # Install the latest copy of c5-conventions rubocop config in the given directory.
+    # If the latest files can't be downloaded from GitHub, print a warning, don't raise an exception.
+    # Any existing .rubocop.yml will be overwritten.
+    def self.install(target:, sources: SOURCES)
+      new(target: target, sources: sources).install
+    rescue Errno::ENOENT, OpenURI::HTTPError => e
+      puts ""
+      puts "Failed to install the CarbonFive conventions from the #{REPO} GitHub repo".colorize(:light_red)
+      puts "Error: #{e}".colorize(:light_red)
+      puts "You'll have to manage your own `.rubocop.yml` setup".colorize(:light_red)
+    end
+
+    def initialize(sources:, target:)
+      @sources = sources
+      @target = target
+    end
+
+    def install
+      sources.each do |url_str|
+        uri = URI(url_str)
+        contents = [attribution_header, uri.open.read].join("\n")
+        filename = File.basename(uri.path)
+
+        IO.write(File.join(target, filename), contents)
+      end
+    end
+
+    private
+
+    attr_reader :sources, :target
+
+    def attribution_header
+      format(ATTRIBUTION_HEADER, sha: latest_commit_sha)
+    end
+
+    def latest_commit_sha
+      @latest_commit_sha ||= begin
+        stdout = `git ls-remote https://github.com/#{REPO} main`
+        stdout[/^(\h{7})/, 1] || "main"
+      end
+    end
+  end
+end

data/lib/raygun/raygun.rb

@@ -1,43 +1,46 @@
-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 "json"
+require "colorize"
+
+require_relative "version"
+require_relative "c5_conventions"
+require_relative "template_repo"
 
 module Raygun
   class Runner
-    CARBONFIVE_REPO = 'carbonfive/raygun-rails'
+    CARBONFIVE_REPO = "carbonfive/raygun-rails"
 
-    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 +48,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,24 +75,23 @@ 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
@@ -100,25 +102,28 @@ module Raygun
       # 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
+
+      C5Conventions.install(target: app_dir) 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}}' {} \\;"
+        %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
@@ -148,26 +153,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
@@ -176,25 +188,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 and prepare the database".colorize(:light_green)
       puts "$".colorize(:blue) + " cd #{target_dir}".colorize(:light_blue)
-      puts "$".colorize(:blue) + " ./bin/setup".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) + " yarn start".colorize(:light_blue)
       puts "$".colorize(:blue) + " open http://localhost:3000".colorize(:light_blue)
       puts ""
+      puts "# For next steps like adding Bootstrap or React, 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 +221,80 @@ 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
-
-      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 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)
+    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
-        opts.on('-p', '--prototype [github_repo]', "Prototype github repo (e.g. carbonfive/raygun-rails).") do |prototype|
-          options.prototype_repo = prototype
-        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