acts_as_word_cloud 0.0.1 → 0.0.2

data/lib/acts_as_word_cloud/word_cloud.rb

@@ -5,223 +5,143 @@ module ActsAsWordCloud
     end
 
     module ClassMethods
-      # args:
-      # using, takes an array of Symbols that refer to the methods we'll use on the model calling word_cloud
-      # excluded models, takes in Class names of models we want to ignore that are associated to model calling word_cloud
-      # skipped attributes, takes in Symbols referring to attributes that won't be pulled from model calling word_cloud
-      # depth level, takes in an Integer referring to how deep of a recursive search we'll make
-      # no_mixin_fields, is a default pre-set array of methods to use on models that do not include the mixin
-      #
-      def acts_as_word_cloud(args)
+      # Sets up the word_cloud method and takes arguments that control what it returns
+      # 
+      # @param [Hash] args
+      # @param args [Array] :included_methods An array of method symbols used to create this model's word cloud
+      # @param args [Array] :excluded_methods An array of method symbols used to remove data from the word cloud.  This should be used to remove database fields from the word cloud.
+      # @param args [Array] :excluded_models An array of models whose data should not be included in the word cloud
+      # @param args [Integer] :depth_level How many levels of associations to include
+      # @param args [Symbol] :object_name_method  How to name the object when included in the word cloud as an association
+      def acts_as_word_cloud(args = {})
 
         # getter/setter methods for the module
-        mattr_accessor :word_cloud_using unless respond_to? :word_cloud_using
-        mattr_accessor :word_cloud_excluded unless respond_to? :word_cloud_excluded 
-        mattr_accessor :word_cloud_skipped unless respond_to? :word_cloud_skipped 
-        mattr_accessor :word_cloud_depth unless respond_to? :word_cloud_depth
-        mattr_accessor :word_cloud_no_mixin_fields unless respond_to? :word_cloud_no_mixin_fields
-                 
-        # set empty arrays to allow |= on values          
-        unless self.word_cloud_using.is_a?(Array)
-          self.word_cloud_using = []      
-        end
-        unless self.word_cloud_excluded.is_a?(Array)
-          self.word_cloud_excluded = []   
-        end                      
-        unless self.word_cloud_skipped.is_a?(Array)
-          self.word_cloud_skipped = []   
-        end                      
-        unless self.word_cloud_no_mixin_fields.is_a?(Array)
-          self.word_cloud_no_mixin_fields = []   
-        end                      
-              
-        # default values if none set in the mixin call on the model
-        self.word_cloud_using |= args[:methods_to_use].present? ?  args[:methods_to_use] : []
-        self.word_cloud_excluded |= args[:excluded_models].present? ? args[:excluded_models] : []
-        self.word_cloud_skipped |= args[:skipped_attributes].present? ? args[:skipped_attributes] : []
-        self.word_cloud_depth = args[:depth].present? ? args[:depth] : ActsAsWordCloud.config.min_depth
-        self.word_cloud_no_mixin_fields = [:name, :title, :label]  #ActsAsWordCloud.config.no_mixin_fields
+        mattr_accessor :word_cloud_attributes unless respond_to? :word_cloud_attributes
+        allowed_options = [:included_methods, :excluded_methods, :excluded_models, :depth, :object_name_methods]
+
+        # set defaults
+        args[:included_methods] ||= []
+        args[:excluded_methods] ||= []
+        args[:excluded_models] ||= []
+        args[:depth] ||= ::ActsAsWordCloud.config.default_search_depth
+        # note that the user passes in object_name_method and it is turned into the array object_name_methods
+        args[:object_name_methods] = args[:object_name_method] ? [args[:object_name_method]] : ::ActsAsWordCloud.config.object_name_methods
+
+        self.word_cloud_attributes = args.keep_if { |key| allowed_options.include?(key) }
 
         include ActsAsWordCloud::WordCloud::InstanceMethods
       end
     end
 
     module InstanceMethods
-    
-      # collects associations on a model as long as they're not nil
-      #
-      # @param [Symbol] the association type to look in
-      # @returns [Array <Symbol>] association names under the passed in type
-      #
-      def word_cloud_get_associated(type)
-        self.class.reflect_on_all_associations(type).select {|r| self.send(r.name).present? }.collect { |r| r.name }
-      end
-      
-      # goes through array of objects or arrays (in the case of has_many association)
-      #
-      # @param [Symbol] the association type to fetch objects from
-      # @returns [Array <Object>] that under association passed in
-      #
-      def word_cloud_associated_objects(type)
-        objects = []
-        associated = word_cloud_get_associated(type)
-        associated.each do |o|
-          if o.class == Array
-            nested_array = self.send(o)
-            nested_array.each do |a|
-              objects << a
-            end
-          else
-            objects << self.send(o)
-          end
-        end
-        return objects
-      end  
-    
-      # removes objects that are in the list of objects to exclude
-      #
-      # @returns [Array <Object>] that are not in the excluded list
-      #
-      def word_cloud_exclude_words(objects)
-        if objects.nil?
-          return []
-        else
-          result = objects.flatten.reject { |x| self.word_cloud_excluded.include?(x.class) }
-          return result.present? ? result : []
-        end
-      end
-    
-      # removes objects that include word_cloud mixin
-      #
-      # @returns [Array <Object>] that don't include the mixin
-      #
-      def word_cloud_no_mixin(objects)
-        if objects.nil?
-          return []
+      # Uses recursive word cloud to find text attributes, associations and included methods on the model
+      #
+      # @param [Symbol] return_type Whether to return an array or string, defaulting to :string
+      # @return [Array<String> or String] All processed values
+      def word_cloud(return_type = :string)
+        output = recursive_word_cloud(self.word_cloud_attributes[:depth]).uniq.flatten
+        if return_type == :string
+          return output.join(' ')
         else
-          result = objects.flatten.reject { |n| n.respond_to?(:word_cloud) }
-          result.present? ? result : []
+          return output
         end
       end
-      
-      # goes through each object passed in trying the included methods for each of those objects
-      # keeps the first one to work and returns the value of that method called on the object
-      #
-      # @param [Array <Objects>] to look through for values
-      # @returns [Array <String>] values returned by method
+
+      protected 
+
+      # Finds all text attributes, associated objects, and included methods down to a specified depth
       #
-      def word_cloud_process_words(objects)
+      # @param [Integer] depth How many layers of associations to search
+      # @return [Array] The word cloud for the specified object and depth
+      def recursive_word_cloud(depth) 
+        # prepare an array of strings to be used as an output
         output = []
+
+        # list of database attributes and selected methods minus a list of excluded methods
+        output |= word_cloud_get_valid_strings
+      
+        # array of objects for every association minus a list of excluded objects
+        objects = word_cloud_associated_objects
         objects.each do |obj|
-          obj_calls = obj.word_cloud_using.select { |f| obj.respond_to?(f) }
-          if obj_calls.first.present?
-            output << obj.send(obj_calls.first)
-          end
-        end
-        return output
-      end
-        
-      # goes through each of the default fields to call on models that don't include mixin
-      # and attempts to return the value of the first one to work, if none do return model class name
-      #
-      # @returns [String] value for object passed in 
-      #
-      def word_cloud_apply_fields_to(no_mixin_model)
-        # fields that should be tried on models that don't have the mixin, set with other attributes
-        fields = self.word_cloud_no_mixin_fields
-        fields.each do |f|
-          if no_mixin_model.respond_to?(f)
-            return no_mixin_model.send(f)
+          if obj.respond_to?(:recursive_word_cloud) && depth > 1
+            # if the object has a word cloud mixin and we can recurse
+            output |= obj.recursive_word_cloud(depth - 1)
+          else
+            # otherwise get the default name for the object
+            output |= [self.word_cloud_object_name(obj)]
           end
         end
-        return no_mixin_model.class.name
-      end
-        
-      # goes through models that don't include mixin trying to find a relevant value for each
-      #
-      # @returns [Array <String>] of values for objects passed in
-      #
-      def word_cloud_find_field(no_mixin)
-        output = []
-        flag = 0
-        no_mixin.each do |n|
-          output << word_cloud_apply_fields_to(n) 
-        end
         return output
-      end
-        
-      
-      # returns values from methods specified in using option
-      # ignores string attributes that are listed in the skipped option
+      end  
+
+      # returns values from methods specified in included_methods option
+      # ignores string attributes that are listed in the excluded_methods option
       #
-      # @returns [Array <String>]
+      # Note that his uses content_columns to read the database data.
+      # At some point, we may want to increase the types that are allowed or use a blacklist instead of a whitelist
       #
+      # @return [Array <String>] The database fields and included methods with excluded methods removed
       def word_cloud_get_valid_strings
-        output = []
-        ignore = []
-         
-        self.word_cloud_using.each do |m|
-          output << self.send(m)
-        end
-        
-        self.word_cloud_skipped.each do |s|
-          ignore << self.send(s)
-        end
+        # database fields
+        string_attributes = self.class.content_columns.collect { |c| c.name.to_sym if c.type == :string || c.type == :text }.compact
+        #  included methods
+        methods = self.word_cloud_attributes[:included_methods] | string_attributes
+        # excluded methods
+        methods -= self.word_cloud_attributes[:excluded_methods]
 
-        # current model's string attributes
-        output += self.attributes.select {|k,v| v.class == String}.values
-        output -= ignore
-
-        return output
+        return methods.map { |m| self.send(m) }
       end
 
-      # finds string attributes on model
-      # processes associations on model, either fetching word_cloud results if they include mixin or default information if they don't
-      # if depth is said to something higher than one the word_cloud results on each associated model then makes more recursive calls (BFS)
-      #
-      # @params Integer, recursive depth for method; Symbol for the type of result (array or string)
-      # @returns [Array <String>] all processed values
+      # Gets a list of objects associated to the calling object
+      # Uses rails reflect_on_all_associations methods.  Only pulls from belongs_to, has_one, and has_many for now.
+      # Each association should return nil, a single object, or an array of objects
       #
-      def word_cloud( depth = self.word_cloud_depth, type = :string ) 
-
-        output = []
+      # @return [Array]  List of models associated to the calling object
+      def word_cloud_associated_objects
         objects = []
-        no_mixin = []
-        
-        # string attributes in current model
-        output = word_cloud_get_valid_strings
+        # get associations
+        [:belongs_to, :has_one, :has_many].each do |association_type|
+          word_cloud_association_names_by_type(association_type).each do |association|
+            objects << self.send(association)
+          end
+        end
+        objects.flatten!
+        # remove excluded associations
+        objects = objects.delete_if { |o| self.word_cloud_attributes[:excluded_models].include?(o.class) }
+        return objects
+      end  
+    
+      # @return [Array <Symbol>] Collect the names of associations of a specific typeI
+      def word_cloud_association_names_by_type(type)
+        self.class.reflect_on_all_associations(type).collect(&:name)
+      end
       
-        # objects on all associations collected 
-        objects += self.word_cloud_associated_objects(:belongs_to)
-        objects += self.word_cloud_associated_objects(:has_one)
-        objects += self.word_cloud_associated_objects(:has_many) 
-        
-        # remove objects that have been explicitly excluded on current model
-        objects = word_cloud_exclude_words(objects)
-        # find associated models that do not include mixin 
-        no_mixin = word_cloud_no_mixin(objects)
-        objects -= no_mixin
-       
-        # process object using set methods for each model with mixin, or try preset general methods for models without
-        output += self.word_cloud_process_words(objects) + word_cloud_find_field(no_mixin)
-       
-        # recursive step, if depth > 1, calls word cloud on objects array (which already excludes objects that don't have the mixin)
-        if depth < 1
-          return "depth for word cloud can't be less than 0"
-        elsif depth == 1
-          # recursive steps got a bit more complicated with :array/:string addition, that last line gets rid of duplicate results in the 'long' strings being returned
-          return ( type == :array ? output.uniq : output.uniq.join(' ') )
+      # Name an object that is included in the word cloud
+      # 
+      # When the depth level is low or an included gem does not use the word cloud mixin
+      # use a special rule to determine the name of the object.  The word cloud attribute
+      # object_name_methods is used for objects that use the word cloud.  Otherwise, the
+      # default config option is used.  If none of the methods are found on the object, an
+      # empty string is returned.
+      #
+      # @param [ActiveRecord::Base] object The object to name
+      # @param [String] The name of the object or a blank string
+      def word_cloud_object_name(object)
+        output = ""
+        method_list = []
+        if object.respond_to?(:word_cloud_attributes)
+          method_list = object.word_cloud_attributes[:object_name_methods]
         else
-          if type == :array
-            output |= objects.collect { |o| o.word_cloud(depth-1, :array) }
-            return output.flatten.uniq
-          else
-            output |= objects.collect { |o| o.word_cloud(depth-1) }
-            return output.flatten.join(' ').split(' ').uniq.join(' ')
+          method_list = ::ActsAsWordCloud.config.object_name_methods
+        end
+        method_list.each do |method|
+          if object.respond_to?(method)
+            output = object.send(method)
+            break
           end
         end
-      end  
+        return output
+      end
     end           
   end
 end
-

data/lib/generators/acts_as_word_cloud/templates/config.rb

@@ -1,7 +1,12 @@
 ActsAsWordCloud.configure do |config|
-  #the default setting for smallest recursive step for calling wordcloud on models
-  config.min_depth = 1
+  # The default recursion depth when looking at data in associations.
+  # A min_depth of 1 will look at all fields on the current model and the name of each association.
+  # A min_depth of 2 will look at all fields on the current model, all fields on the associations, and all names of the association's associations
+  # config.default_search_depth = 1
 
-  #methods whose values we'll attempt to get for models that don't include the mixin
-  config.no_mixin_fields = [:name, :title, :label]
+  # This option is useful when associations do not use the acts_as_word_cloud mixin.
+  # When word_cloud is called, the system tries to guess a reasonable name for the associated models.
+  # It calls the methods in order meaning it will look for name first.
+  # Make sure that the final method in this list is on every model
+  # config.default_object_names = [:name, :title, :label, :to_s]
 end

data/spec/acts_as_word_cloud_spec.rb

@@ -1,109 +1,172 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
 describe "ActsAsWordCloud" do
-  before(:all) do
-    @lone_article = Article.make
-    @publisher = Publisher.make(:name => "publisher", :location => "location")
-    @site = Site.make( :name => "site name", :domain => "uff.us", :genre => "site genre", :publisher => @publisher)
-    @author = Author.make(:name => "author", :genre => "author genre", :publisher => @publisher, :site => @site)
-    @article = Article.make(:title => "article title", :genre => "genre", :content => "article text", :author => @author, :publisher => @publisher, :site => @site) 
-    @reader = Reader.make(:username => "reader", :site => @site)
-    @following = Following.make(:article => @article, :reader => @reader, :special_name => "following1")
+  before(:each) do
+    @article = Article.new
   end
-  
+
   describe "word_cloud" do
-    describe "class method use_word_cloud" do
-      it "should contain set or default values in attributes" do
-        @article.word_cloud_using.should == [:title]
-        @article.word_cloud_excluded.should == []
-        @article.word_cloud_depth.should == 1
-        @article.word_cloud_no_mixin_fields.should == [:name, :title, :label]
-      end
-    end
-
-    it "should return the right association models" do
-      @lone_article.word_cloud.should == [@lone_article.title, @lone_article.genre, @lone_article.content, @lone_article.author.name, @lone_article.publisher.name, @lone_article.site.domain ].join(' ') 
-      @article.word_cloud.should == [@article.title, @article.genre, @article.content, @article.author.name, @article.publisher.name, @article.site.domain, @article.readers.first.username, "Following" ].join(' ')
-      
-      @publisher2 = Publisher.make(:name => "publisher2", :location => "location2")
-      @site2 = Site.make( :name => "site2 name", :domain => "uff.us2", :genre => "site2 genre", :publisher => @publisher2)
-      @author2 = Author.make(:name => "author2", :genre => "author2 genre", :publisher => @publisher2, :site => @site2)
-      @article2 = Article.make(:title => "article2 title", :genre => "genre2", :content => "article2 text", :author => @author2, :publisher => @publisher2, :site => @site2) 
-      @following2 = Following.make(:article => @article2, :reader => @reader , :special_name => "following2")
-      
-      @reader.word_cloud(2, :array).should == [@reader.username, @reader.site.domain, @article.title, @article2.title, "Following", @site.name, @site.genre, @site.publisher.name, @site.authors.first.name, @article.genre, @article.content, @article2.genre, @article2.content, @article2.author.name, @article2.publisher.name, @article2.site.domain ]
+    before(:each) do
+      @article.stub(:recursive_word_cloud).and_return([])
+    end
+
+    it "should call recursive_word_cloud" do
+      @article.should_receive(:recursive_word_cloud).and_return([])
+      @article.word_cloud
+    end
+
+    it "should return a string by default" do
+      @article.word_cloud.should be_a_kind_of String
+    end
+
+    it "should return a string if :string is passed as an argument" do
+      @article.word_cloud(:string).should be_a_kind_of String
+    end
+
+    it "should return an array if :array is passed as an argument" do
+      @article.word_cloud(:array).should be_a_kind_of Array
     end
   end
-  
-  describe "instance methods:" do
-    describe "word_cloud_associated_objects" do
-      it "should return correct models when called with belongs_to" do
-        @article.word_cloud_associated_objects(:belongs_to).should == [@article.author, @article.publisher, @article.site]
-      end
-      
-      it "should return correct models when called with has_many" do
-        @article.word_cloud_associated_objects(:has_many).should == [@article.followings, @article.readers]
-      end
+
+  describe "recursive_word_cloud" do
+    before(:each) do
+      @article.stub(:word_cloud_get_valid_strings).and_return([])
+      @article.stub(:word_cloud_associated_objects).and_return([])
+    end
+    it "should call word_cloud_get_valid_strings" do
+      @article.should_receive(:word_cloud_get_valid_strings).and_return([])
+      @article.send(:recursive_word_cloud, 1)
+    end
+
+    it "should call word_cloud_associated_objects" do
+      @article.should_receive(:word_cloud_associated_objects).and_return([])
+      @article.send(:recursive_word_cloud, 1)
+    end
+
+    it "should call rescursive_word_cloud on an associated object if the depth is more than 1" do
+      object_with_word_cloud = mock(Author)
+      object_with_word_cloud.should_receive(:recursive_word_cloud).with(1).and_return([])
+
+      @article.stub(:word_cloud_associated_objects).and_return([object_with_word_cloud])
+      @article.send(:recursive_word_cloud, 2)
+    end
+
+    it "should call word_cloud_object_name on an associated object if the depth is 1 or less" do
+      object_with_word_cloud = mock(Author)
+      object_with_word_cloud.stub(:recursive_word_cloud).and_return([])
+      @article.stub(:word_cloud_associated_objects).and_return([object_with_word_cloud])
+
+      @article.should_receive(:word_cloud_object_name).with(object_with_word_cloud)
+      @article.send(:recursive_word_cloud, 1)
+    end
+
+    it "should call word_cloud_object_name on an associated object if the object does not have the word cloud mixin" do
+      object_without_word_cloud = mock(Author)
+      @article.stub(:word_cloud_associated_objects).and_return([object_without_word_cloud])
+
+      @article.should_receive(:word_cloud_object_name).with(object_without_word_cloud)
+      @article.send(:recursive_word_cloud, 2)
+    end
+
+    it "should return an array of strings" do
+      @article.stub(:word_cloud_get_valid_strings).and_return(["hello"])
+      results = @article.send(:recursive_word_cloud, 1)
+      results.should be_a_kind_of Array
+      results.each { |r| r.should be_a_kind_of String }
+    end
+  end
+
+  describe "word_cloud_get_valid_strings" do
+    before(:each) do
+      @article.word_cloud_attributes[:included_methods] = [:sample_method]
+      @article.word_cloud_attributes[:excluded_methods] = [:sample_method]
+    end
+
+    it "should read the database structure and return text and string fields only" do
+      @article.should_receive(:title)
+      @article.should_receive(:content)
+      @article.should_not_receive(:created_at)
+      @article.send(:word_cloud_get_valid_strings)
     end 
-    
-    describe "word_cloud_get_associated" do   
-      it "should return collectoin of non-nil associated models" do
-        @article.word_cloud_get_associated(:belongs_to).should == [:author, :publisher, :site]
-        @lone_article.word_cloud_get_associated(:has_many).should == []
-        @article.word_cloud_get_associated(:has_many).should == [:followings, :readers]
-      end
-    end
- 
-    describe "word_cloud_exclude_words" do
-      it "should not keep excluded models" do
-        @article.stub!(:word_cloud_excluded).and_return([Publisher])
-        objects = @article.word_cloud_associated_objects(:belongs_to) 
-        @article.word_cloud_exclude_words(objects).should == [@article.author, @article.site]
-      end 
-    end
-    
-    describe "word_cloud_no_mixin" do
-      it "should only have models that don't have the mixin" do
-        objects = @article.word_cloud_associated_objects(:has_many) 
-        @article.word_cloud_no_mixin(objects).should == @article.followings
-      end 
-    end
-     
-    describe "word_cloud_process_words" do
-      it "should return result of first included method to work on objects with mixin" do
-        objects = []
-        objects += @article.word_cloud_associated_objects(:belongs_to) 
-        objects += @article.word_cloud_associated_objects(:has_many) 
-        objects = @article.word_cloud_exclude_words(objects)
-        no_mixin = @article.word_cloud_no_mixin(objects)
-        objects -= no_mixin
-        @article.word_cloud_process_words(objects).should == [@article.author.name, @article.publisher.name, @article.site.domain, @article.readers.first.username]
-      end
-    end
-
-    describe "word_cloud_apply_fields_to" do
-      it "return the value found in the first method to work on object passed in, if there's none return class name" do
-        @article.word_cloud_apply_fields_to(@article.followings.first).should == "Following"
-        @article.stub!(:word_cloud_no_mixin_fields).and_return([:special_name])
-        @article.word_cloud_apply_fields_to(@article.followings.first).should == @article.followings.first.special_name
-      end
-    end
-
-    describe "word_cloud_find_field" do
-      it "should return result of first included method to work on objects with mixin or their class names" do
-        @article.word_cloud_find_field(@article.followings).should == ["Following"]
-      end
-    end
-
-    describe "word_cloud_get_valid_strings" do
-      it "should return used methods on model and string attributes not in skipped list" do
-        @article.stub!(:word_cloud_skipped).and_return([:title, :content])
-        @article.word_cloud_get_valid_strings.should_not include "article title"
-        @article.word_cloud_get_valid_strings.should_not include "article text"
-        @article.word_cloud_get_valid_strings.should include "genre"
-      end
-    end
-  
+
+    it "should add included methods to the output and call them" do
+      @article.word_cloud_attributes[:excluded_methods] = []
+      @article.should_receive(:sample_method)
+      @article.send(:word_cloud_get_valid_strings)
+    end
+
+    it "should remove excluded methods from the output and not call them" do
+      @article.should_not_receive(:sample_method)
+      @article.send(:word_cloud_get_valid_strings)
+    end
   end
-end
 
+  describe "word_cloud_associated_objects" do
+    before(:each) do
+      @article.stub(:word_cloud_association_names_by_type).and_return([])  
+    end
+    it "should get objects in belongs to, has ony, and has many relationships" do
+      @article.should_receive(:word_cloud_association_names_by_type).with(:belongs_to).and_return([])  
+      @article.should_receive(:word_cloud_association_names_by_type).with(:has_one).and_return([])  
+      @article.should_receive(:word_cloud_association_names_by_type).with(:has_many).and_return([])  
+      @article.send(:word_cloud_associated_objects)
+    end
+
+    it "should remove objects that are included in excluded_models" do
+      author = Author.new
+      @article.stub(:author).and_return(author)
+      @article.stub(:word_cloud_association_names_by_type).with(:belongs_to).and_return([:author])
+      @article.word_cloud_attributes[:excluded_models] = [Author]
+      @article.send(:word_cloud_associated_objects).should be_empty
+    end
+
+    it "should return an array of rails models" do
+      author = Author.new
+      @article.stub(:author).and_return(author)
+      @article.stub(:word_cloud_association_names_by_type).with(:belongs_to).and_return([:author])
+      @article.word_cloud_attributes[:excluded_models] = []
+      @article.send(:word_cloud_associated_objects).should == [author]
+    end
+  end
+
+  describe "word_cloud_association_names_by_type" do
+    # this one is tough to test because we are just calling a single rails method
+    it "should return an array of symbols" do
+      associations = @article.send(:word_cloud_association_names_by_type, :belongs_to)
+      associations.should be_a_kind_of Array
+      associations.each { |a| a.should be_a_kind_of Symbol }
+    end
+  end 
+
+  describe "word_cloud_object_name" do
+    it "should use the object's word cloud attribute for object name if set" do
+      @article.word_cloud_attributes[:object_name_methods] = [:hello]
+      @article.should_receive(:hello).and_return("hello")
+      @article.send(:word_cloud_object_name, @article).should == "hello"
+    end
+
+    it "should call each member of the method list until it finds one that is runnable on the object" do
+      publisher = Publisher.new
+
+      ActsAsWordCloud.config.should_receive(:object_name_methods).and_return([:hello, :world])
+      publisher.stub(:respond_to?).with(:word_cloud_attributes).and_return(false)
+
+      publisher.stub(:respond_to?).with(:hello).and_return(false)
+      publisher.should_not_receive(:hello)
+
+      publisher.stub(:respond_to?).with(:world).and_return(true)
+      publisher.should_receive(:world).and_return("world")
+
+      @article.send(:word_cloud_object_name, publisher).should == "world"
+    end
+
+    it "should return an empty string if no methods are found" do
+      publisher = Publisher.new
+
+      ActsAsWordCloud.config.should_receive(:object_name_methods).and_return([])
+      publisher.stub(:respond_to?).with(:word_cloud_attributes).and_return(false)
+
+      @article.send(:word_cloud_object_name, publisher).should == ""
+    end
+  end
+end

data/spec/dummy/app/models/article.rb

@@ -1,9 +1,11 @@
 class Article < ActiveRecord::Base
-  acts_as_word_cloud :methods_to_use => [:title], :excluded_models => [], :skipped_attributes => [], :depth => 1
+  acts_as_word_cloud :included_methods => [:truncated_title], :excluded_methods => [:genre], :excluded_models => [ArticleReader, Reader], :depth => 2, :object_name_method => :title
  
   belongs_to :author
-  belongs_to :publisher
-  belongs_to :site
-  has_many :followings
-  has_many :readers, :through => :followings
+  has_many :article_readers
+  has_many :readers, :through => :article_readers
+
+  def truncated_title
+    title[0..5] if title
+  end
 end