trusty-cms 1.0.0

data/lib/trusty_cms/extension_loader.rb

@@ -0,0 +1,130 @@
+require 'trusty_cms/extension'
+require 'trusty_cms/extension_path'
+require 'method_observer'
+
+module TrustyCms
+  class ExtensionLoader
+    # The ExtensionLoader is reponsible for the loading, activation and reactivation of extensions. 
+    # The noticing of important subdirectories is now handled by the ExtensionPath class.
+
+    class DependenciesObserver < MethodObserver
+      # Extends the reload mechanism in ActiveSupport so that extensions are deactivated and reactivated
+      # when model classes are reloaded (in development mode, usually).
+      
+      attr_accessor :config
+
+      def initialize(rails_config) #:nodoc
+        @config = rails_config
+      end
+
+      def before_clear(*args) #:nodoc
+        ExtensionLoader.deactivate_extensions
+      end
+
+      def after_clear(*args) #:nodoc
+        ExtensionLoader.load_extensions
+        ExtensionLoader.activate_extensions
+      end
+    end
+
+    include Simpleton
+
+    attr_accessor :initializer, :extensions
+
+    def initialize #:nodoc
+      self.extensions = []
+    end
+
+    # Returns a list of paths to all the extensions that are enabled in the configuration of this application.
+    #
+    def enabled_extension_paths
+      ExtensionPath.enabled.map(&:to_s)
+    end
+
+    # Returns a list of all the paths discovered within extension roots of the specified type.
+    # (by calling the corresponding class method on ExtensionPath).
+    #
+    #   extension_loader.paths(:metal)         #=> ['extension/app/metal', 'extension/app/metal']
+    #   extension_loader.paths(:controller)    #=> ['extension/app/controllers', 'extension/app/controllers']
+    #   extension_loader.paths(:eager_load)    #=> ['extension/app/controllers', 'extension/app/models', 'extension/app/helpers']
+    #
+    # For compatibility with the old loader, there are corresponding +type_paths+ methods.
+    # There are also (deprecated) +add_type_paths+ methods. 
+    #
+    def paths(type)
+      ExtensionPath.send("#{type}_paths".to_sym)
+    end
+
+    # Loads but does not activate all the extensions that have been enabled, in the configured order 
+    # (which defaults to alphabetically). If an extension fails to load an error will be logged
+    # but application startup will continue. If an extension doesn't exist, a LoadError will be raised
+    # and startup will halt.
+    #
+    def load_extensions
+      configuration = TrustyCms::Application.config
+      @observer ||= DependenciesObserver.new(configuration).observe(::ActiveSupport::Dependencies)
+      self.extensions = configuration.enabled_extensions.map { |ext| load_extension(ext) }.compact
+    end
+    
+    # Loads the specified extension.
+    #
+    def load_extension(name)
+      extension_path = ExtensionPath.find(name)
+      begin
+        constant = "#{name}_extension".camelize
+        extension = constant.constantize
+        extension.unloadable
+        extension.path = extension_path
+        extension
+      rescue LoadError, NameError => e
+        $stderr.puts "Could not load extension: #{name}.\n#{e.inspect}"
+        nil
+      end
+    end
+    
+    # Loads all the initializers defined in enabled extensions, in the configured order.
+    #
+    def load_extension_initalizers
+      extensions.each &:load_initializers
+    end
+
+    # Deactivates all enabled extensions.
+    #
+    def deactivate_extensions
+      extensions.each &:deactivate
+    end
+
+    # Activates all enabled extensions and makes sure that any newly declared subclasses of Page are recognised.
+    # The admin UI and views have to be reinitialized each time to pick up changes and avoid duplicates.
+    #
+    def activate_extensions
+      initializer.initialize_views
+      extensions.each &:activate
+      Page.load_subclasses
+    end
+    alias :reactivate :activate_extensions
+
+    class << self
+      # Builds an ExtensionPath object from the supplied path, working out the name of the extension on the way.
+      # The ExtensionPath object will later be used to scan and load the extension.
+      # An extension name can be supplied in addition to the path. It will be processed in the usual way to 
+      # remove radiant- and -extension and any verion numbering.
+      #
+      def record_path(path, name=nil)
+        ExtensionPath.from_path(path, name)
+      end
+    
+      # For compatibility with old calls probably still to be found in some extensions.
+      #
+      %w{controller model view metal plugin load locale}.each do |type|
+        define_method("#{type}_paths".to_sym) do
+          paths(type)
+        end
+        define_method("add_#{type}_paths".to_sym) do |additional_paths|
+          ::ActiveSupport::Deprecation.warn("ExtensionLoader.add_#{type}_paths is has been moved and is deprecated. Please use TrustyCms.configuration.add_#{type}_paths", caller)
+          initializer.configuration.send("add_#{type}_paths".to_sym, additional_paths)
+        end
+      end
+    end
+  end
+end

data/lib/trusty_cms/extension_migrator.rb

@@ -0,0 +1,98 @@
+module TrustyCms
+  class ExtensionMigrator < ActiveRecord::Migrator
+    class << self
+      attr_accessor :extension
+
+      def migrate(target_version = nil)
+        super extension.migrations_path, target_version
+      end
+      
+      def migrate_extensions
+        TrustyCms::Application.config.enabled_extensions.each do |ext|
+          to_migrate = Extension.descendants.detect{|descendant| descendant.name == "#{ext.to_s.camelize}Extension" }
+          to_migrate.migrator.migrate
+        end
+      end
+
+      def get_all_versions
+        ActiveRecord::Base.connection.select_values("SELECT version FROM #{schema_migrations_table_name}").
+          select { |version| version.starts_with?("#{@extension.extension_name}-")}.
+          map { |version| version.sub("#{@extension.extension_name}-", '').to_i }.sort
+      end
+    end
+    
+    def initialize(direction, migrations_path, target_version = nil)
+      super
+      initialize_extension_schema_migrations
+      initialize_received_migrations
+    end
+    
+    private
+      def quote(s)
+        ActiveRecord::Base.connection.quote(s)
+      end
+      
+      def extension_name
+        self.class.extension.extension_name
+      end
+      
+      def version_string(version)
+        "#{extension_name}-#{version}"
+      end
+      
+      def initialize_extension_schema_migrations
+        current_version = ActiveRecord::Base.connection.select_value("SELECT schema_version FROM extension_meta WHERE name = #{quote(extension_name)}")
+        if current_version
+          assume_migrated_upto_version(current_version.to_i) 
+          ActiveRecord::Base.connection.delete("DELETE FROM extension_meta WHERE name = #{quote(extension_name)}")
+        end
+      end
+
+      def initialize_received_migrations
+        if donors = self.class.extension.migrates_from
+          donors.each do |extension_name, until_migration|
+            replaced = ActiveRecord::Base.connection.select_values("SELECT version FROM #{ActiveRecord::Migrator.schema_migrations_table_name} WHERE version LIKE '#{extension_name}-%'").map{|v| v.sub(/^#{extension_name}\-/, '').to_i}
+            replaced.delete_if{|v| v > until_migration.to_i} if until_migration
+            assume_migrated_upto_version(replaced.max) if replaced.any?
+          end
+        end
+      end
+      
+      def assume_migrated_upto_version(version)
+        version = version.to_i
+        sm_table = self.class.schema_migrations_table_name
+
+        migrated = self.class.get_all_versions
+        versions = Dir["#{@migrations_path}/[0-9]*_*.rb"].map do |filename|
+          filename.split('/').last.split('_').first.to_i
+        end
+
+        unless migrated.include?(version)
+          ActiveRecord::Base.connection.execute "INSERT INTO #{sm_table} (version) VALUES (#{quote(version_string(version))})"
+        end
+
+        inserted = Set.new
+        (versions - migrated).each do |v|
+          if inserted.include?(v)
+            raise "Duplicate migration #{v}. Please renumber your migrations to resolve the conflict."
+          elsif v < version
+            ActiveRecord::Base.connection.execute "INSERT INTO #{sm_table} (version) VALUES (#{quote(version_string(v))})"
+            inserted << v
+          end
+        end
+      end
+      
+      def record_version_state_after_migrating(version)
+        sm_table = self.class.schema_migrations_table_name
+
+        @migrated_versions ||= []
+        if down?
+          @migrated_versions.delete(version.to_i)
+          ActiveRecord::Base.connection.update("DELETE FROM #{sm_table} WHERE version = #{quote(version_string(version))}")
+        else
+          @migrated_versions.push(version.to_i).sort!
+          ActiveRecord::Base.connection.insert("INSERT INTO #{sm_table} (version) VALUES (#{quote(version_string(version))})")
+        end
+      end
+  end
+end

data/lib/trusty_cms/extension_path.rb

@@ -0,0 +1,200 @@
+module TrustyCms
+  class ExtensionPath
+    # This class holds information about extensions that may be loaded. It has two roles: to remember the 
+    # location of the extension so that we don't have to search for it again, and to look within that path
+    # for significant application subdirectories.
+    #
+    # We can't just retrieve this information from the Extension class because the initializer sets up 
+    # most of the application load_paths before plugins (including extensions) are loaded. You can think
+    # of this as a sort of pre-extension class preparing the way for extension loading.
+    #
+    # You can use instances of this class to retrieve information about a particular extension:
+    #
+    #   ExtensionPath.new(:name, :path)
+    #   ExtensionPath.find(:name)               #=> ExtensionPath instance
+    #   ExtensionPath.find(:name).plugin_paths  #=> "path/vendor/plugins" if it exists and is a directory
+    #   ExtensionPath.for(:name)                #=> "path"
+    #
+    # The initializer calls class methods to get overall lists (in configured order) of enabled load paths:
+    #
+    #   ExtensionPath.enabled                   #=> ["path", "path", "path", "path"]
+    #   ExtensionPath.plugin_paths              #=> ["path/vendor/plugins", "path/vendor/plugins"]
+
+    attr_accessor :name, :path
+    @@known_paths = {}
+    
+    def initialize(options = {}) #:nodoc
+      @name, @path = options[:name], options[:path]
+      @@known_paths[@name.to_sym] = self
+    end
+    
+    def required
+      File.join(path, "#{name}_extension")
+    end
+    
+    def to_s
+      path
+    end
+    
+    # Builds a new ExtensionPath object from the supplied path, working out the name of the extension by 
+    # stripping the extra bits from radiant-something-extension-1.0.0 to leave just 'something'. The object
+    # is returned, and also remembered here for later use by the initializer (to find load paths) and the
+    # ExtensionLoader, to load and activate the extension.
+    #
+    # If two arguments are given, the second is taken to be the full extension name.
+    #
+    def self.from_path(path, name=nil)
+      name = path if name.blank?
+      name = File.basename(name).gsub(/^trusty-|-extension(-[\d\.a-z]+|-[a-z\d]+)*$/, '')
+      new(:name => name, :path => path)
+    end
+    
+    # Forgets all recorded extension paths.
+    # Currently only used in testing.
+    #
+    def self.clear_paths!
+      @@known_paths = {}
+    end
+    
+    # Returns a list of all the likely load paths found within this extension root. It includes all of these 
+    # that exist and are directories:
+    #
+    # * path
+    # * path/lib 
+    # * path/app/models 
+    # * path/app/controllers
+    # * path/app/metal
+    # * path/app/helpers
+    # * path/test/helpers
+    #
+    # You can call the class method ExtensionPath.load_paths to get a flattened list of all the load paths in all the enabled extensions.
+    #
+    def load_paths
+      %w(lib app/models app/controllers app/metal app/helpers test/helpers).collect { |d| check_subdirectory(d) }.push(path).flatten.compact
+    end
+
+    # Returns a list of all the +vendor/plugin+ paths found within this extension root.
+    # Call the class method ExtensionPath.plugin_paths to get a list of the plugin paths found in all enabled extensions.
+    #
+    def plugin_paths
+      check_subdirectory("vendor/plugins")
+    end
+
+    # Returns a list of names of all the locale files found within this extension root.
+    # Call the class method ExtensionPath.locale_paths to get a list of the locale files found in all enabled extensions
+    # in reverse order so that locale definitions override one another correctly.
+    #
+    def locale_paths
+      if check_subdirectory("config/locales")
+        Dir[File.join("#{path}","config/locales","*.{rb,yml}")] 
+      end
+    end
+
+    # Returns the app/helpers path if it is found within this extension root.
+    # Call the class method ExtensionPath.helper_paths to get a list of the helper paths found in all enabled extensions.
+    #
+    def helper_paths
+      check_subdirectory("app/helpers")
+    end
+
+    # Returns the app/models path if it is found within this extension root.
+    # Call the class method ExtensionPath.model_paths to get a list of the model paths found in all enabled extensions.
+    #
+    def model_paths
+      check_subdirectory("app/models")
+    end
+
+    # Returns the app/controllers path if it is found within this extension root.
+    # Call the class method ExtensionPath.controller_paths to get a list of the controller paths found in all enabled extensions.
+    #
+    def controller_paths
+      check_subdirectory("app/controllers")
+    end
+
+    # Returns the app/views path if it is found within this extension root. 
+    # Call the class method ExtensionPath.view_paths to get a list of the view paths found in all enabled extensions
+    # in reverse order so that views override one another correctly.
+    #
+    def view_paths
+      check_subdirectory("app/views")
+    end
+
+    # Returns the app/metal path if it is found within this extension root.
+    # Call the class method ExtensionPath.metal_paths to get a list of the metal paths found in all enabled extensions.
+    #
+    def metal_paths
+      check_subdirectory("app/metal")
+    end
+
+    # Returns a list of all the rake task files found within this extension root.
+    #
+    def rake_task_paths
+      if check_subdirectory("lib/tasks")
+        Dir[File.join("#{path}","lib/tasks/**","*.rake")] 
+      end
+    end
+
+    # Returns a list of extension subdirectories that should be marked for eager loading. At the moment that
+    # includes all the controller, model and helper paths. The main purpose here is to ensure that extension
+    # controllers are loaded before running cucumber features, and there may be a better way to achieve that.
+    #
+    # Call the class method ExtensionPath.eager_load_paths to get a list for all enabled extensions.
+    #
+    def eager_load_paths
+      [controller_paths, model_paths, helper_paths].flatten.compact
+    end
+    
+    class << self
+      # Returns the ExtensionPath object for the given extension name.
+      #
+      def find(name)
+        raise LoadError, "Cannot return path for unknown extension: #{name}" unless @@known_paths[name.to_sym]
+        @@known_paths[name.to_sym]
+      end
+      
+      # Returns the root path recorded for the given extension name.
+      #
+      def for(name)
+        find(name).path
+      end
+
+      # Returns a list of path objects for all the enabled extensions in the configured order. 
+      # If a configured extension has not been found during initialization, a LoadError will be thrown here.
+      #
+      # Note that at this stage, in line with the usage of config.extensions = [], the extension names
+      # are being passed around as symbols.
+      #
+      def enabled
+        enabled_extensions = TrustyCms::Application.config.enabled_extensions
+        @@known_paths.values_at(*enabled_extensions).compact
+      end
+      
+      # Returns a list of the root paths to all the enabled extensions, in the configured order.
+      #
+      def enabled_paths
+        enabled.map(&:path)
+      end
+      
+      [:load_paths, :plugin_paths, :helper_paths, :model_paths, :controller_paths, :eager_load_paths].each do |m|
+        define_method(m) do
+          enabled.map{|ep| ep.send(m)}.flatten.compact
+        end
+      end
+      [:locale_paths, :view_paths, :metal_paths, :rake_task_paths].each do |m|
+        define_method(m) do
+          enabled.map{|ep| ep.send(m)}.flatten.compact.reverse
+        end
+      end
+    end
+
+  private
+
+    # If the supplied path within the extension root exists and is a directory, its absolute path is returned. Otherwise, nil.
+    #
+    def check_subdirectory(subpath)
+      subdirectory = File.join(path, subpath)
+      subdirectory if File.directory?(subdirectory)
+    end
+    
+  end
+end

data/lib/trusty_cms/initializer.rb

@@ -0,0 +1,162 @@
+require 'trusty_cms/admin_ui'
+require 'trusty_cms/extension_loader'
+
+module TrustyCms
+
+  module Initializer
+  
+    # Rails::Initializer is essentially a list of startup steps and we extend it here by:
+    # * overriding or extending some of those steps so that they use radiant and extension paths
+    #   as well as (or instead of) the rails defaults.
+    # * appending some extra steps to set up the admin UI and activate extensions
+
+
+    # Returns true in the very unusual case where radiant has been deployed as a rails app itself, rather than 
+    # loaded as a gem or from vendor/. This is only likely in situations where radiant is customised so heavily
+    # that extensions are not sufficient.
+    #
+    def deployed_as_app?
+      TRUSTY_CMS_ROOT == Rails.root
+    end
+    
+    # Extends the Rails::Initializer default to add extension paths to the autoload list.
+    # Note that +default_autoload_paths+ is also overridden to point to TRUSTY_CMS_ROOT.
+    # 
+    def set_autoload_patf
+      super
+    end
+    
+    # Overrides the Rails initializer to load metal from TRUSTY_CMS_ROOT and from radiant extensions.
+    #
+    def initialize_metal
+      Rails::Rack::Metal.requested_metals = configuration.metals
+      Rails::Rack::Metal.metal_paths = ["#{TRUSTY_CMS_ROOT}/app/metal"] # reset Rails default to TRUSTY_CMS_ROOT
+      Rails::Rack::Metal.metal_paths += plugin_loader.engine_metal_paths
+      Rails::Rack::Metal.metal_paths += extension_loader.paths(:metal)
+      Rails::Rack::Metal.metal_paths.uniq!
+    
+      configuration.middleware.insert_before(
+        :"ActionController::ParamsParser",
+        Rails::Rack::Metal, :if => Rails::Rack::Metal.metals.any?)
+    end
+
+    # Extends the Rails initializer to add locale paths from TRUSTY_CMS_ROOT and from radiant extensions.
+    #
+    def initialize_i18n
+      radiant_locale_paths = Dir[File.join(TRUSTY_CMS_ROOT, 'config', 'locales', '*.{rb,yml}')]
+      configuration.i18n.load_path = radiant_locale_paths + extension_loader.paths(:locale)
+      super
+    end
+
+    # Extends the Rails initializer to add plugin paths in extensions
+    # and makes extension load paths reloadable (eg in development mode)
+    #
+    def add_plugin_load_paths
+      configuration.add_plugin_paths(extension_loader.paths(:plugin))
+      super
+      ActiveSupport::Dependencies.autoload_once_paths -= extension_loader.paths(:load)
+    end
+
+    # Overrides the standard gem-loader to use Bundler instead of config.gem. This is the method normally monkey-patched
+    # into Rails::Initializer from boot.rb if you follow the instructions at http://gembundler.com/rails23.html
+    #
+    def load_gems
+      @bundler_loaded ||= Bundler.require :default, Rails.env
+    end
+
+    # Extends the Rails initializer also to load radiant extensions (which have been excluded from the list of plugins).
+    #
+    def load_plugins
+      super
+      extension_loader.load_extensions
+    end
+    
+    # Extends the Rails initializer to run initializers from radiant and from extensions. The load order will be:
+    # 1. TRUSTY_CMS_ROOT/config/intializers/*.rb
+    # 2. Rails.root/config/intializers/*.rb
+    # 3. config/initializers/*.rb found in extensions, in extension load order.
+    #
+    # In the now rare case where radiant is deployed as an ordinary rails application, step 1 is skipped 
+    # because it is equivalent to step 2.
+    #
+    def load_application_initializers
+      load_radiant_initializers unless deployed_as_app?
+      super
+      extension_loader.load_extension_initalizers
+    end
+
+    # Loads initializers found in TRUSTY_CMS_ROOT/config/initializers.
+    #
+    def load_radiant_initializers
+      Dir["#{TRUSTY_CMS_ROOT}/config/initializers/**/*.rb"].sort.each do |initializer|
+        load(initializer)
+      end
+    end
+
+    # Extends the Rails initializer with some extra steps at the end of initialization:
+    # * hook up radiant view paths in controllers and notifiers
+    # * initialize the navigation tabs in the admin interface
+    # * initialize the extendable partial sets that make up the admin interface
+    # * call +activate+ on all radiant extensions
+    # * add extension controller paths
+    # * mark extension app paths for eager loading
+    #
+    def after_initialize
+      super
+      extension_loader.activate_extensions  # also calls initialize_views
+      TrustyCms::Application.config.add_controller_paths(extension_loader.paths(:controller))
+      TrustyCms::Application.config.add_eager_load_paths(extension_loader.paths(:eager_load))
+    end
+    
+    # Initializes all the admin interface elements and views. Separate here so that it can be called
+    # to reset the interface before extension (re)activation.
+    #
+    def initialize_views
+      initialize_default_admin_tabs
+      initialize_framework_views
+      admin.load_default_regions
+    end
+    
+    # Initializes the core admin tabs. Separate so that it can be invoked by itself in tests.
+    #
+    def initialize_default_admin_tabs
+      admin.initialize_nav
+    end
+    
+    # This adds extension view paths to the standard Rails::Initializer method. 
+    # In environments that don't cache templates it reloads the path set on each request, 
+    # so that new extension paths are noticed without a restart.
+    #
+    def initialize_framework_views
+      view_paths = extension_loader.paths(:view) #.push(TrustyCms::Application.config.view_path)
+      if ActionController::Base.view_paths.count == 0 || !ActionView::Base.cache_template_loading
+        ActionController::Base.view_paths = ActionView::Base.process_view_paths(view_paths)
+      end
+      if ActionMailer::Base.view_paths.count == 0 || !ActionView::Base.cache_template_loading
+        ActionMailer::Base.view_paths = ActionView::Base.process_view_paths(view_paths)
+      end
+    end 
+
+    # Extends the Rails initializer to make sure that extension controller paths are available when routes 
+    # are initialized.
+    #
+    def initialize_routing
+      configuration.add_controller_paths(extension_loader.paths(:controller))
+      configuration.add_eager_load_paths(extension_loader.paths(:eager_load))
+      super
+    end
+
+    # Returns the TrustyCms::AdminUI singleton so that the initializer can set up the admin interface.
+    #
+    def admin
+      TrustyCms::Application.config.admin
+    end
+
+    # Returns the ExtensionLoader singleton that will eventually load extensions.
+    #
+    def extension_loader
+      ExtensionLoader.instance {|l| l.initializer = self }
+    end
+
+  end
+end

data/lib/trusty_cms/pagination/controller.rb

@@ -0,0 +1,41 @@
+module TrustyCms
+  module Pagination
+    module Controller
+      # for inclusion into public-facing controllers
+
+      def configure_pagination
+        # unconfigured parameters remain at will_paginate defaults
+        # will_paginate controller options are not overridden by tag attribetus
+        WillPaginate::ViewHelpers.pagination_options[:param_name] = TrustyCms::Config["pagination.param_name"].to_sym unless TrustyCms::Config["pagination.param_name"].blank?
+        WillPaginate::ViewHelpers.pagination_options[:per_page_param_name] = TrustyCms::Config["pagination.per_page_param_name"].blank? ? :per_page : TrustyCms::Config["pagination.per_page_param_name"].to_sym
+
+        # will_paginate view options can be overridden by tag attributes
+        [:class, :previous_label, :next_label, :inner_window, :outer_window, :separator, :container].each do |opt|
+          WillPaginate::ViewHelpers.pagination_options[opt] = TrustyCms::Config["pagination.#{opt}"] unless TrustyCms::Config["pagination.#{opt}"].blank?
+        end
+      end
+
+      def pagination_parameters
+        {
+          :page => params[WillPaginate::ViewHelpers.pagination_options[:param_name]] || 1,
+          :per_page => params[WillPaginate::ViewHelpers.pagination_options[:per_page_param_name]] || TrustyCms::Config['pagination.per_page'] || 20
+        }
+      end
+
+      def self.included(base)
+        base.class_eval {
+          helper_method :pagination_parameters
+          before_filter :configure_pagination
+        }
+      end
+    end
+  end
+
+
+
+end
+
+
+
+
+

data/lib/trusty_cms/pagination/link_renderer.rb

@@ -0,0 +1,34 @@
+# This handy simplification is adapted from SphinxSearch (thanks)
+# and originally came from Ultrasphinx
+# it saves us a lot of including and bodging to make will_paginate's template calls work in the Page model
+
+module TrustyCms
+  module Pagination
+    class LinkRenderer < WillPaginate::LinkRenderer
+      def initialize(url_stem)
+        @url_stem = url_stem
+      end
+  
+      def to_html
+        links = @options[:page_links] ? windowed_links : []
+        links.unshift page_link_or_span(@collection.previous_page, 'disabled prev_page', @options[:previous_label])
+        links.push    page_link_or_span(@collection.next_page,     'disabled next_page', @options[:next_label])
+        html = links.join(@options[:separator])
+        @options[:container] ? %{<div class="pagination">#{html}</div>} : html
+      end
+      
+      # this is rather crude compared to the WillPaginate link-builder,
+      # but it can get by without much context to draw on
+      def page_link(page, text, attributes = {})
+        linkclass = %{ class="#{attributes[:class]}"} if attributes[:class]
+        linkrel = %{ rel="#{attributes[:rel]}"} if attributes[:rel]
+        param_name = WillPaginate::ViewHelpers.pagination_options[:param_name]
+        %Q{<a href="#{@url_stem}?#{param_name}=#{page}"#{linkrel}#{linkclass}>#{text}</a>}
+      end
+
+      def page_span(page, text, attributes = {})
+        %{<span class="#{attributes[:class]}">#{text}</span>}
+      end
+    end
+  end
+end