typo 3.99.0

data/app/controllers/admin/themes_controller.rb

@@ -0,0 +1,20 @@
+class Admin::ThemesController < Admin::BaseController
+
+  def index
+    @themes = Theme.find_all
+    @themes.each do |theme|
+      theme.description_html = TextFilter.filter_text(theme.description, self, nil, [:markdown,:smartypants])
+    end
+    @active = this_blog.current_theme
+  end
+
+  def preview
+    send_file "#{Theme.themes_root}/#{params[:theme]}/preview.png", :type => 'image/png', :disposition => 'inline', :stream => false
+  end
+
+  def switchto
+    this_blog.theme = params[:theme]
+    this_blog.save
+    redirect_to :action => 'index'
+  end
+end

data/app/controllers/admin/trackbacks_controller.rb

@@ -0,0 +1,54 @@
+class Admin::TrackbacksController < Admin::BaseController
+
+  before_filter :get_article
+
+  def index
+    list
+    render_action 'list'
+  end
+
+  def list
+    @trackbacks = @article.trackbacks.find(:all, :order => "id DESC")
+  end
+
+  def show
+    @trackback = @article.trackbacks.find(params[:id])
+  end
+
+  def new
+    @trackback = @article.trackbacks.build(params[:trackback])
+
+    if request.post? and @trackback.save
+      flash[:notice] = 'Trackback was successfully created.'
+      redirect_to :action => 'show', :id => @trackback.id
+    end
+  end
+
+  def edit
+    @trackback = @article.trackbacks.find(params[:id])
+    @trackback.attributes = params[:trackback]
+    if request.post? and @trackback.save
+      flash[:notice] = 'Trackback was successfully updated.'
+      redirect_to :action => 'show', :id => @trackback.id
+    end
+  end
+
+  def destroy
+    @trackback = @article.trackbacks.find(params[:id])
+    if request.post?
+      @trackback.destroy
+      redirect_to :action => 'list'
+    end
+  end
+
+  private
+
+    def get_article
+      @article = Article.find(params[:article_id])
+
+      if @article.nil?
+        redirect_to '/admin'
+      end
+    end
+
+end

data/app/controllers/admin/users_controller.rb

@@ -0,0 +1,41 @@
+class Admin::UsersController < Admin::BaseController
+
+  def index
+    list
+    render_action 'list'
+  end
+
+  def list
+    @users = User.find_all
+  end
+
+  def show
+    @user = User.find(params[:id])
+  end
+
+  def new
+    @user = User.new(params[:user])
+    if request.post? and @user.save
+      flash[:notice] = 'User was successfully created.'
+      redirect_to :action => 'list'
+    end
+  end
+
+  def edit
+    @user = User.find(params[:id])
+    @user.attributes = params[:user]
+    if request.post? and @user.save
+      flash[:notice] = 'User was successfully updated.'
+      redirect_to :action => 'show', :id => @user.id
+    end
+  end
+
+  def destroy
+    @user = User.find(params[:id])
+    if request.post?
+      @user.destroy if User.count > 1
+      redirect_to :action => 'list'
+    end
+  end
+
+end

data/app/controllers/application.rb

@@ -0,0 +1,66 @@
+# The filters added to this controller will be run for all controllers in the application.
+# Likewise will all the methods added be available for all controllers.
+class ApplicationController < ActionController::Base
+  include LoginSystem
+
+  before_filter :get_the_blog_object
+  before_filter :fire_triggers
+  after_filter :flush_the_blog_object
+
+  around_filter Blog
+
+  protected
+
+  def fire_triggers
+    Trigger.fire
+  end
+
+  def with_blog_scoped_classes(klasses=[Content, Article, Comment, Page, Trackback], &block)
+    default_id = this_blog.id
+    scope_hash = { :find => { :conditions => "blog_id = #{default_id}"},
+                   :create => { :blog_id => default_id } }
+    klasses.inject(block) do |blk, klass|
+      lambda { klass.with_scope(scope_hash, &blk) }
+    end.call
+  end
+
+  def article_url(article, only_path = true, anchor = nil)
+    article.location(anchor, only_path)
+  end
+
+  def server_url
+    this_blog.server_url
+  end
+
+  def cache
+    $cache ||= SimpleCache.new 1.hour
+  end
+
+  def get_the_blog_object
+    @blog = Blog.default || Blog.create!
+    true
+  end
+
+  def flush_the_blog_object
+    @blog = nil
+    true
+  end
+
+  def this_blog
+    @blog || Blog.default || Blog.new
+  end
+  helper_method :this_blog
+
+  def self.include_protected(*modules)
+    modules.reverse.each do |mod|
+      included_methods = mod.public_instance_methods.reject do |meth|
+        self.method_defined?(meth)
+      end
+      self.send(:include, mod)
+      included_methods.each do |meth|
+        protected meth
+      end
+    end
+  end
+end
+

data/app/controllers/articles_controller.rb

@@ -0,0 +1,218 @@
+class ArticlesController < ContentController
+  before_filter :verify_config
+  before_filter :check_page_query_param_for_missing_routes
+
+  layout :theme_layout, :except => [:comment_preview, :trackback]
+
+  cache_sweeper :blog_sweeper
+
+  cached_pages = [:index, :read, :permalink, :category, :find_by_date, :archives, :view_page, :tag, :author]
+  # If you're really memory-constrained, then consider replacing
+  # caches_action_with_params with caches_page
+  caches_action_with_params *cached_pages
+  session :off, :only => cached_pages
+
+  verify(:only => [:nuke_comment, :nuke_trackback],
+         :session => :user, :method => :post,
+         :render => { :text => 'Forbidden', :status => 403 })
+
+  def index
+    @pages, @articles =
+      paginate(:article, :per_page => this_blog.limit_article_display,
+               :conditions =>
+                 ['published = ? AND contents.created_at < ? AND blog_id = ?',
+                             true,            Time.now,     this_blog.id],
+               :order_by => "contents.created_at DESC",
+               :include => [:categories, :tags])
+  end
+
+  def search
+    @articles = this_blog.published_articles.search(params[:q])
+    render_paginated_index("No articles found...")
+  end
+
+  def comment_preview
+    if params[:comment].blank? or params[:comment][:body].blank?
+      render :nothing => true
+      return
+    end
+
+    set_headers
+    @comment = this_blog.comments.build(params[:comment])
+    @controller = self
+  end
+
+  def archives
+    @articles = this_blog.published_articles
+  end
+
+  def read
+    display_article { this_blog.published_articles.find(params[:id]) }
+  end
+
+  def permalink
+    display_article(this_blog.published_articles.find_by_permalink(*params.values_at(:year, :month, :day, :title)))
+  end
+
+  def find_by_date
+    @articles = this_blog.published_articles.find_all_by_date(params[:year], params[:month], params[:day])
+    render_paginated_index
+  end
+
+  def error(message = "Record not found...")
+    @message = message.to_s
+    render :action => 'error'
+  end
+
+  def author
+    render_grouping(User)
+  end
+
+  def category
+    render_grouping(Category)
+  end
+
+  def tag
+    render_grouping(Tag)
+  end
+
+  # Receive comments to articles
+  def comment
+    unless @request.xhr? || this_blog.sp_allow_non_ajax_comments
+      render_error("non-ajax commenting is disabled")
+      return
+    end
+
+    if request.post?
+      begin
+        params[:comment].merge!({:ip => request.remote_ip,
+                                :published => true })
+        @article = this_blog.published_articles.find(params[:id])
+        @comment = @article.comments.build(params[:comment])
+        @comment.user = session[:user]
+        @comment.save!
+        add_to_cookies(:author, @comment.author)
+        add_to_cookies(:url, @comment.url)
+
+        set_headers
+        render :partial => "comment", :object => @comment
+      rescue ActiveRecord::RecordInvalid
+        STDERR.puts @comment.errors.inspect
+        render_error(@comment)
+      end
+    end
+  end
+
+  # Receive trackbacks linked to articles
+  def trackback
+    @error_message = catch(:error) do
+      if params[:__mode] == "rss"
+        # Part of the trackback spec... will implement later
+        # XXX. Should this throw an error?
+      elsif !(params.has_key?(:url) && params.has_key?(:id))
+        throw :error, "A URL is required"
+      else
+        begin
+          settings = { :id => params[:id],
+                       :url => params[:url],      :blog_name => params[:blog_name],
+                       :title => params[:title],  :excerpt => params[:excerpt],
+                       :ip  => request.remote_ip, :published => true }
+          this_blog.ping_article!(settings)
+        rescue ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid
+          throw :error, "Article id #{params[:id]} not found."
+        rescue ActiveRecord::RecordInvalid
+          throw :error, "Trackback not saved"
+        end
+      end
+      nil
+    end
+  end
+
+  def nuke_comment
+    Comment.find(params[:id]).destroy
+    render :nothing => true
+  end
+
+  def nuke_trackback
+    Trackback.find(params[:id]).destroy
+    render :nothing => true
+  end
+
+  def view_page
+    if(@page = Page.find_by_name(params[:name].to_a.join('/')))
+      @page_title = @page.title
+    else
+      render :nothing => true, :status => 404
+    end
+  end
+
+  private
+
+  def add_to_cookies(name, value, path=nil, expires=nil)
+    cookies[name] = { :value => value, :path => path || "/#{controller_name}",
+                       :expires => 6.weeks.from_now }
+  end
+
+  def check_page_query_param_for_missing_routes
+    unless request.path =~ /\/page\//
+      raise "Page param problem" unless params[:page].nil?
+    end
+  end
+
+  def verify_config
+    if User.count == 0
+      redirect_to :controller => "accounts", :action => "signup"
+    elsif ! this_blog.is_ok?
+      redirect_to :controller => "admin/general", :action => "redirect"
+    else
+      return true
+    end
+  end
+
+  def display_article(article = nil)
+    begin
+      @article      = block_given? ? yield : article
+      @comment      = Comment.new
+      @page_title   = @article.title
+      auto_discovery_feed :type => 'article', :id => @article.id
+      render :action => 'read'
+    rescue ActiveRecord::RecordNotFound, NoMethodError => e
+      error("Post not found...")
+    end
+  end
+
+  alias_method :rescue_action_in_public, :error
+
+  def render_error(object = '', status = 500)
+    render(:text => (object.errors.full_messages.join(", ") rescue object.to_s), :status => status)
+  end
+
+  def set_headers
+    @headers["Content-Type"] = "text/html; charset=utf-8"
+  end
+
+  def list_groupings(klass)
+    @grouping_class = klass
+    @groupings = klass.find_all_with_article_counters(1000)
+    render :action => 'groupings'
+  end
+
+  def render_grouping(klass)
+    return list_groupings(klass) unless params[:id]
+
+    @articles = klass.find_by_permalink(params[:id]).articles.find_already_published rescue []
+    auto_discovery_feed :type => klass.to_s.underscore, :id => params[:id]
+    render_paginated_index("Can't find posts with #{klass.to_prefix} '#{h(params[:id])}'")
+  end
+
+  def render_paginated_index(on_empty = "No posts found...")
+    return error(on_empty) if @articles.empty?
+
+    @pages = Paginator.new self, @articles.size, this_blog.limit_article_display, @params[:page]
+    start = @pages.current.offset
+    stop  = (@pages.current.next.offset - 1) rescue @articles.size
+    # Why won't this work? @articles.slice!(start..stop)
+    @articles = @articles.slice(start..stop)
+    render :action => 'index'
+  end
+end

data/app/controllers/backend_controller.rb

@@ -0,0 +1,11 @@
+class BackendController < ContentController
+  cache_sweeper :blog_sweeper
+  session :off
+
+  web_service_dispatching_mode :layered
+  web_service(:metaWeblog)  { MetaWeblogService.new(self) }
+  web_service(:mt)          { MovableTypeService.new(self) }
+  web_service(:blogger)     { BloggerService.new(self) }
+
+  alias xmlrpc api
+end

data/app/controllers/content_controller.rb

@@ -0,0 +1,98 @@
+# The filters added to this controller will be run for all controllers in the application.
+# Likewise will all the methods added be available for all controllers.
+class ContentController < ApplicationController
+  class ExpiryFilter
+    def before(controller)
+      @request_time = Time.now
+    end
+
+    def after(controller)
+       future_article =
+         Article.find(:first,
+                      :conditions => ['published = ? AND created_at > ?', true, @request_time],
+                      :order =>  "created_at ASC" )
+       if future_article
+         delta = future_article.created_at - Time.now
+         controller.response.lifetime = (delta <= 0) ? 0 : delta
+       end
+    end
+  end
+
+  include LoginSystem
+  model :user
+
+  helper :theme
+
+  before_filter :auto_discovery_defaults
+
+  def self.caches_action_with_params(*actions)
+    super
+    around_filter ExpiryFilter.new, :only => actions
+  end
+
+  def self.cache_page(content, path)
+    begin
+      # Don't cache the page if there are any questionmark characters in the url
+      unless path =~ /\?\w+/ or path =~ /page\d+$/
+        super(content,path)
+        PageCache.create(:name => page_cache_file(path))
+      end
+    rescue # if there's a caching error, then just return the content.
+      content
+    end
+  end
+
+  def self.expire_page(path)
+    if cache = PageCache.find(:first, :conditions => ['name = ?', path])
+      cache.destroy
+    end
+  end
+
+  def auto_discovery_defaults
+    @auto_discovery_url_rss =
+        @request.instance_variable_get(:@auto_discovery_url_rss)
+    @auto_discovery_url_atom =
+         @request.instance_variable_get(:@auto_discovery_url_atom)
+    unless @auto_discovery_url_rss && @auto_discovery_url_atom
+      auto_discovery_feed(:type => 'feed')
+      @request.instance_variable_set(:@auto_discovery_url_rss,
+                                      @auto_discovery_url_rss)
+      @request.instance_variable_set(:@auto_discovery_url_atom,
+                                      @auto_discovery_url_atom)
+    end
+  end
+
+  def auto_discovery_feed(options)
+    options = {:only_path => false, :action => 'feed', :controller => 'xml'}.merge options
+    # Special cased ugliness. Get rid of it when there's a user feed.
+    if options[:type] == 'user'
+      options[:type] = 'feed'
+      options[:id] = nil
+    end
+
+    @auto_discovery_url_rss = url_for(({:format => 'rss20'}.merge options))
+    @auto_discovery_url_atom = url_for(({:format => 'atom'}.merge options))
+  end
+
+  def theme_layout
+    this_blog.current_theme.layout
+  end
+
+  helper_method :contents
+  def contents
+    if @articles
+      @articles
+    elsif @article
+      [@article]
+    elsif @page
+      [@page]
+    else
+      []
+    end
+  end
+
+  protected
+
+  include_protected ActionView::Helpers::TagHelper, ActionView::Helpers::TextHelper
+
+end