typo 3.99.0

data/app/models/article.rb

@@ -0,0 +1,211 @@
+require 'uri'
+require 'net/http'
+
+class Article < Content
+  include TypoGuid
+
+  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 :resources, :order => "created_at DESC",
+           :class_name => "Resource", :foreign_key => 'article_id'
+  has_and_belongs_to_many :categories, :foreign_key => 'article_id'
+  has_and_belongs_to_many :tags, :foreign_key => 'article_id'
+  belongs_to :user
+  has_many :triggers, :as => :pending_item
+
+  after_destroy :fix_resources
+
+  def stripped_title
+    self.title.gsub(/<[^>]*>/,'').to_url
+  end
+
+  def location(anchor=nil, only_path=true)
+    blog.article_url(self, only_path, anchor)
+  end
+
+  def html_urls
+    urls = Array.new
+    (body_html.to_s + extended_html.to_s).gsub(/<a [^>]*>/) do |tag|
+      if(tag =~ /href="([^"]+)"/)
+        urls.push($1)
+      end
+    end
+
+    urls
+  end
+
+  def really_send_pings(serverurl = blog.server_url, articleurl = location(nil, false))
+    return unless blog.send_outbound_pings
+
+    weblogupdatesping_urls = blog.ping_urls.gsub(/ +/,'').split(/[\n\r]+/)
+    pingback_or_trackback_urls = self.html_urls
+
+    ping_urls = weblogupdatesping_urls + pingback_or_trackback_urls
+
+    ping_urls.uniq.each do |url|
+      begin
+        unless pings.collect { |p| p.url }.include?(url.strip)
+          ping = pings.build("url" => url)
+
+          if weblogupdatesping_urls.include?(url)
+            ping.send_weblogupdatesping(serverurl, articleurl)
+          else pingback_or_trackback_urls.include?(url)
+            ping.send_pingback_or_trackback(articleurl)
+          end
+        end
+      rescue
+        # in case the remote server doesn't respond or gives an error,
+        # we should throw an xmlrpc error here.
+      end
+    end
+  end
+
+  def send_pings
+    state.send_pings(self)
+  end
+
+  def next
+    Article.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')
+  end
+
+  # Count articles on a certain date
+  def self.count_by_date(year, month = nil, day = nil, limit = nil)
+    from, to = self.time_delta(year, month, day)
+    Article.count(["published_at BETWEEN ? AND ? AND published = ?",
+                   from, to, true])
+  end
+
+  # Find all articles on a certain date
+  def self.find_all_by_date(year, month = nil, day = nil)
+    from, to = self.time_delta(year, month, day)
+    Article.find_published(:all, :conditions => ["published_at BETWEEN ? AND ?",
+                                                 from, to])
+  end
+
+  # Find one article on a certain date
+
+  def self.find_by_date(year, month, day)
+    find_all_by_date(year, month, day).first
+  end
+
+  # Finds one article which was posted on a certain date and matches the supplied dashed-title
+  def self.find_by_permalink(year, month, day, title)
+    from, to = self.time_delta(year, month, day)
+    find_published(:first,
+                   :conditions => ['permalink = ? AND ' +
+                                   'published_at BETWEEN ? AND ?',
+                                   title, from, to ])
+  end
+
+  # Fulltext searches the body of published articles
+  def self.search(query)
+    if !query.to_s.strip.empty?
+      tokens = query.split.collect {|c| "%#{c.downcase}%"}
+      find_published(:all,
+                     :conditions => [(["(LOWER(body) LIKE ? OR LOWER(extended) LIKE ? OR LOWER(title) LIKE ?)"] * tokens.size).join(" AND "), *tokens.collect { |token| [token] * 3 }.flatten])
+    else
+      []
+    end
+  end
+
+  def keywords_to_tags
+    Article.transaction do
+      tags.clear
+      keywords.to_s.scan(/((['"]).*?\2|\w+)/).collect do |x|
+        x.first.tr("\"'", '')
+      end.uniq.each do |tagword|
+        tags << Tag.get(tagword)
+      end
+    end
+  end
+
+  def interested_users
+    User.find_boolean(:all, :notify_on_new_articles)
+  end
+
+  def notify_user_via_email(controller, user)
+    if user.notify_via_email?
+      EmailNotify.send_article(controller, self, user)
+    end
+  end
+
+  def notify_user_via_jabber(controller, user)
+    if user.notify_via_jabber?
+      JabberNotify.send_message(user, "New post",
+                                "A new message was posted to #{blog.blog_name}",
+                                content.body_html)
+    end
+  end
+
+  protected
+
+  before_create :set_defaults, :create_guid, :add_notifications
+  after_save :keywords_to_tags
+
+  def correct_counts
+    self.comments_count = self.comments_count
+    self.trackbacks_count = self.trackbacks_count
+  end
+
+  def set_defaults
+    if self.attributes.include?("permalink") and self.permalink.blank?
+      self.permalink = self.stripped_title
+    end
+    correct_counts
+    if blog && self.allow_comments.nil?
+      self.allow_comments = blog.default_allow_comments
+    end
+
+    if blog && self.allow_pings.nil?
+      self.allow_pings = blog.default_allow_pings
+    end
+    true
+  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)
+
+    to = from.next_year
+    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]
+  end
+
+
+  validates_uniqueness_of :guid
+  validates_presence_of :title
+
+  private
+
+  def fix_resources
+    Resource.find(:all, :conditions => "article_id = #{id}").each do |fu|
+      fu.article_id = nil
+      fu.save
+    end
+  end
+end

data/app/models/blacklist_pattern.rb

@@ -0,0 +1,22 @@
+class BlacklistPattern < ActiveRecord::Base
+end
+
+class RegexPattern < BlacklistPattern
+  def matches?(string)
+    string.match(/#{pattern}/)
+  end
+
+  def to_s
+    "Regex /#{pattern}/"
+  end
+end
+
+class StringPattern < BlacklistPattern
+  def matches?(string)
+    string.match(/\b#{Regexp.quote(pattern)}\b/)
+  end
+
+  def to_s
+    "String '#{pattern}'"
+  end
+end

data/app/models/blog.rb

@@ -0,0 +1,162 @@
+class Blog < ActiveRecord::Base
+  include ConfigManager
+
+  has_many :contents
+  has_many :trackbacks
+  has_many :articles
+  has_many :comments
+  has_many :pages, :order => "id DESC"
+  has_many(:published_articles, :class_name => "Article",
+           :conditions => ["published = ?", true],
+           :include => [:categories, :tags],
+           :order => "contents.created_at DESC") do
+    def before(date = Time.now)
+      find(:all, :conditions => ["contents.created_at < ?", date])
+    end
+  end
+
+  has_many :pages
+  has_many :comments
+
+  serialize :settings, Hash
+
+  # Description
+  setting :blog_name,                  :string, 'My Shiny Weblog!'
+  setting :blog_subtitle,              :string, ''
+  setting :geourl_location,            :string, ''
+  setting :canonical_server_url,       :string, ''
+
+  # Spam
+  setting :sp_global,                  :boolean, false
+  setting :sp_article_auto_close,      :integer, 0
+  setting :sp_allow_non_ajax_comments, :boolean, true
+  setting :sp_url_limit,               :integer, 0
+
+  # Podcasting
+  setting :itunes_explicit,            :boolean, false
+  setting :itunes_author,              :string, ''
+  setting :itunes_subtitle,            :string, ''
+  setting :itunes_summary,             :string, ''
+  setting :itunes_owner,               :string, ''
+  setting :itunes_email,               :string, ''
+  setting :itunes_name,                :string, ''
+  setting :itunes_copyright,           :string, ''
+
+  # Mostly Behaviour
+  setting :text_filter,                :string, ''
+  setting :comment_text_filter,        :string, ''
+  setting :limit_article_display,      :integer, 10
+  setting :limit_rss_display,          :integer, 10
+  setting :default_allow_pings,        :boolean, false
+  setting :default_allow_comments,     :boolean, true
+  setting :link_to_author,             :boolean, false
+  setting :show_extended_on_rss,       :boolean, true
+  setting :theme,                      :string, 'azure'
+  setting :use_gravatar,               :boolean, false
+  setting :ping_urls,                  :string, "http://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'
+
+  # Jabber config
+  setting :jabber_address,             :string, ''
+  setting :jabber_password,            :string, ''
+
+  def find_already_published(content_type)
+    self.send(content_type).find_already_published
+  end
+
+  def ping_article!(settings)
+    settings[:blog_id] = self.id
+    article_id = settings[:id]
+    settings.delete(:id)
+    published_articles.find(article_id).trackbacks.create!(settings)
+  end
+
+
+  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
+  end
+
+  def self.after(controller)
+    unless controller_stack.last == controller
+      raise "Controller stack got out of kilter!"
+    end
+    controller_stack.pop
+  end
+
+  def controller
+    controller_stack.last
+  end
+
+  def current_theme_path
+    Theme.themes_root + "/" + theme
+  end
+
+  def current_theme
+    Theme.theme_from_path(current_theme_path)
+  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
+  end
+
+  def article_url(article, only_path = true, anchor = nil)
+    url_for(:year => article.created_at.year,
+            :month => sprintf("%.2d", article.created_at.month),
+            :day => sprintf("%.2d", article.created_at.day),
+            :title => article.permalink, :anchor => anchor,
+            :only_path => only_path)
+  end
+
+  def server_url
+    if controller
+      controller.send :url_for, :only_path => false, :controller => "/"
+    else
+      settings[:canonical_server_url]
+    end
+  end
+
+  private
+
+  def request
+    controller.request rescue ActionController::TestRequest.new
+  end
+end
+

data/app/models/blog_sweeper.rb

@@ -0,0 +1,23 @@
+class BlogSweeper < ActionController::Caching::Sweeper
+  observe Article, Category, Comment, Trackback, Page, Blog, Sidebar, User
+
+  def after_save(record)
+    expire_for(record)
+  end
+
+  def after_destroy(record)
+    expire_for(record)
+  end
+
+  def expire_for(record)
+    case record
+    when Blog, Sidebar, Category, Comment, Trackback, Article, User
+      PageCache.sweep_all
+      expire_fragment(/.*/)
+    when Page
+      PageCache.sweep("/pages/#{record.name}.html")
+      expire_fragment(/.*\/pages\/.*/)
+      expire_fragment(/.*\/view_page.*/)
+    end
+  end
+end

data/app/models/category.rb

@@ -0,0 +1,62 @@
+class Category < ActiveRecord::Base
+  acts_as_list
+  has_and_belongs_to_many(:articles,
+                          :order => "published_at DESC, created_at DESC")
+
+  def self.find_all_with_article_counters(maxcount=nil)
+    self.find_by_sql([%{
+      SELECT categories.id, categories.name, categories.permalink, categories.position, COUNT(articles.id) AS article_counter
+      FROM #{Category.table_name} categories
+        LEFT OUTER JOIN #{Category.table_name_prefix}articles_categories#{Category.table_name_suffix} articles_categories
+          ON articles_categories.category_id = categories.id
+        LEFT OUTER JOIN #{Article.table_name} articles
+          ON (articles_categories.article_id = articles.id AND articles.published = ?)
+      GROUP BY categories.id, categories.name, categories.position, categories.permalink
+      ORDER BY position
+      }, true]).each {|item| item.article_counter = item.article_counter.to_i }
+  end
+
+  def self.find_by_permalink(*args)
+    super || new
+  end
+
+  def self.to_prefix
+    'category'
+  end
+
+  def stripped_name
+    self.name.to_url
+  end
+
+  def self.reorder(serialized_list)
+    self.transaction do
+      serialized_list.each_with_index do |cid,index|
+        find(cid).update_attribute "position", index rescue nil
+      end
+    end
+  end
+
+  def self.reorder_alpha
+    reorder find(:all, :order => 'UPPER(name)').collect { |c| c.id }
+  end
+
+  def published_articles
+    self.articles.find_already_published
+  end
+
+  def display_name
+    name
+  end
+
+  protected
+
+  before_save :set_defaults
+
+  def set_defaults
+    self.permalink ||= self.stripped_name
+  end
+
+  validates_presence_of :name
+  validates_uniqueness_of :name, :on => :create
+end
+