mint 0.8.1 → 0.10.0

data/spec/document_spec.rb

@@ -2,260 +2,55 @@ require "spec_helper"
 
 module Mint
   describe Document do
-    # 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.
-    # We do have to test #style_destination derivatives. Those aren't
-    # covered by resource_spec.rb.
-    shared_examples_for "all documents" do
-      # style_spec.rb ensures that our style generation goes as planned
-      # However, we need to test layout generation because it should now
-      # include our content
-      #
-      # This test doesn't cover any plugin transformations. Those
-      # transformations are covered in the Plugin spec.
-      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
-        expect(document.render).to include(document.content)
-        expect(document.render).to include("<html")
-        expect(document.render).to include("</html>")
-      end
-
-      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>")
+    describe "#transform_markdown_links" do
+      around(:each) do |example|
+        in_temp_dir do |dir|
+          @test_dir = dir
+          File.write("test.md", "# Test Document")
+          File.write("layout.erb", "<%= content %>")
+          File.write("style.css", "body { font-family: sans-serif; }")
+          example.run
         end
       end
 
-      # Mint output
-
-      # These tests doesn't cover any plugin transformations. Those
-      # transformations are covered in the Plugin spec.
-      it "writes its rendered style to #style_destination_file" do
-        document.publish!
-        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!
-        expect(document.destination_file_path).to exist
-        content = File.read document.destination_file
-        expect(content).to eq(document.render)
-      end
-    end
-
-    context "when it's created with default options" do
-      let(:document) { Document.new @content_file }
-
-      subject { document }
-      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 }
-
-      it "has a style destination file in user tmp directory" do
-        expect(document.style_destination_file).to match(/\.config\/mint\/tmp\/style\.css$/)
-      end
-
-      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
-        is_expected.to eq(Pathname.new(document.style_destination_file))
-      end
-
-      its(:style_destination_directory_path) do
-        is_expected.to eq(Pathname.new(document.style_destination_directory))
-      end
-
-      its(:layout) { is_expected.to be_in_directory("default") }
-      its(:style) { is_expected.to be_in_directory("default") }
-
-      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" }
-
-      subject { document }
-      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
-        is_expected.to eq("#{@tmp_dir}/destination/styles/style.css")
-      end
-
-      its(:style_destination_directory) do
-        is_expected.to eq("#{@tmp_dir}/destination/styles")
-      end
-
-      its(:style_destination_file_path) do
-        is_expected.to eq(Pathname.new(document.style_destination_file))
-      end
-
-      its(:style_destination_directory_path) do
-        is_expected.to eq(Pathname.new(document.style_destination_directory))
-      end
-
-      its(:layout) { is_expected.to be_in_directory("default") }
-      its(:style) { is_expected.to be_in_directory("default") }
-
-      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" }
-
-      subject { document }
-      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
-
-      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
-        is_expected.to eq(Pathname.new(document.style_destination_file))
-      end
-
-      its(:style_destination_directory_path) do
-        is_expected.to eq(Pathname.new(document.style_destination_directory))
-      end
-
-      its(:layout) { is_expected.to be_in_directory("default") }
-      its(:style) { is_expected.to be_in_directory("default") }
-
-      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 is created with a block" do
       let(:document) do
-        Document.new @content_file do |doc|
-          doc.root              = "#{@tmp_dir}/alternative-root"
-          doc.destination       = "destination"
-          doc.style_destination = "styles"
-          doc.layout            = "zen"
-          doc.style             = "zen"
-        end
-      end
-
-      subject { document }
-      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
-        is_expected.to eq("#{@tmp_dir}/alternative-root/destination/styles/style.css")
-      end
-
-      its(:style_destination_directory) do
-        is_expected.to eq("#{@tmp_dir}/alternative-root/destination/styles")
-      end
-
-      its(:style_destination_file_path) do
-        is_expected.to eq(Pathname.new(document.style_destination_file))
+        Document.new(
+          working_directory: Pathname.new(@test_dir),
+          source_path: Pathname.new("test.md"),
+          destination_path: Pathname.new("test.html"),
+          destination_directory_path: Pathname.new("output"),
+          layout_path: Pathname.new("layout.erb"),
+          style_path: Pathname.new("style.css"),
+          style_destination_path: Pathname.new("output"),
+          style_mode: :inline,
+          insert_title_heading: false,
+          transform_links: proc {|basename| "#{basename}.html" }
+        )
       end
 
-      its(:style_destination_directory_path) do
-        is_expected.to eq(Pathname.new(document.style_destination_directory))
+      it "transforms .md links to .html links" do
+        text = "Check out [this document](other.md) for more info."
+        result = document.transform_markdown_links(text) {|basename| "#{basename}.html" }
+        expect(result).to eq("Check out [this document](other.html) for more info.")
       end
 
-      its(:layout) { is_expected.to be_in_directory("zen") }
-      its(:style) { is_expected.to be_in_directory("zen") }
-
-      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 dealing with metadata" do
-      let(:text) { "metadata: true\n\nReal text" }
-      describe ".metadata_chunk" do
-        it "extracts, but does not parse, metadata from text" do
-          expect(Document.metadata_chunk(text)).to eq("metadata: true")
-        end
+      it "preserves absolute URLs unchanged" do
+        text = "Visit [our website](https://example.com/page.md) for details."
+        result = document.transform_markdown_links(text) {|basename| "#{basename}.html" }
+        expect(result).to eq("Visit [our website](https://example.com/page.md) for details.")
       end
 
-      describe ".metadata_from" do
-        it "parses a documents metadata if present" do
-          expect(Document.metadata_from(text)).to eq({ "metadata" => true })
-        end
-
-        it "returns the empty string if a document has bad/no metadata" do
-          expect(Document.metadata_from("No metadata here")).to eq({})
-        end
-
-        it "handles a non-simple string that is also not YAML" do
-          expect(Document.metadata_from("# Non-simple string")).to eq({})
-        end
+      it "respects custom output file format via block" do
+        text = "See [document](file.md) here."
+        result = document.transform_markdown_links(text) {|basename| "#{basename}_converted.html" }
+        expect(result).to eq("See [document](file_converted.html) here.")
       end
 
-      describe ".parse_metadata_from" do
-        it "separates text from its metadata if present" do
-          expect(Document.parse_metadata_from(text)).to eq(
-            [{ "metadata" => true }, "Real text"])
-        end
-
-        it "returns the entire text if no metadata is found" do
-          expect(Document.parse_metadata_from("No metadata here")).to eq(
-            [{}, "No metadata here"])
-        end
+      it "handles multiple links in same text" do
+        text = "Read [doc1](first.md) and [doc2](second.md)."
+        result = document.transform_markdown_links(text) {|basename| "#{basename}.html" }
+        expect(result).to eq("Read [doc1](first.html) and [doc2](second.html).")
       end
     end
   end
-end
+end

data/spec/flattened_path_spec.rb

@@ -0,0 +1,150 @@
+require "spec_helper"
+
+RSpec.describe "Flattened Path Handling (explicit --no-preserve-structure)" do
+  context "in isolated environment" do
+    around(:each) do |example|
+      in_temp_dir do |dir|
+        @test_dir = dir
+        create_template_directory("default")
+        example.run
+      end
+    end
+
+    describe "default flattened behavior" do
+      it "places files from nested directories directly in destination" do
+        FileUtils.mkdir_p(["docs/guides", "output"])
+        create_markdown_path("docs/guides/setup.md", "# Setup Guide")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("output"), preserve_structure: false)
+        workspace = Mint::Workspace.new([Pathname.new("docs/guides/setup.md")], config)
+        workspace.publish!
+        
+        # File should be flattened to output directory
+        expect(File.exist?("output/setup.html")).to be true
+        expect(File.exist?("output/docs/guides/setup.html")).to be false
+      end
+
+      it "handles multiple files from different nested levels" do
+        FileUtils.mkdir_p(["src", "src/components", "src/pages/admin", "build"])
+        
+        create_markdown_path("src/readme.md", "# Project README")
+        create_markdown_path("src/components/button.md", "# Button Component")  
+        create_markdown_path("src/pages/admin/dashboard.md", "# Admin Dashboard")
+        
+        files = [
+          "src/readme.md",
+          "src/components/button.md", 
+          "src/pages/admin/dashboard.md"
+        ]
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("build"), preserve_structure: false)
+        
+        workspace = Mint::Workspace.new(files.map {|f| Pathname.new(f) }, config)
+        workspace.publish!
+        
+        # All files should be flattened to build directory
+        expect(File.exist?("build/readme.html")).to be true
+        expect(File.exist?("build/button.html")).to be true
+        expect(File.exist?("build/dashboard.html")).to be true
+        
+        # Should not preserve directory structure
+        expect(File.exist?("build/src/readme.html")).to be false
+        expect(File.exist?("build/src/components/button.html")).to be false
+        expect(File.exist?("build/src/pages/admin/dashboard.html")).to be false
+      end
+
+      it "handles files with same basename from different directories" do
+        FileUtils.mkdir_p(["docs/v1", "docs/v2", "output"])
+        
+        create_markdown_path("docs/v1/index.md", "# V1 Index")
+        create_markdown_path("docs/v2/index.md", "# V2 Index")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("output"), preserve_structure: false)
+        
+        # Process files separately to see collision behavior
+        workspace = Mint::Workspace.new([Pathname.new("docs/v1/index.md"), Pathname.new("docs/v2/index.md")], config)
+        workspace.publish!
+        
+        # Only one index.html should exist (last one wins)
+        expect(File.exist?("output/index.html")).to be true
+        
+        # Check that it's the V2 content (last one processed)
+        content = File.read("output/index.html")
+        expect(content).to include("V2 Index")
+      end
+
+      it "works with commandline batch processing" do
+        FileUtils.mkdir_p(["content/posts", "content/pages", "site"])
+        
+        create_markdown_path("content/posts/article1.md", "# Article 1")
+        create_markdown_path("content/posts/article2.md", "# Article 2")
+        create_markdown_path("content/pages/about.md", "# About")
+        
+        files = [
+          Pathname.new("content/posts/article1.md"),
+          Pathname.new("content/posts/article2.md"), 
+          Pathname.new("content/pages/about.md")
+        ]
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("site"), preserve_structure: false)
+        Mint::Commandline.publish!(files, config: config)
+        
+        # All files flattened to site directory
+        expect(File.exist?("site/article1.html")).to be true
+        expect(File.exist?("site/article2.html")).to be true
+        expect(File.exist?("site/about.html")).to be true
+        
+        # No nested structure
+        expect(File.exist?("site/content/posts/article1.html")).to be false
+        expect(File.exist?("site/content/pages/about.html")).to be false
+      end
+
+      it "works with different root and destination directories" do
+        FileUtils.mkdir_p(["source/docs", "public"])
+        
+        create_markdown_path("source/docs/guide.md", "# User Guide")
+        
+        config = Mint::Config.with_defaults(
+          working_directory: Pathname.new("source"),
+          destination_directory: Pathname.new("../public"),
+          preserve_structure: false
+        )
+        
+        workspace = Mint::Workspace.new([Pathname.new("source/docs/guide.md")], config)
+        workspace.publish!
+        
+        # File should be flattened in public directory
+        expect(File.exist?("public/guide.html")).to be true
+        expect(File.exist?("public/docs/guide.html")).to be false
+      end
+
+      it "maintains original behavior for files in root directory" do
+        FileUtils.mkdir_p("output")
+        create_markdown_path("index.md", "# Home Page")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("output"), preserve_structure: false)
+        workspace = Mint::Workspace.new([Pathname.new("index.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("output/index.html")).to be true
+      end
+
+      it "works with external style mode" do
+        FileUtils.mkdir_p(["docs", "site"])
+        create_markdown_path("docs/manual.md", "# Manual")
+        
+        config = Mint::Config.with_defaults(
+          destination_directory: Pathname.new("site"),
+          style_mode: :external,
+          preserve_structure: false
+        )
+        
+        Mint::Commandline.publish!([Pathname.new("docs/manual.md")], config: config)
+        
+        expect(File.exist?("site/manual.html")).to be true  # Flattened
+        expect(File.exist?("site/style.css")).to be true    # Style in destination
+        expect(File.exist?("site/docs/manual.html")).to be false
+      end
+    end
+  end
+end

data/spec/layout_spec.rb

@@ -1,6 +1,45 @@
 require "spec_helper"
 
-module Mint
-  describe Layout do
+describe Mint::Layout do
+  describe ".valid?" do
+    it "determines if a file is a valid layout file" do
+      expect(Mint::Layout.valid?(Pathname.new("layout.html"))).to be true
+      expect(Mint::Layout.valid?(Pathname.new("layout.erb"))).to be true
+      expect(Mint::Layout.valid?(Pathname.new("other.html"))).to be false
+    end
   end
-end
+
+  describe ".find_by_name" do
+    it "returns layout file path by template name" do
+      result = Mint::Layout.find_by_name("default")
+      if result
+        expect(result).to be_a(Pathname)
+        expect(Mint::Layout.valid?(result)).to be true
+      else
+        expect(result).to be_nil
+      end
+    end
+  end
+
+  describe ".find_in_directory" do
+    it "finds layout file in a specific directory" do
+      Dir.mktmpdir do |tmpdir|
+        template_dir = Pathname.new(tmpdir)
+        layout_file = template_dir + "layout.html"
+        layout_file.write("<html><%= content %></html>")
+        
+        result = Mint::Layout.find_in_directory(template_dir)
+        expect(result).to eq(layout_file)
+        expect(Mint::Layout.valid?(result)).to be true
+      end
+    end
+
+    it "returns nil when no layout file exists" do
+      Dir.mktmpdir do |tmpdir|
+        template_dir = Pathname.new(tmpdir)
+        result = Mint::Layout.find_in_directory(template_dir)
+        expect(result).to be_nil
+      end
+    end
+  end
+end