muck-raker 0.1.37 → 0.1.38

data/app/helpers/muck_raker_google_helper.rb

@@ -1,5 +1,26 @@
 module MuckRakerGoogleHelper
 
+  # Render feeds using Google's api
+  # feeds:            Feed object.
+  # show_controls:    Indicates whether or not to show editing controls. ie Remove
+  # number_of_items:  Number of items to display for the given feed.
+  # number_of_images: Number of images to get from the feed.
+  # number_of_videos: Number of videos to get from the feed.
+  # use_uri_for_control: If set to true then a hidden field will be generated containing the feed's uri.  If false then the hidden field will contain the feed's service id.  This is used to
+  #                      regenerate the feed after submission to the server.
+  # javascript_callback: Name of a javascript method to call after the feed has finished loading.  The 
+  #                      method should accept the feed uri and the content id. ie  feed_callback(uri, content_id).
+  def google_feeds(feeds, show_controls = false, number_of_items = 6, number_of_images = 20, number_of_videos = 6, 
+                  use_uri_for_control = false, run_load_scripts = false, javascript_callback = 'google_load_complete')
+    render :partial => 'google/feed', :collection => feeds, :locals => {:number_of_items => number_of_items,
+                                                                       :number_of_images => number_of_images,
+                                                                       :number_of_videos => number_of_videos,
+                                                                       :javascript_callback => javascript_callback,
+                                                                       :show_controls => show_controls,
+                                                                       :use_uri_for_control => use_uri_for_control,
+                                                                       :run_load_scripts => run_load_scripts}
+  end
+
   # Render a google dynamic feed control.
   #
   # feeds:      An array of feeds to render each with a property 'title' and 'uri' defined
@@ -36,107 +57,76 @@ module MuckRakerGoogleHelper
                         options = { :displayTime => 2000, :transistionTime => 600, :scaleImages => true, :fullControlPanel => true })
     render :partial => 'google/slide_show', :locals => { :feed => feed, :content_id => content_id, :options => options }
   end
-  
-  # Render photos from a given feed
-  #
-  # feed:             Url for which to generate the feed.
-  # content_id:       Name of the div that will hold the widget google generates.
-  #                   If this method is called more than once on a given page then you will need to 
-  #                   specify different content_ids for each call.
-  # number_of_images: Number of images to get from the feed.
-  # javascript_callback: Name of a javascript method to call after the feed has finished loading.  The 
-  #                      method should accept the feed uri and the content id. ie  feed_callback(uri, content_id).
-  def google_feed_photos(feed, 
-                        content_id = 'feed_photo_content',
-                        number_of_images = 5,
-                        javascript_callback = nil)
-    render :partial => 'google/feed_photos', :locals => { :feed => feed, :content_id => content_id, :number_of_images => number_of_images, :javascript_callback => javascript_callback }
-  end
-  
-  # Render contents from a given feed
-  #
-  # feed:             Url for which to generate the feed.
-  # content_id:       Name of the div that will hold the widget google generates.
-  #                   If this method is called more than once on a given page then you will need to 
-  #                   specify different content_ids for each call.
-  # number_of_items:  Number of items to display for the given feed.
-  # javascript_callback: Name of a javascript method to call after the feed has finished loading.  The 
-  #                      method should accept the feed uri and the content id. ie  feed_callback(uri, content_id).
-  def google_feed_display(feed,
-                          content_id = 'feed_display_content',
-                          number_of_items = 5,
-                          javascript_callback = nil)
-    render :partial => 'google/feed_display', :locals => { :feed => feed, :content_id => content_id, :number_of_items => number_of_items, :javascript_callback => javascript_callback }
+
+  # Given a feed attempts to assign an appropriate class
+  def feed_class(feed)
+    if feed.service.photo?
+      "feed-photos"
+    elsif feed.service.bookmark?
+      "feed-bookmarks"
+    elsif feed.service.video?
+      "feed-videos"
+    elsif feed.service.music?
+      "feed-music"
+    end
   end
   
-  # Render bookmarks from a given feed
-  #
-  # feed:             Url for which to generate the feed.
-  # content_id:       Name of the div that will hold the widget google generates.
-  #                   If this method is called more than once on a given page then you will need to 
-  #                   specify different content_ids for each call.
-  # number_of_items:  Number of items to display for the given feed.
-  # javascript_callback: Name of a javascript method to call after the feed has finished loading.  The 
-  #                      method should accept the feed uri and the content id. ie  feed_callback(uri, content_id).
-  def google_bookmark_display(feed,
-                          content_id = 'feed_display_content',
-                          number_of_items = 5,
-                          javascript_callback = nil)
-    render :partial => 'google/feed_bookmarks', :locals => { :feed => feed, :content_id => content_id, :number_of_items => number_of_items, :javascript_callback => javascript_callback }
+  # Generates a valid dom id for the feed
+  def feed_content_id(feed)
+    "feed_#{feed.id}_#{feed.title.parameterize}_#{feed.service.name.parameterize}".gsub('+', '-')
   end
   
-  # Determines the type of feed and renders the appropriate content.  For standard data feeds this will be
-  # a list of entries.  For a feed with service type photo it will render photos, etc.
-  #
+  # Outputs the appropriate script for handling the google response once the feed is loaded
   # feed:             Url for which to generate the feed.
   # content_id:       Name of the div that will hold the widget google generates.  
   #                   If this method is called more than once on a given page then you will need to 
   #                   specify different content_ids for each call.
-  # number_of_items:  Number of items to display for the given feed.
-  # number_of_images: Number of images to display if the feed is an image feed.
   # javascript_callback: Name of a javascript method to call after the feed has finished loading.  The 
   #                      method should accept the feed uri and the content id. ie  feed_callback(uri, content_id).
-  def google_muck_feed(feed, number_of_items = 5, number_of_images = 5, content_id = nil, javascript_callback = nil)
-    content_id ||= "feed_#{feed.id}_#{feed.title.parameterize}_#{feed.service.name.parameterize}"
+  def google_muck_load_script(feed, content_id = nil, javascript_callback = nil)
     if feed.service.photo?
-      google_feed_photos(feed, content_id, number_of_images, javascript_callback)
+      google_load_images_script(javascript_callback, feed.uri, content_id)
     elsif feed.service.bookmark?
-      google_bookmark_display(feed, content_id, number_of_items, javascript_callback)
+      google_load_bookmarks_script(javascript_callback, feed.uri, content_id)
     elsif feed.service.video?
-      # TODO for now video feeds are just data feeds. 
-      google_feed_display(feed, content_id, number_of_items, javascript_callback)
+      google_load_videos_script(javascript_callback, feed.uri, content_id)
+    elsif feed.service.music?
+      # TODO need to get music feeds into tag system so that we can search for music feeds and then integrate in a way that can play the tunes.
+      google_load_entries_script(javascript_callback, feed.uri, content_id)
     else
-      google_feed_display(feed, content_id, number_of_items, javascript_callback)
+      google_load_entries_script(javascript_callback, feed.uri, content_id)
     end
   end
   
-  # Render a collection of feeds using google.
-  #
-  # feeds:            An array of feeds to render each with a property 'title' and 'uri' defined
-  # content_id:       Name of the div that will hold the widget google generates.  
-  #                   If this method is called more than once on a given page then you will need to 
-  #                   specify different content_ids for each call.
-  # number_of_images: Number of images to display if the feed is an image feed.
-  # options:          A hash containing the values to pass to the Google widget. The available options are defined here:
-  #                   http://www.google.com/uds/solutions/dynamicfeed/reference.html.
-  def google_feeds_display(feeds,
-                           number_of_items = 5,
-                           number_of_images = 10,
-                           javascript_callback = nil)
-    photo_service_ids = Service.photo_services.map(&:id)
-    photo_feeds = feeds.find_all { |feed| photo_service_ids.include?(feed.service_id) }
-    data_feeds = feeds - photo_feeds
-    render :partial => 'google/feeds_display', :locals => { :data_feeds => data_feeds,
-                                                            :photo_feeds => photo_feeds,
-                                                            :photo_service_ids => photo_service_ids,
-                                                            :number_of_images => number_of_images,
-                                                            :number_of_items => number_of_items,
-                                                            :javascript_callback => javascript_callback }
+  def google_muck_load_callback_script(feed, content_id, number_of_items = 4, number_of_images = 6, number_of_videos = 6)
+    if feed.service.photo?
+      "google_load_images('#{feed.uri}', '#{content_id}', #{number_of_images});"
+    elsif feed.service.bookmark?
+      "google_load_bookmarks('#{feed.uri}', '#{content_id}', #{number_of_items});"
+    elsif feed.service.video?
+      "google_load_videos('#{feed.uri}', '#{content_id}', #{number_of_videos});"
+    elsif feed.service.music?
+      "google_load_entries('#{feed.uri}', '#{content_id}', #{number_of_items});"
+    else
+      "google_load_entries('#{feed.uri}', '#{content_id}', #{number_of_items});"
+    end
   end
   
+  def google_load_videos_script(javascript_callback, uri, content_id)
+    google_load_template_script 'google_load_videos', javascript_callback, uri, content_id do
+      %Q{var link = jQuery(item.content).find('img').parent('a');
+      link.attr('rel', '#{content_id}');
+      link.addClass('feed-video');
+      jQuery('#' + content_id).append(link);}
+    end
+  end
+    
   def google_load_images_script(javascript_callback, uri, content_id)
     google_load_template_script 'google_load_images', javascript_callback, uri, content_id do
-      %Q{jQuery('#' + content_id).append(jQuery(item.content).find('img').parent());}
+      %Q{var link = jQuery(item.content).find('img').parent('a');
+      link.attr('rel', '#{content_id}');
+      link.addClass('feed-photo');
+      jQuery('#' + content_id).append(link);}
     end
   end
   

data/app/models/aggregation.rb

@@ -22,23 +22,69 @@ class Aggregation < ActiveRecord::Base
   has_many :aggregation_feeds
   has_many :feeds, :through => :aggregation_feeds
   
+  named_scope :by_title, :order => "title ASC"
+  named_scope :recent, lambda { { :conditions => ['created_at > ?', 1.week.ago] } }
+  named_scope :newest, :order => "created_at DESC"
+    
   # Builds and then adds feeds for a given terms
-  def add_feeds(user, service_ids)
-    self.feeds << Service.create_feeds(user, self.terms, service_ids)
-  end
-  
-  # ##########################################################
-  # # adds a feed to an aggregation and saves the feed
-  # def add_feed_to_aggregation(aggregation, feed)
-  #   if aggregation.feeds.include?(feed)
-  #     self.already_feeds.push(feed)
-  #   else
-  #     if feed.save # have to save here so that feed has an id.  Without id can't associate with aggregation
-  #       feed.aggregations << aggregation
-  #       self.added_feeds.push(feed )
-  #     end
-  #   end
-  #   feed.save
-  # end
+  # user:         User to be associated with each feed.  Default is nil which makes each feed global.
+  # service_ids:  An array of service ids.  Nil will generate a feed for every available service.
+  def add_feeds(user = nil, service_ids = nil)
+    safe_add_feeds(Service.create_feeds(self.terms, user, service_ids))    
+  end
+  
+  def add_feeds_by_uri(user = nil, uris = nil)
+    safe_add_feeds(Feed.create_feeds(user, uris))
+  end
+  
+  # Only add feeds that aren't already part of the aggregation
+  def safe_add_feeds(new_feeds)
+    new_feeds.each do |feed|
+      begin
+        self.feeds << feed
+      rescue ActiveRecord::RecordInvalid => ex
+        # Throw away exception.  Feed already exists so we don't need to do anything.
+      end
+    end
+    new_feeds
+  end
+  
+  # Get only photo feeds
+  def photo_feeds
+    all_feeds.find_all{ |feed| feed.service.photo? }
+  end
+  
+  # Get only video feeds
+  def video_feeds
+    all_feeds.find_all{ |feed| feed.service.video? }
+  end
+  
+  # Get only bookmark feeds
+  def bookmark_feeds
+    all_feeds.find_all{ |feed| feed.service.bookmark? }
+  end
+
+  # Get only music feeds
+  def music_feeds
+    all_feeds.find_all{ |feed| feed.service.music? }
+  end
 
+  # Get only general feeds (exclude all specific feeds such as photos, videos, etc)
+  def general_feeds
+    all_feeds.find_all{ |feed| feed.service.general? }
+  end
+  
+  def all_feeds
+    @all_feeds ||= self.feeds.find(:all, :include => :service)
+  end
+
+  # Determines whether or not he given user can edit the aggregation
+  def can_edit?(user)
+    if ownable == user || user.admin?
+      true
+    else
+      false
+    end
+  end
+  
 end

data/app/models/aggregation_feed.rb

@@ -8,6 +8,7 @@
 #
 
 class AggregationFeed < ActiveRecord::Base
-  belongs_to :aggregation
+  belongs_to :aggregation, :counter_cache => 'feed_count', :touch => true
   belongs_to :feed
+  validates_uniqueness_of :feed_id, :scope => :aggregation_id
 end

data/app/models/feed.rb

@@ -144,13 +144,24 @@ class Feed < ActiveRecord::Base
     feeds = []
     @available_feeds = discover_feeds(uri)
     @available_feeds.each do |feed|
-      feeds << from_feedzirra(Feedzirra::Feed.fetch_and_parse(feed.url)) unless feed.blank?
+      feeds << new_from_feedzirra(Feedzirra::Feed.fetch_and_parse(feed.url)) unless feed.blank?
     end
     feeds
   end
 
+  # Gathers all available feed uris from the given uri and parses them into
+  # feed objects
+  def self.feeds_from_uri(uri, user = nil)
+    feeds = []
+    @available_feeds = discover_feeds(uri)
+    @available_feeds.each do |feed|
+      feeds << create_from_feedzirra(Feedzirra::Feed.fetch_and_parse(feed.url), user) unless feed.blank?
+    end
+    feeds
+  end
+  
   # Turns a feed from feedzirra into a muck feed
-  def self.from_feedzirra(feed)
+  def self.new_from_feedzirra(feed)
     return if feed.blank?
     Feed.new(:short_title => feed.title,
              :title => feed.title,
@@ -158,6 +169,12 @@ class Feed < ActiveRecord::Base
              :uri => feed.feed_url)
   end
 
+  # Creates a feed from feedzirra into a muck feed
+  def self.create_from_feedzirra(feed, user)
+    return if feed.blank?
+    Feed.find_or_create(feed.feed_url, feed.title, '', '', Service.find_service_by_uri(feed.url), user, feed.url)
+  end
+  
   # Looks for feeds from a given url
   def self.discover_feeds(uri)
     Feedbag.find(uri)
@@ -177,4 +194,14 @@ class Feed < ActiveRecord::Base
                  :display_uri => display_uri)
   end
   
+  # Create feeds for the given uris
+  # user: User that will be set as the feed contributor
+  # uris: An array of uris for which to create feeds
+  # service: A default service to be associated with all the feeds.
+  def self.create_feeds(user = nil, uris = nil, service = nil)
+    return [] if uris.blank?
+    service ||= Service.default_service
+    uris.collect { |uri| Feed.find_or_create(uri, '', '', '', service.id, user, uri) }
+  end
+  
 end

data/app/models/google_feed_request.rb

@@ -26,7 +26,13 @@ class GoogleFeedRequest
   # Search for feeds using google.  This will return 
   # a collection of 'Feed' objects
   def self.find_feeds(query)
-    convert_google_json_to_feeds(find_google_feeds(query))
+    query = query.join('+') if query.is_a?(Array)
+    feed_response = find_google_feeds(query)
+    if 200 == feed_response['responseStatus']
+      convert_google_json_to_feeds(feed_response)
+    else
+      []
+    end
   end
   
   # Search for feeds using google.  This will return 

data/app/models/identity_feed.rb

@@ -14,9 +14,9 @@ class IdentityFeed < ActiveRecord::Base
   
   validates_uniqueness_of :feed_id, :scope => [:ownable_id, :ownable_type]
   
-  # override this method to change the way permissions are handled on comments
+  # Determines whether or not he given user can edit the identity feed
   def can_edit?(user)
-    if ownable == user || check_user(user)
+    if ownable == user || user.admin?
       true
     else
       false

data/app/models/service.rb

@@ -28,30 +28,43 @@ class Service < ActiveRecord::Base
   
   # Indicates whether feed is primarily a photo feed ie from flick, picasa, etc
   def photo?
-    self.service_category.name == 'Photos'
+    Service.get_photo_services.include?(self)
   end
   
   # Indicates whether feed is primarily a video feed ie from youtube, etc
   def video?
-    self.service_category.name == 'Videos'
+    Service.get_video_services.include?(self)
   end
   
   # Indicates whether feed is primarily a bookmark feed ie from delicious, etc
   def bookmark?
-    self.service_category.name == 'Bookmarks'
+    Service.get_bookmark_services.include?(self)
+  end
+  
+  # Indicates whether feed is primarily a music feed
+  def music?
+    Service.get_music_services.include?(self)
+  end
+  
+  def general?
+    Service.get_general_services.include?(self)
   end
   
   def human_uri(tag)
-    if self.uri_template
-      self.uri_template.sub("{tag}", tag)
-    else
-      self.uri
-    end
+    generate_tag_template_uri(tag, self.uri_template)
   end
   
   # Generate a uri for the current service
   def generate_tag_uri(tag)
-    self.uri_data_template.sub("{tag}", tag)
+    generate_tag_template_uri(tag, self.uri_data_template)
+  end
+  
+  def generate_tag_template_uri(tag, uri_template)
+    if self.name == 'Flickr'
+      uri_template.sub("{tag}", tag.gsub('+',',')) # flickr wants a comma deliminated list of tags
+    else
+      uri_template.sub("{tag}", tag)
+    end
   end
   
   def generate_uris(username = '', password = '', uri = '')
@@ -92,59 +105,140 @@ class Service < ActiveRecord::Base
   end
 
   # creates a feed for a service with a username and optional password
-  def self.create_feeds_for_service(service, uri, username, password, contributor_id)
+  def self.create_feeds_for_service(service, uri, username, password, contributor)
     uris = service.generate_uris(username, password, uri)
-    uris.collect{ |u| Feed.find_or_create(u.url, u.title, username, password, service.id, contributor_id) } if uris
+    uris.collect{ |u| Feed.find_or_create(u.url, u.title, username, password, service.id, contributor) } if uris
   end
   
-  # Builds feeds (does not save them to the db) for the given term.  Note that this
-  # method calls each feed created and so it can take a while to run.
-  def self.build_live_feeds(user_id, terms, selected_service_ids = nil)
-    uris = generate_tag_uris(terms, selected_service_ids)
-    feed_uris = uris.collect { |uri| Feed.discover_feeds(uri)}
-    feed_uris.collect { |feed| Feed.new(:uri => feed.url,
-                                        :title => feed.title,
-                                        :service_id => service.id,
-                                        :contributor_id => user_id) }
+  def self.build_photo_feeds(terms, user, service_ids = nil)
+    if service_ids.nil?
+      service_ids = get_photo_services.map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_photo_services.map(&:id)
+    end
+    build_feeds(terms, user, service_ids)
+  end
+  
+  def self.build_video_feeds(terms, user, service_ids = nil)
+    if service_ids.nil?
+      service_ids = get_video_services.map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_video_services.map(&:id)
+    end
+    build_feeds(terms, user, service_ids)
+  end
+  
+  def self.build_bookmark_feeds(terms, user, service_ids = nil)
+    if service_ids.nil?
+      service_ids = get_bookmark_services.map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_bookmark_services.map(&:id)
+    end
+    build_feeds(terms, user, service_ids)
+  end
+  
+  def self.build_music_feeds(terms, user, service_ids = nil)
+    if service_ids.nil?
+      service_ids = get_music_services.map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_music_services.map(&:id)
+    end
+    build_feeds(terms, user, service_ids)
+  end
+  
+  def self.build_general_feeds(terms, user, service_ids = nil)
+    if service_ids.nil?
+      service_ids = get_general_services.map(&:id)
+    else
+      service_ids = make_int_array(service_ids) & get_general_services.map(&:id)
+    end
+    build_feeds(terms, user, service_ids)
+  end
+    
+  def self.get_photo_services
+    @photo_services ||= get_services.find_all{|service| service.service_category.name == 'Photos' }
+  end
+  
+  def self.get_video_services
+    @video_services ||= get_services.find_all{|service| service.service_category.name == 'Videos' }
+  end
+  
+  def self.get_bookmark_services
+    @bookmark_services ||= get_services.find_all{|service| service.service_category.name == 'Bookmarks' }
+  end
+  
+  def self.get_music_services
+    @music_services ||= get_services.find_all{|service| service.service_category.name == 'Music' }
+  end
+  
+  def self.get_general_services
+    @general_services ||= get_services.find_all{|service| !['Photos', 'Videos', 'Bookmarks', 'Music'].include?(service.service_category.name) }
   end
   
   # Builds feeds (does not save them to the db) for the given term
-  def self.build_feeds(user_id, terms, selected_service_ids = nil)
+  def self.build_feeds(terms, user, selected_service_ids = nil)
     split_terms(terms).collect { |tag|
       get_services(selected_service_ids).collect { |service| Feed.new(:uri => service.generate_tag_uri(tag),
                                                                       :display_uri => service.human_uri(tag),
                                                                       :title => I18n.t('muck.raker.service_feed_name', :term => CGI.unescape(tag).humanize, :service => service.name),
                                                                       :service_id => service.id,
-                                                                      :contributor_id => user_id) }
+                                                                      :contributor_id => user) }
     }.flatten!
   end
   
+  # Builds feeds (does not save them to the db) for the given term.  Note that this
+  # method calls each feed created and so it can take a while to run.
+  def self.build_live_feeds(terms, user, selected_service_ids = nil)
+    uris = generate_tag_uris(terms, selected_service_ids)
+    feed_uris = uris.collect { |uri| Feed.discover_feeds(uri)}
+    feed_uris.collect { |feed| Feed.new(:uri => feed.url,
+                                        :title => feed.title,
+                                        :service_id => service.id,
+                                        :contributor_id => user) }
+  end
+  
   # Create feeds for the given terms
-  def self.create_feeds(user_id, terms, selected_service_ids = nil)
+  def self.create_feeds(terms, user = nil, selected_service_ids = nil)
     split_terms(terms).collect { |tag|
-      get_services(selected_service_ids).collect { |service| Feed.find_or_create(service.generate_tag_uri(tag), tag, '', '', service.id, user_id, service.human_uri(tag)) }
+      get_services(selected_service_ids).collect { |service| Feed.find_or_create(service.generate_tag_uri(tag), tag, '', '', service.id, user, service.human_uri(tag)) }
     }.flatten!
   end
   
   def self.split_terms(terms)
-    terms.split(',').collect { |tag| CGI.escape(tag.strip) }
+    return '' if terms.blank?
+    terms = terms.split(',') unless terms.is_a?(Array)
+    terms.collect { |tag| CGI.escape(tag.strip) }
   end
   
   def self.get_services(selected_service_ids = nil)
     if selected_service_ids
-      selected_service_ids.collect! { |service_id| service_id.to_i }
-      services = Service.tag_services.find_all { |service| selected_service_ids.include?(service.id) }
+      selected_service_ids.collect! { |service_id| service_id.to_i } # make sure the ids are ints
+      Service.tag_services.find_all { |service| selected_service_ids.include?(service.id) }
     else
-      services = Service.tag_services
+      @services ||= Service.tag_services
     end
   end
 
   # attempts to find a service using a uri
-  def self.find_service_by_uri(uri)
-    @services ||= Service.all
+  # uri:              Uri to search for.  This method will attempt to all services for any part of the provided uri.
+  # refresh_services: Forces a refresh of the services.  By default the services are cached for the duration of the request.
+  def self.find_service_by_uri(uri, refresh_services = false)
+    if refresh_services
+      @services = Service.all
+    else
+      @services ||= Service.all
+    end
     service = @services.detect { |service| service.uri && service.uri.length > 0 && (uri.include?(service.uri) || service.uri.include?(uri)) }
-    service ||= Service.find_by_name('rss') # this will return the default rss service
+    service ||= default_service
     service
   end
   
+  def self.make_int_array(a)
+    a.collect{|i| i.to_i}
+  end
+  
+  def self.default_service
+    Service.find_by_name('rss') # this will return the default rss service
+  end
+  
 end

data/app/views/aggregations/_aggregation.html.erb

@@ -0,0 +1 @@
+<%= aggregation.title %><%= aggregation.feed_count %>

data/app/views/aggregations/_data_source.html.erb

@@ -1,4 +1,4 @@
 <li id="<%= data_source.name.parameterize %>-link" <%= service_icon_background(data_source) %> class="service-link">
-  <%= check_box_tag "#{@parent.to_s.underscore}[service_ids][]", data_source.id, data_source_checked?(data_source) -%> 
+  <%= check_box_tag "service_ids[]", data_source.id, data_source_checked?(data_source) -%> 
   <%= data_source.name %>
-</li>
+</li>

data/app/views/aggregations/_feeds.html.erb

@@ -0,0 +1 @@
+<%= google_feeds(@feeds, @show_controls, @number_of_items, @number_of_images, @number_of_videos, false, true) %>

data/app/views/aggregations/_preview_form.html.erb

@@ -0,0 +1,12 @@
+<h2><%= I18n.t('muck.raker.new_aggregation') %></h2>
+<%= text_field_tag :terms, params[:terms] %>
+<p><%= t('muck.raker.terms_instructions') %></p>
+<div class="button form-row">
+  <%= f.submit t('muck.raker.search'), :id => 'search' %>
+  <span id="searching_message" style="display:none;">
+    <%= t('muck.raker.finding_topics') %><img src="/images/spinner.gif" alt="<%= t('muck.general.loading') %>" />
+  </span>
+</div>
+<% content_for :javascript do -%>
+  <%= show_hide_on_click('searching_message', 'search') %>
+<% end -%>