mint 0.7.4 → 0.8.1

data/spec/helpers_spec.rb

@@ -4,63 +4,63 @@ module Mint
   describe Helpers do
     describe ".underscore" do
       it "underscores class names per ActiveSupport conventions" do
-        Helpers.underscore("ClassName").should == "class_name"
+        expect(Helpers.underscore("ClassName")).to eq("class_name")
       end
 
       it "allows for camel case prefixes" do
-        Helpers.underscore("EPub").should == "e_pub"
-        Helpers.underscore("EPub", :ignore_prefix => true).should == "epub"
+        expect(Helpers.underscore("EPub")).to eq("e_pub")
+        expect(Helpers.underscore("EPub", :ignore_prefix => true)).to eq("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", 
+        expect(Helpers.underscore("Mint::EPub", 
+                           :namespaces => true)).to eq("mint/e_pub")
+        expect(Helpers.underscore("Mint::EPub", 
+                           :namespaces => false)).to eq("e_pub")
+        expect(Helpers.underscore("Mint::EPub", 
                            :namespaces => true, 
-                           :ignore_prefix => true).should == "mint/epub"
+                           :ignore_prefix => true)).to eq("mint/epub")
       end
     end
     
     describe ".slugize" do
       it "downcases everything" do
-        Helpers.slugize("This could use FEWER CAPITALS").should ==
-          "this-could-use-fewer-capitals"
+        expect(Helpers.slugize("This could use FEWER CAPITALS")).to eq(
+          "this-could-use-fewer-capitals")
       end
 
       it "parses 'and'" do
-        Helpers.slugize("You & me").should == "you-and-me"
+        expect(Helpers.slugize("You & me")).to eq("you-and-me")
       end
 
       it "parses spaces" do
-        Helpers.slugize("You     and me").should == "you-and-me"
+        expect(Helpers.slugize("You     and me")).to eq("you-and-me")
       end
 
       it "removes non-word/non-digits" do
-        Helpers.slugize("You // and :: me").should == "you-and-me"
+        expect(Helpers.slugize("You // and :: me")).to eq("you-and-me")
       end
 
       it "condenses multiple hyphens" do
-        Helpers.slugize("You-----and me").should == "you-and-me"
+        expect(Helpers.slugize("You-----and me")).to eq("you-and-me")
       end
     end
 
     describe ".symbolize" do
       it "converts hyphens to underscores" do
-        Helpers.symbolize("you-and-me").should == :you_and_me
+        expect(Helpers.symbolize("you-and-me")).to eq(: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
+        expect(Helpers.pathize("filename.md")).to eq(
+          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
+        expect(Helpers.pathize(pathname)).to eq(pathname.expand_path)
       end
     end
 
@@ -78,7 +78,7 @@ module Mint
           key3: "value3"
         }
 
-        Helpers.symbolize_keys(flat_map).should == expected_map
+        expect(Helpers.symbolize_keys(flat_map)).to eq(expected_map)
       end
 
       it "recursively turns all string keys in a nested map into symbols" do
@@ -102,7 +102,7 @@ module Mint
           }
         }
 
-        Helpers.symbolize_keys(nested_map).should == expected_map
+        expect(Helpers.symbolize_keys(nested_map)).to eq(expected_map)
       end
 
       it "recursively downcases all keys if specified" do
@@ -126,22 +126,22 @@ module Mint
           }
         }
 
-        Helpers.symbolize_keys(capitalized_map, :downcase => true).should == expected_map
+        expect(Helpers.symbolize_keys(capitalized_map, :downcase => true)).to eq(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"
+        expect(Helpers.listify(["Alex", "Chris", "John"])).to eq(
+          "Alex, Chris & John")
       end
 
       it "joins a list of two with an ampersand" do
-        Helpers.listify(["Alex", "Chris"]).should == "Alex & Chris"
+        expect(Helpers.listify(["Alex", "Chris"])).to eq("Alex & Chris")
       end
 
       it "does not do anything to a list of one" do
-        Helpers.listify(["Alex"]).should == "Alex"
+        expect(Helpers.listify(["Alex"])).to eq("Alex")
       end
     end
 
@@ -169,18 +169,18 @@ module Mint
       end
 
       it "converts all nonstandard keys to standard ones" do
-        Helpers.standardize(@nonstandard, 
-                            :table => @table).should == @standard
+        expect(Helpers.standardize(@nonstandard, 
+                            :table => @table)).to eq(@standard)
       end
     end
 
     describe ".hashify" do
       it "zips two lists of the same size into a Hash" do
-        Helpers.hashify([:one, :two, :three], [1, 2, 3]).should == {
+        expect(Helpers.hashify([:one, :two, :three], [1, 2, 3])).to eq({
           one: 1,
           two: 2,
           three: 3
-        }
+        })
       end
     end
 
@@ -188,28 +188,28 @@ module Mint
       it "handles two files in the same directory" do
         path1 = "~/file1"
         path2 = "~/file2"
-        Helpers.normalize_path(path1, path2).should == 
-          Pathname.new("../file1")
+        expect(Helpers.normalize_path(path1, path2)).to eq(
+          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")
+        expect(Helpers.normalize_path(path1, path2)).to eq(
+          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")
+        expect(Helpers.normalize_path(path1, path2)).to eq(
+          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(".")
+        expect(Helpers.normalize_path(path1, path2)).to eq(Pathname.new("."))
       end
     end
 
@@ -222,7 +222,7 @@ module Mint
 
       it "combines specified data with data in YAML file and updates file" do
         Helpers.update_yaml! "example.yaml", "conflicting" => "baz"
-        YAML.load_file("example.yaml")["conflicting"].should == "baz"
+        expect(YAML.load_file("example.yaml")["conflicting"]).to eq("baz")
       end
     end
 
@@ -233,16 +233,16 @@ module Mint
       end
 
       it "creates a randomly named temp file" do
-        @path.should exist
+        expect(@path).to exist
       end
 
       it "creates a temp file with the correct name and extension" do
-        @path.basename.to_s.should =~ /content/
-        @path.extname.should == ".md"
+        expect(@path.basename.to_s).to match(/content/)
+        expect(@path.extname).to eq(".md")
       end
 
       it "fills the temp file with the specified content" do
-        @path.read.should =~ /This is just a test/
+        expect(@path.read).to match(/This is just a test/)
       end
     end
   end

data/spec/mint_spec.rb

@@ -3,21 +3,9 @@ require "spec_helper"
 describe Mint do
   subject { Mint }
 
-  its(:default_options) do
-    should == {
-      layout: "default",
-      style: "default",
-      destination: nil,
-      style_destination: nil
-    }
-  end
-
-  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__)
+  describe "::ROOT" do
+    it "contains the root of the Mint gem as a string" do
+      expect(Mint::ROOT).to eq(File.expand_path("../..", __FILE__))
     end
   end
 
@@ -26,19 +14,19 @@ describe Mint do
       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]
+    it "returns the paths corresponding to all scopes as an array" do
+      expect(Mint.path).to eq([Pathname.new(".mint"),
+                               Pathname.new("~/.config/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]
+      expect(Mint.path([:user])).to eq([Pathname.new("~/.config/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]
+      expect(Mint.path([:local, :user])).to eq([Pathname.new(".mint"),
+                                                Pathname.new("~/.config/mint").expand_path])
     end
   end
 
@@ -46,23 +34,28 @@ describe Mint do
   describe ".configuration" do
     let(:defaults) do
       {
-        layout: "default",
-        style: "default",
+        root: Dir.getwd,
         destination: nil,
-        style_destination: nil
+        style_mode: :inline,
+        style_destination: nil,
+        output_file: '#{basename}.#{new_extension}',
+        layout_or_style_or_template: [:template, 'default'],
+        scope: :local,
+        recursive: false,
+        verbose: false
       }
     end
 
-    context "when there is no defaults.yaml file on the Mint path" do
+    context "when there is no config.yaml file on the Mint path" do
       it "returns a default set of options" do
-        Mint.configuration.should == defaults 
+        expect(Mint.configuration).to eq(defaults)
       end
     end
 
-    context "when there is a defaults.yaml file on the Mint path" do
+    context "when there is a config.yaml file on the Mint path" do
       before do
         FileUtils.mkdir_p ".mint"
-        File.open(".mint/defaults.yaml", "w") do |file|
+        File.open(".mint/config.yaml", "w") do |file|
           file << "layout: zen"
         end
       end
@@ -72,57 +65,62 @@ describe Mint do
       end
 
       it "merges all specified options with precedence according to scope" do
-        Mint.configuration[:layout].should == "zen"
+        expect(Mint.configuration[:layout]).to eq("zen")
       end
 
       it "can filter by scope (but always includes defaults)" do
-        Mint.configuration(:scopes => [:user]).should == defaults
+        expect(Mint.configuration(scopes: [:user])).to eq(defaults)
       end
     end
   end
 
   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",
+      expect(Mint.configuration_with(local: true)).to eq({
+        root: Dir.getwd,
         destination: nil,
+        style_mode: :inline,
         style_destination: nil,
+        output_file: '#{basename}.#{new_extension}',
+        layout_or_style_or_template: [:template, 'default'],
+        scope: :local,
+        recursive: false,
+        verbose: false,
         local: true
-      }
+      })
     end
   end
 
   describe ".templates" do
-    it "returns all templates if no scopes are passed in" do
-      Mint.templates.should include(Mint.root + "/config/templates/default") 
+    it "returns local templates by default" do
+      # Note: Now defaults to local scope, will include global templates only if explicitly requested
+      expect(Mint.templates).to be_an(Array)
     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")
+    it "returns global templates when global scope is specified" do
+      expect(Mint.templates(:global)).to include(Mint::ROOT + "/config/templates/default")
     end
   end
 
   describe ".formats" do
     it "includes Markdown" do
-      Mint.formats.should include("md")
+      expect(Mint.formats).to include("md")
     end
 
     it "includes Haml" do
-      Mint.formats.should include("haml")
+      expect(Mint.formats).to include("haml")
     end
   end
 
   describe ".css_formats" do
     it "includes Sass" do
-      Mint.formats.should include("sass")
+      expect(Mint.css_formats).to include("sass")
     end
   end
 
   describe ".renderer" do
     it "creates a valid renderer" do
-      Mint.renderer(@content_file).should respond_to(:render)
+      expect(Mint.renderer(@content_file)).to respond_to(:render)
     end
   end
 
@@ -130,51 +128,69 @@ describe Mint 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
+        user: Pathname.new("~/.config/mint").expand_path,
+        global: Pathname.new(Mint::ROOT + "/config").expand_path
       }
 
       expectations.each do |scope, path|
-        Mint.path_for_scope(scope).should == path
+        expect(Mint.path_for_scope(scope)).to eq(path)
       end
     end
   end
 
+  # Refactored lookup methods for explicit parameter interface
   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"
+    it "returns template directory path by name" do
+      result = Mint.lookup_template("default")
+      expect(result.to_s).to include("templates/default")
+      expect(File.directory?(result)).to be true
     end
   end
 
-  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")
+  describe ".lookup_layout" do
+    it "returns layout file path by template name" do
+      result = Mint.lookup_layout("default")
+      expect(result).to include("templates/default")
+      expect(result).to end_with("layout.erb")
+    end
+  end
+
+  describe ".lookup_style" do
+    it "returns style file path by template name" do
+      result = Mint.lookup_style("default")
+      expect(result).to include("templates/default")
+      expect(result).to end_with("style.css")
     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}/config/templates/default.css"
+  describe ".find_template" do
+    it "finds the correct template file by name and type" do
+      layout_file = Mint.find_template("default", :layout)
+      style_file = Mint.find_template("default", :style)
+      
+      expect(layout_file).to include("templates/default")
+      expect(layout_file).to end_with("layout.erb")
+      expect(style_file).to include("templates/default")
+      expect(style_file).to end_with("style.css")
+    end
+
+    it "determines if a file is a template file" do
+      actual_template = Mint.lookup_layout("default")
+      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
+      expect(Mint.template?(actual_template)).to be_truthy
+      expect(Mint.template?(fake_template)).to be_falsy
+      expect(Mint.template?(obvious_nontemplate)).to be_falsy
     end
   end
 
   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"
+      expect(Mint.guess_name_from("content.md")).to eq("content.html")
+      expect(Mint.guess_name_from("content.textile")).to eq("content.html")
+      expect(Mint.guess_name_from("layout.haml")).to eq("layout.html")
+      expect(Mint.guess_name_from("dynamic.sass")).to eq("dynamic.css")
     end
   end
 
@@ -184,7 +200,11 @@ describe Mint do
       subject { document }
 
       its(:destination_file_path) { should_not exist }
-      its(:style_destination_file_path) { should_not exist }
+      it "style destination file should not exist initially" do
+        # Clean up any existing style file first
+        FileUtils.rm_f(document.style_destination_file_path) if document.style_destination_file_path && File.exist?(document.style_destination_file_path)
+        expect(document.style_destination_file_path).not_to exist
+      end
     end
 
     # These are copied from document_spec.rb. I eventually want to move
@@ -195,24 +215,28 @@ describe Mint do
       subject { document }
 
       its(:destination_file_path) { should exist }
-      its(:style_destination_file_path) { should exist }
+      
+      it "creates style file only for external style mode" do
+        if document.style_mode == :external
+          expect(document.style_destination_file_path).to exist
+        else
+          expect(document.style_destination_file_path).not_to exist
+        end
+      end
     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" 
+    it "returns template directory for given name and scope" do
+      expect(Mint.template_path("pro", :local)).to eq(Pathname.new(".mint/templates/pro"))
     end
 
-    it "allows an extension to be specified" do
-      Mint.template_path("pro", :layout, :ext => "erb").should == 
-        ".mint/templates/pro/layout.erb" 
+    it "works with user scope" do
+      expect(Mint.template_path("pro", :user)).to eq(Pathname.new("~/.config/mint/templates/pro").expand_path)
     end
 
-    it "allows a scope to be specified" do
-      Mint.template_path("pro", :layout, :scope => :user).should == 
-        File.expand_path("~/.mint/templates/pro/layout.haml")
+    it "works with global scope" do
+      expect(Mint.template_path("pro", :global)).to eq(Pathname.new("#{Mint::ROOT}/config/templates/pro"))
     end
   end
 end