mr_poole 0.1.0 → 0.2.0

data/spec/command_spec.rb

@@ -1,290 +1,348 @@
 require 'spec_helper'
-
 require 'mr_poole'
 
 module MrPoole
   describe Commands do
 
-    before :all do
-      @date_regex = %r{\d{4}-\d{2}-\d{2}}
-    end
-
-    before :each do
-      @c = Commands.new
-      @olddir, @tmpdir = make_jekyll_dir
-    end
-
-    after :each do
-      clean_tmp_files(@tmpdir, @olddir)
-    end
+    let(:date_regex) { %r{\d{4}-\d{2}-\d{2}} }
+    let(:c) { Commands.new }
+    before(:each) { @olddir, @tmpdir = make_jekyll_dir }
+    after(:each) { clean_tmp_files(@tmpdir, @olddir) }
 
     describe "#post" do
       context 'title only' do
-
         it "should create a new post in the _posts directory" do
-          @c.post("test_post")
-          Dir.glob("_posts/*.md").length.should == 1
-        end
-
-        it "should create a timestamped post in the _posts directory" do
-          @c.post("test_post")
-          fn = Dir.glob("_posts/*.md").first
-          fn.should match(/#{@date_regex}-test_post[.]md$/)
+          fn = c.post({title: "test_post"})
+          expect(File.exists?(fn)).to be_true
         end
 
         it "should return path to the newly created post" do
-          returned = @c.post("test_post")
+          returned = c.post({title: "test_post"})
           determined = Dir.glob("_posts/*.md").first
-          returned.should == determined
+          expect(returned).to eq(determined)
+        end
+
+        it "should create a timestamped post in the _posts directory" do
+          fn = c.post({title: "test_post" })
+          expect(fn).to match(/#{date_regex}-test_post[.]md$/)
         end
 
         it "should downcase a title" do
-          @c.post("Test_Post_With_Uppercase")
-          fn = Dir.glob("_posts/*.md").first
-          fn.should match(/#{@date_regex}-test_post_with_uppercase[.]md/)
+          fn = c.post({title: "Test_Post_With_Uppercase"})
+          expect(fn).to match(/#{date_regex}-test_post_with_uppercase[.]md/)
         end
 
         it "should sub underscores for spaces in title" do
-          @c.post("Test Post with Spaces")
-          fn = Dir.glob("_posts/*.md").first
-          fn.should match(/#{@date_regex}-test_post_with_spaces[.]md/)
+          fn = c.post({title: "Test Post with Spaces"})
+          expect(fn).to match(/#{date_regex}-test_post_with_spaces[.]md/)
         end
 
         it "should remove non-word characters for slug" do
-          @c.post("On (function() {}()) in JavaScript")
-          fn = Dir.glob("_posts/*.md").first
-          fn.should match(/#{@date_regex}-on_function_in_javascript[.]md/)
+          fn = c.post({title: "On (function() {}()) in JavaScript"})
+          expect(fn).to match(/#{date_regex}-on_function_in_javascript[.]md/)
         end
 
         it "should update the title in the file itself" do
-          @c.post("Testing Post {}")
-          fn = Dir.glob("_posts/*.md").first
+          fn = c.post({title: "Testing Post {}"})
           content = File.open(fn, 'r').read
-          content.should match(/title: Testing Post {}/)
+          expect(content).to match(/title: Testing Post {}/)
         end
 
         it "should update the date in the file itself" do
-          @c.post("Date test post")
-          fn = Dir.glob("_posts/*.md").first
+          fn = c.post({title: "Date test post"})
 
           # date in filename should match date in file itself
-          date = fn.match(/(#{@date_regex})-date_test_post[.]md/)[1]
+          date = fn.match(/(#{date_regex})-date_test_post[.]md/)[1]
           content = File.open(fn, 'r').read
-          content.should match(/date: #{date}/)
+          expect(content).to match(/date: #{date}/)
         end
-
       end   # end context title only
 
       context 'title and slug' do
-
         it "should create a post named for slug" do
-          @c.post("Test Post", 'unique_slug')
-          fn = Dir.glob("_posts/*.md").first
-          fn.should match(/#{@date_regex}-unique_slug[.]md$/)
+          fn = c.post({title: "Test Post", slug: 'unique_slug'})
+          expect(fn).to match(/#{date_regex}-unique_slug[.]md$/)
         end
 
         it "should sub any weird characters in slug" do
-          @c.post("Test Post with Spaces", "(stupid] {slüg/")
-          fn = Dir.glob("_posts/*.md").first
-          fn.should match(/#{@date_regex}-stupid_slg[.]md/)
+          fn = c.post({title: "Test Post with Spaces", slug: "(stupid] {slüg/"})
+          expect(fn).to match(/#{date_regex}-stupid_slg[.]md/)
         end
 
         it "should update the title in the file itself" do
-          @c.post("Testing Post {}", 'shouldnt_be_in_title')
-          fn = Dir.glob("_posts/*.md").first
+          fn = c.post({title: "Testing Post {}", slug: 'shouldnt_be_in_title'})
           content = File.open(fn, 'r').read
-          content.should match(/title: Testing Post {}/)
+          expect(content).to match(/title: Testing Post {}/)
         end
-
       end   # end context title & slug
 
+      context 'with custom layout' do
+        let(:layout_path) { write_custom_layout }
+
+        it "should exit if layout path doesn't exist" do
+          expect {
+            capture_stdout do
+              c.post({title: 'test_post', layout: 'bogus_path.md'})
+            end
+          }.to raise_error(SystemExit)
+        end
+
+        it 'should not use the default layout' do
+          fn = c.post({title: 'test_post', layout: layout_path})
+          content = File.open(fn, 'r').read
+          expect(content).not_to match(/layout: post/)
+        end
+
+        it 'should use the custom layout' do
+          fn = c.post({title: 'test_post', layout: layout_path})
+          content = File.open(fn, 'r').read
+          expect(content).to match(/tags: testing/)
+        end
+      end   # context custom layout
     end   # end describe post
 
     describe "#draft" do
       context 'title only' do
-
         it "should create a _drafts directory" do
-          @c.draft('draft post')
-          Dir.exists?('_drafts').should be_true
-        end
-
-        it "should create a new draft in the _drafts directory" do
-          @c.draft('draft post')
-          Dir.glob("_drafts/*.md").length.should == 1
+          c.draft({title: 'draft post'})
+          expect(Dir.exists?('_drafts')).to be_true
         end
 
         it "should return path to the newly created draft" do
-          returned = @c.draft("test_draft")
+          returned = c.draft({title: "test_draft"})
           determined = Dir.glob("_drafts/*.md").first
-          returned.should == determined
+          expect(returned).to eq(determined)
+        end
+
+        it "should create a new draft in the _drafts directory" do
+          fn = c.draft({title: 'draft post'})
+          expect(File.exists?(fn)).to be_true
         end
 
         it "should create a non-timestamped draft" do
-          @c.draft('draft post')
-          fn = Dir.glob("_drafts/*.md").first
-          fn.should_not match(/#{@date_regex}/)
+          fn = c.draft({title: 'draft post'})
+          expect(fn).not_to match(/#{date_regex}/)
         end
 
         it "should downcase and underscore title for slug" do
-          @c.draft("Test Post with Spaces")
-          fn = Dir.glob("_drafts/*.md").first
-          fn.should match(/test_post_with_spaces[.]md/)
+          fn = c.draft({title: "Test Post with Spaces"})
+          expect(fn).to match(/test_post_with_spaces[.]md/)
         end
 
         it "should remove non-word characters for slug" do
-          @c.draft("On (function() {}()) in JavaScript")
-          fn = Dir.glob("_drafts/*.md").first
-          fn.should match(/on_function_in_javascript[.]md/)
+          fn = c.draft({title: "On (function() {}()) in JavaScript"})
+          expect(fn).to match(/on_function_in_javascript[.]md/)
         end
 
         it "should update the title in the file itself" do
-          @c.draft("Testing Draft {}")
-          fn = Dir.glob("_drafts/*.md").first
+          fn = c.draft({title: "Testing Draft {}"})
           content = File.open(fn, 'r').read
-          content.should match(/title: Testing Draft {}/)
+          expect(content).to match(/title: Testing Draft {}/)
         end
 
         it "should not update the date in the file itself" do
-          @c.draft("Date test post")
-          fn = Dir.glob("_drafts/*.md").first
-
-          # date in filename should match date in file itself
+          fn = c.draft({title: "Date test post"})
           content = File.open(fn, 'r').read
-          content.should match(/date:\s*\n/)
+          expect(content).to match(/date:\s*\n/)
         end
-
       end   # end context title only
 
       context 'title and slug' do
-
         it "should create a draft named for slug" do
-          @c.draft("Test Draft", 'unique_slug')
-          fn = Dir.glob("_drafts/*.md").first
-          fn.should match(/unique_slug[.]md$/)
+          fn = c.draft({title: "Test Draft", slug: 'unique_slug'})
+          expect(fn).to match(/unique_slug[.]md$/)
         end
 
         it "should sub any weird characters in slug" do
-          @c.draft("Test Post with Spaces", "(stupid] {slüg/")
-          fn = Dir.glob("_drafts/*.md").first
-          fn.should match(/stupid_slg[.]md/)
+          fn = c.draft({title: "Test Post with Spaces", slug: "(stupid] {slüg/"})
+          expect(fn).to match(/stupid_slg[.]md/)
         end
 
         it "should update the title in the file itself" do
-          @c.draft("Testing Post {}", 'shouldnt_be_in_title')
-          fn = Dir.glob("_drafts/*.md").first
+          fn = c.draft({title: "Testing Post {}", slug: 'shouldnt_be_in_title'})
           content = File.open(fn, 'r').read
-          content.should match(/title: Testing Post {}/)
+          expect(content).to match(/title: Testing Post {}/)
         end
+      end   # context title & slug
 
-      end   # end context title & slug
+      context 'with custom layout' do
+        let(:layout_path) { write_custom_layout }
+
+        it "should exit if layout path doesn't exist" do
+          expect {
+            capture_stdout do
+              c.draft({title: 'test_post', layout: 'bogus_path.md'})
+            end
+          }.to raise_error(SystemExit)
+        end
+
+        it 'should not use the default layout' do
+          fn = c.draft({title: 'test_post', layout: layout_path})
+          content = File.open(fn, 'r').read
+          expect(content).not_to match(/layout: post/)
+        end
 
+        it 'should use the custom layout' do
+          fn = c.draft({title: 'test_post', layout: layout_path})
+          content = File.open(fn, 'r').read
+          expect(content).to match(/tags: testing/)
+        end
+      end   # context custom layout
     end   # end describe draft
 
     describe "#publish" do
+      let(:d_path) { c.draft({title: 'test_draft'}) }
 
-      before :each do
-        @d_path = @c.draft('test_draft')
+      it 'should return path to newly created post' do
+        returned = c.publish(d_path)
+        determined = Dir.glob("_posts/*.md").first
+        expect(returned).to eq(determined)
       end
 
       it 'should create a timestamped post in the _posts folder' do
-        @c.publish(@d_path)
-        fn = Dir.glob("_posts/*.md").first
-        fn.should match(/#{@date_regex}-test_draft[.]md$/)
+        fn = c.publish(d_path)
+        expect(fn).to match(/#{date_regex}-test_draft[.]md$/)
       end
 
       it 'should remove file in the _drafts folder' do
-        @c.publish(@d_path)
-        File.exist?(@d_path).should be_false
-      end
-
-      it 'should return path to newly created post' do
-        returned = @c.publish(@d_path)
-        determined = Dir.glob("_posts/*.md").first
-        returned.should == determined
+        c.publish(d_path)
+        expect(File.exist?(d_path)).to be_false
       end
 
       it 'should create post with matching slug' do
-        post = @c.publish(@d_path)
-
-        draft_slug = File.basename(@d_path, '.md')
-        post_slug = post.match(/#{@date_regex}-(.*)[.]md/)[1]
-
-        post_slug.should == draft_slug
+        post = c.publish(d_path)
+        draft_slug = File.basename(d_path, '.md')
+        post_slug = post.match(/#{date_regex}-(.*)[.]md/)[1]
+        expect(post_slug).to eq(draft_slug)
       end
 
       it 'should update timestamp in actual file' do
-        post = @c.publish(@d_path)
+        post = c.publish(d_path)
         content = File.open(post, 'r').read
-        content.should match(/date: #{@date_regex} \d{2}:\d{2}\n/)
+        expect(content).to match(/date: #{date_regex} \d{2}:\d{2}\n/)
       end
 
       it 'should copy contents of draft into post' do
         # first add some content to the draft
-        f = File.open(@d_path, 'a')
+        f = File.open(d_path, 'a')
         f.write("Some new content for my blog\n")
         f.close
 
-        post = @c.publish(@d_path)
+        post = c.publish(d_path)
         content = File.open(post, 'r').read
-        content.should match(/Some new content for my blog/)
+        expect(content).to match(/Some new content for my blog/)
       end
-
     end   # end describe publish
 
     describe "#unpublish" do
+      let(:p_path) { c.post({title: 'test_post'}) }
 
-      before :each do
-        @p_path = @c.post('test_post')
+      it 'should return path to newly created draft' do
+        returned = c.unpublish(p_path)
+        determined = Dir.glob("_drafts/*.md").first
+        expect(returned).to eq(determined)
       end
 
       it 'should create a _drafts directory' do
-        @c.unpublish(@p_path)
-        Dir.exists?('_drafts').should be_true
+        c.unpublish(p_path)
+        expect(Dir.exists?('_drafts')).to be_true
       end
 
       it 'should create an untimestamped draft in the _drafts folder' do
-        @c.unpublish(@p_path)
-        fn = Dir.glob("_drafts/*.md").first
-        fn.should_not match(/#{@date_regex}/)
+        fn = c.unpublish(p_path)
+        expect(fn).not_to match(/#{date_regex}/)
       end
 
       it 'should remove file in the _posts folder' do
-        @c.unpublish(@p_path)
-        File.exist?(@p_path).should be_false
-      end
-
-      it 'should return path to newly created draft' do
-        returned = @c.unpublish(@p_path)
-        determined = Dir.glob("_drafts/*.md").first
-        returned.should == determined
+        c.unpublish(p_path)
+        expect(File.exist?(p_path)).to be_false
       end
 
       it 'should create draft with matching slug' do
-        draft = @c.unpublish(@p_path)
-
-        post_slug = @p_path.match(/#{@date_regex}-(.*)[.]md$/)[1]
+        draft = c.unpublish(p_path)
+        post_slug = p_path.match(/#{date_regex}-(.*)[.]md$/)[1]
         draft_slug = File.basename(draft, '.md')
-
-        draft_slug.should == post_slug
+        expect(draft_slug).to eq(post_slug)
       end
 
       it 'should delete timestamp in actual file' do
-        draft = @c.unpublish(@p_path)
+        draft = c.unpublish(p_path)
         content = File.open(draft, 'r').read
-        content.should match(/date:\s*\n/)
+        expect(content).to match(/date:\s*\n/)
       end
 
       it 'should copy contents of post into draft' do
         # first add some content to the draft
-        f = File.open(@p_path, 'a')
+        f = File.open(p_path, 'a')
         f.write("Some new content for my blog\n")
         f.close
 
-        draft = @c.unpublish(@p_path)
+        draft = c.unpublish(p_path)
         content = File.open(draft, 'r').read
-        content.should match(/Some new content for my blog/)
+        expect(content).to match(/Some new content for my blog/)
       end
 
     end   # end describe unpublish
+
+    context 'with custom extension' do
+      let(:commands) { Commands.new('textile') }
+
+      it 'post should use custom extension' do
+        fn = commands.post({title: 'post title'})
+        expect(fn).to match(/textile$/)
+      end
+
+      it 'draft should use custom extension' do
+        fn = commands.draft({title: 'post title'})
+        expect(fn).to match(/textile$/)
+      end
+
+      it 'publish should use custom extension' do
+        draft_path = commands.draft({title: 'post title'})
+        fn = commands.publish(draft_path)
+        expect(fn).to match(/textile$/)
+      end
+
+      it 'unpublish should use custom extension' do
+        post_path = commands.post({title: 'post title'})
+        fn = commands.unpublish(post_path)
+        expect(fn).to match(/textile$/)
+      end
+
+    end
+
+    context 'with layout override' do
+
+      it "post should inherit layout's file extension" do
+        layout_path = write_custom_layout_textile
+        fn = c.post({title: 'post title', layout: layout_path})
+        expect(fn).not_to match(/md/)
+        expect(fn).to match(/textile$/)
+      end
+
+      it "draft should inherit layout's file extension" do
+        layout_path = write_custom_layout_textile
+        fn = c.draft({title: 'post title', layout: layout_path})
+        expect(fn).not_to match(/md/)
+        expect(fn).to match(/textile$/)
+      end
+
+      it "publish should inherit draft's extension" do
+        layout_path = write_custom_layout_textile
+        draft_path = c.draft({title: 'post title', layout: layout_path})
+        fn = c.publish(draft_path)
+        expect(fn).not_to match(/md/)
+        expect(fn).to match(/textile$/)
+      end
+
+      it "unpublish should inherit post's extension" do
+        layout_path = write_custom_layout_textile
+        post_path = c.post({title: 'post title', layout: layout_path})
+        fn = c.publish(post_path)
+        expect(fn).not_to match(/md/)
+        expect(fn).to match(/textile$/)
+      end
+
+    end
   end
 end

data/spec/config_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'mr_poole'
+
+def write_config_file
+  f = File.open('_config.yml', 'w')
+  f.puts 'poole:'
+  f.puts '  default_layout: _layouts/poole.md'
+  f.puts '  default_extension: md'
+  f.close
+end
+
+def write_config_file_no_poole
+  f = File.open('_config.yml', 'w')
+  f.puts 'name: Douglas N. Adams'
+  f.puts 'description: Life, the universe, and everything'
+  f.close
+end
+
+module MrPoole
+  describe Config do
+    before(:each) { @olddir, @tmpdir = make_jekyll_dir }
+    after(:each) { clean_tmp_files(@tmpdir, @olddir) }
+
+    describe '::initialize' do
+      it 'is empty with no config file' do
+        config = Config.new
+        expect(config).to be_empty
+      end
+
+      it "is empty with no 'poole' key in config file" do
+        write_config_file_no_poole
+        config = Config.new
+        expect(config).to be_empty
+      end
+
+      it "is not empty with 'poole' key in config file" do
+        write_config_file
+        config = Config.new
+        expect(config).not_to be_empty
+      end
+
+    end
+
+    describe '#method_missing' do
+      before(:each) { write_config_file }
+      let(:config) { Config.new }
+
+      it 'allows access to defined members' do
+        expect(config.default_extension).to eq('md')
+      end
+
+      it 'returns nil for unknown key' do
+        expect(config.bogus_key).to be_nil
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -38,7 +38,7 @@ def clean_tmp_files(tmpdir, restoredir)
   FileUtils.rm_rf(tmpdir)
 end
 
-def poole_with_args(argv)
+def poole(argv)
   return Proc.new do
     action = argv.shift
     cli = MrPoole::CLI.new(argv)
@@ -46,7 +46,7 @@ def poole_with_args(argv)
   end
 end
 
-def poole_with_args_no_stdout(argv)
+def poole_no_stdout(argv)
   return Proc.new do
     capture_stdout do
       action = argv.shift
@@ -55,3 +55,73 @@ def poole_with_args_no_stdout(argv)
     end
   end
 end
+
+# This captures SystemExit exceptions and returns stdout
+def aborted_poole_output(argv)
+  return Proc.new do
+    output = capture_stdout do
+      begin
+        action = argv.shift
+        cli = MrPoole::CLI.new(argv)
+        cli.execute(action)
+      rescue SystemExit
+      end
+    end
+    output
+  end
+end
+
+def write_custom_layout
+  filename = 'custom_layout.md'
+  f = File.open(filename, 'w')
+  f.puts '---'
+  f.puts 'title:'
+  f.puts 'date:'
+  f.puts 'tags: testing'
+  f.puts '---'
+  f.puts ''
+  f.close
+
+  filename
+end
+
+def write_custom_layout_textile
+  filename = 'custom_layout.textile'
+  f = File.open(filename, 'w')
+  f.puts '---'
+  f.puts 'title:'
+  f.puts 'date:'
+  f.puts 'tags: testing'
+  f.puts '---'
+  f.puts ''
+  f.close
+
+  filename
+end
+
+def write_config_file_custom_layout
+  filename = 'default_layout.md'
+
+  l = File.open(filename, 'w')
+  l.puts '---'
+  l.puts 'title:'
+  l.puts 'date:'
+  l.puts 'tags: from_config'
+  l.puts '---'
+  l.puts ''
+  l.close
+
+  c = File.open('_config.yml', 'w')
+  c.puts 'poole:'
+  c.puts "  default_layout: #{filename}"
+  c.close
+
+  filename
+end
+
+def write_config_file_custom_extension
+  c = File.open('_config.yml', 'w')
+  c.puts 'poole:'
+  c.puts "  default_extension: textile"
+  c.close
+end