MIT-LICENSE lib/active_record/acts/category_content.rb @@ -187,7 +187,7 @@ In your layout, make sure that you have all the JavaScripts included, that will Then, in your view, you can call this little helper to generate a drag and drop list where you can re-sort the positions. Remember to provide the name of the model to use: - <%= sortable_categories Category %> + <%= aac_sortable_tree Category %> Finally, in your controller create an action method like this: @@ -198,7 +198,7 @@ Finally, in your controller create an action method like this: And you can already try it. You can change the URL to that action method like this: - <%= sortable_categories(Category, {:action => :update_positions}) %> - <%= sortable_categories(Category, {:controller => :mycontroller, :action => :update_positions}) %> + <%= aac_sortable_tree(Category, {:action => :update_positions}) %> + <%= aac_sortable_tree(Category, {:controller => :mycontroller, :action => :update_positions}) %> === Have fun. \ No newline at end of file README @@ -5,19 +5,18 @@ require 'rake/rdoctask' desc 'Default: run unit tests.' task :default => :test -desc 'Test acts_as_category plugin.' +desc 'Test the acts_as_category plugin.' Rake::TestTask.new(:test) do |t| t.libs << 'lib' t.pattern = 'test/**/*_test.rb' t.verbose = true end -desc 'Generate documentation for acts_as_category plugin.' +desc 'Generate documentation for the acts_as_category plugin.' Rake::RDocTask.new(:rdoc) do |rdoc| rdoc.rdoc_dir = 'rdoc' - rdoc.title = 'acts_as_category' + rdoc.title = 'ActsAsCategory' rdoc.options << '--line-numbers' << '--inline-source' rdoc.rdoc_files.include('README') - rdoc.rdoc_files.include('lib/active_record/acts/category.rb') - #rdoc.rdoc_files.include('lib/**/**/.rb') + rdoc.rdoc_files.include('lib/**/*.rb') end Rakefile @@ -1,2 +1,3 @@ ActiveRecord::Base.send :include, ActiveRecord::Acts::Category +ActiveRecord::Base.send :include, ActiveRecord::Acts::CategoryContent ActionView::Base.send :include, ActsAsCategoryHelper init.rb @@ -10,36 +10,38 @@ module ActiveRecord def self.included(base) # Add class methods module of Acts::Category to the superior class ActiveRecord # In that module, the InstanceMethods will be added as well - base.extend(ClassMethods) + base.extend ClassMethods end ####################### # ClassMethods module # ####################### - module ClassMethods + module ClassMethods # Please refer to README for more information about this plugin. # - # create_table :category do |t| - # t.column :parent_id, :integer - # t.column :position, :integer - # t.column :hidden, :boolean - # t.column :children_count, :integer - # t.column :ancestors_count, :integer - # t.column :descendants_count, :integer - # end + # create_table "categories", :force => true do |t| + # t.integer "parent_id" + # t.integer "position" + # t.boolean "hidden" + # t.integer "children_count" + # t.integer "ancestors_count" + # t.integer "descendants_count" + # end # # Configuration options are: # # * <tt>foreign_key</tt> - specifies the column name to use for tracking of the tree (default: +parent_id+) # * <tt>position</tt> - specifies the integer column name to use for ordering siblings (default: +position+) + # * <tt>hidden</tt> - specifies a column name to use for hidden flag (default: +hidden+) # * <tt>children_count</tt> - specifies a column name to use for caching number of children (default: +children_count+) # * <tt>ancestors_count</tt> - specifies a column name to use for caching number of ancestors (default: +ancestors_count+) # * <tt>descendants_count</tt> - specifies a column name to use for caching number of descendants (default: +descendants_count+) + # * <tt>memoize</tt> - Should memoization be used in order to speed up performance? (default: +true+) def acts_as_category(options = {}) - + # Load parameters whenever acts_as_category is called - configuration = { :foreign_key => "parent_id", :position => "position", :hidden => "hidden", :children_count => 'children_count', :ancestors_count => 'ancestors_count', :descendants_count => 'descendants_count' } + configuration = { :foreign_key => "parent_id", :position => "position", :hidden => "hidden", :children_count => 'children_count', :ancestors_count => 'ancestors_count', :descendants_count => 'descendants_count', :memoize => true } configuration.update(options) if options.is_a?(Hash) # Create a class association to itself @@ -83,6 +85,7 @@ module ActiveRecord permissions = [] ids.each { |id| permissions << id.to_i if id.to_i > 0 } if ids.is_a?(Array) class_variable_set :@@permissions, permissions.uniq + # TODO?: unmemoize_all if memoize? end # This class_eval contains methods which cannot be added wihtout having a concrete model. @@ -92,17 +95,20 @@ module ActiveRecord # and not already when our plugin's init.rb adds our Acts::Category modules to ActiveRecord. # Another example is, that we want to overwrite the association method "children", but this # association doesn't exist before acts_as_category is actually called. So we need class_eval. - + class_eval <<-EOV ############################## # Generated instance methods # ############################## + # Make class methods memoizable + class << self; extend ActiveSupport::Memoizable if #{configuration[:memoize]}; end + # Include instance methods from our InstanceMethods module include ActiveRecord::Acts::Category::InstanceMethods - # Define instance getter and setter methods to keep track of the column name options + # Define instance getter and setter methods to keep track of the option parameters def parent_id_column() '#{configuration[:foreign_key]}' end def parent_id_column=(id) write_attribute('#{configuration[:foreign_key]}', id) end def position_column() '#{configuration[:position]}' end @@ -111,6 +117,8 @@ module ActiveRecord def children_count_column() '#{configuration[:children_count]}' end def ancestors_count_column() '#{configuration[:ancestors_count]}' end def descendants_count_column() '#{configuration[:descendants_count]}' end + def self.memoize?() #{configuration[:memoize]} end + def memoize?() #{configuration[:memoize]} end # Overwrite the children association method, so that it will respect permitted/hidden categories # Note: If you ask about the children of a not-permitted category, the result will be an empty array in any case @@ -124,13 +132,14 @@ module ActiveRecord ########################### # Generated class methods # ########################### - + # Update cache columns of a whole branch, which includes the given +category+ or its +id+. def self.refresh_cache_of_branch_with(category) category = find(category) unless category.instance_of?(self) # possibly convert id into category root = category.#{configuration[:foreign_key]}.nil? ? category : category.root # find root of category (if not already) root.refresh_cache root.descendants.each { |d| d.refresh_cache } + # TODO?: unmemoize_all if #{configuration[:memoize]} end # Creates a WHERE clause for SQL statements, which causes forbidden categories not to be included. Adds AND statement if parameter +true+ is given. @@ -145,20 +154,21 @@ module ActiveRecord # Returns the +category+ to a given +id+. This is as a replacement for find(id), but it respects permitted/hidden categories. def self.get(id) - find(:first, :conditions => 'id = ' + id.to_i.to_s + where_permitted(true), :order => #{configuration[:position].nil? ? 'nil' : %Q{"#{configuration[:position]}"}}) + find(:first, :conditions => 'id = ' + id.to_i.to_s + where_permitted(true)) end # Returns all root +categories+, respecting permitted/hidden ones + # (Note: I tried to memoize this function, but it would not work correctly, so I let it be) def self.roots(ignore_permissions = false) where_clause = ignore_permissions ? '' : where_permitted(true) find(:all, :conditions => '#{configuration[:foreign_key]} IS NULL' + where_clause, :order => #{configuration[:position].nil? ? 'nil' : %Q{"#{configuration[:position]}"}}) end - + # Receives the controller's +params+ variable and updates category positions accordingly. # Please refer to the helper methods that came with this model for further information. def self.update_positions(params) params.each_key { |key| - if key.include?('sortable_categories_') + if key.include?('aac_sortable_tree_') parent_id = key.split('_').last.to_i params[key].each_with_index { |id, position| category = find(id) @@ -187,6 +197,9 @@ module ActiveRecord module InstanceMethods + def self.memoize?() end # Dummy which is overwritten by class_eval + extend ActiveSupport::Memoizable if memoize? + #################### # Instance methods # #################### @@ -201,6 +214,7 @@ module ActiveRecord end true end + memoize :permitted? if memoize? # Returns +array+ of children's ids, respecting permitted/hidden categories def children_ids @@ -208,14 +222,16 @@ module ActiveRecord self.children.each { |child| children_ids << child.id if child.permitted? } unless self.children.empty? children_ids end - + memoize :children_ids if memoize? + # Returns list of ancestors, disregarding any permissions def ancestors node, nodes = self, [] nodes << node = node.parent while node.parent nodes end - + memoize :ancestors if memoize? + # Returns array of IDs of ancestors, disregarding any permissions def ancestors_ids node, nodes = self, [] @@ -225,6 +241,7 @@ module ActiveRecord end nodes end + memoize :ancestors_ids if memoize? # Returns list of descendants, respecting permitted/hidden categories def descendants @@ -235,7 +252,8 @@ module ActiveRecord } unless self.children.empty? descendants end - + memoize :descendants if memoize? + # Returns array of IDs of descendants, respecting permitted/hidden categories def descendants_ids(ignore_permissions = false) descendants_ids = [] @@ -245,13 +263,15 @@ module ActiveRecord } unless self.children.empty? descendants_ids end - + memoize :descendants_ids if memoize? + # Returns the root node of the branch, disregarding any permissions def root node = self node = node.parent while node.parent node end + memoize :root if memoize? # Returns +true+ if category is root, otherwise +false+, disregarding any permissions def root? @@ -269,7 +289,7 @@ module ActiveRecord def self_and_siblings parent ? parent.children : self.class.roots end - + # Immediately refresh cache of category instance def refresh_cache self.class.connection.execute "UPDATE #{self.class.table_name} SET #{ancestors_count_column}=#{self.ancestors.size}, #{descendants_count_column}=#{self.descendants.size} WHERE id=#{self.id}" lib/active_record/acts/category.rb @@ -1,24 +1,66 @@ module ActsAsCategoryHelper - def sortable_categories(model, ajaxurl = {:controller => :funkengallery, :action => :update_positions}, column = 'name') + extend ActiveSupport::Memoizable + + def aac_tree(roots) + result = '<ul class="tree_root">' + roots.each { |root| result += aac_tree_category(root) } + result += '</ul>' + end + memoize :aac_tree + + def aac_sortable_tree(model, ajaxurl = {:controller => :funkengallery, :action => :update_positions}, column = 'name') raise "Model '#{model.to_s}' does not acts_as_category" unless model.respond_to?(:acts_as_category) - result = '<div id="sortable_category_response" "></div>' - model.roots.each { |root| result += sortable_category_list(root, ajaxurl, column) } + result = '<div id="aac_sortable_tree_response" "></div>' + model.roots.each { |root| result += aac_sortable_tree_list(root, ajaxurl, column) } result end + + private + + def aac_tree_category(category) + anchor = "aac_tree_#{category.id.to_s}" + if category.ancestors_count == 0 + # CSS for root categories + html_headline = ' class="tree_headline" ' + html_count = '' + else + # CSS for any deeper level of categories + html_headline = '' + html_count = ' <span class="tree_count"> ' + h(category.pictures_count.to_s)+ '</span>' + end + + result = tag('a', {:name => anchor}) + result += "<li#{html_headline}>" + result += '<b>' if @category == category.id + if category.pictures_count == 0 or category.ancestors_count == 0 or category.children_count > 0 then + result += content_tag('a', h(category.name), :onclick => "new Element.toggle('#{anchor}')", :href => "\##{anchor}") + else + result += link_to_unless_current h(category.name), {:controller => 'category', :id => category.id } unless category.ancestors_count == 0 + end + result += '</b>' if @category == category.id + result += html_count if category.pictures_count > 0 + result += '</li>' - private + if category.children_count > 0 + addon = (category.ancestors_count == 0 or category.descendants_ids.include?(@category) or (category.self_and_siblings_ids.include?(@category) and category.children_count == 0)) ? '' : ' style="display: none;"' + result += "<ul id='#{anchor}' #{addon}>" + category.children.each { |child| result += aac_tree_category(child) } + result += '</ul>' + end + result + end - def sortable_category_list(category, ajaxurl, column = 'name') + def aac_sortable_tree_list(category, ajaxurl, column = 'name') parent_id = category.parent ? category.parent.id.to_s : '0' firstitem = category.read_attribute(category.position_column) == 1 lastitem = category.position == category.self_and_siblings.size result = '' - result += "<ul id=\"sortable_categories_#{parent_id}\">\n" if firstitem + result += "<ul id=\"aac_sortable_tree_#{parent_id}\">\n" if firstitem result += "<li id=\"category_#{category.id}\">#{category.read_attribute(column)}" result += category.children.empty? ? "</li>\n" : "\n" - category.children.each {|child| result += sortable_category_list(child, ajaxurl, column = 'name') } unless category.children.empty? - result += "</ul></li>\n" + sortable_element("sortable_categories_#{parent_id}", :update => 'sortable_category_response', :url => ajaxurl) if lastitem + category.children.each {|child| result += aac_sortable_tree_list(child, ajaxurl, column = 'name') } unless category.children.empty? + result += "</ul></li>\n" + sortable_element("aac_sortable_tree_#{parent_id}", :update => 'aac_sortable_tree_response', :url => ajaxurl) if lastitem result end lib/acts_as_category_helper.rb @@ -9,8 +9,10 @@ # For further information see http://blog.funkensturm.de/ruby-on-rails-plugins require 'test/unit' + require 'rubygems' require 'active_record' +require 'action_view' ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:") $stdout = StringIO.new # Prevent ActiveRecord's annoying schema statements @@ -18,13 +20,13 @@ $stdout = StringIO.new # Prevent ActiveRecord's annoying schema statements def setup_db ActiveRecord::Base.logger ActiveRecord::Schema.define(:version => 1) do - create_table :categories do |t| - t.column :parent_id, :integer - t.column :position, :integer - t.column :hidden, :boolean - t.column :children_count, :integer - t.column :ancestors_count, :integer - t.column :descendants_count, :integer + create_table "categories", :force => true do |t| + t.integer "my_parent_id" + t.integer "my_position" + t.boolean "my_hidden" + t.integer "my_children_count" + t.integer "my_ancestors_count" + t.integer "my_descendants_count" end end end @@ -39,13 +41,18 @@ setup_db # Because the plugin needs an existing table before initialization (e.g $:.unshift File.dirname(__FILE__) + '/../lib' # make "lib" known to "require" require 'active_record/acts/category' +require 'active_record/acts/category_content' +require 'acts_as_category_helper' require File.dirname(__FILE__) + '/../init' # Initialize Plugin -#class Mixin < ActiveRecord::Base -#end - class Category < ActiveRecord::Base - acts_as_category + acts_as_category :foreign_key => 'my_parent_id', + :position => 'my_position', + :hidden => 'my_hidden', + :children_count => 'my_children_count', + :ancestors_count => 'my_ancestors_count', + :descendants_count => 'my_descendants_count', + :memoize => true end teardown_db # Because CategoryTest's setup method won't execute setup_db otherwise @@ -64,12 +71,12 @@ class CategoryTest < Test::Unit::TestCase assert @r1 = Category.create! # id 1 assert @r2 = Category.create! # id 2 assert @r3 = Category.create! # id 3 - assert @r11 = Category.create!(:parent_id => @r1.id) # id 4 - assert @r21 = Category.create!(:parent_id => @r2.id) # id 5 - assert @r22 = Category.create!(:parent_id => @r2.id) # id 6 - assert @r111 = Category.create!(:parent_id => @r11.id) # id 7 - assert @r211 = Category.create!(:parent_id => @r21.id) # id 8 - assert @r221 = Category.create!(:parent_id => @r22.id) # id 9 + assert @r11 = Category.create!(:my_parent_id => @r1.id) # id 4 + assert @r21 = Category.create!(:my_parent_id => @r2.id) # id 5 + assert @r22 = Category.create!(:my_parent_id => @r2.id) # id 6 + assert @r111 = Category.create!(:my_parent_id => @r11.id) # id 7 + assert @r211 = Category.create!(:my_parent_id => @r21.id) # id 8 + assert @r221 = Category.create!(:my_parent_id => @r22.id) # id 9 assert @r1 = Category.find(1) assert @r2 = Category.find(2) assert @r3 = Category.find(3) @@ -89,11 +96,16 @@ class CategoryTest < Test::Unit::TestCase def check_cache # This is merely a method used by certain tests Category.find(:all).each { |c| # Note that "children_count" is a built-in Rails functionality and must not be tested here - assert_equal c.ancestors.size, c.ancestors_count - assert_equal c.descendants.size, c.descendants_count + assert_equal c.ancestors.size, c.my_ancestors_count + assert_equal c.descendants.size, c.my_descendants_count } end + def test_memoizabla_plugin_options_parameters + assert Category.memoize? + assert @r1.memoize? + end + def test_cache_columns check_cache end @@ -116,47 +128,47 @@ class CategoryTest < Test::Unit::TestCase Category.permissions.clear assert_equal [], Category.permissions end - + def test_where_permitted_sql_query - assert_equal ' (hidden IS NULL) ', Category.where_permitted - assert_equal ' AND (hidden IS NULL) ', Category.where_permitted(true) + assert_equal ' (my_hidden IS NULL) ', Category.where_permitted + assert_equal ' AND (my_hidden IS NULL) ', Category.where_permitted(true) Category.permissions = [1,2,3] - assert_equal ' (hidden IS NULL OR id IN (1,2,3)) ', Category.where_permitted - assert_equal ' AND (hidden IS NULL OR id IN (1,2,3)) ', Category.where_permitted(true) + assert_equal ' (my_hidden IS NULL OR id IN (1,2,3)) ', Category.where_permitted + assert_equal ' AND (my_hidden IS NULL OR id IN (1,2,3)) ', Category.where_permitted(true) end def test_attr_readonly - assert @r1.children_count = 99 - assert @r1.ancestors_count = 99 - assert @r1.descendants_count = 99 + assert @r1.my_children_count = 99 + assert @r1.my_ancestors_count = 99 + assert @r1.my_descendants_count = 99 assert @r1.save assert @r1 = Category.find(1) - assert_nil @r1.children_count - assert_equal 0, @r1.ancestors_count - assert_equal 2, @r1.descendants_count - assert @r1.update_attribute('children_count', 99) - assert @r1.update_attribute('ancestors_count', 99) - assert @r1.update_attribute('descendants_count', 99) + assert_equal 1, @r1.my_children_count + assert_equal 0, @r1.my_ancestors_count + assert_equal 2, @r1.my_descendants_count + assert @r1.update_attribute('my_children_count', 99) + assert @r1.update_attribute('my_ancestors_count', 99) + assert @r1.update_attribute('my_descendants_count', 99) assert @r1 = Category.find(1) - assert_nil @r1.children_count - assert_equal 0, @r1.ancestors_count - assert_equal 2, @r1.descendants_count + assert_equal 1, @r1.my_children_count + assert_equal 0, @r1.my_ancestors_count + assert_equal 2, @r1.my_descendants_count end def test_permitted? assert @r3.permitted? - assert @r3.update_attribute('hidden', true) + assert @r3.update_attribute('my_hidden', true) assert !@r3.permitted? Category.permissions = [@r3.id] assert @r3.permitted? Category.permissions.clear assert !@r3.permitted? - assert @r3.update_attribute('hidden', false) + assert @r3.update_attribute('my_hidden', false) assert @r3.permitted? assert @r2.permitted? assert @r21.permitted? assert @r211.permitted? - assert @r211.update_attribute('hidden', true) + assert @r211.update_attribute('my_hidden', true) assert @r2.permitted? assert @r21.permitted? assert !@r211.permitted? @@ -169,22 +181,22 @@ class CategoryTest < Test::Unit::TestCase assert @r2.permitted? assert @r21.permitted? assert !@r211.permitted? - assert @r211.update_attribute('hidden', false) + assert @r211.update_attribute('my_hidden', false) assert @r2.permitted? assert @r21.permitted? assert @r211.permitted? - assert @r21.update_attribute('hidden', true) + assert @r21.update_attribute('my_hidden', true) assert @r2.permitted? assert !@r21.permitted? - assert !@r211.hidden + assert !@r211.my_hidden assert !@r211.permitted? Category.permissions = [@r21.id] assert @r2.permitted? assert @r21.permitted? assert @r211.permitted? Category.permissions.clear - assert @r2.update_attribute('hidden', true) - assert @r21.update_attribute('hidden', false) + assert @r2.update_attribute('my_hidden', true) + assert @r21.update_attribute('my_hidden', false) assert !@r2.permitted? assert !@r21.permitted? assert !@r211.permitted? @@ -211,7 +223,7 @@ class CategoryTest < Test::Unit::TestCase end def test_children_permissions - assert @r22.update_attribute('hidden', true) + assert @r22.update_attribute('my_hidden', true) assert_equal [@r21, @r22], @r2.orig_children assert_equal [@r11], @r1.children assert_equal [@r21], @r2.children @@ -237,7 +249,7 @@ class CategoryTest < Test::Unit::TestCase end def test_children_ids_permissions - assert @r22.update_attribute('hidden', true) + assert @r22.update_attribute('my_hidden', true) assert_equal [4], @r1.children_ids assert_equal [5], @r2.children_ids assert_equal [], @r3.children_ids @@ -259,8 +271,8 @@ class CategoryTest < Test::Unit::TestCase assert_equal 1, @r22.children.size assert_equal 0, @r211.children.size assert_equal 0, @r221.children.size - assert @r111.update_attribute('hidden', true) - assert @r22.update_attribute('hidden', true) + assert @r111.update_attribute('my_hidden', true) + assert @r22.update_attribute('my_hidden', true) assert_equal 1, @r1.children.size assert_equal 1, @r2.children.size assert_equal 0, @r3.children.size @@ -321,7 +333,7 @@ class CategoryTest < Test::Unit::TestCase end def test_descendants_permissions - assert @r22.update_attribute('hidden', true) + assert @r22.update_attribute('my_hidden', true) assert_equal [@r11, @r111], @r1.descendants assert_equal [@r21, @r211], @r2.descendants assert_equal [], @r3.descendants @@ -349,7 +361,7 @@ class CategoryTest < Test::Unit::TestCase end def test_descendants_ids_permissions - assert @r22.update_attribute('hidden', true) + assert @r22.update_attribute('my_hidden', true) assert_equal [4, 7], @r1.descendants_ids assert_equal [5, 8], @r2.descendants_ids assert_equal [], @r3.descendants_ids @@ -373,7 +385,7 @@ class CategoryTest < Test::Unit::TestCase end def test_root_permissions # i. e. ignoring permissions - assert @r22.update_attribute('hidden', true) + assert @r22.update_attribute('my_hidden', true) assert_equal @r2, @r2.root assert_equal @r2, @r22.root assert_equal @r2, @r221.root @@ -386,7 +398,7 @@ class CategoryTest < Test::Unit::TestCase end def test_root_permissions # i. e. ignoring permissions - assert @r3.update_attribute('hidden', true) + assert @r3.update_attribute('my_hidden', true) assert @r1.root? assert @r3.root? assert !@r11.root? @@ -398,12 +410,12 @@ class CategoryTest < Test::Unit::TestCase end def test_roots_permissions - assert @r2.update_attribute('hidden', true) + assert @r2.update_attribute('my_hidden', true) assert_equal [@r1, @r3], Category.roots end def test_roots_permissions_override - assert @r2.update_attribute('hidden', true) + assert @r2.update_attribute('my_hidden', true) assert_equal [@r1, @r2, @r3], Category.roots(true) end @@ -420,7 +432,7 @@ class CategoryTest < Test::Unit::TestCase end def test_siblings_permissions - assert @r2.update_attribute('hidden', true) + assert @r2.update_attribute('my_hidden', true) assert_equal [@r3], @r1.siblings assert_equal [@r1, @r3], @r2.siblings assert_equal [@r1], @r3.siblings @@ -430,13 +442,13 @@ class CategoryTest < Test::Unit::TestCase assert_equal [], @r111.siblings assert_equal [], @r211.siblings assert_equal [], @r221.siblings - assert @r22.update_attribute('hidden', true) + assert @r22.update_attribute('my_hidden', true) assert_equal [], @r21.siblings assert_equal [], @r22.siblings assert_equal [], @r111.siblings assert_equal [], @r211.siblings assert_equal [], @r221.siblings - assert @r2.update_attribute('hidden', false) + assert @r2.update_attribute('my_hidden', false) assert_equal [], @r22.siblings end @@ -453,7 +465,7 @@ class CategoryTest < Test::Unit::TestCase end def test_self_and_siblings_permissions - assert @r22.update_attribute('hidden', true) + assert @r22.update_attribute('my_hidden', true) assert_equal [@r1, @r2, @r3], @r1.self_and_siblings assert_equal [@r1, @r2, @r3], @r2.self_and_siblings assert_equal [@r1, @r2, @r3], @r3.self_and_siblings @@ -495,19 +507,19 @@ class CategoryTest < Test::Unit::TestCase Category.new().save assert @r3 = Category.find(3) check_cache - assert @r11 = Category.create!(:parent_id => @r1.id) + assert @r11 = Category.create!(:my_parent_id => @r1.id) check_cache - Category.new(:parent_id => @r2.id).save + Category.new(:my_parent_id => @r2.id).save assert @r21 = Category.find(5) check_cache - assert @r22 = Category.create!(:parent_id => @r2.id) + assert @r22 = Category.create!(:my_parent_id => @r2.id) check_cache - Category.new(:parent_id => @r11.id).save + Category.new(:my_parent_id => @r11.id).save assert @r111 = Category.find(7) check_cache - assert @r211 = Category.create!(:parent_id => @r21.id) + assert @r211 = Category.create!(:my_parent_id => @r21.id) check_cache - assert @r221 = Category.create!(:parent_id => @r22.id) + assert @r221 = Category.create!(:my_parent_id => @r22.id) check_cache @r12 = @r1.children.create check_cache @@ -521,69 +533,69 @@ class CategoryTest < Test::Unit::TestCase end def test_update_where_root_becomes_child - @r1.update_attributes(:parent_id => @r21.id) + @r1.update_attributes(:my_parent_id => @r21.id) check_cache end def test_update_where_child_becomes_root - @r111.update_attributes(:parent_id =>nil) + @r111.update_attributes(:my_parent_id =>nil) check_cache end def test_update_where_child_switches_within_branch - @r22.update_attributes(:parent_id => @r211.id) + @r22.update_attributes(:my_parent_id => @r211.id) check_cache end def test_update_where_child_switches_branch - @r221.update_attributes(:parent_id => @r11.id) + @r221.update_attributes(:my_parent_id => @r11.id) check_cache end def test_invalid_parent_id_type - assert !Category.new(:parent_id => 0.0).save - assert !Category.new(:parent_id => 1.5).save - assert !Category.new(:parent_id => 0).save - assert !Category.new(:parent_id => 'string').save + assert !Category.new(:my_parent_id => 0.0).save + assert !Category.new(:my_parent_id => 1.5).save + assert !Category.new(:my_parent_id => 0).save + assert !Category.new(:my_parent_id => 'string').save end def test_non_existant_foreign_key - assert !Category.new(:parent_id => 9876543210).save - assert_raise(ActiveRecord::RecordInvalid) { Category.create!(:parent_id => 9876543210) } + assert !Category.new(:my_parent_id => 9876543210).save + assert_raise(ActiveRecord::RecordInvalid) { Category.create!(:my_parent_id => 9876543210) } end def test_category_becomes_its_own_parent - assert !@r1.update_attributes(:parent_id => @r1.id) - assert @r2.parent_id = @r2.id + assert !@r1.update_attributes(:my_parent_id => @r1.id) + assert @r2.my_parent_id = @r2.id assert !@r2.save end def test_category_becomes_parent_of_descendant - assert !@r1.update_attributes(:parent_id => @r11.id) - assert !@r1.update_attributes(:parent_id => @r111.id) - assert !@r11.update_attributes(:parent_id => @r111.id) - assert @r2.parent_id = @r21.id + assert !@r1.update_attributes(:my_parent_id => @r11.id) + assert !@r1.update_attributes(:my_parent_id => @r111.id) + assert !@r11.update_attributes(:my_parent_id => @r111.id) + assert @r2.my_parent_id = @r21.id assert !@r2.save end def test_update_positions - Category.update_positions({'sortable_categories_0' => [3,1,2]}) - assert_equal 1, Category.find(3).position - assert_equal 2, Category.find(1).position - assert_equal 3, Category.find(2).position - Category.update_positions({'sortable_categories_2' => [6,5]}) - assert_equal 1, Category.find(6).position - assert_equal 2, Category.find(5).position - assert_raise(::ArgumentError) { Category.update_positions({'sortable_categories_2' => [1]}) } - assert_raise(::ArgumentError) { Category.update_positions({'sortable_categories_2' => [1,2,3]}) } - assert_raise(::ArgumentError) { Category.update_positions({'sortable_categories_2' => [5,6,7]}) } - assert_raise(::ArgumentError) { Category.update_positions({'sortable_categories_9876543210' => [1]}) } - assert_raise(::ArgumentError) { Category.update_positions({'sortable_categories_1' => [9876543210]}) } + Category.update_positions({'aac_sortable_tree_0' => [3,1,2]}) + assert_equal 1, Category.find(3).my_position + assert_equal 2, Category.find(1).my_position + assert_equal 3, Category.find(2).my_position + Category.update_positions({'aac_sortable_tree_2' => [6,5]}) + assert_equal 1, Category.find(6).my_position + assert_equal 2, Category.find(5).my_position + assert_raise(::ArgumentError) { Category.update_positions({'aac_sortable_tree_2' => [1]}) } + assert_raise(::ArgumentError) { Category.update_positions({'aac_sortable_tree_2' => [1,2,3]}) } + assert_raise(::ArgumentError) { Category.update_positions({'aac_sortable_tree_2' => [5,6,7]}) } + assert_raise(::ArgumentError) { Category.update_positions({'aac_sortable_tree_9876543210' => [1]}) } + assert_raise(::ArgumentError) { Category.update_positions({'aac_sortable_tree_1' => [9876543210]}) } end def get assert_equal @r1, Category.get(1) - assert @r1.update_attribute('hidden', true) + assert @r1.update_attribute('my_hidden', true) assert_nil Category.get(1) assert_nil Category.get(4) assert_nil Category.get(7) test/acts_as_category_test.rb 6f286caffb3632b2a87734114b5c36e880099ffd Marius Maximus nom@ximus.de http://github.com/funkensturm/acts_as_category/commit/dd316c61891f4c9895bba6d0e7605083ce7cfeae dd316c61891f4c9895bba6d0e7605083ce7cfeae 2008-12-27T15:12:26-08:00 2008-12-27T15:12:26-08:00 Added optional memoization (Rails 2.2), repaired unit tests 8884ae075cf26ed01234df4b2bb7ab6ebc0a218c Marius Maximus nom@ximus.de