RubyGems - mint - Versions diffs - 0.2.9 → 0.5.0 - Mend

mint 0.2.9 → 0.5.0

Files changed (32) hide show

data/README.md +45 -283
data/bin/mint +10 -10
data/bin/mint-epub +23 -0
data/features/plugins/epub.feature +23 -0
data/features/publish.feature +73 -0
data/features/support/env.rb +1 -1
data/lib/mint.rb +1 -0
data/lib/mint/commandline.rb +3 -3
data/lib/mint/document.rb +46 -5
data/lib/mint/helpers.rb +65 -4
data/lib/mint/mint.rb +6 -7
data/lib/mint/plugin.rb +136 -0
data/lib/mint/plugins/epub.rb +292 -0
data/lib/mint/version.rb +1 -1
data/plugins/templates/epub/container.haml +5 -0
data/plugins/templates/epub/content.haml +36 -0
data/plugins/templates/epub/layout.haml +6 -0
data/plugins/templates/epub/title.haml +11 -0
data/plugins/templates/epub/toc.haml +26 -0
data/spec/commandline_spec.rb +91 -0
data/spec/document_spec.rb +48 -9
data/spec/helpers_spec.rb +231 -0
data/spec/layout_spec.rb +6 -0
data/spec/mint_spec.rb +94 -0
data/spec/plugin_spec.rb +457 -0
data/spec/plugins/epub_spec.rb +242 -0
data/spec/resource_spec.rb +135 -0
data/spec/spec_helper.rb +18 -0
data/spec/style_spec.rb +69 -0
metadata +103 -34
data/features/mint_document.feature +0 -48
data/features/step_definitions/mint_steps.rb +0 -1

@@ -10,21 +10,19 @@ module Mint
     # We do have to test #style_destination derivatives. Those aren't
     # covered by resource_spec.rb.
     shared_examples_for "all documents" do
-      # Convenience methods
-      it "#stylesheet" do
-        document.stylesheet.should ==
-          Helpers.normalize_path(document.style_destination_file,
-                                 document.destination_directory).to_s
-      end
       # style_spec.rb ensures that our style generation goes as planned
       # However, we need to test layout generation because it should now
       # include our content
+      #
+      # This test doesn't cover any plugin transformations. Those
+      # transformations are covered in the Plugin spec.
       its(:content) { should =~ /<p>This is just a test.<\/p>/ }
+      its(:metadata) { should == { 'metadata' =>  true } }
       # Render output
+      # This test doesn't cover any plugin transformations. Those
+      # transformations are covered in the Plugin spec.
       it "renders its layout, injecting content inside" do
         document.render.should =~
           /.*<html>.*#{document.content}.*<\/html>.*/m
@@ -36,6 +34,8 @@ module Mint
       # Mint output
+      # These tests doesn't cover any plugin transformations. Those
+      # transformations are covered in the Plugin spec.
       it "writes its rendered style to #style_destination_file" do
         document.publish!
         document.style_destination_file_path.should exist
@@ -77,6 +77,8 @@ module Mint
       its(:layout) { should be_in_directory('default') }
       its(:style) { should be_in_directory('default') }
+      its(:stylesheet) { should == Mint.root + '/templates/default/css/style.css' }
       it_should_behave_like "all documents"
     end
@@ -110,6 +112,8 @@ module Mint
       its(:layout) { should be_in_directory('default') }
       its(:style) { should be_in_directory('default') }
+      its(:stylesheet) { should == 'styles/style.css' }
       it_should_behave_like "all documents"
     end
@@ -142,6 +146,8 @@ module Mint
       its(:layout) { should be_in_directory('default') }
       its(:style) { should be_in_directory('default') }
+      its(:stylesheet) { should == Mint.root + '/templates/default/css/style.css' }
       it_should_behave_like "all documents"
     end
@@ -181,7 +187,40 @@ module Mint
       its(:layout) { should be_in_directory('pro') }
       its(:style) { should be_in_directory('pro') }
+      its(:stylesheet) { should == 'styles/style.css' }
       it_should_behave_like "all documents"
     end
+    context "when dealing with metadata" do
+      let(:text) { "metadata: true\n\nReal text" }
+      describe ".metadata_chunk" do
+        it "extracts, but does not parse, metadata from text" do
+          Document.metadata_chunk(text).should == 'metadata: true'
+        end
+      end
+      describe ".metadata_from" do
+        it "parses a documents metadata if present" do
+          Document.metadata_from(text).should == { 'metadata' => true }
+        end
+        it "returns the empty string if a document has bad/no metadata" do
+          Document.metadata_from('No metadata here').should == {}
+        end
+      end
+      describe ".parse_metadata_from" do
+        it "separates text from its metadata if present" do
+          Document.parse_metadata_from(text).should ==
+            [{ 'metadata' => true }, 'Real text']
+        end
+        it "returns the entire text if no metadata is found" do
+          Document.parse_metadata_from('No metadata here').should ==
+            [{}, 'No metadata here']
+        end
+      end
+    end
   end
 end

data/spec/helpers_spec.rb ADDED

@@ -0,0 +1,231 @@
+require 'spec_helper'
+module Mint
+  describe Helpers do
+    describe "#underscore" do
+      it "underscores class names per ActiveSupport conventions" do
+        Helpers.underscore('ClassName').should == 'class_name'
+      end
+      it "allows for camel case prefixes" do
+        Helpers.underscore('EPub').should == 'e_pub'
+        Helpers.underscore('EPub', :ignore_prefix => true).should == 'epub'
+      end
+      it "allows for namespace removal" do
+        Helpers.underscore('Mint::EPub',
+                           :namespaces => true).should == 'mint/e_pub'
+        Helpers.underscore('Mint::EPub',
+                           :namespaces => false).should == 'e_pub'
+        Helpers.underscore('Mint::EPub',
+                           :namespaces => true,
+                           :ignore_prefix => true).should == 'mint/epub'
+      end
+    end
+    describe "#slugize" do
+      it "downcases everything" do
+        Helpers.slugize('This could use FEWER CAPITALS').should ==
+          'this-could-use-fewer-capitals'
+      end
+      it "parses 'and'" do
+        Helpers.slugize('You & me').should == 'you-and-me'
+      end
+      it "parses spaces" do
+        Helpers.slugize('You     and me').should == 'you-and-me'
+      end
+      it "removes non-word/non-digits" do
+        Helpers.slugize('You // and :: me').should == 'you-and-me'
+      end
+      it "condenses multiple hyphens" do
+        Helpers.slugize('You-----and me').should == 'you-and-me'
+      end
+    end
+    describe "#symbolize" do
+      it "converts hyphens to underscores" do
+        Helpers.symbolize('you-and-me').should == :you_and_me
+      end
+    end
+    describe "#pathize" do
+      it "converts a String to a Pathname" do
+        Helpers.pathize("filename.md").should ==
+          Pathname.new("filename.md").expand_path
+      end
+      it "does not convert a Pathname" do
+        pathname = Pathname.new("filename.md")
+        Helpers.pathize(pathname).should == pathname.expand_path
+      end
+    end
+    describe "#symbolize_keys" do
+      it "turns all string keys in a flat map into symbols" do
+        flat_map = {
+          'key1' => 'value1',
+          'key2' => 'value2',
+          'key3' => 'value3'
+        }
+        expected_map = {
+          key1: 'value1',
+          key2: 'value2',
+          key3: 'value3'
+        }
+        Helpers.symbolize_keys(flat_map).should == expected_map
+      end
+      it "recursively turns all string keys in a nested map into symbols" do
+        nested_map = {
+          'key1' => 'value1',
+          'key2' => 'value2',
+          'key3' => 'value3',
+          'key4' => {
+            'nested_key1' => 'nested_value1',
+            'nested_key2' => 'nested_value2'
+          }
+        }
+        expected_map = {
+          key1: 'value1',
+          key2: 'value2',
+          key3: 'value3',
+          key4: {
+            nested_key1: 'nested_value1',
+            nested_key2: 'nested_value2'
+          }
+        }
+        Helpers.symbolize_keys(nested_map).should == expected_map
+      end
+      it "recursively downcases all keys if specified" do
+        capitalized_map = {
+          'Key1' => 'value1',
+          'Key2' => 'value2',
+          'Key3' => 'value3',
+          'Key4' => {
+            'Nested_key1' => 'nested_value1',
+            'Nested_key2' => 'nested_value2'
+          }
+        }
+        expected_map = {
+          key1: 'value1',
+          key2: 'value2',
+          key3: 'value3',
+          key4: {
+            nested_key1: 'nested_value1',
+            nested_key2: 'nested_value2'
+          }
+        }
+        Helpers.symbolize_keys(capitalized_map, :downcase => true).should == expected_map
+      end
+    end
+    describe "#listify" do
+      it "joins a list of three or more with an ampersand, without the Oxford comma" do
+        Helpers.listify(['Alex', 'Chris', 'John']).should ==
+          'Alex, Chris & John'
+      end
+      it "joins a list of two with an ampersand" do
+        Helpers.listify(['Alex', 'Chris']).should == 'Alex & Chris'
+      end
+      it "does not do anything to a list of one" do
+        Helpers.listify(['Alex']).should == 'Alex'
+      end
+    end
+    describe "#standardize" do
+      before do
+        @nonstandard = {
+          title: 'Title',
+          author: 'David',
+          editors: ['David', 'Jake'],
+          barcode: 'Unique ID'
+        }
+        @table = {
+          author: [:creators, :array],
+          editors: [:collaborators, :array],
+          barcode: [:uuid, :string]
+        }
+        @standard = {
+          title: 'Title',
+          creators: ['David'],
+          collaborators: ['David', 'Jake'],
+          uuid: 'Unique ID'
+        }
+      end
+      it "converts all nonstandard keys to standard ones" do
+        Helpers.standardize(@nonstandard,
+                            :table => @table).should == @standard
+      end
+    end
+    describe "#normalize_path" do
+      it "handles two files in the same directory" do
+        path1 = '~/file1'
+        path2 = '~/file2'
+        Helpers.normalize_path(path1, path2).should ==
+          Pathname.new('../file1')
+      end
+      it "handles two files one directory apart" do
+        path1 = '~/file1'
+        path2 = '~/subdir/file2'
+        Helpers.normalize_path(path1, path2).should ==
+          Pathname.new('../../file1')
+      end
+      it "handles two files linked only at the directory root" do
+        path1 = '/home/david/file1'
+        path2 = '/usr/local/src/file2'
+        Helpers.normalize_path(path1, path2).should ==
+          Pathname.new('/home/david/file1')
+      end
+      it "returns nil for identical files" do
+        path1 = '~/file1'
+        path2 = '~/file1'
+        Helpers.normalize_path(path1, path2).should == Pathname.new('.')
+      end
+    end
+    describe "#update_yaml!" do
+      it "loads existing YAML data from file"
+      it "combines existing YAML data with new data and writes to file"
+    end
+    describe "#generate_temp_file!" do
+      before do
+        @file = Helpers.generate_temp_file! 'content.md'
+        @path = Pathname.new @file
+      end
+      it "creates a randomly named temp file" do
+        @path.should exist
+      end
+      it "creates a temp file with the correct name and extension" do
+        @path.basename.to_s.should =~ /content/
+        @path.extname.should == '.md'
+      end
+      it "fills the temp file with the specified content" do
+        @path.read.should =~ /This is just a test/
+      end
+    end
+  end
+end

data/spec/layout_spec.rb ADDED

@@ -0,0 +1,6 @@
+require 'spec_helper'
+module Mint
+  describe Layout do
+  end
+end

data/spec/mint_spec.rb ADDED

@@ -0,0 +1,94 @@
+require 'spec_helper'
+describe Mint do
+  subject { Mint }
+  its(:root) { should == File.expand_path('../../../mint', __FILE__) }
+  its(:path) { should == ["#{Dir.getwd}/.mint", "~/.mint", Mint.root] }
+  its(:formats) { should include('md') }
+  its(:css_formats) { should include('sass') }
+  its(:templates) { should include(Mint.root + '/templates/default') }
+  its(:default_options) do
+    should == {
+      layout: 'default',
+      style: 'default',
+      destination: nil,
+      style_destination: nil
+    }
+  end
+  its(:directories) do
+    should == {
+      templates: 'templates',
+      config: 'config'
+    }
+  end
+  its(:files) do
+    should == {
+      syntax: Mint.directories[:config] + '/syntax.yaml',
+      config: Mint.directories[:config] + '/config.yaml'
+    }
+  end
+  it "creates a valid renderer" do
+    Mint.renderer(@content_file).should respond_to(:render)
+  end
+  it "chooses the appropriate path for scope" do
+    Mint.path_for_scope(:local).should == "#{Dir.getwd}/.mint"
+    Mint.path_for_scope(:user).should == '~/.mint'
+    Mint.path_for_scope(:global).should == Mint.root
+  end
+  it "looks up the correct template according to scope" do
+    Mint.lookup_template(:default, :layout).should be_in_template('default')
+    Mint.lookup_template(:default, :style).should be_in_template('default')
+    Mint.lookup_template(:pro, :layout).should be_in_template('pro')
+    Mint.lookup_template(:pro, :style).should be_in_template('pro')
+    Mint.lookup_template('layout.haml').should == 'layout.haml'
+    Mint.lookup_template('dynamic.sass').should == 'dynamic.sass'
+  end
+  it "finds the correct template according to scope" do
+    Mint.find_template('default', :layout).should be_in_template('default')
+    Mint.find_template('pro', :layout).should be_in_template('pro')
+    Mint.find_template('pro', :style).should be_in_template('pro')
+  end
+  it "decides whether or not a file is a template file" do
+    actual_template = Mint.lookup_template(:default, :layout)
+    fake_template = "#{Mint.root}/templates/default.css"
+    obvious_nontemplate = @dynamic_style_file
+    actual_template.should be_a_template
+    fake_template.should_not be_a_template
+    obvious_nontemplate.should_not be_a_template
+  end
+  it "properly guesses destination file names based on source file names" do
+    Mint.guess_name_from('content.md').should == 'content.html'
+    Mint.guess_name_from('content.textile').should == 'content.html'
+    Mint.guess_name_from('layout.haml').should == 'layout.html'
+    Mint.guess_name_from('dynamic.sass').should == 'dynamic.css'
+  end
+  context "before it publishes a document" do
+    let(:document) { Mint::Document.new @content_file }
+    subject { document }
+    its(:destination_file_path) { should_not exist }
+    its(:style_destination_file_path) { should_not exist }
+  end
+  # These are copied from document_spec.rb. I eventually want to move
+  # to this non-OO style of publishing, and this is the transition
+  context "when it publishes a document" do
+    let(:document) { Mint::Document.new @content_file }
+    before { Mint.publish! document }
+    subject { document }
+    its(:destination_file_path) { should exist }
+    its(:style_destination_file_path) { should exist }
+  end
+end

data/spec/plugin_spec.rb ADDED

@@ -0,0 +1,457 @@
+require 'spec_helper'
+describe Mint do
+  # Remove unintended side effects of creating
+  # new plugins in other files.
+  before { Mint.clear_plugins! }
+  after { Mint.clear_plugins! }
+  describe ".plugins" do
+    it "returns all registered plugins" do
+      plugin = Class.new(Mint::Plugin)
+      Mint.plugins.should == [plugin]
+    end
+    it "returns an empty array if there are no registered plugins" do
+      Mint.plugins.should == []
+    end
+  end
+  describe ".activated_plugins" do
+    it "returns a list of plugins activated for a document"
+    it "returns a list of plugins activated for a set of documents"
+    it "returns a list of plugins activated for all documents"
+  end
+  describe ".register_plugin!" do
+    let(:plugin) { Class.new }
+    it "registers a plugin once" do
+      Mint.register_plugin! plugin
+      Mint.plugins.should == [plugin]
+    end
+    it "does not register a plugin more than once" do
+      Mint.register_plugin! plugin
+      lambda { Mint.register_plugin! plugin }.should_not change { Mint.plugins }
+      Mint.plugins.should == [plugin]
+    end
+  end
+  describe ".activate_plugin!" do
+    let(:plugin) { Class.new }
+    it "activates a plugin once" do
+      Mint.activate_plugin! plugin
+      Mint.activated_plugins.should == [plugin]
+    end
+    it "does not register a plugin more than once" do
+      Mint.activate_plugin! plugin
+      lambda { Mint.activate_plugin! plugin }.should_not change { Mint.activated_plugins }
+      Mint.activated_plugins.should == [plugin]
+    end
+  end
+  describe ".clear_plugins!" do
+    let(:plugin) { Class.new }
+    it "does nothing if no plugins are registered" do
+      lambda { Mint.clear_plugins! }.should_not raise_error
+    end
+    it "removes all registered plugins" do
+      Mint.register_plugin! plugin
+      lambda { Mint.clear_plugins! }.should change { Mint.plugins.length }.by(-1)
+    end
+    it "removes all activated plugins" do
+      Mint.activate_plugin! plugin
+      lambda { Mint.clear_plugins! }.should change { Mint.activated_plugins.length }.by(-1)
+    end
+  end
+  describe ".template_directory" do
+    let(:plugin) { Class.new(Mint::Plugin) }
+    it "gives access to a directory where template files can be stored" do
+      plugin.should_receive(:name).and_return('DocBook')
+      Mint.template_directory(plugin).should ==
+        Mint.root + '/plugins/templates/doc_book'
+    end
+  end
+  describe ".config_directory" do
+    let(:plugin) { Class.new(Mint::Plugin) }
+    it "gives access to a directory where template files can be stored" do
+      plugin.should_receive(:name).and_return('DocBook')
+      Mint.config_directory(plugin).should ==
+        Mint.root + '/plugins/config/doc_book'
+    end
+  end
+  describe ".commandline_options_file" do
+    let(:plugin) { Class.new(Mint::Plugin) }
+    it "gives access to a directory where template files can be stored" do
+      plugin.should_receive(:name).and_return('DocBook')
+      Mint.commandline_options_file(plugin).should ==
+        Mint.root + '/plugins/config/doc_book/syntax.yml'
+    end
+  end
+  [:before_render, :after_render].each do |callback|
+    describe ".#{callback}" do
+      let(:first_plugin) { Class.new(Mint::Plugin) }
+      let(:second_plugin) { Class.new(Mint::Plugin) }
+      let(:third_plugin) { Class.new(Mint::Plugin) }
+      context "when plugins are specified" do
+        before do
+          first_plugin.should_receive(callback).ordered.and_return('first')
+          second_plugin.should_receive(callback).ordered.and_return('second')
+          third_plugin.should_receive(callback).never
+        end
+        it "reduces .#{callback} across all specified plugins in order" do
+          plugins = [first_plugin, second_plugin]
+          Mint.send(callback, 'text', :plugins => plugins).should == 'second'
+        end
+      end
+      context "when plugins are activated, but no plugins are specified" do
+        before do
+          first_plugin.should_receive(callback).ordered.and_return('first')
+          second_plugin.should_receive(callback).ordered.and_return('second')
+          third_plugin.should_receive(callback).never
+        end
+        it "reduces .#{callback} across all activated plugins in order" do
+          Mint.activate_plugin! first_plugin
+          Mint.activate_plugin! second_plugin
+          Mint.send(callback, 'text').should == 'second'
+        end
+      end
+      context "when plugins are not specified" do
+        before do
+          first_plugin.should_receive(callback).never
+          second_plugin.should_receive(callback).never
+          third_plugin.should_receive(callback).never
+        end
+        it "returns the parameter text" do
+          Mint.send(callback, 'text').should == 'text'
+        end
+      end
+    end
+  end
+  describe ".after_publish" do
+    let(:first_plugin) { Class.new(Mint::Plugin) }
+    let(:second_plugin) { Class.new(Mint::Plugin) }
+    let(:third_plugin) { Class.new(Mint::Plugin) }
+    context "when plugins are specified" do
+      before do
+        first_plugin.should_receive(:after_publish).ordered
+        second_plugin.should_receive(:after_publish).ordered
+        third_plugin.should_receive(:after_publish).never
+      end
+      it "iterates across all specified plugins in order" do
+        plugins = [first_plugin, second_plugin]
+        Mint.after_publish('fake document', :plugins => plugins)
+      end
+    end
+    context "when plugins are activated, but no plugins are specified" do
+      before do
+        first_plugin.should_receive(:after_publish).ordered
+        second_plugin.should_receive(:after_publish).ordered
+        third_plugin.should_receive(:after_publish).never
+      end
+      it "iterates across all activated plugins in order" do
+        Mint.activate_plugin! first_plugin
+        Mint.activate_plugin! second_plugin
+        Mint.after_publish('fake document')
+      end
+    end
+    context "when plugins are not specified" do
+      before do
+        first_plugin.should_receive(:after_publish).never
+        second_plugin.should_receive(:after_publish).never
+        third_plugin.should_receive(:after_publish).never
+      end
+      it "does not iterate over any plugins" do
+        Mint.after_publish('fake document')
+      end
+    end
+  end
+  # TODO: Document expected document functionality changes related to plugins
+  describe Mint::Document do
+    context "when plugins are registered with Mint" do
+      describe "#content=" do
+        it "applies each registered plugin's before_render filter"
+      end
+      describe "#render" do
+        it "applies each registered plugin's after_render filter"
+      end
+      describe "#publish!" do
+        it "applies each registered plugin's after_publish filter"
+      end
+    end
+  end
+  describe Mint::Plugin do
+    # We have to instantiate these plugins in a before block,
+    # and not in a let block. Because lets are lazily evaluated,
+    # the first two tests in the '#inherited' suite will not
+    # pass.
+    before do
+      @first_plugin = Class.new(Mint::Plugin)
+      @second_plugin = Class.new(Mint::Plugin)
+    end
+    describe ".underscore" do
+      let(:plugin) { Class.new(Mint::Plugin) }
+      it "when anonymous, returns a random identifier"
+      it "when named, returns its name, underscored" do
+        plugin.should_receive(:name).and_return('EPub')
+        plugin.underscore.should == 'epub'
+      end
+    end
+    describe ".inherited" do
+      it "registers the subclass with Mint as a plugin" do
+        lambda do
+          Class.new(Mint::Plugin)
+        end.should change { Mint.plugins.length }.by(1)
+      end
+      it "preserves the order of subclassing" do
+        Mint.plugins.should == [@first_plugin, @second_plugin]
+      end
+      it "does not change the order of a plugin when it is monkey-patched" do
+        lambda do
+          @first_plugin.instance_eval do
+            def monkey_patch
+            end
+          end
+        end.should_not change { Mint.plugins }
+      end
+    end
+    describe ".commandline_options" do
+      let(:plugin) { Class.new(Mint::Plugin) }
+      before do
+        plugin.instance_eval do
+          def commandline_options
+          end
+        end
+      end
+      it "returns a hash of options the plugin can take, including constraints"
+    end
+    context "plugin callbacks" do
+      let(:plugin) { Class.new(Mint::Plugin) }
+      describe ".before_render" do
+        it "allows changes to the un-rendered content" do
+          plugin.instance_eval do
+            def before_render(text_document)
+              'base'
+            end
+          end
+          plugin.before_render('text').should == 'base'
+        end
+      end
+      describe ".after_render" do
+        it "allows changes to the rendered HTML" do
+          plugin.instance_eval do
+            def after_render(html_document)
+              '<!doctype html>'
+            end
+          end
+          plugin.after_render('<html></html>').should == '<!doctype html>'
+        end
+      end
+      describe ".after_mint" do
+        let(:document) { Mint::Document.new 'content.md' }
+        it "allows changes to the document extension" do
+          plugin.instance_eval do
+            def after_publish(document)
+              document.name.gsub! /html$/, 'htm'
+            end
+          end
+          lambda do
+            plugin.after_publish(document)
+          end.should change { document.name.length }.by(-1)
+        end
+        it "allows splitting up the document into two, without garbage" do
+          plugin.instance_eval do
+            def after_publish(document)
+              content = document.content
+              fake_splitting_point = content.length / 2
+              first  = content[0..fake_splitting_point]
+              second = content[fake_splitting_point..-1]
+              File.open 'first-half.html', 'w+' do |file|
+                file << first
+              end
+              File.open 'second-half.html', 'w+' do |file|
+                file << second
+              end
+              File.delete document.destination_file
+            end
+          end
+          document.publish! :plugins => [plugin]
+          File.exist?(document.destination_file).should be_false
+          File.exist?('first-half.html').should be_true
+          File.exist?('second-half.html').should be_true
+        end
+        it "allows changes to the style file" do
+          pending "figure out a better strategy for style manipulation"
+          document = Mint::Document.new 'content.md', :style => 'style.css'
+          plugin.instance_eval do
+            def after_publish(document)
+              # I'd like to take document.style_destination_file,
+              # but the current Mint API doesn't allow for this
+              # if we're setting the style via a concrete
+              # stylesheet in our current directory
+              style_source = document.style.source_file
+              style = File.read style_source
+              File.open style_source, 'w' do |file|
+                file << style.gsub(/#/, '.')
+              end
+            end
+          end
+          document.publish! :plugins => [plugin]
+          File.read(document.style.source_file).should =~ /\#container/
+        end
+        context "when the output is in the default directory" do
+          it "doesn't allow changes to the document directory" do
+            pending "figuring out the best way to prevent directory manipulation"
+            document = Mint::Document.new 'content.md'
+            plugin.instance_eval do
+              def after_publish
+                original = document.destination_directory
+                new = File.expand_path 'invalid'
+                FileUtils.mv original, new
+                document.destination = 'invalid'
+              end
+              lambda do
+                document.publish! :plugins => [plugin]
+              end.should raise_error(InvalidPluginAction)
+            end
+          end
+        end
+        context "when the output is a new directory" do
+          it "allows changes to the document directory" do
+            document = Mint::Document.new 'content.md', :destination => 'destination'
+            plugin.instance_eval do
+              def after_publish(document)
+                original = document.destination_directory
+                new = File.expand_path 'book'
+                FileUtils.mv original, new
+                document.destination = 'book'
+              end
+            end
+            document.publish! :plugins => [plugin]
+            File.exist?('destination').should be_false
+            File.exist?('book').should be_true
+            document.destination_directory.should == File.expand_path('book')
+          end
+          it "allows compression of the final output" do
+            require 'zip/zip'
+            require 'zip/zipfilesystem'
+            document = Mint::Document.new 'content.md', :destination => 'destination'
+            plugin.instance_eval do
+              def after_publish(document)
+                Zip::ZipOutputStream.open 'book.zip' do |zos|
+                  # zos.put_next_entry('mimetype', nil, nil, Zip::ZipEntry::STORED)
+                  # zos.puts 'text/epub'
+                  zos.put_next_entry('chapter-1', nil, nil, Zip::ZipEntry::DEFLATED)
+                  zos.puts File.read(document.destination_file)
+                end
+                FileUtils.mv 'book.zip', 'book.epub'
+              end
+            end
+            document.publish! :plugins => [plugin]
+            File.exist?('destination').should be_true
+            File.exist?('book.zip').should be_false
+            File.exist?('book.epub').should be_true
+            directory_size =
+              Dir["#{document.destination_directory}/**/*"].
+              flatten.
+              map {|file| File.stat(file).size }.
+              reduce(&:+)
+            compressed_size = File.stat('book.epub').size
+            directory_size.should > compressed_size
+          end
+        end
+        context "when the style output is a new directory" do
+          it "allows changes to the style directory" do
+            document = Mint::Document.new 'content.md', :style_destination => 'styles'
+            plugin.instance_eval do
+              def after_publish(document)
+                original = document.style_destination_directory
+                new = File.expand_path 'looks'
+                FileUtils.mv original, new
+                document.style_destination = 'looks'
+              end
+            end
+            document.publish! :plugins => [plugin]
+            File.exist?('styles').should be_false
+            File.exist?('looks').should be_true
+            document.style_destination_directory.should == File.expand_path('looks')
+          end
+          after do
+            FileUtils.rm_r File.expand_path('looks')
+          end
+        end
+      end
+    end
+  end
+end