jro_apps/redmine Commit - r9355:d0d01d4e704b

Jicamarca Repository

0

- This repo
- ?
- Use '/' key to quickly access this field. - Enter a name of repository, or repository group for quick search. - Prefix query to allow special search: user:admin, to search for usernames, always global user_group:devops, to search for user groups, always global pr:303, to search for pull request number, title, or description, always global commit:efced4, to search for commits, scoped to repositories or groups file:models.py, to search for file paths, scoped to repositories or groups For advanced full text search visit: repository search
Home
Public journal
Gists
Sign in

jro_apps » redmine

RSS

model: replace Rails2 "named_scope" to Rails3 "scope"...

Toshi MARUYAMA -

r9355:d0d01d4e704b

parent child

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

                validates_length_of :name, :maximum => 30
                validates_length_of :description, :maximum => 255
-               named_scope :visible, lambda {|*args| { :include => :project,
+               scope :visible, lambda {|*args| { :include => :project,
                                                        :conditions => Project.allowed_to_condition(args.shift || User.current, :view_messages, *args) } }
                safe_attributes 'name', 'description', 'move_to'

                validates_uniqueness_of :revision, :scope => :repository_id
                validates_uniqueness_of :scmid, :scope => :repository_id, :allow_nil => true
-               named_scope :visible, lambda {|*args| { :include => {:repository => :project},
+               scope :visible,
+                  lambda {|*args| { :include => {:repository => :project},
                                                        :conditions => Project.allowed_to_condition(args.shift || User.current, :view_changesets, *args) } }
                after_create :scan_for_issues

                validates_presence_of :project, :title, :category
                validates_length_of :title, :maximum => 60
-               named_scope :visible, lambda {|*args| { :include => :project,
+               scope :visible, lambda {|*args| { :include => :project,
                                                        :conditions => Project.allowed_to_condition(args.shift || User.current, :view_documents, *args) } }
                safe_attributes 'category_id', 'title', 'description'

                validates_uniqueness_of :name, :scope => [:type, :project_id]
                validates_length_of :name, :maximum => 30
-               named_scope :shared, :conditions => { :project_id => nil }
-               named_scope :active, :conditions => { :active => true }
-               named_scope :named, lambda {|arg| { :conditions => ["LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip]}}
+               scope :shared, :conditions => { :project_id => nil }
+               scope :active, :conditions => { :active => true }
+               scope :named, lambda {|arg| { :conditions => ["LOWER(#{table_name}.name) = LOWER(?)", arg.to_s.strip]}}
                def self.default
                  # Creates a fake default scope so Enumeration.default will check

                validates_numericality_of :estimated_hours, :allow_nil => true
                validate :validate_issue
-               named_scope :visible, lambda {|*args| { :include => :project,
+               scope :visible,
+                     lambda {|*args| { :include => :project,
-                                                       :conditions => Issue.visible_condition(args.shift || User.current, *args) } }
-               named_scope :open, lambda {|*args|
+               scope :open, lambda {|*args|
                  is_closed = args.size > 0 ? !args.first : false
                  {:conditions => ["#{IssueStatus.table_name}.is_closed = ?", is_closed], :include => :status}
                }
-               named_scope :recently_updated, :order => "#{Issue.table_name}.updated_on DESC"
-               named_scope :with_limit, lambda { |limit| { :limit => limit} }
-               named_scope :on_active_project, :include => [:status, :project, :tracker],
+               scope :recently_updated, :order => "#{Issue.table_name}.updated_on DESC"
+               scope :with_limit, lambda { |limit| { :limit => limit} }
+               scope :on_active_project, :include => [:status, :project, :tracker],
-                                               :conditions => ["#{Project.table_name}.status=#{Project::STATUS_ACTIVE}"]
                before_create :default_assign

                after_update :update_messages_board
                after_destroy :reset_board_counters
-               named_scope :visible, lambda {|*args| { :include => {:board => :project},
+               scope :visible, lambda {|*args| { :include => {:board => :project},
                                                        :conditions => Project.allowed_to_condition(args.shift || User.current, :view_messages, *args) } }
                safe_attributes 'subject', 'content'

                has_many :issue_categories, :foreign_key => 'assigned_to_id', :dependent => :nullify
                # Groups and active users
-               named_scope :active, :conditions => "#{Principal.table_name}.status = 1"
+               scope :active, :conditions => "#{Principal.table_name}.status = 1"
-               named_scope :like, lambda {|q|
+               scope :like, lambda {|q|
                  if q.blank?
                    {}
                  else
                }
                # Principals that are members of a collection of projects
-               named_scope :member_of, lambda {|projects|
+               scope :member_of, lambda {|projects|
                  projects = [projects] unless projects.is_a?(Array)
                  if projects.empty?
                    {:conditions => "1=0"}
                  end
                }
                # Principals that are not members of projects
-               named_scope :not_member_of, lambda {|projects|
+               scope :not_member_of, lambda {|projects|
                  projects = [projects] unless projects.is_a?(Array)
                  if projects.empty?
                    {:conditions => "1=0"}

                before_destroy :delete_all_members
-               named_scope :has_module, lambda { |mod| { :conditions => ["#{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name=?)", mod.to_s] } }
-               named_scope :active, { :conditions => "#{Project.table_name}.status = #{STATUS_ACTIVE}"}
-               named_scope :status, lambda {|arg| arg.blank? ? {} : {:conditions => {:status => arg.to_i}} }
-               named_scope :all_public, { :conditions => { :is_public => true } }
-               named_scope :visible, lambda {|*args| {:conditions => Project.visible_condition(args.shift || User.current, *args) }}
-               named_scope :allowed_to, lambda {|*args|
+               scope :has_module, lambda { |mod| { :conditions => ["#{Project.table_name}.id IN (SELECT em.project_id FROM #{EnabledModule.table_name} em WHERE em.name=?)", mod.to_s] } }
+               scope :active, { :conditions => "#{Project.table_name}.status = #{STATUS_ACTIVE}"}
+               scope :status, lambda {|arg| arg.blank? ? {} : {:conditions => {:status => arg.to_i}} }
+               scope :all_public, { :conditions => { :is_public => true } }
+               scope :visible, lambda {|*args| {:conditions => Project.visible_condition(args.shift || User.current, *args) }}
+               scope :allowed_to, lambda {|*args|
                  user = User.current
                  permission = nil
                  if args.first.is_a?(Symbol)
                  end
                  { :conditions => Project.allowed_to_condition(user, permission, *args) }
                }
-               named_scope :like, lambda {|arg|
+               scope :like, lambda {|arg|
                  if arg.blank?
                    {}
                  else

                ]
                cattr_reader :available_columns
-               named_scope :visible, lambda {|*args|
+               scope :visible, lambda {|*args|
                  user = args.shift || User.current
                  base = Project.allowed_to_condition(user, :view_issues, *args)
                  user_id = user.logged? ? user.id : 0

                  ['own', :label_issues_visibility_own]
                ]
-               named_scope :sorted, {:order => 'builtin, position'}
-               named_scope :givable, { :conditions => "builtin = 0", :order => 'position' }
-               named_scope :builtin, lambda { |*args|
+               scope :sorted, {:order => 'builtin, position'}
+               scope :givable, { :conditions => "builtin = 0", :order => 'position' }
+               scope :builtin, lambda { |*args|
                  compare = 'not' if args.first == true
                  { :conditions => "#{compare} builtin = 0" }
                }

                before_validation :set_project_if_nil
                validate :validate_time_entry
-               named_scope :visible, lambda {|*args| {
+               scope :visible, lambda {|*args| {
                  :include => :project,
                  :conditions => Project.allowed_to_condition(args.shift || User.current, :view_time_entries, *args)
                }}
-               named_scope :on_issue, lambda {|issue| {
+               scope :on_issue, lambda {|issue| {
                  :include => :issue,
                  :conditions => "#{Issue.table_name}.root_id = #{issue.root_id} AND #{Issue.table_name}.lft >= #{issue.lft} AND #{Issue.table_name}.rgt <= #{issue.rgt}"
                }}
-               named_scope :on_project, lambda {|project, include_subprojects| {
+               scope :on_project, lambda {|project, include_subprojects| {
                  :include => :project,
                  :conditions => project.project_condition(include_subprojects)
                }}
-               named_scope :spent_between, lambda {|from, to|
+               scope :spent_between, lambda {|from, to|
                  if from && to
                   {:conditions => ["#{TimeEntry.table_name}.spent_on BETWEEN ? AND ?", from, to]}
                  elsif from

                belongs_to :auth_source
                # Active non-anonymous users scope
-               named_scope :active, :conditions => "#{User.table_name}.status = #{STATUS_ACTIVE}"
-               named_scope :logged, :conditions => "#{User.table_name}.status <> #{STATUS_ANONYMOUS}"
-               named_scope :status, lambda {|arg| arg.blank? ? {} : {:conditions => {:status => arg.to_i}} }
+               scope :active, :conditions => "#{User.table_name}.status = #{STATUS_ACTIVE}"
+               scope :logged, :conditions => "#{User.table_name}.status <> #{STATUS_ANONYMOUS}"
+               scope :status, lambda {|arg| arg.blank? ? {} : {:conditions => {:status => arg.to_i}} }
                acts_as_customizable
                before_save   :update_hashed_password
                before_destroy :remove_references_before_destroy
-               named_scope :in_group, lambda {|group|
+               scope :in_group, lambda {|group|
                  group_id = group.is_a?(Group) ? group.id : group.to_i
                  { :conditions => ["#{User.table_name}.id IN (SELECT gu.user_id FROM #{table_name_prefix}groups_users#{table_name_suffix} gu WHERE gu.group_id = ?)", group_id] }
                }
-               named_scope :not_in_group, lambda {|group|
+               scope :not_in_group, lambda {|group|
                  group_id = group.is_a?(Group) ? group.id : group.to_i
                  { :conditions => ["#{User.table_name}.id NOT IN (SELECT gu.user_id FROM #{table_name_prefix}groups_users#{table_name_suffix} gu WHERE gu.group_id = ?)", group_id] }
                }

                before_save    :handle_redirects
                # eager load information about last updates, without loading text
-               named_scope :with_updated_on, {
+               scope :with_updated_on, {
                  :select => "#{WikiPage.table_name}.*, #{WikiContent.table_name}.updated_on",
                  :joins => "LEFT JOIN #{WikiContent.table_name} ON #{WikiContent.table_name}.page_id = #{WikiPage.table_name}.id"
                }