typo 3.99.0

data/app/models/comment.rb

@@ -0,0 +1,76 @@
+require_dependency 'spam_protection'
+
+class Comment < Content
+  include TypoGuid
+
+  content_fields :body
+
+  belongs_to :article, :counter_cache => true
+  belongs_to :user
+
+  validates_presence_of :author, :body
+  validates_against_spamdb :body, :url, :ip
+  validates_age_of :article_id
+  validate_on_create :check_article_is_open_to_comments
+
+  def self.default_order
+    'created_at ASC'
+  end
+
+  def notify_user_via_email(controller, user)
+    if user.notify_via_email?
+      EmailNotify.send_comment(controller, self, user)
+    end
+  end
+
+  def notify_user_via_jabber(controller, user)
+    if user.notify_via_jabber?
+      JabberNotify.send_message(user, "New comment", "A new comment was posted to '#{article.title}' on #{blog.blog_name} by #{author}: #{body}", self.body_html)
+    end
+  end
+
+  def interested_users
+    users = User.find_boolean(:all, :notify_on_comments)
+    self.notify_users = users
+    users
+  end
+
+  def location(anchor=:ignored, only_path=true)
+    blog.url_for(article, "comment-#{id}", only_path)
+  end
+
+  protected
+
+  def check_article_is_open_to_comments
+    return unless article
+    unless article.allow_comments?
+      errors.add(:article, "Article is not open to comments")
+    end
+  end
+
+
+
+  def body_html_postprocess(value, controller)
+    controller.send(:sanitize, controller.send(:auto_link, value))
+  end
+
+  def default_text_filter_config_key
+    'comment_text_filter'
+  end
+
+  before_create :create_guid
+  before_save :correct_url, :make_nofollow
+
+  def correct_url
+    unless url.to_s.empty?
+      unless url =~ /^http\:\/\//
+        self.url = "http://#{url}"
+      end
+    end
+  end
+
+  def make_nofollow
+    self.author    = author.nofollowify
+    self.body_html = body_html.to_s.nofollowify
+  end
+end

data/app/models/config_manager.rb

@@ -0,0 +1,80 @@
+module ConfigManager
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def fields
+      @fields ||= Hash.new { Item.new }
+    end
+
+    def setting(name, type=:object, default=nil)
+      item = Item.new
+      item.name, item.ruby_type, item.default = name.to_s, type, default
+      fields[name.to_s] = item
+      add_setting_accessor(item)
+    end
+
+    def default_for(key)
+      fields[key.to_s].default
+    end
+
+    private
+
+    def add_setting_accessor(item)
+      add_setting_reader(item)
+      add_setting_writer(item)
+    end
+
+    def add_setting_reader(item)
+      self.send(:define_method, item.name) do
+        raw_value = settings[item.name]
+        raw_value.nil? ? item.default : raw_value
+      end
+      if item.ruby_type == :boolean
+        self.send(:define_method, item.name + "?") do
+          raw_value = settings[item.name]
+          raw_value.nil? ? item.default : raw_value
+        end
+      end
+    end
+
+    def add_setting_writer(item)
+      self.send(:define_method, "#{item.name}=") do |newvalue|
+        retval = settings[item.name] = canonicalize(item.name, newvalue)
+        self.save! unless new_record?
+        retval
+      end
+    end
+
+  end
+
+  def canonicalize(key, value)
+    self.class.fields[key.to_s].canonicalize(value)
+  end
+
+  class Item
+    attr_accessor :name, :ruby_type, :default
+
+    def canonicalize(value)
+      case ruby_type
+      when :boolean
+        case value
+        when "0", 0, '', false, "false", "f", nil
+          false
+        else
+          true
+        end
+      when :integer
+        value.to_i
+      when :string
+        value.to_s
+      when :yaml
+        value.to_yaml
+      else
+        value
+      end
+    end
+  end
+end

data/app/models/content.rb

@@ -0,0 +1,222 @@
+require 'observer'
+require 'set'
+class Content < ActiveRecord::Base
+  include Observable
+
+  belongs_to :text_filter
+  belongs_to :blog
+  validates_presence_of :blog_id
+
+  has_and_belongs_to_many :notify_users, :class_name => 'User',
+    :join_table => 'notifications', :foreign_key => 'notify_content_id',
+    :association_foreign_key => 'notify_user_id', :uniq => true
+
+  has_many :triggers, :as => :pending_item, :dependent => :delete_all
+
+  before_save :state_before_save
+  after_save :post_trigger
+
+  serialize :whiteboard
+
+  @@content_fields = Hash.new
+  @@html_map       = Hash.new
+  
+  def initialize(*args)
+    super(*args)
+    
+    # 
+    if self.blog_id == nil or self.blog_id == 0
+      self.blog_id = Blog.default
+    end
+  end
+
+  class << self
+    def content_fields(*attribs)
+      @@content_fields[self] = ((@@content_fields[self]||[]) + attribs).uniq
+      @@html_map[self] = nil
+      attribs.each do | field |
+        define_method("#{field}=") do | newval |
+          if self[field] != newval
+            changed
+            self[field] = newval
+            if html_map(field)
+              self[html_map(field)] = nil
+            end
+            notify_observers(self, field.to_sym)
+          end
+          self[field]
+        end
+        unless self.method_defined?("#{field}_html")
+          define_method("#{field}_html") do
+            if blog.controller
+              html(blog.controller, field.to_sym)
+            else
+              self["#{field}_html"]
+            end
+          end
+        end
+      end
+    end
+
+    def html_map(field=nil)
+      unless @@html_map[self]
+        @@html_map[self] = Hash.new
+        instance = self.new
+        @@content_fields[self].each do |attrib|
+          @@html_map[self][attrib] = "#{attrib}_html"
+        end
+      end
+      if field
+        @@html_map[self][field]
+      else
+        @@html_map[self]
+      end
+    end
+
+    def find_published(what = :all, options = {})
+      options.reverse_merge!(:order => default_order)
+      options[:conditions] = merge_conditions(['published = ?', true],
+                                              options[:conditions])
+      find(what, options)
+    end
+
+    def default_order
+      'published_at DESC'
+    end
+
+    def find_already_published(what = :all, at = nil, options = { })
+      if what.respond_to?(:has_key?)
+        what, options = :all, what
+      elsif at.respond_to?(:has_key?)
+        options, at = at, nil
+      end
+      at ||= options.delete(:at) || Time.now
+      with_scope(:find => { :conditions => ['published_at < ?', at]}) do
+        find_published(what, options)
+      end
+    end
+
+    def merge_conditions(*conditions)
+      conditions.compact.collect do |cond|
+        '(' + sanitize_sql(cond) + ')'
+      end.join(' AND ')
+    end
+  end
+
+  def state
+    @state ||= ContentState::Factory.derived_from(self)
+  end
+
+  def state=(new_state)
+    @state = new_state
+  end
+
+  def state_before_save
+    self.state.before_save(self)
+  end
+
+  def html_map(field=nil); self.class.html_map(field); end
+
+  def full_html
+    unless blog.controller
+      raise "full_html only works with an active controller"
+    end
+    html(blog.controller, :all)
+  end
+
+  def populate_html_fields(controller)
+    html_map.each do |field, html_field|
+      if !self[field].blank? && self[html_field].blank?
+        html = text_filter.filter_text_for_controller( self[field].to_s, controller, self, false )
+        self[html_field] = self.send("#{html_field}_postprocess",
+                                     html, controller)
+      end
+    end
+  end
+
+  def html(controller,what = :all)
+    populate_html_fields(controller)
+
+    if what == :all
+      self[:body_html].to_s + (self[:extended_html].to_s rescue '')
+    elsif self.class.html_map(what)
+      self[html_map(what)]
+    else
+      raise "Unknown 'what' in article.html"
+    end
+  end
+
+  def method_missing(method, *args, &block)
+    if method.to_s =~ /_postprocess$/
+      args[0]
+    else
+      super(method, *args, &block)
+    end
+  end
+
+  def whiteboard
+    self[:whiteboard] ||= Hash.new
+  end
+
+
+  def text_filter
+    self[:text_filter] ||= if self[:text_filter_id]
+                             TextFilter.find(self[:text_filter_id])
+                           else
+                             blog[default_text_filter_config_key].to_text_filter
+                           end
+  end
+
+  def text_filter=(filter)
+    self[:text_filter] = filter.to_text_filter
+  end
+
+  def blog
+    self[:blog] ||= blog_id.to_i.zero? ? Blog.default : Blog.find(blog_id)
+  end
+
+  def publish!
+    self.published = true
+    self.save!
+  end
+
+  def published=(a_boolean)
+    self[:published] = a_boolean
+    state.change_published_state(self, a_boolean)
+  end
+
+  def published_at=(a_time)
+    state.set_published_at(self, (a_time.to_time rescue nil))
+  end
+
+  def published_at
+    self[:published_at] || self[:created_at]
+  end
+
+  def just_published?
+    state.just_published?
+  end
+
+  def publication_pending?
+    state.publication_pending?
+  end
+
+  def post_trigger
+    state.post_trigger(self)
+  end
+
+  def after_save
+    state.after_save(self)
+  end
+
+  def send_notification_to_user(controller, user)
+    notify_user_via_email(controller, user)
+    notify_user_via_jabber(controller, user)
+  end
+
+  def send_notifications(controller = nil)
+    state.send_notifications(self, controller || blog.controller)
+  end
+end
+
+class Object; def to_text_filter; TextFilter.find_by_name(self.to_s); end; end

data/app/models/content_observer.rb

@@ -0,0 +1,5 @@
+class ContentObserver < ActiveRecord::Observer
+  def before_save(content)
+    content.populate_html_fields
+  end
+end

data/app/models/content_state/base.rb

@@ -0,0 +1,51 @@
+module ContentState
+  class Base
+    include Reloadable
+
+    class << self
+      def instance
+        nil
+      end
+
+      protected :new
+    end
+
+    def before_save(content)
+      serialize_on(content)
+      true
+    end
+
+    def published?
+      false
+    end
+
+    def just_published?
+      false
+    end
+
+    def draft?
+      false
+    end
+
+    def publication_pending?
+      false
+    end
+
+    def after_save(content)
+      true
+    end
+
+    def post_trigger(content)
+      true
+    end
+
+    def send_notifications(content)
+      true
+    end
+
+    def send_pings(content)
+      true
+    end
+  end
+end
+

data/app/models/content_state/draft.rb

@@ -0,0 +1,40 @@
+module ContentState
+  class Draft < Base
+    include Reloadable
+    include Singleton
+    class << self
+      def derivable_from(content)
+        ! content.new_record? &&
+          ! content.published &&
+          content.published_at.nil?
+      end
+    end
+
+    def serialize_on(content)
+      content[:published] = false
+      content.published_at = nil
+      true
+    end
+
+    def change_published_state(content, boolean)
+      content[:published] = boolean
+      if content.published
+        content.state = JustPublished.instance
+      end
+    end
+
+    def set_published_at(content, new_time)
+      content[:published_at] = new_time
+      return if new_time.nil?
+      if new_time <= Time.now
+        content[:published_at] = nil
+      else
+        content.state = PublicationPending.instance
+      end
+    end
+
+    def draft?
+      true
+    end
+  end
+end