typo 4.0.3 → 4.1

data/app/models/article.rb

@@ -6,12 +6,17 @@ class Article < Content
 
   content_fields :body, :extended
 
-  has_many :pings, :dependent => true, :order => "created_at ASC"
-  has_many :comments, :dependent => true, :order => "created_at ASC"
-  has_many :trackbacks, :dependent => true, :order => "created_at ASC"
+  has_many :pings,      :dependent => :destroy, :order => "created_at ASC"
+  has_many :comments,   :dependent => :destroy, :order => "created_at ASC"
+  has_many :trackbacks, :dependent => :destroy, :order => "created_at ASC"
   has_many :resources, :order => "created_at DESC",
            :class_name => "Resource", :foreign_key => 'article_id'
-  has_and_belongs_to_many :categories, :foreign_key => 'article_id'
+  has_many :categorizations
+  has_many :categories, :through => :categorizations, :uniq => true do
+    def push_with_attributes(cat, join_attrs = { :is_primary => false })
+      Categorization.with_scope(:create => join_attrs) { self << cat }
+    end
+  end
   has_and_belongs_to_many :tags, :foreign_key => 'article_id'
   belongs_to :user
   has_many :triggers, :as => :pending_item
@@ -22,27 +27,50 @@ class Article < Content
     self.title.gsub(/<[^>]*>/,'').to_url
   end
 
-  def location(anchor=nil, only_path=true)
-    blog.article_url(self, only_path, anchor)
+  def permalink_url(anchor=nil, only_path=true)
+    @cached_permalink_url ||= {}
+    @cached_permalink_url["#{anchor}#{only_path}"] ||= blog.url_for(
+      :year => published_at.year,
+      :month => sprintf("%.2d", published_at.month),
+      :day => sprintf("%.2d", published_at.day),
+      :title => permalink,
+      :anchor => anchor,
+      :only_path => only_path,
+      :controller => '/articles'
+    )
+  end
+
+  def trackback_url
+    blog.url_for(:controller => "articles", :action =>"trackback", :id => id)
+  end
+
+  def feed_url(format = :rss20)
+    blog.url_for(:controller => 'xml', :action => 'feed', :type => 'article', :format => format, :id => id)
+  end
+
+  def edit_url
+    blog.url_for(:controller => "/admin/content", :action =>"edit", :id => id)
+  end
+
+  def delete_url
+    blog.url_for(:controller => "/admin/content", :action =>"destroy", :id => id)
   end
 
   def html_urls
     urls = Array.new
-    (body_html.to_s + extended_html.to_s).gsub(/<a [^>]*>/) do |tag|
+    html.gsub(/<a [^>]*>/) do |tag|
       if(tag =~ /href="([^"]+)"/)
         urls.push($1)
       end
     end
 
-    urls
+    urls.uniq
   end
 
-  def really_send_pings(serverurl = blog.server_url, articleurl = nil)
+  def really_send_pings(serverurl = blog.base_url, articleurl = nil)
     return unless blog.send_outbound_pings
 
-    # Moved the default value for articleurl out of the method declaration to
-    # avoid unnecessary evaluations of the #location() method.
-    articleurl ||= location(nil, false)
+    articleurl ||= permalink_url(nil, false)
 
     weblogupdatesping_urls = blog.ping_urls.gsub(/ +/,'').split(/[\n\r]+/)
     pingback_or_trackback_urls = self.html_urls
@@ -73,13 +101,13 @@ class Article < Content
   end
 
   def next
-    Article.find(:first, :conditions => ['published_at > ?', published_at],
-                 :order => 'published_at asc')
+    blog.articles.find(:first, :conditions => ['published_at > ?', published_at],
+                       :order => 'published_at asc')
   end
 
   def previous
-    Article.find(:first, :conditions => ['published_at < ?', published_at],
-                 :order => 'published_at desc')
+    blog.articles.find(:first, :conditions => ['published_at < ?', published_at],
+                       :order => 'published_at desc')
   end
 
   # Count articles on a certain date
@@ -137,17 +165,17 @@ class Article < Content
     User.find_boolean(:all, :notify_on_new_articles)
   end
 
-  def notify_user_via_email(controller, user)
+  def notify_user_via_email(user)
     if user.notify_via_email?
-      EmailNotify.send_article(controller, self, user)
+      EmailNotify.send_article(self, user)
     end
   end
 
-  def notify_user_via_jabber(controller, user)
+  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}",
-                                body_html)
+                                html(:body))
     end
   end
 
@@ -171,11 +199,52 @@ class Article < Content
     trackbacks.select {|c| c.published?}
   end
 
+  # Bloody rails reloading. Nasty workaround.
+  def body=(newval)
+    if self[:body] != newval
+      changed
+      self[:body] = newval
+    end
+    self[:body]
+  end
+
+  def body_html
+    typo_deprecated "Use html(:body)"
+    html(:body)
+  end
+
+  def extended=(newval)
+    if self[:extended] != newval
+      changed
+      self[:extended] = newval
+    end
+    self[:extended]
+  end
+
+  def extended_html
+    typo_deprecated "Use html(:extended)"
+    html(:extended)
+  end
+
+  def self.html_map(field=nil)
+    html_map = { :body => true, :extended => true }
+    if field
+      html_map[field.to_sym]
+    else
+      html_map
+    end
+  end
+
+  def content_fields
+    [:body, :extended]
+  end
+
   protected
 
-  before_create :set_defaults, :create_guid, :add_notifications
+  before_create :set_defaults, :create_guid
   before_save :set_published_at
   after_save :keywords_to_tags
+  after_create :add_notifications
 
   def set_published_at
     if self.published and self[:published_at].nil?
@@ -199,20 +268,11 @@ class Article < Content
   end
 
   def add_notifications
-    # Grr, how do I do :conditions => 'notify_on_new_articles = true' when on MySQL boolean DB tables
-    # are integers, Postgres booleans are booleans, and sqlite is basically just a string?
-    #
-    # I'm punting for now and doing the test in Ruby.  Feel free to rewrite.
-
     self.notify_users = User.find_boolean(:all, :notify_on_new_articles)
     self.notify_users << self.user if (self.user.notify_watch_my_articles? rescue false)
     self.notify_users.uniq!
   end
 
-  def default_text_filter_config_key
-    'text_filter'
-  end
-
   def self.time_delta(year, month = nil, day = nil)
     from = Time.mktime(year, month || 1, day || 1)
 
@@ -224,8 +284,6 @@ class Article < Content
   end
 
   def find_published(what = :all, options = {})
-    options[:include] ||= []
-    options[:include] += [:user]
     super(what, options)
   end
 

data/app/models/blog.rb

@@ -1,7 +1,5 @@
 # BlogRequest is a fake Request object, created so blog.url_for will work.
-# This isn't enabled yet, but it will be soon...
 class BlogRequest
-  include Reloadable
 
   attr_accessor :protocol, :host_with_port, :path, :symbolized_path_parameters, :relative_url_root
 
@@ -12,7 +10,12 @@ class BlogRequest
   end
 end
 
-class Blog < ActiveRecord::Base
+# The Blog class represents one blog.  It stores most configuration settings
+# and is linked to most of the assorted content classes via has_many.
+#
+# Typo decides which Blog object to use by searching for a Blog base_url that
+# matches the base_url computed for each request.
+class Blog < CachedModel
   include ConfigManager
 
   has_many :contents
@@ -21,9 +24,9 @@ class Blog < ActiveRecord::Base
   has_many :comments
   has_many :pages, :order => "id DESC"
   has_many(:published_articles, :class_name => "Article",
-           :conditions => ["published = ?", true],
+           :conditions => {:published => true},
            :include => [:categories, :tags],
-           :order => "contents.created_at DESC") do
+           :order => "contents.published_at DESC") do
     def before(date = Time.now)
       find(:all, :conditions => ["contents.created_at < ?", date])
     end
@@ -31,15 +34,16 @@ class Blog < ActiveRecord::Base
 
   has_many :pages
   has_many :comments
+  has_many :sidebars, :order => 'active_position ASC'
 
   serialize :settings, Hash
 
   # Description
   setting :blog_name,                  :string, 'My Shiny Weblog!'
   setting :blog_subtitle,              :string, ''
-  setting :title_prefix,               :boolean, false
+  setting :title_prefix,               :integer, 0
   setting :geourl_location,            :string, ''
-  setting :canonical_server_url,       :string, ''
+  setting :canonical_server_url,       :string, ''  # Deprecated
 
   # Spam
   setting :sp_global,                  :boolean, false
@@ -65,6 +69,7 @@ class Blog < ActiveRecord::Base
   setting :limit_rss_display,          :integer, 10
   setting :default_allow_pings,        :boolean, false
   setting :default_allow_comments,     :boolean, true
+  setting :default_moderate_comments,  :boolean, false
   setting :link_to_author,             :boolean, false
   setting :show_extended_on_rss,       :boolean, true
   setting :theme,                      :string, 'azure'
@@ -78,8 +83,26 @@ class Blog < ActiveRecord::Base
   setting :jabber_address,             :string, ''
   setting :jabber_password,            :string, ''
 
-  def find_already_published(content_type)
-    self.send(content_type).find_already_published
+  def initialize(*args)
+    super
+    # Yes, this is weird - PDC
+    begin
+      self.settings ||= {}
+    rescue Exception => e
+      self.settings = {}
+    end
+  end
+
+  # Find the Blog that matches a specific base URL.  If no Blog object is found
+  # 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
+  end
+
+  # The default Blog.  This is the lowest-numbered blog, almost always id==1.
+  def self.default
+    find(:first, :order => 'id')
   end
 
   def ping_article!(settings)
@@ -89,93 +112,78 @@ class Blog < ActiveRecord::Base
     trackback = published_articles.find(article_id).trackbacks.create!(settings)
   end
 
-
+  # Check that all required blog settings have a value.
   def is_ok?
     settings.has_key?('blog_name')
   end
 
-  def [](key)
-    self.send(key)
-  end
-
-  def []=(key, value)
-    self.send("#{key}=", value)
-  end
-
-  def has_key?(key)
-    self.class.fields.has_key?(key.to_s)
-  end
-
-  def initialize(*args)
-    super
-    self.settings ||= { }
-  end
-
-  def self.default
-    find(:first, :order => 'id')
-  end
-
-  @@controller_stack = []
-  cattr_accessor :controller_stack
-
-  def self.before(controller)
-    controller_stack << controller
+  # The +Theme+ object for the current theme.
+  def current_theme
+    @cached_theme ||= Theme.find(theme)
   end
 
-  def self.after(controller)
-    unless controller_stack.last == controller
-      raise "Controller stack got out of kilter!"
+  # Generate a URL based on the +base_url+.  This allows us to generate URLs
+  # without needing a controller handy, so we can produce URLs from within models
+  # where appropriate.
+  #
+  # It also uses our new RouteCache, so repeated URL generation requests should be
+  # fast, as they bypass all of Rails' route logic.
+  def url_for(options = {}, *extra_params)
+    case options
+    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',
+                               :action => 'permalink')
+        @url ||= ActionController::UrlRewriter.new(BlogRequest.new(self.base_url), {})
+        RouteCache[options] = @url.rewrite(options)
+      end
+
+      return RouteCache[options]
+    else
+      raise "Invalid URL in url_for: #{options.inspect}"
     end
-    controller_stack.pop
   end
 
-  def controller
-    controller_stack.last
+  # The URL for a static file.
+  def file_url(filename)
+    "#{base_url}/files/#{filename}"
   end
 
-  def current_theme_path
-    Theme.themes_root + "/" + theme
+  # The base server URL.
+  def server_url
+    base_url
   end
 
-  def current_theme
-    Theme.theme_from_path(current_theme_path)
+  # Deprecated
+  def canonical_server_url
+    typo_deprecated "Use base_url instead"
+    base_url
   end
 
-  def url_for(options = {}, *extra_params)
-    case options
-    when String then options
-    when Hash
-      options.reverse_merge!(:only_path => true, :controller => '/articles',
-                             :action => 'permalink')
-      url = ActionController::UrlRewriter.new(request, {})
-      url.rewrite(options)
-    else
-      options.location(*extra_params)
-    end
+  def [](key)  # :nodoc:
+    typo_deprecated "Use blog.#{key}"
+    self.send(key)
   end
 
-  def article_url(article, only_path = true, anchor = nil)
-    url_for(:year => article.published_at.year,
-            :month => sprintf("%.2d", article.published_at.month),
-            :day => sprintf("%.2d", article.published_at.day),
-            :title => article.permalink, :anchor => anchor,
-            :only_path => only_path,
-            :controller => '/articles')
+  def []=(key, value)  # :nodoc:
+    typo_deprecated "Use blog.#{key}="
+    self.send("#{key}=", value)
   end
 
-  def server_url
-    if controller
-      controller.send :url_for, :only_path => false, :controller => "/articles"
-    else
-      settings[:canonical_server_url]
-    end
+  def has_key?(key)  # :nodoc:
+    typo_deprecated "Why?"
+    self.class.fields.has_key?(key.to_s)
   end
 
-  private
+  def find_already_published(content_type)  # :nodoc:
+    typo_deprecated "Use #{content_type}.find_already_published"
+    self.send(content_type).find_already_published
+  end
 
-  def request
-    #BlogRequest.new(self.canonical_server_url)
-    controller.request rescue ActionController::TestRequest.new
+  def current_theme_path  # :nodoc:
+    typo_deprecated "use current_theme.path"
+    Theme.themes_root + "/" + theme
   end
 end
 

data/app/models/blog_sweeper.rb

@@ -1,23 +1,48 @@
 class BlogSweeper < ActionController::Caching::Sweeper
-  observe Article, Category, Comment, Trackback, Page, Blog, Sidebar, User
+  observe Article, Category, Feedback, Page, Blog, Sidebar, User
 
   def after_save(record)
+    logger.info "Expiring #{record}, with controller: #{controller}"
     expire_for(record)
   end
 
   def after_destroy(record)
-    expire_for(record)
+    expire_for(record, true)
   end
 
-  def expire_for(record)
+  def expire_for(record, destroying = false)
     case record
-    when Blog, Sidebar, Category, Comment, Trackback, Article, User
-      PageCache.sweep_all
-      expire_fragment(/.*/)
     when Page
-      PageCache.sweep("/pages/#{record.name}.html")
+      sweep_pages(record)
+    when Content
+      if record.invalidates_cache?(destroying)
+        sweep_all
+      end
+    when Sidebar, Category
+      sweep_articles
+      sweep_pages(record)
+    when Blog, User
+      sweep_all
+    end
+  end
+
+  def sweep_all
+    PageCache.sweep_all
+    expire_fragment(/.*/)
+  end
+
+  def sweep_articles
+    PageCache.sweep('/articles/%')
+    expire_fragment(%r{.*/articles/.*})
+  end
+
+  def sweep_pages(record)
+      PageCache.sweep("/pages/#{record.name rescue ''}.html")
       expire_fragment(/.*\/pages\/.*/)
       expire_fragment(/.*\/view_page.*/)
-    end
+  end
+
+  def logger
+    @logger ||= RAILS_DEFAULT_LOGGER || Logger.new(STDERR)
   end
 end