manveru-ramaze 2009.01 → 2009.04

data/Rakefile

@@ -1,228 +1,85 @@
-begin
-  require 'rubygems'
-rescue LoadError
-end
+begin; require 'rubygems'; rescue LoadError; end
 
 require 'rake'
 require 'rake/clean'
-require 'rake/packagetask'
 require 'rake/gempackagetask'
-require 'rake/rdoctask'
-
-require 'pp'
-require 'date'
 require 'time'
-require 'fileutils'
-
-include FileUtils
-
-$:.unshift File.join(File.dirname(__FILE__), "lib")
-
-require 'ramaze/version'
-load 'rake_tasks/conf.rake'
-load 'rake_tasks/maintenance.rake'
-load 'rake_tasks/spec.rake'
-load 'rake_tasks/coverage.rake'
-load 'rake_tasks/release.rake'
-load 'rake_tasks/git.rake'
-load 'rake_tasks/gem.rake'
-load 'rake_tasks/metric.rake'
-
-task :default => ['spec']
-task :test => ['spec']
-# task :package => ['jquery']
-
-desc 'download latest jquery and put in /lib/proto/public/js/jquery.js'
-task :jquery do
-  require 'open-uri'
-  $stdout.sync = true
-
-  File.open('lib/proto/public/js/jquery.js', 'w+') do |jquery|
-    remote = open('http://code.jquery.com/jquery-latest.js')
-    print "openend remote side, copying..."
-    while chunk = remote.read(4096)
-      print '.'
-      jquery.write(chunk)
-    end
-    puts " done."
-  end
-end
-
-desc 'Check gemspec file list against real file list'
-task :check_gemspec do
-  base_dir = File.expand_path(File.dirname(__FILE__))
-  gemspec_files = eval(File.read(File.join(base_dir,'ramaze.gemspec'))).files.map{|file|File.join(base_dir,file)}
-
-  deleted_files = gemspec_files.select{|file|!File.exists?(file)}.map{|file|file[(base_dir.size+1)..-1]}
-
-  added_files = Dir.glob(File.join(File.dirname(__FILE__),'**/*')).select do |file|
-    !gemspec_files.index(file)
-  end.map do |file|
-    file[(base_dir.size+1)..-1]
-  end.select do |file|
-    !( file == 'pkg' or file =~ /.*\.gem/ )
-  end
-
-  unless deleted_files.empty?
-    puts "The following files appear in the gemspec but cannot be found:"
-    deleted_files.each do |file|
-      puts "\t#{file}"
-    end
-  end
-  unless added_files.empty?
-    puts "The following files exist, but cannot be found in the gemspec:"
-    added_files.each do |file|
-      puts "\t#{file}"
-    end
-  end
-end
-
-task :rcov_dir do
-  mkdir_p 'doc/output/tools/rcov/'
-end
-
-desc "Generate HTML coverage report"
-task :rcov_summary => :rcov_dir do
-  `rcov --version`
-  raise LoadError, "Please `gem install rcov` first" if $?.exitstatus == 127
-  raise "Run `rake coverage` to generate coverage data first" unless File.exists? 'coverage.data'
-  sh "rcov --aggregate coverage.data -o doc/output/tools/rcov/"
-end
-
-desc "generate rdoc"
-task :rdoc => [:clean] do
-  sh "rdoc #{(RDOC_OPTS + RDOC_FILES).join(' ')}"
-end
-
-desc "generate improved allison-rdoc"
-task :allison => :clean do
-  opts = RDOC_OPTS
-  path = `allison --path`.strip
-  raise LoadError, "Please `gem install allison` first" if $?.exitstatus == 127
-  opts << %W[--template '#{path}']
-  sh "rdoc #{(RDOC_OPTS + RDOC_FILES).join(' ')}"
-end
-
-desc "create bzip2 and tarball"
-task :distribute => :gem do
-  sh "rm -rf pkg/ramaze-#{VERS}"
-  sh "mkdir -p pkg/ramaze-#{VERS}"
-  sh "cp -r {bin,doc,lib,examples,spec,Rakefile,README.markdown,rake_tasks} pkg/ramaze-#{VERS}/"
-
-  Dir.chdir('pkg') do |pwd|
-    sh "tar -zcvf ramaze-#{VERS}.tar.gz ramaze-#{VERS}"
-    sh "tar -jcvf ramaze-#{VERS}.tar.bz2 ramaze-#{VERS}"
-  end
-
-  sh "rm -rf pkg/ramaze-#{VERS}"
-end
-
-desc "show a todolist from all the TODO tags in the source"
-task :todo do
-  files = Dir[File.join(BASEDIR, '{lib,spec}', '**/*.rb')]
-
-  files.each do |file|
-    lastline = todo = comment = long_comment = false
-
-    File.readlines(file).each_with_index do |line, lineno|
-      lineno += 1
-      comment = line =~ /^\s*?#.*?$/
-      long_comment = line =~ /^=begin/
-      long_comment = line =~ /^=end/
-      todo = true if line =~ /TODO/ and (long_comment or comment)
-      todo = false if line.gsub('#', '').strip.empty?
-      todo = false unless comment or long_comment
-      if todo
-        unless lastline and lastline + 1 == lineno
-          puts
-          puts "vim #{file} +#{lineno}"
-        end
-
-        l = line.strip.gsub(/^#\s*/, '')
-        print '  ' unless l =~ /^-/
-        puts l
-        lastline = lineno
-      end
-    end
-  end
-end
-
-desc "opens a simple readline that makes making requests easier"
-task 'request' do
-  ARGV.clear
-  require 'open-uri'
-  require 'pp'
-
-  loop do
-    print 'do request? [enter] '
-    gets
-    begin
-      pp open('http://localhost:7000/xxx').read
-    rescue Object => ex
-      puts ex
-    end
-  end
-end
-
-desc 'listing of available traits per class/module'
-task 'traits' do
-  nodes = Hash.new{|h,k| h[k] = []}
-  Dir['lib/**/*.rb'].each do |file|
-    content = File.read(file)
-    traits = content.grep(/^\s*trait\s*:/)
-    traits.each do |trait|
-      space = content[0..content.index(trait)].scan(/^\s*(?:class|module)\s+(.*)$/)
-      space = space.flatten.join('::')
-      nodes[space] << trait.strip
-    end
-  end
-
-  nodes.each do |space, traits|
-    puts space
-    traits.each do |trait|
-      print '  ', trait, "\n"
-    end
-    puts
-  end
-end
-
-desc "Update doc/CHANGELOG"
-task 'doc/CHANGELOG' do
-  File.open('doc/CHANGELOG', 'w+') do |f|
-    f.puts `git log`
-  end
-end
-
-desc "#{README} to doc/README.html"
-task 'doc/README.html' => [README] do
-  sh "maruku #{README}"
-  mv 'README.html', 'doc/README.html'
-end
-
-desc "Compile the #{README} from the parts of doc/readme"
-task README do
-  require 'enumerator'
-
-  chapters = [
-    'About Ramaze',         'introduction',
-    'Features Overview',    'features',
-    'Basic Principles',     'principles',
-    'Installation',         'installing',
-    'Getting Started',      'getting_started',
-    'A couple of Examples', 'examples',
-    'How to find Help',     'getting_help',
-    'Appendix',             'appendix',
-    'And thanks to...',     'thanks',
-  ]
-
-  File.open(README, 'w+') do |readme|
-    readme.puts COPYRIGHT.map{|l| l[1..-1]}, ''
+require 'date'
 
-    chapters.each_slice(2) do |title, file|
-      file = File.join('doc', 'readme_chunks', "#{file}.txt")
-      chapter = File.read(file)
-      readme.puts "# #{title}", '', chapter
-      readme.puts '', '' unless title == chapters[-2]
-    end
-  end
-end
+PROJECT_SPECS = FileList[
+  'spec/{contrib,examples,ramaze,snippets}/**/*.rb',
+  'lib/proto/spec/*.rb'
+]
+
+PROJECT_MODULE = 'Ramaze'
+PROJECT_JQUERY_FILE = 'lib/proto/public/js/jquery.js'
+PROJECT_README = 'README.markdown'
+PROJECT_RUBYFORGE_GROUP_ID = 3034
+PROJECT_COPYRIGHT = [
+  "#          Copyright (c) #{Time.now.year} Michael Fellinger m.fellinger@gmail.com",
+  "# All files in this distribution are subject to the terms of the Ruby license."
+]
+
+# To release the monthly version do:
+# $ PROJECT_VERSION=2009.03 rake release
+
+GEMSPEC = Gem::Specification.new{|s|
+  s.name         = 'ramaze'
+  s.author       = "Michael 'manveru' Fellinger"
+  s.summary      = "Ramaze is a simple and modular web framework"
+  s.description  = s.summary
+  s.email        = 'm.fellinger@gmail.com'
+  s.homepage     = 'http://github.com/manveru/org'
+  s.platform     = Gem::Platform::RUBY
+  s.version      = (ENV['PROJECT_VERSION'] || Date.today.strftime("%Y.%m.%d"))
+  s.files        = `git ls-files`.split("\n").sort
+  s.has_rdoc     = true
+  s.require_path = 'lib'
+  s.bindir = "bin"
+  s.executables = ["ramaze"]
+  s.rubyforge_project = "ramaze"
+
+  s.add_dependency('rack',   '= 1.0.0')
+  s.add_dependency('innate', '= 2009.04')
+
+  # s.add_development_dependency('rack-test',  '>=0.1.0')
+  # s.add_development_dependency('json',       '>=1.1.3')
+  # s.add_development_dependency('erubis',     '>=2.6.4')
+  # s.add_development_dependency('ezamar')
+  # s.add_development_dependency('haml',       '~>2.0.9')
+  # s.add_development_dependency('hpricot',    '>=0.7')
+  # s.add_development_dependency('liquid',     '~>2.0.0')
+  # s.add_development_dependency('memcache',   '~>1.7.0')
+  # s.add_development_dependency('nagoro')
+  # s.add_development_dependency('Remarkably', '~>0.5.2')
+  # s.add_development_dependency('sequel',     '>=2.11.0')
+  # s.add_development_dependency('tagz',       '>=5.0.1')
+  # s.add_development_dependency('tenjin',     '~>0.6.1')
+
+  s.post_install_message = <<MESSAGE.strip
+============================================================
+
+Thank you for installing Ramaze!
+You can now do create a new project:
+# ramaze create yourproject
+
+============================================================
+MESSAGE
+}
+
+Dir['tasks/*.rake'].each{|f| import(f) }
+
+task :default => [:bacon]
+
+CLEAN.include %w[
+  **/.*.sw?
+  *.gem
+  .config
+  **/*~
+  **/{data.db,cache.yaml}
+  *.yaml
+  pkg
+  rdoc
+  ydoc
+  *coverage*
+]

data/bin/ramaze

@@ -1,80 +1,303 @@
 #!/usr/bin/env ruby
 
-begin
-  $:.unshift File.join(File.dirname(__FILE__), '../lib')
-  require 'ramaze'
-rescue LoadError
-  $:.shift
-
+def include_ramaze
   begin
-    require 'rubygems'
+    $:.unshift File.join(File.dirname(__FILE__), '/../lib')
+    require 'ramaze'
   rescue LoadError
+    $:.shift
+
+    begin
+      require 'rubygems'
+    rescue LoadError
+    end
+    require 'ramaze'
   end
-  require 'ramaze'
 end
 
-additions = lambda do |op|
-  op.separator ''
-  op.separator 'Specialized options:'
+def usage
+  txt = <<-TXT
+  Usage:
 
-  op.on('--create PROJECT', 'New application from proto') do |project_name|
-    require 'ramaze/tool/create'
-    Ramaze::Tool::Create.create(project_name)
-    exit
-  end
+    ramaze <start [PIDFILE]|stop [PIDFILE]|restart [PIDFILE]|status [PIDFILE]|create PROJECT|console> [ruby/rack options]
+
+    Commands:
+      * All commands which take an optional PIDFILE default to PROJECT.pid if you do not supply one.
+      * 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.
+
+      start   - Starts an instance of this application.
+
+      stop    - Stops a running instance of this application.
+
+      restart - Stops running instance of this application, then starts it back up.  Pidfile
+                (if supplied) is used for both stop and start.
 
-  op.on('-i', '--instant', "Start up with bare-bones Controller") do |instant|
-    require 'ramaze/controller/main'
+      status  - Gives status of a running ramaze instance
+
+      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.
+
+      console - Starts an irb console with app.rb (and irb completion) loaded. This command
+                ignores rack options, ARGV is passed on to IRB.
+TXT
+  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
+end
 
-  op.on('-e', '--execute STRING', String, "Execute string instead of a start.rb.") do |execute|
-    eval execute
+## Methods for commands {{{
+def start
+  # Find the name of this app
+  app_name = default_pidfile.sub(/\.pid$/,'')
+  added_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}"
+      added_args += ["-P", pid_file]
+    end
+    if check_running?(pid_file)
+      $stderr.puts "Ramaze is already running with pidfile: #{pid_file}"
+      exit 127
+    end
+  end
+  added_args += ["-p", "7000"] unless OURARGS.detect { |arg| arg.match(/^(-p|--port)/) }
+  added_args += ["-s", "webrick"] unless OURARGS.detect { |arg| arg.match(/^(-s|--server)/) }
+  if is_windows?
+    exec("ruby", rackup_path.to_s, "config.ru", *(ARGV + added_args))
+  else
+    exec(rackup_path.to_s, "config.ru", *(ARGV + added_args))
   end
 end
 
-runner = ARGV.reverse.find{|arg| File.file?(arg) }
-runner ||= 'start.rb' if File.file?('start.rb')
+def create(command)
+  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
+  opts = {}
+  if OURARGS.detect { |arg| arg.match(/^(--force)/) }
+    puts "Overwriting any existing files as requested."
+    opts[:force] = true
+  end
+  if OURARGS.detect { |arg| arg.match(/^(--amend)/) }
+    puts "Only amending missing files as requested."
+    opts[:amend] = true
+  end
+  include_ramaze
+  require 'ramaze/tool/create'
+  Ramaze::Tool::Create.create(project_name, opts)
+end
 
-if runner
-  overlay = {
-    :root => File.dirname(runner),
-    :runner => runner, :origin => :console,
-  }
+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
 
-  [overlay, ENV, ARGV].each do |opt|
-    Ramaze::Global.merge!(opt, &additions)
+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
 
-  runner = File.expand_path(runner)
-  
-  console = Ramaze::Global.console
+## End Command methods }}}
 
-  if console
-    ARGV.clear #Avoid passing args to IRB
+# 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
 
-    Ramaze.trait[:started] = true
-    require runner
+def is_windows?
+  return @is_win if @is_win
+  begin
+    require "win32ole"
+  rescue LoadError
+  end
+  @is_win ||= Object.const_defined?("WIN32OLE")
+end
 
-    require 'irb'
-    require 'irb/completion'
+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
 
-    ENV['IRBRC'] = ".irbrc" if File.exists? ".irbrc"
-    Ramaze.start! :run_loose => true
-    IRB.start
-    Ramaze.shutdown
+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
-  
-  daemonize = Ramaze::Global.daemonize
+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 helper methods }}}
+
+OURARGS = ARGV.dup
+command = ARGV.detect { |arg| arg.match(/^(?:--?)?(?:start|stop|restart|create|h(?:elp)?|v(?:ersion)?|console|status)/) }
+if command.nil?
+  command = ""
+else
+  ARGV.delete(command)
+end
 
-  unless daemonize.empty?
-    require 'ramaze/tool/daemonize'
-    Ramaze::daemonize(runner, daemonize)
+case command
+when /^(?:--?)?status$/
+  status(command)
+when /^(?:--?)?restart$/
+  stop(command)
+  start
+when /^(?:--?)?start$/
+  start
+when /^(?:--?)?create$/
+  create(command)
+when /^(?:--?)?stop$/
+  if stop(command)
+    puts "Ramazement has ended, go in peace."
+    $stdout.flush
   else
-    Ramaze.trait[:started] = true
-    require runner
-    Ramaze.start!
+    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 usage
+when /^(?:--?)?v(ersion)?$/
+  include_ramaze
+  puts Ramaze::VERSION
+  exit
+when /^$/
+  puts "Must supply a valid command"
+  puts usage
+  exit 1
 else
-  Ramaze::Global.merge!(ARGV, &additions)
-  puts Ramaze::Global.option_parser(&additions)
+  puts "#{command} not implemented"
+  puts usage
+  exit 1
 end
+