rails_blog_engine 0.0.1

data/app/assets/stylesheets/rails_blog_engine/comments.css.scss

@@ -0,0 +1,29 @@
+.rails_blog_engine_comment.show {
+  border: 1px solid lightgrey;
+  padding: 10px 10px 0 10px;
+  margin-bottom: 20px;
+  max-width: 600px;
+
+  &.spam {
+    background: lighten(#ffb6c1, 10%);
+    border-color: lighten(#ffb6c1, 5%);
+    color: darkgrey;
+  }
+
+  >.byline {
+    margin-top: 0;
+    margin-bottom: 10px;
+    font-weight: normal;
+
+    a.comment-link {
+      color: inherit;
+      &:link, &:visited { text-decoration: none; }
+      &:hover, &:active { text-decoration: underline; }
+    }
+  }
+
+  >.comment-tools {
+    float: right;
+    margin: 0 0 10px 10px;
+  }
+}

data/app/assets/stylesheets/rails_blog_engine/posts.css.scss

@@ -0,0 +1,46 @@
+// Place all the styles for posts and lists of posts here.  We assume a
+// light background color.
+
+.rails_blog_engine_posts {
+  .new_post.btn, nav {
+    margin-bottom: 20px;
+  }
+}
+
+.rails_blog_engine_post {
+  color: black;
+  margin-bottom: 20px;
+
+  // Clear top margins. We'll use the bottom margin for spacing.
+  >h1, >p.byline, >.body {
+    margin-top: 0;
+  }
+
+  >h1 {
+    margin-bottom: 0px;
+    .btn {
+      vertical-align: text-bottom;
+    }
+  }
+
+  >p.byline {
+    margin-bottom: 10px;
+    color: grey;
+  }
+
+  // This works at both the top level and in nested comments.
+  .body {
+    >blockquote, >dl, >embed, >h1, >h2, >h3, >h4, >h5, >h6, >hr, >object, >ol,
+    >p, >pre, >table, >ul, >aside, >figure, >header, >hgroup, >section {
+      margin-bottom: 10px;
+    }
+  }
+
+  // We use this for moderation warnings.
+  >.flash.notice {
+    border: 1px solid #049cdb;
+    background: #c7eefe;
+    padding: 10px;
+    max-width: 600px;
+  }
+}

data/app/assets/stylesheets/rails_blog_engine/simple_form.css.scss

@@ -0,0 +1,70 @@
+.rails_blog_engine_post.simple_form, .rails_blog_engine_post .simple_form {
+
+// Copied from
+// https://github.com/plataformatec/simple_form/wiki/CSS-for-simple_form,
+// tweaked to remove .simple_form, and nested inside our namespace.
+div.input {
+  margin-bottom: 10px;
+}
+
+label {
+  float: left;
+  width: 100px;
+  text-align: right;
+  margin: 2px 10px;
+}
+
+div.boolean, input[type='submit'] {
+  margin-left: 120px;
+}
+
+div.boolean label, label.collection_radio {
+  float: none;
+  margin: 0;
+}
+
+label.collection_radio {
+  margin-right: 10px;
+  vertical-align: -2px;
+  margin-left:   2px;
+}
+
+.field_with_errors {
+  background-color: #ff3333;
+}
+
+.error {
+  clear:   left;
+  color:   black;
+  display: block;
+  margin-left: 120px;
+  font-size:    12px;
+}
+
+.hint {
+  clear: left;
+  margin-left: 120px;
+  font-size:    12px;
+  color: #555;
+  display: block;
+  font-style: italic;
+}
+
+input.radio {
+  margin-right: 5px;
+  vertical-align: -3px;
+}
+
+input.check_boxes {
+  margin-left: 3px;
+  vertical-align: -3px;
+}
+
+label.collection_check_boxes {
+  float: none;
+  margin: 0;
+  vertical-align: -2px;
+  margin-left:   2px;
+}
+
+}

data/app/assets/stylesheets/rails_blog_engine.css

@@ -0,0 +1,6 @@
+/*
+ * Include the CSS files required by rails_blog_engine.
+ *
+ *= require_self
+ *= require_tree ./rails_blog_engine
+*/

data/app/controllers/rails_blog_engine/application_controller.rb

@@ -0,0 +1,26 @@
+module RailsBlogEngine
+  class ApplicationController < ActionController::Base
+    # Use our parent application's layout, so that we "auto-blend" into
+    # the existing look-and-feel of the site.
+    layout 'application'
+
+    helper_method :post_permalink_url
+    helper_method :post_permalink_path
+
+    protected
+
+    def post_permalink_local_path(post)
+      date = post.published_at.utc
+      sprintf('%04d/%02d/%02d/%s', date.year, date.month,
+              date.day, post.permalink)
+    end
+
+    def post_permalink_path(post)
+      root_path + post_permalink_local_path(post)
+    end
+
+    def post_permalink_url(post)
+      root_url + post_permalink_local_path(post)
+    end
+  end
+end

data/app/controllers/rails_blog_engine/comments_controller.rb

@@ -0,0 +1,47 @@
+module RailsBlogEngine
+  class CommentsController < ApplicationController
+    before_filter :load_post
+
+    load_and_authorize_resource :class => "RailsBlogEngine::Comment"
+    skip_load_resource :create
+
+    def create
+      @comment = @post.comments.create(params[:comment]) do |c|
+        # Record some extra information from our environment.  Most of this
+        # is used by the spam filter.
+        c.author_ip = request.remote_ip
+        c.author_user_agent = request.env['HTTP_USER_AGENT']
+        c.author_can_post = can?(:create, RailsBlogEngine::Post)
+        c.referrer = request.env['HTTP_REFERER']
+      end
+
+      if @comment.valid?
+        @comment.run_spam_filter
+        if @comment.filtered_as_spam?
+          flash[:comment_notice] = "Your comment has been held for moderation."
+          redirect_to(post_permalink_path(@post) + '#comment-flash')
+        else
+          redirect_to(post_permalink_path(@post) + "#comment-#{@comment.id}")
+        end
+      else
+        render "new"
+      end
+    end
+
+    def mark_as_spam
+      @comment.mark_as_spam!
+      redirect_to(post_permalink_path(@post) + "#comment-#{@comment.id}")
+    end
+
+    def mark_as_ham
+      @comment.mark_as_ham!
+      redirect_to(post_permalink_path(@post) + "#comment-#{@comment.id}")
+    end
+
+    protected
+
+    def load_post
+      @post = Post.find(params[:post_id])
+    end
+  end
+end

data/app/controllers/rails_blog_engine/posts_controller.rb

@@ -0,0 +1,67 @@
+module RailsBlogEngine
+  class PostsController < ApplicationController
+    before_filter :load_recently_published, :only => :index
+    before_filter :load_by_permalink, :only => :show
+
+    load_and_authorize_resource :class => "RailsBlogEngine::Post"
+
+    def index
+      respond_to do |format|
+        format.html { @posts = @posts.page(params[:page]).per(5) }
+        format.atom { @posts = @posts.limit(15) }
+      end
+    end
+
+    def new
+    end
+
+    def create
+      @post.author = current_user
+      @post.publish
+      if @post.save
+        redirect_to(post_permalink_path(@post),
+                    :notice => "Post was successfully created.")
+      else
+        render :action => :new
+      end
+    end
+
+    def show
+      @comments = comments_to_display.order(:created_at)
+      @comment = Comment.new {|c| c.post = @post }
+    end
+
+    def edit
+    end
+
+    def update
+      @post.update_attributes(params[:post])
+      if @post.save
+        redirect_to(post_permalink_path(@post),
+                    :notice => "Post was successfully updated.")
+      else
+        render :action => :edit
+      end
+    end
+
+    protected
+
+    def load_recently_published
+      @posts = Post.recently_published
+    end
+
+    def load_by_permalink
+      date = Time.utc(params[:year], params[:month], params[:day])
+      @post = Post.where(:published_at => (date..date.end_of_day),
+                         :permalink => params[:permalink]).first!
+    end
+
+    def comments_to_display
+      if can?(:update, RailsBlogEngine::Comment)
+        @post.comments
+      else
+        @post.comments.visible
+      end
+    end
+  end
+end

data/app/helpers/rails_blog_engine/application_helper.rb

@@ -0,0 +1,52 @@
+module RailsBlogEngine
+  module ApplicationHelper
+    # Process a block of text as Markdown, using our filters, and sanitize
+    # any usafe HTML.  You can pass <code>:trusted? => true</code> to allow
+    # images and links without nofollow.
+    def markdown(md_text, options={})
+      config = sanitize_config(options[:trusted?] || false)
+      filtered = Filters.apply_all_to(md_text)
+      Sanitize.clean(RDiscount.new(filtered, :smart).to_html, config).html_safe
+    end
+
+    # The URL of our Atom feed. Rails refuses to generate this in any simple
+    # fashion, so we do it manually.
+    def feed_url
+      root_url + "posts.atom"
+    end
+
+    # Get extra HTML classes for the specified comment.
+    def comment_classes(comment)
+      comment.state.sub(/\A(filtered|marked)_as_/, '')
+    end
+
+    # Generate HTML describing the author of a comment.
+    def comment_author_html(comment)
+      if comment.author_url && !comment.author_url.blank?
+        link_to comment.author_byline, comment.author_url, :rel => "nofollow"
+      else
+        comment.author_byline
+      end
+    end
+
+    protected
+
+    # Choose a configuration for the Sanitizer gem.
+    def sanitize_config(trusted)
+      if trusted then CUSTOM_RELAXED_CONFIG else Sanitize::Config::BASIC end
+    end
+
+    # Allow a few extra tags, mostly for use by our source-code highlighting
+    # filter.
+    def self.customize_sanitize_config(sanitize_config)
+      new_config = {}
+      sanitize_config.each {|k,v| new_config[k] = v.dup }
+      new_config[:elements] += ['div', 'span']
+      new_config[:attributes].merge!('div' => ['class'], 'span' => ['class'])
+      new_config
+    end
+
+    # The Sanitize configuration used for trusted posters.
+    CUSTOM_RELAXED_CONFIG = customize_sanitize_config(Sanitize::Config::RELAXED)
+  end
+end

data/app/helpers/rails_blog_engine/comments_helper.rb

@@ -0,0 +1,4 @@
+module RailsBlogEngine
+  module CommentsHelper
+  end
+end

data/app/helpers/rails_blog_engine/posts_helper.rb

@@ -0,0 +1,13 @@
+module RailsBlogEngine
+  module PostsHelper
+    # Link to the comments section of a post.
+    def link_to_comments_section(post)
+      if post.comments.visible.empty?
+        link_to("Comment", post_permalink_path(post) + "#comments")
+      else
+        link_to(pluralize(post.comments.visible.count, 'comment'),
+                post_permalink_path(post) + "#comments")
+      end
+    end
+  end
+end

data/app/models/rails_blog_engine/comment.rb

@@ -0,0 +1,74 @@
+module RailsBlogEngine
+  class Comment < ActiveRecord::Base
+    # Define the functions spam?, spam!, and ham!.
+    include Rakismet::Model
+
+    belongs_to :post, :class_name => 'RailsBlogEngine::Post'
+
+    validates :author_byline, :presence => true
+    validates :body, :presence => true
+
+    # Comments that are visible to the public.
+    scope(:visible,
+          where(:state => ['unfiltered', 'filtered_as_ham', 'marked_as_ham']))
+
+    # These fields are directly settable by the user.
+    attr_accessible :author_byline, :author_email, :author_url, :body
+
+    # Tell rakismet where to find the fields it needs for the spam filter.
+    # We don't need to specify fields which already have the right name.
+    #
+    # TODO: Include article permalink.
+    rakismet_attrs(:author => :author_byline, :content => :body,
+                   :user_ip => :author_ip, :user_agent => :author_user_agent)
+
+    # A state machine which keeps track of our spam filter status.
+    state_machine :state, :initial => :unfiltered do
+      state :unfiltered
+      state :filtered_as_ham
+      state :filtered_as_spam
+      state :marked_as_ham
+      state :marked_as_spam
+
+      event :filter_as_ham do
+        transition :unfiltered => :filtered_as_ham
+      end
+
+      event :filter_as_spam do
+        transition :unfiltered => :filtered_as_spam
+      end
+
+      event :mark_as_ham do
+        transition [:filtered_as_spam, :marked_as_spam] => :marked_as_ham
+      end
+
+      event :mark_as_spam do
+        transition :unfiltered => :marked_as_spam
+        transition [:filtered_as_ham, :marked_as_ham] => :marked_as_spam
+      end
+
+      after_transition any => :marked_as_ham, :do => :train_as_ham
+      after_transition any => :marked_as_spam, :do => :train_as_spam
+    end
+
+    # Run the spam filter on this comment and update it appropriately.
+    def run_spam_filter
+      return unless Rakismet.key
+      if spam?
+        filter_as_spam!
+      else
+        filter_as_ham!
+      end
+    end
+
+    # Train our spam filter to treat messages like this as ham.
+    def train_as_ham
+      ham! if Rakismet.key
+    end
+
+    # Train our spam filter to treat messages like this as spam.
+    def train_as_spam
+      spam! if Rakismet.key
+    end
+  end
+end

data/app/models/rails_blog_engine/post.rb

@@ -0,0 +1,73 @@
+module RailsBlogEngine
+  class Post < ActiveRecord::Base
+    belongs_to :author, :polymorphic => true
+    has_many :comments, :class_name => 'RailsBlogEngine::Comment'
+
+    validates :title, :presence => true
+    validates :body, :presence => true
+    validates(:state, :presence => true,
+              :inclusion => { :in => %w(unpublished published) })
+    validates :permalink, :presence => true, :uniqueness => true
+    validates :author, :presence => true
+    validates :author_byline, :presence => true
+    validates :published_at, :presence => true, :if => :published?
+
+    attr_accessible :title, :body, :permalink, :author
+
+    # Recently published posts.  Use this with +limit+.
+    scope :recently_published,
+      where(:state => 'published').order('published_at DESC')
+
+    # We use a state machine to represent our publication state.  This is
+    # mostly because I visualize a UI with a great big "Publish" button,
+    # and not a "Published" checkbox in a form.
+    #
+    # If you'd like to upgrade your blog into a content-management system
+    # with some kind of pre-publication review, just adjust the states and
+    # transitions.
+    state_machine :state, :initial => :unpublished do
+      state :unpublished
+      state :published
+
+      event :publish do
+        transition :unpublished => :published
+      end
+
+      event :unpublish do
+        transition :published => :unpublished
+      end
+
+      before_transition any => :published do |post, transition|
+        post.published_at ||= Time.now
+      end
+    end
+
+    before_validation :record_author_byline
+
+    protected
+
+    # Since the byline is computed from a polymorphic author association in
+    # a complicated fashion, we want to cache it in this object where it's
+    # available all the time.
+    def record_author_byline
+      byline = self.class.author_byline(author)
+      self.author_byline = byline unless self.author_byline == byline
+    end
+
+    class << self
+      # Try to generate a reasonable byline for an author.  We use a
+      # +author.byline+ method if present, and default to +author.email+
+      # stripped of its domain.
+      def author_byline(author)
+        case
+        when author.respond_to?(:byline) && author.byline
+          author.byline
+        when author.respond_to?(:email) && author.email
+          author.email.sub(/@.*\z/, '')
+        else
+          'unknown'
+        end
+      end
+    end
+  end
+end

data/app/views/rails_blog_engine/comments/_comment.html.haml

@@ -0,0 +1,10 @@
+.rails_blog_engine_comment.show{:class => comment_classes(comment)}
+  = render(:partial => 'rails_blog_engine/comments/tools',
+           :locals => { :comment => comment })
+  %h4.byline
+    %a{:name => "comment-#{comment.id}"}
+      = comment_author_html(comment)
+      said
+      %a{:class => "comment-link", :href => "#comment-#{comment.id}"}= distance_of_time_in_words_to_now(comment.created_at)
+      ago:
+  %div.body~ markdown(comment.body, :trusted? => comment.author_can_post?)

data/app/views/rails_blog_engine/comments/_form.html.haml

@@ -0,0 +1,6 @@
+= simple_form_for(comment, :url => post_comments_path(comment.post)) do |f|
+  = f.input :author_byline
+  = f.input :author_email
+  = f.input :author_url
+  = f.input :body
+  = f.button :submit, :class => "new_comment btn primary"

data/app/views/rails_blog_engine/comments/_tools.html.haml

@@ -0,0 +1,10 @@
+- if can?(:update, comment)
+  .comment-tools
+    - if can?(:mark_as_ham, comment) && comment.can_mark_as_ham?
+      = link_to("Not Spam",
+                mark_as_ham_post_comment_path(comment.post, comment),
+                :method => :post, :class => "btn")
+    - if can?(:mark_as_spam, comment) && comment.can_mark_as_spam?
+      = link_to("Spam",
+                mark_as_spam_post_comment_path(comment.post, comment),
+                :method => :post, :class => "btn")

data/app/views/rails_blog_engine/comments/new.html.haml

@@ -0,0 +1,6 @@
+- content_for :title do
+  New Comment
+
+<h1>New Comment</h1>
+
+= render :partial => 'form', :locals => { :comment => @comment }

data/app/views/rails_blog_engine/posts/_comments_section.html.haml

@@ -0,0 +1,11 @@
+%h3.comments
+  %a(name="comments") Comments
+
+= render @comments
+
+- if flash[:comment_notice]
+  %p.flash.notice
+    %a(name="comment-flash")= flash[:comment_notice]
+
+= render(:partial => 'rails_blog_engine/comments/form',
+         :locals => { :comment => @comment })

data/app/views/rails_blog_engine/posts/_form.html.haml

@@ -0,0 +1,7 @@
+= simple_form_for(post,
+                  :input_html => { :class => "rails_blog_engine_post" }) do |f|
+  = f.input :title
+  = f.input :permalink
+  = f.input :body
+  = f.input :published_at
+  = f.button :submit, :class => "update_post btn primary"

data/app/views/rails_blog_engine/posts/_post.html.haml

@@ -0,0 +1,20 @@
+.rails_blog_engine_post
+  %h1
+    = link_to_unless_current(post.title, post_permalink_path(post))
+    = render(:partial => 'rails_blog_engine/posts/tools',
+             :locals => { :post => post })
+  %p.byline
+    Posted
+    = distance_of_time_in_words_to_now(post.published_at)
+    ago by
+    = post.author_byline
+
+  %div.body~ markdown(post.body, :trusted? => true)
+
+  - if current_page?(post_permalink_path(post))
+    = render(:partial => 'rails_blog_engine/posts/comments_section',
+             :locals => { :post => post, :comments => @comments,
+                          :comment => @comment })
+  - else
+    %p.links
+      = link_to_comments_section(post)

data/app/views/rails_blog_engine/posts/_tools.html.haml

@@ -0,0 +1,2 @@
+- if can?(:update, RailsBlogEngine::Post)
+  = link_to "Edit", edit_post_path(post), :class => "edit_post btn secondary"

data/app/views/rails_blog_engine/posts/edit.html.haml

@@ -0,0 +1,5 @@
+- content_for :title do
+  Edit Post
+%h1 Edit Post
+
+= render :partial => 'form', :locals => { :post => @post }

data/app/views/rails_blog_engine/posts/index.atom.builder

@@ -0,0 +1,14 @@
+atom_feed(:root_url => root_url, :url => feed_url) do |feed|
+  feed.title t('rails_blog_engine.blog.title')
+  feed.updated @posts.map(&:updated_at).sort.reverse.first
+  @posts.each do |post|
+    feed.entry(post, :published => post.published_at,
+               :url => post_permalink_url(post)) do |entry|
+      entry.title post.title
+      entry.content markdown(post.body), :type => 'html'
+      entry.author do |author|
+        author.name post.author_byline
+      end
+    end
+  end
+end

data/app/views/rails_blog_engine/posts/index.html.haml

@@ -0,0 +1,15 @@
+- content_for :title do
+  = t('rails_blog_engine.blog.title')
+- content_for :head do
+  = auto_discovery_link_tag :atom, feed_url
+  - if params[:page]
+    -# Don't index pages after the first, but still follow links.
+    - content_for :head do
+      %meta(name="robots" content="noindex, follow")
+
+.rails_blog_engine_posts
+  - if can?(:create, RailsBlogEngine::Post)
+    = link_to "New Post", new_post_path, :class => "new_post btn large primary"
+
+  = render @posts
+  = paginate @posts

data/app/views/rails_blog_engine/posts/new.html.haml

@@ -0,0 +1,5 @@
+- content_for :title do
+  New Post
+%h1 New Post
+
+= render :partial => 'form', :locals => { :post => @post }

data/app/views/rails_blog_engine/posts/show.html.haml

@@ -0,0 +1,8 @@
+- content_for :title do
+  = @post.title
+  —
+  = t('rails_blog_engine.blog.title')
+- content_for :head do
+  = auto_discovery_link_tag :atom, feed_url
+
+= render @post

data/config/locales/rails_blog_engine.en.yml

@@ -0,0 +1,15 @@
+en:
+  rails_blog_engine:
+    blog:
+      title: "Blog"
+  activerecord:
+    attributes:
+      rails_blog_engine/comment:    
+        author_byline: "Your name"
+        author_email: "Your email"
+        author_url: "Your website"
+        body: "Comment"
+  helpers:
+    submit:
+      comment:
+        create: "Post Comment"