RubyGems - mint - Versions diffs - 0.7.4 → 0.8.0 - Mend

mint 0.7.4 → 0.8.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 (71) hide show

checksums.yaml +7 -0
data/Gemfile +23 -14
data/LICENSE +22 -0
data/README.md +82 -56
data/bin/mint +47 -10
data/bin/mint-epub +1 -4
data/config/templates/base/style.css +187 -0
data/config/templates/default/css/style.css +126 -79
data/config/templates/default/layout.erb +10 -0
data/config/templates/default/style.css +237 -0
data/config/templates/garden/layout.erb +38 -0
data/config/templates/garden/style.css +303 -0
data/config/templates/newspaper/layout.erb +16 -0
data/config/templates/nord/layout.erb +11 -0
data/config/templates/nord/style.css +339 -0
data/config/templates/nord-dark/layout.erb +11 -0
data/config/templates/nord-dark/style.css +339 -0
data/config/templates/protocol/layout.erb +9 -0
data/config/templates/protocol/style.css +25 -0
data/config/templates/zen/layout.erb +11 -0
data/config/templates/zen/style.css +114 -0
data/lib/mint/command_line.rb +253 -111
data/lib/mint/css.rb +11 -4
data/lib/mint/css_template.rb +37 -0
data/lib/mint/document.rb +185 -43
data/lib/mint/helpers.rb +50 -10
data/lib/mint/layout.rb +2 -3
data/lib/mint/markdown_template.rb +47 -0
data/lib/mint/mint.rb +181 -114
data/lib/mint/plugin.rb +3 -3
data/lib/mint/plugins/epub.rb +1 -2
data/lib/mint/resource.rb +19 -9
data/lib/mint/style.rb +10 -14
data/lib/mint/version.rb +1 -1
data/lib/mint.rb +1 -0
data/man/mint.1 +135 -0
data/spec/cli/README.md +99 -0
data/spec/cli/argument_parsing_spec.rb +207 -0
data/spec/cli/bin_integration_spec.rb +348 -0
data/spec/cli/configuration_management_spec.rb +363 -0
data/spec/cli/full_workflow_integration_spec.rb +527 -0
data/spec/cli/publish_workflow_spec.rb +368 -0
data/spec/cli/template_management_spec.rb +300 -0
data/spec/css_spec.rb +1 -1
data/spec/document_spec.rb +102 -69
data/spec/helpers_spec.rb +42 -42
data/spec/mint_spec.rb +104 -80
data/spec/plugin_spec.rb +86 -88
data/spec/run_cli_tests.rb +95 -0
data/spec/spec_helper.rb +8 -1
data/spec/style_spec.rb +18 -16
data/spec/support/cli_helpers.rb +169 -0
data/spec/support/fixtures/content-2.md +16 -0
data/spec/support/matchers.rb +1 -1
metadata +116 -223
data/config/syntax.yaml +0 -71
data/config/templates/base/style.sass +0 -144
data/config/templates/default/layout.haml +0 -8
data/config/templates/default/style.sass +0 -36
data/config/templates/protocol/layout.haml +0 -7
data/config/templates/protocol/style.sass +0 -20
data/config/templates/zen/css/style.css +0 -145
data/config/templates/zen/layout.haml +0 -7
data/config/templates/zen/style.sass +0 -24
data/features/config.feature +0 -21
data/features/plugins/epub.feature +0 -23
data/features/publish.feature +0 -73
data/features/support/env.rb +0 -15
data/features/templates.feature +0 -79
data/spec/command_line_spec.rb +0 -87
data/spec/plugins/epub_spec.rb +0 -242

data/spec/document_spec.rb CHANGED Viewed

@@ -14,20 +14,27 @@ 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(:content) { is_expected.to match(/<p>This is just a test.<\/p>/) }
+      its(:metadata) { is_expected.to eq({ "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
+        expect(document.render).to include(document.content)
+        expect(document.render).to include("<html")
+        expect(document.render).to include("</html>")
       end
-      it "links to its stylesheet" do
-        document.render.should =~ /#{document.stylesheet}/
+      it "includes its stylesheet appropriately based on style mode" do
+        if document.style_mode == :external
+          expect(document.render).to include('<link rel="stylesheet"')
+          expect(document.render).not_to include("<style>")
+        else
+          expect(document.render).to include("<style>")
+          expect(document.render).to include("</style>")
+        end
       end
       # Mint output
@@ -36,14 +43,19 @@ module Mint
       # 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
+        if document.style_mode == :external
+          expect(document.style_destination_file_path).to exist
+        else
+          # For inline styles, no external file should be created
+          expect(document.style_destination_file_path).not_to exist
+        end
       end
       it "writes its rendered layout and content to #destination_file" do
         document.publish!
-        document.destination_file_path.should exist
+        expect(document.destination_file_path).to exist
         content = File.read document.destination_file
-        content.should == document.render
+        expect(content).to eq(document.render)
       end
     end
@@ -51,100 +63,119 @@ module Mint
       let(:document) { Document.new @content_file }
       subject { document }
-      its(:root) { should == @tmp_dir }
-      its(:destination) { should be_nil }
-      its(:source) { should == "content.md" }
-      its(:style_destination) { should be_nil }
+      its(:root) { is_expected.to eq(@tmp_dir) }
+      its(:destination) { is_expected.to be_nil }
+      its(:source) { is_expected.to eq("content.md") }
+      its(:style_destination) { is_expected.to be_nil }
-      its(:style_destination_file) do
-        should == Mint.root + "/config/templates/default/css/style.css"
+      it "has a style destination file in user tmp directory" do
+        expect(document.style_destination_file).to match(/\.config\/mint\/tmp\/style\.css$/)
       end
-      its(:style_destination_directory) do
-        should == Mint.root + "/config/templates/default/css"
+      it "has a style destination directory in user tmp directory" do
+        expect(document.style_destination_directory).to match(/\.config\/mint\/tmp$/)
       end
       its(:style_destination_file_path) do
-        should == Pathname.new(document.style_destination_file)
+        is_expected.to eq(Pathname.new(document.style_destination_file))
       end
       its(:style_destination_directory_path) do
-        should == Pathname.new(document.style_destination_directory)
+        is_expected.to eq(Pathname.new(document.style_destination_directory))
       end
-      its(:layout) { should be_in_directory("default") }
-      its(:style) { should be_in_directory("default") }
+      its(:layout) { is_expected.to be_in_directory("default") }
+      its(:style) { is_expected.to be_in_directory("default") }
-      its(:stylesheet) { should == Mint.root + "/config/templates/default/css/style.css" }
+      it "has a stylesheet path relative to user tmp directory" do
+        expect(document.stylesheet).to match(/\.config\/mint\/tmp\/style\.css$/)
+      end
       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(:root) { is_expected.to eq(@tmp_dir) }
+      its(:destination) { is_expected.to eq("destination") }
+      its(:source) { is_expected.to eq("content.md") }
+      its(:style_destination) { is_expected.to eq("styles") }
       its(:style_destination_file) do
-        should == "#{@tmp_dir}/destination/styles/style.css"
+        is_expected.to eq("#{@tmp_dir}/destination/styles/style.css")
       end
       its(:style_destination_directory) do
-        should == "#{@tmp_dir}/destination/styles"
+        is_expected.to eq("#{@tmp_dir}/destination/styles")
       end
       its(:style_destination_file_path) do
-        should == Pathname.new(document.style_destination_file)
+        is_expected.to eq(Pathname.new(document.style_destination_file))
       end
       its(:style_destination_directory_path) do
-        should == Pathname.new(document.style_destination_directory)
+        is_expected.to eq(Pathname.new(document.style_destination_directory))
       end
-      its(:layout) { should be_in_directory("default") }
-      its(:style) { should be_in_directory("default") }
+      its(:layout) { is_expected.to be_in_directory("default") }
+      its(:style) { is_expected.to be_in_directory("default") }
-      its(:stylesheet) { should == "styles/style.css" }
+      it "has a stylesheet path relative to user tmp directory" do
+        expect(document.stylesheet).to match(/\.config\/mint\/tmp\/style\.css$/)
+      end
       it_should_behave_like "all documents"
     end
     context "when it's created with an explicit root" do
       let(:document) { Document.new @content_file,
-                       :root => "#{@tmp_dir}/alternative-root" }
+                       root: "#{@tmp_dir}/alternative-root" }
       subject { document }
-      its(:root) { should == "#{@tmp_dir}/alternative-root" }
-      its(:destination) { should be_nil }
-      its(:source) { should == "content.md" }
-      its(:style_destination) { should be_nil }
-      its(:style_destination_file) do
-        should == Mint.root + "/config/templates/default/css/style.css"
+      its(:root) { is_expected.to eq("#{@tmp_dir}/alternative-root") }
+      it "preserves folder structure" do
+        expect(document.destination).to be_present
+      end
+      its(:source) { is_expected.to eq("content.md") }
+      its(:style_destination) { is_expected.to be_nil }
+      it "has appropriate style behavior based on style mode" do
+        if document.style_mode == :external
+          expect(document.style_destination_file).to match(/\.config\/mint\/tmp\/style\.css$/)
+        else
+          # For inline styles, the style_destination_file should still exist as a path
+          # but no actual file should be created during publish
+          expect(document.style_destination_file).to be_present
+        end
       end
-      its(:style_destination_directory) do
-        should == Mint.root + "/config/templates/default/css"
+      it "has appropriate style destination directory based on style mode" do
+        if document.style_mode == :external
+          expect(document.style_destination_directory).to match(/\.config\/mint\/tmp$/)
+        else
+          # For inline styles, still has a directory path but it's not used for external files
+          expect(document.style_destination_directory).to be_present
+        end
       end
       its(:style_destination_file_path) do
-        should == Pathname.new(document.style_destination_file)
+        is_expected.to eq(Pathname.new(document.style_destination_file))
       end
       its(:style_destination_directory_path) do
-        should == Pathname.new(document.style_destination_directory)
+        is_expected.to eq(Pathname.new(document.style_destination_directory))
       end
-      its(:layout) { should be_in_directory("default") }
-      its(:style) { should be_in_directory("default") }
+      its(:layout) { is_expected.to be_in_directory("default") }
+      its(:style) { is_expected.to be_in_directory("default") }
-      its(:stylesheet) { should == Mint.root + "/config/templates/default/css/style.css" }
+      it "has a stylesheet path relative to user tmp directory" do
+        expect(document.stylesheet).to match(/\.config\/mint\/tmp\/style\.css$/)
+      end
       it_should_behave_like "all documents"
     end
@@ -161,31 +192,33 @@ module Mint
       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(:root) { is_expected.to eq("#{@tmp_dir}/alternative-root") }
+      its(:destination) { is_expected.to eq("destination") }
+      its(:source) { is_expected.to eq("content.md") }
+      its(:style_destination) { is_expected.to eq("styles") }
       its(:style_destination_file) do
-        should == "#{@tmp_dir}/alternative-root/destination/styles/style.css"
+        is_expected.to eq("#{@tmp_dir}/alternative-root/destination/styles/style.css")
       end
       its(:style_destination_directory) do
-        should == "#{@tmp_dir}/alternative-root/destination/styles"
+        is_expected.to eq("#{@tmp_dir}/alternative-root/destination/styles")
       end
       its(:style_destination_file_path) do
-        should == Pathname.new(document.style_destination_file)
+        is_expected.to eq(Pathname.new(document.style_destination_file))
       end
       its(:style_destination_directory_path) do
-        should == Pathname.new(document.style_destination_directory)
+        is_expected.to eq(Pathname.new(document.style_destination_directory))
       end
-      its(:layout) { should be_in_directory("zen") }
-      its(:style) { should be_in_directory("zen") }
+      its(:layout) { is_expected.to be_in_directory("zen") }
+      its(:style) { is_expected.to be_in_directory("zen") }
-      its(:stylesheet) { should == "styles/style.css" }
+      it "has a stylesheet path relative to user tmp directory" do
+        expect(document.stylesheet).to match(/\.config\/mint\/tmp\/style\.css$/)
+      end
       it_should_behave_like "all documents"
     end
@@ -194,33 +227,33 @@ 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"
+          expect(Document.metadata_chunk(text)).to eq("metadata: true")
         end
       end
       describe ".metadata_from" do
         it "parses a documents metadata if present" do
-          Document.metadata_from(text).should == { "metadata" => true }
+          expect(Document.metadata_from(text)).to eq({ "metadata" => true })
         end
         it "returns the empty string if a document has bad/no metadata" do
-          Document.metadata_from("No metadata here").should == {}
+          expect(Document.metadata_from("No metadata here")).to eq({})
         end
         it "handles a non-simple string that is also not YAML" do
-          Document.metadata_from("# Non-simple string").should == {}
+          expect(Document.metadata_from("# Non-simple string")).to eq({})
         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"]
+          expect(Document.parse_metadata_from(text)).to eq(
+            [{ "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"]
+          expect(Document.parse_metadata_from("No metadata here")).to eq(
+            [{}, "No metadata here"])
         end
       end
     end

data/spec/helpers_spec.rb CHANGED Viewed

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