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

mint 0.2.9 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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

data/spec/document_spec.rb CHANGED

@@ -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