jro_apps/redmine Commit - r4292:2ee45e8cac90

Use Object#tap instead of #returning (#6887)....

Jean-Philippe Lang -

r4292:2ee45e8cac90

parent child

Context file:

r4292:2ee45e8cac90

Collapse all files

lib/redmine/hook.rb +1 -1

             # Redmine - project management software
             # Copyright (C) 2006-2008  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.
             module Redmine
               module Hook
                 include ActionController::UrlWriter
                 @@listener_classes = []
                 @@listeners = nil
                 @@hook_listeners = {}
                 class << self
                   # Adds a listener class.
                   # Automatically called when a class inherits from Redmine::Hook::Listener.
                   def add_listener(klass)
                     raise "Hooks must include Singleton module." unless klass.included_modules.include?(Singleton)
                     @@listener_classes << klass
                     clear_listeners_instances
                   end
                   # Returns all the listerners instances.
                   def listeners
                     @@listeners ||= @@listener_classes.collect {|listener| listener.instance}
                   end
                   # Returns the listeners instances for the given hook.
                   def hook_listeners(hook)
                     @@hook_listeners[hook] ||= listeners.select {|listener| listener.respond_to?(hook)}
                   end
                   # Clears all the listeners.
                   def clear_listeners
                     @@listener_classes = []
                     clear_listeners_instances
                   end
                   # Clears all the listeners instances.
                   def clear_listeners_instances
                     @@listeners = nil
                     @@hook_listeners = {}
                   end
                   # Calls a hook.
                   # Returns the listeners response.
                   def call_hook(hook, context={})
-                    returning [] do |response|
+                    [].tap do |response|
                       hls = hook_listeners(hook)
                       if hls.any?
                         hls.each {|listener| response << listener.send(hook, context)}
                       end
                     end
                   end
                 end
                 # Base class for hook listeners.
                 class Listener
                   include Singleton
                   include Redmine::I18n
                   # Registers the listener
                   def self.inherited(child)
                     Redmine::Hook.add_listener(child)
                     super
                   end
                 end
                 # Listener class used for views hooks.
                 # Listeners that inherit this class will include various helpers by default.
                 class ViewListener < Listener
                   include ERB::Util
                   include ActionView::Helpers::TagHelper
                   include ActionView::Helpers::FormHelper
                   include ActionView::Helpers::FormTagHelper
                   include ActionView::Helpers::FormOptionsHelper
                   include ActionView::Helpers::JavaScriptHelper
                   include ActionView::Helpers::PrototypeHelper
                   include ActionView::Helpers::NumberHelper
                   include ActionView::Helpers::UrlHelper
                   include ActionView::Helpers::AssetTagHelper
                   include ActionView::Helpers::TextHelper
                   include ActionController::UrlWriter
                   include ApplicationHelper
                   # Default to creating links using only the path.  Subclasses can
                   # change this default as needed
                   def self.default_url_options
                     {:only_path => true }
                   end
                   # Helper method to directly render a partial using the context:
                   #
                   #   class MyHook < Redmine::Hook::ViewListener
                   #     render_on :view_issues_show_details_bottom, :partial => "show_more_data"
                   #   end
                   #
                   def self.render_on(hook, options={})
                     define_method hook do |context|
                       context[:controller].send(:render_to_string, {:locals => context}.merge(options))
                     end
                   end
                 end
                 # Helper module included in ApplicationHelper and ActionControllerso that
                 # hooks can be called in views like this:
                 #
                 #   <%= call_hook(:some_hook) %>
                 #   <%= call_hook(:another_hook, :foo => 'bar' %>
                 #
                 # Or in controllers like:
                 #   call_hook(:some_hook)
                 #   call_hook(:another_hook, :foo => 'bar'
                 #
                 # Hooks added to views will be concatenated into a string.  Hooks added to
                 # controllers will return an array of results.
                 #
                 # Several objects are automatically added to the call context:
                 #
                 # * project => current project
                 # * request => Request instance
                 # * controller => current Controller instance
                 #
                 module Helper
                   def call_hook(hook, context={})
                     if is_a?(ActionController::Base)
                       default_context = {:controller => self, :project => @project, :request => request}
                       Redmine::Hook.call_hook(hook, default_context.merge(context))
                     else
                       default_context = {:controller => controller, :project => @project, :request => request}
                       Redmine::Hook.call_hook(hook, default_context.merge(context)).join(' ')
                     end
                   end
                 end
               end
             end
             ApplicationHelper.send(:include, Redmine::Hook::Helper)
             ActionController::Base.send(:include, Redmine::Hook::Helper)

lib/redmine/menu_manager.rb +3 -3

             # 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 'tree' # gem install rubytree
             # Monkey patch the TreeNode to add on a few more methods :nodoc:
             module TreeNodePatch
               def self.included(base)
                 base.class_eval do
                   attr_reader :last_items_count
                   alias :old_initilize :initialize
                   def initialize(name, content = nil)
                     old_initilize(name, content)
                     @last_items_count = 0
                     extend(InstanceMethods)
                   end
                 end
               end
               module InstanceMethods
                 # Adds the specified child node to the receiver node.  The child node's
                 # parent is set to be the receiver.  The child is added as the first child in
                 # the current list of children for the receiver node.
                 def prepend(child)
                   raise "Child already added" if @childrenHash.has_key?(child.name)
                   @childrenHash[child.name]  = child
                   @children = [child] + @children
                   child.parent = self
                   return child
                 end
                 # Adds the specified child node to the receiver node.  The child node's
                 # parent is set to be the receiver.  The child is added at the position
                 # into the current list of children for the receiver node.
                 def add_at(child, position)
                   raise "Child already added" if @childrenHash.has_key?(child.name)
                   @childrenHash[child.name]  = child
                   @children = @children.insert(position, child)
                   child.parent = self
                   return child
                 end
                 def add_last(child)
                   raise "Child already added" if @childrenHash.has_key?(child.name)
                   @childrenHash[child.name]  = child
                   @children <<  child
                   @last_items_count += 1
                   child.parent = self
                   return child
                 end
                 # Adds the specified child node to the receiver node.  The child node's
                 # parent is set to be the receiver.  The child is added as the last child in
                 # the current list of children for the receiver node.
                 def add(child)
                   raise "Child already added" if @childrenHash.has_key?(child.name)
                   @childrenHash[child.name]  = child
                   position = @children.size - @last_items_count
                   @children.insert(position, child)
                   child.parent = self
                   return child
                 end
                 # Wrapp remove! making sure to decrement the last_items counter if
                 # the removed child was a last item
                 def remove!(child)
                   @last_items_count -= +1 if child && child.last
                   super
                 end
                 # Will return the position (zero-based) of the current child in
                 # it's parent
                 def position
                   self.parent.children.index(self)
                 end
               end
             end
             Tree::TreeNode.send(:include, TreeNodePatch)
             module Redmine
               module MenuManager
                 class MenuError < StandardError #:nodoc:
                 end
                 module MenuController
                   def self.included(base)
                     base.extend(ClassMethods)
                   end
                   module ClassMethods
                     @@menu_items = Hash.new {|hash, key| hash[key] = {:default => key, :actions => {}}}
                     mattr_accessor :menu_items
                     # Set the menu item name for a controller or specific actions
                     # Examples:
                     #   * menu_item :tickets # => sets the menu name to :tickets for the whole controller
                     #   * menu_item :tickets, :only => :list # => sets the menu name to :tickets for the 'list' action only
                     #   * menu_item :tickets, :only => [:list, :show] # => sets the menu name to :tickets for 2 actions only
                     #
                     # The default menu item name for a controller is controller_name by default
                     # Eg. the default menu item name for ProjectsController is :projects
                     def menu_item(id, options = {})
                       if actions = options[:only]
                         actions = [] << actions unless actions.is_a?(Array)
                         actions.each {|a| menu_items[controller_name.to_sym][:actions][a.to_sym] = id}
                       else
                         menu_items[controller_name.to_sym][:default] = id
                       end
                     end
                   end
                   def menu_items
                     self.class.menu_items
                   end
                   # Returns the menu item name according to the current action
                   def current_menu_item
                     @current_menu_item ||= menu_items[controller_name.to_sym][:actions][action_name.to_sym] ||
                                              menu_items[controller_name.to_sym][:default]
                   end
                   # Redirects user to the menu item of the given project
                   # Returns false if user is not authorized
                   def redirect_to_project_menu_item(project, name)
                     item = Redmine::MenuManager.items(:project_menu).detect {|i| i.name.to_s == name.to_s}
                     if item && User.current.allowed_to?(item.url, project) && (item.condition.nil? || item.condition.call(project))
                       redirect_to({item.param => project}.merge(item.url))
                       return true
                     end
                     false
                   end
                 end
                 module MenuHelper
                   # Returns the current menu item name
                   def current_menu_item
                     @controller.current_menu_item
                   end
                   # Renders the application main menu
                   def render_main_menu(project)
                     render_menu((project && !project.new_record?) ? :project_menu : :application_menu, project)
                   end
                   def display_main_menu?(project)
                     menu_name = project && !project.new_record? ? :project_menu : :application_menu
                     Redmine::MenuManager.items(menu_name).size > 1 # 1 element is the root
                   end
                   def render_menu(menu, project=nil)
                     links = []
                     menu_items_for(menu, project) do |node|
                       links << render_menu_node(node, project)
                     end
                     links.empty? ? nil : content_tag('ul', links.join("\n"))
                   end
                   def render_menu_node(node, project=nil)
                     if node.hasChildren? || !node.child_menus.nil?
                       return render_menu_node_with_children(node, project)
                     else
                       caption, url, selected = extract_node_details(node, project)
                       return content_tag('li',
                                            render_single_menu_node(node, caption, url, selected))
                     end
                   end
                   def render_menu_node_with_children(node, project=nil)
                     caption, url, selected = extract_node_details(node, project)
-                    html = returning [] do |html|
+                    html = [].tap do |html|
                       html << '<li>'
                       # Parent
                       html << render_single_menu_node(node, caption, url, selected)
                       # Standard children
-                      standard_children_list = returning "" do |child_html|
+                      standard_children_list = "".tap do |child_html|
                         node.children.each do |child|
                           child_html << render_menu_node(child, project)
                         end
                       end
                       html << content_tag(:ul, standard_children_list, :class => 'menu-children') unless standard_children_list.empty?
                       # Unattached children
                       unattached_children_list = render_unattached_children_menu(node, project)
                       html << content_tag(:ul, unattached_children_list, :class => 'menu-children unattached') unless unattached_children_list.blank?
                       html << '</li>'
                     end
                     return html.join("\n")
                   end
                   # Returns a list of unattached children menu items
                   def render_unattached_children_menu(node, project)
                     return nil unless node.child_menus
-                    returning "" do |child_html|
+                    "".tap do |child_html|
                       unattached_children = node.child_menus.call(project)
                       # Tree nodes support #each so we need to do object detection
                       if unattached_children.is_a? Array
                         unattached_children.each do |child|
                           child_html << content_tag(:li, render_unattached_menu_item(child, project))
                         end
                       else
                         raise MenuError, ":child_menus must be an array of MenuItems"
                       end
                     end
                   end
                   def render_single_menu_node(item, caption, url, selected)
                     link_to(h(caption), url, item.html_options(:selected => selected))
                   end
                   def render_unattached_menu_item(menu_item, project)
                     raise MenuError, ":child_menus must be an array of MenuItems" unless menu_item.is_a? MenuItem
                     if User.current.allowed_to?(menu_item.url, project)
                       link_to(h(menu_item.caption),
                               menu_item.url,
                               menu_item.html_options)
                     end
                   end
                   def menu_items_for(menu, project=nil)
                     items = []
                     Redmine::MenuManager.items(menu).root.children.each do |node|
                       if allowed_node?(node, User.current, project)
                         if block_given?
                           yield node
                         else
                           items << node  # TODO: not used?
                         end
                       end
                     end
                     return block_given? ? nil : items
                   end
                   def extract_node_details(node, project=nil)
                     item = node
                     url = case item.url
                     when Hash
                       project.nil? ? item.url : {item.param => project}.merge(item.url)
                     when Symbol
                       send(item.url)
                     else
                       item.url
                     end
                     caption = item.caption(project)
                     return [caption, url, (current_menu_item == item.name)]
                   end
                   # Checks if a user is allowed to access the menu item by:
                   #
                   # * Checking the conditions of the item
                   # * Checking the url target (project only)
                   def allowed_node?(node, user, project)
                     if node.condition && !node.condition.call(project)
                       # Condition that doesn't pass
                       return false
                     end
                     if project
                       return user && user.allowed_to?(node.url, project)
                     else
                       # outside a project, all menu items allowed
                       return true
                     end
                   end
                 end
                 class << self
                   def map(menu_name)
                     @items ||= {}
                     mapper = Mapper.new(menu_name.to_sym, @items)
                     if block_given?
                       yield mapper
                     else
                       mapper
                     end
                   end
                   def items(menu_name)
                     @items[menu_name.to_sym] || Tree::TreeNode.new(:root, {})
                   end
                 end
                 class Mapper
                   def initialize(menu, items)
                     items[menu] ||= Tree::TreeNode.new(:root, {})
                     @menu = menu
                     @menu_items = items[menu]
                   end
                   @@last_items_count = Hash.new {|h,k| h[k] = 0}
                   # Adds an item at the end of the menu. Available options:
                   # * param: the parameter name that is used for the project id (default is :id)
                   # * if: a Proc that is called before rendering the item, the item is displayed only if it returns true
                   # * caption that can be:
                   #   * a localized string Symbol
                   #   * a String
                   #   * a Proc that can take the project as argument
                   # * before, after: specify where the menu item should be inserted (eg. :after => :activity)
                   # * parent: menu item will be added as a child of another named menu (eg. :parent => :issues)
                   # * children: a Proc that is called before rendering the item. The Proc should return an array of MenuItems, which will be added as children to this item.
                   #   eg. :children => Proc.new {|project| [Redmine::MenuManager::MenuItem.new(...)] }
                   # * last: menu item will stay at the end (eg. :last => true)
                   # * html_options: a hash of html options that are passed to link_to
                   def push(name, url, options={})
                     options = options.dup
                     if options[:parent]
                       subtree = self.find(options[:parent])
                       if subtree
                         target_root = subtree
                       else
                         target_root = @menu_items.root
                       end
                     else
                       target_root = @menu_items.root
                     end
                     # menu item position
                     if first = options.delete(:first)
                       target_root.prepend(MenuItem.new(name, url, options))
                     elsif before = options.delete(:before)
                       if exists?(before)
                         target_root.add_at(MenuItem.new(name, url, options), position_of(before))
                       else
                         target_root.add(MenuItem.new(name, url, options))
                       end
                     elsif after = options.delete(:after)
                       if exists?(after)
                         target_root.add_at(MenuItem.new(name, url, options), position_of(after) + 1)
                       else
                         target_root.add(MenuItem.new(name, url, options))
                       end
                     elsif options[:last] # don't delete, needs to be stored
                       target_root.add_last(MenuItem.new(name, url, options))
                     else
                       target_root.add(MenuItem.new(name, url, options))
                     end
                   end
                   # Removes a menu item
                   def delete(name)
                     if found = self.find(name)
                       @menu_items.remove!(found)
                     end
                   end
                   # Checks if a menu item exists
                   def exists?(name)
                     @menu_items.any? {|node| node.name == name}
                   end
                   def find(name)
                     @menu_items.find {|node| node.name == name}
                   end
                   def position_of(name)
                     @menu_items.each do |node|
                       if node.name == name
                         return node.position
                       end
                     end
                   end
                 end
                 class MenuItem < Tree::TreeNode
                   include Redmine::I18n
                   attr_reader :name, :url, :param, :condition, :parent, :child_menus, :last
                   def initialize(name, url, options)
                     raise ArgumentError, "Invalid option :if for menu item '#{name}'" if options[:if] && !options[:if].respond_to?(:call)
                     raise ArgumentError, "Invalid option :html for menu item '#{name}'" if options[:html] && !options[:html].is_a?(Hash)
                     raise ArgumentError, "Cannot set the :parent to be the same as this item" if options[:parent] == name.to_sym
                     raise ArgumentError, "Invalid option :children for menu item '#{name}'" if options[:children] && !options[:children].respond_to?(:call)
                     @name = name
                     @url = url
                     @condition = options[:if]
                     @param = options[:param] || :id
                     @caption = options[:caption]
                     @html_options = options[:html] || {}
                     # Adds a unique class to each menu item based on its name
                     @html_options[:class] = [@html_options[:class], @name.to_s.dasherize].compact.join(' ')
                     @parent = options[:parent]
                     @child_menus = options[:children]
                     @last = options[:last] || false
                     super @name.to_sym
                   end
                   def caption(project=nil)
                     if @caption.is_a?(Proc)
                       c = @caption.call(project).to_s
                       c = @name.to_s.humanize if c.blank?
                       c
                     else
                       if @caption.nil?
                         l_or_humanize(name, :prefix => 'label_')
                       else
                         @caption.is_a?(Symbol) ? l(@caption) : @caption
                       end
                     end
                   end
                   def html_options(options={})
                     if options[:selected]
                       o = @html_options.dup
                       o[:class] += ' selected'
                       o
                     else
                       @html_options
                     end
                   end
                 end
               end
             end

test/exemplars/project_exemplar.rb +1 -1

             class Project < ActiveRecord::Base
               generator_for :name, :method => :next_name
               generator_for :identifier, :method => :next_identifier_from_object_daddy
               generator_for :enabled_modules, :method => :all_modules
               generator_for :trackers, :method => :next_tracker
               def self.next_name
                 @last_name ||= 'Project 0'
                 @last_name.succ!
                 @last_name
               end
               # Project#next_identifier is defined on Redmine
               def self.next_identifier_from_object_daddy
                 @last_identifier ||= 'project-0000'
                 @last_identifier.succ!
                 @last_identifier
               end
               def self.all_modules
-                returning [] do |modules|
+                [].tap do |modules|
                   Redmine::AccessControl.available_project_modules.each do |name|
                     modules << EnabledModule.new(:name => name.to_s)
                   end
                 end
               end
               def self.next_tracker
                 [Tracker.generate!]
               end
             end

vendor/plugins/awesome_nested_set/lib/awesome_nested_set.rb +1 -1

             module CollectiveIdea #:nodoc:
               module Acts #:nodoc:
                 module NestedSet #:nodoc:
                   def self.included(base)
                     base.extend(SingletonMethods)
                   end
                   # This acts provides Nested Set functionality. Nested Set is a smart way to implement
                   # an _ordered_ tree, with the added feature that you can select the children and all of their
                   # descendants with a single query. The drawback is that insertion or move need some complex
                   # sql queries. But everything is done here by this module!
                   #
                   # Nested sets are appropriate each time you want either an orderd tree (menus,
                   # commercial categories) or an efficient way of querying big trees (threaded posts).
                   #
                   # == API
                   #
                   # Methods names are aligned with acts_as_tree as much as possible, to make replacment from one
                   # by another easier, except for the creation:
                   #
                   # in acts_as_tree:
                   #   item.children.create(:name => "child1")
                   #
                   # in acts_as_nested_set:
                   #   # adds a new item at the "end" of the tree, i.e. with child.left = max(tree.right)+1
                   #   child = MyClass.new(:name => "child1")
                   #   child.save
                   #   # now move the item to its right place
                   #   child.move_to_child_of my_item
                   #
                   # You can pass an id or an object to:
                   # * <tt>#move_to_child_of</tt>
                   # * <tt>#move_to_right_of</tt>
                   # * <tt>#move_to_left_of</tt>
                   #
                   module SingletonMethods
                     # Configuration options are:
                     #
                     # * +:parent_column+ - specifies the column name to use for keeping the position integer (default: parent_id)
                     # * +:left_column+ - column name for left boundry data, default "lft"
                     # * +:right_column+ - column name for right boundry data, default "rgt"
                     # * +:scope+ - restricts what is to be considered a list. Given a symbol, it'll attach "_id"
                     #   (if it hasn't been already) and use that as the foreign key restriction. You
                     #   can also pass an array to scope by multiple attributes.
                     #   Example: <tt>acts_as_nested_set :scope => [:notable_id, :notable_type]</tt>
                     # * +:dependent+ - behavior for cascading destroy. If set to :destroy, all the
                     #   child objects are destroyed alongside this object by calling their destroy
                     #   method. If set to :delete_all (default), all the child objects are deleted
                     #   without calling their destroy method.
                     #
                     # See CollectiveIdea::Acts::NestedSet::ClassMethods for a list of class methods and
                     # CollectiveIdea::Acts::NestedSet::InstanceMethods for a list of instance methods added
                     # to acts_as_nested_set models
                     def acts_as_nested_set(options = {})
                       options = {
                         :parent_column => 'parent_id',
                         :left_column => 'lft',
                         :right_column => 'rgt',
                         :order => 'id',
                         :dependent => :delete_all, # or :destroy
                       }.merge(options)
                       if options[:scope].is_a?(Symbol) && options[:scope].to_s !~ /_id$/
                         options[:scope] = "#{options[:scope]}_id".intern
                       end
                       write_inheritable_attribute :acts_as_nested_set_options, options
                       class_inheritable_reader :acts_as_nested_set_options
                       include Comparable
                       include Columns
                       include InstanceMethods
                       extend Columns
                       extend ClassMethods
                       # no bulk assignment
                       attr_protected  left_column_name.intern,
                                       right_column_name.intern,
                                       parent_column_name.intern
                       before_create :set_default_left_and_right
                       before_destroy :prune_from_tree
                       # no assignment to structure fields
                       [left_column_name, right_column_name, parent_column_name].each do |column|
                         module_eval <<-"end_eval", __FILE__, __LINE__
                           def #{column}=(x)
                             raise ActiveRecord::ActiveRecordError, "Unauthorized assignment to #{column}: it's an internal field handled by acts_as_nested_set code, use move_to_* methods instead."
                           end
                         end_eval
                       end
                       named_scope :roots, :conditions => {parent_column_name => nil}, :order => quoted_left_column_name
                       named_scope :leaves, :conditions => "#{quoted_right_column_name} - #{quoted_left_column_name} = 1", :order => quoted_left_column_name
                       if self.respond_to?(:define_callbacks)
                         define_callbacks("before_move", "after_move")
                       end
                     end
                   end
                   module ClassMethods
                     # Returns the first root
                     def root
                       roots.find(:first)
                     end
                     def valid?
                       left_and_rights_valid? && no_duplicates_for_columns? && all_roots_valid?
                     end
                     def left_and_rights_valid?
                       count(
                         :joins => "LEFT OUTER JOIN #{quoted_table_name} AS parent ON " +
                           "#{quoted_table_name}.#{quoted_parent_column_name} = parent.#{primary_key}",
                         :conditions =>
                           "#{quoted_table_name}.#{quoted_left_column_name} IS NULL OR " +
                           "#{quoted_table_name}.#{quoted_right_column_name} IS NULL OR " +
                           "#{quoted_table_name}.#{quoted_left_column_name} >= " +
                             "#{quoted_table_name}.#{quoted_right_column_name} OR " +
                           "(#{quoted_table_name}.#{quoted_parent_column_name} IS NOT NULL AND " +
                             "(#{quoted_table_name}.#{quoted_left_column_name} <= parent.#{quoted_left_column_name} OR " +
                             "#{quoted_table_name}.#{quoted_right_column_name} >= parent.#{quoted_right_column_name}))"
                       ) == 0
                     end
                     def no_duplicates_for_columns?
                       scope_string = Array(acts_as_nested_set_options[:scope]).map do |c|
                         connection.quote_column_name(c)
                       end.push(nil).join(", ")
                       [quoted_left_column_name, quoted_right_column_name].all? do |column|
                         # No duplicates
                         find(:first,
                           :select => "#{scope_string}#{column}, COUNT(#{column})",
                           :group => "#{scope_string}#{column}
                             HAVING COUNT(#{column}) > 1").nil?
                       end
                     end
                     # Wrapper for each_root_valid? that can deal with scope.
                     def all_roots_valid?
                       if acts_as_nested_set_options[:scope]
                         roots(:group => scope_column_names).group_by{|record| scope_column_names.collect{|col| record.send(col.to_sym)}}.all? do |scope, grouped_roots|
                           each_root_valid?(grouped_roots)
                         end
                       else
                         each_root_valid?(roots)
                       end
                     end
                     def each_root_valid?(roots_to_validate)
                       left = right = 0
                       roots_to_validate.all? do |root|
-                        returning(root.left > left && root.right > right) do
+                        (root.left > left && root.right > right).tap do
                           left = root.left
                           right = root.right
                         end
                       end
                     end
                     # Rebuilds the left & rights if unset or invalid.  Also very useful for converting from acts_as_tree.
                     def rebuild!
                       # Don't rebuild a valid tree.
                       return true if valid?
                       scope = lambda{|node|}
                       if acts_as_nested_set_options[:scope]
                         scope = lambda{|node|
                           scope_column_names.inject(""){|str, column_name|
                             str << "AND #{connection.quote_column_name(column_name)} = #{connection.quote(node.send(column_name.to_sym))} "
                           }
                         }
                       end
                       indices = {}
                       set_left_and_rights = lambda do |node|
                         # set left
                         node[left_column_name] = indices[scope.call(node)] += 1
                         # find
                         find(:all, :conditions => ["#{quoted_parent_column_name} = ? #{scope.call(node)}", node], :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each{|n| set_left_and_rights.call(n) }
                         # set right
                         node[right_column_name] = indices[scope.call(node)] += 1
                         node.save!
                       end
                       # Find root node(s)
                       root_nodes = find(:all, :conditions => "#{quoted_parent_column_name} IS NULL", :order => "#{quoted_left_column_name}, #{quoted_right_column_name}, #{acts_as_nested_set_options[:order]}").each do |root_node|
                         # setup index for this scope
                         indices[scope.call(root_node)] ||= 0
                         set_left_and_rights.call(root_node)
                       end
                     end
                   end
                   # Mixed into both classes and instances to provide easy access to the column names
                   module Columns
                     def left_column_name
                       acts_as_nested_set_options[:left_column]
                     end
                     def right_column_name
                       acts_as_nested_set_options[:right_column]
                     end
                     def parent_column_name
                       acts_as_nested_set_options[:parent_column]
                     end
                     def scope_column_names
                       Array(acts_as_nested_set_options[:scope])
                     end
                     def quoted_left_column_name
                       connection.quote_column_name(left_column_name)
                     end
                     def quoted_right_column_name
                       connection.quote_column_name(right_column_name)
                     end
                     def quoted_parent_column_name
                       connection.quote_column_name(parent_column_name)
                     end
                     def quoted_scope_column_names
                       scope_column_names.collect {|column_name| connection.quote_column_name(column_name) }
                     end
                   end
                   # Any instance method that returns a collection makes use of Rails 2.1's named_scope (which is bundled for Rails 2.0), so it can be treated as a finder.
                   #
                   #   category.self_and_descendants.count
                   #   category.ancestors.find(:all, :conditions => "name like '%foo%'")
                   module InstanceMethods
                     # Value of the parent column
                     def parent_id
                       self[parent_column_name]
                     end
                     # Value of the left column
                     def left
                       self[left_column_name]
                     end
                     # Value of the right column
                     def right
                       self[right_column_name]
                     end
                     # Returns true if this is a root node.
                     def root?
                       parent_id.nil?
                     end
                     def leaf?
                       new_record? || (right - left == 1)
                     end
                     # Returns true is this is a child node
                     def child?
                       !parent_id.nil?
                     end
                     # order by left column
                     def <=>(x)
                       left <=> x.left
                     end
                     # Redefine to act like active record
                     def ==(comparison_object)
                       comparison_object.equal?(self) ||
                         (comparison_object.instance_of?(self.class) &&
                           comparison_object.id == id &&
                           !comparison_object.new_record?)
                     end
                     # Returns root
                     def root
                       self_and_ancestors.find(:first)
                     end
                     # Returns the immediate parent
                     def parent
                       nested_set_scope.find_by_id(parent_id) if parent_id
                     end
                     # Returns the array of all parents and self
                     def self_and_ancestors
                       nested_set_scope.scoped :conditions => [
                         "#{self.class.table_name}.#{quoted_left_column_name} <= ? AND #{self.class.table_name}.#{quoted_right_column_name} >= ?", left, right
                       ]
                     end
                     # Returns an array of all parents
                     def ancestors
                       without_self self_and_ancestors
                     end
                     # Returns the array of all children of the parent, including self
                     def self_and_siblings
                       nested_set_scope.scoped :conditions => {parent_column_name => parent_id}
                     end
                     # Returns the array of all children of the parent, except self
                     def siblings
                       without_self self_and_siblings
                     end
                     # Returns a set of all of its nested children which do not have children
                     def leaves
                       descendants.scoped :conditions => "#{self.class.table_name}.#{quoted_right_column_name} - #{self.class.table_name}.#{quoted_left_column_name} = 1"
                     end
                     # Returns the level of this object in the tree
                     # root level is 0
                     def level
                       parent_id.nil? ? 0 : ancestors.count
                     end
                     # Returns a set of itself and all of its nested children
                     def self_and_descendants
                       nested_set_scope.scoped :conditions => [
                         "#{self.class.table_name}.#{quoted_left_column_name} >= ? AND #{self.class.table_name}.#{quoted_right_column_name} <= ?", left, right
                       ]
                     end
                     # Returns a set of all of its children and nested children
                     def descendants
                       without_self self_and_descendants
                     end
                     # Returns a set of only this entry's immediate children
                     def children
                       nested_set_scope.scoped :conditions => {parent_column_name => self}
                     end
                     def is_descendant_of?(other)
                       other.left < self.left && self.left < other.right && same_scope?(other)
                     end
                     def is_or_is_descendant_of?(other)
                       other.left <= self.left && self.left < other.right && same_scope?(other)
                     end
                     def is_ancestor_of?(other)
                       self.left < other.left && other.left < self.right && same_scope?(other)
                     end
                     def is_or_is_ancestor_of?(other)
                       self.left <= other.left && other.left < self.right && same_scope?(other)
                     end
                     # Check if other model is in the same scope
                     def same_scope?(other)
                       Array(acts_as_nested_set_options[:scope]).all? do |attr|
                         self.send(attr) == other.send(attr)
                       end
                     end
                     # Find the first sibling to the left
                     def left_sibling
                       siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} < ?", left],
                         :order => "#{self.class.table_name}.#{quoted_left_column_name} DESC")
                     end
                     # Find the first sibling to the right
                     def right_sibling
                       siblings.find(:first, :conditions => ["#{self.class.table_name}.#{quoted_left_column_name} > ?", left])
                     end
                     # Shorthand method for finding the left sibling and moving to the left of it.
                     def move_left
                       move_to_left_of left_sibling
                     end
                     # Shorthand method for finding the right sibling and moving to the right of it.
                     def move_right
                       move_to_right_of right_sibling
                     end
                     # Move the node to the left of another node (you can pass id only)
                     def move_to_left_of(node)
                       move_to node, :left
                     end
                     # Move the node to the left of another node (you can pass id only)
                     def move_to_right_of(node)
                       move_to node, :right
                     end
                     # Move the node to the child of another node (you can pass id only)
                     def move_to_child_of(node)
                       move_to node, :child
                     end
                     # Move the node to root nodes
                     def move_to_root
                       move_to nil, :root
                     end
                     def move_possible?(target)
                       self != target && # Can't target self
                       same_scope?(target) && # can't be in different scopes
                       # !(left..right).include?(target.left..target.right) # this needs tested more
                       # detect impossible move
                       !((left <= target.left && right >= target.left) or (left <= target.right && right >= target.right))
                     end
                     def to_text
                       self_and_descendants.map do |node|
                         "#{'*'*(node.level+1)} #{node.id} #{node.to_s} (#{node.parent_id}, #{node.left}, #{node.right})"
                       end.join("\n")
                     end
                   protected
                     def without_self(scope)
                       scope.scoped :conditions => ["#{self.class.table_name}.#{self.class.primary_key} != ?", self]
                     end
                     # All nested set queries should use this nested_set_scope, which performs finds on
                     # the base ActiveRecord class, using the :scope declared in the acts_as_nested_set
                     # declaration.
                     def nested_set_scope
                       options = {:order => quoted_left_column_name}
                       scopes = Array(acts_as_nested_set_options[:scope])
                       options[:conditions] = scopes.inject({}) do |conditions,attr|
                         conditions.merge attr => self[attr]
                       end unless scopes.empty?
                       self.class.base_class.scoped options
                     end
                     # on creation, set automatically lft and rgt to the end of the tree
                     def set_default_left_and_right
                       maxright = nested_set_scope.maximum(right_column_name) || 0
                       # adds the new node to the right of all existing nodes
                       self[left_column_name] = maxright + 1
                       self[right_column_name] = maxright + 2
                     end
                     # Prunes a branch off of the tree, shifting all of the elements on the right
                     # back to the left so the counts still work.
                     def prune_from_tree
                       return if right.nil? || left.nil?
                       diff = right - left + 1
                       delete_method = acts_as_nested_set_options[:dependent] == :destroy ?
                         :destroy_all : :delete_all
                       self.class.base_class.transaction do
                         nested_set_scope.send(delete_method,
                           ["#{quoted_left_column_name} > ? AND #{quoted_right_column_name} < ?",
                             left, right]
                         )
                         nested_set_scope.update_all(
                           ["#{quoted_left_column_name} = (#{quoted_left_column_name} - ?)", diff],
                           ["#{quoted_left_column_name} >= ?", right]
                         )
                         nested_set_scope.update_all(
                           ["#{quoted_right_column_name} = (#{quoted_right_column_name} - ?)", diff],
                           ["#{quoted_right_column_name} >= ?", right]
                         )
                       end
                     end
                     # reload left, right, and parent
                     def reload_nested_set
                       reload(:select => "#{quoted_left_column_name}, " +
                         "#{quoted_right_column_name}, #{quoted_parent_column_name}")
                     end
                     def move_to(target, position)
                       raise ActiveRecord::ActiveRecordError, "You cannot move a new node" if self.new_record?
                       return if callback(:before_move) == false
                       transaction do
                         if target.is_a? self.class.base_class
                           target.reload_nested_set
                         elsif position != :root
                           # load object if node is not an object
                           target = nested_set_scope.find(target)
                         end
                         self.reload_nested_set
                         unless position == :root || move_possible?(target)
                           raise ActiveRecord::ActiveRecordError, "Impossible move, target node cannot be inside moved tree."
                         end
                         bound = case position
                           when :child;  target[right_column_name]
                           when :left;   target[left_column_name]
                           when :right;  target[right_column_name] + 1
                           when :root;   1
                           else raise ActiveRecord::ActiveRecordError, "Position should be :child, :left, :right or :root ('#{position}' received)."
                         end
                         if bound > self[right_column_name]
                           bound = bound - 1
                           other_bound = self[right_column_name] + 1
                         else
                           other_bound = self[left_column_name] - 1
                         end
                         # there would be no change
                         return if bound == self[right_column_name] || bound == self[left_column_name]
                         # we have defined the boundaries of two non-overlapping intervals,
                         # so sorting puts both the intervals and their boundaries in order
                         a, b, c, d = [self[left_column_name], self[right_column_name], bound, other_bound].sort
                         new_parent = case position
                           when :child;  target.id
                           when :root;   nil
                           else          target[parent_column_name]
                         end
                         self.class.base_class.update_all([
                           "#{quoted_left_column_name} = CASE " +
                             "WHEN #{quoted_left_column_name} BETWEEN :a AND :b " +
                               "THEN #{quoted_left_column_name} + :d - :b " +
                             "WHEN #{quoted_left_column_name} BETWEEN :c AND :d " +
                               "THEN #{quoted_left_column_name} + :a - :c " +
                             "ELSE #{quoted_left_column_name} END, " +
                           "#{quoted_right_column_name} = CASE " +
                             "WHEN #{quoted_right_column_name} BETWEEN :a AND :b " +
                               "THEN #{quoted_right_column_name} + :d - :b " +
                             "WHEN #{quoted_right_column_name} BETWEEN :c AND :d " +
                               "THEN #{quoted_right_column_name} + :a - :c " +
                             "ELSE #{quoted_right_column_name} END, " +
                           "#{quoted_parent_column_name} = CASE " +
                             "WHEN #{self.class.base_class.primary_key} = :id THEN :new_parent " +
                             "ELSE #{quoted_parent_column_name} END",
                           {:a => a, :b => b, :c => c, :d => d, :id => self.id, :new_parent => new_parent}
                         ], nested_set_scope.proxy_options[:conditions])
                       end
                       target.reload_nested_set if target
                       self.reload_nested_set
                       callback(:after_move)
                     end
                   end
                 end
               end
             end

vendor/plugins/engines/generators/plugin_migration/plugin_migration_generator.rb +1 -1

             # Generates a migration which migrates all plugins to their latest versions
             # within the database.
             class PluginMigrationGenerator < Rails::Generator::Base
               # 255 characters max for Windows NTFS (http://en.wikipedia.org/wiki/Filename)
               # minus 14 for timestamp, minus some extra chars for dot, underscore, file
               # extension. So let's have 230.
               MAX_FILENAME_LENGTH = 230
               def initialize(runtime_args, runtime_options={})
                 super
                 @options = {:assigns => {}}
                 ensure_schema_table_exists
                 get_plugins_to_migrate(runtime_args)
                 if @plugins_to_migrate.empty?
                   puts "All plugins are migrated to their latest versions"
                   exit(0)
                 end
                 @options[:migration_file_name] = build_migration_name
                 @options[:assigns][:class_name] = build_migration_name.classify
               end
               def manifest
                 record do |m|
                   m.migration_template 'plugin_migration.erb', 'db/migrate', @options
                 end
               end
               protected
                 # Create the schema table if it doesn't already exist.
                 def ensure_schema_table_exists
                   ActiveRecord::Base.connection.initialize_schema_migrations_table
                 end
                 # Determine all the plugins which have migrations that aren't present
                 # according to the plugin schema information from the database.
                 def get_plugins_to_migrate(plugin_names)
                   # First, grab all the plugins which exist and have migrations
                   @plugins_to_migrate = if plugin_names.empty?
                     Engines.plugins
                   else
                     plugin_names.map do |name|
                       Engines.plugins[name] ? Engines.plugins[name] : raise("Cannot find the plugin '#{name}'")
                     end
                   end
                   @plugins_to_migrate.reject! { |p| !p.respond_to?(:latest_migration) || p.latest_migration.nil? }
                   # Then find the current versions from the database
                   @current_versions = {}
                   @plugins_to_migrate.each do |plugin|
                     @current_versions[plugin.name] = Engines::Plugin::Migrator.current_version(plugin)
                   end
                   # Then find the latest versions from their migration directories
                   @new_versions = {}
                   @plugins_to_migrate.each do |plugin|
                     @new_versions[plugin.name] = plugin.latest_migration
                   end
                   # Remove any plugins that don't need migration
                   @plugins_to_migrate.map { |p| p.name }.each do |name|
                     @plugins_to_migrate.delete(Engines.plugins[name]) if @current_versions[name] == @new_versions[name]
                   end
                   @options[:assigns][:plugins] = @plugins_to_migrate
                   @options[:assigns][:new_versions] = @new_versions
                   @options[:assigns][:current_versions] = @current_versions
                 end
                 # Returns a migration name. If the descriptive migration name based on the
                 # plugin names involved is shorter than 230 characters that one will be
                 # used. Otherwise a shorter name will be returned.
                 def build_migration_name
-                  returning descriptive_migration_name do |name|
+                  descriptive_migration_name.tap do |name|
                     name.replace short_migration_name if name.length > MAX_FILENAME_LENGTH
                   end
                 end
                 # Construct a unique migration name based on the plugins involved and the
                 # versions they should reach after this migration is run. The name constructed
                 # needs to be lowercase
                 def descriptive_migration_name
                   @plugins_to_migrate.map do |plugin|
                     "#{plugin.name}_to_version_#{@new_versions[plugin.name]}"
                   end.join("_and_").downcase
                 end
                 # Short migration name that will be used if the descriptive_migration_name
                 # exceeds 230 characters
                 def short_migration_name
                   'plugin_migrations'
                 end
             end

vendor/plugins/gravatar/lib/gravatar.rb +1 -1

             require 'digest/md5'
             require 'cgi'
             module GravatarHelper
               # These are the options that control the default behavior of the public
               # methods. They can be overridden during the actual call to the helper,
               # or you can set them in your environment.rb as such:
               #
               #   # Allow racier gravatars
               #   GravatarHelper::DEFAULT_OPTIONS[:rating] = 'R'
               #
               DEFAULT_OPTIONS = {
                 # The URL of a default image to display if the given email address does
                 # not have a gravatar.
                 :default => nil,
                 # The default size in pixels for the gravatar image (they're square).
                 :size => 50,
                 # The maximum allowed MPAA rating for gravatars. This allows you to
                 # exclude gravatars that may be out of character for your site.
                 :rating => 'PG',
                 # The alt text to use in the img tag for the gravatar.  Since it's a
                 # decorational picture, the alt text should be empty according to the
                 # XHTML specs.
                 :alt => '',
                 # The title text to use for the img tag for the gravatar.
                 :title => '',
                 # The class to assign to the img tag for the gravatar.
                 :class => 'gravatar',
                 # Whether or not to display the gravatars using HTTPS instead of HTTP
                 :ssl => false,
               }
               # The methods that will be made available to your views.
               module PublicMethods
                 # Return the HTML img tag for the given user's gravatar. Presumes that
                 # the given user object will respond_to "email", and return the user's
                 # email address.
                 def gravatar_for(user, options={})
                   gravatar(user.email, options)
                 end
                 # Return the HTML img tag for the given email address's gravatar.
                 def gravatar(email, options={})
                   src = h(gravatar_url(email, options))
                   options = DEFAULT_OPTIONS.merge(options)
                   [:class, :alt, :size, :title].each { |opt| options[opt] = h(options[opt]) }
                   "<img class=\"#{options[:class]}\" alt=\"#{options[:alt]}\" title=\"#{options[:title]}\" width=\"#{options[:size]}\" height=\"#{options[:size]}\" src=\"#{src}\" />"
                 end
                 # Returns the base Gravatar URL for the given email hash. If ssl evaluates to true,
                 # a secure URL will be used instead. This is required when the gravatar is to be
                 # displayed on a HTTPS site.
                 def gravatar_api_url(hash, ssl=false)
                   if ssl
                     "https://secure.gravatar.com/avatar/#{hash}"
                   else
                     "http://www.gravatar.com/avatar/#{hash}"
                   end
                 end
                 # Return the gravatar URL for the given email address.
                 def gravatar_url(email, options={})
                   email_hash = Digest::MD5.hexdigest(email)
                   options = DEFAULT_OPTIONS.merge(options)
                   options[:default] = CGI::escape(options[:default]) unless options[:default].nil?
-                  returning gravatar_api_url(email_hash, options.delete(:ssl)) do |url|
+                  gravatar_api_url(email_hash, options.delete(:ssl)).tap do |url|
                     opts = []
                     [:rating, :size, :default].each do |opt|
                       unless options[opt].nil?
                         value = h(options[opt])
                         opts << [opt, value].join('=')
                       end
                     end
                     url << "?#{opts.join('&')}" unless opts.empty?
                   end
                 end
               end
             end

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