refinerycms

#!/usr/bin/env ruby
# Load bundler
begin
  require 'rubygems'
  require 'bundler'
rescue LoadError
  puts "\n=== ACTION REQUIRED ===\n\n"
  puts "Could not load the bundler gem. This is a required dependency of Refinery CMS."
  puts "Please install it with `gem install bundler`.\n\n"
  exit(1)
end

# Let the application have a constant it can detect installation with.
REFINERYCMS_INSTALLER = true

# Load refinerycms
require File.expand_path(File.dirname(__FILE__) << "/../lib/refinery")

# Load other required libraries
require 'pathname'
require 'fileutils'
require 'optparse'

module Refinery
  class AppGenerator

    def initialize(input)
      # Default options
      @input = input
      @options = {
        :confirm => false,
        :database => {
          :adapter => 'sqlite3',
          :ident => false,
          :password => nil,
          :username => 'root',
          :skip => false
        },
        :duostack => false,
        :force => false,
        :gems => [],
        :heroku => false
      }

      @optparse = OptionParser.new do |opts|
        opts.banner = "Purpose: Installs Refinery CMS to the specified directory"
        opts.banner << "\nUsage:   #{opts.program_name} /path/to/project [options]"

        opts.separator ""
        opts.separator "Specific Options:"

        # Bail out if --update is specified.
        opts.on('--update') do |update|
          puts "\nYou specified --update which is a command that has been removed."
          puts "To update your application:"
          puts "- Change the version of the 'refinerycms' gem in your Gemfile."
          puts "- Run bundle install"
          puts "- Run rails generate refinerycms --update"
          puts "\n"
          exit(1)
        end

        # Rails supports more options, but Refinery is only tested on these three
        databases = %w(mysql postgresql sqlite3)
        opts.on("-d DATABASE", "--database DATABASE", databases, "Select the database (default sqlite3)", "  #{databases.join('/')}") do |db|
          @options[:database][:adapter] = db
        end

        opts.on("--ident", "Use ident database authentication (for mysql or postgresql)") do
          @options[:database][:ident] = true
        end

        opts.on("-u USERNAME", '--database-username USERNAME', String, "Set the database username", '  (default root)') do |username|
          @options[:database][:username] = username
        end

        opts.on("-p PASSWORD", '--database-password PASSWORD', String, "Set the database password", "  (default '')") do |password|
          @options[:database][:password] = password
        end

        opts.on('--skip-db', "Skip any database creation or migration tasks") do
          @options[:database][:skip] = true
        end

        opts.on("-g", "--gems gem1,gem2,gem3", Array, "Additional gems to install") do |gems|
          @options[:gems] = gems.reject {|g| g.to_s =~ /^refinerycms/}.map {|g| "gem '#{g.to_s}'"}
        end

        opts.on("-f", "--force", "Force overwriting of directory") do
          @options[:force] = true
        end

        opts.on("--heroku [APP_NAME]", "Set up and deploy to Heroku") do |app_name|
          @options[:heroku] = app_name || ''
        end

        opts.on("--duostack APP_NAME", String, "Set up and deploy to Duostack") do |app_name|
          @options[:duostack] = app_name
        end

        opts.on("-c", "--confirm", "Confirm any prompts that require input") do
          @options[:confirm] = true
        end

        opts.separator ""
        opts.separator "Common options:"

        opts.on_tail("-h", "--help", "Display this screen") do
          puts opts
          exit
        end

        opts.on_tail("-v", "--version", "Display the version") do
          puts Refinery.version
          exit
        end
      end
    end

    def run!
      # Grab input and ensure that the path doesn't exist already and other checks.
      validate!

      # Generate a Refinery CMS application
      generate!

      # Bundle the application which activates Refinery CMS
      bundle!

      unless @options[:database][:skip]
        # Ensure the database exists so that queries like .table_exists? don't fail.
        puts "\nCreating a new database.."
        # Warn about incorrect username or password.
        unless @options[:database][:adapter] == 'sqlite3'
          if @options[:database][:ident]
            note = "NOTE: If ident authentication fails then the installer will stall or fail here.\n\n"
          else
            note = "NOTE: if your database username is not '#{@options[:database][:username]}'"
            note << " or your password is not '#{@options[:database][:password]}' then the installer will stall here.\n\n"
          end
          puts note
        end
        run_command("rake -f \"#{@app_path.join('Rakefile')}\" db:create", {
          :fail => "Unable to create the application's database"
        })

        # Run the newly activated Refinery CMS generator.
        run_command("rails generate refinerycms", {
          :cd => true,
          :fail => "Could not run the refinerycms generator successfully."
        })
      end

      # Output helpful messages to user
      output!
    end

    def validate!
      # Check for valid input
      begin
        @optparse.parse!(@input)
      rescue OptionParser::ParseError => pe
        puts pe
        puts "\n"
        puts @optparse
        exit(1)
      end

      # Ensure only one path is specified
      unless @input.size == 1
        puts "Please specify a single path to install Refinery CMS"
        puts "\n"
        puts @optparse
        exit(1)
      end

      # Get the name and path of the new application
      @app_path = Pathname.new(File.expand_path(@input.first))
      @app_name = @app_path.to_s.split(File::SEPARATOR).last

      # Get the refinery path based on this file
      @refinery_path = Pathname.new(File.expand_path('../../', __FILE__))

      if @app_path == @refinery_path
        puts "\nPlease generate your new project from outside the Refinery directory and any Rails directory."
        puts "\n"
        exit(1)
      elsif %w(refinery test testing).include?(@input.first)
        puts "\nYou can't use '#{@input.first}' as a name for your project, this is a reserved word that will cause conflicts."
        puts "Please choose another name for your new project."
        puts "\n"
        exit(1)
      elsif @app_path.directory? && !@options[:force]
        puts "\nThe directory '#{@app_path}' that you specified already exists."
        puts "Use --force to overwrite an existing directory."
        puts "\n"
        exit(1)
      elsif @options[:heroku]
        if @options[:heroku].to_s.include?('_') or @options[:heroku].to_s.length > 30
          message = ["\nThe application name '#{@options[:heroku]}' that you specified is invalid for Heroku."]
          suggested_name = @options[:heroku].to_s
          if suggested_name.include?('_')
            message << "This is because it contains underscores which Heroku does not allow."
            suggested_name.gsub!(/_/, '-')
          end
          if suggested_name.length > 30
            message << "This is#{" also" unless suggested_name.nil?} because it is longer than 30 characters."
            suggested_name = suggested_name[0..29]
          end

          if @options[:force] or @options[:confirm]
            @options[:heroku] = suggested_name
          else
            message << "Please choose another name like '#{suggested_name}'"
            message << "Or use --confirm to automatically use '#{suggested_name}'"
            message << "\n"
            puts message.join("\n")
            exit(1)
          end
        end
      end
    end

    def generate!
      # Generate a rails application
      rails_command = "rails new \"#{@app_path}\""
      rails_command << " --database #{@options[:database][:adapter]}"
      rails_command << " --force" if @options[:force]
      rails_command << " --skip-test-unit --skip-prototype"
      rails_command << " -m http://jruby.org" if defined? JRUBY_VERSION

      rails_output = run_command(rails_command, {:cd => false})

      # Detect non-success or a blank rails output or starting with "Can't initialize" or "Error"
      if !$?.success? or rails_output.to_s.length == 0 or rails_output =~ /^(Can't\ initialize|Error)/
        puts "Generating Rails application failed. Exiting..."
        exit(1)
      else
        if defined? JRUBY_VERSION
          find_and_replace(@app_path.join('Gemfile'), /['|"]sqlite3['|"]/, "'activerecord-jdbcsqlite3-adapter'")
        end

        # Override username and password
        if @options[:database][:ident]
          find_and_replace('config/database.yml', %r{username:}, '#username:')
          find_and_replace('config/database.yml', %r{password:}, '#password:')
        else
          find_and_replace('config/database.yml', %r{username:.*}, "username: #{@options[:database][:username]}")
          find_and_replace('config/database.yml', %r{password:.*}, "password: #{@options[:database][:password]}")
        end

        puts "\n---------"
        puts "Refinery successfully installed in '#{@app_path}'!\n\n"
      end
    end

    def bundle!
      # Insert the current REFINERY CMS section (you shouldn't put anything in here).
      refinery_gemfile_contents = Refinery.root.join('Gemfile').read
      refinery_gems = refinery_gemfile_contents.match(/# REFINERY CMS =+.*# END REFINERY CMS =+/m)[0]
      refinery_gems.gsub!("# gem 'refinerycms'", "gem 'refinerycms'") # Enable refinerycms
      refinery_gems.gsub!("gem 'refinerycms-testing'", "# gem 'refinerycms-testing'") # Disable testing

      app_gemfile = @app_path.join('Gemfile')
      refinery_user_defined_gems = refinery_gemfile_contents.match(/# USER DEFINED(.*)# END USER DEFINED/m)
      refinery_user_defined_gems = refinery_user_defined_gems[1] unless refinery_user_defined_gems.nil?

      if @options[:database][:adapter] == 'mysql'
        app_gemfile_contents = app_gemfile.read
        app_gemfile.open('w') do |f|
          f.write app_gemfile_contents.gsub "gem 'mysql2'", "gem 'mysql2', '~> 0.2.7'"
        end
      end

      app_gemfile.open('a') do |f|
        f.write "\n#{refinery_gems}\n"
        @options[:gems] = ([refinery_user_defined_gems] | [@options[:gems]]).flatten.compact

        f.write "\n# USER DEFINED\n#{@options[:gems].join("\n")}\n# END USER DEFINED" if @options[:gems].any?
      end


      # Specify the correct version of the Refinery CMS gem (may be git source).
      src = Refinery.version !~ /\.pre$/ ? "'= #{Refinery.version}'" : ":git => 'git://github.com/resolve/refinerycms'"
      find_and_replace('Gemfile', %r{gem 'refinerycms',.*}, "gem 'refinerycms',              #{src}")

      # Add in fog gem for Heroku
      find_and_replace('Gemfile', "# gem 'fog'", "gem 'fog'") if @options[:heroku]

      # Automate
      # TODO: Check exit codes to see whether or not these worked
      puts "Installing gem requirements using bundler..\n"

      # Install!
      run_command("bundle install", {:fail => "Unable to install necessary gems"})
    end

    def output!
      unless @options[:database][:skip]
        puts "\n\nSetting up your development database..\n"
        run_command("rake -f \"#{@app_path.join('Rakefile')}\" db:migrate")
      end

      # Deploy to Heroku
      hosting = nil
      hosting = "Heroku" if @options[:heroku]
      hosting = "Duostack" if @options[:duostack]
      unless hosting.nil?
        puts "\n\nInitializing and committing to git..\n"
        run_command("git init && git add . && git commit -am 'Initial Commit'", :ruby => false)

        puts "\n\nCreating #{hosting} app..\n"
        run_command("#{hosting.downcase} create #{@options[:heroku] || @options[:duostack]}")

        puts "\n\nPushing to #{hosting} (this takes time, be patient)..\n"
        run_command("git push #{hosting.downcase} master", :ruby => false)

        puts "\n\nSetting up the #{hosting} database..\n"
        run_command("#{hosting.downcase} rake db:migrate")

        if @options[:heroku]
          puts "\n\nRestarting servers...\n"
          run_command("#{hosting.downcase} restart")
        end
      end
      # End automation

      # Construct helpful output messages
      note = ["\n=== ACTION REQUIRED ==="]
      if @options[:database][:skip]
        note << "Because you elected to skip database creation and migration in the installer"
        note << "you will need to run the following tasks manually to maintain correct operation:"
        note << "\ncd #{@app_path}"
        note << "rake db:create"
        note << "rails generate refinerycms"
        note << "rake db:migrate"
        note << "\n---------\n"
      end
      note << "Now you can launch your webserver using:"
      note << "\ncd #{@app_path}"
      note << "rails server"
      note << "\nThis will launch the built-in webserver at port 3000."
      note << "You can now see your site running in your browser at http://localhost:3000"

      if @options[:heroku]
        note << "\nIf you want files and images to work on heroku, you will need setup S3:"
        note << "heroku config:add S3_BUCKET=XXXXXXXXX S3_KEY=XXXXXXXXX S3_SECRET=XXXXXXXXXX S3_REGION=XXXXXXXXXX"
      end

      note << "\nThanks for installing Refinery, enjoy creating your new application!"
      note << "---------\n\n"

      # finally, output.
      puts note.join("\n")
    end

    private :validate!, :generate!, :bundle!, :output!

    def run_command(command, options = {})
      require 'rbconfig'
      options = {:cd => true, :puts => true, :fail => nil, :ruby => true}.merge(options)
      to_run = %w()
      to_run << "cd \"#{@app_path}\" &&" if options[:cd]

      # Sometimes we want to exclude the ruby runtime executable from the front
      # e.g. when shelling to git
      if options[:ruby]
        exe = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['RUBY_INSTALL_NAME'])
        to_run << "\"#{exe}\" -S "
      end

      to_run << command

      if Refinery::WINDOWS
        to_run = ['"'] + to_run + ['"']
        to_run = %w(cmd /c) + to_run.map{|c| c.gsub(/\//m, '\\')}
      end

      to_run = to_run.join(' ')

      output = []
      if options[:puts]
        puts "Running: #{to_run}"
        IO.popen(to_run) do |t|
          while (line = t.gets)
            output << line
            puts line
          end
        end
      else
        output << `#{to_run}`
      end

      if $?.success? or options[:fail].nil?
        output.join("\n")
      else
        puts "\nFailed to generate application."
        puts "Message: #{options[:fail]}" unless options[:fail].nil?
        puts "Exiting...\n\n"
        exit(1)
      end
    end

    def find_and_replace(file, find, replace)
      (contents = @app_path.join(file).read).gsub!(find, replace)
      (@app_path + file).open("w") do |f|
        f.puts contents
      end
    end

    protected :run_command, :find_and_replace
  end
end

Refinery::AppGenerator.new(ARGV).run! if $0 =~ %r{refinerycms$}