doozer 0.2.0

data/lib/doozer/scripts/console.rb

@@ -0,0 +1,2 @@
+require 'doozer'
+Doozer::Initializer.console(@env)

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=2
+    PATCH=0
+    STRING=[MAJOR, MINOR, PATCH].join('.')
+  end
+end

data/lib/doozer/view_helpers.rb

@@ -0,0 +1,251 @@
+require 'digest/sha1'
+
+module Doozer
+  
+  # ViewHelpers which are included in Controllers and Partials
+  module ViewHelpers
+    
+    # Returns a url from a hash of options. Expects option keys as symbols.
+    #
+    # :name - the route.name to parse additional options with
+    #
+    # :base_url - the base url of the request
+    #
+    # => route tokens are replace the key/values pairs in the options. if a route token is found in the options it is replaced with a 'MISSING-key' string.
+    #
+    # => all remaining options are added as key=value query string parameters
+    #
+    # You can also pass a opt as a string which just passed it through.
+    #
+    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 and account for formats on the end of the path
+          tokens = route.tokens
+          tokens.last.gsub!(Regexp.compile("\.#{route.format.to_s}$"), '') if route.format != :html if not route.tokens.empty?
+          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
+    
+    # Creates an html anchor tag.
+    #
+    # text - the text of the anchor tag
+    # 
+    # opt - a hash of options which are passed to url(opt)
+    #
+    # prop - a hash of anchor tag attributes to add to the link
+    def link(text='', opt={}, prop={})
+      "<a href=\"#{url(opt)}\"#{hash_to_props(prop)}>#{text}</a>"
+    end
+    
+    # Creates an img tag.
+    #
+    # path - the src of the image tag
+    #
+    # prop - a hash of image tag attributes
+    def img(path, prop={})
+      path = timestamp_path(path)
+      "<img src=\"#{path}\"#{hash_to_props(prop)} />"
+    end
+    
+    # Creates a stylesheet link tag.
+    #
+    # path - the href of the link tag
+    #
+    # prop - a hash of link tag attributes.
+    #
+    # => Defaults to :rel=>'stylesheet', :type=>'text/css', :media=>'all'
+    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
+
+    # Creates a link tag for feeds.
+    #
+    # opt - a hash of options which are passed to url(opt)
+    #
+    # prop - a hash of link tag attributes.
+    #
+    # => Example: :rel=>'alternate', :type=>'application/rss+', :media=>'all'
+    def feed(opt={}, prop={})
+      "<link #{hash_to_props(prop)} href=\"#{url(opt)}\" />"
+    end
+
+    # Creates a script tag.
+    #
+    # path - the src of the javascript tag
+    #
+    # prop - a hash of script tag attributes.
+    #
+    # => Defaults to: :type=>'text/javascript'
+    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
+
+    # Creates metatags
+    #
+    # retuns a differnt metatag for each key/value added to @view[:meta] hash. See Doozer::Controller#meta for adding examples.
+    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
+
+    # Creates an authtoken form element
+    #
+    # By default, all post requests expect this value to be present unless overrided with Doozer::Controller#after_initialize
+    #
+    # You can customize the elemement id by passing arg[:id] to the method.
+    #
+    # The value contains an checksum of the app_name and cookie sid
+    def authtoken(args={})
+      id = args[:id] if args[:id]
+      "<input type=\"hidden\" id=\"#{id}_authtoken\" name=\"_authtoken\" value=\"#{generate_authtoken(@request.cookies['sid'])}\" />"
+    end
+
+    # Turns a hash of key/value pairs in to a key1="value1" key2="value2" key3="value3"
+    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
+
+    # Turns a hash of key/value pairs in querystring like key1=value%201&key2=value2&key3=value3
+    #
+    # All values are CGI.escaped for output
+    def hash_to_qs(opt={})
+      props=[]
+      opt.each { | key, value | 
+        props.push("#{key.to_s}=#{CGI::escape(value.to_s)}") 
+      }
+      props.join("&")
+    end    
+    
+    # Safe encodes a string by entity encodes all less then and greater then signs
+    #
+    def h(s)
+      s.gsub!(/</,'&lt;')
+      s.gsub!(/>/,'&gt;')
+      return s
+    end
+    
+    # Returns the base url configured in app.yml
+    #
+    def base_url
+      Doozer::Configs.base_url
+    end
+
+    # Returns the env setting the application was loaded under (:development, :deployment, or :test)
+    #
+    def rack_env
+      Doozer::Configs.rack_env
+    end
+
+    # Returns the app name configured in app.yml
+    #
+    def app_name
+      Doozer::Configs.app_name
+    end
+
+    # Returns the app path the application was loaded in. This defaults to the path all scripts were executed from. In general, this is the root of your project directory unless specified otherwise.
+    #
+    def app_path
+      Doozer::Configs.app_path
+    end
+    
+    # Returns the ip address of the server
+    # 
+    # Automatically accounts for proxied requests and returns HTTP_X_FORWARDED_FOR if present.
+    def ip
+      if addr = @env['HTTP_X_FORWARDED_FOR']
+        addr.split(',').last.strip
+      else
+        @env['REMOTE_ADDR']
+      end
+    end
+
+    # Returns the domain name of the request
+    #
+    def server_name
+      @env['SERVER_NAME']
+    end
+
+    # Returns the request path
+    #
+    def path
+        @env['REQUEST_PATH']
+    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