grippy-doozer 0.1.0

data/lib/doozer/scripts/cluster.rb

@@ -0,0 +1,132 @@
+#= 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 'rubygems'
+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}" 
+  p "Command: #{cmd} -p 5000 -E test -o 127.0.0.1"
+  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
+  p "Starting clusters..."
+  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}" 
+      p "Command: #{cmd}"
+      system(cmd)
+    else
+      cmd = "rackup #{@config} -p #{app[:port]} -E #{@env.to_s} -s #{@server} -o #{app[:ip]}" 
+      p "Command: #{cmd}"
+      system(cmd)
+      break
+    end
+  end
+  p "Did they start?"
+  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")
+  p "Stoping clusters..."
+  for app in @apps
+    if @env == :deployment
+      pid_file = "#{APP_PATH}/log/doozer.#{app[:port]}.pid"
+      p "Reading pid from #{pid_file}" 
+      if File.exist?(pid_file)
+        File.open(pid_file, 'r'){ | f | 
+          pid = f.gets.to_i
+          p "Shutting down process #{pid}"
+          system("kill -9 #{pid}")
+
+        }
+        File.delete(pid_file) 
+      else
+        p "pid file doesn't exist"
+      end
+    end
+  end
+  system("ps | grep rackup")
+end
+
+opts = OptionParser.new("", 24, '  ') { |opts|
+  opts.banner = "Usage: script/clusters -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
+
+
+

data/lib/doozer/scripts/migrate.rb

@@ -0,0 +1,108 @@
+#= Migrations
+# This file is required in script/migrate. It loads the specified migration from the project/db directory and runs the migration with the specified direction. 
+# Navigate to your project root and run it with the following commands.
+#
+# script/migrate 
+# -V version:direction  (example: 1:up || 1:down)
+# -E environment (default: development || deployment)
+# -h Hellllpppp!!!
+#
+#== Examples
+#
+# Suppose you have this file db/001_initial_schema.rb
+#
+#== Example for ActiveRecord
+#
+# class InitialSchema < ActiveRecord::Migration
+#   def self.up
+#   end
+#   def self.down
+#   end
+# end
+#
+#
+#== Example for DataMapper
+#
+# require 'dm-more'
+# class CreateUser
+#   def self.up
+#   end
+#   def self.down
+#   end
+# end
+#
+#== Example for Sequel
+#
+# class InitialSchema
+#   def self.db
+#     Doozer::Configs.db
+#   end
+#   def self.up
+#     db.create_table :examples do
+#     end
+#   end
+#   def self.down
+#     db.drop_table :examples
+#   end
+# end
+
+require 'optparse'
+@env = :development
+@version = nil
+@direction = nil
+
+opts = OptionParser.new("", 24, ' ') { |opts|
+  opts.banner = "Usage: script/migrate -V number:direction -E (default: development || deployment)"
+  opts.separator ""
+  opts.separator "Command options:"
+
+  opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development || deployment)") { |e|
+    @env = e.to_sym
+  }
+
+  opts.on("-V", "--version VERSION", "use VERSION to upgrade or downgrade to the correct version number") { | v |
+    if v.index(":up")
+      @direction = :up
+    elsif v.index(":down")
+      @direction = :down
+    else
+      raise "Missing direction. Must be -V (num:up || num:down)"
+    end
+    @version = v.split(":")[0].to_i
+  }
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+  
+  opts.parse! ARGV
+}
+
+raise "Missing Version and Direction in form of version:direction" if @version.nil? or @direction.nil?
+
+#--boot it up
+Doozer::Initializer.boot(@env)
+
+# need to grab all the current migrations. assumes there isn't a migration with 000_*_.rb
+migrations = [nil].concat( Dir.glob(File.join(APP_PATH,'db/*_*.rb')) )
+
+p "Loading migration files"
+p "Version: #{@version}"
+p "Direction: #{@direction}"
+
+if @version > 0
+  file = migrations[@version]
+  raise "Can't find file for this migration" if file.nil?
+  require file
+  p "Migrating #{file}"
+  klass = file.split("/").last.gsub(/\.rb/,"").split('_')
+  klass = Doozer::Lib.classify(klass.slice(1, klass.length).join('_'))
+  obj = Object.const_get(klass)
+  
+  case @direction
+  when :up
+    obj.up
+  when :down
+    obj.down
+  end
+end

data/lib/doozer/scripts/task.rb

@@ -0,0 +1,60 @@
+#= Tasks
+# This file is required in script/task.
+# Add files to /tasks where the specified task_name contains a class with TaskName and a 'run' class method.
+# Running a task automatically loads Doozer::Config and the specified ORM. You must require all other files your tasks require beyond these.
+# Navigate to your app root and run it with the following commands.
+#
+# script/clusters 
+# -T task_name
+# -E environment (default: development || deployment)
+# -h Hellllpppp!!!
+#
+#== Example
+# Suppose you have this file tasks/who_rocks.rb
+#
+# class WhoRocks
+#   def self.run
+#    p "You Do!"
+#   end
+# end
+#
+# run: script/task -T who_rocks
+require 'optparse'
+@env = :development
+@task = nil
+
+opts = OptionParser.new("", 24, ' ') { |opts|
+  opts.banner = "Usage: script/task -T task_name -E (default: development || deployment || test)"
+  opts.separator ""
+  opts.separator "Command options:"
+
+  opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development || deployment || test)") { |e|
+    @env = e.to_sym
+  }
+
+  opts.on("-T", "--task TASK", "run task_name") { | t |
+    @task = t
+  }
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.parse! ARGV
+}
+
+raise "Missing task_name" if @task.nil?
+
+#--boot it up
+Doozer::Initializer.boot(@env)
+
+if @task
+  file = File.join(APP_PATH, "tasks/#{@task}.rb")
+  raise "Can't find this task file #{@task}" if file.nil?
+  p "Running #{@task}"
+  klass = file.split("/").last
+  require file
+  klass = Doozer::Lib.classify(klass.gsub(/\.rb/,""))
+  Object.const_get(klass).run
+end

data/lib/doozer/scripts/test.rb

@@ -0,0 +1,23 @@
+# #!/usr/bin/env ruby
+require 'optparse'
+@command = nil
+
+opts = OptionParser.new("", 24, '  ') { |opts|
+  opts.banner = "Usage: script/test [command]"
+
+  opts.separator ""
+  opts.separator "Command options:"
+  opts.on("-C", "--command COMMAND", "setup (not implemented yet: unit, functional)") { | c |
+      @command = c.downcase.to_sym if c
+  }
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+  opts.parse! ARGV
+}
+
+case @command
+  when :setup
+    require 'test/setup'
+end

data/lib/doozer/version.rb

@@ -0,0 +1,8 @@
+module Doozer
+  module Version
+    MAJOR=0
+    MINOR=1
+    PATCH=0
+    STRING=[MAJOR, MINOR, PATCH].join('.')
+  end
+end

data/lib/doozer/view_helpers.rb

@@ -0,0 +1,163 @@
+require 'digest/sha1'
+
+module Doozer
+  module ViewHelpers
+
+    def url(opt)
+      url = ''
+      if opt.kind_of? Hash
+        # name (if present) trumps controller/action (if present)
+        if opt[:name]
+          # TODO: this needs to be only in dev mode
+          name = opt.delete(:name)
+          route = Doozer::Routing::Routes::get_by_name(name)
+          return "MISSING-ROUTE-for-name-#{name}" if route .nil?
+          url = "#{route.path}"
+
+          # we need to swap out the tokens here...
+          route.tokens.each {|token|
+            val = opt[token.to_sym]
+            if val
+              opt.delete(token.to_sym)
+            else  
+              val = "MISSING-#{token}" 
+            end
+            url.gsub!(/:#{token}/, val.to_s)
+          }
+        end
+
+        # set base _url
+        host = ""
+        if opt[:base_url]
+          host = opt.delete(:base_url)
+        end
+        # add qs pairs
+        if not opt.empty?
+          url += "?#{hash_to_qs(opt)}"
+        end
+        url = "#{host}#{url}"
+      elsif opt.kind_of? String
+        url = "#{opt}"
+      end
+      return url
+    end
+    
+    def link(text='', opt={}, prop={})
+      "<a href=\"#{url(opt)}\"#{hash_to_props(prop)}>#{text}</a>"
+    end
+  
+    def img(path, prop={})
+      path = timestamp_path(path)
+      "<img src=\"#{path}\"#{hash_to_props(prop)} />"
+    end
+    
+    def stylesheet(path, prop={})
+      #<link rel="stylesheet" type="text/css" media="all" href="/css/style.css" />
+      path = timestamp_path(path)
+      prop[:rel] = 'stylesheet' if prop[:rel].nil?
+      prop[:type] = 'text/css' if prop[:type].nil?
+      prop[:media] = 'all' if prop[:media].nil?
+      "<link #{hash_to_props(prop)} href=\"#{path}\" />"
+    end
+
+    def javascript(path, prop={})
+      path = timestamp_path(path)
+      prop[:type] = 'text/javascript' if prop[:type].nil?
+      "<script #{hash_to_props(prop)} src=\"#{path}\"></script>"
+    end
+
+    def metatags
+      #loop all metatags here...
+      out=[]
+      @view[:meta].each{ | key, value | 
+        out.push("""<meta name=\"#{key.to_s}\" content=\"#{h(value)}\" />
+                """)
+      }
+      out.join("")
+    end
+    
+    def hash_to_props(opt={})
+      props=[]
+      opt.each { | key, value | 
+        props.push("#{key.to_s}=\"#{value}\"")
+      }
+      return " #{props.join(" ")}" if props.length > 0
+      return ""
+    end
+
+    def hash_to_qs(opt={})
+      props=[]
+      opt.each { | key, value | 
+        props.push("#{key.to_s}=#{CGI::escape(value.to_s)}") 
+      }
+      props.join("&")
+    end    
+    
+    def h(s)
+      s.gsub!(/</,'&lt;')
+      s.gsub!(/>/,'&gt;')
+      return s
+    end
+    
+    def base_url
+      Doozer::Configs.base_url
+    end
+
+    def rack_env
+      Doozer::Configs.rack_env
+    end
+
+    def app_name
+      Doozer::Configs.app_name
+    end
+
+    def ip
+      if addr = @env['HTTP_X_FORWARDED_FOR']
+        addr.split(',').last.strip
+      else
+        @env['REMOTE_ADDR']
+      end
+    end
+
+    def server_name
+      @env['SERVER_NAME']
+    end
+
+    def path
+        @env['REQUEST_PATH']
+    end
+
+    def authtoken(args={})
+      id = args[:id] if args[:id]
+      "<input type=\"hidden\" id=\"#{id}_authtoken\" name=\"_authtoken\" value=\"#{generate_authtoken(@request.cookies['sid'])}\" />"
+    end
+
+    # test if this person has a session with keys in it...
+    def session?
+      @session.empty?
+    end
+
+    private
+    def timestamp_path(path)
+      # p Doozer::Configs.rack_env
+      return path if Doozer::Configs.rack_env == :deployment
+      if path.index('?').nil?
+        path = "#{path}?#{@bust_key}"
+      else
+        path = "#{path}&#{@bust_key}"
+      end
+    end
+    
+    ## check to see if form authtoken matches the one expected
+    ## phrase defaults to 'sid' which the default used for form authtokens
+    def authtoken_matches?(token, phrase=nil)
+      phrase = @request.cookies['sid'] if phrase.nil?
+      token == generate_authtoken(phrase)
+    end
+    
+    def generate_authtoken(phrase)
+      Digest::SHA1.hexdigest("--#{app_name}--#{phrase}--")
+    end
+
+  end
+end