mint 0.5.1 → 0.7.1

data/lib/mint/resource.rb

@@ -1,4 +1,4 @@
-require 'mint/mint'
+require "mint/mint"
 
 module Mint
   class Resource
@@ -45,7 +45,7 @@ module Mint
     attr_accessor :destination
 
     def destination_file_path
-      root_directory_path + (destination || '') + name
+      root_directory_path + (destination || "") + name
     end
 
     def destination_file

data/lib/mint/style.rb

@@ -1,4 +1,4 @@
-require 'mint/resource'
+require "mint/resource"
 
 module Mint
   class Style < Resource
@@ -19,7 +19,7 @@ module Mint
       # However, if a destination directory is already specified, we
       # leave it alone.
       if Mint.template?(self.source_directory) and rendered?
-        self.destination ||= 'css' 
+        self.destination ||= "css" 
       end
     end
 

data/lib/mint/version.rb

@@ -1,3 +1,3 @@
 module Mint
-  VERSION = '0.5.1'
+  VERSION = "0.7.1"
 end

data/spec/command_line_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+
+module Mint
+  describe CommandLine do
+    describe ".options" do
+      it "provides default options" do
+        CommandLine.options["template"]["long"].should == "template"
+        CommandLine.options["layout"]["long"].should == "layout"
+        CommandLine.options["style"]["long"].should == "style"
+      end
+    end
+
+    describe ".parse" do
+      it "does not mutate passed in ARGV" do
+        argv = ["--layout", "zen"]
+        lambda { CommandLine.parse(argv) }.should_not change { argv }
+      end
+
+      it "returns a hash of commandline options, unconsumed options, and the help message" do
+        OptionParser.any_instance.stub(:help => "Help message")
+        CommandLine.parse(["command", "--layout", "zen"]).should == {
+          help: "Help message",
+          argv: ["command"],
+          options: {
+            layout: "zen" 
+          }
+        }
+      end
+    end
+
+    describe ".help" do
+      it "prints a help message" do
+        STDOUT.should_receive(:puts).with("message")
+        CommandLine.help("message")
+      end
+    end
+
+    describe ".install" do
+      describe "when there is no template by the specified name" do
+        it "installs the specified file as a new template" do
+          CommandLine.install("dynamic.sass", :template => "pro")
+          Mint.find_template("pro", :style).should == Mint.template_path("pro", :style, :scope => :local, :ext => "sass")
+        end
+      end
+    end
+
+    describe ".uninstall" do
+      it "uninstalls the specified template" do
+        CommandLine.install("dynamic.sass", :template => "pro")
+        CommandLine.uninstall("pro")
+        lambda do
+          Mint.find_template("pro", :style)
+        end.should raise_error
+      end
+    end
+
+    describe ".edit" do
+      it "pulls up a named template file in the user's editor" do
+        ENV["EDITOR"] = "vim"
+        CommandLine.should_receive(:system).with("vim #{@dynamic_style_file}")
+        CommandLine.edit(@dynamic_style_file)
+      end
+    end
+
+    describe ".configure" do
+      it "writes options to the correct file for the scope specified" do
+        Mint.configuration[:layout].should == "default"
+        CommandLine.configure({ layout: "pro" }, :local)
+        Mint.configuration[:layout].should == "pro"
+      end
+    end
+
+    describe ".set" do
+      it "sets and stores a scoped configuration variable" do
+        CommandLine.should_receive(:configure).with({ layout: "pro" }, :local)
+        CommandLine.set(:layout, "pro", :scope => :local)
+      end
+    end
+
+    describe ".publish!" do
+      it "publishes a set of files" do
+        CommandLine.publish!([@content_file])
+        File.exist?("content.html").should be_true
+      end
+    end
+  end
+end

data/spec/css_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+module Mint
+  describe CSS do
+    describe ".stylify" do
+      it "translates from human-readable configuration to CSS" do
+        table = {
+          "Font: Helvetica"         => "font-family: Helvetica",
+          'Font: "Lucida Grande"'   => 'font-family: "Lucida Grande"',
+          "Font Size: 12pt"         => "font-size: 12pt",
+          "Font Color: gray"        => "color: gray",
+          "Color: gray"             => "color: gray",
+          "Top Margin: 1in"         => "padding-top: 1in",
+          "Top: 1in"                => "padding-top: 1in",
+          "Bottom: 1in"             => "padding-bottom: 1in",
+          "Left: 1in"               => "padding-left: 1in",
+          "Right: 1in"              => "padding-right: 1in",
+          "Height: 11in"            => "height: 11in",
+          "Width: 8in"              => "width: 8in",
+          "Columns: 2"              => "column-count: 2",
+          "Column Gap: 1in"         => "column-gap: 1in",
+          "Orientation: landscape"  => "@page { size: landscape }",
+          "Indentation: 0.5in"      => "p+p { text-indent: 0.5in }",
+          "Indent: 0.5in"           => "p+p { text-indent: 0.5in }",
+          "Bullet: square"          => "li { list-style-type: square }",
+          "Bullet Image: img.png"   => "li { list-style-image: url(img.png) }",
+          "Before Paragraph: 0.5in" => "p { margin-top: 0.5in }",
+          "After Paragraph: 0.5in"  => "p { margin-bottom: 0.5in }"
+          # "Smart Typography: On"    => "text-rendering: optimizeLegibility",
+          # "Spacing: double"         => "line-height: 2 * ?",
+          # "Bullet: checkbox.png"    => "li { list-style-image: url(checkbox.png) }",
+        }
+
+        table.each do |human, machine|
+          CSS.stylify(*human.split(":").map(&:strip))
+        end
+      end
+    end
+
+    describe ".parse" do
+      it "transforms a map of human-readable styles into a CSS string" do
+        CSS.parse({ "Font" => "Helvetica" }).should == "#container {\n  font-family: Helvetica; }\n" 
+      end
+    end
+  end
+end

data/spec/document_spec.rb

@@ -1,9 +1,7 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Mint
   describe Document do
-    before { @tmp_dir = Dir.getwd }
-
     # We're not going to re-test derivative methods like source_file_path
     # or root_directory. resource_spec.rb tells us that if the master
     # values hold true, then their derivatives will be what we expect, as well.
@@ -17,7 +15,7 @@ module Mint
       # 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 } }
+      its(:metadata) { should == { "metadata" =>  true } }
 
       # Render output
 
@@ -55,15 +53,15 @@ module Mint
       subject { document }
       its(:root) { should == @tmp_dir }
       its(:destination) { should be_nil }
-      its(:source) { should == 'content.md' }
+      its(:source) { should == "content.md" }
       its(:style_destination) { should be_nil }
 
       its(:style_destination_file) do
-        should == Mint.root + '/templates/default/css/style.css'
+        should == Mint.root + "/config/templates/default/css/style.css"
       end
 
       its(:style_destination_directory) do 
-        should == Mint.root + '/templates/default/css'
+        should == Mint.root + "/config/templates/default/css"
       end
 
       its(:style_destination_file_path) do
@@ -74,24 +72,24 @@ module Mint
         should == Pathname.new(document.style_destination_directory)
       end
 
-      its(:layout) { should be_in_directory('default') }
-      its(:style) { should be_in_directory('default') }
+      its(:layout) { should be_in_directory("default") }
+      its(:style) { should be_in_directory("default") }
 
-      its(:stylesheet) { should == Mint.root + '/templates/default/css/style.css' }
+      its(:stylesheet) { should == Mint.root + "/config/templates/default/css/style.css" }
 
       it_should_behave_like "all documents"
     end
 
     context "when it's created with explicit destination directories" do
       let(:document) { Document.new @content_file,
-                       :destination => 'destination',
-                       :style_destination => 'styles' }
+                       :destination => "destination",
+                       :style_destination => "styles" }
 
       subject { document }
       its(:root) { should == @tmp_dir }
-      its(:destination) { should == 'destination' }
-      its(:source) { should == 'content.md' }
-      its(:style_destination) { should == 'styles' }
+      its(:destination) { should == "destination" }
+      its(:source) { should == "content.md" }
+      its(:style_destination) { should == "styles" }
 
       its(:style_destination_file) do
         should == "#{@tmp_dir}/destination/styles/style.css"
@@ -109,10 +107,10 @@ module Mint
         should == Pathname.new(document.style_destination_directory)
       end
 
-      its(:layout) { should be_in_directory('default') }
-      its(:style) { should be_in_directory('default') }
+      its(:layout) { should be_in_directory("default") }
+      its(:style) { should be_in_directory("default") }
 
-      its(:stylesheet) { should == 'styles/style.css' }
+      its(:stylesheet) { should == "styles/style.css" }
 
       it_should_behave_like "all documents"
     end
@@ -124,15 +122,15 @@ module Mint
       subject { document }
       its(:root) { should == "#{@tmp_dir}/alternative-root" }
       its(:destination) { should be_nil }
-      its(:source) { should == 'content.md' }
+      its(:source) { should == "content.md" }
       its(:style_destination) { should be_nil }
 
       its(:style_destination_file) do
-        should == Mint.root + '/templates/default/css/style.css'
+        should == Mint.root + "/config/templates/default/css/style.css"
       end
 
       its(:style_destination_directory) do
-        should == Mint.root + '/templates/default/css'
+        should == Mint.root + "/config/templates/default/css"
       end
 
       its(:style_destination_file_path) do
@@ -143,10 +141,10 @@ module Mint
         should == Pathname.new(document.style_destination_directory)
       end
 
-      its(:layout) { should be_in_directory('default') }
-      its(:style) { should be_in_directory('default') }
+      its(:layout) { should be_in_directory("default") }
+      its(:style) { should be_in_directory("default") }
 
-      its(:stylesheet) { should == Mint.root + '/templates/default/css/style.css' }
+      its(:stylesheet) { should == Mint.root + "/config/templates/default/css/style.css" }
 
       it_should_behave_like "all documents"
     end
@@ -155,18 +153,18 @@ module Mint
       let(:document) do
         Document.new @content_file do |doc|
           doc.root              = "#{@tmp_dir}/alternative-root"
-          doc.destination       = 'destination'
-          doc.style_destination = 'styles'
-          doc.layout            = 'pro'
-          doc.style             = 'pro'
+          doc.destination       = "destination"
+          doc.style_destination = "styles"
+          doc.layout            = "zen"
+          doc.style             = "zen"
         end
       end
 
       subject { document }
       its(:root) { should == "#{@tmp_dir}/alternative-root" }
-      its(:destination) { should == 'destination' }
-      its(:source) { should == 'content.md' }
-      its(:style_destination) { should == 'styles' }
+      its(:destination) { should == "destination" }
+      its(:source) { should == "content.md" }
+      its(:style_destination) { should == "styles" }
 
       its(:style_destination_file) do
         should == "#{@tmp_dir}/alternative-root/destination/styles/style.css"
@@ -184,10 +182,10 @@ module Mint
         should == Pathname.new(document.style_destination_directory)
       end
 
-      its(:layout) { should be_in_directory('pro') }
-      its(:style) { should be_in_directory('pro') }
+      its(:layout) { should be_in_directory("zen") }
+      its(:style) { should be_in_directory("zen") }
 
-      its(:stylesheet) { should == 'styles/style.css' }
+      its(:stylesheet) { should == "styles/style.css" }
 
       it_should_behave_like "all documents"
     end
@@ -196,29 +194,29 @@ module Mint
       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'
+          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 }
+          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 == {}
+          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']
+            [{ "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']
+          Document.parse_metadata_from("No metadata here").should ==
+            [{}, "No metadata here"]
         end
       end
     end

data/spec/helpers_spec.rb

@@ -1,58 +1,58 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Mint
   describe Helpers do
-    describe "#underscore" do
+    describe ".underscore" do
       it "underscores class names per ActiveSupport conventions" do
-        Helpers.underscore('ClassName').should == 'class_name'
+        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'
+        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', 
+        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'
+                           :ignore_prefix => true).should == "mint/epub"
       end
     end
     
-    describe "#slugize" do
+    describe ".slugize" do
       it "downcases everything" do
-        Helpers.slugize('This could use FEWER CAPITALS').should ==
-          'this-could-use-fewer-capitals'
+        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'
+        Helpers.slugize("You & me").should == "you-and-me"
       end
 
       it "parses spaces" do
-        Helpers.slugize('You     and me').should == 'you-and-me'
+        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'
+        Helpers.slugize("You // and :: me").should == "you-and-me"
       end
 
       it "condenses multiple hyphens" do
-        Helpers.slugize('You-----and me').should == 'you-and-me'
+        Helpers.slugize("You-----and me").should == "you-and-me"
       end
     end
 
-    describe "#symbolize" do
+    describe ".symbolize" do
       it "converts hyphens to underscores" do
-        Helpers.symbolize('you-and-me').should == :you_and_me
+        Helpers.symbolize("you-and-me").should == :you_and_me
       end
     end
 
-    describe "#pathize" do
+    describe ".pathize" do
       it "converts a String to a Pathname" do
         Helpers.pathize("filename.md").should == 
           Pathname.new("filename.md").expand_path
@@ -64,18 +64,18 @@ module Mint
       end
     end
 
-    describe "#symbolize_keys" do
+    describe ".symbolize_keys" do
       it "turns all string keys in a flat map into symbols" do
         flat_map = {
-          'key1' => 'value1',
-          'key2' => 'value2',
-          'key3' => 'value3'
+          "key1" => "value1",
+          "key2" => "value2",
+          "key3" => "value3"
         }
 
         expected_map = {
-          key1: 'value1',
-          key2: 'value2',
-          key3: 'value3'
+          key1: "value1",
+          key2: "value2",
+          key3: "value3"
         }
 
         Helpers.symbolize_keys(flat_map).should == expected_map
@@ -83,22 +83,22 @@ module Mint
 
       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'
+          "key1" => "value1",
+          "key2" => "value2",
+          "key3" => "value3",
+          "key4" => {
+            "nested_key1" => "nested_value1",
+            "nested_key2" => "nested_value2"
           }
         }
 
         expected_map = {
-          key1: 'value1',
-          key2: 'value2',
-          key3: 'value3',
+          key1: "value1",
+          key2: "value2",
+          key3: "value3",
           key4: {
-            nested_key1: 'nested_value1',
-            nested_key2: 'nested_value2'
+            nested_key1: "nested_value1",
+            nested_key2: "nested_value2"
           }
         }
 
@@ -107,22 +107,22 @@ module Mint
 
       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'
+          "Key1" => "value1",
+          "Key2" => "value2",
+          "Key3" => "value3",
+          "Key4" => {
+            "Nested_key1" => "nested_value1",
+            "Nested_key2" => "nested_value2"
           }
         }
 
         expected_map = {
-          key1: 'value1',
-          key2: 'value2',
-          key3: 'value3',
+          key1: "value1",
+          key2: "value2",
+          key3: "value3",
           key4: {
-            nested_key1: 'nested_value1',
-            nested_key2: 'nested_value2'
+            nested_key1: "nested_value1",
+            nested_key2: "nested_value2"
           }
         }
 
@@ -130,28 +130,28 @@ module Mint
       end
     end
 
-    describe "#listify" do
+    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'
+        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'
+        Helpers.listify(["Alex", "Chris"]).should == "Alex & Chris"
       end
 
       it "does not do anything to a list of one" do
-        Helpers.listify(['Alex']).should == 'Alex'
+        Helpers.listify(["Alex"]).should == "Alex"
       end
     end
 
-    describe "#standardize" do
+    describe ".standardize" do
       before do
         @nonstandard = {
-          title: 'Title',
-          author: 'David',
-          editors: ['David', 'Jake'],
-          barcode: 'Unique ID'
+          title: "Title",
+          author: "David",
+          editors: ["David", "Jake"],
+          barcode: "Unique ID"
         }
 
         @table = {
@@ -161,10 +161,10 @@ module Mint
         }
 
         @standard = {
-          title: 'Title',
-          creators: ['David'],
-          collaborators: ['David', 'Jake'],
-          uuid: 'Unique ID'
+          title: "Title",
+          creators: ["David"],
+          collaborators: ["David", "Jake"],
+          uuid: "Unique ID"
         }
       end
 
@@ -174,43 +174,61 @@ module Mint
       end
     end
 
-    describe "#normalize_path" do
+    describe ".hashify" do
+      it "zips two lists of the same size into a Hash" do
+        Helpers.hashify([:one, :two, :three], [1, 2, 3]).should == {
+          one: 1,
+          two: 2,
+          three: 3
+        }
+      end
+    end
+
+    describe ".normalize_path" do
       it "handles two files in the same directory" do
-        path1 = '~/file1'
-        path2 = '~/file2'
+        path1 = "~/file1"
+        path2 = "~/file2"
         Helpers.normalize_path(path1, path2).should == 
-          Pathname.new('../file1')
+          Pathname.new("../file1")
       end
       
       it "handles two files one directory apart" do
-        path1 = '~/file1'
-        path2 = '~/subdir/file2'
+        path1 = "~/file1"
+        path2 = "~/subdir/file2"
         Helpers.normalize_path(path1, path2).should == 
-          Pathname.new('../../file1')
+          Pathname.new("../../file1")
       end
 
       it "handles two files linked only at the directory root" do
-        path1 = '/home/david/file1'
-        path2 = '/usr/local/src/file2'
+        path1 = "/home/david/file1"
+        path2 = "/usr/local/src/file2"
         Helpers.normalize_path(path1, path2).should == 
-          Pathname.new('/home/david/file1')
+          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('.')
+        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"
+    describe ".update_yaml!" do
+      before do
+        File.open "example.yaml", "w" do |file|
+          file << "conflicting: foo\nnon-conflicting: bar"
+        end
+      end
+
+      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"
+      end
     end
 
-    describe "#generate_temp_file!" do
+    describe ".generate_temp_file!" do
       before do
-        @file = Helpers.generate_temp_file! 'content.md'
+        @file = Helpers.generate_temp_file! "content.md"
         @path = Pathname.new @file
       end
 
@@ -220,7 +238,7 @@ module Mint
 
       it "creates a temp file with the correct name and extension" do
         @path.basename.to_s.should =~ /content/
-        @path.extname.should == '.md'
+        @path.extname.should == ".md"
       end
 
       it "fills the temp file with the specified content" do