typo 5.5 → 6.0.4

data/app/controllers/content_controller.rb

@@ -1,51 +0,0 @@
-# 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 published_at > ?', true, @request_time],
-                      :order =>  "published_at ASC" )
-       if future_article
-         delta = future_article.published_at - Time.now
-         controller.response.lifetime = (delta <= 0) ? 0 : delta
-       end
-    end
-  end
-
-  include LoginSystem
-  before_filter :setup_themer
-  helper :theme
-
-  protected
-
-  # TODO: Make this work for all content.
-  def auto_discovery_feed(options = { })
-    with_options(options.reverse_merge(:only_path => true)) do |opts|
-      @auto_discovery_url_rss = opts.url_for(:format => 'rss')
-      @auto_discovery_url_atom = opts.url_for(:format => 'atom')
-    end
-  end
-
-  def theme_layout
-    this_blog.current_theme.layout(self.action_name)
-  end
-
-  helper_method :contents
-  def contents
-    if @articles
-      @articles
-    elsif @article
-      [@article]
-    elsif @page
-      [@page]
-    else
-      []
-    end
-  end
-end

data/app/controllers/feedback_controller.rb

@@ -1,50 +0,0 @@
-class FeedbackController < ApplicationController
-  helper :theme
-
-  before_filter :get_article, :only => [:create]
-
-  cache_sweeper :blog_sweeper
-
-  # Used only by comments. Maybe need move to comments controller
-  # or use it in our code with send some feed about trackback
-  #
-  # Redirect to article with good anchor with /comments?article_id=xxx ou
-  # /trackacks?article_id=xxx
-  #
-  # If no article_id params, so no page found. TODO: See all
-  # comments/trackbacks with paginate ?
-  #
-  # If /comments.rss|atom or /trabacks.atom|rss see a feed about all comments
-  # or trackback
-  #
-  # If article_id params in feed see only this comment|feedback on this
-  # article.
-  #
-  # TODO: It's usefull but use anywhere. Create some extension in xml_sidebar
-  # to define this feed.
-  def index
-    @page_title = self.class.name.to_s.sub(/Controller$/, '')
-    respond_to do |format|
-      format.html do
-        if params[:article_id]
-          article = Article.find(params[:article_id])
-          redirect_to "#{article.permalink_url}\##{@page_title.underscore}"
-        else
-          render :text => 'this space left blank'
-        end
-      end
-      format.atom { render :partial => 'articles/atom_feed', :object => get_feedback }
-      format.rss { render :partial => 'articles/rss20_feed', :object => get_feedback }
-    end
-  end
-
-  protected
-
-  def get_feedback
-    if params[:article_id]
-      Article.find(params[:article_id]).published_feedback
-    else
-      this_blog.published_feedback.find(:all, this_blog.rss_limit_params.merge(:order => 'created_at DESC'))
-    end
-  end
-end

data/app/controllers/grouping_controller.rb

@@ -1,123 +0,0 @@
-class GroupingController < ContentController
-  before_filter :auto_discovery_feed, :only => [:show, :index]
-  layout :theme_layout
-  cache_sweeper :blog_sweeper
-
-  caches_page :index, :show, :if => Proc.new {|c|
-    c.request.query_string == ''
-  }
-
-  class << self
-    def grouping_class(klass = nil)
-      if klass
-        @grouping_class = klass
-      end
-      @grouping_class ||= \
-        self.to_s \
-        .sub(/Controller$/,'') \
-        .singularize.constantize
-    end
-
-    def ivar_name
-      @ivar_name ||= "@#{to_s.sub(/Controller$/, '').underscore}"
-    end
-  end
-
-  def index
-    set_noindex
-    self.groupings = grouping_class.paginate(:page => params[:page], :per_page => 100)
-    @page_title = "#{self.class.to_s.sub(/Controller$/,'')}"
-    @keywords = ""
-    @description = "#{_(self.class.to_s.sub(/Controller$/,''))} #{'for'} #{this_blog.blog_name}"
-    @description << "#{_('page')} #{params[:page]}" if params[:page]
-    render_index(groupings)
-  end
-
-  def show
-    set_noindex
-    @grouping = grouping_class.find_by_permalink(params[:id])
-
-    @page_title = "#{_(self.class.to_s.sub(/Controller$/,'').singularize)} #{@grouping.name}, "
-
-    if @grouping.respond_to? :description and
-        not @grouping.description.nil?
-      @page_title += @grouping.description
-    else
-      @page_title += "#{_('everything about')} "
-
-      if @grouping.respond_to? :display_name and
-          not @grouping.display_name.nil?
-        @page_title += @grouping.display_name
-      else
-        @page_title += @grouping.name
-      end
-    end
-
-    @page_title << " page " << params[:page] if params[:page]
-    @description = (@grouping.description.blank?) ? "" : @grouping.description
-    @keywords = (@grouping.keywords.blank?) ? "" : @grouping.keywords
-    @articles = @grouping.articles.paginate(:page => params[:page], :conditions => { :published => true}, :per_page => 10)
-    render_articles
-  end
-
-  protected
-
-  def grouping_class
-    self.class.grouping_class
-  end
-
-  def groupings=(groupings)
-    instance_variable_set(self.class.ivar_name, groupings)
-  end
-
-  def groupings
-    instance_variable_get(self.class.ivar_name)
-  end
-
-  def render_index(groupings)
-    respond_to do |format|
-      format.html do
-        unless template_exists?
-          @grouping_class = self.class.grouping_class
-          @groupings = groupings
-          render :template => 'articles/groupings'
-        end
-      end
-    end
-  end
-
-  def render_articles
-    respond_to do |format|
-      format.html do
-        if @articles.empty?
-          redirect_to this_blog.base_url, :status => 301
-          return
-        end
-
-        render :template => 'articles/index' unless template_exists?
-      end
-
-      format.atom { render_feed 'atom_feed',  @articles }
-      format.rss  { render_feed 'rss20_feed', @articles }
-    end
-  end
-
-  def render_feed(template, collection)
-    articles = collection[0,this_blog.limit_rss_display]
-    render :partial => template.sub(%r{^(?:articles/)?}, 'articles/'), :object => articles
-  end
-  
-  private
-  def set_noindex
-    # irk there must be a better way to do this
-    @noindex = 1 if (grouping_class.to_s.downcase == "tag" and this_blog.index_tags == false)
-    @noindex = 1 if (grouping_class.to_s.downcase == "category" and this_blog.index_categories == false)
-    @noindex = 1 unless params[:page].blank?
-  end
-
-  def template_exists?(path = default_template_name)
-    self.view_paths.find_template(path, response.template.template_format)
-  rescue ActionView::MissingTemplate
-    false
-  end
-end

data/app/controllers/setup_controller.rb

@@ -1,45 +0,0 @@
-class SetupController < ApplicationController
-  before_filter :check_config, :only => 'index'
-  layout 'setup'
-  
-  def index
-    if request.post?
-      Blog.transaction do
-        this_blog.blog_name = params[:setting][:blog_name]  
-        this_blog.base_url = blog_base_url
-        this_blog.save    
-      end
-      
-      @user = User.new(:login => 'admin', :email => params[:setting][:email])
-
-        @user.password = generate_password
-        session[:tmppass] = @user.password
-        @user.name = @user.login
-        if @user.save
-          self.current_user = @user
-          session[:user_id] = @user.id
-
-          # Crappy hack : by default, the auto generated post is user_id less and it makes Typo crash
-          if User.count == 1
-            art = Article.find(:first)
-            art.user_id = @user.id
-            art.save
-          end
-        end
-      redirect_to :action => 'confirm'
-    end
-  end
-
-  private
-  def generate_password
-    chars = ("a".."z").to_a + ("A".."Z").to_a + ("0".."9").to_a
-    newpass = ""
-    1.upto(7) { |i| newpass << chars[rand(chars.size-1)] }
-    return newpass
-  end
-  
-  def check_config
-    return unless this_blog.configured?
-    redirect_to :controller => 'articles', :action => 'index'
-  end
-end

data/app/controllers/tags_controller.rb

@@ -1,3 +0,0 @@
-class TagsController < GroupingController
-  # index, #show are inherited
-end

data/app/controllers/textfilter_controller.rb

@@ -1,19 +0,0 @@
-class TextfilterController < ApplicationController
-  def public_action
-    filter = params[:filter]
-    action = params[:public_action]
-    plugin = TextFilter.filters_map[filter]
-
-    if(plugin and plugin.plugin_public_actions.include? action.to_sym)
-      render_component(:controller => "plugins/textfilters/#{params[:filter]}",
-        :action => params[:public_action], :params => params)
-    else
-      render :text => '', :status => 404
-    end
-  end
-
-  def test_action
-    render :text => ''
-  end
-end
-

data/app/controllers/theme_controller.rb

@@ -1,62 +0,0 @@
-class ThemeController < ContentController
-
-  def stylesheets
-    render_theme_item(:stylesheets, params[:filename], 'text/css; charset=utf-8')
-  end
-
-  def javascript
-    render_theme_item(:javascript, params[:filename], 'text/javascript; charset=utf-8')
-  end
-
-  def images
-    render_theme_item(:images, params[:filename])
-  end
-
-  def error
-    render :nothing => true, :status => 404
-  end
-
-  def static_view_test
-  end
-
-  private
-
-  def render_theme_item(type, file, mime = nil)
-    mime ||= mime_for(file)
-    if file.split(%r{[\\/]}).include?("..")
-      return (render :text => "Not Found", :status => 404)
-    end
-
-    src = this_blog.current_theme.path + "/#{type}/#{file}"
-    return (render :text => "Not Found", :status => 404) unless File.exists? src
-
-    if perform_caching
-      dst = "#{page_cache_directory}/#{type}/theme/#{file}"
-      FileUtils.makedirs(File.dirname(dst))
-      FileUtils.cp(src, "#{dst}.#{$$}")
-      FileUtils.ln("#{dst}.#{$$}", dst) rescue nil
-      FileUtils.rm("#{dst}.#{$$}", :force => true)
-    end 
-    send_file(src, :type => mime, :disposition => 'inline', :stream => true)
-  end
-
-  def mime_for(filename)
-    case filename.downcase
-    when /\.js$/
-      'text/javascript'
-    when /\.css$/
-      'text/css'
-    when /\.gif$/
-      'image/gif'
-    when /(\.jpg|\.jpeg)$/
-      'image/jpeg'
-    when /\.png$/
-      'image/png'
-    when /\.swf$/
-      'application/x-shockwave-flash'
-    else
-      'application/binary'
-    end
-  end
-end
-

data/app/controllers/trackbacks_controller.rb

@@ -1,41 +0,0 @@
-class TrackbacksController < FeedbackController
-  def create
-    @error_message = catch(:error) do
-      if this_blog.global_pings_disable
-        throw :error, "Trackback not saved"
-      elsif params[:__mode] == 'rss'
-        # Part of the trackback spec... not sure what we should be doing here though.
-      else
-          begin
-              @trackback =  this_blog.ping_article!(
-                params.merge(:ip => request.remote_ip, :published => true))
-              ""
-          rescue ActiveRecord::RecordNotFound, ActiveRecord::StatementInvalid
-            throw :error, "Article id #{params[:id]} not found."
-          rescue ActiveRecord::RecordInvalid
-            throw :error, "Trackback not saved"
-          end
-      end
-    end
-
-    respond_to do |format|
-        format.xml { render :action => 'trackback.xml.builder' }
-        format.html { render :nothing => true }
-    end
-  end
-
-  protected
-
-  def get_feedback
-    @trackbacks =
-      if params[:article_id]
-        Article.find(params[:article_id]).published_trackbacks
-      else
-        Trackback.find_published(:all, this_blog.rss_limit_params.merge(:order => 'created_at DESC'))
-      end
-  end
-
-  def get_article
-    true
-  end
-end

data/app/controllers/xml_controller.rb

@@ -1,134 +0,0 @@
-class XmlController < ApplicationController
-  caches_page :feed, :if => Proc.new {|c|
-    c.request.query_string == ''
-  }
-
-  NORMALIZED_FORMAT_FOR = {'atom' => 'atom', 'rss' => 'rss',
-    'atom10' => 'atom', 'atom03' => 'atom', 'rss20' => 'rss',
-    'googlesitemap' => 'googlesitemap', 'rsd' => 'rsd' }
-
-  CONTENT_TYPE_FOR = { 'rss' => 'application/xml',
-    'atom' => 'application/atom+xml',
-    'googlesitemap' => 'application/xml' }
-
-  before_filter :adjust_format
-
-  def feed
-    @format = params[:format]
-
-    unless @format
-      return render(:text => 'Unsupported format', :status => 404)
-    end
-
-    case params[:type]
-    when 'feed'
-      redirect_to :controller => 'articles', :action => 'index', :format => @format, :status => 301
-    when 'comments'
-      head :moved_permanently, :location => admin_comments_url(:format => @format)
-    when 'article'
-      head :moved_permanently, :location => Article.find(params[:id]).permalink_by_format(@format)
-    when 'category', 'tag', 'author'
-      head :moved_permanently, \
-        :location => self.send("#{params[:type]}_url", params[:id], :format => @format)
-    else
-      @items = Array.new
-      @blog = this_blog
-      # We use @feed_title.<< to destructively modify @feed_title, below, so
-      # make sure we have our own copy to modify.
-      @feed_title = this_blog.blog_name.dup
-      @link = this_blog.base_url
-      @self_url = url_for(params)
-
-      if respond_to?("prep_#{params[:type]}")
-        self.send("prep_#{params[:type]}")
-      else
-        render :text => 'Unsupported action', :status => 404
-        return
-      end
-
-      # TODO: Use templates from articles controller.
-      respond_to do |format|
-        format.googlesitemap
-        format.atom
-        format.rss
-      end
-    end
-  end
-
-  def articlerss
-    redirect_to :action => 'feed', :format => 'rss', :type => 'article', :id => params[:id]
-  end
-
-  def commentrss
-    redirect_to :action => 'feed', :format => 'rss', :type => 'comments'
-  end
-  def trackbackrss
-    redirect_to :action => 'feed', :format => 'rss', :type => 'trackbacks'
-  end
-
-  def rsd
-
-  end
-
-  protected
-
-  def adjust_format
-    if params[:format]
-      params[:format] = NORMALIZED_FORMAT_FOR[params[:format]]
-    else
-      params[:format] = 'rss'
-    end
-    return true
-  end
-
-  def fetch_items(association, order='published_at DESC', limit=nil)
-    if association.instance_of?(Symbol)
-      association = association.to_s.singularize.classify.constantize
-    end
-    limit ||= this_blog.limit_rss_display
-    @items += association.find_already_published(:all, :limit => limit, :order => order)
-  end
-
-  def prep_feed
-    fetch_items(:articles)
-  end
-
-  def prep_comments
-    fetch_items(:comments)
-    @feed_title << " comments"
-  end
-
-  def prep_trackbacks
-    fetch_items(:trackbacks)
-    @feed_title << " trackbacks"
-  end
-
-  def prep_article
-    article = this_blog.articles.find(params[:id])
-    fetch_items(article.comments, 'published_at DESC', 25)
-    @items.unshift(article)
-    @feed_title << ": #{article.title}"
-    @link = article.permalink_url
-  end
-
-  def prep_category
-    category = Category.find_by_permalink(params[:id])
-    fetch_items(category.articles)
-    @feed_title << ": Category #{category.name}"
-    @link = category.permalink_url
-  end
-
-  def prep_tag
-    tag = Tag.find_by_name(params[:id])
-    fetch_items(tag.articles)
-    @feed_title << ": Tag #{tag.display_name}"
-    @link = tag.permalink_url
-  end
-
-  def prep_sitemap
-    fetch_items(:articles, 'created_at DESC', 1000)
-    fetch_items(:pages, 'created_at DESC', 1000)
-    @items += Category.find_all_with_article_counters(1000) unless this_blog.index_categories == false
-    @items += Tag.find_all_with_article_counters(1000) unless this_blog.index_tags == false
-  end
-end