Pistos-ramaze 2009.04.08 → 2009.06.12

data/lib/ramaze/helper/link.rb

@@ -7,39 +7,20 @@ module Ramaze
   module Helper
     # This is a modification of Innate::Helper::Link to respect the routing of
     # Ramaze
+    #
     # NOTE: The A/R/Rs methods have been deprecated.
     module Link
-
-      # @return [String]
-      # @see Innate::Helper#anchor
-      def A(*args)
-        Ramaze.deprecated('Ramaze::Helper::Link#A', 'Ramaze::Helper::Link#a')
-        a(*args)
-      end
-
-      # @return [String]
-      # @see Innate::Helper#route
-      def R(arg, *args)
-        Ramaze.deprecated('Ramaze::Helper::Link#R', 'Ramaze::Helper::Link#r')
-        (arg < Controller ? arg.r(*args) : r(arg, *args)).to_s
-      end
-
-      # @return [String]
-      # @see Innate::Helper#route
-      def Rs(*args)
-        Ramaze.deprecated('Ramaze::Helper::Link#Rs', 'Ramaze::Helper::Link#r')
-        r(*args).to_s
-      end
-
       def route_location(klass)
-        Ramaze.to(klass) || Ramaze.to(klass.class)
+        prefix = Ramaze.options.prefix
+        location = Ramaze.to(klass) || Ramaze.to(klass.class)
+        [prefix, location].join('/')
       end
 
       # Give it a path with character to split at and one to join the crumbs with.
       # It will generate a list of links that act as pointers to previous pages on
       # this path.
       #
-      # Example:
+      # @example usage
       #   breadcrumbs('/path/to/somewhere')
       #
       #   # results in this, newlines added for readability:
@@ -51,7 +32,7 @@ module Ramaze
       # Optionally a href prefix can be specified which generate link
       # names a above, but with the prefix prepended to the href path.
       #
-      # Example:
+      # @example usage
       #   breadcrumbs('/path/to/somewhere', '/', '/', '/mycontroller/action')
       #
       #   # results in this, newlines added for readability:

data/lib/ramaze/helper/localize.rb

@@ -19,7 +19,12 @@ module Ramaze
       end
 
       def locales
-        Parser.new(request).locales(ancestral_trait[:localize_locale])
+        locales = request.env['localize.locales']
+        return locales if locales
+
+        fallback = ancestral_trait[:localize_locale]
+        locales = Parser.new(request).locales(fallback)
+        request.env['localize.locales'] = locales
       end
 
       class Dictionary
@@ -105,7 +110,7 @@ module Ramaze
         end
 
         def parse
-          parse_params || parse_cookie || parse_header
+          parse_params || parse_session || parse_cookie || parse_header
         end
 
         def parse_params(key = 'lang')
@@ -113,13 +118,18 @@ module Ramaze
           ::Locale::Tag.parse(lang)
         end
 
+        def parse_session(key = :lang)
+          return unless lang = Current.session[key]
+          ::Locale::Tag.parse(lang)
+        end
+
         def parse_cookie(key = 'lang')
           return unless lang = request.cookies[key]
           ::Locale::Tag.parse(lang)
         end
 
         def parse_header
-          request.accept_language_with_weight.map{|lang|
+          request.accept_language.map{|lang|
             ::Locale::Tag.parse(lang) }
         end
       end

data/lib/ramaze/helper/paginate.rb

@@ -134,7 +134,7 @@ module Ramaze
           end
 
           out << '</div>'
-          out.map{|e| e.to_s}.join("\n")
+          out.join
         end
 
         # Useful to omit pager if it's of no use.
@@ -154,6 +154,8 @@ module Ramaze
         def last_page; @pager.last_page; end
         def last_page?; @pager.last_page?; end
         def next_page; @pager.next_page; end
+        def empty?; @pager.empty?; end
+        def count; @pager.count; end
 
         private
 
@@ -173,7 +175,7 @@ module Ramaze
 
           action = Current.action
           params = request.params.merge(@var.to_s => n)
-          hash[:href] = action.node.r(action.name, params)
+          hash[:href] = action.node.r(action.path, params)
 
           g.a(hash){ text }
         end

data/lib/ramaze/helper/ultraviolet.rb

@@ -1,6 +1,8 @@
 module Ramaze
   module Helper
     module Ultraviolet
+      include Innate::Traited
+
       trait :ultraviolet => {
         :output       => 'xhtml',
         :syntax       => nil, # syntax_name, nil|false indicates automatic detection

data/lib/ramaze/helper/user.rb

@@ -170,7 +170,7 @@ module Ramaze
         # @return [Ramaze::Helper::User::Wrapper] wrapped return value from
         #                                         model or callback
         # @see Ramaze::Helper::User#user_login
-        # @autor manveru
+        # @author manveru
         def _login(creds = _persistence)
           if @_user = _would_login?(creds)
             self._persistence = creds
@@ -195,7 +195,7 @@ module Ramaze
 
         # @api internal
         # @see Ramaze::Helper::User#user_logout
-        # @autor manveru
+        # @author manveru
         def _logout
           _persistence.clear
           Current.request.env['ramaze.helper.user'] = nil
@@ -204,7 +204,7 @@ module Ramaze
         # @return [true false] whether the current user is logged in.
         # @api internal
         # @see Ramaze::Helper::User#logged_in?
-        # @autor manveru
+        # @author manveru
         def _logged_in?
           !!_user
         end

data/lib/ramaze/log/rotatinginformer.rb

@@ -1,16 +1,16 @@
 module Ramaze
-  
+
   module Logger
 
     # A customized logger (based on Informer) that creates multiple log files based on time
 
     class RotatingInformer
-      
+      include Innate::Traited
       include Logging
 
       attr_accessor :time_format, :log_levels
       attr_reader :base_dir
-      
+
       # parameter for Time.now.strftime
       trait :timestamp => "%Y-%m-%d %H:%M:%S"
 
@@ -47,24 +47,24 @@ module Ramaze
       def initialize(base_dir, time_format = '%Y-%m-%d.log', log_levels = [:debug, :error, :info, :warn])
         # Verify and set base directory
         send :base_dir=, base_dir, true
-        
+
         @time_format = time_format
         @log_levels = log_levels
-        
+
         # Keep track of log shutdown (to prevent StackErrors due to recursion)
         @in_shutdown = false
       end
 
       # Set the base directory for log files
-      # 
+      #
       # If this method is called with the raise_exception
       # parameter set to true the method will raise an exception
       # if the specified directory does not exist or is unwritable.
-      # 
+      #
       # If raise_exception is set to false, the method will just
       # silently fail if the specified directory does not exist
       # or is unwritable
-      
+
       def base_dir=(directory, raise_exception = false)
         # Expand directory path
         base_dir = File.expand_path(directory)
@@ -85,7 +85,7 @@ module Ramaze
           raise Exception.new("#{base_dir} does not exist.") if raise_exception
         end
       end
-      
+
       # Close the file we log to if it isn't closed already.
 
       def shutdown
@@ -106,7 +106,7 @@ module Ramaze
         return unless @log_levels.include?(tag)
 
         # Update current log
-        update_current_log       
+        update_current_log
 
         messages.flatten!
 

data/lib/ramaze/request.rb

@@ -1,17 +1,14 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
   # The purpose of this class is to act as a simple wrapper for Rack::Request
   # and provide some convinient methods for our own use.
   class Request < Innate::Request
-    # Currently active request out of STATE[:request]
-    def self.current; Current.request; end
 
     # you can access the original @request via this method_missing,
     # first it tries to match your method with any of the HTTP parameters
     # then, in case that fails, it will relay to @request
-
     def method_missing meth, *args
       key = meth.to_s.upcase
       return env[key] if env.has_key?(key)
@@ -27,13 +24,14 @@ module Ramaze
     #   @name # => 'manveru'
     #   @lang # => nil
 
-    def to_ivs(*args)
+    def to_instance_variables(*args)
       instance = Action.current.instance
       args.each do |arg|
         next unless value = self[arg]
         instance.instance_variable_set("@#{arg}", value)
       end
     end
+    alias to_ivs to_instance_variables
 
     def accept_charset(default = 'UTF-8')
       return default unless charsets = env['HTTP_ACCEPT_CHARSET']

data/lib/ramaze/setup.rb

@@ -4,7 +4,8 @@ module Ramaze
   # It's almost like Kernel#gem but also installs automatically if a gem is
   # missing.
   #
-  # @usage
+  # @example
+  #
   #   Ramaze.setup :verbose => true do
   #     # gem and specific version
   #     gem 'makura', '>=2009.01'
@@ -65,14 +66,20 @@ module Ramaze
 
     # first try to activate, install and try to activate again if activation
     # fails the first time
-    def setup_gem(name, options, try_install = true)
+    def setup_gem(name, options)
+      version = [options[:version]].compact
+      lib_name = options[:lib] || name
+
       log "activating #{name}"
-      Gem.activate(name, *[options[:version]].compact)
-      require(options[:lib] || name)
-    rescue LoadError => exception
-      puts exception
-      install_gem(name, options) if try_install
-      setup_gem(name, options, try_install = false)
+
+      Gem.activate(name, *version)
+      require(lib_name)
+
+    rescue LoadError
+
+      install_gem(name, options)
+      Gem.activate(name, *version)
+      require(lib_name)
     end
 
     # tell rubygems to install a gem
@@ -101,7 +108,13 @@ module Ramaze
     private
 
     def log(msg)
-      puts(msg) if @verbose
+      return unless @verbose
+
+      if defined?(Log)
+        Log.info(msg)
+      else
+        puts(msg)
+      end
     end
 
     def rubyforge; 'http://gems.rubyforge.org/' end

data/lib/ramaze/spec.rb

@@ -1,7 +1,4 @@
-require 'ramaze'
-require 'bacon'
-
-require 'innate/spec'
+require File.expand_path('../', __FILE__) unless defined?(Ramaze)
 
 def spec_requires(*libs)
   spec_precondition 'require' do
@@ -26,12 +23,11 @@ module Ramaze
   middleware!(:spec){|m| m.run(AppMap) }
 end
 
-shared :rack_test do
-  require 'rack/test'
-
-  extend Rack::Test::Methods
-
-  def app
-    Ramaze.middleware(:spec)
-  end
+# FIXME: will remove that in 2009.07, and then we can offer integration with
+#        any other test-framework we like and they can share this code.
+#        Then Ramaze can be:
+#          Any ruby, any ORM, any templating-engine, any test-framework
+unless defined?(Bacon)
+  Ramaze.deprecated "require('ramaze/spec')", "require('ramaze/spec/bacon')"
+  require 'ramaze/spec/bacon'
 end

data/lib/ramaze/spec/bacon.rb

@@ -0,0 +1,34 @@
+begin
+  require 'bacon'
+rescue LoadError
+  require 'rubygems'
+  require 'bacon'
+end
+
+require File.expand_path('../', __FILE__) unless defined?(Ramaze)
+
+require 'innate/spec/bacon'
+
+shared :rack_test do
+  Ramaze.setup_dependencies
+  extend Rack::Test::Methods
+
+  def app; Ramaze; end
+end
+
+shared :webrat do
+  behaves_like :rack_test
+
+  require 'webrat'
+
+  Webrat.configure{|config| config.mode = :rack_test }
+
+  extend Webrat::Methods
+  extend Webrat::Matchers
+end
+
+# Backwards compatibility
+shared(:mock){
+  Ramaze.deprecated('behaves_like(:mock)', 'behaves_like(:rack_test)')
+  behaves_like :rack_test
+}

data/lib/ramaze/spec/helper/template_examples.rb

@@ -1,28 +1,21 @@
-module Ramaze
-  module Spec
-    module Examples
-      module Templates
-        def self.tests( describe, spec_engine )
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
 
-            describe.behaves_like :mock
+shared :template_spec do
+  behaves_like :rack_test
 
-            describe.it '/' do
-              get('/').body.strip.should =~
-                %r{<a href\s*=\s*"/">Home</a>\s+\|\s+<a href\s*=\s*"/internal">internal</a>\s+\|\s+<a href\s*=\s*"/external">external</a>}
-            end
-
-            %w[/internal /external].each do |url|
-              describe.it url do
-                html = get(url).body
-                html.should.not == nil
-                html.should =~ %r{<title>Template::#{spec_engine} (internal|external)</title>}
-                html.should =~ %r{<h1>The (internal|external) Template for #{spec_engine}</h1>}
-              end
-
-          end
-
-        end
+  def spec_template(spec_engine)
+    it 'works on /' do
+      get('/').body.strip.
+        should =~ %r{<a href\s*=\s*"/">Home</a>\s+\|\s+<a href\s*=\s*"/internal">internal</a>\s+\|\s+<a href\s*=\s*"/external">external</a>}
+    end
 
+    %w[/internal /external].each do |url|
+      it "works on #{url}" do
+        html = get(url).body
+        html.should.not == nil
+        html.should =~ %r{<title>Template::#{spec_engine} (internal|external)</title>}
+        html.should =~ %r{<h1>The (internal|external) Template for #{spec_engine}</h1>}
       end
     end
   end

data/lib/ramaze/tool/bin.rb

@@ -0,0 +1,340 @@
+#!/usr/bin/env ruby
+### This module offers the functionality to start, stop, restart, create,
+### Check status, or run a console of a ramaze application
+### see ramaze -h for usage
+module Ramaze
+  module Tool
+    module Bin
+      module Helpers # Helper methods {{{
+
+        def default_pidfile # {{{
+          return @default_pidfile if @default_pidfile
+          require "pathname"
+          @default_pidfile = (Pathname.new(".").expand_path.basename.to_s + ".pid").strip
+        end # }}}
+
+        # We're really only concerned about win32ole, so we focus our check on its
+        # ability to load that
+        def is_windows?  # {{{
+          return @is_win if @is_win
+          begin
+            require "win32ole"
+          rescue LoadError
+          end
+          @is_win ||= Object.const_defined?("WIN32OLE")
+        end # }}}
+
+        # Find the path to rackup, by searching for -R (undocumented cli argument),
+        # then checking RUBYLIB for the _first_ rack it can find there, finally
+        # falling back to gems and looking for rackup in the gem bindir.
+        # If we can't find rackup we're raising; not even #usage is sane without
+        # rackup.
+        def rackup_path # {{{
+          return @rackup_path if @rackup_path
+          # Use the supplied path if the user supplied -R
+          if path_supplied = ARGV.delete("-R")
+            @rackup_path = ARGV.delete(@ourargs[@ourargs.index("-R") + 1])
+            if @rackup_path and File.file?(@rackup_path)
+              return @rackup_path
+            else
+              $stderr.puts "rackup does not exist at #{@rackup_path} (given with -R)"
+            end
+          end
+          # 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
+          raise "Cannot find path to rackup, please supply full path to rackup with -R"
+        end # }}}
+
+        def is_running?(pid) # {{{
+          if is_windows?
+            wmi = WIN32OLE.connect("winmgmts://")
+            processes, ours = wmi.ExecQuery("select * from win32_process where ProcessId = #{pid}"), []
+            processes.each { |process| ours << process.Name }
+            ours.first.nil?
+          else
+            begin
+              prio = Process.getpriority(Process::PRIO_PROCESS, pid)
+              true
+            rescue Errno::ESRCH
+              false
+            end
+          end
+        end # }}}
+
+        def check_running?(pid_file) # {{{
+          return false unless File.file?(pid_file)
+          is_running?(File.read(pid_file).to_i)
+        end # }}}
+
+        def find_pid(pid_file) # {{{
+          if pid_file.nil? or not File.file?(pid_file)
+            pid_file = default_pidfile
+          end
+          unless File.file?(pid_file)
+            $stderr.puts "Could not find running process id."
+            return false
+          end
+          pid_file
+        end # }}}
+      end # End helper methods }}}
+
+      class Cmd # This class contains the command methods {{{
+        include Helpers
+        attr_accessor :command
+
+        def initialize(args = nil)
+          args ||= ARGV
+          raise "arguments must be an array!" unless args.respond_to?(:detect)
+          @ourargs = args.dup
+          @command = args.detect { |arg| arg.match(/^(?:--?)?(?:start|stop|restart|create|h(?:elp)?|v(?:ersion)?|console|status)/) }
+          if command.nil?
+            @command = ""
+          else
+            args.delete(@command)
+          end
+          ARGV.replace(args)
+        end
+
+        # {{{ #run is called when we're interactive ($0 == __FILE__)
+        def self.run(args = nil)
+          cmd = new(args)
+          case cmd.command
+          when /^(?:--?)?status$/
+            cmd.status(cmd.command)
+          when /^(?:--?)?restart$/
+            cmd.stop(cmd.command)
+            cmd.start
+          when /^(?:--?)?start$/
+            cmd.start
+          when /^(?:--?)?create$/
+            cmd.create(cmd.command)
+          when /^(?:--?)?stop$/
+            if cmd.stop(cmd.command)
+              puts "Ramazement has ended, go in peace."
+              $stdout.flush
+            else
+              puts "Ramaze failed to stop (or was not running)"
+            end
+          when /^(?:--?)?console$/
+            require "ramaze"
+            require "irb"
+            require "irb/completion"
+            Ramaze.options.started = true
+            require "start"
+            IRB.start
+            puts "Ramazement has ended, go in peace."
+          when /^(?:--?)?h(elp)?$/
+            puts cmd.usage
+          when /^(?:--?)?v(ersion)?$/
+            cmd.include_ramaze
+            puts Ramaze::VERSION
+            exit
+          when /^$/
+            puts "Must supply a valid command"
+            puts cmd.usage
+            exit 1
+          else
+            puts "#{command} not implemented"
+            puts cmd.usage
+            exit 1
+          end
+        end # }}}
+
+        def include_ramaze # {{{
+          begin
+            $:.unshift File.join(File.dirname(__FILE__), '/../lib')
+            require 'ramaze'
+          rescue LoadError
+            $:.shift
+
+            begin
+              require 'rubygems'
+            rescue LoadError
+            end
+            require 'ramaze'
+          end
+        end # }}}
+
+        def usage # {{{
+          txt = [
+            "\n  Usage:",
+            "ramaze <start [PIDFILE]|stop [PIDFILE]|restart [PIDFILE]|status [PIDFILE]|create PROJECT|console> [ruby/rack options]\n",
+            "Commands:\n",
+            "  * All commands which take an optional PIDFILE (defaults to PROJECT.pid otherwise).",
+            "  * All commands which start a ramaze instance will default to webrick on port 7000",
+            "    unless you supply the rack options -p/--port PORT and/or * -s/--server SERVER.\n",
+            " start   - Starts an instance of this application.\n",
+            " stop    - Stops a running instance of this application.\n",
+            " restart - Stops running instance of this application, then starts it back up.  Pidfile",
+            "           (if supplied) is used for both stop and start.\n",
+            " status  - Gives status of a running ramaze instance\n",
+            " create  - Creates a new prototype Ramaze application in a directory named PROJECT in",
+            "           the current directory.  ramaze create foo would make ./foo containing an",
+            "           application prototype. Rack options are ignored here.\n",
+            " console - Starts an irb console with app.rb (and irb completion) loaded. This command",
+            "           ignores rack options, ARGV is passed on to IRB.\n\n\t"
+          ].join("\n\t")
+
+          if is_windows?
+            txt << %x{ruby #{rackup_path} --help}.split("\n").reject { |line| line.match(/^Usage:/) }.join("\n\t")
+          else
+            txt << %x{#{rackup_path} --help}.split("\n").reject { |line| line.match(/^Usage:/) }.join("\n\t")
+          end
+
+          txt.gsub(/^\t$/, '')
+        end # }}}
+
+        ### Methods for commands {{{
+        def start # {{{
+          include_ramaze
+
+          # Find the name of this app
+          app_name = default_pidfile.sub(/\.pid$/,'')
+          rack_args = []
+
+          if daemonize = @ourargs.detect { |arg| arg.match(/^(-[dD]|--daemonize)$/) }
+            if pid_arg = @ourargs.detect { |arg| arg.match(/^(-P|--pid)/) }
+              puts "User supplied pid: #{pid_arg}"
+              pid_file = @ourargs[@ourargs.index(pid_arg) + 1]
+              puts "Starting daemon with user defined pidfile: #{pid_file}"
+            else
+              puts "Starting daemon with default pidfile: #{pid_file = default_pidfile}"
+              rack_args += ["-P", pid_file]
+            end
+            if check_running?(pid_file)
+              $stderr.puts "Ramaze is already running with pidfile: #{pid_file}"
+              exit 127
+            end
+          end
+
+          port = Ramaze.options.adapter.port.to_s
+          rack_args += ["-p", port   ] if @ourargs.grep(/^(-p|--port)/).empty?
+
+          handler = Ramaze.options.adapter.handler.to_s
+          rack_args += ["-s", handler] if @ourargs.grep(/^(-s|--server)/).empty?
+
+          if is_windows?
+            exec("ruby", rackup_path.to_s, "config.ru", *(ARGV + rack_args))
+          else
+            exec(rackup_path.to_s, "config.ru", *(ARGV + rack_args))
+          end
+        end # }}}
+
+        def create(command) # {{{
+          opts = {}
+          if forced = @ourargs.detect { |arg| arg.match(/^(--force)/) }
+            puts "Overwriting any existing files as requested."
+            opts[:force] = true
+            @ourargs.delete(forced)
+          end
+          if amended = @ourargs.detect { |arg| arg.match(/^(--amend)/) }
+            puts "Only amending missing files as requested."
+            opts[:amend] = true
+            @ourargs.delete(amended)
+          end
+          project_name = @ourargs[@ourargs.index(command) + 1]
+          if project_name.nil?
+            $stderr.puts "Must supply a project name" if project_name.nil?
+            puts usage
+            exit 1
+          end
+          include_ramaze
+          require 'ramaze/tool/create'
+          Ramaze::Tool::Create.create(project_name, opts)
+        end # }}}
+
+        def stop(command) # {{{
+          unless pid_file = find_pid(@ourargs[@ourargs.index(command) + 1])
+            $stderr.puts "No pid_file found!  Cannot stop ramaze (may not be started)."
+            return false
+          end
+          pid = File.read(pid_file).to_i
+          puts "Stopping pid #{pid}"
+          Process.kill("INT", pid)
+          sleep 2
+          if is_running?(pid)
+            $stderr.puts "Process #{pid} did not die, forcing it with -9"
+            Process.kill(9, pid)
+            File.unlink(pid_file) if File.file?(pid_file)
+            true
+          else
+            File.unlink(pid_file) if File.file?(pid_file)
+            true
+          end
+        end # }}}
+
+        def status(command) # {{{
+          unless pid_file = find_pid(@ourargs[@ourargs.index(command) + 1])
+            $stderr.puts "No pid_file found! Ramaze may not be started."
+            exit 1
+          end
+          puts "Pid file #{pid_file} found, PID is #{pid = File.read(pid_file)}"
+          unless is_running?(pid.to_i)
+            $stderr.puts "PID #{pid} is not running"
+            exit 1
+          end
+          if is_windows?
+            wmi = WIN32OLE.connect("winmgmts://")
+            processes, ours = wmi.ExecQuery("select * from win32_process where ProcessId = #{pid}"), []
+            processes.each { |p| ours << [p.Name, p.CommandLine, p.VirtualSize, p.CreationDate, p.ExecutablePath, p.Status ] }
+            puts "Ramaze is running!\n\tName: %s\n\tCommand Line: %s\n\tVirtual Size: %s\n\tStarted: %s\n\tExec Path: %s\n\tStatus: %s" % ours.first
+          else
+            require "pathname"
+            # Check for /proc
+            if File.directory?(proc_dir = Pathname.new("/proc"))
+              proc_dir = proc_dir.join(pid)
+              # If we have a "stat" file, we'll assume linux and get as much info
+              # as we can
+              if File.file?(stat_file = proc_dir.join("stat"))
+                stats = File.read(stat_file).split
+                puts "Ramaze is running!\n\tCommand Line: %s\n\tVirtual Size: %s\n\tStarted: %s\n\tExec Path: %s\n\tStatus: %s" % [
+                  File.read(proc_dir.join("cmdline")).split("\000").join(" "),
+                  "%s k" % (stats[22].to_f / 1024),
+                  File.mtime(proc_dir),
+                  File.readlink(proc_dir.join("exe")),
+                  stats[2]
+                ]
+                exit
+              end
+            end
+            # Fallthrough status, just print a ps
+            puts "Ramaze process #{pid} is running!"
+            begin
+              puts %x{ps l #{pid}}
+            rescue
+              puts "No further information available"
+            end
+          end
+        end # }}}
+
+        ### End of command methods }}}
+      end # }}}
+    end
+  end
+end
+
+if $0 == __FILE__
+  Ramaze::Tool::Bin::Cmd.run(ARGV)
+end