mint 0.8.1 → 0.10.0

data/spec/helpers_spec.rb

@@ -1,249 +0,0 @@
-require "spec_helper"
-
-module Mint
-  describe Helpers do
-    describe ".underscore" do
-      it "underscores class names per ActiveSupport conventions" do
-        expect(Helpers.underscore("ClassName")).to eq("class_name")
-      end
-
-      it "allows for camel case prefixes" do
-        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
-        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)).to eq("mint/epub")
-      end
-    end
-    
-    describe ".slugize" do
-      it "downcases everything" do
-        expect(Helpers.slugize("This could use FEWER CAPITALS")).to eq(
-          "this-could-use-fewer-capitals")
-      end
-
-      it "parses 'and'" do
-        expect(Helpers.slugize("You & me")).to eq("you-and-me")
-      end
-
-      it "parses spaces" do
-        expect(Helpers.slugize("You     and me")).to eq("you-and-me")
-      end
-
-      it "removes non-word/non-digits" do
-        expect(Helpers.slugize("You // and :: me")).to eq("you-and-me")
-      end
-
-      it "condenses multiple hyphens" do
-        expect(Helpers.slugize("You-----and me")).to eq("you-and-me")
-      end
-    end
-
-    describe ".symbolize" do
-      it "converts hyphens to underscores" do
-        expect(Helpers.symbolize("you-and-me")).to eq(:you_and_me)
-      end
-    end
-
-    describe ".pathize" do
-      it "converts a String to a Pathname" do
-        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")
-        expect(Helpers.pathize(pathname)).to eq(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"
-        }
-
-        expect(Helpers.symbolize_keys(flat_map)).to eq(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"
-          }
-        }
-
-        expect(Helpers.symbolize_keys(nested_map)).to eq(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"
-          }
-        }
-
-        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
-        expect(Helpers.listify(["Alex", "Chris", "John"])).to eq(
-          "Alex, Chris & John")
-      end
-
-      it "joins a list of two with an ampersand" do
-        expect(Helpers.listify(["Alex", "Chris"])).to eq("Alex & Chris")
-      end
-
-      it "does not do anything to a list of one" do
-        expect(Helpers.listify(["Alex"])).to eq("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
-        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
-        expect(Helpers.hashify([:one, :two, :three], [1, 2, 3])).to eq({
-          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"
-        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"
-        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"
-        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"
-        expect(Helpers.normalize_path(path1, path2)).to eq(Pathname.new("."))
-      end
-    end
-
-    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"
-        expect(YAML.load_file("example.yaml")["conflicting"]).to eq("baz")
-      end
-    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
-        expect(@path).to exist
-      end
-
-      it "creates a temp file with the correct name and extension" do
-        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
-        expect(@path.read).to match(/This is just a test/)
-      end
-    end
-  end
-end

data/spec/plugin_spec.rb

@@ -1,449 +0,0 @@
-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)
-      expect(Mint.plugins).to eq([plugin])
-    end
-
-    it "returns an empty array if there are no registered plugins" do
-      expect(Mint.plugins).to eq([])
-    end
-  end
-
-  describe ".register_plugin!" do
-    let(:plugin) { Class.new }
-
-    it "registers a plugin once" do
-      Mint.register_plugin! plugin
-      expect(Mint.plugins).to eq([plugin])
-    end
-
-    it "does not register a plugin more than once" do
-      Mint.register_plugin! plugin
-      expect { Mint.register_plugin! plugin }.not_to change { Mint.plugins }
-      expect(Mint.plugins).to eq([plugin])
-    end
-  end
-
-  describe ".activate_plugin!" do
-    let(:plugin) { Class.new }
-
-    it "activates a plugin once" do
-      Mint.activate_plugin! plugin
-      expect(Mint.activated_plugins).to eq [plugin]
-    end
-
-    it "does not register a plugin more than once" do
-      Mint.activate_plugin! plugin
-      expect { Mint.activate_plugin! plugin }.not_to change { Mint.activated_plugins }
-      expect(Mint.activated_plugins).to eq [plugin]
-    end
-  end
-
-  describe ".clear_plugins!" do
-    let(:plugin) { Class.new }
-
-    it "does nothing if no plugins are registered" do
-      expect { Mint.clear_plugins! }.not_to raise_error
-    end
-
-    it "removes all registered plugins" do
-      Mint.register_plugin! plugin
-      expect { Mint.clear_plugins! }.to change { Mint.plugins.length }.by(-1)
-    end
-
-    it "removes all activated plugins" do
-      Mint.activate_plugin! plugin
-      expect { Mint.clear_plugins! }.to 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
-      expect(plugin).to receive(:name).and_return("DocBook")
-      expect(Mint.template_directory(plugin)).to eq(
-        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
-      expect(plugin).to receive(:name).and_return("DocBook")
-      expect(Mint.config_directory(plugin)).to eq(
-        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
-      expect(plugin).to receive(:name).and_return("DocBook")
-      expect(Mint.commandline_options_file(plugin)).to eq(
-        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
-          expect(first_plugin).to receive(callback).ordered.and_return("first")
-          expect(second_plugin).to receive(callback).ordered.and_return("second")
-          expect(third_plugin).to receive(callback).never
-        end
-
-        it "reduces .#{callback} across all specified plugins in order" do
-          plugins = [first_plugin, second_plugin]
-          expect(Mint.send(callback, "text", :plugins => plugins)).to eq("second")
-        end
-      end
-
-      context "when plugins are activated, but no plugins are specified" do
-        before do
-          expect(first_plugin).to receive(callback).ordered.and_return("first")
-          expect(second_plugin).to receive(callback).ordered.and_return("second")
-          expect(third_plugin).to receive(callback).never
-        end
-        
-        it "reduces .#{callback} across all activated plugins in order" do
-          Mint.activate_plugin! first_plugin
-          Mint.activate_plugin! second_plugin
-          expect(Mint.send(callback, "text")).to eq("second")
-        end
-      end
-
-      context "when plugins are not specified" do
-        before do
-          expect(first_plugin).to receive(callback).never
-          expect(second_plugin).to receive(callback).never
-          expect(third_plugin).to receive(callback).never
-        end
-        
-        it "returns the parameter text" do
-          expect(Mint.send(callback, "text")).to eq("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
-        expect(first_plugin).to receive(:after_publish).ordered
-        expect(second_plugin).to receive(:after_publish).ordered
-        expect(third_plugin).to 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
-        expect(first_plugin).to receive(:after_publish).ordered
-        expect(second_plugin).to receive(:after_publish).ordered
-        expect(third_plugin).to 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
-        expect(first_plugin).to receive(:after_publish).never
-        expect(second_plugin).to receive(:after_publish).never
-        expect(third_plugin).to 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
-        expect(plugin).to receive(:name).and_return("EPub")
-        expect(plugin.underscore).to eq("epub")
-      end
-    end
-
-    describe ".inherited" do
-      it "registers the subclass with Mint as a plugin" do
-        expect do
-          Class.new(Mint::Plugin)
-        end.to change { Mint.plugins.length }.by(1)
-      end
-
-      it "preserves the order of subclassing" do
-        expect(Mint.plugins).to eq([@first_plugin, @second_plugin])
-      end
-
-      it "does not change the order of a plugin when it is monkey-patched" do
-        expect do
-          @first_plugin.instance_eval do 
-            def monkey_patch
-            end
-          end
-        end.not_to 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
-
-          expect(plugin.before_render("text")).to eq("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
-
-          expect(plugin.after_render("<html></html>")).to eq("<!doctype html>")
-        end
-      end
-
-      describe ".after_mint" do
-        let(:document) { Mint::Document.new "content.md" } 
-
-        it "allows changes to the document extension" do
-          plugin.class_eval do
-            def self.after_publish(document)
-              document.name.gsub! /html$/, "htm"
-            end
-          end
-
-          expect do
-            plugin.after_publish(document)
-          end.to change { document.name.length }.by(-1)
-        end
-
-        it "allows splitting up the document into two, without garbage" do
-          plugin.class_eval do
-            def self.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]
-
-          expect(File.exist?(document.destination_file)).to be_falsy
-          expect(File.exist?("first-half.html")).to be_truthy
-          expect(File.exist?("second-half.html")).to be_truthy
-        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
-
-        #       expect do
-        #         document.publish! :plugins => [plugin]
-        #       end.to 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.class_eval do
-              def self.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]
-            expect(File.exist?("destination")).to be_falsy
-            expect(File.exist?("book")).to be_truthy
-            expect(document.destination_directory).to eq(File.expand_path("book"))
-          end
-
-          it "allows compression of the final output" do
-            require "zip"
-            require "zip/filesystem"
-
-            document = Mint::Document.new "content.md", destination: "destination"
-            plugin.class_eval do
-              def self.after_publish(document)
-                Zip::OutputStream.open("book.zip") do |zos|
-                  zos.put_next_entry("chapter-1.html")
-                  zos.puts File.read(document.destination_file)
-                end
-
-                FileUtils.mv "book.zip", "book.epub"
-              end
-            end
-
-            document.publish! :plugins => [plugin]
-
-            expect(File.exist?("destination")).to be_truthy
-            expect(File.exist?("book.zip")).to be_falsy
-            expect(File.exist?("book.epub")).to be_truthy
-
-            directory_size = 
-              Dir["#{document.destination_directory}/**/*"].
-              flatten.
-              map {|file| File.stat(file).size }.
-              reduce(&:+)
-            compressed_size = File.stat("book.epub").size
-            expect(directory_size).to be > 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.class_eval do
-              def self.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]
-
-            expect(File.exist?("styles")).to be_falsy
-            expect(File.exist?("looks")).to be_truthy
-            expect(document.style_destination_directory).to eq(File.expand_path("looks"))
-          end
-
-          after do
-            FileUtils.rm_r File.expand_path("looks")
-          end
-        end
-      end
-    end
-  end
-end