jro_apps/redmine Commit - r2132:e2952d3e5fc4

Rails 2.1.2 deprecations (#2332)....

Jean-Philippe Lang -

r2132:e2952d3e5fc4

parent child

Context file:

r2132:e2952d3e5fc4

Collapse all files

app/models/user.rb +1 -1

             # redMine - project management software
             # Copyright (C) 2006-2007  Jean-Philippe Lang
             #
             # This program is free software; you can redistribute it and/or
             # modify it under the terms of the GNU General Public License
             # as published by the Free Software Foundation; either version 2
             # of the License, or (at your option) any later version.
             #
             # This program is distributed in the hope that it will be useful,
             # but WITHOUT ANY WARRANTY; without even the implied warranty of
             # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
             # GNU General Public License for more details.
             #
             # You should have received a copy of the GNU General Public License
             # along with this program; if not, write to the Free Software
             # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
             require "digest/sha1"
             class User < ActiveRecord::Base
               # Account statuses
               STATUS_ANONYMOUS  = 0
               STATUS_ACTIVE     = 1
               STATUS_REGISTERED = 2
               STATUS_LOCKED     = 3
               USER_FORMATS = {
                 :firstname_lastname => '#{firstname} #{lastname}',
                 :firstname => '#{firstname}',
                 :lastname_firstname => '#{lastname} #{firstname}',
                 :lastname_coma_firstname => '#{lastname}, #{firstname}',
                 :username => '#{login}'
               }
               has_many :memberships, :class_name => 'Member', :include => [ :project, :role ], :conditions => "#{Project.table_name}.status=#{Project::STATUS_ACTIVE}", :order => "#{Project.table_name}.name"
               has_many :members, :dependent => :delete_all
               has_many :projects, :through => :memberships
               has_many :issue_categories, :foreign_key => 'assigned_to_id', :dependent => :nullify
               has_many :changesets, :dependent => :nullify
               has_one :preference, :dependent => :destroy, :class_name => 'UserPreference'
               has_one :rss_token, :dependent => :destroy, :class_name => 'Token', :conditions => "action='feeds'"
               belongs_to :auth_source
               # Active non-anonymous users scope
               named_scope :active, :conditions => "#{User.table_name}.status = #{STATUS_ACTIVE}"
               acts_as_customizable
               attr_accessor :password, :password_confirmation
               attr_accessor :last_before_login_on
               # Prevents unauthorized assignments
               attr_protected :login, :admin, :password, :password_confirmation, :hashed_password
               validates_presence_of :login, :firstname, :lastname, :mail, :if => Proc.new { |user| !user.is_a?(AnonymousUser) }
               validates_uniqueness_of :login, :if => Proc.new { |user| !user.login.blank? }
               validates_uniqueness_of :mail, :if => Proc.new { |user| !user.mail.blank? }
               # Login must contain lettres, numbers, underscores only
               validates_format_of :login, :with => /^[a-z0-9_\-@\.]*$/i
               validates_length_of :login, :maximum => 30
               validates_format_of :firstname, :lastname, :with => /^[\w\s\'\-\.]*$/i
               validates_length_of :firstname, :lastname, :maximum => 30
               validates_format_of :mail, :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i, :allow_nil => true
               validates_length_of :mail, :maximum => 60, :allow_nil => true
               validates_length_of :password, :minimum => 4, :allow_nil => true
               validates_confirmation_of :password, :allow_nil => true
               def before_create
                 self.mail_notification = false
                 true
               end
               def before_save
                 # update hashed_password if password was set
                 self.hashed_password = User.hash_password(self.password) if self.password
               end
               def reload(*args)
                 @name = nil
                 super
               end
               # Returns the user that matches provided login and password, or nil
               def self.try_to_login(login, password)
                 # Make sure no one can sign in with an empty password
                 return nil if password.to_s.empty?
                 user = find(:first, :conditions => ["login=?", login])
                 if user
                   # user is already in local database
                   return nil if !user.active?
                   if user.auth_source
                     # user has an external authentication method
                     return nil unless user.auth_source.authenticate(login, password)
                   else
                     # authentication with local password
                     return nil unless User.hash_password(password) == user.hashed_password
                   end
                 else
                   # user is not yet registered, try to authenticate with available sources
                   attrs = AuthSource.authenticate(login, password)
                   if attrs
                     user = new(*attrs)
                     user.login = login
                     user.language = Setting.default_language
                     if user.save
                       user.reload
                       logger.info("User '#{user.login}' created from the LDAP") if logger
                     end
                   end
                 end
                 user.update_attribute(:last_login_on, Time.now) if user && !user.new_record?
                 user
               rescue => text
                 raise text
               end
               # Return user's full name for display
               def name(formatter = nil)
                 if formatter
                   eval('"' + (USER_FORMATS[formatter] || USER_FORMATS[:firstname_lastname]) + '"')
                 else
                   @name ||= eval('"' + (USER_FORMATS[Setting.user_format] || USER_FORMATS[:firstname_lastname]) + '"')
                 end
               end
               def active?
                 self.status == STATUS_ACTIVE
               end
               def registered?
                 self.status == STATUS_REGISTERED
               end
               def locked?
                 self.status == STATUS_LOCKED
               end
               def check_password?(clear_password)
                 User.hash_password(clear_password) == self.hashed_password
               end
               def pref
                 self.preference ||= UserPreference.new(:user => self)
               end
               def time_zone
-                @time_zone ||= (self.pref.time_zone.blank? ? nil : TimeZone[self.pref.time_zone])
+                @time_zone ||= (self.pref.time_zone.blank? ? nil : ActiveSupport::TimeZone[self.pref.time_zone])
               end
               def wants_comments_in_reverse_order?
                 self.pref[:comments_sorting] == 'desc'
               end
               # Return user's RSS key (a 40 chars long string), used to access feeds
               def rss_key
                 token = self.rss_token || Token.create(:user => self, :action => 'feeds')
                 token.value
               end
               # Return an array of project ids for which the user has explicitly turned mail notifications on
               def notified_projects_ids
                 @notified_projects_ids ||= memberships.select {|m| m.mail_notification?}.collect(&:project_id)
               end
               def notified_project_ids=(ids)
                 Member.update_all("mail_notification = #{connection.quoted_false}", ['user_id = ?', id])
                 Member.update_all("mail_notification = #{connection.quoted_true}", ['user_id = ? AND project_id IN (?)', id, ids]) if ids && !ids.empty?
                 @notified_projects_ids = nil
                 notified_projects_ids
               end
               def self.find_by_rss_key(key)
                 token = Token.find_by_value(key)
                 token && token.user.active? ? token.user : nil
               end
               def self.find_by_autologin_key(key)
                 token = Token.find_by_action_and_value('autologin', key)
                 token && (token.created_on > Setting.autologin.to_i.day.ago) && token.user.active? ? token.user : nil
               end
               # Makes find_by_mail case-insensitive
               def self.find_by_mail(mail)
                 find(:first, :conditions => ["LOWER(mail) = ?", mail.to_s.downcase])
               end
               # Sort users by their display names
               def <=>(user)
                 self.to_s.downcase <=> user.to_s.downcase
               end
               def to_s
                 name
               end
               def logged?
                 true
               end
               def anonymous?
                 !logged?
               end
               # Return user's role for project
               def role_for_project(project)
                 # No role on archived projects
                 return nil unless project && project.active?
                 if logged?
                   # Find project membership
                   membership = memberships.detect {|m| m.project_id == project.id}
                   if membership
                     membership.role
                   else
                     @role_non_member ||= Role.non_member
                   end
                 else
                   @role_anonymous ||= Role.anonymous
                 end
               end
               # Return true if the user is a member of project
               def member_of?(project)
                 role_for_project(project).member?
               end
               # Return true if the user is allowed to do the specified action on project
               # action can be:
               # * a parameter-like Hash (eg. :controller => 'projects', :action => 'edit')
               # * a permission Symbol (eg. :edit_project)
               def allowed_to?(action, project, options={})
                 if project
                   # No action allowed on archived projects
                   return false unless project.active?
                   # No action allowed on disabled modules
                   return false unless project.allows_to?(action)
                   # Admin users are authorized for anything else
                   return true if admin?
                   role = role_for_project(project)
                   return false unless role
                   role.allowed_to?(action) && (project.is_public? || role.member?)
                 elsif options[:global]
                   # authorize if user has at least one role that has this permission
                   roles = memberships.collect {|m| m.role}.uniq
                   roles.detect {|r| r.allowed_to?(action)} || (self.logged? ? Role.non_member.allowed_to?(action) : Role.anonymous.allowed_to?(action))
                 else
                   false
                 end
               end
               def self.current=(user)
                 @current_user = user
               end
               def self.current
                 @current_user ||= User.anonymous
               end
               def self.anonymous
                 anonymous_user = AnonymousUser.find(:first)
                 if anonymous_user.nil?
                   anonymous_user = AnonymousUser.create(:lastname => 'Anonymous', :firstname => '', :mail => '', :login => '', :status => 0)
                   raise 'Unable to create the anonymous user.' if anonymous_user.new_record?
                 end
                 anonymous_user
               end
             private
               # Return password digest
               def self.hash_password(clear_password)
                 Digest::SHA1.hexdigest(clear_password || "")
               end
             end
             class AnonymousUser < User
               def validate_on_create
                 # There should be only one AnonymousUser in the database
                 errors.add_to_base 'An anonymous user already exists.' if AnonymousUser.find(:first)
               end
               def available_custom_fields
                 []
               end
               # Overrides a few properties
               def logged?; false end
               def admin; false end
               def name; 'Anonymous' end
               def mail; nil end
               def time_zone; nil end
               def rss_key; nil end
             end

app/views/my/account.rhtml +1 -1

             <div class="contextual">
             <%= link_to(l(:button_change_password), :action => 'password') unless @user.auth_source_id %>
             </div>
             <h2><%=l(:label_my_account)%></h2>
             <%= error_messages_for 'user' %>
             <% form_for :user, @user, :url => { :action => "account" },
                                       :builder => TabularFormBuilder,
                                       :lang => current_language,
                                       :html => { :id => 'my_account_form' } do |f| %>
             <div class="splitcontentleft">
             <h3><%=l(:label_information_plural)%></h3>
             <div class="box tabular">
             <p><%= f.text_field :firstname, :required => true %></p>
             <p><%= f.text_field :lastname, :required => true %></p>
             <p><%= f.text_field :mail, :required => true %></p>
             <p><%= f.select :language, lang_options_for_select %></p>
             </div>
             <%= submit_tag l(:button_save) %>
             </div>
             <div class="splitcontentright">
             <h3><%=l(:field_mail_notification)%></h3>
             <div class="box">
             <%= select_tag 'notification_option', options_for_select(@notification_options, @notification_option),
                                                   :onchange => 'if ($("notification_option").value == "selected") {Element.show("notified-projects")} else {Element.hide("notified-projects")}' %>
             <% content_tag 'div', :id => 'notified-projects', :style => (@notification_option == 'selected' ? '' : 'display:none;') do %>
             <p><% User.current.projects.each do |project| %>
                 <label><%= check_box_tag 'notified_project_ids[]', project.id, @user.notified_projects_ids.include?(project.id) %> <%=h project.name %></label><br />
             <% end %></p>
             <p><em><%= l(:text_user_mail_option) %></em></p>
             <% end %>
             <p><label><%= check_box_tag 'no_self_notified', 1, @user.pref[:no_self_notified] %> <%= l(:label_user_mail_no_self_notified) %></label></p>
             </div>
             <h3><%=l(:label_preferences)%></h3>
             <div class="box tabular">
             <% fields_for :pref, @user.pref, :builder => TabularFormBuilder, :lang => current_language do |pref_fields| %>
             <p><%= pref_fields.check_box :hide_mail %></p>
-            <p><%= pref_fields.select :time_zone, TimeZone.all.collect {|z| [ z.to_s, z.name ]}, :include_blank => true %></p>
+            <p><%= pref_fields.select :time_zone, ActiveSupport::TimeZone.all.collect {|z| [ z.to_s, z.name ]}, :include_blank => true %></p>
             <p><%= pref_fields.select :comments_sorting, [[l(:label_chronological_order), 'asc'], [l(:label_reverse_chronological_order), 'desc']] %></p>
             <% end %>
             </div>
             </div>
             <% end %>
             <% content_for :sidebar do %>
             <%= render :partial => 'sidebar' %>
             <% end %>
             <% html_title(l(:label_my_account)) -%>

vendor/plugins/actionwebservice/init.rb +1 -1

             require 'action_web_service'
             # These need to be in the load path for action_web_service to work
-            Dependencies.load_paths += ["#{RAILS_ROOT}/app/apis"]
+            ActiveSupport::Dependencies.load_paths += ["#{RAILS_ROOT}/app/apis"]
             # AWS Test helpers
             require 'action_web_service/test_invoke' if ENV['RAILS_ENV'] && ENV['RAILS_ENV'] =~ /^test/

vendor/plugins/classic_pagination/lib/pagination.rb +2 -2

             module ActionController
               # === Action Pack pagination for Active Record collections
               #
               # The Pagination module aids in the process of paging large collections of
               # Active Record objects. It offers macro-style automatic fetching of your
               # model for multiple views, or explicit fetching for single actions. And if
               # the magic isn't flexible enough for your needs, you can create your own
               # paginators with a minimal amount of code.
               #
               # The Pagination module can handle as much or as little as you wish. In the
               # controller, have it automatically query your model for pagination; or,
               # if you prefer, create Paginator objects yourself.
               #
               # Pagination is included automatically for all controllers.
               #
               # For help rendering pagination links, see
               # ActionView::Helpers::PaginationHelper.
               #
               # ==== Automatic pagination for every action in a controller
               #
               #   class PersonController < ApplicationController
               #     model :person
               #
               #     paginate :people, :order => 'last_name, first_name',
               #              :per_page => 20
               #
               #     # ...
               #   end
               #
               # Each action in this controller now has access to a <tt>@people</tt>
               # instance variable, which is an ordered collection of model objects for the
               # current page (at most 20, sorted by last name and first name), and a
               # <tt>@person_pages</tt> Paginator instance. The current page is determined
               # by the <tt>params[:page]</tt> variable.
               #
               # ==== Pagination for a single action
               #
               #   def list
               #     @person_pages, @people =
               #       paginate :people, :order => 'last_name, first_name'
               #   end
               #
               # Like the previous example, but explicitly creates <tt>@person_pages</tt>
               # and <tt>@people</tt> for a single action, and uses the default of 10 items
               # per page.
               #
               # ==== Custom/"classic" pagination
               #
               #   def list
               #     @person_pages = Paginator.new self, Person.count, 10, params[:page]
               #     @people = Person.find :all, :order => 'last_name, first_name',
               #                           :limit  =>  @person_pages.items_per_page,
               #                           :offset =>  @person_pages.current.offset
               #   end
               #
               # Explicitly creates the paginator from the previous example and uses
               # Paginator#to_sql to retrieve <tt>@people</tt> from the model.
               #
               module Pagination
                 unless const_defined?(:OPTIONS)
                   # A hash holding options for controllers using macro-style pagination
                   OPTIONS = Hash.new
                   # The default options for pagination
                   DEFAULT_OPTIONS = {
                     :class_name => nil,
                     :singular_name => nil,
                     :per_page   => 10,
                     :conditions => nil,
                     :order_by   => nil,
                     :order      => nil,
                     :join       => nil,
                     :joins      => nil,
                     :count      => nil,
                     :include    => nil,
                     :select     => nil,
                     :group      => nil,
                     :parameter  => 'page'
                   }
                 else
                   DEFAULT_OPTIONS[:group] = nil
                 end
                 def self.included(base) #:nodoc:
                   super
                   base.extend(ClassMethods)
                 end
                 def self.validate_options!(collection_id, options, in_action) #:nodoc:
                   options.merge!(DEFAULT_OPTIONS) {|key, old, new| old}
                   valid_options = DEFAULT_OPTIONS.keys
                   valid_options << :actions unless in_action
                   unknown_option_keys = options.keys - valid_options
                   raise ActionController::ActionControllerError,
                         "Unknown options: #{unknown_option_keys.join(', ')}" unless
                           unknown_option_keys.empty?
-                  options[:singular_name] ||= Inflector.singularize(collection_id.to_s)
+                  options[:singular_name] ||= ActiveSupport::Inflector.singularize(collection_id.to_s)
-                  options[:class_name]  ||= Inflector.camelize(options[:singular_name])
+                  options[:class_name]  ||= ActiveSupport::Inflector.camelize(options[:singular_name])
                 end
                 # Returns a paginator and a collection of Active Record model instances
                 # for the paginator's current page. This is designed to be used in a
                 # single action; to automatically paginate multiple actions, consider
                 # ClassMethods#paginate.
                 #
                 # +options+ are:
                 # <tt>:singular_name</tt>:: the singular name to use, if it can't be inferred by singularizing the collection name
                 # <tt>:class_name</tt>:: the class name to use, if it can't be inferred by
                 #                        camelizing the singular name
                 # <tt>:per_page</tt>::   the maximum number of items to include in a
                 #                        single page. Defaults to 10
                 # <tt>:conditions</tt>:: optional conditions passed to Model.find(:all, *params) and
                 #                        Model.count
                 # <tt>:order</tt>::      optional order parameter passed to Model.find(:all, *params)
                 # <tt>:order_by</tt>::   (deprecated, used :order) optional order parameter passed to Model.find(:all, *params)
                 # <tt>:joins</tt>::      optional joins parameter passed to Model.find(:all, *params)
                 #                        and Model.count
                 # <tt>:join</tt>::       (deprecated, used :joins or :include) optional join parameter passed to Model.find(:all, *params)
                 #                        and Model.count
                 # <tt>:include</tt>::    optional eager loading parameter passed to Model.find(:all, *params)
                 #                        and Model.count
                 # <tt>:select</tt>::     :select parameter passed to Model.find(:all, *params)
                 #
                 # <tt>:count</tt>::      parameter passed as :select option to Model.count(*params)
                 #
                 # <tt>:group</tt>::     :group parameter passed to Model.find(:all, *params). It forces the use of DISTINCT instead of plain COUNT to come up with the total number of records
                 #
                 def paginate(collection_id, options={})
                   Pagination.validate_options!(collection_id, options, true)
                   paginator_and_collection_for(collection_id, options)
                 end
                 # These methods become class methods on any controller
                 module ClassMethods
                   # Creates a +before_filter+ which automatically paginates an Active
                   # Record model for all actions in a controller (or certain actions if
                   # specified with the <tt>:actions</tt> option).
                   #
                   # +options+ are the same as PaginationHelper#paginate, with the addition
                   # of:
                   # <tt>:actions</tt>:: an array of actions for which the pagination is
                   #                     active. Defaults to +nil+ (i.e., every action)
                   def paginate(collection_id, options={})
                     Pagination.validate_options!(collection_id, options, false)
                     module_eval do
                       before_filter :create_paginators_and_retrieve_collections
                       OPTIONS[self] ||= Hash.new
                       OPTIONS[self][collection_id] = options
                     end
                   end
                 end
                 def create_paginators_and_retrieve_collections #:nodoc:
                   Pagination::OPTIONS[self.class].each do |collection_id, options|
                     next unless options[:actions].include? action_name if
                       options[:actions]
                     paginator, collection =
                       paginator_and_collection_for(collection_id, options)
                     paginator_name = "@#{options[:singular_name]}_pages"
                     self.instance_variable_set(paginator_name, paginator)
                     collection_name = "@#{collection_id.to_s}"
                     self.instance_variable_set(collection_name, collection)
                   end
                 end
                 # Returns the total number of items in the collection to be paginated for
                 # the +model+ and given +conditions+. Override this method to implement a
                 # custom counter.
                 def count_collection_for_pagination(model, options)
                   model.count(:conditions => options[:conditions],
                               :joins => options[:join] || options[:joins],
                               :include => options[:include],
                               :select => (options[:group] ? "DISTINCT #{options[:group]}" : options[:count]))
                 end
                 # Returns a collection of items for the given +model+ and +options[conditions]+,
                 # ordered by +options[order]+, for the current page in the given +paginator+.
                 # Override this method to implement a custom finder.
                 def find_collection_for_pagination(model, options, paginator)
                   model.find(:all, :conditions => options[:conditions],
                              :order => options[:order_by] || options[:order],
                              :joins => options[:join] || options[:joins], :include => options[:include],
                              :select => options[:select], :limit => options[:per_page],
                              :group => options[:group], :offset => paginator.current.offset)
                 end
                 protected :create_paginators_and_retrieve_collections,
                           :count_collection_for_pagination,
                           :find_collection_for_pagination
                 def paginator_and_collection_for(collection_id, options) #:nodoc:
                   klass = options[:class_name].constantize
                   page  = params[options[:parameter]]
                   count = count_collection_for_pagination(klass, options)
                   paginator = Paginator.new(self, count, options[:per_page], page)
                   collection = find_collection_for_pagination(klass, options, paginator)
                   return paginator, collection
                 end
                 private :paginator_and_collection_for
                 # A class representing a paginator for an Active Record collection.
                 class Paginator
                   include Enumerable
                   # Creates a new Paginator on the given +controller+ for a set of items
                   # of size +item_count+ and having +items_per_page+ items per page.
                   # Raises ArgumentError if items_per_page is out of bounds (i.e., less
                   # than or equal to zero). The page CGI parameter for links defaults to
                   # "page" and can be overridden with +page_parameter+.
                   def initialize(controller, item_count, items_per_page, current_page=1)
                     raise ArgumentError, 'must have at least one item per page' if
                       items_per_page <= 0
                     @controller = controller
                     @item_count = item_count || 0
                     @items_per_page = items_per_page
                     @pages = {}
                     self.current_page = current_page
                   end
                   attr_reader :controller, :item_count, :items_per_page
                   # Sets the current page number of this paginator. If +page+ is a Page
                   # object, its +number+ attribute is used as the value; if the page does
                   # not belong to this Paginator, an ArgumentError is raised.
                   def current_page=(page)
                     if page.is_a? Page
                       raise ArgumentError, 'Page/Paginator mismatch' unless
                         page.paginator == self
                     end
                     page = page.to_i
                     @current_page_number = has_page_number?(page) ? page : 1
                   end
                   # Returns a Page object representing this paginator's current page.
                   def current_page
                     @current_page ||= self[@current_page_number]
                   end
                   alias current :current_page
                   # Returns a new Page representing the first page in this paginator.
                   def first_page
                     @first_page ||= self[1]
                   end
                   alias first :first_page
                   # Returns a new Page representing the last page in this paginator.
                   def last_page
                     @last_page ||= self[page_count]
                   end
                   alias last :last_page
                   # Returns the number of pages in this paginator.
                   def page_count
                     @page_count ||= @item_count.zero? ? 1 :
                                       (q,r=@item_count.divmod(@items_per_page); r==0? q : q+1)
                   end
                   alias length :page_count
                   # Returns true if this paginator contains the page of index +number+.
                   def has_page_number?(number)
                     number >= 1 and number <= page_count
                   end
                   # Returns a new Page representing the page with the given index
                   # +number+.
                   def [](number)
                     @pages[number] ||= Page.new(self, number)
                   end
                   # Successively yields all the paginator's pages to the given block.
                   def each(&block)
                     page_count.times do |n|
                       yield self[n+1]
                     end
                   end
                   # A class representing a single page in a paginator.
                   class Page
                     include Comparable
                     # Creates a new Page for the given +paginator+ with the index
                     # +number+. If +number+ is not in the range of valid page numbers or
                     # is not a number at all, it defaults to 1.
                     def initialize(paginator, number)
                       @paginator = paginator
                       @number = number.to_i
                       @number = 1 unless @paginator.has_page_number? @number
                     end
                     attr_reader :paginator, :number
                     alias to_i :number
                     # Compares two Page objects and returns true when they represent the
                     # same page (i.e., their paginators are the same and they have the
                     # same page number).
                     def ==(page)
                       return false if page.nil?
                       @paginator == page.paginator and
                         @number == page.number
                     end
                     # Compares two Page objects and returns -1 if the left-hand page comes
                     # before the right-hand page, 0 if the pages are equal, and 1 if the
                     # left-hand page comes after the right-hand page. Raises ArgumentError
                     # if the pages do not belong to the same Paginator object.
                     def <=>(page)
                       raise ArgumentError unless @paginator == page.paginator
                       @number <=> page.number
                     end
                     # Returns the item offset for the first item in this page.
                     def offset
                       @paginator.items_per_page * (@number - 1)
                     end
                     # Returns the number of the first item displayed.
                     def first_item
                       offset + 1
                     end
                     # Returns the number of the last item displayed.
                     def last_item
                       [@paginator.items_per_page * @number, @paginator.item_count].min
                     end
                     # Returns true if this page is the first page in the paginator.
                     def first?
                       self == @paginator.first
                     end
                     # Returns true if this page is the last page in the paginator.
                     def last?
                       self == @paginator.last
                     end
                     # Returns a new Page object representing the page just before this
                     # page, or nil if this is the first page.
                     def previous
                       if first? then nil else @paginator[@number - 1] end
                     end
                     # Returns a new Page object representing the page just after this
                     # page, or nil if this is the last page.
                     def next
                       if last? then nil else @paginator[@number + 1] end
                     end
                     # Returns a new Window object for this page with the specified
                     # +padding+.
                     def window(padding=2)
                       Window.new(self, padding)
                     end
                     # Returns the limit/offset array for this page.
                     def to_sql
                       [@paginator.items_per_page, offset]
                     end
                     def to_param #:nodoc:
                       @number.to_s
                     end
                   end
                   # A class for representing ranges around a given page.
                   class Window
                     # Creates a new Window object for the given +page+ with the specified
                     # +padding+.
                     def initialize(page, padding=2)
                       @paginator = page.paginator
                       @page = page
                       self.padding = padding
                     end
                     attr_reader :paginator, :page
                     # Sets the window's padding (the number of pages on either side of the
                     # window page).
                     def padding=(padding)
                       @padding = padding < 0 ? 0 : padding
                       # Find the beginning and end pages of the window
                       @first = @paginator.has_page_number?(@page.number - @padding) ?
                         @paginator[@page.number - @padding] : @paginator.first
                       @last =  @paginator.has_page_number?(@page.number + @padding) ?
                         @paginator[@page.number + @padding] : @paginator.last
                     end
                     attr_reader :padding, :first, :last
                     # Returns an array of Page objects in the current window.
                     def pages
                       (@first.number..@last.number).to_a.collect! {|n| @paginator[n]}
                     end
                     alias to_a :pages
                   end
                 end
               end
             end

vendor/plugins/engines/lib/engines/rails_extensions/dependencies.rb +1 -1

             # One of the magic features that that engines plugin provides is the ability to
             # override selected methods in controllers and helpers from your application.
             # This is achieved by trapping requests to load those files, and then mixing in
             # code from plugins (in the order the plugins were loaded) before finally loading
             # any versions from the main +app+ directory.
             #
             # The behaviour of this extension is output to the log file for help when
             # debugging.
             #
             # == Example
             #
             # A plugin contains the following controller in <tt>plugin/app/controllers/my_controller.rb</tt>:
             #
             #   class MyController < ApplicationController
             #     def index
             #       @name = "HAL 9000"
             #     end
             #     def list
             #       @robots = Robot.find(:all)
             #     end
             #   end
             #
             # In one application that uses this plugin, we decide that the name used in the
             # index action should be "Robbie", not "HAL 9000". To override this single method,
             # we create the corresponding controller in our application
             # (<tt>RAILS_ROOT/app/controllers/my_controller.rb</tt>), and redefine the method:
             #
             #   class MyController < ApplicationController
             #     def index
             #       @name = "Robbie"
             #     end
             #   end
             #
             # The list method remains as it was defined in the plugin controller.
             #
             # The same basic principle applies to helpers, and also views and partials (although
             # view overriding is performed in Engines::RailsExtensions::Templates; see that
             # module for more information).
             #
             # === What about models?
             #
             # Unfortunately, it's not possible to provide this kind of magic for models.
             # The only reason why it's possible for controllers and helpers is because
             # they can be recognised by their filenames ("whatever_controller", "jazz_helper"),
             # whereas models appear the same as any other typical Ruby library ("node",
             # "user", "image", etc.).
             #
             # If mixing were allowed in models, it would mean code mixing for *every*
             # file that was loaded via +require_or_load+, and this could result in
             # problems where, for example, a Node model might start to include
             # functionality from another file called "node" somewhere else in the
             # <tt>$LOAD_PATH</tt>.
             #
             # One way to overcome this is to provide model functionality as a module in
             # a plugin, which developers can then include into their own model
             # implementations.
             #
             # Another option is to provide an abstract model (see the ActiveRecord::Base
             # documentation) and have developers subclass this model in their own
             # application if they must.
             #
             # ---
             #
             # The Engines::RailsExtensions::Dependencies module includes a method to
             # override Dependencies.require_or_load, which is called to load code needed
             # by Rails as it encounters constants that aren't defined.
             #
             # This method is enhanced with the code-mixing features described above.
             #
             module Engines::RailsExtensions::Dependencies
               def self.included(base) #:nodoc:
                 base.class_eval { alias_method_chain :require_or_load, :engine_additions }
               end
               # Attempt to load the given file from any plugins, as well as the application.
               # This performs the 'code mixing' magic, allowing application controllers and
               # helpers to override single methods from those in plugins.
               # If the file can be found in any plugins, it will be loaded first from those
               # locations. Finally, the application version is loaded, using Ruby's behaviour
               # to replace existing methods with their new definitions.
               #
               # If <tt>Engines.disable_code_mixing == true</tt>, the first controller/helper on the
               # <tt>$LOAD_PATH</tt> will be used (plugins' +app+ directories are always lower on the
               # <tt>$LOAD_PATH</tt> than the main +app+ directory).
               #
               # If <tt>Engines.disable_application_code_loading == true</tt>, controllers will
               # not be loaded from the main +app+ directory *if* they are present in any
               # plugins.
               #
               # Returns true if the file could be loaded (from anywhere); false otherwise -
               # mirroring the behaviour of +require_or_load+ from Rails (which mirrors
               # that of Ruby's own +require+, I believe).
               def require_or_load_with_engine_additions(file_name, const_path=nil)
                 return require_or_load_without_engine_additions(file_name, const_path) if Engines.disable_code_mixing
                 file_loaded = false
                 # try and load the plugin code first
                 # can't use model, as there's nothing in the name to indicate that the file is a 'model' file
                 # rather than a library or anything else.
                 Engines.code_mixing_file_types.each do |file_type|
                   # if we recognise this type
                   # (this regexp splits out the module/filename from any instances of app/#{type}, so that
                   #  modules are still respected.)
                   if file_name =~ /^(.*app\/#{file_type}s\/)?(.*_#{file_type})(\.rb)?$/
                     base_name = $2
                     # ... go through the plugins from first started to last, so that
                     # code with a high precedence (started later) will override lower precedence
                     # implementations
                     Engines.plugins.each do |plugin|
                       plugin_file_name = File.expand_path(File.join(plugin.directory, 'app', "#{file_type}s", base_name))
                       Engines.logger.debug("checking plugin '#{plugin.name}' for '#{base_name}'")
                       if File.file?("#{plugin_file_name}.rb")
                         Engines.logger.debug("==> loading from plugin '#{plugin.name}'")
                         file_loaded = true if require_or_load_without_engine_additions(plugin_file_name, const_path)
                       end
                     end
                     # finally, load any application-specific controller classes using the 'proper'
                     # rails load mechanism, EXCEPT when we're testing engines and could load this file
                     # from an engine
                     if Engines.disable_application_code_loading
                       Engines.logger.debug("loading from application disabled.")
                     else
                       # Ensure we are only loading from the /app directory at this point
                       app_file_name = File.join(RAILS_ROOT, 'app', "#{file_type}s", "#{base_name}")
                       if File.file?("#{app_file_name}.rb")
                         Engines.logger.debug("loading from application: #{base_name}")
                         file_loaded = true if require_or_load_without_engine_additions(app_file_name, const_path)
                       else
                         Engines.logger.debug("(file not found in application)")
                       end
                     end
                   end
                 end
                 # if we managed to load a file, return true. If not, default to the original method.
                 # Note that this relies on the RHS of a boolean || not to be evaluated if the LHS is true.
                 file_loaded || require_or_load_without_engine_additions(file_name, const_path)
               end
             end
-            Dependencies.send :include, Engines::RailsExtensions::Dependencies
+            ActiveSupport::Dependencies.send :include, Engines::RailsExtensions::Dependencies

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages