tb_blog 1.1.3 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6985b911d99d89f62668336b020afd530179731b
-  data.tar.gz: a6670c45aae3e10bc112844326cc78ef64310003
+  metadata.gz: 75d08014c6bfae23f36194966d8c44c90b2bf360
+  data.tar.gz: 9d671ef8e92119816d1e763c76c075f3f7e8355d
 SHA512:
-  metadata.gz: 51fe31feee68e1f6191a5ac9eaa80a6d00454ada4b96089c3c8aee56d5a6550acf17405758ba8234de8c11f14af9735fd5aa4046c3ee6c60661029ee6bedce7e
-  data.tar.gz: 96ae50f8a8e5393e3c03194e6e4b41302ee2bb3efc3c5509d6159fe447dce89c02646302cf3067658a9271d5bd89e937236e8a7b905a8bed38c8731f0d680e8b
+  metadata.gz: 034db71980235a49973be16e66a5041275accebe67aae1217251aca2904462670258902a5ae439ad81c53df5ccef212960ed1e12e980300cb582545bc1c0676f
+  data.tar.gz: 474aeaf3a4a457368cfb19092d9d2273df82da6b71d141f2f5dd540cfa22bbb7b74a63b9c91f942b37c47660f214ab81eca7ede8734723c58118d5f910a63530

data/Readme.md

@@ -39,11 +39,30 @@ A number of built-in views have been provided to help you get started with the f
 
 __NOTE:__ The built-in views are likely to undergo changes as features are added to the blogging engine. If a new version of TB Blog does not play nicely with your customized views, try backing up your views to an alternate location and running the views generator again to see what has changed.
 
-## Javascript Driver
+## Custom Blogs
 
-TB Blog includes a small, unobtrusive javascript driver that adds functionality to the built-in views. Including the driver is optional, as all client-side views and controllers are designed to work whether you include it or not.
+TB Blog has the ability to define arbitrary blogs outside of the typical Blog and News feeds. To get a custom blog up and running quickly, simply run the provided generator.
 
-	<%= javascript_include_tag 'spud/blog' %>
+    rails g spud:blog:blog "Press Releases"
+
+The generator will have inserted the following snippet of code into your `application.rb` file:
+
+    Spud::Blog.config.blogs << {
+      :name => 'Press Releases',        # Display name for the blog
+      :key => 'press-releases',         # Used by the controller and database to key each post
+      :path => '/about/press-releases', # Front-end url for the blog
+      :layout => 'about'                # Which erb layout should be used
+    }
+
+By default, custom blogs will use the standard `index` and `show` views under `app/views/posts`. However, you may choose to customize those views by copying the same files over to `app/views/[BLOG KEY]`. Files in that directory will take precedence over those in the standard directory.
+
+### Upgrading from v1.1.2 or Lower
+
+The new blog configuration system required a change to the way we determine blog vs news (vs other) posts. After upgrading your gems and running the migrations, you should run the following rake task to update your data model:
+
+    rake tb_blog:apply_blog_keys
+
+The `is_news` column is being left on the `SpudPost` model for the time being to facilitate this transation. At some point in a future version will we remove that column entirely. Please make sure to transition your data before the column goes away for good.
 
 ## Access Control
 
@@ -52,9 +71,7 @@ TB Blog offers a mechanism for limitting who can see what posts. Supply a lambda
 The example below is from an application that allows subscribers to view subscriber-only content. 
 
 	Spud::Blog.query_for_user = ->(user){
-    	if user.present? && user.has_paid_subscription?
-      		{}
-    	else
+    	if !user.try(:has_paid_subscription?)
       		{:requires_subscription => false}
     	end
 	}

data/app/controllers/admin/post_comments_controller.rb

@@ -1,8 +1,9 @@
 class Admin::PostCommentsController < Admin::ApplicationController
+	include BlogUrlHelpers
 
 	respond_to :html, :xml, :json
-	belongs_to_spud_app :blog_posts
-	before_filter :find_comment, :only => [:show, :edit, :update, :destroy, :approve, :spam]
+	before_action :load_blog, :only => :index
+	before_action :find_comment, :only => [:show, :edit, :update, :destroy, :approve, :spam]
 	add_breadcrumb 'Blog Posts', :admin_posts_path
 	add_breadcrumb 'Comments', :admin_post_comments_path
 
@@ -11,9 +12,9 @@ class Admin::PostCommentsController < Admin::ApplicationController
 		if params[:post_id]
 			@post_comments = SpudPostComment.where(:spud_post_id => params[:post_id])
 		else
-			@post_comments = SpudPostComment
+			@post_comments = SpudPostComment.for_blog(params[:blog_key])
 		end
-		@post_comments = @post_comments.order('created_at desc').includes(:post).paginate(:page => params[:page], :per_page => 15)
+		@post_comments = @post_comments.ordered.includes(:post).paginate(:page => params[:page], :per_page => 15)
 		respond_with @post_comments
 	end
 
@@ -40,7 +41,7 @@ class Admin::PostCommentsController < Admin::ApplicationController
 		@post_comment.spam = false
 		@post_comment.approved = true
 		@post_comment.save()
-		redirect_to request.referer || admin_post_comments_path
+		redirect_to request.referer || admin_post_post_comments_path(@post_comment.post)
 	end
 
 	def spam
@@ -50,20 +51,32 @@ class Admin::PostCommentsController < Admin::ApplicationController
 		@post_comment.spam = true
 		@post_comment.approved = false
 		@post_comment.save()
-		redirect_to request.referer || admin_post_comments_path
+		redirect_to request.referer || admin_post_post_comments_path(@post_comment.post)
 	end
 
 	def destroy
 		if !@post_comment.destroy
 			flash[:error] = "Whoops! Something odd happened while trying to delete that comment. Thats not fun. please try again."
 		end
-		respond_with @post_comment, :location => request.referer || admin_post_comments_path
+		respond_with @post_comment, :location => request.referer || admin_post_post_comments_path(@post_comment.post)
 	end
 
-	private
+private
 
 	def find_comment
 		@post_comment = SpudPostComment.find(params[:id])
 	end
 
+	def load_blog
+		logger.debug 'load_blog'
+		key = params[:blog_key]
+		config = Spud::Blog.config.blogs.find{ |it| it[:key] == key }
+		if key.blank? || config.blank?
+			redirect_to admin_root_path
+			return false
+		else
+			self.class.belongs_to_spud_app config[:name].parameterize.underscore.to_sym
+		end
+	end
+
 end

data/app/controllers/admin/posts_controller.rb

@@ -1,23 +1,20 @@
 class Admin::PostsController < Admin::ApplicationController
+	include BlogUrlHelpers
 
 	respond_to :html, :xml, :json
-	before_filter :find_post, :only => [:show, :edit, :update, :destroy]
-	add_breadcrumb 'Blog Posts', :admin_posts_path
-	belongs_to_spud_app :blog_posts
+	before_action :load_blog
+	before_action :find_post, :only => [:show, :edit, :update, :destroy]
 
 	def index
-		@posts = SpudPost.where(:is_news => false).order('published_at desc').includes(:pending_comments, :author).paginate(:page => params[:page], :per_page => 15)
+		@posts = SpudPost.for_blog(params[:blog_key]).ordered.includes(:pending_comments, :author).paginate(:page => params[:page], :per_page => 15)
 		respond_with @posts
 	end
 
 	def edit
-		@categories = SpudPostCategory.ordered
 		respond_with @post
 	end
 
 	def update
-		@categories = SpudPostCategory.ordered
-		params[:spud_post][:spud_site_ids] ||= []
 		params[:spud_post][:updated_at] = Time.now()
 		if @post.update_attributes(post_params)
 			flash[:notice] = 'Post was successfully updated.'
@@ -27,14 +24,14 @@ class Admin::PostsController < Admin::ApplicationController
 
 	def new
 		@categories = SpudPostCategory.ordered
-		@post = SpudPost.new(:published_at => Time.zone.now, :spud_user_id => current_user.id, :spud_site_ids => [session[:admin_site] || 0])
+		@post = SpudPost.new(:published_at => Time.zone.now, :spud_user_id => current_user.id)
 		respond_with @post
 	end
 
 	def create
 		@categories = SpudPostCategory.ordered
-		params[:spud_post][:spud_site_ids] ||= []
 		@post = SpudPost.new(post_params)
+		@post.blog_key = params[:blog_key]
 		if @post.save
 	    flash[:notice] = 'Post was successfully created.'
 		end
@@ -59,11 +56,21 @@ private
 	end
 
 	def post_params
-		permitted = [:published_at, :title, :content, :spud_user_id, :url_name, :visible, :comments_enabled, :meta_keywords, :meta_description, :content_format, :category_ids => [], :spud_site_ids => []]
+		permitted = [:published_at, :title, :content, :spud_user_id, :url_name, :visible, :comments_enabled, :meta_keywords, :meta_description, :content_format, :category_ids => []]
 		if Spud::Blog.permitted_attributes.present?
 			permitted = permitted + Spud::Blog.permitted_attributes
 		end
 		params.require(:spud_post).permit(permitted)
 	end
 
+	def load_blog
+		@config = SpudBlogConfig.find(params[:blog_key])
+		if @config.blank?
+			redirect_to admin_root_path
+			return false
+		else
+			self.class.belongs_to_spud_app "#{@config.name} Posts".parameterize.underscore.to_sym
+			add_breadcrumb "#{@config.name} Posts", admin_posts_path(blog_key: @config.key)
+		end
+	end
 end

data/app/controllers/concerns/blog_url_helpers.rb

@@ -0,0 +1,60 @@
+module BlogUrlHelpers
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :posts_path, :post_path, :post_category_path, :post_archive_path,
+      :admin_posts_path, :admin_post_path, :new_admin_post_path, :edit_admin_post_path, :admin_post_post_comments_path, :admin_post_comments_path
+  end
+
+  def posts_path(opts={})
+    url_for opts.merge({:controller => '/posts', :action => 'index', :blog_key => params[:blog_key]})
+  end
+
+  def post_path(url_name, opts={})
+    url_for opts.merge({:controller => '/posts', :action => 'show', :id => url_name, :blog_key => params[:blog_key]})
+  end
+
+  def post_category_path(category_url_name, opts={})
+    url_for opts.merge({:controller => '/posts', :action => 'category', :category_url_name => category_url_name, :blog_key => params[:blog_key]})
+  end
+
+  def post_archive_path(archive_date, opts={})
+    url_for opts.merge({:controller => '/posts', :action => 'archive', :archive_date => archive_date, :blog_key => params[:blog_key]})
+  end
+
+  def post_category_archive_path(category_url_name, archive_date, opts={})
+    url_for opts.merge({:controller => '/posts', :action => 'category', :category_url_name => category_url_name, :archive_date => archive_date, :blog_key => params[:blog_key]})
+  end
+
+#
+# Admin
+#
+
+  def admin_posts_path(blog_key: nil)
+    blog_key ||= params[:blog_key]
+    url_for :controller => '/admin/posts', :action => 'index', :blog_key => blog_key
+  end
+
+  def new_admin_post_path(blog_key: nil)
+    blog_key ||= params[:blog_key]
+    url_for :controller => '/admin/posts', :action => 'new', :blog_key => blog_key
+  end
+
+  def admin_post_path(post)
+    url_for :controller => '/admin/posts', :action => 'show', :id => post.id, :blog_key => post.blog_key
+  end
+
+  def edit_admin_post_path(post)
+    url_for :controller => '/admin/posts', :action => 'edit', :id => post.id, :blog_key => post.blog_key
+  end
+
+  def admin_post_comments_path(blog_key: nil)
+    blog_key ||= params[:blog_key]
+    url_for :controller => '/admin/post_comments', :action => 'index', :blog_key => blog_key
+  end
+
+  def admin_post_post_comments_path(post)
+    url_for :controller => '/admin/post_comments', :action => 'index', :post_id => post.id, :blog_key => post.blog_key
+  end
+
+end

data/app/controllers/posts_controller.rb

@@ -0,0 +1,140 @@
+class PostsController < ApplicationController
+  include BlogUrlHelpers
+
+	respond_to :html, :json, :rss
+
+  before_action :load_blog
+  before_action :find_post, :only => [:show, :create_comment]
+
+  def index
+    @posts = SpudPost.for_user(current_user).visible.for_blog(params[:blog_key]).ordered.paginate(:page => get_page_number, :per_page => Spud::Blog.config.posts_per_page)
+    respond_with @posts do |format|
+      format.html{
+        render view_for_action('index')
+      }
+    end
+  end
+
+  # The sole purpose of this action is to redirect from a POST to an seo-friendly url
+  def filter
+    if !params[:category_url_name].blank? && !params[:archive_date].blank?
+      redirect_to post_category_archive_path(params[:category_url_name], params[:archive_date])
+    elsif !params[:category_url_name].blank?
+      redirect_to post_category_path(params[:category_url_name])
+    elsif !params[:archive_date].blank?
+      redirect_to post_archive_path(params[:archive_date])
+    else
+      redirect_to posts_path
+    end
+  end
+
+  def category
+    page = 1
+    if params[:page].blank? == false
+      page = params[:page].to_i
+      if page.to_s != params[:page].to_s
+        if(page > 1)
+          redirect_to post_category_path(:page => page),:status => :moved_permanently and return
+        else
+          redirect_to post_category_path(:page => nil),:status => :moved_permanently and return
+        end
+      end
+    end
+    if @post_category = SpudPostCategory.find_by_url_name(params[:category_url_name])
+      @posts = @post_category.posts.for_user(current_user).visible.for_blog(params[:blog_key]).from_archive(params[:archive_date]).paginate(:page => page, :per_page => Spud::Blog.config.posts_per_page)
+    else
+      redirect_to posts_path
+      return
+    end
+    respond_with @posts do |format|
+      format.html { render view_for_action 'index' }
+    end
+  end
+
+  def archive
+    @posts = SpudPost.for_user(current_user).visible.for_blog(params[:blog_key]).from_archive(params[:archive_date]).paginate(:page => get_page_number, :per_page => Spud::Blog.config.posts_per_page)
+    respond_with @posts do |format|
+      format.html { render view_for_action 'index' }
+    end
+  end
+
+  def show
+    if @post.comments_enabled
+      @comment = SpudPostComment.new()
+    end
+  	respond_with @post do |format|
+      format.html { render view_for_action 'show' }
+    end
+  end
+
+  def create_comment
+    unless params[:comment_validation].blank? # trap spam bots
+      render :nothing => true
+      return
+    end
+    @comment = @post.comments.new(comment_params)
+    @comment.user_agent = request.env["HTTP_USER_AGENT"]
+    @comment.user_ip = request.remote_ip
+    @comment.referrer = request.referrer
+    @comment.approved = Spud::Blog.default_comment_approval
+    @comment.permalink = post_path(@post.url_name)
+    if @comment.save
+      if @comment.approved?
+        flash[:notice] = 'Your comment has been posted.'
+      else
+        flash[:notice] = 'Your comment has been saved and will appear after being reviewed by an administrator.'
+      end
+      @comment = SpudPostComment.new()
+    end
+    respond_with @comment do |format|
+    	format.html { render view_for_action 'show' }
+    end
+  end
+
+private
+
+  def find_post
+    @post = SpudPost.for_user(current_user).for_blog(params[:blog_key]).where(:url_name => params[:id]).first
+		if @post.blank? || @post.is_private?
+			raise Spud::NotFoundError.new(:item => 'post')
+		end
+  end
+
+  def comment_params
+    params.require(:spud_post_comment).permit(:author, :content)
+  end
+
+  def get_page_number
+    page = 1
+    if params[:page].present?
+      page = params[:page].to_i
+      if page.to_s != params[:page].to_s
+        if(page > 1)
+          redirect_to posts_path(:page => page), :status => :moved_permanently and return
+        else
+          redirect_to posts_path(:page => nil), :status => :moved_permanently and return
+        end
+      end
+    end
+    return page
+  end
+
+  def load_blog
+    @config = SpudBlogConfig.find(params[:blog_key])
+    if @config.blank?
+      raise Spud::NotFoundError(:item => 'blog')
+      return false
+    else
+      self.class.layout(@config.layout)
+    end
+  end
+
+  def view_for_action(action)
+    if File.exist?(Rails.root.join("app/views/#{@config.key}/#{action}.html.erb"))
+      return "#{@config.key}/#{action}"
+    else
+      return action
+    end
+  end
+
+end

data/app/helpers/blog_helper.rb

@@ -1,24 +1,19 @@
 module BlogHelper
 
 	def spud_post_category_select
-		return select_tag 'category_url_name', 
-			options_for_select(SpudPostCategory.options_for_categories(), params[:category_url_name]), 
-			:include_blank => true,
-			:rel => 'category'
+		return select_tag('category_url_name',
+			options_from_collection_for_select(SpudPostCategory.ordered, :url_name, :name, params[:category_url_name]),
+			{:prompt => 'All Categories'})
 	end
 
 	def spud_post_archive_select
 		return select_tag 'archive_date', options_for_select(SpudPost.months_with_public_posts.collect{ |d| 
 			[d.strftime('%B %Y'), d.strftime('%Y-%b').downcase]
-		}, params[:archive_date]), :include_blank => true, :rel => 'archive'
+		}, params[:archive_date]), :prompt => 'All Dates', :rel => 'archive'
 	end
 
 	def spud_blog_rss_link
-		return tag :link, :rel => 'alternate', :type => 'application/rss+xml', :title => "#{Spud::Core.site_name} Blog RSS", :href => blog_url(:format => :rss)
+		return tag :link, :rel => 'alternate', :type => 'application/rss+xml', :title => "#{Spud::Core.site_name} Blog RSS", :href => posts_path(:format => :rss)
 	end
 
-	def spud_news_rss_link
-		return tag(:link, :rel => 'alternate', :type => 'application/rss+xml', :title => "#{Spud::Core.site_name} News RSS", :href => news_url(:format => :rss))
-	end
-
-end
+end

data/app/models/spud/spud_post_model.rb

@@ -14,11 +14,12 @@ class Spud::SpudPostModel < ActiveRecord::Base
   has_many :pending_comments, ->{ where(:spam => [nil, false], :approved => false) }, :class_name => "SpudPostComment", :foreign_key => 'spud_post_id'
   has_many :visible_comments, ->{ where(:spam => [nil,false], :approved => true) }, :class_name => 'SpudPostComment', :foreign_key => 'spud_post_id'
   has_many :spam_comments, ->{ where(:spam => true) }, :class_name => "SpudPostComment", :foreign_key => 'spud_post_id'
-  has_many :spud_permalinks,:as => :attachment
-  has_many :spud_post_sites, :dependent => :destroy
+  has_many :spud_permalinks, :as => :attachment
+  has_many :spud_post_sites, :dependent => :destroy, :foreign_key => 'spud_post_id'
 
-  scope :blog_posts, ->{ where(:is_news => false) }
-  scope :news_posts, ->{ where(:is_news => true) }
+  scope :blog_posts, ->{ for_blog('blog') }
+  scope :news_posts, ->{ for_blog('news') }
+  scope :for_blog, ->(key){ where(:blog_key => key) }
   scope :visible, ->{ where('visible = true AND published_at <= ?', Time.now.utc) }
   scope :ordered, ->{ order('published_at desc') }
 
@@ -43,21 +44,6 @@ class Spud::SpudPostModel < ActiveRecord::Base
     return joins(:spud_post_sites).where(:spud_post_sites => {:spud_site_id => spud_site_id})
   end
 
-  def self.public_posts(page, per_page)
-    ActiveSupport::Deprecation.warn "SpudPost.public_posts is deprecated. Please the :visible, and :ordered scopes instead.", caller
-    return where('visible = ? AND published_at <= ?', true,Time.now.utc).order('published_at desc').paginate(:page => page, :per_page => per_page)
-  end
-
-  def self.public_blog_posts(page, per_page)
-    ActiveSupport::Deprecation.warn "SpudPost.public_blog_posts is deprecated. Please the :blog_posts, :visible, and :ordered scopes instead.", caller
-    return self.public_posts(page, per_page).where(:is_news => false)
-  end
-
-  def self.public_news_posts(page, per_page)
-    ActiveSupport::Deprecation.warn "SpudPost.public_news_posts is deprecated. Please the :news_posts, :visible, and :ordered scopes instead.", caller
-    return self.public_posts(page, per_page).where(:is_news => true)
-  end
-
   def self.recent_posts(limit=5)
     return where('visible = ? AND published_at <= ?', true, Time.now.utc).order('published_at desc').limit(limit)
   end
@@ -75,10 +61,16 @@ class Spud::SpudPostModel < ActiveRecord::Base
       date = Date.strptime(date_string, "%Y-%b")
       return where(:published_at => date..date.end_of_month)
     rescue
-      return all
+      logger.debug 'fallback'
+      return where('')
     end
   end
 
+  def is_news
+    ActiveSupport::Deprecation.warn ":is_news is deprecated. Please rely on the :blog_key column stead.", caller
+    return self.read_attribute(:is_news)
+  end
+
   #def self.posts_for_category_archive(category, )
 
   # Returns an array of Date objects for months with public posts
@@ -100,24 +92,6 @@ class Spud::SpudPostModel < ActiveRecord::Base
     end
   end
 
-  def self.months_with_public_news_posts
-    records = SpudPost.select('Extract(Month from published_at) as published_month, Extract(Year from published_at) as published_year').where('visible = ? AND published_at < ? AND is_news = ?', true, DateTime.now, true).group('published_month, published_year').order('published_year desc, published_month desc')
-    begin
-      return records.collect{ |r| Date.new(r[:published_year].to_i, r[:published_month].to_i) }
-    rescue Exception => e
-      logger.fatal "Exception occurred while fetching post archive dates:\n #{e.to_s}"
-    end
-  end
-
-  def self.months_with_public_blog_posts
-    records = SpudPost.select('Extract(Month from published_at) as published_month, Extract(Year from published_at) as published_year').where('visible = ? AND published_at < ? AND is_news = ?', true, DateTime.now, false).group('published_month, published_year').order('published_year desc, published_month desc')
-    begin
-      return records.collect{ |r| Date.new(r[:published_year].to_i, r[:published_month].to_i) }
-    rescue Exception => e
-      logger.fatal "Exception occurred while fetching post archive dates:\n #{e.to_s}"
-    end
-  end
-
   def postprocess_content
     # if self.content_format == 'Markdown'
     #   require 'redcarpet'

data/app/models/spud_blog_config.rb

@@ -0,0 +1,26 @@
+class SpudBlogConfig
+
+  def self.push(config)
+    Spud::Blog.config.blogs.push(new(config))
+  end
+
+  def self.find(key)
+    return Spud::Blog.config.blogs.find{ |it| it.key == key }
+  end
+
+  def self.each
+    Spud::Blog.config.blogs.each do |config|
+      yield(config)
+    end
+  end
+
+  attr_accessor :name, :key, :path, :layout
+
+  def initialize(name:, key:, path:, layout:nil)
+    @name = name
+    @key = key
+    @path = path
+    @layout = layout || Spud::Blog.config.base_layout
+  end
+
+end

data/app/models/spud_post_category.rb

@@ -15,10 +15,6 @@ class SpudPostCategory < ActiveRecord::Base
 
 	scope :ordered, ->{ order('name asc') }
 
-	def self.options_for_categories()
-		return ordered.select(:name, :url_name).collect{ |c| [c.name, c.url_name] }
-	end
-
 private
 
 	def set_url_name

data/app/models/spud_post_comment.rb

@@ -8,6 +8,12 @@ class SpudPostComment < ActiveRecord::Base
 	validates_presence_of :author, :content
 	belongs_to :post, :class_name => 'SpudPost', :foreign_key => 'spud_post_id', :counter_cache => :comments_count, :inverse_of => :comments, :touch => true
 
+  scope :for_blog, ->(key){ where(:blog_key => key) }
+  scope :pending_approval, ->{ where(:approved => nil) }
+  scope :ordered, ->{ order('created_at desc') }
+
+  before_save :set_blog_key
+
   def visible?
     return approved && !spam
   end
@@ -24,4 +30,13 @@ private
     return true
   end
 
+  def set_blog_key
+    self.blog_key = self.post.blog_key
+  end
+
 end
+
+# To update current comments
+# SpudPostComment.all.each do |comment|
+#   comment.update_column(:blog_key, comment.post.blog_key)
+# end

data/app/views/admin/post_comments/index.html.erb

@@ -21,7 +21,7 @@
                 <span class="spud-post-comment-details-timestamp"><%= timestamp(comment.created_at) %></span>
               </p>
               <p class="spud-post-comment-details-title">
-                <%= link_to truncate(comment.post.title, {:length => 100}), blog_post_path(comment.post.url_name), :target => :blank %>
+                <%= link_to truncate(comment.post.title, {:length => 100}), post_path(comment.post.url_name), :target => :blank %>
               </p>
               <p>
                 <span class="spud-post-comment-details-content"><%= comment.content %></span>

data/app/views/admin/posts/_form.html.erb

@@ -66,17 +66,15 @@
 				</div>
 			</div>
 
-			<% unless @post.is_news %>
-				<div class="spud_post_form_row">
-					<%= f.label :comments_enabled,"Comments Enabled" %>
-					<div class="spud_post_form_input_group">
-						<%= f.radio_button :comments_enabled, true %>
-						<label class="radio inline" for="spud_post_comments_enabled_true">Yes</label>
-						<%= f.radio_button :comments_enabled, false %>
-						<label class="radio inline" for="spud_post_comments_enabled_false">No</label>
-					</div>
+			<div class="spud_post_form_row">
+				<%= f.label :comments_enabled,"Comments Enabled" %>
+				<div class="spud_post_form_input_group">
+					<%= f.radio_button :comments_enabled, true %>
+					<label class="radio inline" for="spud_post_comments_enabled_true">Yes</label>
+					<%= f.radio_button :comments_enabled, false %>
+					<label class="radio inline" for="spud_post_comments_enabled_false">No</label>
 				</div>
-			<% end %>
+			</div>
 
 			<div class="spud_post_form_row">
 				<%= f.label :meta_keywords, 'Keywords' %>
@@ -96,7 +94,7 @@
 			<%= link_to 'Add Category', new_admin_post_category_path, :class => 'btn btn-mini spud_post_add_category' %>
 			<input type="hidden" name="spud_post[category_ids][]" value="" />
 			<ul class="spud_post_categories_form">
-				<%= render :partial => '/admin/posts/category', :collection => @categories %>
+				<%= render :partial => '/admin/posts/category', :collection => SpudPostCategory.ordered %>
 			</ul>
 		</div>
 

data/app/views/admin/posts/index.html.erb

@@ -19,7 +19,7 @@
 			<% @posts.each do |post| %>
 				<tr>
 					<td>
-						<%= link_to post.title, blog_post_path(post.url_name), :target => :blank %>
+						<%= link_to post.title, post_path(post.url_name), :target => :blank %>
 						<% if !post.visible? %>
 							<span class="badge">Draft</span>
 						<% end %>
@@ -28,7 +28,7 @@
 					<td><%= post.published_at.strftime('%m/%d/%Y') %></td>
 					<td>
 						<%= post.pending_comments.length %>
-						<%= link_to "Manage", admin_post_post_comments_path(:post_id => post.id), :class => 'spud-post-comments-manage' %>
+						<%= link_to "Manage", admin_post_post_comments_path(post), :class => 'spud-post-comments-manage' %>
 					</td>
 					<td class="text-right">
 						<%= link_to 'Edit', edit_admin_post_path(post), :class => 'btn btn-small' %>

data/app/views/{blog → posts}/_comment_form.html.erb

@@ -1,4 +1,4 @@
-<%= form_for @comment, :url => blog_post_path(@post.url_name, :anchor => 'comment_form') do |f| %>
+<%= form_for @comment, :url => post_path(@post.url_name, :anchor => 'comment_form') do |f| %>
 	
 	<% if @comment.errors.any? %>
     <div class="comment_error_list">