doozer 0.2.0

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,12 @@
+module Doozer
+  module Util
+    module Logger
+      
+      # Helper function for returning logger.
+      def logger
+        Doozer::Configs.logger
+      end
+
+    end
+  end
+end

data/lib/doozer/orm/active_record.rb

@@ -0,0 +1,28 @@
+require 'active_record'
+module Doozer
+  module ORM
+    def self.load
+      db_config = Doozer::Configs.db()
+      #ActiveRecord::Base.allow_concurrency = true
+        config = {
+          :adapter  => db_config["adapter"],
+          :host     => db_config["host"],
+          :username => db_config["username"],
+          :password => db_config["password"],
+          :database => db_config["database"]
+        }
+      config[:pool] = db_config["pool"] if db_config["pool"]
+      config[:reconnect] = db_config["reconnect"] if db_config["reconnect"]
+      
+      ActiveRecord::Base.establish_connection(config)
+      printf "ORM: #{Doozer::Configs.orm()} initialized...\n"
+      # printf "ORM: logging initialized"
+      ActiveRecord::Base.logger = Doozer::Configs.logger
+    end
+    
+    def self.after_request
+      ActiveRecord::Base.clear_active_connections!
+    end
+    
+  end
+end

data/lib/doozer/orm/data_mapper.rb

@@ -0,0 +1,22 @@
+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"]
+      })
+      printf "ORM: #{Doozer::Configs.orm()} initialized...\n"
+      DataMapper::Logger.new(STDOUT, :debug)
+    end
+    
+    def self.after_request; end
+    
+  end
+end

data/lib/doozer/orm/sequel.rb

@@ -0,0 +1,21 @@
+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"]
+      }) 
+      printf "ORM: #{Doozer::Configs.orm} initialized...\n"
+    end
+    
+    def self.after_request; 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
+        printf "--no partial exists for #{file}\n"
+      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(Doozer::Configs.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
+        printf "sorry couldn't load partial #{name} (#{file}) \n"
+      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"

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/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