grippy-doozer 0.1.0

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

@@ -0,0 +1,60 @@
+module Paginate
+
+  class InvalidPage < ArgumentError
+    def initialize(page, page_num)
+      super "#{page.inspect} given as value, which translates to '#{page_num}' as page number"
+    end
+  end
+  
+  class Collection < Array
+    attr_reader :current_page, :per_page, :total_entries, :total_pages
+
+    def initialize(page, per_page, total = nil)
+      @current_page = page.to_i
+      raise InvalidPage.new(page, @current_page) if @current_page < 1
+      @per_page = per_page.to_i
+      raise ArgumentError, "`per_page` setting cannot be less than 1 (#{@per_page} given)" if @per_page < 1
+      
+      self.total_entries = total if total
+    end
+
+    def self.create(page, per_page, total = nil)
+      pager = new(page, per_page, total)
+      yield pager
+      pager
+    end
+
+    def out_of_bounds?
+      current_page > total_pages
+    end
+
+    def offset
+      (current_page - 1) * per_page
+    end
+
+    def previous_page
+      current_page > 1 ? (current_page - 1) : nil
+    end
+
+    def next_page
+      current_page < total_pages ? (current_page + 1) : nil
+    end
+    
+    def total_entries=(number)
+      @total_entries = number.to_i
+      @total_pages   = (@total_entries / per_page.to_f).ceil
+    end
+
+    def replace(array)
+      result = super
+      
+      # The collection is shorter then page limit? Rejoice, because
+      # then we know that we are on the last page!
+      if total_entries.nil? and length < per_page and (current_page == 1 or length > 0)
+        self.total_entries = offset + length
+      end
+
+      result
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module Paginate
+  module Finder
+  
+    def self.included(base)
+      base.extend ClassMethods
+      class << base
+        # alias_method_chain :method_missing, :paginate
+        # # alias_method_chain :find_every,     :paginate
+        define_method(:per_page) { 30 } unless respond_to?(:per_page)
+      end
+    end
+
+    module ClassMethods
+
+      def paginate(*args)
+        options = args.pop
+        page, per_page, total_entries = paginate_parse_options(options)
+
+        finder = (options[:finder] || 'find').to_s
+
+        if finder == 'find'
+          # an array of IDs may have been given:
+          total_entries ||= (Array === args.first and args.first.size)
+          # :all is implicit
+          args.unshift(:all) if args.empty?
+        end
+
+        Paginate::Collection.create(page, per_page, total_entries) do |pager|
+          count_options = options.except :page, :per_page, :total_entries, :finder
+          find_options = count_options.except(:count).update(:offset => pager.offset, :limit => pager.per_page) 
+          
+          args << find_options
+          # @options_from_last_find = nil
+          pager.replace(send(finder, *args) { |*a| yield(*a) if block_given? })
+          
+          # magic counting for user convenience:
+          pager.total_entries = paginate_count(count_options, args, finder) unless pager.total_entries
+        end
+        
+        
+      end
+
+      def paginate_parse_options(options)
+        raise ArgumentError, 'parameter hash expected' unless options.respond_to? :symbolize_keys
+        options = options.symbolize_keys
+        raise ArgumentError, ':page parameter required' unless options.key? :page
+    
+        if options[:count] and options[:total_entries]
+          raise ArgumentError, ':count and :total_entries are mutually exclusive'
+        end
+
+        page     = options[:page] || 1
+        per_page = options[:per_page] || self.per_page
+        total    = options[:total_entries]
+        [page, per_page, total]
+      end
+    
+      # Does the not-so-trivial job of finding out the total number of entries
+      # in the database. It relies on the ActiveRecord +count+ method.
+      def paginate_count(options, args, finder)
+        excludees = [:count, :order, :limit, :offset, :readonly]
+        excludees << :from unless ActiveRecord::Calculations::CALCULATIONS_OPTIONS.include?(:from)
+
+        # we may be in a model or an association proxy
+        klass = (@owner and @reflection) ? @reflection.klass : self
+
+        # Use :select from scope if it isn't already present.
+        options[:select] = scope(:find, :select) unless options[:select]
+
+        if options[:select] and options[:select] =~ /^\s*DISTINCT\b/i
+          # Remove quoting and check for table_name.*-like statement.
+          if options[:select].gsub('`', '') =~ /\w+\.\*/
+            options[:select] = "DISTINCT #{klass.table_name}.#{klass.primary_key}"
+          end
+        else
+          excludees << :select # only exclude the select param if it doesn't begin with DISTINCT
+        end
+
+        # count expects (almost) the same options as find
+        count_options = options.except *excludees
+
+        # merge the hash found in :count
+        # this allows you to specify :select, :order, or anything else just for the count query
+        count_options.update options[:count] if options[:count]
+
+        # forget about includes if they are irrelevant (Rails 2.1)
+        # if count_options[:include] and
+        #     klass.private_methods.include_method?(:references_eager_loaded_tables?) and
+        #     !klass.send(:references_eager_loaded_tables?, count_options)
+        #   count_options.delete :include
+        # end
+
+        # we may have to scope ...
+        counter = Proc.new { count(count_options) }
+
+        count = if finder.index('find_') == 0 and klass.respond_to?(scoper = finder.sub('find', 'with'))
+                  # scope_out adds a 'with_finder' method which acts like with_scope, if it's present
+                  # then execute the count with the scoping provided by the with_finder
+                  send(scoper, &counter)
+                # elsif finder =~ /^find_(all_by|by)_([_a-zA-Z]\w*)$/
+                #   # extract conditions from calls like "paginate_by_foo_and_bar"
+                #   attribute_names = $2.split('_and_')
+                #   conditions = construct_attributes_from_arguments(attribute_names, args)
+                #   with_scope(:find => { :conditions => conditions }, &counter)
+                else
+                  counter.call
+                end
+
+        count.respond_to?(:length) ? count.length : count
+      end    
+    
+    
+    end # ClassMethods
+    
+  end
+end

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

@@ -0,0 +1,37 @@
+module Paginate
+  module ViewHelpers
+    # default options that can be overridden on the global level
+    @@pagination_options = {
+      :class          => 'pagination',
+      :previous_label => '« Previous',
+      :next_label     => 'Next »',
+      :inner_window   => 4, # links around the current page
+      :outer_window   => 1, # links around beginning and end
+      :separator      => ' ', # single space is friendly to spiders and non-graphic browsers
+      :param_name     => :page,
+      :params         => {},
+      :page_links     => true,
+      :container      => true,
+      :debug          => false
+    }
+    mattr_reader :pagination_options
+
+    def paginate(collection, options={})
+      #Collection => :current_page, :per_page, :total_entries, :total_pages
+      opt = @@pagination_options
+      opt.update(options)
+      out=[]
+      if opt[:debug]
+        out.push("current_page:#{collection.current_page} / ")
+        out.push("per_page:#{collection.per_page} / ")
+        out.push("total_entries:#{collection.total_entries} / ")
+        out.push("total_pages:#{collection.total_pages} <br />")
+      end
+      out.push("<div class=\"pagination_container\">") if opt[:container]
+      out.push(link(opt[:previous_label], {:page=>collection.previous_page}.update(opt[:params]), {:class=>opt[:class]}) ) if collection.previous_page
+      out.push(link(opt[:next_label], {:page=>collection.next_page}.update(opt[:params]), {:class=>opt[:class]}) ) if collection.next_page
+      out.push("</div>") if opt[:container]
+      return out.join(opt[:separator])
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# = Doozer Paginate
+# This code was lifted (i mean...ported) from the WillPaginate gem for ActiveRecord with a few modifications.
+#
+# Not supported by this plugin but in WillPAginate: 
+# * Page numbers between 'Previous' and 'Next' links
+# * NamedScopes
+#
+# See http://wiki.github.com/mislav/will_paginate for more details on useage and license.
+require "#{PAGINATE_PLUGIN_ROOT}/paginate/collection"
+module Paginate
+  class << self
+    def enable_activerecord
+      return if ActiveRecord::Base.respond_to? :paginate
+      require "#{PAGINATE_PLUGIN_ROOT}/paginate/finder"
+      ActiveRecord::Base.send :include, Paginate::Finder
+    end
+    def enable_view_helpers
+      # return if Doozer::Initializer.respond_to? :paginate
+      require "#{PAGINATE_PLUGIN_ROOT}/paginate/view_helpers"
+      Doozer::Controller.send :include, Paginate::ViewHelpers
+      Doozer::Partial.send :include, Paginate::ViewHelpers
+    end
+  end
+end
+
+# Enable ActiveRecord if it's defined
+Paginate.enable_activerecord if defined? ActiveRecord
+
+# Load the View Helpers if Doozer::Initializer is loaded
+Doozer::Initializer.before_rackup do | config |
+  Paginate.enable_view_helpers
+end if defined? Doozer::Initializer

data/lib/doozer/rackup/server.ru

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'doozer'
+
+#--load initializers
+# require 'doozer/initializer'
+
+#--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 => "#{Dir.pwd}/#{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 "#{Dir.pwd}/config/rack"
+	stack()
+rescue => e
+	Doozer::Configs.logger.error(e)
+end

data/lib/doozer/rackup/test.rb

@@ -0,0 +1,19 @@
+""" 
+  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 = 'doozer/rackup/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 < Exception
+    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,264 @@
+require 'doozer/app'
+
+module Doozer
+  module Routing
+    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!
+        p "Routes drawn and sorted..."
+        # @@parts.each { | i | p i[1] }
+      end
+      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
+              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
+      
+      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
+      
+      def self.get_by_name(name)
+        # p @@dict.inspect
+        return @@dict[name]
+      end
+
+      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
+      
+      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
+      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 = :none if @format != :html and @layout == 'default'
+        
+        @view = "#{@action}_#{@format.to_s}"
+        @view_path = "#{@controller}/#{@action}.#{@format.to_s}.erb"
+        regify()
+      end
+    
+      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('/')}"
+          @grouping = Regexp.compile(out)
+        else
+          #handle default index route
+          @grouping = Regexp.compile("/")
+        end
+      end
+    
+      def match(path)
+        # p "#{path} vs #{@path}" 
+        # p path =~ @grouping
+        #short-circut for root
+        return false if path == '/' and @path != '/' #handles root condition
+        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
+    
+      def extra_params(path)
+        hashish = {}
+        params = @grouping.match(path)
+        i = 1
+        for token in @tokens
+          hashish[token.to_sym] = params[i]
+          i += 1 
+        end        
+        return hashish
+      end
+    end
+  end
+end