blogit 0.0.4

data/lib/blogit/engine.rb

@@ -0,0 +1,14 @@
+module Blogit
+  class Engine < Rails::Engine
+    isolate_namespace Blogit
+    
+    config.to_prepare do
+
+      if defined?(::ActiveRecord::Base)
+        ::ActiveRecord::Base.send(:include, Blogit::Blogs)
+        ::ActiveRecord::Base.send(:include, Validators)
+      end
+      
+    end
+  end
+end

data/lib/blogit/parsers.rb

@@ -0,0 +1,5 @@
+module Blogit::Parsers
+  require "blogit/parsers/html_parser"
+  require "blogit/parsers/textile_parser"
+  require "blogit/parsers/markdown_parser"
+end

data/lib/blogit/parsers/html_parser.rb

@@ -0,0 +1,9 @@
+class Blogit::Parsers::HtmlParser
+
+  attr_reader :parsed
+
+  def initialize(content)
+    @parsed = content
+  end
+
+end  

data/lib/blogit/parsers/markdown_parser.rb

@@ -0,0 +1,21 @@
+class Blogit::Parsers::MarkdownParser
+
+  require "nokogiri"
+
+  def initialize(content)
+    @content = content
+  end
+
+  def parsed
+    Redcarpet.new(@content, *Blogit.configuration.redcarpet_options).to_html
+  end
+
+  # def syntax_highlighter(html)
+  #   doc = Nokogiri::HTML(html)
+  #   doc.search("//pre[@lang]").each do |pre|
+  #     pre.replace Albino.colorize(pre.text.rstrip, pre[:lang])
+  #   end
+  #   doc.to_s
+  # end  
+  
+end

data/lib/blogit/parsers/textile_parser.rb

@@ -0,0 +1,13 @@
+class Blogit::Parsers::TextileParser
+
+  require "redcloth"
+
+  def initialize(content)
+    @content = content
+  end
+
+  def parsed
+    RedCloth.new(@content).to_html
+  end
+
+end

data/lib/blogit/version.rb

@@ -0,0 +1,3 @@
+module Blogit
+  VERSION = "0.0.4"
+end

data/lib/generators/blogit/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate install Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/blogit/install_generator.rb

@@ -0,0 +1,15 @@
+module Blogit
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      
+      source_root File.expand_path('../../templates', __FILE__)
+
+      desc "Creates a Blogit initializer in your application's config/initializers dir"
+
+      def copy_initializer
+        template "blogit.rb", "config/initializers/blogit.rb"
+      end
+
+    end
+  end
+end

data/lib/generators/templates/blogit.rb

@@ -0,0 +1,42 @@
+# These configuration options can be used to customise the behaviour of Blogit
+Blogit.configure do |config|
+  
+  # Do you want to add comments to your blog?
+  config.include_comments = true
+
+  # The name of the controller method we'll call to return the current blogger.
+  # Change this if you use something other than current_user.
+  # Eg. current_admin_user (if using ActiveAdmin)
+  config.current_blogger_method = :current_user
+
+  # What method do we call on blogger to show who they are?
+  config.blogger_display_name_method = :username
+
+  # Which DateTime::FORMATS format do we use to display blog and comment publish time
+  config.datetime_format = :short
+
+  # No. of posts to show per page
+  config.posts_per_page = 5
+
+  # The name of the before filter we'll call to authenticate the current user.
+  config.authentication_method = :login_required
+
+  # If set to true, the comments form will POST and DELETE to the comments 
+  # controller using AJAX calls.
+  config.ajax_comments = true
+
+  # If set to true, the create, edit, update and destroy actions
+  # will be included. If set to false, you'll have to set these 
+  # yourself elsewhere in the app.
+  # @note - This is not currently implemented
+  config.include_admin_actions = true
+
+  # The default format for parsing the blog content.
+  config.default_parser = :markdown
+
+  # When using redcarpet as content parser, pass these options as defaults.
+  # @see here for more options: https://github.com/tanoku/redcarpet
+  config.redcarpet_options = [:hard_wrap, :filter_html, :autolink, 
+    :no_intraemphasis, :fenced_code, :gh_blockcode]
+  
+end

data/lib/tasks/blog_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :blog do
+#   # Task goes here
+# end

data/lib/validators.rb

@@ -0,0 +1,3 @@
+require "validators/absence_validator"
+module Validators
+end

data/lib/validators/absence_validator.rb

@@ -0,0 +1,13 @@
+module Validators
+
+  # Checks that an attribute is absent. 
+  # The opposite of PresenceValidator
+  class AbsenceValidator < ActiveModel::EachValidator
+
+    def validate_each(record, attribute, value)
+      record.errors.add(attribute, :invalid, options) unless value.blank?
+    end
+
+  end
+
+end

data/spec/blogit_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Blogit do
+  
+  it "should allow developers to set configurations with a block" do
+    initial_value = Blogit.configuration.current_blogger_method
+    Blogit.configure do |config| 
+      config.current_blogger_method = :logged_in_user
+    end
+    user_set_value = Blogit.configuration.current_blogger_method
+    initial_value.should_not eql(user_set_value)
+  end
+  
+  after :all do
+    Blogit.configure do |config|
+      config.inspect
+    end
+  end
+  
+end

data/spec/controllers/blogit/comments_controller_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe CommentsController do
+  
+  let(:blog_post) { Blogit::Post.first || create(:post) }
+    
+  describe "POST create" do
+    
+    before do
+      @comment_attributes = attributes_for(:comment)
+    end
+    
+    def do_post(format = :html)
+      post :create, post_id: blog_post.id, 
+        comment: @comment_attributes, use_route: :blogit, format: format
+    end
+    
+    describe "whith JS" do
+      
+      it "should persist comment" do
+        lambda { do_post(:js) }.should change { blog_post.comments.count }.by(1)
+      end
+      
+      # The rest is handled in the view
+      
+    end
+    
+    describe "with HTML" do
+      
+      it "should persist comment" do
+        lambda { do_post(:html) }.should change { blog_post.comments.count }.by(1)        
+      end
+      
+      it "should redirect to the blog post" do
+        do_post
+        response.should redirect_to(controller.post_url(blog_post))
+      end
+
+      it "should display a flash notice" do
+        do_post
+        flash[:notice].should be_present
+      end
+      
+    end
+    
+  end
+  
+  describe "DELETE destroy" do
+    
+    def do_delete(format = :html)
+      delete :destroy, id: @comment.id,
+        post_id: blog_post.id, format: format, use_route: :blogit
+    end
+    
+    before do
+      @comment  = create(:comment, post: blog_post)  
+    end
+    
+    describe "when user logged in" do
+
+      before do
+        mock_login
+      end
+            
+      describe "whith JS" do
+        
+        it "should destroy the comment" do
+          lambda { do_delete(:js) }.should change { blog_post.reload.comments.count }
+        end
+        
+      end
+
+      describe "with HTML" do
+
+        it "should destroy the comment" do
+          lambda { do_delete(:html) }.should change { blog_post.reload.comments.count }
+        end
+
+        it "should redirect to the blog post " do
+          do_delete
+          response.should redirect_to(controller.post_url(blog_post))
+        end
+
+      end
+      
+    end
+    
+    describe "when user is not logged in" do
+      
+      
+      describe "whith JS" do
+        
+        it 'should not destroy the comment' do
+          lambda { do_delete }.should_not change { Comment.count }
+        end
+        
+      end
+
+      describe "with HTML" do
+
+        it "should not destroy the comment" do
+          lambda { do_delete }.should_not change { Comment.count }
+        end
+
+      end
+      
+    end
+    
+  end
+
+end

data/spec/controllers/blogit/posts_controller_spec.rb

@@ -0,0 +1,261 @@
+require 'spec_helper'
+
+describe PostsController do
+  
+  before do
+    reset_configuration
+  end
+
+  let(:blog_post) { build :post }
+
+  describe "GET 'index'" do
+
+    let(:posts) { [] }
+    
+    def do_get(page=nil)
+      get :index, :use_route => :blogit, page: page.to_s
+    end
+    
+    it "should set posts to Blogit::Post.for_index" do
+      Blogit::Post.expects(:for_index).returns(posts)
+      do_get
+      controller.posts.should == posts
+    end
+    
+    it "should pass the page param to for_index" do
+      Blogit::Post.expects(:for_index).with("2").returns(posts)
+      do_get("2")
+      controller.posts.should == posts
+    end
+    
+  end
+  
+  describe "GET 'new'" do
+    
+    context "when logged in" do
+      
+      before do
+        mock_login
+      end
+      
+      def do_get
+        get :new, use_route: :blogit
+      end
+    
+      it "should be successful" do
+        do_get
+        response.should be_success
+      end
+      
+      it "should set post to a new blog post" do
+        do_get
+        controller.post.should be_a(Blogit::Post)
+        controller.post.should be_a_new_record
+      end
+      
+    end
+    
+    context "when not logged in" do
+      
+      def do_get
+        get :new, use_route: :blogit
+      end
+      
+      # It's not really the responsibility of the gem to manage authentication 
+      # so testing for specific behaviour here is not required
+      # at the very least though, we'd expect the status not to be 200
+      it "should redirect to another page" do
+        do_get
+        response.should_not be_success
+      end
+      
+    end
+  end
+  
+  describe "POST /create" do
+    
+    context "when logged in" do
+      
+      before do
+        mock_login
+      end
+      
+      context "with valid params" do
+        
+        let(:post_attributes) { attributes_for(:post) }
+        
+        def do_post
+          post :create, use_route: :blogit, post: post_attributes
+        end
+        
+        before do
+          @blog_posts = []
+          @current_blogger.expects(:blog_posts).returns(@blog_posts)
+          @blog_posts.expects(:new).with(post_attributes.stringify_keys).returns(blog_post)
+          blog_post.expects(:save).returns(true)
+        end
+                
+        it "should redirect to the blog post page" do
+          do_post
+          response.should redirect_to(controller.posts_url)
+        end
+        
+      end
+      
+    end
+    
+  end
+
+  
+  describe "GET 'edit'" do
+    
+    context "when logged in" do
+            
+      before do
+        mock_login
+        @current_blogger.expects(:blog_posts).returns(@blog_posts = [])
+        @blog_posts.expects(:find).with("1").returns(blog_post)
+      end
+      
+      def do_get
+        get :edit, :id => 1, use_route: :blogit
+      end
+      
+      it "should find the blog post by the ID" do
+        do_get
+        controller.post.should eql(blog_post)
+      end
+      
+    end
+    
+    context "when not logged in" do
+      
+      def do_get
+        get :edit, :id => 1, use_route: :blogit
+      end
+      
+      # It's not really the responsibility of the gem to manage authentication 
+      # so testing for specific behaviour here is not required
+      # at the very least though, we'd expect the status not to be 200
+      it "should redirect to another pages" do
+        do_get
+        response.should_not be_success
+      end
+      
+    end
+
+  end
+  
+  describe "PUT 'update'" do
+        
+    context "when logged in" do
+      
+      before do
+        @post_attributes = { "title" => "Something new" }
+        mock_login
+        @current_blogger.expects(:blog_posts).returns(@blog_posts = [])
+        @blog_posts.expects(:find).with("1").returns(blog_post)
+      end
+      
+      def do_put
+        put :update, id: "1", use_route: :blogit, post: @post_attributes
+      end
+      
+      it "should update the post attributes from params" do
+        blog_post.expects(:update_attributes).with(@post_attributes).returns(true)
+        do_put
+      end
+      
+      it "should redirect to the blog post page" do
+        do_put
+        response.should redirect_to(controller.post_url(blog_post))
+      end
+      
+      it "should set a flash notice" do
+        do_put
+        flash[:notice].should be_present
+      end
+    end
+    
+    context "when not logged in" do
+      
+      before do
+        @post_attributes = { "title" => "Something new" }
+      end
+      
+      def do_put
+        put :update, id: "1", use_route: :blogit, post: @post_attributes
+      end
+      
+      # It's not really the responsibility of the gem to manage authentication 
+      # so testing for specific behaviour here is not required
+      # at the very least though, we'd expect the status not to be 200
+      it "should redirect to another page" do
+        do_put
+        response.should_not be_success
+      end
+      
+    end
+    
+  end
+  
+  describe "GET 'show'" do
+      
+    before do
+      Blogit::Post.expects(:find).with("1").returns(blog_post)
+    end
+    
+    def do_get
+      get :show, :id => 1, use_route: :blogit
+    end
+    
+    it "should find blog post by id" do
+      do_get
+      controller.post.should eql(blog_post)
+    end
+
+  end
+  
+  describe "DELETE 'destroy'" do
+        
+    def do_delete
+      delete :destroy, id: "1", use_route: :blogit
+    end
+    
+    describe "when logged in" do
+            
+      before do
+        mock_login
+        @current_blogger.expects(:blog_posts).returns(@blog_posts = [])
+        @blog_posts.expects(:find).with("1").returns(blog_post)
+      end
+      
+      it "should destroy the blog post" do
+        blog_post.expects(:destroy)
+        do_delete
+      end
+      
+      it "should redirect to the blog posts url" do
+        do_delete
+        response.should redirect_to(controller.posts_url)
+      end
+      
+      it "should show a flash notice" do
+        do_delete
+        flash[:notice].should be_present
+      end
+      
+    end
+    
+    describe "when not logged in" do
+      
+      it "should redirect to another page" do
+        do_delete
+        response.should_not be_success
+      end
+      
+    end
+    
+  end
+
+end