doozer 0.2.0

data/lib/doozer/rackup/server.ru

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+APP_PATH = Dir.pwd
+require File.join(APP_PATH, 'config/boot')
+
+#--boot it up
+Doozer::Initializer.boot(env)
+
+#--hookup the logger for production only since the base rackup builder doesn't load it. this avoids double logging in development
+use Rack::CommonLogger, Doozer::Configs.logger if Doozer::Configs.rack_env == :deployment
+
+#--map root to doozer
+map "/" do
+	# use Rack::ShowExceptions
+	if Doozer::Configs.rack_env != :deployment
+	  use Rack::Reloader, secs=1
+	end
+	
+	use Rack::Static, {:urls => Doozer::Configs.app["static_urls"], :root => "#{APP_PATH}/#{Doozer::Configs.app["static_root"]}"} if Doozer::Configs.app
+
+	use Rack::Session::Cookie, :key => 'rack.session',
+	                           :domain => '',
+	                           :path => '/',
+	                           :expire_after => 2592000
+	
+	run Doozer::App.new(args=options)
+end
+
+#--stack additional rack apps
+begin
+	require "#{APP_PATH}/config/rack"
+	stack()
+rescue => e
+	Doozer::Configs.logger.error(e)
+end

data/lib/doozer/rackup/test.rb

@@ -0,0 +1,20 @@
+""" 
+  script to bootstrap the doozer/rackup/server.ru in test mode
+  since rackup doesn't call Rackup::Builder in test (in rackup this is 'none') mode
+  
+"""
+
+config = File.expand_path(File.join(File.dirname(__FILE__), 'server.ru'))
+env = :test
+cfgfile = File.read(config)
+if cfgfile[/^#\\(.*)/]
+  opts.parse! $1.split(/\s+/)
+end
+ru=[]
+ru.push("options = {:Port => 5000, :Host => '127.0.0.1', :AccessLog => []}")
+ru.push("app = Rack::Builder.new do")
+ru.push("use Rack::CommonLogger")
+ru.push(cfgfile)
+ru.push("end.to_app") 
+ru.push("Rack::Handler::Mongrel.run app, :Port => 5000")
+app = eval "Rack::Builder.new {( " + ru.join("\n") + "\n )}.to_app", nil, config

data/lib/doozer/redirect.rb

@@ -0,0 +1,12 @@
+module Doozer
+  class Redirect < RuntimeError
+    attr_accessor :url
+    attr_reader :status
+    
+    def initialize(url, opts={})
+      super "redirect"
+      @url=(url=="") ? "/" : url
+      @status = (opts[:status]) ? opts[:status] : nil
+    end
+  end
+end

data/lib/doozer/route.rb

@@ -0,0 +1,292 @@
+require 'doozer/app'
+
+module Doozer
+  module Routing
+    
+    
+    # Route manager for drawing and adding routes.
+    class Routes
+      @@parts=[] # stored as [route.name, route.path]
+      @@dict={}  # route hash
+      @@cache={} # lookup for matches
+      @@magics=[] # hold raw magic routes before processing
+      @@inner_apps={} # holds the app dedicated to processing this path
+      
+      def self.draw(&block)
+        # p "draw routes"
+        instance_eval(&block) if block_given?
+
+        # init magic routes :conrtoller/:action or just /:action with predefined :controller
+        # Routes.init_magic_routes
+        
+        # sort routes here
+        @@parts.sort! do |a, b| a[1].length <=> b[1].length end
+        @@parts.reverse!
+        printf "Routes drawn and sorted...\n"
+        # @@parts.each { | i | p i[1] }
+      end
+      
+      
+      # An empty path defaults to a path of '/'
+      def self.add(name=nil, path=nil, args=nil)
+        # p name
+        # p path
+        # p args.inspect
+        if not name.nil? and not path.nil? and not args.nil?
+          args = Routes::init_formats(args)
+          formats = args[:formats]
+          # p formats.inspect
+          for format in formats
+            args.delete(:formats)
+            if name != :magic
+              path = '/' if path == ''
+              
+              raise Doozer::Exceptions::Route.new("Route name must be a symbol. #{name} given.") if not name.kind_of? Symbol
+              raise Doozer::Exceptions::Route.new("Route already exists with the name of #{name}.") if @@dict[name]
+              @@parts.each { |p| raise Doozer::Exceptions::Route.new("Route already defined with a path of '#{path}'") if p[1] == path }
+              parts = [name, path, args]
+              # p parts.inspect
+              args[:format] = format
+              route = Doozer::Routing::Route.new(parts)
+              # p route.inspect
+              @@parts.push([route.name, route.path])
+              @@dict[route.name] = route
+            else
+              p "magic routes init turned off"
+              # Routes.magic(parts)
+            end
+          end
+        end
+      end
+      
+      # sets up default formats to initialize a mapped route
+      def self.init_formats(args)
+        formats = args[:formats]
+        formats = [] if formats.nil?
+        formats.push(:html) if not formats.include?(:html)
+        args[:formats] = formats
+        return args
+      end
+      
+      # return a route by name
+      def self.get_by_name(name)
+        # p @@dict.inspect
+        return @@dict[name]
+      end
+      
+      # return the route which matches the request path
+      def self.match(path)
+          # p path
+          # p @@cache.inspect
+          # return @@dict[@@cache[path]] if @@cache[path]
+          for part in @@parts
+            route = @@dict[part[0]]
+            # p route.inspect
+            if route.match(path)
+              # Routes.cache_request_path(route, path)
+              return route
+            end
+          end
+          return nil
+      end
+      
+      # caches the request path and with the route.name
+      def self.cache_request_path(route,path)
+        # p "route cache request path"
+        @@cache[path] = route.name
+      end
+      
+      def self.magic(route)
+        @@magics.push(route)
+      end
+      
+      def self.init_magic_routes
+          @@controllers={}
+          controller_files = Dir.glob(File.join(File.dirname(__FILE__),'../app/controllers/*_controller.rb'))
+          
+          if controller_files.length > 0
+            i=0
+            for f in controller_files
+              break if i==0 and f.index('application_controller.rb')
+              if f.index('application_controller.rb')
+                controller_files.insert(0, controller_files.delete(f))
+                break
+              end
+              i+=1
+            end
+          end
+          
+          controller_files.each {|f|
+            require f
+            key = f.split("controllers/")[1].split("_controller.rb")[0]
+            if key.index("_")
+              value = key.split('_').each{ | k | k.capitalize! }.join('') 
+            else
+              value = key.capitalize
+            end
+            @@controllers[key.to_sym] = "#{value}Controller"
+            # p "cache controller: #{key.to_sym}"
+          }
+          # p @@controllers.inspect
+          # grab all controllers
+          routes = []
+          dup_lu = {}
+          obj = Doozer::Controller
+          obj.public_instance_methods.each { | name | dup_lu[name]=''}
+          # p dup_lu.inspect
+          
+          @@magics.each { | route |
+            path = route[1]
+            if path.index(':controller') and path.index(':action')
+              ## loop all controller and then loop all #methods
+              @@controllers.each{ |key,value | 
+                klass = Object.const_get(value)
+                methods = klass.public_instance_methods()
+                methods.push('index')
+                methods.uniq! # filter duplicate indexes
+                methods.each { | val | 
+                  if dup_lu[val].nil?
+                    controller= route[2][:controller] || key.to_s
+                    action = route[2][:action] || val
+                    # p "#{controller}##{action}"
+                    name = "#{controller}_#{action}".to_sym
+                    new_path = path.gsub(/:controller/, controller).gsub(/:action/,action)
+                    new_path = new_path.gsub(/\/index/) if new_path.endswith('/index')
+                    new_path = "/#{new_path}" if not new_path =~ /^\//
+                    add([name, new_path, {:controller=>controller, :action=>action, :status=>200, :formats=>route[2][:formats]}])
+                  end
+                }
+              }
+            elsif path.index(':action') and not route[2][:controller].nil?
+              ## loop all methods on this controller
+              #p "load route controller:" + @@controllers[route[2][:controller].to_sym].inspect
+              controller= route[2][:controller]
+
+              klass = Object.const_get(@@controllers[controller.to_sym])
+              methods = klass.public_instance_methods()
+              methods.push('index')
+              methods.uniq! # filter duplicate indexes
+              methods.each { | val | 
+                if dup_lu[val].nil?
+                  action = val
+                  # p "#{controller}##{action}"
+                  name = "#{controller}_#{action}".to_sym
+                  new_path = path.gsub(/:action/,action)
+                  new_path = new_path.gsub(/\/index/,'') if new_path =~ /\/index/
+                  new_path = "/#{new_path}" if not new_path =~ /^\//
+                  
+                  # p [name, new_path, {:controller=>controller, :action=>action, :status=>200}].inspect
+                  add([name, new_path, {:controller=>controller, :action=>action, :status=>200, :formats=>route[2][:formats]}])
+                end
+              }
+            end
+          }
+          
+          ## make sure to route index to '/'
+          ## loop route/methods pairs
+          # save new path for action controller
+      end
+    end
+
+    class Route
+      attr_accessor :name, :path, :controller, :action, 
+                    :layout, :status, :content_type, :tokens, 
+                    :grouping, :app, :format, :view, :view_path
+                    
+                    
+      # Initializes a route with the following parameters
+      # route - [:name, 'path', {args}]
+      def initialize(route)
+        #p "Doozer::Route#new: #{route}"
+        args = route[2]
+        @controller = args[:controller]
+        @action = args[:action]
+        @layout = (args[:layout]) ? args[:layout] : 'default'
+        @status = (args[:status]) ? args[:status] : 200
+        @app=args[:app]
+        @format = (args[:format]) ? args[:format] : :html
+        #@content_type = (args[:content_type]) ? args[:content_type] : 'text/html'
+        case @format
+          when :js
+            content_type = 'text/javascript'
+          when :xml
+            content_type = 'text/xml'
+          when :json
+            content_type = 'application/json'
+          when :rss
+            content_type = 'application/rss+xml'
+          when :atom
+            content_type = 'application/atom+xml'
+          else
+            content_type = 'text/html'
+        end
+        @content_type = content_type
+        @tokens = []
+        path = route[1]
+        path = '/' if path == ''
+        @path = (@format == :html) ? path : "#{path}.#{format}"
+        @name = (@format == :html) ? route[0] : "#{route[0]}_#{format.to_s}".to_sym
+        @layout = "default_#{@format.to_s}".to_sym if @format != :html and @layout == 'default'
+        
+        @view = "#{@action}_#{@format.to_s}"
+        @view_path = "#{@controller}/#{@action}.#{@format.to_s}.erb"
+        regify()
+      end
+      
+      # Creates the Regex grouping for matching and parsing route tokens
+      def regify
+        if (@path.index('/'))
+          grouping = []
+          url = @path.split('/')
+          for part in url
+              if /^:/.match(part) 
+                token = part.gsub(/:/,'')
+                # part = '(?P<'+token+'>.)'
+                # part = '(\.*)'
+                # part = '(\w*)'
+                part = '([a-zA-Z0-9,-.%_~;]*)' # this picks up all allowable route tokens (a-zA-Z0-9,-.%)
+                @tokens.push(token)
+              end
+              grouping.push(part)
+          end
+          out = "^#{grouping.join('/')}"
+          out += ".#{@format.to_s}" if @format != :html # we need to include the 
+          @grouping = Regexp.compile(out)
+        else
+          #handle default index route
+          @grouping = Regexp.compile("/")
+        end
+      end
+    
+      # Matches a request path against a route.path if a direct match or route.grouping
+      def match(path)
+        # p "#{path} vs #{@path}" 
+        # p path =~ @grouping
+        # short-circut for root
+        return false if path == '/' and @path != '/' #handles root condition
+        # short-circut for exact match with no tokens
+        return true if path == @path
+        # test for tokens
+        pass=(path =~ @grouping) == 0 ? true : false
+        # p @tokens.inspect if pass
+        if @tokens.empty?; pass=false if @path != path; end #handles root condition '/'
+        pass=false if path.split('/').length != @path.split('/').length #handles the root condition /:token
+        return pass
+      end
+      
+      # Parses route tokens and creates a hash of extra params
+      def extra_params(path)
+        hashish = {}
+        params = @grouping.match(path)
+        # make sure to remove the format from the last token
+        @tokens.last.gsub!(Regexp.compile("\.#{@format.to_s}$"), '') if @format != :html if not @tokens.empty?
+        i = 1
+        for token in @tokens
+          hashish[token.to_sym] = params[i]
+          i += 1 
+        end        
+        return hashish
+      end
+    end
+  end
+end

data/lib/doozer/scripts/cluster.rb

@@ -0,0 +1,126 @@
+#= start/stop/restart webserver(s)
+# This file is required in script/cluster. 
+#
+# Navigate to your app root and run it with the following commands.
+#
+# script/cluster
+# -C command (start || stop || restart || test)
+# -E environment (default: development || deployment)
+# -D (daemonize) - This is automatically initialized in deployment mode. There should be no need to pass this unless you want to test it out in development mode.
+# -h Hellllpppp!!!
+require 'optparse'
+
+APP_PATH = Dir.pwd if APP_PATH.nil?
+config =  Doozer::Configs.symbolize_keys( YAML.load(File.read(File.join(APP_PATH,'config/app.yml'))) )
+clusters = Doozer::Configs.symbolize_keys(config[:clusters])
+
+@command = nil
+@env = :development
+@daemonize = ''
+@server = clusters[:server]
+@config = DOOZER_PATH + '/doozer/rackup/server.ru'
+@test_config = DOOZER_PATH + '/doozer/rackup/test.rb'
+@apps = []
+
+for app in clusters[:apps]
+  ip = app.split(':')[0]
+  port = app.split(':')[1]
+  @apps.push({:ip=>ip, :port=>port})
+end
+
+# Automatically starts a test instance of your appserver on http://localhost:5000. (No -E flag is required for this command).
+def test
+  cmd = "rackup #{@test_config}" 
+  printf "Command: #{cmd} -p 5000 -E test -o 127.0.0.1\n"
+  system(cmd)
+end
+
+# <b>development</b>: Only starts the first configured (if more then one) address:port
+#
+# <b>deployment</b>: Automatically starts a new instance of your appserver for each defined cluster address:port
+def start
+  printf "Starting clusters...\n"
+  for app in @apps
+    if @env == :deployment
+      #need to check if application has a pid file so we don't start
+      pid_file = "#{APP_PATH}/log/doozer.#{app[:port]}.pid"
+      raise "pid file already exists for #{pid_file}" if File.exist?(pid_file)
+      cmd = "rackup #{@config} -p #{app[:port]} -E #{@env.to_s} -s #{@server} -o #{app[:ip]} #{@daemonize} -P #{pid_file}" 
+      printf "Command: #{cmd}\n"
+      system(cmd)
+    else
+      cmd = "rackup #{@config} -p #{app[:port]} -E #{@env.to_s} -s #{@server} -o #{app[:ip]}" 
+      printf "Command: #{cmd}\n"
+      system(cmd)
+      break
+    end
+  end
+  printf "Did they start?\n"
+  system("ps -aux | grep rackup")
+end
+
+# Calls stop() and then start()
+def restart
+  stop
+  start
+end
+
+# <b>development</b>: Only stops the first configured (if more then one) address:port
+#
+# <b>deployment</b>: Automatically stops all instances of your appserver for each defined cluster address:port
+def stop
+  system("ps -aux | grep rackup")
+  printf "Stoping clusters...\n"
+  for app in @apps
+    if @env == :deployment
+      pid_file = "#{APP_PATH}/log/doozer.#{app[:port]}.pid"
+      printf "Reading pid from #{pid_file}\n" 
+      if File.exist?(pid_file)
+        File.open(pid_file, 'r'){ | f | 
+          pid = f.gets.to_i
+          printf "Shutting down process #{pid}\n"
+          system("kill -9 #{pid}")
+
+        }
+        File.delete(pid_file) 
+      else
+        printf "pid file doesn't exist\n"
+      end
+    end
+  end
+  system("ps | grep rackup")
+end
+
+opts = OptionParser.new("", 24, '  ') { |opts|
+  opts.banner = "Usage: script/cluster -C [command] -E [environment] -h"
+  opts.separator ""
+  opts.separator "Command options:"
+  opts.on("-C", "--command COMMAND", "start, stop, restart, or test") { | c |
+    @command = c.downcase.to_sym
+  }
+  opts.on("-E", "--env ENVIRONMENT", "default: development || deployment") { | e |
+    @env = e.downcase.to_sym
+  }
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+    
+  opts.parse! ARGV
+}
+
+@daemonize = '-D' if @env == :deployment
+
+case @command
+  when :start
+    start()
+  when :restart
+    restart()
+  when :stop
+    stop()
+  when :test
+    test()
+end
+
+
+