mint 0.5.1 → 0.7.1

data/spec/layout_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Mint
   describe Layout do

data/spec/mint_spec.rb

@@ -1,94 +1,218 @@
-require 'spec_helper'
+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',
+      layout: "default",
+      style: "default",
       destination: nil,
       style_destination: nil
     }
   end
 
-  its(:directories) do 
-    should == { 
-      templates: 'templates',
-      config: 'config'
-    }
+  its(:directories) { should == { templates: "templates" } }
+  its(:files) { should == { syntax: "syntax.yaml", defaults: "defaults.yaml" } }
+
+  describe ".root" do
+    it "returns the root of the Mint gem as a string" do
+      Mint.root.should == File.expand_path("../../../mint", __FILE__)
+    end
   end
 
-  its(:files) do 
-    should == { 
-      syntax: Mint.directories[:config] + '/syntax.yaml',
-      config: Mint.directories[:config] + '/config.yaml' 
-    }
+  describe ".path" do
+    def as_pathname(files)
+      files.map {|file| Pathname.new(file) }
+    end
+
+    it "it returns the paths corresponding to all scopes as an array" do
+      Mint.path.should == [Pathname.new(".mint"),
+                           Pathname.new("~/.mint").expand_path,
+                           Pathname.new(Mint.root + "/config").expand_path]
+    end
+
+    it "can filter paths by one scope" do
+      Mint.path(:scopes => [:user]).should == [Pathname.new("~/.mint").expand_path]
+    end
+
+    it "can filter paths by many scopes" do
+      Mint.path(:scopes => [:local, :user]).should == [Pathname.new(".mint"),
+                                                       Pathname.new("~/.mint").expand_path]
+    end
   end
 
-  it "creates a valid renderer" do
-    Mint.renderer(@content_file).should respond_to(:render)
+
+  describe ".configuration" do
+    let(:defaults) do
+      {
+        layout: "default",
+        style: "default",
+        destination: nil,
+        style_destination: nil
+      }
+    end
+
+    context "when there is no defaults.yaml file on the Mint path" do
+      it "returns a default set of options" do
+        Mint.configuration.should == defaults 
+      end
+    end
+
+    context "when there is a defaults.yaml file on the Mint path" do
+      before do
+        FileUtils.mkdir_p ".mint"
+        File.open(".mint/defaults.yaml", "w") do |file|
+          file << "layout: zen"
+        end
+      end
+
+      after do
+        FileUtils.rm_rf ".mint"
+      end
+
+      it "merges all specified options with precedence according to scope" do
+        Mint.configuration[:layout].should == "zen"
+      end
+
+      it "can filter by scope (but always includes defaults)" do
+        Mint.configuration(:scopes => [:user]).should == defaults
+      end
+    end
   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
+  describe ".configuration_with" do
+    it "displays the sum of all configuration files with other options added" do
+      Mint.configuration_with(:local => true).should == {
+        layout: "default",
+        style: "default",
+        destination: nil,
+        style_destination: nil,
+        local: true
+      }
+    end
   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'
+  describe ".templates" do
+    it "returns all templates if no scopes are passed in" do
+      Mint.templates.should include(Mint.root + "/config/templates/default") 
+    end
+
+    it "returns all local templates if the scope is local" do
+      pending "a rearchitecture and unification of scopes"
+      Mint.templates(:scope => :local).should_not include(Mint.root + "/config/templates/default")
+    end
   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')
+  describe ".formats" do
+    it "includes Markdown" do
+      Mint.formats.should include("md")
+    end
+
+    it "includes Haml" do
+      Mint.formats.should include("haml")
+    end
   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
+  describe ".css_formats" do
+    it "includes Sass" do
+      Mint.formats.should include("sass")
+    end
+  end
+
+  describe ".renderer" do
+    it "creates a valid renderer" do
+      Mint.renderer(@content_file).should respond_to(:render)
+    end
+  end
+
+  describe ".path_for_scope" do
+    it "chooses the appropriate path for scope" do
+      expectations = {
+        local: Pathname.new(".mint"),
+        user: Pathname.new("~/.mint").expand_path,
+        global: Pathname.new(Mint.root + "/config").expand_path
+      }
 
-    actual_template.should be_a_template
-    fake_template.should_not be_a_template
-    obvious_nontemplate.should_not be_a_template
+      expectations.each do |scope, path|
+        Mint.path_for_scope(scope).should == path
+      end
+    end
   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'
+  describe ".lookup_template" do
+    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(:zen, :layout).should be_in_template("zen")
+      Mint.lookup_template(:zen, :style).should be_in_template("zen")
+      Mint.lookup_template("layout.haml").should == "layout.haml"
+      Mint.lookup_template("dynamic.sass").should == "dynamic.sass"
+    end
   end
 
-  context "before it publishes a document" do
-    let(:document) { Mint::Document.new @content_file }
-    subject { document }
+  describe ".find_template" do
+    it "finds the correct template according to scope" do
+      Mint.find_template("default", :layout).should be_in_template("default")
+      Mint.find_template("zen", :layout).should be_in_template("zen")
+      Mint.find_template("zen", :style).should be_in_template("zen")
+    end
+
+    it "decides whether or not a file is a template file" do
+      actual_template = Mint.lookup_template(:default, :layout)
+      fake_template = "#{Mint.root}/config/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
+  end
 
-    its(:destination_file_path) { should_not exist }
-    its(:style_destination_file_path) { should_not exist }
+  describe ".guess_name_from" do
+    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
   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 }
+  describe ".destination_file_path and .style_destination_file_path" do
+    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
+
+  describe ".template_path" do
+    it "creates a template in the local directory" do
+      Mint.template_path("pro", :layout).should == 
+        ".mint/templates/pro/layout.haml" 
+    end
+
+    it "allows an extension to be specified" do
+      Mint.template_path("pro", :layout, :ext => "erb").should == 
+        ".mint/templates/pro/layout.erb" 
+    end
 
-    its(:destination_file_path) { should exist }
-    its(:style_destination_file_path) { should exist }
+    it "allows a scope to be specified" do
+      Mint.template_path("pro", :layout, :scope => :user).should == 
+        File.expand_path("~/.mint/templates/pro/layout.haml")
+    end
   end
 end

data/spec/plugin_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Mint do
   # Remove unintended side effects of creating
@@ -17,12 +17,6 @@ describe Mint do
     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 }
 
@@ -75,9 +69,9 @@ describe Mint 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')
+      plugin.should_receive(:name).and_return("DocBook")
       Mint.template_directory(plugin).should == 
-        Mint.root + '/plugins/templates/doc_book'
+        Mint.root + "/plugins/templates/doc_book"
     end
   end
 
@@ -85,9 +79,9 @@ describe Mint 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')
+      plugin.should_receive(:name).and_return("DocBook")
       Mint.config_directory(plugin).should == 
-        Mint.root + '/plugins/config/doc_book'
+        Mint.root + "/plugins/config/doc_book"
     end
   end
 
@@ -95,9 +89,9 @@ describe Mint 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')
+      plugin.should_receive(:name).and_return("DocBook")
       Mint.commandline_options_file(plugin).should == 
-        Mint.root + '/plugins/config/doc_book/syntax.yml'
+        Mint.root + "/plugins/config/doc_book/syntax.yml"
     end
   end
 
@@ -109,28 +103,28 @@ describe Mint do
 
       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')
+          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'
+          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')
+          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'
+          Mint.send(callback, "text").should == "second"
         end
       end
 
@@ -142,7 +136,7 @@ describe Mint do
         end
         
         it "returns the parameter text" do
-          Mint.send(callback, 'text').should == 'text'
+          Mint.send(callback, "text").should == "text"
         end
       end
     end
@@ -162,7 +156,7 @@ describe Mint do
 
       it "iterates across all specified plugins in order" do
         plugins = [first_plugin, second_plugin]
-        Mint.after_publish('fake document', :plugins => plugins)
+        Mint.after_publish("fake document", :plugins => plugins)
       end
     end
 
@@ -176,7 +170,7 @@ describe Mint do
       it "iterates across all activated plugins in order" do
         Mint.activate_plugin! first_plugin
         Mint.activate_plugin! second_plugin
-        Mint.after_publish('fake document')
+        Mint.after_publish("fake document")
       end
     end
 
@@ -188,7 +182,7 @@ describe Mint do
       end
       
       it "does not iterate over any plugins" do
-        Mint.after_publish('fake document')
+        Mint.after_publish("fake document")
       end
     end
   end
@@ -213,7 +207,7 @@ describe Mint do
   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
+    # the first two tests in the "#inherited" suite will not
     # pass.
     before do
       @first_plugin = Class.new(Mint::Plugin)
@@ -226,8 +220,8 @@ describe Mint do
       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'
+        plugin.should_receive(:name).and_return("EPub")
+        plugin.underscore.should == "epub"
       end
     end
 
@@ -271,11 +265,11 @@ describe Mint do
         it "allows changes to the un-rendered content" do
           plugin.instance_eval do
             def before_render(text_document)
-              'base'
+              "base"
             end
           end
 
-          plugin.before_render('text').should == 'base'
+          plugin.before_render("text").should == "base"
         end
       end
 
@@ -283,21 +277,21 @@ describe Mint do
         it "allows changes to the rendered HTML" do
           plugin.instance_eval do
             def after_render(html_document)
-              '<!doctype html>'
+              "<!doctype html>"
             end
           end
 
-          plugin.after_render('<html></html>').should == '<!doctype html>'
+          plugin.after_render("<html></html>").should == "<!doctype html>"
         end
       end
 
       describe ".after_mint" do
-        let(:document) { Mint::Document.new 'content.md' } 
+        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'
+              document.name.gsub! /html$/, "htm"
             end
           end
 
@@ -315,11 +309,11 @@ describe Mint do
               first  = content[0..fake_splitting_point]
               second = content[fake_splitting_point..-1]
 
-              File.open 'first-half.html', 'w+' do |file|
+              File.open "first-half.html", "w+" do |file|
                 file << first
               end
 
-              File.open 'second-half.html', 'w+' do |file|
+              File.open "second-half.html", "w+" do |file|
                 file << second
               end
 
@@ -330,13 +324,13 @@ describe Mint do
           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
+          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' 
+          document = Mint::Document.new "content.md", :style => "style.css" 
 
           plugin.instance_eval do
             def after_publish(document)
@@ -346,8 +340,8 @@ describe Mint do
               # 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(/#/, '.')
+              File.open style_source, "w" do |file|
+                file << style.gsub(/#/, ".")
               end
             end
           end
@@ -360,13 +354,13 @@ describe Mint do
         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'
+            document = Mint::Document.new "content.md"
             plugin.instance_eval do
               def after_publish
                 original = document.destination_directory
-                new = File.expand_path 'invalid'
+                new = File.expand_path "invalid"
                 FileUtils.mv original, new
-                document.destination = 'invalid'
+                document.destination = "invalid"
               end
 
               lambda do
@@ -378,77 +372,77 @@ describe Mint do
 
         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'
+            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'
+                new = File.expand_path "book"
                 FileUtils.mv original, new
-                document.destination = 'book'
+                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')
+            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'
+            require "zip/zip"
+            require "zip/zipfilesystem"
 
-            document = Mint::Document.new 'content.md', :destination => 'destination'
+            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)
+                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'
+                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
+            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
+            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'
+            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'
+                new = File.expand_path "looks"
                 FileUtils.mv original, new
-                document.style_destination = 'looks'
+                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')
+            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')
+            FileUtils.rm_r File.expand_path("looks")
           end
         end
       end