ramaze 2011.01.30 → 2011.07.25

data/lib/ramaze/bin/console.rb

@@ -0,0 +1,87 @@
+require 'irb'
+require 'irb/completion'
+
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # Allows the user to enter an IRB like session that takes advantage of
+    # everything provided by Ramaze.
+    #
+    # == Usage
+    #
+    #  ramaze console
+    #  ramaze console /path/to/app/start.rb
+    #
+    # @author Yorick Peterse
+    # @since  21-07-2011
+    #
+    class Console
+      # String containing the description of this command.
+      Description = 'Starts an IRB session with Ramaze loaded into the session'
+
+      # The banner that is displayed when the -h or --help option is specified.
+      Banner = <<-TXT.strip
+Starts an IRB session and loads Ramaze into the session. All specified Rack
+options are ignored and environment variables are passed to IRB.
+
+Usage:
+  ramaze console [DIR] [OPTIONS]
+
+Example:
+  ramaze console
+  ramaze console /home/foobar/ramaze/start.rb
+      TXT
+
+      ##
+      # Creates a new instance of the command and sets all the options.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      #
+      def initialize
+        @options = OptionParser.new do |opt|
+          opt.banner         = Banner
+          opt.summary_indent = '  '
+
+          opt.separator "\nOptions:\n"
+
+          opt.on('-h', '--help', 'Shows this help message') do
+            puts @options
+            exit
+          end
+        end
+      end
+
+      ##
+      # Runs the command based on the given command line arguments.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      # @param  [Array] argv An array of command line arguments.
+      #
+      def run(argv = [])
+        @options.parse!(argv)
+
+        start_file = argv.delete_at(0)
+        start_file = File.join(Dir.pwd, 'start.rb') if start_file.nil?
+
+        if File.directory?(start_file)
+          start_file = File.join(start_file, 'start.rb')
+        end
+
+        if !File.exist?(start_file)
+          abort "The file #{start_file} does not exist"
+        end
+
+        start_file             = Pathname.new(start_file).realpath.to_s
+        Ramaze.options.started = true
+
+        require(start_file)
+
+        IRB.start
+        puts 'Ramazement has ended, go in peace.'
+      end
+    end # Console
+  end # Bin
+end # Ramaze

data/lib/ramaze/bin/create.rb

@@ -0,0 +1,94 @@
+require 'fileutils'
+
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # Simple command that allows users to easily create a new application based
+    # on the prototype that ships with Ramaze.
+    #
+    # == Usage
+    #
+    #  ramaze create blog
+    #
+    # @author Yorick Peterse
+    # @since  21-07-2011
+    #
+    class Create
+      # The description of this command as shown in the global help message.
+      Description = 'Allows developers to easily create new Ramaze applications.'
+
+      # The banner of this command.
+      Banner = <<-TXT.strip
+Allows developers to easily create new Ramaze applications based on the
+prototype that ships with Ramaze.
+
+Usage:
+  ramaze create [NAME] [OPTIONS]
+
+Example:
+  ramaze create blog
+      TXT
+
+      ##
+      # Creates a new instance of the command and sets the options for
+      # OptionParser.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      #
+      def initialize
+        @options = {
+          :force => false
+        }
+
+        @opts = OptionParser.new do |opt|
+          opt.banner         = Banner
+          opt.summary_indent = '  '
+
+          opt.separator "\nOptions:\n"
+
+          opt.on('-f', '--force', 'Overwrites existing directories') do
+            @options[:force] = true
+          end
+
+          opt.on('-h', '--help', 'Shows this help message') do
+            puts @opts
+            exit
+          end
+        end
+      end
+
+      ##
+      # Runs the command based on the specified command line arguments.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      # @param  [Array] argv Array containing all command line arguments.
+      #
+      def run(argv = [])
+        @opts.parse!(argv)
+
+        path  = argv.delete_at(0)
+        proto = __DIR__('../../proto')
+
+        abort 'You need to specify a name for your application' if path.nil?
+
+        if File.directory?(path) and @options[:force] === false
+          abort 'The specified application already exists, use -f to overwrite it'
+        end
+
+        if File.directory?(path) and @options[:force] === true
+          FileUtils.rm_rf(path)
+        end
+
+        begin
+          FileUtils.cp_r(proto, path)
+          puts "The application has been generated and saved in #{path}"
+        rescue
+          abort 'The application could not be generated'
+        end
+      end
+    end # Create
+  end # Bin
+end # Ramaze

data/lib/ramaze/bin/helper.rb

@@ -0,0 +1,107 @@
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # Module containing various helper methods useful for most commands.
+    #
+    # @author Yorick Peterse
+    # @author TJ Vanderpoel
+    # @since  21-07-2011
+    #
+    module Helper
+      ##
+      # Checks if the specified PID points to a process that's already running.
+      #
+      # @author TJ Vanderpoel
+      # @since  21-07-2011
+      # @param  [String] pid The path to the PID.
+      # @return [TrueClass|FalseClass]
+      #
+      def is_running?(pid)
+        return false if !File.exist?(pid)
+
+        pid = File.read(pid).to_i
+
+        if is_windows?
+          wmi             = WIN32OLE.connect("winmgmts://")
+          processes, ours = wmi.ExecQuery(
+            "select * from win32_process where ProcessId = #{pid}"
+          ), []
+
+          processes.each { |process| ours << process.Name }
+
+          return ours.first.nil?
+        else
+          begin
+            prio = Process.getpriority(Process::PRIO_PROCESS, pid)
+            return true
+          rescue Errno::ESRCH
+            return false
+          end
+        end
+      end
+
+      ##
+      # Checks if the system the user is using is Windows.
+      #
+      # @author TJ Vanderpoel
+      # @since  21-07-2011
+      # @return [TrueClass|FalseClass]
+      #
+      def is_windows?
+        return @is_win if @is_win
+
+        begin; require "win32ole"; rescue LoadError; end
+
+        @is_win ||= Object.const_defined?("WIN32OLE")
+      end
+
+      ##
+      # Tries to extract the path to the Rackup executable.
+      #
+      # @author TJ Vanderpoel
+      # @since  21-07-2001
+      # @return [String]
+      #
+      def rackup_path
+        return @rackup_path if @rackup_path
+
+        # Check with 'which' on platforms which support it
+        unless is_windows?
+          @rackup_path = %x{which rackup}.to_s.chomp
+
+          if @rackup_path.size > 0 and File.file?(@rackup_path)
+            return @rackup_path
+          end
+        end
+
+        # check for rackup in RUBYLIB
+        libs = ENV["RUBYLIB"].to_s.split(is_windows? ? ";" : ":")
+
+        if rack_lib = libs.detect { |r| r.match %r<(\\|/)rack\1> }
+          require "pathname"
+          @rackup_path = Pathname.new(rack_lib).parent.join("bin").join(
+            "rackup"
+          ).expand_path
+          
+          return @rackup_path if File.file?(@rackup_path)
+        end
+
+        begin
+          require "rubygems"
+          require "rack"
+          require "pathname"
+
+          @rackup_path = Pathname.new(Gem.bindir).join("rackup").to_s
+
+          return @rackup_path if File.file?(@rackup_path)
+        rescue LoadError
+          nil
+        end
+
+        @rackup_path = nil
+        abort "Cannot find the path to the Rackup executable"
+      end
+    end # Helper
+  end # Bin
+end # Ramaze

data/lib/ramaze/bin/restart.rb

@@ -0,0 +1,95 @@
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # Restarts an application based on a specified directory/rackup file and
+    # PID. The PID is used to kill the process, the Rackup file is used to start
+    # the process again after it has been killed.
+    #
+    # == Usage
+    #
+    #  ramaze restart
+    #  ramaze restart /home/foobar/projects/ramaze/ \
+    #  -P /home/foobar/projects/ramaze/ramaze.pid
+    #
+    # @author Yorick Peterse
+    # @since  21-07-2011
+    #
+    class Restart
+      # The description of this command, displayed in the global help message.
+      Description = 'Restarts an application'
+
+      # The banner, displayed when the -h or --help option is specified.
+      Banner = <<-TXT.strip
+Restarts an active Ramaze application.
+
+Usage:
+  ramaze restart [RACKUP] [OPTIONS]
+
+Example:
+  ramaze restart config.ru -P ramaze.pid
+      TXT
+
+      ##
+      # Creates a new instance of the command and sets all the options.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      #
+      def initialize
+        @options = OptionParser.new do |opt|
+          opt.banner         = Banner
+          opt.summary_indent = '  '
+
+          opt.separator "\nOptions:\n"
+
+          opt.on('-h', '--help', 'Shows this help message') do
+            puts @options
+            exit
+          end
+
+          opt.on(
+            '-P',
+            '--pid FILE',
+            'Uses the PID to kill the application'
+          ) do |pid|
+            @pid = pid
+          end
+        end
+      end
+
+      ##
+      # Runs the command based on the specified command line arguments.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      # @param  [Array] argv An array containing all command line arguments.
+      #
+      def run(argv = [])
+        @options.parse!(argv)
+
+        @rackup = argv.delete_at(0)
+        @rackup = File.join(Dir.pwd, 'config.ru') if @rackup.nil?
+
+        if File.directory?(@rackup)
+          @rackup = File.join(@rackup, 'config.ru')
+        end
+
+        if !File.exist?(@rackup)
+          abort "The Rackup file #{@rackup} does not exist"
+        end
+
+        stop   = Ramaze::Bin::Runner::Commands[:stop].new
+        start  = Ramaze::Bin::Runner::Commands[:start].new
+        params = [@rackup]
+
+        unless @pid.nil?
+          params.push("-P #{@pid}")
+        end
+
+        stop.run([@pid])
+        start.run(params)
+      end
+    end # Restart
+  end # Bin
+end # Ramaze

data/lib/ramaze/bin/runner.rb

@@ -0,0 +1,141 @@
+require 'optparse'
+require 'pathname'
+
+require __DIR__('helper')
+require __DIR__('start')
+require __DIR__('restart')
+require __DIR__('stop')
+require __DIR__('create')
+require __DIR__('status')
+require __DIR__('console')
+
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # Module used for running a particular command based on the specified
+    # command line arguments.
+    #
+    # == Usage
+    #
+    #  ramaze --help # Shows a help message
+    #  ramaze -h     # Shows a help message as well
+    #  ramaze -v     # Shows the version of Ramaze
+    #
+    #  ramaze [COMMAND] # Runs [COMMAND]
+    #
+    # @author Yorick Peterse
+    # @since  21-07-2011
+    #
+    module Runner
+      # Hash containing all the available commands, their names and their
+      # classes.
+      Commands = {
+        :start   => Ramaze::Bin::Start,
+        :stop    => Ramaze::Bin::Stop,
+        :restart => Ramaze::Bin::Restart,
+        :status  => Ramaze::Bin::Status,
+        :create  => Ramaze::Bin::Create,
+        :console => Ramaze::Bin::Console,
+      }
+
+      # String containing the banner of the main command.
+      Banner = <<-TXT.strip
+Ramaze is a simple, light and modular open-source web application
+framework written in Ruby.
+
+Usage:
+  ramaze [COMMAND] [OPTIONS]
+
+Example:
+  ramaze create blog
+      TXT
+
+      ##
+      # Runs a particular command based on the specified array.
+      #
+      # @example
+      #  Ramaze::Bin::Runner.run(ARGV)
+      #  Ramaze::Bin::Runner.run(['start', '--help'])
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      # @param  [Array] argv An array containing command line arguments, set to
+      #  ARGV by default.
+      #
+      def self.run(argv=ARGV)
+        op = OptionParser.new do |opt|
+          opt.banner         = Banner
+          opt.summary_indent = '  '
+
+          opt.separator "\nCommands:\n  #{commands_info.join("\n  ")}"
+
+          # Show all the common options
+          opt.separator "\nOptions:\n"
+
+          # Show the version of Ramaze
+          opt.on('-v', '--version', 'Shows the version of Ramaze') do
+            puts Ramaze::VERSION
+            exit
+          end
+
+          opt.on('-h', '--help', 'Shows this help message') do
+            puts op
+            exit
+          end
+        end
+
+        op.order!(argv)
+
+        # Show a help message if no command has been specified
+        if !argv[0]
+          puts op.to_s
+          exit
+        end
+
+        cmd = argv.delete_at(0).to_sym
+
+        if Commands.key?(cmd)
+          cmd = Commands[cmd].new
+          cmd.run(argv)
+        else
+          abort 'The specified command is invalid'
+        end
+      end
+
+      ##
+      # Generates an array of "rows" where each row contains the name and
+      # description of a command. The descriptions of all commands are aligned
+      # based on the length of the longest command name.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      # @return [Array]
+      #
+      def self.commands_info
+        cmds    = []
+        longest = Commands.map { |name, klass| name.to_s }.sort[0].size
+
+        Commands.each do |name, klass|
+          name = name.to_s
+          desc = ''
+
+          # Try to extract the command description
+          if klass.respond_to?(:const_defined?) \
+          and klass.const_defined?(:Description)
+            desc = klass.const_get(:Description)
+          end
+
+          # Align the description based on the length of the name
+          while name.size <= longest do
+            name += ' '
+          end
+
+          cmds.push(["#{name}    #{desc}"])
+        end
+
+        return cmds
+      end
+    end # Runner
+  end # Bin
+end # Ramaze