muck-raker 0.2.11 → 0.3.1

data/app/helpers/muck_raker_services_helper.rb

@@ -1,117 +0,0 @@
-module MuckRakerServicesHelper
-  
-  # Render a summary of all services for the given parent.  The parent should 'acts_as_muck_feed_owner' 
-  def services_summary(parent)
-    identity_feeds = parent.identity_feeds.find(:all, :include => [{:feed => :service}])
-    render :partial => 'services/summary', :locals => { :identity_feeds => identity_feeds }
-  end
-  
-  # Render a view with all services in categories.
-  # service_categories: Results from a query to service_categories.  For performance try something like this:
-  #                     ServiceCategory.sorted.find(:all, :include => [:identity_services])
-  # title: Optional title.  Default is 'Available Services' - from I18n.t('muck.raker.available_services')
-  # css: Optional css to be added to the div that surrounds the categories
-  def available_service_categories(service_categories, title = nil, css = '')
-    render :partial => 'identity_feeds/available_service_categories', :locals => { :service_categories => service_categories, :css => css, :title => title }
-  end
-  
-  # Render a view with the user's registered services.
-  # identity_feeds: Results from a query to service_categories.  For performance try something like this:
-  #                 @user.identity_feeds.find(:all, :include => [{:feed => :service}])
-  # title: Optional title.  Default is 'My Services' - from I18n.t('muck.raker.my_services')
-  # css: Optional css to be added to the div that surrounds the categories
-  def services_for_user(identity_feeds, title = nil, css = '')
-    render :partial => 'identity_feeds/services_for_user', :locals => { :identity_feeds => identity_feeds, :css => css, :title => title, :edit => false }
-  end
-  
-  # Render an edit view with the user's registered services.
-  # identity_feeds: Results from a query to service_categories.  For performance try something like this:
-  #                 @user.identity_feeds.find(:all, :include => [{:feed => :service}])
-  # title: Optional title.  Default is 'My Services' - from I18n.t('muck.raker.my_services')
-  # css: Optional css to be added to the div that surrounds the categories
-  def services_for_user_edit(identity_feeds, title = nil, css = '')
-    render :partial => 'identity_feeds/services_for_user', :locals => { :identity_feeds => identity_feeds, :css => css, :title => title, :edit => true }
-  end
-  
-  # Renders an icon for the given service
-  # Name is the name of the image file associated with the service
-  # Size can be one of 16, 24, 48 or 60.
-  def service_icon(name, size = 24)
-    %Q{<img src="/images/service_icons/#{size}/#{name}" />}
-  end
-  
-  def service_image(name, size = 24)
-    %Q{/images/service_icons/#{size}/#{name}}
-  end
-  
-  # Renders name and icon for the service
-  def service_title(service)
-    %Q{<div class="identity-service-title" #{service_icon_background(service)}>#{service_prompt(service)}</div>}
-  end
-  
-  # By default renders Service username e.g. Flickr username
-  # If the service has a 'prompt' set it will look for a value in the localization
-  # files.  For example, setting service.prompt to 'blog_url' will cause this method
-  # to look for a translation at muck.raker.blog_url and will pass the name of the service
-  # using 'service' so your translation might look like:
-  # muck.raker.blog_url: "Blog Url" or
-  # muck.raker.facebook_prompt: "{{service}} Feeds"
-  def service_prompt(service)
-    if @service.prompt.blank?
-      I18n.t('muck.raker.service_username', :service => @service.name)
-    else
-      I18n.t("muck.raker.#{@service.prompt}", :service => @service.name)
-    end
-  end
-  
-  # Renders a link for a new user service with class 'lightbox' or optional css set on the link.
-  def service_lightbox(parent, service, link_css = 'lightbox', wrapper = 'li')
-    path = new_polymorphic_url([parent, :identity_feed], :service_id => service.to_param)
-    service_link(path, service, link_css, wrapper, nil, nil, "#{service.name.parameterize}-link")
-  end
-
-  # Renders a link for editing a user feed with class 'lightbox' or optional css set on the link.
-  def service_lightbox_edit(parent, identity_feed, link_css = 'lightbox', wrapper = nil)
-    path = edit_polymorphic_url([parent, identity_feed])
-    link_text = identity_feed.feed.title unless identity_feed.feed.title.blank?
-    service_link(path, identity_feed.feed.service, link_css, wrapper, link_text)
-  end
-  
-  def service_external_link(identity_feed, link_css = nil, wrapper = nil)
-    path = identity_feed.feed.display_uri || identity_feed.feed.uri
-    link_text = identity_feed.feed.title unless identity_feed.feed.title.blank?
-    service_link(path, identity_feed.feed.service, link_css, wrapper, link_text, 'blank')
-  end
-  
-  # Renders a delete button for an identity_feed
-  def service_delete(identity_feed, button_type = :button, button_text = t("muck.general.delete"))
-    render :partial => 'shared/delete', :locals => { :delete_object => identity_feed, 
-                                                     :button_type => button_type,
-                                                     :button_text => button_text,
-                                                     :form_class => 'identity-feed-delete',
-                                                     :delete_path => identity_feed_path(identity_feed, :format => 'js') }
-  end
-  
-  # Renders a service link optionally wrapping it in the specified element
-  def service_link(path, service, link_css, wrapper, link_text = nil, target = nil, id = nil)
-    link = %Q{<a #{'id=' + id if id} href="#{path}" #{service_icon_background(service)} #{'target=' + target if target} class="service-link #{link_css}">#{link_text || service.name}</a>}
-    if wrapper
-      content_tag wrapper, link, :class => 'identity-service' 
-    else
-      link
-    end
-  end
-  
-  def service_icon_background(service)
-    %Q{style="background: transparent url('#{service_image(service.icon, 24)}') no-repeat scroll left top;"}
-  end
-  
-  def url_by_identity_feed(owner, identity_feed, service)
-    if identity_feed
-      polymorphic_url([owner, identity_feed], :service_id => service.to_param)
-    else
-      polymorphic_url([owner, :identity_feeds], :service_id => service.to_param)
-    end
-  end
-  
-end

data/app/models/aggregation.rb

@@ -1,92 +0,0 @@
-# == Schema Information
-#
-# Table name: aggregations
-#
-#  id           :integer(4)      not null, primary key
-#  terms         :string(255)
-#  title        :string(255)
-#  description  :text
-#  top_tags     :text
-#  created_at   :datetime
-#  updated_at   :datetime
-#  ownable_id   :integer(4)
-#  ownable_type :string(255)
-#
-
-class Aggregation < ActiveRecord::Base
-  unloadable
-
-  has_friendly_id :terms, :use_slug => true
-  
-  belongs_to :ownable, :polymorphic => true
-  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
-  # 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.
-  # refresh_services:     By default all tag services are cached.  Setting this value to true
-  #                       will result in the values being repopulated from the database
-  def add_feeds(user = nil, service_ids = nil, refresh_services = false)
-    safe_add_feeds(Service.create_tag_feeds(self.terms, user, service_ids, refresh_services))
-  end
-  
-  def add_feeds_by_uri(user = nil, uris = nil)
-    safe_add_feeds(Feed.create_tag_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(refresh_services = false)
-    all_feeds.find_all{ |feed| feed.service.photo?(refresh_services) rescue nil }
-  end
-  
-  # Get only video feeds
-  def video_feeds(refresh_services = false)
-    all_feeds.find_all{ |feed| feed.service.video?(refresh_services) rescue nil }
-  end
-  
-  # Get only bookmark feeds
-  def bookmark_feeds(refresh_services = false)
-    all_feeds.find_all{ |feed| feed.service.bookmark?(refresh_services) rescue nil }
-  end
-
-  # Get only music feeds
-  def music_feeds(refresh_services = false)
-    all_feeds.find_all{ |feed| feed.service.music?(refresh_services) rescue nil}
-  end
-
-  # Get only general feeds (exclude all specific feeds such as photos, videos, etc)
-  def general_feeds(refresh_services = false)
-    all_feeds.find_all{ |feed| feed.service.general?(refresh_services) rescue nil }
-  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

@@ -1,14 +0,0 @@
-# == Schema Information
-#
-# Table name: aggregation_feeds
-#
-#  id             :integer(4)      not null, primary key
-#  aggregation_id :integer(4)
-#  feed_id        :integer(4)
-#
-
-class AggregationFeed < ActiveRecord::Base
-  belongs_to :aggregation, :counter_cache => 'feed_count', :touch => true
-  belongs_to :feed
-  validates_uniqueness_of :feed_id, :scope => :aggregation_id
-end

data/app/models/attention.rb

@@ -1,14 +0,0 @@
-# == Schema Information
-#
-# Table name: attentions
-#
-#  id                 :integer(4)      not null, primary key
-#  attentionable_id   :integer(4)
-#  attentionable_type :string(255)
-#  entry_id           :integer(4)
-#  action_type        :string(255)
-#  weight             :float
-#
-
-class Attention < ActiveRecord::Base
-end

data/app/models/click.rb

@@ -1,14 +0,0 @@
-# == Schema Information
-#
-# Table name: clicks
-#
-#  id                :integer(4)      not null, primary key
-#  recommendation_id :integer(4)
-#  when              :datetime        not null
-#  referrer          :string(2083)
-#  requester         :string(255)
-#  user_agent        :string(2083)
-#
-
-class Click < ActiveRecord::Base
-end

data/app/models/entry.rb

@@ -1,341 +0,0 @@
-# == Schema Information
-#
-# Table name: entries
-#
-#  id                      :integer(4)      not null, primary key
-#  feed_id                 :integer(4)      not null
-#  permalink               :string(2083)    default(""), not null
-#  author                  :string(2083)
-#  title                   :text            default(""), not null
-#  description             :text
-#  content                 :text
-#  unique_content          :boolean(1)
-#  published_at            :datetime        not null
-#  entry_updated_at        :datetime
-#  harvested_at            :datetime
-#  oai_identifier          :string(2083)
-#  language_id             :integer(4)
-#  direct_link             :string(2083)
-#  indexed_at              :datetime        default(Fri Jan 01 01:01:01 UTC 1971), not null
-#  relevance_calculated_at :datetime        default(Fri Jan 01 01:01:01 UTC 1971), not null
-#  popular                 :text
-#  relevant                :text
-#  other                   :text
-#  grain_size              :string(255)     default("unknown")
-#
-# Indexes
-#
-#  index_entries_on_direct_link              (direct_link)
-#  index_entries_on_feed_id                  (feed_id)
-#  index_entries_on_indexed_at               (indexed_at)
-#  index_entries_on_language_id              (language_id)
-#  index_entries_on_oai_identifier           (oai_identifier)
-#  index_entries_on_permalink                (permalink)
-#  index_entries_on_published_at             (published_at)
-#  index_entries_on_relevance_calculated_at  (relevance_calculated_at)
-#  index_entries_on_grain_size               (grain_size)
-#
-
-class Entry < ActiveRecord::Base
-  
-  unloadable
-  
-  belongs_to :feed
-  belongs_to :language
-  has_many :activities, :as => :attachable, :dependent => :destroy
-  has_many :attentions, :dependent => :destroy
-  acts_as_commentable
-  acts_as_taggable
-  
-  @@default_time_on_page = 60.0
-  
-  acts_as_solr({:if => false, :fields => [{:feed_id => :integer}, {:grain_size => :string}]}, {:type_field => :type_s})
-
-  def resource_uri 
-    self.direct_link.nil? ? self.permalink : self.direct_link
-  end
-  
-  def self.top_tags(tags = nil)
-    
-  end
-  
-  def self.search(search_terms, grain_size = nil, language = "en", limit = 10, offset = 0, operator = :or)
-    raise MuckRaker::Exceptions::LanguageNotSupported, I18n.t('muck.raker.language_not_supported') unless Recommender::Languages.supported_languages.include?(language)
-    query = (!grain_size.nil? && grain_size != 'all') ? (search_terms + ") AND (grain_size:#{grain_size}") : search_terms
-    return find_by_solr(query, :limit => limit, :offset => offset, :scores => true, :select => "entries.id, entries.title, entries.permalink, entries.direct_link, entries.published_at, entries.description, entries.feed_id, feeds.short_title AS collection", :joins => "INNER JOIN feeds ON feeds.id = entries.feed_id", :core => language, :operator => operator)
-  end
-
-  def self.recommender_entry(uri)
-    uri = normalized_uri(uri)
-    Entry.find(:first, :conditions => ['permalink = ? OR direct_link = ?', uri, uri], :order => 'direct_link IS NULL DESC') || Entry.new(:permalink => uri)
-  end
-  
-  def recommendations(limit = 20, order = "relevance", details = false, omit_feeds = nil)
-    sql = "SELECT recommendations.id, dest_entry_id, entries.permalink, entries.title, entries.description, entries.direct_link, feeds.short_title AS collection "
-    sql << ", relevance_calculated_at, relevance, clicks, avg_time_at_dest AS avg_time_on_target, author, published_at " if details == true
-    sql << "FROM recommendations "
-    sql << "INNER JOIN entries ON recommendations.dest_entry_id = entries.id "
-    sql << "INNER JOIN feeds ON entries.feed_id = feeds.id "
-    sql << "WHERE recommendations.entry_id = ? "
-    sql << ("AND entries.feed_id NOT IN (" + omit_feeds.gsub(/[^0-9,]/,'') + ") ") if omit_feeds != nil
-    sql << "ORDER BY " + order + " DESC "
-    sql << "LIMIT " + limit.to_s
-    Entry.find_by_sql([sql,self.id])
-  end
-
-  def recommendation_entries(limit = 20, order = "relevance", details = false, omit_feeds = nil)
-    sql = "SELECT recommendations.dest_entry_id AS id, entries.permalink, entries.title, entries.description, entries.direct_link, feeds.short_title AS collection "
-    sql << ", relevance_calculated_at, relevance, clicks, avg_time_at_dest AS avg_time_on_target, author, published_at " if details == true
-    sql << "FROM recommendations "
-    sql << "INNER JOIN entries ON recommendations.dest_entry_id = entries.id "
-    sql << "INNER JOIN feeds ON entries.feed_id = feeds.id "
-    sql << "WHERE recommendations.entry_id = ? "
-    sql << ("AND entries.feed_id NOT IN (" + omit_feeds.gsub(/[^0-9,]/,'') + ") ") if omit_feeds != nil
-    sql << "ORDER BY " + order + " DESC "
-    sql << "LIMIT " + limit.to_s
-    Entry.find_by_sql([sql,self.id])
-  end
-
-  def self.track_time_on_page(session, uri)
-    recommendation_id = session[:last_clicked_recommendation]
-    if !recommendation_id.nil?
-      time_on_page = (Time.now - session[:last_clicked_recommendation_time].to_f).to_i
-      
-      # if they spend longer than two minutes on a page, we don't infer anything
-      if time_on_page > 5 and time_on_page < 120
-        if normalized_uri(uri) != session[:last_clicked_recommendation_uri] 
-          recommendation = Recommendation.find(recommendation_id)
-          entry = Entry.find(recommendation.entry_id)
-          new_avg = (recommendation.avg_time_at_dest*recommendation.clicks - @@default_time_on_page + time_on_page)/recommendation.clicks
-          recommendation.avg_time_at_dest = new_avg
-          recommendation.save!
-          entry.rank_recommendations
-          session[:last_clicked_recommendation] = nil
-        end
-      else
-        session[:last_clicked_recommendation] = nil if time_on_page > 5
-      end
-    end
-  end
-  
-  def self.avg_time(clicks, old_avg, time_on_page)
-    return (old_avg*(clicks-1) + time_on_page)/clicks
-  end
-
-  def self.track_click(session, recommendation_id, referrer, redirect_type = "direct_link", requester = "unknown", user_agent = "unknown")
-    # look up the recommendation
-    recommendation = Recommendation.find(recommendation_id)
-    return "" if !recommendation
-    
-    # get the entries being linked from and to
-    entry = Entry.find(recommendation.entry_id)
-    target = Entry.find(recommendation.dest_entry_id)
-    
-    # get the list of recommendations that have been clicked during this session
-    clicks = session[:rids] || Array.new
-    
-    # redirect to our frame page
-    redirect = "/visits/#{recommendation.dest_entry_id}"
-    
-    # track the time on the last page
-    track_time_on_page(session, redirect)
-    
-    # if this is first time the user clicked on this recommendation during this session 
-    if !clicks.include?(recommendation_id)
-      
-      # add this recommendation to the end of the list 
-      clicks << recommendation_id
-      session[:rids] = clicks
-      
-      # update the click time
-      recommendation.avg_time_at_dest = ((recommendation.avg_time_at_dest*recommendation.clicks) + @@default_time_on_page)/(recommendation.clicks + 1) 
-      recommendation.clicks += 1 
-      recommendation.save!
-      
-      # store info about this click in the session
-      now = Time.now
-      session[:last_clicked_recommendation] = recommendation_id
-      session[:last_clicked_recommendation_time] = now
-      session[:last_clicked_recommendation_uri] = redirect
-
-      # update the recommendation cache for the entry
-      entry.rank_recommendations if entry
-      
-      # track the click in the db
-      Click.create(:recommendation_id => recommendation_id, :when => now, :referrer => referrer, :requester => requester, :user_agent => user_agent)
-    end
-    
-    return redirect   
-  end
-
-  def relevant_recommendations(limit = 5, order = "relevance", details = false, omit_feeds = nil)
-    return self.recommendations(limit, order, details, omit_feeds)
-  end
-
-  def self.truncate_words(text, length = 30, end_string = ' ...')
-    words = text.split()
-    words[0..(length-1)].join(' ') + (words.length > length ? end_string : '')
-  end
-  
-  def ranked_recommendations(limit = 5, order = "mixed", details = false, omit_feeds = nil)
-#    if self.id.nil?
-#      return Entry.real_time_recommendations(self.permalink, details, :core => 'en', :limit => limit)
-#    else
-      return relevant_recommendations(limit, "clicks DESC, relevance", details, omit_feeds) if order == "clicks" 
-      return relevant_recommendations(limit, "relevance", details, omit_feeds) if (order == "relevance" || details == true)
-      return relevant_recommendations_filtered(limit, details, omit_feeds) if omit_feeds != nil 
-#    end
-
-    recs = []
-    if self.popular != nil && !self.popular.empty?
-      recs.concat(ActiveSupport::JSON.decode(self.popular).first(limit))
-    end
-    if recs.length < limit && self.relevant != nil && !self.relevant.empty?
-      relevant_recs = randomize(ActiveSupport::JSON.decode(self.relevant))
-      recs.concat(relevant_recs.first(limit - recs.length))
-    end
-    if recs.length < limit && self.relevant != nil && !self.other.empty?
-      other_recs = randomize(ActiveSupport::JSON.decode(self.other))
-      recs.concat(other_recs.first(limit - recs.length))
-    end
-    return recs
-  end
-  
-  def relevant_recommendations_filtered(limit, details, omit_feeds)
-    # get recommendations for the entry from the recommendations table
-    recs = self.recommendations(limit, "mixed", details, omit_feeds)
-    
-    # for storing the various lists
-    popular_recs = []
-    relevant_recs = []
-    other_recs = []
-
-    # see where to cut draw the lines for popular and relevant
-    click_threshold = calc_click_threshold(recs)
-    relevance_threshold = calc_relevance_threshold(recs)
-    
-    # store the recommendations
-    recs.each do |r|
-      if (r["clicks"].to_i > click_threshold)
-        popular_recs << r 
-      elsif (r["relevance"].to_f > relevance_threshold)
-        relevant_recs << r
-      else 
-        other_recs << r
-      end
-    end
-    
-    # order popular items strictly by clicks
-    popular_recs.sort{|r1,r2| r2["avg_time_on_target"].to_i <=> r1["avg_time_on_target"].to_i}
-    
-    return popular_recs[0..limit] if popular_recs.size > limit 
-    return (popular_recs + relevant_recs)[0..limit] if (popular_recs.size + relevant_recs.size) > limit
-    return (popular_recs + relevant_recs + other_recs)[0..limit]
-  end
-
-  def json_recommendations(limit = 5, order = "mixed", details = false, omit_feeds = nil)
-    ActiveSupport::JSON.encode(ranked_recommendations(limit, order, details, omit_feeds))
-  end
-  
-  def rank_recommendations
-    return
-    # get recommendations for the entry from the recommendations table
-    recs = self.recommendations
-    
-    # for storing the various lists
-    popular_recs = []
-    relevant_recs = []
-    other_recs = []
-
-    # see where to cut draw the lines for popular and relevant
-    click_threshold = calc_click_threshold(recs)
-    relevance_threshold = calc_relevance_threshold(recs)
-    
-    # store the recommendations
-    recs.each do |r|
-      if (r["clicks"].to_i > click_threshold)
-        popular_recs << r 
-      elsif (r["relevance"].to_f > relevance_threshold)
-        relevant_recs << r
-      else 
-        other_recs << r
-      end
-    end
-    
-    # order popular items strictly by clicks
-    popular_recs.sort{|r1,r2| r2["avg_time_on_target"].to_i <=> r1["avg_time_on_target"].to_i}
-    
-    # cache the JSON for the lists in the entry record
-    self.popular = ActiveSupport::JSON.encode(popular_recs)
-    self.relevant = ActiveSupport::JSON.encode(relevant_recs)
-    self.other = ActiveSupport::JSON.encode(other_recs)
-    self.save!
-  end
-  
-  def randomize(recs)
-    i = recs.length
-    return recs if (i == 0)
-    while (i > 0)
-      i = i - 1
-      j = (rand*(i+1)).floor
-      ti = recs[i]
-      tj =recs[j]
-      recs[i] = tj
-      recs[j] = ti
-    end
-    return recs
-  end
-
-  def calc_relevance_threshold(recs)
-    sum = 0
-    recs.each do |r|
-      sum += r["relevance"].to_f
-    end
-    average = sum/recs.length
-    sum = 0
-    recs.each do |r|
-      sum += (r["relevance"].to_f-average)**2
-    end
-    standard_deviation = Math.sqrt(sum/recs.length);
-    return average + standard_deviation
-  end
-  
-  def calc_click_threshold(recs)
-    sum = 0
-    recs.each do |r|
-      sum += r["clicks"].to_f
-    end
-    average = sum/recs.length
-    sum = 0
-    recs.each do |r|
-      sum += (r["clicks"].to_f-average)**2
-    end
-    standard_deviation = Math.sqrt(sum/recs.length);
-    threshold = average + standard_deviation
-    return threshold > 5 ? threshold : 5
-  end
-  
-  protected
-  
-#  def self.redirect_uri(target, referrer, redirect_type)
-#    if !target.direct_link.nil? and redirect_type != "metadata"
-#      return target.direct_link if redirect_type == "direct_link" 
-#      if !referrer.nil?
-#        domain = "http://" + URI.parse(referrer).host
-#        return target.direct_link if target.permalink[0..domain.length-1] != domain
-#      end
-#    end
-#    return target.permalink
-#  end
-
-  def self.normalized_uri(uri)
-    uri.sub(/index.?\.(html|aspx|shtm|htm|asp|php|cfm|jsp|shtml|jhtml)$/, '')
-  end
-  
-  def self.real_time_recommendations(uri, details = false, options = {})
-    fields = "entries.id, entries.title, entries.permalink, entries.direct_link, feeds.short_title AS collection"
-    fields << ", entries.published_at, entries.description, entries.author" if details == true 
-    more_like_this(uri, options.merge(:select => fields, :joins => "INNER JOIN feeds ON feeds.id = entries.feed_id"))
-  end
-
-end