blabs 0.4.4

data/app/helpers/blabs/blog_posts_helper.rb

@@ -0,0 +1,114 @@
+# encoding: UTF-8
+
+module Blabs::BlogPostsHelper
+  EXTRACT_LENGTH = 600
+
+  def title(title)
+    content_for(:title, title)
+    content_tag(:h1, title)
+  end
+
+  def field_error(form, object, field)
+    if object.errors[field] && object.errors[field].size > 0
+      content_tag 'div', object.errors[field].first,
+        class: 'i i-info form-error'
+    end
+  end
+
+  def admin_controls(blog_post)
+    edit_link = link_to("Edit", edit_blabs_blog_post_path(blog_post))
+    publish_link = publish_or_unpublish_link(blog_post)
+    delete_link = link_to("Delete", blog_post, method: :delete, data: { confirm: "Are you sure?" })
+    raw [edit_link, publish_link, delete_link].join(" • ")
+  end
+
+  def formatted_body(text)
+    options = { autolink: true, lax_spacing: true, space_after_headers: true}
+    renderer = Redcarpet::Markdown.new(Redcarpet::Render::HTML, options)
+    auto_link_username(renderer.render(text)).html_safe
+  end
+
+  def validate_layout
+    if !content_for?(:title) && !@blog_post.meta_title.blank?
+      raise "You need to put a title yield in your layouts title tag.\n
+            e.g. <title>My Blog - <%= yield(:title) %> </title>\n"
+    end
+
+    if !content_for?(:meta_tags)
+      raise "You need to put a meta_tags yield in your layouts head tag.\n
+            e.g. <%= yield(:meta_tags) %> </head>\n"
+    end
+
+  end
+
+  def pretty_date(date)
+    date.strftime("#{date.day.ordinalize} %B %Y") unless date.blank?
+  end
+
+  def extract(blog_post)
+    if blog_post.extract.present?
+      extract = blog_post.extract + " " + link_to("Read more", pretty_blog_post_path(blog_post), :class=>"more")
+      formatted_body(extract)
+    else
+      truncate_html(formatted_body(blog_post.body), length: EXTRACT_LENGTH,
+      omission: "... #{link_to("Read more", pretty_blog_post_path(blog_post), :class=>"more")}",
+      escape: false)
+    end
+  end
+
+  def show_meta_tags
+    content_for(:meta_tags) do
+      concat twitter_meta_tag("card", "summary")
+      concat twitter_meta_tag("site", Blabs.twitter_site_username)
+      concat twitter_meta_tag("creator", @blog_post.try(:author_twitter_username))
+      concat twitter_meta_tag("title", @blog_post.title)
+
+      sample = truncate(strip_tags(formatted_body(@blog_post.body)), length: EXTRACT_LENGTH)
+
+      concat twitter_meta_tag("description", sample.strip)
+      concat twitter_meta_tag("image", @blog_post.post_image_url)
+
+      concat open_graph_meta_tag("title", @blog_post.title)
+      concat open_graph_meta_tag("description", sample.strip)
+      concat open_graph_meta_tag("image", @blog_post.post_image_url)
+      concat open_graph_meta_tag("url", pretty_blog_post_url(@blog_post))
+    end
+  end
+
+  def index_meta_tags
+    content_for(:meta_tags) do
+      concat auto_discovery_link_tag :atom, "/blog/feed"
+      concat auto_discovery_link_tag :rss, "/blog/feed.rss"
+    end
+  end
+
+  def auto_link_username(body)
+    body.gsub(/@(\w+)/, %Q{<a href="https://twitter.com/\\1">@\\1</a>})
+  end
+
+  def display_author(blog_post)
+    if blog_post.author_twitter_username.blank?
+      blog_post.author
+    else
+      link_to(blog_post.author, "https://twitter.com/#{blog_post.author_twitter_username.delete("@")}")
+    end
+  end
+
+  private
+  def publish_or_unpublish_link(blog_post)
+    if blog_post.published?
+      link_to("Unpublish", blabs_published_blog_posts_path(id: blog_post), method: :delete)
+    else
+      link_to("Publish", blabs_published_blog_posts_path(id: blog_post), method: :post)
+    end
+  end
+
+  def twitter_meta_tag(label, value)
+    tag(:meta, name: "twitter:#{label}", content: value)
+  end
+
+  def open_graph_meta_tag(label, value)
+    tag(:meta, property: "og:#{label}", content: value)
+  end
+
+end

data/app/models/blabs/blog_post.rb

@@ -0,0 +1,70 @@
+module Blabs
+  class BlogPost < ActiveRecord::Base
+    self.table_name_prefix = 'blabs_'
+
+    validates :title, presence: true
+    validates :body, presence: true
+    validates :author, presence: true
+    validates :path, presence: true, uniqueness: true
+
+    serialize :extra_attributes, Hash
+
+    before_validation :set_path
+    before_validation :set_meta_title
+
+    has_many :taggings, class_name: "Blabs::Tagging", foreign_key: "blabs_blog_post_id"
+    has_many :tags, class_name: "Blabs::Tag", through: :taggings, foreign_key: "blabs_tag_id"
+
+    def self.tagged_with(name)
+      Tag.find_by_name!(name).blog_posts
+    end
+
+    def to_param
+      path
+    end
+
+    def publish!
+      update_attributes(published: true, published_at: Time.now) unless published?
+    end
+
+    def unpublish!
+      update_attributes(published: false, published_at: nil) if published?
+    end
+
+    def toggle_publish!(value)
+      value ? publish! : unpublish!
+    end
+
+    def post_image_url
+      (Blabs.post_image_url_attribute && extra_attributes[Blabs.post_image_url_attribute]) || begin
+        find_link_regex = /\[([^\[]+)\]\(([^\)]+)\)/
+        body.match(find_link_regex) && $2
+      end
+    end
+
+    def author_twitter_username
+      username = self[:author_twitter_username]
+      username.blank? ? "" : "@#{username}".squeeze("@")
+    end
+
+    def tag_list=(names)
+      self.tags = names.split(",").map do |n|
+        Blabs::Tag.where(name: n.strip).first_or_create!
+      end
+    end
+
+    def tag_list
+      self.tags.collect {|t| t.name }.join(", ")
+    end
+
+    private
+
+    def set_path
+      self.path = self.title.parameterize if self.path.blank? && self.title.present?
+    end
+
+    def set_meta_title
+      self.meta_title = self.title if self.meta_title.blank?
+    end
+  end
+end

data/app/models/blabs/image.rb

@@ -0,0 +1,4 @@
+class Blabs::Image < ActiveRecord::Base
+  mount_uploader :image, ImageUploader
+  self.table_name_prefix = 'blabs_'
+end

data/app/models/blabs/tag.rb

@@ -0,0 +1,9 @@
+module Blabs
+  class Tag < ActiveRecord::Base
+    self.table_name_prefix = 'blabs_'
+
+    has_many :taggings, class_name: "Blabs::Tagging", foreign_key: "blabs_tag_id"
+    has_many :blog_posts, through: :taggings, class_name: "Blabs::BlogPost"
+
+  end
+end

data/app/models/blabs/tagging.rb

@@ -0,0 +1,9 @@
+module Blabs
+  class Tagging < ActiveRecord::Base
+    self.table_name_prefix = 'blabs_'
+
+    belongs_to :tag, class_name: "Blabs::Tag", foreign_key: "blabs_tag_id"
+    belongs_to :blog_post, class_name: "Blabs::BlogPost", foreign_key: "blabs_blog_post_id"
+
+  end
+end

data/app/uploaders/image_uploader.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require 'carrierwave/processing/mime_types'
+
+class ImageUploader < CarrierWave::Uploader::Base
+
+  # Include RMagick or MiniMagick support:
+  # include CarrierWave::RMagick
+  include CarrierWave::MiniMagick
+  include CarrierWave::MimeTypes
+
+  # Include the Sprockets helpers for Rails 3.1+ asset pipeline compatibility:
+  # include Sprockets::Helpers::RailsHelper
+  # include Sprockets::Helpers::IsolatedHelper
+
+  # Choose what kind of storage to use for this uploader:
+  if Rails.env.production?
+    storage :fog
+    fog_credentials Blabs.fog_credentials
+    fog_directory Blabs.fog_directory
+  else
+    storage :file
+  end
+
+
+  # Override the directory where uploaded files will be stored.
+  # This is a sensible default for uploaders that are meant to be mounted:
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{model.id}"
+  end
+
+  # Provide a default URL as a default if there hasn't been a file uploaded:
+  # def default_url
+  #   # For Rails 3.1+ asset pipeline compatibility:
+  #   # asset_path("fallback/" + [version_name, "default.png"].compact.join('_'))
+  #
+  #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+  # end
+
+  # Process files as they are uploaded:
+  # process :scale => [200, 300]
+  #
+  # def scale(width, height)
+  #   # do something
+  # end
+
+  process :set_content_type
+
+  # Create different versions of your uploaded files:
+  version :thumb do
+    process :resize_to_fit => [60, 60]
+  end
+
+  # Add a white list of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  # def extension_white_list
+  #   %w(jpg jpeg gif png)
+  # end
+
+  # Override the filename of the uploaded files:
+  # Avoid using model.id or version_name here, see uploader/store.rb for details.
+  # def filename
+  #   "something.jpg" if original_filename
+  # end
+
+end

data/app/views/blabs/blog_posts/_form.html.haml

@@ -0,0 +1,54 @@
+=form_for(@blog_post) do |f|
+  .col-lg-8
+    .form-group
+      = f.label :title
+      = f.text_field :title, class: "form-control", placeholder: "Give your blog post an interesting title"
+      = field_error(f, @blog_post, :title)
+    .row
+      .col-lg-6
+        .form-group
+          = f.label :author
+          = f.text_field :author, class: "form-control", placeholder: "You need to put your name in"
+          = field_error(f, @blog_post, :author)
+      .col-lg-6
+        .form-group
+          = f.label :author_twitter_username
+          = f.text_field :author_twitter_username, class: "form-control", placeholder: "Your twitter name (for the twitter summary card)"
+          = field_error(f, @blog_post, :author_twitter_username)
+    .form-group
+      = f.label :body
+      %p.pull-right= link_to("Markdown syntax (new window)", "http://daringfireball.net/projects/markdown/syntax", target: :window, tabIndex: -1)
+      = f.text_area :body, class: "form-control", placeholder: "Use markdown to write your blog post", rows: 25
+      = field_error(f, @blog_post, :body)
+    .form-group
+      = f.label :extract
+      %p.pull-right Leave blank to use the default extract
+      = f.text_area :extract, class: "form-control", placeholder: "Use markdown to write your extract", rows: 2
+      = field_error(f, @blog_post, :extract)
+    .form-group
+      = f.submit "Save (unpublished)", class: "btn btn-default"
+      = f.submit "Save and publish", class: "btn btn-default btn-success", name: "publish"
+      = f.submit "Preview", class: "btn btn-default btn-info", name: "preview"
+      or
+      = link_to "cancel", "/blog", data: { confirm: "Are you sure?" }
+  .col-lg-4.panel.panel-info
+    .panel-heading For SEO nerds
+    .well.well-sm If you don't put anything in here, a sensible default will be applied
+    .form-group
+      = f.label :meta_title
+      = f.text_field :meta_title, class: "form-control", placeholder: "Meta title - for you SEO nerds (will default to the title)"
+      = field_error(f, @blog_post, :meta_title)
+    .form-group
+      = f.label :path
+      = f.text_field :path, class: "form-control", placeholder: "The url - (will be defaulted to something sensible)"
+      = field_error(f, @blog_post, :path)
+    .form-group
+      = f.label :tag_list
+      = f.text_field :tag_list, class: "form-control", placeholder: "Comma delimited list of tags"
+  - if Blabs.extra_attributes.any?
+    .col-lg-4.panel.panel-info
+      - Blabs.extra_attributes.each do |attribute|
+        .form-group
+          = label_tag "blabs_blog_post[extra_attributes][#{attribute}]", attribute.to_s.humanize
+          = text_field_tag "blabs_blog_post[extra_attributes][#{attribute}]", @blog_post.extra_attributes[attribute], class: "form-control"
+  =render "image_panel"

data/app/views/blabs/blog_posts/_image.html.haml

@@ -0,0 +1,5 @@
+%li.list-group-item.image[image]
+  = link_to(image_tag(image.image_url(:thumb)), image.image_url) if image.image?
+  = link_to("Add", image.image_url, class: "add-to-blog")
+  |
+  = link_to("Delete", blabs_image_path(image), :method => :delete, data: { confirm: "Are you sure?" }, :remote => :true)

data/app/views/blabs/blog_posts/_image_panel.html.haml

@@ -0,0 +1,32 @@
+.col-lg-4.panel.panel-success
+  .panel-heading Images
+  .well.well-sm Upload an image, and then add it to the post with the add button
+  = fields_for Blabs::Image.new do |f|
+    = f.file_field :image, rel: blabs_images_path
+  %ul#images.list-group
+    = render partial: 'image', collection: @images
+
+  - key = Rails.application.config.session_options[:key]
+  = content_for :scripts do
+    :javascript
+      var upload_params = {};
+      var csrf_param = $('meta[name=csrf-param]').attr('content');
+      var csrf_token = $('meta[name=csrf-token]').attr('content');
+      upload_params[csrf_param] = encodeURI(encodeURIComponent(csrf_token));
+      upload_params['#{ key }'] = '#{ cookies[key] }';
+
+      var url = $('input#blabs_image_image').attr('rel');
+      $('input#blabs_image_image').uploadify({
+        'swf'     : '#{ image_path("uploadify.swf") }',
+        'buttonText': "Upload image",
+        'uploader'     : url,
+        'fileObjName' : 'blabs_image[image]',
+        'fileTypeExts' : '*.png;*.jpg;*.gif',
+        'multi'        : true,
+        'formData'   : upload_params,
+        'auto'         : true,
+        'onUploadSuccess'   : function(file, data, response) {
+          var newImage = $('#images').prepend(data);
+          $(document).trigger('new_image', $(newImage).attr("id"));
+        }
+      });

data/app/views/blabs/blog_posts/edit.html.haml

@@ -0,0 +1,7 @@
+%ul.breadcrumb
+  %li= link_to("All posts", "/blog")
+  %li.active= "Edit #{@blog_post.title}"
+
+.content
+  =title("Edit #{@blog_post.title}")
+  =render partial: 'form'

data/app/views/blabs/blog_posts/feed.atom.builder

@@ -0,0 +1,15 @@
+atom_feed do |feed|
+  feed.title @title
+  feed.updated @updated
+
+  @posts.each do |post|
+    feed.entry post do |entry|
+      entry.title post.title
+      entry.content formatted_body(post.body), type: 'html'
+      entry.updated(post.updated_at.strftime("%Y-%m-%dT%H:%M:%SZ"))
+      entry.author do |author|
+        author.name post.author
+      end
+    end
+  end
+end

data/app/views/blabs/blog_posts/index.html.haml

@@ -0,0 +1,27 @@
+- index_meta_tags
+
+.blabs-blog
+  %nav.blabs-navigation
+    - if blabs_admin_required && @blog_posts.any?
+      =link_to("New Blog Post", new_blabs_blog_post_path)
+  -if @blog_posts.none?
+    %article
+      %header
+        %h2.title You don't have any blog posts.
+        %p.authorship #{link_to("Why don't you create the first!", new_blabs_blog_post_path)}
+
+  -else
+    -@blog_posts.each do |blog_post|
+      %article
+        %header
+          %h2.title=link_to(blog_post.title, pretty_blog_post_path(blog_post))
+          %p.authorship #{display_author(blog_post)} • #{pretty_date(blog_post.published_at) || pretty_date(blog_post.created_at)}
+        %hr
+        .content.post-body
+          - if @blog_posts.size == 1
+            = formatted_body(blog_post.body)
+          - else
+            = extract(blog_post)
+        - if blabs_admin_required
+          .blabs-admin-controls
+            = admin_controls(blog_post)

data/app/views/blabs/blog_posts/new.html.haml

@@ -0,0 +1,7 @@
+%ul.breadcrumb
+  %li= link_to("All posts", "/blog")
+  %li.active= "New blog post"
+
+.content
+  =title("New blog post")
+  =render partial: 'form'

data/app/views/blabs/blog_posts/show.html.haml

@@ -0,0 +1,16 @@
+- content_for(:title, @blog_post.meta_title)
+- show_meta_tags
+- validate_layout
+.blabs-blog
+  %nav.blabs-navigation
+    =link_to("< Back", "/blog")
+  %article
+    %header
+      %h1.title= @blog_post.title
+      %p.authorship #{display_author(@blog_post)} • #{pretty_date(@blog_post.published_at) || pretty_date(@blog_post.created_at)}
+
+    .content.post-body
+      = formatted_body(@blog_post.body)
+    - if blabs_admin_required
+      .blabs-admin-controls
+        = admin_controls(@blog_post)