blogit 1.0.0.rc1 → 1.0.0

data/app/helpers/blogit/application_helper.rb

@@ -1,94 +1,84 @@
 module Blogit
   module ApplicationHelper
-
-    TIMETAG_FORMAT = "%Y-%m-%dT%TZ"
-
-    # Creates a div tag with class 'blog_' + (post|comment) + '_' + name
-    # Eg:
-    #   blog_tag(:title, "") # => <div class="blog_post_title"></div>
-    #   blog_tag(:email, "", {:type => "comment"}) # => <div class="blog_comment_email"></div>
-    #   blog_tag(:tweet, "", {:type => "status"}) # => <div class="blog_status_tweet"></div>
-    def blog_tag(name, content_or_options = {}, options = {}, &block)
-      tag_type = options.delete(:type) || "post"
-
-      if block_given?
-        content = capture(&block)
-        options = content_or_options
-      else
-        content = content_or_options
-      end
-      options[:class] = "#{options[:class]} blog_#{tag_type}_#{name}".strip
-      content_tag(name, content, options)
-    end
-
+    
     # Format content using the {Blogit::Configuration#default_parser_class default_parser_class}
+    #
+    # content - A String containing the content to be formatted (defaults: nil)
+    # block   - A Proc that returns a String of content to be formatted
+    #
+    # Examples
+    # 
+    #   format_content("# This is a Markdown header")
+    #   # => "<h1>This is a Markdown header</h1>"
+    #
+    #   format_content do 
+    #     "some text"
+    #   end
+    #   # => "<p>some text</p>"
+    #
+    # Returns an HTML safe String.
     def format_content(content = nil, &block)
       content = capture(&block) if block_given?
-      parser = Blogit::configuration.default_parser_class.new(content)
-      parser.parsed.html_safe
+      parser  = Blogit::configuration.default_parser_class.new(content)
+      parser.parsed.to_s.html_safe
     end
 
-    # Returns the first error message for an ActiveRecord model instance
-    # @param object A model instance to check
-    # @param attribute A symbol or string for attribute name to check for
-    #   errors
+    # The first error message for an ActiveRecord::Base model instance attribute
+    #
+    # object    - An ActiveRecord::Base instance to check
+    # attribute - A Symbol or String with the attribute name to check errors on
+    #
+    # Examples
+    #
+    #  errors_on(@user, :first_name)
+    #  # => "Can't be blank"
+    #
+    # Returns a String with the error message
     def errors_on(object, attribute)
       error_message = object.errors[attribute].first
       content_tag(:span, error_message, class: "blogit_error_message") if error_message
     end
 
-    # A helper method for creating a +<div>+ tag with class 'field'
-    # Used for separating form fields
-    def field(content_or_options={}, options ={}, &block)
-      div_with_default_class(:field, content_or_options, options, &block)
-    end
-
-    # A helper method for creating a +<div>+ tag with class 'actions'
-    # Used for option links and form buttons
-    def actions(content_or_options={}, options ={}, &block)
-      div_with_default_class(:actions, content_or_options, options, &block)
-    end
-
-    # A helper method for creating a +<div>+ tag with class 'login_required'
-    # Will only render content if there is a logged in user
-    def login_required(content_or_options={}, options ={}, &block)
-      if current_blogger and blogit_conf.include_admin_links
-        div_with_default_class(:login_required, content_or_options, options, &block)
-      end
-    end
-
-    # Can search for named routes directly in the main app, omitting
-    # the "main_app." prefix
-    def method_missing method, *args, &block
-      if main_app_url_helper?(method)
-        main_app.send(method, *args)
+    # A helper method for creating a div tag with class 'field'. Used for separating
+    # form fields.
+    #
+    # content_or_options - The content to include in the div when not using a block. The
+    #                      options Hash when using a block
+    # options            - The options when not using a block
+    # block              - A block that returns HTML content to include in the div
+    #
+    # Returns an HTML safe String
+    def field(content_or_options = {}, options ={}, &block)
+      if block_given?
+        options = content_or_options
+        content = capture(&block)
       else
-        super
+        content = content_or_options
       end
-    end
-    
-    def respond_to?(method)
-      main_app_url_helper?(method) or super
-    end
-
-    private
-
-    def main_app_url_helper?(method)
-      Blogit::configuration.inline_main_app_named_routes and
-        (method.to_s.end_with?('_path') or method.to_s.end_with?('_url')) and
-        main_app.respond_to?(method)
+      options[:class] = Array(options[:class]) + ["field"]
+      content_tag(:div, content, options)
     end
 
-    def div_with_default_class(default_class, content_or_options={}, options={}, &block)
+    # A helper method for creating a div tag with class 'actions'. Used as a wrapper
+    # for form actions.
+    #
+    # content_or_options - The content to include in the div when not using a block. The
+    #                      options Hash when using a block
+    # options            - The options when not using a block
+    # block              - A block that returns HTML content to include in the div
+    #
+    # Returns an HTML safe String
+    def actions(content_or_options={}, options ={}, &block)
       if block_given?
-        content = capture(&block)
         options = content_or_options
+        content = capture(&block)
       else
         content = content_or_options
       end
-      options[:class] = "#{default_class} #{options[:class]}".strip
+      options[:class] = Array(options[:class]) + ["actions"]
       content_tag(:div, content, options)
     end
 
   end
-end
+  
+end

data/app/helpers/blogit/comments_helper.rb

@@ -0,0 +1,20 @@
+module Blogit
+  
+  module CommentsHelper
+    
+    # The commenter's name for a Comment. When the Comment has a website, includes an html
+    # link containing their name. Otherwise, just shows the name as a String.
+    #
+    # comment - A {Blogit::Comment}
+    #
+    # Returns a String containing the commenter's name.
+    def name_for_comment(comment)
+      if comment.website?
+        link_to(comment.name, comment.website, class: "blogit_comment__name_link")
+      else
+        comment.name
+      end + " " + t('wrote', scope: "blogit.comments")
+    end
+    
+  end
+end

data/app/helpers/blogit/layout_helper.rb

@@ -0,0 +1,33 @@
+module Blogit
+  
+  module LayoutHelper
+
+    # Sets or returns the title for a page
+    #
+    # content - The content to include in the HTML title tag.
+    #
+    # Returns a String
+    def title(content=nil)
+      if content
+        content_for(:title, content)
+      else
+        content_for(:title)
+      end
+    end
+    
+    # Sets or returns the description for a page. Formats the content if it's Markdown or
+    # HTML and strips out the HTML tags.
+    #
+    # content - The content to include in the HTML meta description tag.
+    #
+    # Returns a String    
+    def description(content=nil)
+      if content
+        content_for(:description, strip_tags(format_content(content)).html_safe)
+      else
+        content_for(:description)
+      end
+    end
+    
+  end
+end

data/app/helpers/blogit/posts_helper.rb

@@ -1,45 +1,47 @@
 module Blogit
   module PostsHelper
-
-    # A comments tag corresponding to the comments configuration
-    def comments_for(post)
-      render(partial: "blogit/posts/#{Blogit.configuration.include_comments}_comments", locals: { post: post, comment: Blogit::Comment.new })
+    
+    require "blogit/archive"
+    
+    # Renders the comments for a {Post} based on the
+    # {Blogit::Configuration::include_comments} configuration
+    def comments_for_post(post)
+      comment_type = Blogit.configuration.include_comments
+      render(partial: "blogit/comments/#{comment_type}_comments", 
+        locals: { post: post, comment: Blogit::Comment.new })
     end
 
-    # A share bar as configured
-    def share_bar_for(post)
+    # Renders the comments for a JS share bar based on the
+    # {Blogit::Configuration::include_share_bar} configuration
+    def share_bar_for_post(post)
       return "" unless Blogit.configuration.include_share_bar
       render(partial: "blogit/posts/share_bar", locals: { post: post})
     end
+    
+    # Returns the {Post Posts} that share one or more of the same tags for a given post
+    #
+    # post - A {Post} instance
+    #
+    # Returns a collection of {Post Posts}
+    def related_posts_for_post(post)
+      post.find_related_on_tags.active
+    end
 
-    # Creates a ul tag tree with posts by year and monthes. Include
-    # blogit/archive.js to enabled expand collapse.
-    # @param year_css [String, Symbol] The CSS class of the year UL tag
-    # @param month_css [String, Symbol] The CSS class of the month UL tag
-    # @param post_css [String, Symbol] The CSS class of the year LI tag
-    # @param archive_posts [ActiveRecord::Relation, Array] The posts to be included in the archive (defaults to Post.all)
-    # @yield[post] block responsible for writing the link (or whatever) to the post
-    def blog_posts_archive_tag(year_css, month_css, post_css, archive_posts = Post.order("created_at DESC"))
-      posts_tree = archive_posts.chunk {|post| post.created_at.year}.map do |year, posts_of_year|
-        [year, posts_of_year.chunk {|post| l(post.created_at, format: :plain_month_only) }]
-      end
-
-      result = []
-      result << "<ul class=\"#{year_css}\">"
-      posts_tree.each do |year, posts_by_month|
-        result << "<li><a data-blogit-click-to-toggle-children>#{year}</a><ul class=\"#{month_css}\">"
-        posts_by_month.each do |month, posts|
-          result << "<li><a data-blogit-click-to-toggle-children>#{CGI.escape_html(month)}</a><ul class=\"#{post_css}\">"
-          posts.each do |post|
-            result << "<li>#{link_to(post.title, blogit.post_path(post))}</li>"
-          end
-          result << "</ul></li>"
-        end
-        result << "</ul></li>"
-      end
-      result << "</ul>"
-
-      result.join.html_safe
+    # Creates a ul tag tree with posts by year and months. Include blogit/archive.js in
+    # your js to enabled expand collapse.
+    #
+    # Examples
+    #
+    #   <%= archive_list_for_posts(@posts) %>
+    #   # => <div class="blogit_archive">
+    #          <ul class="blogit_archive__list blogit_archive__list--years">
+    #            ...
+    #          </ul>
+    #        </div>
+    # 
+    # Returns an HTML safe String
+    def archive_list_for_posts(archive_posts)
+      render Blogit::Archive::List.new(archive_posts)
     end
 
   end

data/app/models/blogit/post.rb

@@ -18,31 +18,67 @@ module Blogit
     # ===============
 
     validates :title, presence: true, length: { minimum: 10, maximum: 66 }
+
     validates :body,  presence: true, length: { minimum: 10 }
+    
+    validates :description, presence: Blogit.configuration.show_post_description
+
     validates :blogger_id, presence: true
+
     validates :state, presence: true
 
     # ================
     # = Associations =
     # ================
 
+    ##
+    # The blogger (User, Admin, etc.) who wrote this Post
+    #
+    # Returns a Blogger (polymorphic type)
     belongs_to :blogger, :polymorphic => true
 
+    ##
+    # The {Comment Comments} written on this Post
+    #
+    # Returns an ActiveRecord::Relation instance
     has_many :comments, :class_name => "Blogit::Comment"
 
     # ==========
     # = Scopes =
     # ==========
 
-    # Returns the blog posts paginated for the index page
-    # @scope class
-    scope :for_index, lambda { |page_no = 1| order("created_at DESC").page(page_no) }
+    scope :for_index, lambda { |page_no = 1| 
+      active.order("created_at DESC").page(page_no) }
+      
     scope :active, lambda { where(state:  Blogit.configuration.active_states ) }
 
+
+    # The posts to be displayed for RSS and XML feeds/sitemaps
+    #
+    # Returns an ActiveRecord::Relation
+    def self.for_feed
+      active.order('created_at DESC')
+    end
+    
+    # Finds an active post with given id
+    #
+    # id - The id of the Post to find
+    #
+    # Returns a Blogit::Post
+    # Raises ActiveRecord::NoMethodError if no Blogit::Post could be found
+    def self.active_with_id(id)
+      active.find(id)
+    end
+    
     # ====================
     # = Instance Methods =
     # ====================
 
+    # TODO: Get published at working properly!
+    def published_at
+      created_at
+    end
+    
     def to_param
       "#{id}-#{title.parameterize}"
     end
@@ -62,8 +98,11 @@ module Blogit
     end
     
 
-    # If there's a current blogger and the display name method is set, returns the blogger's display name
-    # Otherwise, returns an empty string
+    # The blogger who wrote this {Post Post's} display name
+    #
+    # Returns the blogger's display name as a String if it's set.
+    # Returns an empty String if blogger is not present.
+    # Raises a ConfigurationError if the method called is not defined on {#blogger}
     def blogger_display_name
       if self.blogger and !self.blogger.respond_to?(Blogit.configuration.blogger_display_name_method)
         raise ConfigurationError,
@@ -71,12 +110,22 @@ module Blogit
       elsif self.blogger.nil?
         ""
       else
-        self.blogger.send Blogit.configuration.blogger_display_name_method
+        blogger.send(Blogit.configuration.blogger_display_name_method)
+      end
+    end
+
+    # If there's a blogger and that blogger responds to :twitter_username, returns that.
+    # Otherwise, returns nil
+    def blogger_twitter_username
+      if blogger and blogger.respond_to?(:twitter_username)
+        blogger.twitter_username
       end
     end
+    
 
     private
 
+
     def check_comments_config
       raise RuntimeError.new("Posts only allow active record comments (check blogit configuration)") unless Blogit.configuration.include_comments == :active_record
     end

data/app/views/blogit/archive/_list.html.erb

@@ -0,0 +1,5 @@
+<div class="blogit_archive">
+  <ul class="blogit_archive__list blogit_archive__list--years">
+    <%= render list.years %>
+  </ul>
+</div>

data/app/views/blogit/archive/_month.html.erb

@@ -0,0 +1,9 @@
+<li class="blogit_archive__item blogit_archive__item--month">
+  <%= link_to(month, '#', class: "blogit_archive__toggle_link",
+    data: { blogit_click_to_toggle_children: true }) %>
+  <ul class="blogit_archive__list blogit_archive__list--archiveables">
+    <% for archiveable in month.archiveables %>
+      <%= render partial: "#{archiveable.model_name.i18n_key.to_s.pluralize}/archiveable", object: archiveable, as: archiveable.model_name.singular_route_key %>
+    <% end %>
+  </ul>
+</li>

data/app/views/blogit/archive/_year.html.erb

@@ -0,0 +1,7 @@
+<li class="blogit_archive__item blogit_archive__item--year">
+  <%= link_to(year, '#', class: 'blogit_archive__toggle_link',
+    data: { blogit_click_to_toggle_children: true }) %>
+  <ul class="blogit_archive__list blogit_archive__list--months">
+    <%= render year.months %>
+  </ul>
+</li>

data/app/views/blogit/{posts → comments}/_active_record_comments.html.erb

@@ -1,4 +1,5 @@
-<div id="comments">
+<div class="blogit_comments_list">
+  <h3 class="blogit_comments_list__header blogit_header--section">Comments</h3>
   <%= render post.comments %>
 </div>
 <%= render partial: "blogit/comments/form", locals: { post: post, comment: comment } %>

data/app/views/blogit/comments/_comment.html.erb

@@ -1,21 +1,17 @@
-<%= content_tag(:article, id: "blog_comment_#{comment.id}", class: "blog_comment") do %>
-  <%= content_tag(:div, class: "blog_comment_name", id: "blog_comment_#{comment.id}_name") do %>
-    <%= comment.website? ? link_to(comment.name, comment.website) : comment.name %>
-    <%= t('blogit.comments.wrote') %>
-  <% end %>
+<%= content_tag(:div, id: "blogit_comment_#{comment.id}", class: "blogit_comment") do %>
 
+  <div class="blogit_comment__name">
+    <%= name_for_comment(comment) %>
+  </div>
 
-  <%= content_tag(:div, class: "blog_comment_body",
-      id: "blog_comment_#{comment.id}_body") do %>
-      <%= format_content comment.body || "" %>
-  <% end %>
+  <div class="blogit_comment__body">
+    <%= format_content(comment.body.to_s) %>
+  </div>
 
-  <%= blog_tag(:footer, type: "comment") do %>
-    <%=t :posted_on, scope: 'blogit.comments'%> 
+  <div class="blogit_comment__created_at">
+    <%= t(:posted_on, scope: 'blogit.comments') %> 
     <%= time_tag(comment.created_at, format: blogit_conf.datetime_format) %>
-  <% end %>
-
-  <%= render partial: "blogit/comments/admin_links", locals: {comment: comment} %>
+  </div>
 
 <% end if comment.persisted? %>