acts_as_word_cloud 0.0.1

data/lib/acts_as_word_cloud/word_cloud.rb

@@ -0,0 +1,227 @@
+module ActsAsWordCloud
+  module WordCloud
+    def self.included(base)
+      base.extend ClassMethods
+    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)
+
+        # 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
+
+        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 []
+        else
+          result = objects.flatten.reject { |n| n.respond_to?(:word_cloud) }
+          result.present? ? result : []
+        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
+      #
+      def word_cloud_process_words(objects)
+        output = []
+        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)
+          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
+      #
+      # @returns [Array <String>]
+      #
+      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
+
+        # current model's string attributes
+        output += self.attributes.select {|k,v| v.class == String}.values
+        output -= ignore
+
+        return output
+      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
+      #
+      def word_cloud( depth = self.word_cloud_depth, type = :string ) 
+
+        output = []
+        objects = []
+        no_mixin = []
+        
+        # string attributes in current model
+        output = word_cloud_get_valid_strings
+      
+        # 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(' ') )
+        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(' ')
+          end
+        end
+      end  
+    end           
+  end
+end
+

data/lib/acts_as_word_cloud.rb

@@ -0,0 +1,2 @@
+require 'acts_as_word_cloud/railtie'
+require 'acts_as_word_cloud/engine'

data/lib/generators/acts_as_word_cloud/install_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'active_record'
+require 'rails/generators/active_record'
+
+module ActsAsWordCloud
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path(File.join(File.dirname(__FILE__), "templates"))
+
+      desc <<DESC
+Description:
+  Copies over migrations and config for the normalizer.
+DESC
+
+      def copy_config_file
+        copy_file "config.rb", "config/initializers/acts_as_word_cloud.rb"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+ActsAsWordCloud.configure do |config|
+  #the default setting for smallest recursive step for calling wordcloud on models
+  config.min_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]
+end

data/lib/model_methods_helper.rb

@@ -0,0 +1,87 @@
+require 'find'
+class ModelMethodsHelper
+
+  # finds or makes a model based on the given attributes
+  # @param [Constant] model_name The name of the model
+  # @param [Hash] attributes The attributes to find the model or add to the new one
+  def self.find_or_make_by_attributes(model_name, attributes)
+    instances = model_name.where(attributes)
+    if instances.empty?
+      return model_name.make(attributes)
+    else
+      return instances.first
+    end
+  end
+
+  # Uses the descendants_of method to determine the model structure
+  # Then tableizes and converts to symbol
+  #
+  # Load all models must be run for accurate descendants list
+  # it is now being called every time this method is called
+  # for now it works because this is only called one time when the authorization config is loaded on initialize
+  # if this ever changes, this code may need to be update (2-15-2012)
+  #
+  # @return [Array] Array with file names underscored and pluralized in the format [:users, :case_placements, :roles, :job_locations, ... ]
+  def self.get_model_symbol_array
+    # Old method:
+    # Major redesign of this method that finds namespaced models
+    # Finds all files in the given folder, tries to find the ruby files
+    # Then processes the names to get the names we need for the code
+    #
+    # @return [Array] Array with file names underscored and pluralized in the format [:users, :case_placements, :roles, :job_locations, ... ]
+    #model_array = []
+    #Find.find("#{Rails.root.to_s}/app/models") do |model_path|
+    #  if model_path.match(/\.rb$/)
+    #    model_path = model_path.gsub("#{Rails.root.to_s}/app/models/", "")
+    #    model_path = model_path.gsub("/","_")
+    #    model_path = model_path.gsub(/\.rb$/, "")
+    #    model_array.push model_path.pluralize.to_sym
+    #  end
+    #end
+    #return model_array
+
+    # new method
+    self.load_all_models
+    # returns the table name if there is one or tableizes the model name if not
+    # our permissions system generally uses table names for model permissions
+    return self.descendants_of(ActiveRecord::Base).map{ |m| m.abstract_class ? m.to_s.tableize.to_sym : m.table_name.to_sym }
+  end
+
+  # Requires all models so that they are visible in the object space
+  # This is only necessary when we are not caching classes
+  def self.load_all_models
+    if !::Rails.application.config.cache_classes
+      Dir[Rails.root.join("app/models/**/*.rb")].each {|f| require f}
+    end
+  end
+
+  # Return a list of descendants of the given model.
+  #
+  # If direct is set to true, only return immediate descendants
+  # The load_all_models must be called before this is called or the result may not be correct
+  #
+  # @param [Constant] parent_class The parent class to look for descendants for
+  # @param [Boolean] direct Whether to look for all descendants or immediate descendants
+  # @return [Array] An array of class constants that satisfy the conditions of the parameters
+  def self.descendants_of(parent_class, direct = false)
+    classes = []
+    ObjectSpace.each_object(::Class).each do |klass|
+      if direct
+        classes << klass if klass.superclass == parent_class
+      else
+        classes << klass if klass < parent_class
+      end
+    end
+    return classes
+  end
+
+  # Convenience method to return the results of descendants_of with direct set to true 
+  #
+  # The load_all_models must be called before this is called or the result may not be correct
+  #
+  # @param [Constant] parent_class The parent class to look for descendants for
+  # @return [Array] An array of class constants that satisfy the conditions of the parameters
+  def self.direct_descendants_of(parent_class)
+    return self.descendants_of(parent_class, true)
+  end
+end

data/spec/acts_as_word_cloud_spec.rb

@@ -0,0 +1,109 @@
+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")
+  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 ]
+    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
+    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
+  
+  end
+end
+