typo 5.0.2 → 5.0.3.98

data/app/helpers/sidebar_helper.rb

@@ -1,6 +1,6 @@
 module SidebarHelper
   def render_sidebars(*sidebars)
-    (sidebars.blank? ? this_blog.sidebars : sidebars).inject('') do |acc, sb|
+    (sidebars.blank? ? Sidebar.find(:all, :order => 'active_position ASC') : sidebars).inject('') do |acc, sb|
       @sidebar = sb
       sb.parse_request(contents, params)
       controller.response.lifetime = sb.lifetime if sb.lifetime

data/app/models/article.rb

@@ -7,29 +7,34 @@ class Article < Content
   content_fields :body, :extended
 
   has_many :pings,      :dependent => :destroy, :order => "created_at ASC"
+
   has_many :comments,   :dependent => :destroy, :order => "created_at ASC"
   with_options(:conditions => { :published => true }, :order => 'created_at DESC') do |this|
     this.has_many :published_comments,   :class_name => "Comment", :order => "created_at ASC"
     this.has_many :published_trackbacks, :class_name => "Trackback", :order => "created_at ASC"
     this.has_many :published_feedback,   :class_name => "Feedback", :order => "created_at ASC"
   end
+
   has_many :trackbacks, :dependent => :destroy, :order => "created_at ASC"
+
   has_many :feedback,                           :order => "created_at DESC"
+
   has_many :resources, :order => "created_at DESC",
            :class_name => "Resource", :foreign_key => 'article_id'
-  
+  after_destroy :fix_resources
+
   has_many :categorizations
   has_many :categories, \
     :through => :categorizations, \
     :uniq => true, \
     :order => 'categorizations.is_primary DESC, categories.position'
-  
+
   has_and_belongs_to_many :tags, :foreign_key => 'article_id'
+
   belongs_to :user
-  has_many :triggers, :as => :pending_item
 
+  has_many :triggers, :as => :pending_item
   after_save :post_trigger
-  after_destroy :fix_resources
 
   has_state(:state,
             :valid_states  => [:new, :draft,
@@ -42,40 +47,50 @@ class Article < Content
                                :published_at=, :just_published?])
 
 
-  include States
+  include Article::States
 
-  def stripped_title
-    str = String.new(self.title)
-    
-    accents = { ['á','à','â','ä','ã','Ã','Ä','Â','À'] => 'a',
-      ['é','è','ê','ë','Ë','É','È','Ê'] => 'e',
-      ['í','ì','î','ï','I','Î','Ì'] => 'i',
-      ['ó','ò','ô','ö','õ','Õ','Ö','Ô','Ò'] => 'o',
-      ['œ'] => 'oe',
-      ['ß'] => 'ss',
-      ['ú','ù','û','ü','U','Û','Ù'] => 'u',
-      ['ç','Ç'] => 'c'
-      }
-    accents.each do |ac,rep|
-      ac.each do |s|
-        str.gsub!(s, rep)
-      end
+  class << self
+    def published_articles
+      find(:conditions => { :published => true }, :order => 'published_at DESC')
+    end
+
+    def count_published_articles
+      count(:conditions => { :published => true })
     end
-    
-    str.gsub(/<[^>]*>/,'').to_url
   end
-  
+
+  accents = { ['á','à','â','ä','ã','Ã','Ä','Â','À'] => 'a',
+    ['é','è','ê','ë','Ë','É','È','Ê'] => 'e',
+    ['í','ì','î','ï','I','Î','Ì'] => 'i',
+    ['ó','ò','ô','ö','õ','Õ','Ö','Ô','Ò'] => 'o',
+    ['œ'] => 'oe',
+    ['ß'] => 'ss',
+    ['ú','ù','û','ü','U','Û','Ù'] => 'u',
+    ['ç','Ç'] => 'c'
+  }
+
+  FROM, TO = accents.inject(['','']) { |o,(k,v)|
+    o[0] << k * '';
+    o[1] << v * k.size
+    o
+  }
+
+  def stripped_title
+    self.title.tr(FROM, TO).gsub(/<[^>]*>/, '').to_url
+  end
+
   def permalink_url_options(nesting = false)
-    {:year => published_at.year,
-     :month => sprintf("%.2d", published_at.month),
-     :day => sprintf("%.2d", published_at.day),
-     :controller => 'articles',
-     :action => 'show',
+    {:year                         => published_at.year,
+     :month                        => sprintf("%.2d", published_at.month),
+     :day                          => sprintf("%.2d", published_at.day),
+     :controller                   => 'articles',
+     :action                       => 'show',
      (nesting ? :article_id : :id) => permalink}
   end
 
   def permalink_url(anchor=nil, only_path=true)
     @cached_permalink_url ||= {}
+
     @cached_permalink_url["#{anchor}#{only_path}"] ||= \
       blog.with_options(permalink_url_options) do |b|
         b.url_for(:anchor => anchor, :only_path => only_path)
@@ -84,12 +99,15 @@ class Article < Content
 
   def param_array
     @param_array ||=
-      returning([published_at.year, sprintf('%.2d', published_at.month),
-                 sprintf('%.2d', published_at.day), permalink]) do |params|
-      this = self
-      k = class << params; self; end
-      k.send(:define_method, :to_s) { params[-1] }
-    end
+      returning([published_at.year,
+                 sprintf('%.2d', published_at.month),
+                 sprintf('%.2d', published_at.day),
+                 permalink]) \
+      do |params|
+        this = self
+        k = class << params; self; end
+        k.send(:define_method, :to_s) { params[-1] }
+      end
   end
 
   def to_param
@@ -153,34 +171,33 @@ class Article < Content
   end
 
   def next
-    blog.articles.find(:first, :conditions => ['published_at > ?', published_at],
-                       :order => 'published_at asc')
+    self.class.find(:first, :conditions => ['published_at > ?', published_at],
+                    :order => 'published_at asc')
   end
 
   def previous
-    blog.articles.find(:first, :conditions => ['published_at < ?', published_at],
-                       :order => 'published_at desc')
+    self.class.find(:first, :conditions => ['published_at < ?', published_at],
+                    :order => 'published_at desc')
   end
 
   # Count articles on a certain date
   def self.count_by_date(year, month = nil, day = nil, limit = nil)
     if !year.blank?
-      from, to = self.time_delta(year, month, day)
-      Article.count(["published_at BETWEEN ? AND ? AND published = ?",
-                     from, to, true])
+      count(:conditions => { :published_at => time_delta(year, month, day),
+              :published => true })
     else
-      Article.count(:conditions => { :published => true })
+      count(:conditions => { :published => true })
     end
   end
 
   # Find all articles on a certain date
   def self.find_all_by_date(year, month = nil, day = nil)
     if !year.blank?
-      from, to = self.time_delta(year, month, day)
-      Article.find_published(:all, :conditions => ["published_at BETWEEN ? AND ?",
-                                                   from, to])
+      find_published(:all,
+                     :conditions => { :published_at =>
+                       time_delta(year,month,day) })
     else
-      Article.find_published(:all)
+      find_published(:all)
     end
   end
 
@@ -190,6 +207,10 @@ class Article < Content
     find_all_by_date(year, month, day).first
   end
 
+  def self.find_by_published_at
+    super(:published_at)
+  end
+
   def self.date_from(params_hash)
     params_hash[:article_year] \
       ? params_hash.values_at(:article_year, :article_month, :article_day, :article_id) \
@@ -206,15 +227,11 @@ class Article < Content
         year, month, day, title = year
       end
     end
-    from, to = self.time_delta(year, month, day)
-    returning(find_published(:first,
-                             :conditions => ['permalink = ? AND ' +
-                                             'published_at BETWEEN ? AND ?',
-                                             title, from, to ])) do |res|
-      if res.nil?
-        raise ActiveRecord::RecordNotFound
-      end
-    end
+    date_range = self.time_delta(year, month, day)
+    find_published(:first,
+                   :conditions => { :permalink => title,
+                                    :published_at => date_range }) \
+      or raise ActiveRecord::RecordNotFound
   end
 
   def self.find_by_params_hash(params = {})
@@ -258,14 +275,6 @@ class Article < Content
     end
   end
 
-  def notify_user_via_jabber(user)
-    if user.notify_via_jabber?
-      JabberNotify.send_message(user, _("New post"),
-                                _("A new message was posted to ") +  blog.blog_name,
-                                html(:body))
-    end
-  end
-
   def comments_closed?
     !(allow_comments? && in_feedback_window?)
   end
@@ -403,16 +412,20 @@ class Article < Content
   end
 
   def atom_content(xml)
-    xml.summary html(:body), "type" => "html"
+    xml.summary "type" => "xhtml" do
+      xml.div(:xmlns => "http://www.w3.org/1999/xhtml") {xml << html(:body) }
+    end
     if blog.show_extended_on_rss
-      xml.content html(:all), "type" => "html"
+      xml.content(:type => "xhtml") do
+        xml.div(:xmlns => 'http://www.w3.org/1999/xhtml') { xml << html(:all) }
+      end
     end
   end
 
   def add_comment(params)
     comments.build(params)
   end
-  
+
   def add_category(category, is_primary = false)
     self.categorizations.build(:category => category, :is_primary => is_primary)
   end
@@ -458,7 +471,7 @@ class Article < Content
     to = from.next_month unless month.blank?
     to = from + 1.day unless day.blank?
     to = to - 1 # pull off 1 second so we don't overlap onto the next day
-    return [from, to]
+    return from..to
   end
 
   validates_uniqueness_of :guid

data/app/models/blog.rb

@@ -18,36 +18,11 @@ end
 class Blog < CachedModel
   include ConfigManager
 
-  has_many :contents
-  has_many :trackbacks
-  has_many :articles
-  has_many :comments
-  has_many(:published_comments,
-           :class_name => 'Comment',
-           :conditions => {:published => true},
-           :order      => 'feedback.published_at DESC')
-  has_many(:published_trackbacks,
-           :class_name => 'Trackback',
-           :conditions => {:published => true},
-           :order      => 'feedback.published_at DESC')
-  has_many(:published_feedback,
-           :class_name => 'Feedback',
-           :conditions => {:published => true},
-           :order      => 'feedback.published_at DESC')
-  has_many(:pages,
-           :order      => "id DESC")
-  has_many(:published_articles,
-           :class_name => "Article",
-           :conditions => {:published => true},
-           :include    => [:categories, :tags],
-           :order      => "contents.published_at DESC") do
-    def before(date = Time.now)
-      find(:all, :conditions => ["contents.created_at < ?", date])
+  validate_on_create { |blog|
+    unless Blog.count.zero?
+      blog.errors.add_to_base("There can only be one...")
     end
-  end
-
-  has_many :pages
-  has_many :sidebars, :order => 'active_position ASC'
+  }
 
   serialize :settings, Hash
 
@@ -58,7 +33,6 @@ class Blog < CachedModel
   setting :geourl_location,            :string, ''
   setting :canonical_server_url,       :string, ''  # Deprecated
   setting :lang,                       :string, 'en_US'
-  setting :display_advanced,           :integer, 0
 
   # Spam
   setting :sp_global,                  :boolean, false
@@ -87,18 +61,14 @@ class Blog < CachedModel
   setting :default_moderate_comments,  :boolean, false
   setting :link_to_author,             :boolean, false
   setting :show_extended_on_rss,       :boolean, true
-  setting :theme,                      :string, 'standard_issue'
+  setting :theme,                      :string, 'typographic'
   setting :use_gravatar,               :boolean, false
   setting :global_pings_disable,       :boolean, false
-  setting :ping_urls,                  :string, "http://rpc.technorati.com/rpc/ping\nhttp://ping.blo.gs/\nhttp://rpc.weblogs.com/RPC2"
+  setting :ping_urls,                  :string, "http://blogsearch.google.com/ping/RPC2\nhttp://rpc.technorati.com/rpc/ping\nhttp://ping.blo.gs/\nhttp://rpc.weblogs.com/RPC2"
   setting :send_outbound_pings,        :boolean, true
   setting :email_from,                 :string, 'typo@example.com'
-  setting :editor,                     :integer, 1
-  setting :cache_option,               :string, 'caches_action_with_params'
-
-  # Jabber config
-  setting :jabber_address,             :string, ''
-  setting :jabber_password,            :string, ''
+  setting :editor,                     :integer, 2
+  setting :cache_option,               :string, 'caches_page'
 
   #deprecation warning for plugins removal
   setting :deprecation_warning,        :integer, 1
@@ -117,7 +87,7 @@ class Blog < CachedModel
   # that matches, then grab the default blog.  If *that* fails, then create a new
   # Blog.  The last case should only be used when Typo is first installed.
   def self.find_blog(base_url)
-    (Blog.find_by_base_url(base_url) rescue nil)|| Blog.default || Blog.new
+    Blog.default || Blog.create
   end
 
   # The default Blog.  This is the lowest-numbered blog, almost always id==1.
@@ -162,7 +132,7 @@ class Blog < CachedModel
     when String then options # They asked for 'url_for "/some/path"', so return it unedited.
     when Hash
       unless RouteCache[options]
-        options.reverse_merge!(:only_path => true, :controller => '/articles',
+        options.reverse_merge!(:only_path => true, :controller => '',
                                :action => 'permalink')
         @url ||= ActionController::UrlRewriter.new(BlogRequest.new(self.base_url), {})
         RouteCache[options] = @url.rewrite(options)
@@ -204,7 +174,7 @@ class Blog < CachedModel
 
   def find_already_published(content_type)  # :nodoc:
     typo_deprecated "Use #{content_type}.find_already_published"
-    self.send(content_type).find_already_published
+    content_type.to_s.camelize.constantize.find_already_published
   end
 
   def current_theme_path  # :nodoc:
@@ -213,15 +183,15 @@ class Blog < CachedModel
   end
 
   def requested_article(params)
-    published_articles.find_by_params_hash(params)
+    Article.find_by_params_hash(params)
   end
 
   def requested_articles(params)
-    published_articles.find_all_by_date(*params.values_at(:year, :month, :day))
+    Article.find_all_by_date(*params.values_at(:year, :month, :day))
   end
 
   def articles_matching(query)
-    published_articles.search(query)
+    Article.search(query)
   end
 
   def rss_limit_params

data/app/models/blog_sweeper.rb

@@ -1,6 +1,17 @@
 class BlogSweeper < ActionController::Caching::Sweeper
   observe Category, Blog, Sidebar, User, Article, Page, Categorization
 
+  def pending_sweeps
+    @pending_sweeps ||= Set.new
+  end
+
+  def run_pending_page_sweeps
+    logger.debug "Running pending page_sweeps: #{pending_sweeps.to_a.inspect}"
+    pending_sweeps.each do |each|
+      self.send(each)
+    end
+  end
+
   def after_comments_create
     logger.debug 'BlogSweeper#after_comments_create'
     expire_for(controller.send(:instance_variable_get, :@comment))
@@ -39,24 +50,24 @@ class BlogSweeper < ActionController::Caching::Sweeper
   def expire_for(record, destroying = false)
     case record
     when Page
-      sweep_pages(record)
+      pending_sweeps << :sweep_pages
     when Content
       if record.invalidates_cache?(destroying)
-        sweep_articles
-        sweep_pages
+        pending_sweeps << :sweep_articles << :sweep_pages
       end
     when Sidebar, Category, Categorization
-      sweep_articles
-      sweep_pages
+      pending_sweeps << :sweep_articles << :sweep_pages
     when Blog, User
-      sweep_all
-      sweep_theme
+      pending_sweeps << :sweep_all << :sweep_theme
+    end
+    unless controller
+      run_pending_page_sweeps
     end
   end
 
   def sweep_all
-    expire_fragment(/.*/)
     PageCache.sweep_all
+    expire_fragment(/.*/)
   end
 
   def sweep_theme
@@ -66,11 +77,12 @@ class BlogSweeper < ActionController::Caching::Sweeper
   def sweep_articles
     expire_fragment(%r{.*/articles/.*})
     unless Blog.default && Blog.default.cache_option == "caches_action_with_params"
-      PageCache.zap_pages('index.*', 'articles')
+      PageCache.zap_pages %w{index.* articles.* articles feedback
+                             comments comments.* categories categories.* tags tags.* }
     end
   end
 
-  def sweep_pages(record = nil)
+  def sweep_pages
     expire_fragment(/.*\/pages\/.*/)
     expire_fragment(/.*\/view_page.*/)
     unless Blog.default && Blog.default.cache_option == "caches_action_with_params"
@@ -81,4 +93,12 @@ class BlogSweeper < ActionController::Caching::Sweeper
   def logger
     @logger ||= RAILS_DEFAULT_LOGGER || Logger.new(STDERR)
   end
+
+  private
+  def callback(timing)
+    super
+    if timing == :after
+      run_pending_page_sweeps
+    end
+  end
 end