grippy-doozer 0.1.0

data/lib/doozer/controller.rb

@@ -0,0 +1,335 @@
+# load gems
+%w(rack erb).each { |dep| require dep } 
+
+# load doozer modules
+# %w(doozer/lib doozer/extend doozer/logger doozer/view_helpers doozer/route doozer/partial).each { |dep| require dep }
+
+# autoload all models
+# Dir.glob(File.join(File.dirname(__FILE__),'../app/models/*.rb')).each {|f| require f }
+
+module Doozer
+
+  # This is the main Controller class which is inherited by application controllers.
+  #
+  # Controllers have access to all ViewHelpers.
+  class Controller
+    
+    # @route variable containing the route instance
+    attr_accessor :route
+    # @env variable passed from the Rack request
+    attr_accessor :env
+    # @request variable. See Rack request for additional methods. http://rack.rubyforge.org/doc/Rack/Request.html
+    attr_accessor :request
+    # @params variable which is a symbolized hash of all querystring values
+    attr_accessor :params
+    # @flash variable containing a hash of strings which are persisted in the flash cookie across the response, next request/response and then removed.
+    attr_accessor :flash
+    # @session variable containing a hash of strings which are persisted in the session cookie until the browser session expires.
+    attr_accessor :session
+    # @view variable containing a hash of string which are read from layouts.
+    attr_accessor :view
+    # @bust_key variable which is appended to img sources and script sources via view_helpers in development mode
+    attr_accessor :bust_key
+    # @format variable which is a symbol
+    attr_accessor :format
+    # @port variable holing the port number of the appserver handling the request
+    attr_accessor :port
+    # @render_args variable containing a hash of values to use while rendering the request
+    attr_accessor :render_args
+
+    include Doozer::Util::Logger
+    include Doozer::ViewHelpers
+
+    self.class_inheritable_accessor :after_initialize_exclude, :before_filter_exclude, :after_filter_exclude, :require_view_helpers
+    
+    # Array of actions to exclude from calling after_initialize.
+    #
+    # Example: self.after_initialize_exclude=[:action_1, :action_2]
+    self.after_initialize_exclude=[]
+
+    # Array of actions to exclude from calling before_filter.
+    #
+    # Example: self.before_filter_exclude=[:action_1, :action_2]
+    self.before_filter_exclude=[]
+
+    # Array of actions to exclude from calling after_filter.
+    #
+    # Example: self.after_filter_exclude=[:action_1, :action_2]
+    self.after_filter_exclude=[]
+
+    # Array of actions to exclude from calling require_view.
+    #
+    # Example: self.require_view_helpers=[:application, :helper_1]
+    self.require_view_helpers=[]
+
+    # When a Controller is intialized it expects the following args:
+    #
+    # args={
+    #   :route=>route matched against the request path,
+    #   :extra_params=>the route tokens parameterized as a hash,
+    #   :port=>the port of the appserver responding to the request
+    # }
+    #
+    # * :extra_params are turned into instance variables so you can access them directly from controller methods and views. In order to keep a small footprint these aren't passed into partial classes.
+    # 
+    # Example: A route of /admin/post/:id and a request path of /admin/post/8 automatically exposes an instance variable of @id with a value of 8 in your controller.
+    #
+    # * query params are accessible via @params hash and are parameterized via Rack.
+
+    def initialize(args={})
+      @route = args[:route]; @env = args[:env]
+      @format = @route.format
+      @port = args[:port]
+
+      #init request from env
+      @request = Rack::Request.new(@env)
+      
+      #holds all variables for template binding
+      @view={}; @view[:meta]={}
+      
+      #store flash
+      @flash={}; flash_from_cookie()
+      
+      #store session
+      @session={}; session_from_cookie()
+            
+      #symbolize params
+      @params={}; @request.params.each { |key, value| @params[key.to_sym] = value} 
+      
+      #set bust key
+      @bust_key = (rand(1000) * 1024)
+      
+      # set up default render_args
+      @render_args = {:layout=>nil, :view=>nil, :text=>nil}
+      render_args_init()
+      
+      #turn extra params into instance variables...
+      args[:extra_params].each { |key, value| self.instance_variable_set("@#{key}".to_sym, value)}
+      logger.info("       Params: #{@request.params.inspect}") if not @request.params.nil?
+      logger.info("       Extra params: #{args[:extra_params].inspect}") if not args[:extra_params].nil?
+    end
+    
+    # Renders an action with any of the following overridable parameters:
+    #
+    # args={
+    #   :view=>Symbol, String or ERB,
+    #   :layout=>Symbol,
+    #   :text=>'this is the text to render'
+    # }
+    #
+    # :view - All actions default to a view of views/controller_name/action_name.format.erb which is originated from the route properties.
+    #
+    # To override this from controller actions, you can pass any of the following:
+    #
+    # * :view=>:view_name
+    #
+    #   This assumes the view is in the same controller as the present action.
+    #
+    # * :view=>'controller_name/action_name'
+    #
+    #   This renders a view from a the provided controller and action and with the format specified in the route.
+    #
+    # * :view=>ERB.new('<%=var%> is nice')
+    #
+    # :layout - All actions default to a layout of views/layouts/default.format.erb
+    #
+    # To override this from controller actions, you can pass any of the following:
+    #
+    # * :layout=>:layout_name_format or :none (don't display a layout at all)
+    #
+    #   There is no need to specify the format for :html formats. 
+    #
+    #   Example: :layout=>:some_layout (where format equals :html) or :some_layout_json (where format equals :json)
+    #
+    # :text - Overrides all view rendering options and displays an ERB template with the provided text string. 
+    #
+    # A layout is rendered unless its overriden or the route was declared without one.
+    #
+    # To override this from controller actions, you can pass any of the following:
+    def render(args={})
+      change_layout(args[:layout]) if args[:layout]
+      change_view(args[:view]) if args[:view]
+      change_view(ERB.new(args[:text])) if args[:text]
+      
+    end
+    
+    # This method is called from the appserver controller handler.
+    def render_result
+        layout = @render_args[:layout]
+        view = @render_args[:view]
+        if layout.kind_of? Symbol # this handles the layout(:none)
+          view.result(binding)
+        else
+          @view[:timestamp] = "<!-- server: #{@port} / rendered: #{Time.now()} / env: #{rack_env} -->"
+          @view[:body] = view.result(binding)
+          # layout = @layout if layout.nil? # this handles the layout(:some_other_layout) case for formats
+          layout.result(binding)
+        end
+    end
+    
+    # A method to render a partial from a controller. Expects a file name and optional local variables. See Partial for more details.
+    #
+    # By default, the @request variable is appended to locals and available in the partial view. 
+    def partial(file=nil, locals={})
+      # self.instance_variables.each { | k | 
+      #   locals[k.gsub(/@/,'').to_s] = eval(k)
+      # }
+      # p locals.inspect
+      locals[:request] = @request
+      Doozer::Partial.partial(file, locals, route=@route)
+    end
+        
+    # Redirect the response object to the tokenized route url with optional query string values
+    #
+    # The route is passed through the ViewHelpers.url method. See url() for examples.
+    def redirect_to(route={}, opts={})
+      path = url(route)
+      # p "Redirect to: #{path}"
+      raise Doozer::Redirect.new(path, opts)
+    end
+
+    # Sequel ORM db connection
+    def db
+      Doozer::Configs.db_conn
+    end
+    
+    # Compile flash keys as name=value array which are stored in the flash cookie. The flash variables are only persisted for one response.
+    def flash_to_cookie
+      #loop over all flash messages and return as name/value array
+      out=[]; @flash.each { |key, value| out.push("#{key}=#{CGI::escape(value.to_s)}") }
+      return out
+    end
+
+    # Read all the flash cookies and store them in the @flash instance variable
+    def flash_from_cookie
+      #split name/value pairs and merge with flash
+      if @request.cookies
+        if @request.cookies["flash"]
+          pairs=@request.cookies["flash"].split('&')
+          pairs.each{|pair| 
+            pair = pair.split('=')
+            @flash[pair[0].to_sym]=CGI::unescape(pair[1])
+          }
+        end
+      end
+    end
+
+    # Compile session keys as name=value array which are eventually stored as cookies.
+    def session_to_cookie
+      #loop over all flash messages and return as name/value array
+      out=[]; @session.each { |key, value| out.push("#{key}=#{CGI::escape(value.to_s)}") }
+      return out
+    end
+
+    # Read all the session cookies and store them in the @session instance variable
+    def session_from_cookie
+      #split name/value pairs and merge with flash
+      if @request.cookies
+        if @request.cookies["session"]
+          pairs=@request.cookies["session"].split('&')
+          pairs.each{|pair| 
+            pair = pair.split('=')
+            @session[pair[0].to_sym]=CGI::unescape(pair[1])
+          }
+        end
+      end
+    end
+    
+    # Method for setting metatags via Controllers. 
+    #
+    # Pass an options hash to meta and all the keys are turned into metatags with the corresponding values.
+    #
+    # Example: meta({:description=>'The awesome metatag description is awesome', :keywords=>'awesome, blog, of awesomeness'})
+    def meta(opt={})
+      @view[:meta]=opt
+    end
+    
+    # DEPRECATED: use render() instead
+    def layout(sym)
+      raise "Deprecated: Controller#layout; Use render({:layout=>:symbol}) instead"
+    end
+    
+    # Controller hook called after controller#initialize call.
+    #
+    # By default, this method automatically checks if the authtoken is present for post requests. It throws an error if it's missing or has been tampered with.
+    def after_initialize
+      # test if request == post and if so if authtoken is present and valid
+      if @request.post?
+        token=@params[:_authtoken]
+        if token
+          raise "Doozer Authtoken Tampered With!" if not authtoken_matches?(token)
+        else
+          raise "Doozer Authtoken Missing! By default, post requests require an authtoken. You can override this by adding the action to the after_initialize_exclude list." if not authtoken_matches?(token)
+        end
+      end
+    end
+    
+    # Controller hook called before controller#method call
+    def before_filter; end
+    
+    # Controller hook called after controller#method call
+    def after_filter; end
+
+    # Include additional view helpers declared for the class.
+    #
+    # This method automatically appends '_helper' to each required helper symbol
+    def self.include_view_helpers
+        # importing view helpers into controller
+        self.require_view_helpers.each { | sym |
+          self.include_view_helper("#{sym.to_s}_helper")
+        }
+    end
+
+    # Include the app/helpers file_name. Expects helper as a string. 
+    #
+    # You must pass the full file name if you use this method.
+    #
+    # Example: self.include_view_helper('application_helper')
+    def self.include_view_helper(helper)
+        # importing view helpers into controller
+        include Object.const_get(Doozer::Lib.classify("#{helper}"))
+    end
+      
+    private
+    def render_args_init
+      if not [301, 302].include?(@route.status)
+        # view = (@format == :html) ? "#{@route.name.to_s}_html".to_sym : @route.
+        view = @route.view.to_sym
+        layout = (@route.layout.kind_of? String) ? @route.layout.to_sym : @route.layout
+        render({
+          :view=>view,
+          :layout=>layout
+        })
+      end
+    end
+
+    def change_layout(sym)
+      if sym == :none
+        layout=sym
+      else
+        #this needs to look up the layout and reset layout to this erb template
+        lay = Doozer::App.layouts[sym]
+        raise "Can't find layout for #{sym}" if lay.nil?
+        layout = lay
+      end
+      @render_args[:layout] = layout
+    end
+
+    def change_view(args)
+      if args.kind_of? Symbol
+        # implies we're using the same controller as the current controller with a view name of :view_name
+        view = Doozer::App.views[@route.controller.to_sym][args]
+      elsif args.kind_of? String
+        # implies 
+        controller = (args.index('/')) ? args.split('/')[0].to_sym : @route.controller.to_sym
+        action = (args.index('/')) ? args.split('/')[1] : args
+        action = "#{action}_#{@format.to_s}".to_sym
+        view = Doozer::App.views[controller][action]
+      elsif args.kind_of? ERB
+        view = args
+      end
+      view = ERB.new("Missing view for controller#action") if view.nil?
+      @render_args[:view] = view
+    end
+  end
+end  

data/lib/doozer/extend.rb

@@ -0,0 +1,10 @@
+# 
+# Load some of the rails active_support/core_ext class extensions which are used by Doozer.
+# All of these are automtically loaded if active_record is used but we need to provide them incase
+#
+require 'doozer/active_support/array'
+require 'doozer/active_support/object'
+require 'doozer/active_support/class'
+require 'doozer/active_support/time'
+require 'doozer/active_support/date_time'
+

data/lib/doozer/initializer.rb

@@ -0,0 +1,95 @@
+module Doozer
+  
+  # This is the main class which facilitates booting Doozer components and hooks.
+  # 
+  # Calling boot initializes Doozer in the following order:
+  # 1. Doozer::Configs
+  # 2. require ORM
+  # 3. require root/config/environment.rb
+  # 4. call after_orm_init
+  # 5. require Doozer::App
+  # 6. call before_rackup_init
+  class Initializer
+    @@after_orm = []
+    @@before_rackup = []
+
+    # env - :development, :deployment, or :test
+    def self.boot(env)
+      #--load configs
+      require 'doozer/configs'
+      Doozer::Configs.load(env)
+      
+      #--load orm
+      Doozer::Initializer.orm
+
+      #--load environment hooks
+      Doozer::Initializer.environment
+
+      #--call the after_orm_init features
+      Doozer::Initializer.after_orm_init
+
+      #--load app
+      require 'doozer/app'
+
+      #--call the before_rackup_init features
+      Doozer::Initializer.before_rackup_init
+    end
+        
+    # Checks to see if an ORM gem (active_record, data_mapper, or sequel) is specified in database.yml and loads it.
+    def self.orm
+      begin
+      # load orm layer (if required)
+        if not Doozer::Configs.orm.nil? and not Doozer::Configs.db.nil?
+          require "doozer/orm/#{Doozer::Configs.orm}"
+          Doozer::ORM.load 
+        end
+      rescue => e
+        Doozer::Configs.logger.error(e)
+      end
+    end
+
+    # Requires the root/config/environment.rb hooks. 
+    #
+    # This is where you can place your code to initialize additional plugins for models, extend ruby, or whatever else yor app requires.
+    # 
+    #=== Example environment.rb
+    # Time::DATE_FORMATS[:month_and_year] = "%B %Y"
+    # 
+    # Doozer::Initializer.after_orm do | config |
+    #   p "Extending some ORM, yo!"
+    # end
+    #
+    # Doozer::Initializer.before_rackup do | config |
+    #   p "Before rackup, horray for rackup!"
+    # end
+    def self.environment
+      begin
+        require "#{Dir.pwd}/config/environment"
+      rescue => e
+        Doozer::Configs.logger.error(e)
+      end
+    end
+
+    # Primary hook for extending/overriding ORM. Code block is pushed onto an array which allows for multiple hooks throughtout different files.
+    # 
+    # &block - code to execute after ORM is intialized
+    def self.after_orm(&block)
+      @@after_orm.push(block) if block_given?
+    end
+    
+    # Primary hook for adding/overriding Doozer::ViewHelpers methods. Code block is pushed onto an array which allows for multiple hooks throughtout different files.
+    #
+    # &block - code to execute after prior to Doozer.App.new being intialized. 
+    def self.before_rackup(&block)
+      @@before_rackup.push(block) if block_given?
+    end
+
+    private
+    def self.after_orm_init
+        @@after_orm.each{ | block | instance_eval(&block)}
+    end
+    def self.before_rackup_init
+        @@before_rackup.each{ | block | instance_eval(&block)}
+    end
+  end
+end

data/lib/doozer/lib.rb

@@ -0,0 +1,32 @@
+module Doozer
+  class Lib
+    
+    #Return a ClassName as string from an underscored string. 
+    # example: input "example_class" > "ExampleClass"
+    def self.classify(klass)
+      if klass.index('_')
+        klass = klass.split('_')
+        parts = []
+        klass = klass.each { | part | 
+          parts.push(part.capitalize)
+        }
+        klass = parts.join('')
+      else
+        klass.capitalize!
+      end
+    end
+    
+    #Returns a one-level deep folder/file structure and preservers underscores for filename. 
+    # example: input "folder_some_file_name" > "folder/some_file_name"
+    def self.pathify_first(s)
+      if s.index('_')
+        parts = s.split('_')
+        folder = parts[0]
+        file = parts.slice(1, parts.length).join('_')
+        s = "#{folder}/#{file}"
+      end
+      s
+    end
+        
+  end
+end

data/lib/doozer/logger.rb

@@ -0,0 +1,11 @@
+module Doozer
+  module Util
+    module Logger
+    
+      def logger
+        Doozer::Configs.logger
+      end
+
+    end
+  end
+end

data/lib/doozer/orm/active_record.rb

@@ -0,0 +1,19 @@
+require 'active_record'
+module Doozer
+  module ORM
+    def self.load
+      db_config = Doozer::Configs.db()
+      # ActiveRecord::Base.allow_concurrency = true
+      ActiveRecord::Base.establish_connection(
+        :adapter  => db_config["adapter"],
+        :host     => db_config["host"],
+        :username => db_config["username"],
+        :password => db_config["password"],
+        :database => db_config["database"]
+      )
+      p "ORM: #{Doozer::Configs.orm()} initialized..."
+      p "ORM: logging initialized"
+      ActiveRecord::Base.logger = Doozer::Configs.logger 
+    end
+  end
+end

data/lib/doozer/orm/data_mapper.rb

@@ -0,0 +1,19 @@
+require 'dm-core'
+module Doozer
+  
+  # See for more info => http://datamapper.org/doku.php?id=getting_started_with_datamapper
+  module ORM
+    def self.load
+      db_config = Doozer::Configs.db()
+      DataMapper.setup(:default, {
+        :adapter  => db_config["adapter"],
+        :database => db_config["database"],
+        :username => db_config["username"],
+        :password => db_config["password"],
+        :host     => db_config["host"]
+      })
+      p "ORM: #{Doozer::Configs.orm()} initialized..."
+      DataMapper::Logger.new(STDOUT, :debug)
+    end
+  end
+end

data/lib/doozer/orm/sequel.rb

@@ -0,0 +1,18 @@
+require 'sequel'
+module Doozer
+  module ORM
+    
+    # See for details => http://sequel.rubyforge.org/rdoc/index.html
+    def self.load
+      db_config = Doozer::Configs.db()
+      Doozer::Configs.db_conn = Sequel.connect({
+        :adapter  => db_config["adapter"],
+        :database => db_config["database"],
+        :username => db_config["username"],
+        :password => db_config["password"],
+        :host     => db_config["host"]
+      }) 
+      p "ORM: #{Doozer::Configs.orm} initialized..."
+    end
+  end
+end

data/lib/doozer/partial.rb

@@ -0,0 +1,99 @@
+require "erb"
+require "doozer/lib"
+require "doozer/view_helpers"
+
+module Doozer
+  
+  # This class facilitates loading and rendering of partials.
+  #
+  # A partial is an ERB template which starts with an underscore. They behave the same as action view ERB template with the only difference of not having access to Controller instance variables.
+  #
+  # An example partial: app/views/controller_name/_partial.html.erb
+  #
+  # By default, the Doozer scaffold creates an app/views/global folder which can be used to place global partials like headers, footers, etc.
+  #
+  # Partials have access to Doozer::ViewHelpers.
+  #
+  # All view helpers in app/helpers are automatically included in the Partial class during app initialize.
+  #
+  # A partial can render another partial and so on and so on.
+  class Partial
+    attr_accessor :erb, :route
+    
+    include ERB::Util
+    include Doozer::Util::Logger
+    include Doozer::ViewHelpers
+    
+    APP_PATH = Dir.pwd
+    @@partials={}
+    
+    def initialize(erb, locals, route)
+      @erb = erb
+      @route = route
+      if locals.kind_of? Hash
+        locals.each_pair {|key, value| 
+          #p "#{key}:#{value}"
+          self.instance_variable_set("@#{key}".to_sym, value) # :@a, value
+        }
+      end
+    end
+    
+    def bind
+      @erb.result(binding)
+    end
+
+    # This class method lazily loads and caches the erb templates of the requested partials
+    def self.partial(file=nil, locals={}, route=route)
+      #p "Class method: Doozer::Partial#partial"
+      if file.index("/").nil?
+        name = "#{route.controller}/_#{file}" 
+      else
+        name = "#{file.gsub(/\//,'/_')}"
+      end
+      load_partial(name) if  @@partials[name].nil?
+      erb = @@partials[name]
+      if erb
+          partial = Doozer::Partial.new(erb, locals, route)
+          partial.bind()
+      else
+        p "no partial exists for #{file}"
+      end
+    end
+    
+    # Renders and returns a partial template with the given file_name and local variables.
+    #
+    # * file - expects a string. By default, if you don't pass a controller, it's assumed the lookup location is the current route.controller path in the views folder.
+    #   You must omit the underscore when passing the file_name. 
+    #   A partial is automatically assumed to be html format. It shouldn't matter if you display an html partial inside a view with a different format.
+    #
+    # * locals - All local key/values are instantiated as instance variables acessable from the partial template. The controller.request variable is appended to locals and is also accessable as an instance variable from the partial template.
+    def partial(file=nil, locals={})
+      locals[:request] = @request if not @request.nil?
+      Doozer::Partial.partial(file, locals, route=@route)
+    end
+
+    # Load and cache partial ERB template with the given file_name.
+    def self.load_partial(name)
+      file = File.join(APP_PATH,"/app/views/#{name}.html.erb")
+      results = []
+      begin
+        File.new(file, "r").each { |line| results << line }
+        # TODO: throw error if doesn't exist
+        @@partials[name] = ERB.new(results.join(""))
+      rescue
+        p "sorry couldn't load partial #{name} (#{file})"
+      end
+    end    
+    
+    # Class methods for clearing all cached partials. Mainly a dispatcher for the file watcher to pick up new changes without having to restart the appserver in development mode.
+    def self.clear_loaded_partials
+      @@partials = {}
+    end
+    
+    # Class method for including a view helper.
+    def self.include_view_helper(helper)
+      m = Doozer::Lib.classify(helper) 
+      include Object.const_get(m)
+    end
+  end
+end

data/lib/doozer/plugins/paginate/init.rb

@@ -0,0 +1,2 @@
+PAGINATE_PLUGIN_ROOT = File.join(File.dirname(__FILE__), 'lib')
+require "#{PAGINATE_PLUGIN_ROOT}/paginate"