mist 0.6.0

data/app/assets/stylesheets/mist_core.css

@@ -0,0 +1,4 @@
+/*
+ *= require_self
+ *= require_tree ./mist
+*/

data/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+end
+

data/app/controllers/mist/posts_controller.rb

@@ -0,0 +1,130 @@
+class Mist::PostsController < ApplicationController
+  # caches_action :index, :cache_path => proc { cache_path }
+  caches_page :feed
+  caches_page :index, :cache_path => proc { cache_path }
+  caches_action :show, :cache_path => proc { cache_path }
+  before_filter :bump_post_popularity, :only => :show
+  cache_sweeper Mist::PostSweeper
+  
+  # GET /posts
+  # GET /posts.json
+  def index
+    if Mist.authorized? :view_drafts, self
+      @posts = Mist::Post.last(20).reverse
+    else
+      @posts = Mist::Post.recently_published(20)
+    end
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render :json => @posts }
+    end
+  end
+  
+  # GET /posts/feed
+  def feed
+    respond_to do |format|
+      format.atom do
+        @title = Mist.title
+        @posts = Mist::Post.all_by_publication_date
+        unless @posts.empty?
+          @updated = @posts.inject(@posts.first.updated_at) do |date, post|
+            date > post.updated_at ? date : post.updated_at
+          end
+        end
+        render :layout => false
+      end
+      format.rss { redirect_to feed_posts_path(:format => :atom), :status => :moved_permanently }
+    end
+  end
+
+  # GET /posts/1
+  # GET /posts/1.json
+  def show
+    @post ||= Mist::Post.find(params[:id])
+
+    respond_to do |format|
+      format.html # show.html.erb
+      format.json { render :json => @post }
+    end
+  end
+
+  # GET /posts/new
+  # GET /posts/new.json
+  def new
+    redirect_to posts_path and return unless Mist.authorized?(:create_post, self)
+    @post = Mist::Post.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render :json => @post }
+    end
+  end
+
+  # GET /posts/1/edit
+  def edit
+    redirect_to posts_path and return unless Mist.authorized?(:update_post, self)
+    @post = Mist::Post.find(params[:id])
+  end
+
+  # POST /posts
+  # POST /posts.json
+  def create
+    redirect_to posts_path and return unless Mist.authorized?(:create_post, self)
+    @post = Mist::Post.new(params[:post])
+
+    respond_to do |format|
+      if @post.save
+        format.html { redirect_to @post, :notice => 'Post was successfully created.' }
+        format.json { render :json => @post, :status => :created, :location => @post }
+      else
+        format.html { render :action => "new" }
+        format.json { render :json => @post.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /posts/1
+  # PUT /posts/1.json
+  def update
+    redirect_to posts_path and return unless Mist.authorized?(:update_post, self)
+    @post = Mist::Post.find(params[:id])
+
+    respond_to do |format|
+      if @post.update_attributes(params[:post])
+        format.html { redirect_to @post, :notice => 'Post was successfully updated.' }
+        format.json { head :ok }
+      else
+        format.html { render :action => "edit" }
+        format.json { render :json => @post.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /posts/1
+  # DELETE /posts/1.json
+  def destroy
+    redirect_to posts_path and return unless Mist.authorized?(:destroy_post, self)
+    @post = Mist::Post.find(params[:id])
+    @post.destroy
+
+    respond_to do |format|
+      format.html { redirect_to posts_url }
+      format.json { head :ok }
+    end
+  end
+  
+  private
+  def cache_path
+    options = Mist.authorized_actions.inject(ActiveSupport::OrderedHash.new) do |hash, key|
+      hash[key] = true if Mist.authorized?(key, self)
+      hash
+    end
+  end
+  
+  def bump_post_popularity
+    @post = Mist::Post.find(params[:id])
+    redirect_to posts_path and return unless @post.published? || Mist.authorized?(:view_drafts, self)
+    Mist::Post.increase_popularity(@post) if @post
+  end
+end

data/app/helpers/mist/posts_helper.rb

@@ -0,0 +1,61 @@
+module Mist::PostsHelper
+  def authorized_link(type, *link_options)
+    if authorized? type
+      link_to *link_options
+    else
+      ""
+    end
+  end
+  
+  def authorized_links(separator, *link_options)
+    link_options.collect { |link_args| authorized_link(*link_args) }.reject { |a| a.blank? }.join(separator).html_safe
+  end
+  
+  def admin_link_separator
+    ' • '.html_safe
+  end
+  
+  def authorized?(type)
+    Mist.authorized? type, controller
+  end
+  
+  def render_posts
+    preview = false
+    @posts.collect { |post|
+      if post.published? || authorized?(:view_drafts)
+        render(:partial => 'post', :locals => { :post => post, :preview => preview }).tap do
+          preview = true
+        end
+      else
+        ""
+      end
+    }.join.html_safe
+  end
+  
+  def recent_posts(count = 5)
+    @recent_posts ||= {}
+    @recent_posts[count] ||= begin
+      # without SQL, we don't have access to conveniences like Post.where(:published),
+      # so instead just find 2x count and return those that are published.
+      result = Mist::Post.recently_published count*2
+      result = result[0...count] if result.length > count
+      result
+    end
+  end
+  
+  def popular_posts(count = 5)
+    # same as recent posts -- get twice as many and filter out the extras
+    @popular_posts ||= {}
+    @popular_posts[count] ||= begin
+      result = Mist::Post.most_popular(count*2).select { |post| post.published? }
+      result = result[0...count] if result.length > count
+      result
+    end
+  end
+  
+  def similar_posts(count = 5)
+    return [] if @post.nil?
+    @similar_posts ||= {}
+    @similar_posts[count] ||= @post.similar_posts(count)
+  end
+end

data/app/models/mist/post.rb

@@ -0,0 +1,240 @@
+class Mist::Post < Mist::GitModel
+  TAG_DELIM = /\s*,\s*/
+  include Mist::Permalink
+
+  validates_presence_of :title
+  validates_presence_of :content
+  
+  validate do |record|
+    if record.new_record? && self.class.exist?(record.id)
+      record.errors.add :title, 'has already been taken'
+    end
+  end
+  
+  timestamps
+  attribute :content
+  attribute :title
+  attribute :published_at
+  attribute :gist_id
+  attribute :popularity, :default => 0
+  attribute :tags, :default => []
+  
+  before_validation { |r| r.id = permalink(r.title) unless r.title.blank? }
+  after_validation :update_gist_if_necessary
+  after_save :update_meta
+  after_initialize :load_code_examples_from_gist
+  after_destroy :destroy_gist
+  
+  def self.load_existing_with_attribute(attribute_name, array)
+    array.collect { |(post_id, attribute_value)| find post_id, attribute_name => attribute_value }.reject { |i| i.nil? }
+  end
+  
+  def self.most_popular(count)
+    # invert <=> so that result is descending order
+    load_existing_with_attribute :popularity, self[:popular_posts].sort { |a, b| -(a[1].to_i <=> b[1].to_i) }
+  end
+  
+  def self.increase_popularity(post)
+    self[:popular_posts][post.id] = popularity_for(post.id) + 1
+    save_meta_data :popular_posts
+    post.popularity = self[:popular_posts][post.id]
+  end
+  
+  def self.popularity_for(post_id)
+    self[:popular_posts][post_id] || 0
+  end
+  
+  def self.recently_published(count)
+    all_by_publication_date.tap do |result|
+      result.pop while result.length > count
+    end
+  end
+  
+  def self.all_by_publication_date
+    # invert <=> so that result is descending order
+    load_existing_with_attribute :published_at, self[:published_at].sort { |a, b| -(a[1] <=> b[1]) }
+  end
+  
+  def self.matching_tags(tags)
+    return [] if tags.blank?
+    matches = self[:tags].inject({}) { |h,(k,v)| ((t = v.split(TAG_DELIM)) & tags).size > 0 ? h[k] = t : nil; h }
+    load_existing_with_attribute :tags, matches.sort { |a, b| -((a[1] & tags).size <=> (b[1] & tags).size) }
+  end
+  
+  def similar_posts(max_count = nil)
+    self.class.matching_tags(tags).tap do |matching|
+      matching.delete self # similar does not mean identical :)
+      while max_count && matching.length > max_count
+        matching.pop
+      end
+    end
+  end
+  
+  def tags=(t)
+    if t.kind_of?(String)
+      attributes[:tags] = t.split(TAG_DELIM)
+    else
+      attributes[:tags] = t
+    end
+  end
+  
+  def update_meta
+    if popularity_changed? || new_record?
+      self.class[:popular_posts][id] = popularity
+      self.class.save_meta_data :popular_posts
+    end
+    
+    if published_at_changed?
+      if published_at.blank?
+        self.class[:published_at].delete id
+      else
+        self.class[:published_at][id] = published_at
+      end
+      self.class.save_meta_data :published_at
+    end
+    
+    if tags && !tags.empty?
+      self.class[:tags][id] = tags.join(', ')
+    else
+      self.class[:tags].delete id
+    end
+    self.class.save_meta_data :tags
+  end
+  
+  def title=(value)
+    attributes[:title] = value
+  end
+  
+  def published?
+    !published_at.blank?
+  end
+  
+  def draft?
+    !published?
+  end
+  
+  def publish
+    self.published_at = Time.now unless published?
+  end
+  
+  def unpublish
+    self.published_at = nil
+  end
+  
+  def published=(bool)
+    bool ? publish : unpublish
+  end
+  
+  def content=(c)
+    attributes[:content] = c.gsub(/\r/, "")
+  end
+  
+  def generated_gist_description
+    'Code examples for "%s" - %s' % [title, url]
+  end
+  
+  def gist
+    @gist ||= begin
+      if gist_id.blank?
+        if has_code_examples?
+          ActiveGist.new(:description => generated_gist_description, :public => true)
+        else
+          nil
+        end
+      else
+        begin
+          ActiveGist.find(gist_id)
+        rescue RestClient::ResourceNotFound
+          self.gist_id = nil
+          nil
+        end
+      end
+    end
+  end
+  
+  def content_as_html
+    GitHub::Markup.render("#{title}.markdown", content_with_embedded_gists).html_safe
+  end
+  
+  def content_as_html_preview
+    # just take to the first blank line -- that's probably the first paragraph
+    # TODO make this smarter by including more than 1 paragraph if it's short, or by omitting headers
+    first_paragraph = /\A(.+?)(\n\n|\n    |\z)/m.match(content.gsub(/\r/, ''))
+    GitHub::Markup.render("#{title}.markdown", first_paragraph[1]).html_safe
+  end
+  
+  def content_with_embedded_gists
+    # by using gist_id directly we can avoid hitting the Gist API every time the
+    # post is rendered.
+    
+    return content.dup if gist_id.blank?
+    
+    template = '<script src="https://gist.github.com/__ID__.js?file=__FILENAME__"></script>'
+    template['__ID__'] = gist_id.to_s
+    
+    content.dup.tap do |result|
+      # process last example first, so that changes to result don't taint offsets
+      code_examples.reverse.each do |example|
+        result[example.offset] = template.sub(/__FILENAME__/, example.filename) + "\n"
+      end
+    end
+  end
+  
+  def has_code_examples?
+    code_examples.length > 0
+  end
+  
+  def code_examples
+    Mist::CodeExampleParser.new(content).examples
+  end
+  
+  def load_code_examples_from_gist
+    if gist && gist.persisted?
+      self.content = self.content.dup.tap do |result|
+        code_examples.reverse.each do |example|
+          if gist.files[example.filename]
+            lines = gist.files[example.filename][:content].split("\n")
+            lines.unshift "    file: #{example.filename}"
+            result[example.offset] = lines.join("\n    ") + "\n"
+          end
+        end
+      end
+    end
+  end
+  
+  # Assigns the file contents of each file in the gist according to what's found in
+  # #content. Does not save the gist. Returns the list of files themselves.
+  def set_gist_data
+    gist.description = generated_gist_description
+    gist.files.keys.each { |filename| gist.files[filename] = nil }
+    code_examples.each do |example|
+      gist.files[example.filename] = { :content => example }
+    end
+    gist.files
+  end
+  
+  def url(options = {})
+    Mist::Engine.routes.url_helpers.post_path(id, options.reverse_merge(:only_path => false).reverse_merge(Rails.application.default_url_options))
+  end
+  
+  def update_gist_if_necessary
+    return unless errors.empty?
+    
+    if has_code_examples?
+      set_gist_data
+      
+      if gist.changed?
+        errors.add(:gist, "could not be saved: #{gist.errors.full_messages.join('; ')}") unless gist.save
+      end
+
+      self.gist_id = gist.id
+    else
+      # no code examples, delete gist
+      gist.destroy if gist && gist.persisted?
+    end
+  end
+  
+  def destroy_gist
+    gist.destroy if gist && gist.persisted?
+  end
+end