RubyGems - mint - Versions diffs - 0.8.1 → 0.10.0 - Mend

mint 0.8.1 → 0.10.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 (83) hide show

checksums.yaml +4 -4
data/Gemfile +1 -26
data/README.md +117 -37
data/bin/mint +2 -81
data/config/templates/base/navigation.css +136 -0
data/config/templates/base/print.css +152 -0
data/config/templates/{reset.css → base/reset.css} +1 -1
data/config/templates/base/style.css +117 -137
data/config/templates/base/utilities.css +136 -0
data/config/templates/base/variables.css +124 -0
data/config/templates/basic/style.css +151 -0
data/config/templates/default/layout.erb +33 -3
data/config/templates/default/style.css +95 -164
data/config/templates/magazine/style.css +383 -0
data/config/templates/nord/style.css +105 -220
data/config/templates/nord-dark/style.css +82 -263
data/lib/mint/commandline/parse.rb +144 -0
data/lib/mint/commandline/publish.rb +46 -0
data/lib/mint/commandline/run.rb +30 -0
data/lib/mint/config.rb +162 -0
data/lib/mint/{css.rb → css_dsl.rb} +9 -9
data/lib/mint/css_parser.rb +45 -25
data/lib/mint/document.rb +250 -365
data/lib/mint/document_tree.rb +163 -0
data/lib/mint/exceptions.rb +2 -3
data/lib/mint/helpers.rb +23 -180
data/lib/mint/layout.rb +26 -9
data/lib/mint/renderers/css_renderer.rb +32 -0
data/lib/mint/renderers/erb_renderer.rb +11 -0
data/lib/mint/renderers/markdown_renderer.rb +45 -0
data/lib/mint/style.rb +21 -31
data/lib/mint/template.rb +30 -0
data/lib/mint/version.rb +1 -1
data/lib/mint/workspace.rb +171 -0
data/lib/mint.rb +44 -12
data/man/mint.1 +85 -44
data/spec/cli/README.md +2 -2
data/spec/cli/argument_parsing_spec.rb +89 -147
data/spec/cli/bin_integration_spec.rb +23 -243
data/spec/cli/full_workflow_integration_spec.rb +99 -442
data/spec/cli/original_style_integration_spec.rb +58 -0
data/spec/cli/publish_workflow_spec.rb +72 -70
data/spec/commandline_path_integration_spec.rb +230 -0
data/spec/config_file_integration_spec.rb +362 -0
data/spec/{css_spec.rb → css_dsl_spec.rb} +7 -3
data/spec/css_parser_spec.rb +59 -1
data/spec/document_spec.rb +37 -242
data/spec/flattened_path_spec.rb +150 -0
data/spec/layout_spec.rb +42 -3
data/spec/mint_spec.rb +22 -217
data/spec/path_handling_spec.rb +237 -0
data/spec/run_cli_tests.rb +1 -1
data/spec/spec_helper.rb +3 -10
data/spec/style_spec.rb +31 -56
data/spec/support/cli_helpers.rb +7 -10
data/spec/support/matchers.rb +1 -1
data/spec/template_spec.rb +31 -0
data/spec/workspace_spec.rb +177 -0
metadata +75 -89
data/bin/mint-epub +0 -20
data/config/templates/garden/layout.erb +0 -38
data/config/templates/garden/style.css +0 -303
data/config/templates/nord/layout.erb +0 -11
data/config/templates/nord-dark/layout.erb +0 -11
data/config/templates/zen/layout.erb +0 -11
data/config/templates/zen/style.css +0 -114
data/lib/mint/command_line.rb +0 -360
data/lib/mint/css_template.rb +0 -37
data/lib/mint/markdown_template.rb +0 -47
data/lib/mint/mint.rb +0 -313
data/lib/mint/plugin.rb +0 -136
data/lib/mint/plugins/epub.rb +0 -293
data/lib/mint/resource.rb +0 -101
data/plugins/templates/epub/layouts/container.haml +0 -5
data/plugins/templates/epub/layouts/content.haml +0 -35
data/plugins/templates/epub/layouts/layout.haml +0 -6
data/plugins/templates/epub/layouts/title.haml +0 -11
data/plugins/templates/epub/layouts/toc.haml +0 -26
data/spec/cli/configuration_management_spec.rb +0 -363
data/spec/cli/template_management_spec.rb +0 -300
data/spec/helpers_spec.rb +0 -249
data/spec/plugin_spec.rb +0 -449
data/spec/resource_spec.rb +0 -135

data/spec/cli/full_workflow_integration_spec.rb CHANGED Viewed

@@ -12,514 +12,171 @@ RSpec.describe "Full CLI Workflow Integration" do
       describe "new user getting started" do
         it "can set up a new project from scratch" do
-          # 1. Initialize configuration
-          expect {
-            Mint::CommandLine.set("author", "Test User", :local)
-            Mint::CommandLine.set("layout", "clean", :local)
-          }.not_to raise_error
-          # 2. Create a custom template
-          layout_content = <<~HTML
-            <!DOCTYPE html>
-            <html lang="en">
-            <head>
-              <meta charset="UTF-8">
-              <title>My Site</title>
-              <% if style %>
-                <link rel="stylesheet" href="<%= style %>">
-              <% end %>
-            </head>
-            <body>
-              <header>
-                <h1>My Site</h1>
-              </header>
-              <main>
-                <%= content %>
-              </main>
-              <footer>
-                <p>&copy; 2024 Test User</p>
-              </footer>
-            </body>
-            </html>
-          HTML
-          create_template_file("my-layout.erb", :layout, layout_content)
-          Mint::CommandLine.install("my-layout.erb", "clean", :local)
-          # 3. Create some content
-          create_markdown_file("index.md", <<~MARKDOWN
+          # 1. Create configuration file manually (since set command was removed)
+          FileUtils.mkdir_p(".mint")
+          File.write(".mint/config.toml", <<~TOML)
+            layout = "default"
+            style = "default"
+            destination = "output"
+          TOML
+          # 2. Create content files
+          create_markdown_path("index.md", <<~MARKDOWN)
             # Welcome to My Site
-            This is the homepage of my new site.
+            This is my new project built with Mint.
             ## Features
-            - Clean design
-            - Easy to maintain
-            - Fast loading
-            Check out my [about page](about.html).
+            - Simple Markdown processing
+            - Clean HTML output
+            - Customizable templates
           MARKDOWN
-          )
-          create_markdown_file("about.md", <<~MARKDOWN
-            # About Me
-            I'm a developer who loves simple, clean websites.
-            ## Contact
-            - Email: test@example.com
-            - GitHub: @testuser
-          MARKDOWN
-          )
+          create_markdown_path("about.md", "# About\n\nThis is the about page.")
-          # 4. Publish the site
+          # 3. Create output directory and publish
+          FileUtils.mkdir_p("output")
+          config = Mint::Config.with_defaults(destination_directory: Pathname.new("output"))
           expect {
-            Mint::CommandLine.publish!(["index.md", "about.md"], {})
+            Mint::Commandline.publish!([Pathname.new("index.md"), Pathname.new("about.md")], config: config)
           }.not_to raise_error
-          # 5. Verify everything worked
-          expect(File.exist?("index.html")).to be true
-          expect(File.exist?("about.html")).to be true
-          index_content = File.read("index.html")
-          expect(index_content).to include("<h1>My Site</h1>") # header
-          expect(index_content).to include("Welcome to My Site") # content
-          expect(index_content).to include("Test User") # footer
-          expect(index_content).to include("about.html") # link
+          # 4. Verify output
+          expect(File.exist?("output/index.html")).to be true
+          expect(File.exist?("output/about.html")).to be true
-          about_content = File.read("about.html")
-          expect(about_content).to include("About Me")
-          expect(about_content).to include("test@example.com")
+          # Check content
+          index_content = File.read("output/index.html")
+          expect(index_content).to include("<h1>Welcome to My Site</h1>")
+          expect(index_content).to include("<h2>Features</h2>")
         end
       end
       describe "documentation site workflow" do
         it "can build a multi-page documentation site" do
-          # Create a documentation structure
-          FileUtils.mkdir_p("docs/guides")
-          FileUtils.mkdir_p("docs/api")
-          FileUtils.mkdir_p("build")
-          # Create navigation template
-          nav_layout = <<~ERB
-            <!DOCTYPE html>
-            <html>
-            <head>
-              <title>Documentation</title>
-              <style>
-                body { font-family: sans-serif; margin: 0; }
-                .container { display: flex; }
-                .sidebar { width: 200px; background: #f5f5f5; padding: 1rem; }
-                .content { flex: 1; padding: 1rem; }
-                .nav-link { display: block; margin: 0.5rem 0; }
-              </style>
-            </head>
-            <body>
-              <div class="container">
-                <nav class="sidebar">
-                  <h3>Documentation</h3>
-                  <% if defined?(all_files) && all_files %>
-                    <% all_files.each do |file| %>
-                      <% name = File.basename(file, '.md') %>
-                      <% path = file.gsub('.md', '.html') %>
-                      <a href="<%= path %>" class="nav-link"><%= name.tr('-', ' ').capitalize %></a>
-                    <% end %>
-                  <% end %>
-                </nav>
-                <main class="content">
-                  <%= content %>
-                </main>
-              </div>
-            </body>
-            </html>
-          ERB
-          FileUtils.mkdir_p(".mint/templates/docs")
-          File.write(".mint/templates/docs/layout.erb", nav_layout)
-          # Create documentation content
-          create_markdown_file("docs/index.md", <<~MARKDOWN
-            # Project Documentation
-            Welcome to our comprehensive documentation.
-            ## Getting Started
-            See our [installation guide](guides/installation.html) to get up and running.
-          MARKDOWN
-          )
-          create_markdown_file("docs/guides/installation.md", <<~MARKDOWN
-            # Installation Guide
-            ## Prerequisites
-            - Ruby 2.7+
-            - Git
-            ## Steps
-            1. Clone the repository
-            2. Run `bundle install`
-            3. Run `mint publish`
-          MARKDOWN
+          # Set up configuration for documentation
+          config = Mint::Config.with_defaults(
+            layout_name: "default",
+            style_name: "default",
+            destination_directory: Pathname.new("docs"),
+            preserve_structure: true  # Preserve source structure
           )
-          create_markdown_file("docs/api/overview.md", <<~MARKDOWN
-            # API Overview
-            Our API provides REST endpoints for all major operations.
-            ## Authentication
-            All requests require an API key in the header.
-          MARKDOWN
-          )
-          # Configure for documentation
-          Mint::CommandLine.set("layout", "docs", :local)
-          Mint::CommandLine.set("destination", "build", :local)
+          # Create documentation structure
+          FileUtils.mkdir_p(["source/guides", "source/api", "docs"])
+          create_markdown_path("source/index.md", "# Documentation\n\nWelcome to our docs!")
+          create_markdown_path("source/guides/getting-started.md", "# Getting Started\n\nInstallation guide.")
+          create_markdown_path("source/guides/advanced.md", "# Advanced Usage\n\nAdvanced features.")
+          create_markdown_path("source/api/reference.md", "# API Reference\n\nComplete API docs.")
           # Publish all documentation
-          files = ["docs/index.md", "docs/guides/installation.md", "docs/api/overview.md"]
-          Mint::CommandLine.publish!(files, { recursive: false })
+          md_files = Dir.glob("source/**/*.md").map {|f| Pathname.new(f) }
+          expect {
+            Mint::Commandline.publish!(md_files, config: config)
+          }.not_to raise_error
-          # Verify the documentation site
-          expect(File.exist?("build/docs/index.html")).to be true
-          expect(File.exist?("build/docs/guides/installation.html")).to be true
-          expect(File.exist?("build/docs/api/overview.html")).to be true
+          # Verify structure is maintained (with autodrop applied)
+          expect(File.exist?("docs/index.html")).to be true
+          expect(File.exist?("docs/guides/getting-started.html")).to be true
+          expect(File.exist?("docs/guides/advanced.html")).to be true
+          expect(File.exist?("docs/api/reference.html")).to be true
-          index_content = File.read("build/docs/index.html")
-          expect(index_content).to include("Documentation") # nav
-          expect(index_content).to include("installation") # nav link
-          expect(index_content).to include("Project Documentation") # content
+          # Verify content
+          index_content = File.read("docs/index.html")
+          expect(index_content).to include("Welcome to our docs!")
         end
       end
       describe "blog workflow" do
         it "can manage a simple blog" do
-          # Create blog structure
-          FileUtils.mkdir_p("posts")
-          FileUtils.mkdir_p("output")
-          # Create blog template
-          blog_layout = <<~ERB
-            <!DOCTYPE html>
-            <html>
-            <head>
-              <title>My Blog</title>
-              <meta name="viewport" content="width=device-width, initial-scale=1">
-              <style>
-                body {
-                  max-width: 800px;
-                  margin: 0 auto;
-                  padding: 2rem;
-                  font-family: Georgia, serif;
-                  line-height: 1.6;
-                }
-                .header { border-bottom: 1px solid #eee; margin-bottom: 2rem; }
-                .post-meta { color: #666; font-size: 0.9em; margin-bottom: 1rem; }
-                .back-link { margin-top: 2rem; }
-              </style>
-            </head>
-            <body>
-              <header class="header">
-                <h1><a href="index.html">My Blog</a></h1>
-              </header>
-              <article>
-                <%= content %>
-              </article>
-              <div class="back-link">
-                <a href="index.html">&larr; Back to all posts</a>
-              </div>
-            </body>
-            </html>
-          ERB
-          FileUtils.mkdir_p(".mint/templates/blog")
-          File.write(".mint/templates/blog/layout.erb", blog_layout)
-          # Create blog posts
-          create_markdown_file("posts/2024-01-15-first-post.md", <<~MARKDOWN
-            # My First Blog Post
-            <div class="post-meta">January 15, 2024</div>
-            Welcome to my new blog! I'm excited to share my thoughts on:
-            - Web development
-            - Ruby programming
-            - Life and code
-            Stay tuned for more posts!
-          MARKDOWN
+          # Set up blog configuration
+          config = Mint::Config.with_defaults(
+            layout_name: "default",
+            destination_directory: Pathname.new("blog"),
+            preserve_structure: true  # Preserve posts/ structure
           )
-          create_markdown_file("posts/2024-01-20-learning-mint.md", <<~MARKDOWN
-            # Learning Mint for Static Sites
-            <div class="post-meta">January 20, 2024</div>
-            I've been exploring Mint for generating static sites. Here's what I've learned:
-            ## Why Static Sites?
-            - Fast loading
-            - Easy hosting
-            - Version control friendly
-            ## Getting Started with Mint
-            The process is straightforward...
-          MARKDOWN
-          )
-          # Create an index page
-          create_markdown_file("index.md", <<~MARKDOWN
-            # Welcome to My Blog
-            Recent posts:
-            - [Learning Mint for Static Sites](posts/2024-01-20-learning-mint.html) - January 20, 2024
-            - [My First Blog Post](posts/2024-01-15-first-post.html) - January 15, 2024
-          MARKDOWN
-          )
-          # Configure and publish
-          Mint::CommandLine.configure({
-            "layout" => "blog",
-            "destination" => "output"
-          }, :local)
-          # Publish all content
-          files = Dir.glob("posts/*.md") + ["index.md"]
-          Mint::CommandLine.publish!(files, {})
-          # Verify blog structure
-          expect(File.exist?("output/index.html")).to be true
-          expect(File.exist?("output/posts/2024-01-15-first-post.html")).to be true
-          expect(File.exist?("output/posts/2024-01-20-learning-mint.html")).to be true
-          # Check content
-          index_content = File.read("output/index.html")
-          expect(index_content).to include("My Blog")
-          expect(index_content).to include("Recent posts")
-          post_content = File.read("output/posts/2024-01-15-first-post.html")
-          expect(post_content).to include("My First Blog Post")
-          expect(post_content).to include("January 15, 2024")
-          expect(post_content).to include("Back to all posts")
-        end
-      end
-      describe "team collaboration workflow" do
-        it "supports shared templates and configuration" do
-          # Simulate a team setup with shared templates
-          # 1. Set up shared template (simulating user scope)
-          shared_template = <<~ERB
-            <!DOCTYPE html>
-            <html>
-            <head>
-              <title>Company Documentation</title>
-              <style>
-                body { font-family: 'Helvetica', sans-serif; }
-                .company-header { background: #003366; color: white; padding: 1rem; }
-                .content { padding: 2rem; }
-              </style>
-            </head>
-            <body>
-              <header class="company-header">
-                <h1>Acme Corp Documentation</h1>
-              </header>
-              <div class="content">
-                <%= content %>
-              </div>
-            </body>
-            </html>
-          ERB
-          # Create company template
-          FileUtils.mkdir_p(".mint/templates/company")
-          File.write(".mint/templates/company/layout.erb", shared_template)
-          # 2. Individual developer customizes local config
-          Mint::CommandLine.configure({
-            "layout" => "company",
-            "author" => "Alice Developer",
-            "destination" => "team-docs"
-          }, :local)
-          # 3. Create team documentation
-          FileUtils.mkdir_p("team-docs")
-          create_markdown_file("project-overview.md", <<~MARKDOWN
-            # Project Overview
-            ## Architecture
-            Our system consists of three main components:
-            1. Frontend (React)
-            2. Backend (Rails API)
-            3. Database (PostgreSQL)
-            ## Deployment
-            We use Docker for containerization and deploy to AWS.
-          MARKDOWN
-          )
-          # 4. Publish with team template
-          Mint::CommandLine.publish!(["project-overview.md"], {})
-          # 5. Verify team branding is applied
-          expect(File.exist?("team-docs/project-overview.html")).to be true
+          # Create blog structure
+          FileUtils.mkdir_p(["posts", "blog"])
-          content = File.read("team-docs/project-overview.html")
-          expect(content).to include("Acme Corp Documentation")
-          expect(content).to include("company-header")
-          expect(content).to include("Project Overview")
-        end
-      end
-      describe "migration and maintenance workflows" do
-        it "can migrate templates and preserve content" do
-          # Start with old template
-          old_template = "<html><body><%= content %></body></html>"
-          create_template_file("old.erb", :layout, old_template)
-          Mint::CommandLine.install("old.erb", "v1", :local)
-          # Create content with old template
-          create_markdown_file("document.md", "# My Document\n\nContent here.")
-          Mint::CommandLine.publish!(["document.md"], { layout: "v1" })
-          old_content = File.read("document.html")
-          expect(old_content).to include("My Document")
+          create_markdown_path("index.md", "# My Blog\n\nWelcome to my thoughts!")
+          create_markdown_path("posts/2023-01-01-hello-world.md", "# Hello World\n\nMy first post.")
+          create_markdown_path("posts/2023-02-15-update.md", "# February Update\n\nWhat I've been up to.")
-          # Create new, improved template
-          new_template = <<~ERB
-            <!DOCTYPE html>
-            <html lang="en">
-            <head>
-              <meta charset="UTF-8">
-              <title>Documentation</title>
-            </head>
-            <body>
-              <div class="container">
-                <%= content %>
-              </div>
-            </body>
-            </html>
-          ERB
-          create_template_file("new.erb", :layout, new_template)
-          Mint::CommandLine.install("new.erb", "v2", :local)
-          # Migrate to new template
-          Mint::CommandLine.publish!(["document.md"], { layout: "v2" })
+          # Publish blog
+          blog_files = [Pathname.new("index.md")] + Dir.glob("posts/*.md").map {|f| Pathname.new(f) }
+          expect {
+            Mint::Commandline.publish!(blog_files, config: config)
+          }.not_to raise_error
-          new_content = File.read("document.html")
-          expect(new_content).to include("My Document") # content preserved
-          expect(new_content).to include("<!DOCTYPE html>") # new template features
-          expect(new_content).to include("container") # new styling
+          # Verify blog structure
+          expect(File.exist?("blog/index.html")).to be true
+          expect(File.exist?("blog/posts/2023-01-01-hello-world.html")).to be true
+          expect(File.exist?("blog/posts/2023-02-15-update.html")).to be true
         end
       end
       describe "error recovery workflows" do
         it "can recover from and fix common mistakes" do
-          # 1. Try to use non-existent template (common mistake)
-          create_markdown_file("test.md", "# Test")
+          create_markdown_path("test.md", "# Test")
+          # Test error when nonexistent style is specified
           expect {
-            Mint::CommandLine.publish!(["test.md"], { layout: "nonexistent" })
-          }.to raise_error(Mint::TemplateNotFoundException)
-          # 2. Create the missing template
-          allow(STDIN).to receive(:gets).and_return("y\n") # auto-create
-          silence_output do
-            mock_editor do
-              Mint::CommandLine.edit("nonexistent", :layout, :local)
-            end
-          end
+            Mint::Commandline.publish!([Pathname.new("test.md")], config: Mint::Config.with_defaults(style_name: "nonexistent"))
+          }.to raise_error(Mint::StyleNotFoundException)
-          # 3. Now publishing should work
+          # Recovery: Use existing layout
           expect {
-            Mint::CommandLine.publish!(["test.md"], { layout: "nonexistent" })
+            Mint::Commandline.publish!([Pathname.new("test.md")], config: Mint::Config.with_defaults(layout_name: "default"))
           }.not_to raise_error
           expect(File.exist?("test.html")).to be true
         end
         it "handles corrupted configuration gracefully" do
-          # Create corrupted config
+          # Create corrupted config file
           FileUtils.mkdir_p(".mint")
-          File.write(".mint/config.yaml", "invalid: yaml: content: [")
+          File.write(".mint/config.toml", "invalid = toml content [")
-          # Should still be able to set new config
+          create_markdown_path("test.md", "# Test")
+          # Should still work with explicit config
           expect {
-            Mint::CommandLine.set("layout", "recovery", :local)
+            Mint::Commandline.publish!([Pathname.new("test.md")], config: Mint::Config.defaults)
           }.not_to raise_error
-          # Config should now be valid
-          config = YAML.load_file(".mint/config.yaml")
-          expect(config["layout"]).to eq("recovery")
+          expect(File.exist?("test.html")).to be true
         end
       end
       describe "performance with large projects" do
         it "handles many files efficiently" do
-          # Create a larger number of files
-          FileUtils.mkdir_p("large-project")
-          setup_basic_config
-          create_template_directory("default")
+          # Create many files
           files = []
-          20.times do |i|
-            file = "large-project/page-#{i.to_s.rjust(3, '0')}.md"
-            content = <<~MARKDOWN
-              # Page #{i}
-              This is page number #{i} in our large project.
-              ## Content
-              #{'Lorem ipsum dolor sit amet. ' * 10}
-              ## Links
-              - [Previous](page-#{'%03d' % (i-1)}.html) #{i > 0 ? '' : '(none)'}
-              - [Next](page-#{'%03d' % (i+1)}.html) #{i < 19 ? '' : '(none)'}
-            MARKDOWN
-            create_markdown_file(file, content)
-            files << file
+          (1..50).each do |i|
+            filename = "doc#{i}.md"
+            create_markdown_path(filename, "# Document #{i}\n\nContent for document #{i}.")
+            files << Pathname.new(filename)
           end
-          # Publish all files and measure time
+          config = Mint::Config.defaults
+          # Measure performance
           start_time = Time.now
           expect {
-            Mint::CommandLine.publish!(files, {})
+            Mint::Commandline.publish!(files, config: config)
           }.not_to raise_error
           end_time = Time.now
-          duration = end_time - start_time
-          # Verify all files were created
-          20.times do |i|
-            expect(File.exist?("large-project/page-#{'%03d' % i}.html")).to be true
-          end
-          # Should complete in reasonable time (adjust as needed)
-          expect(duration).to be < 10.0
+          # Should complete in reasonable time (less than 30 seconds for 50 files)
+          expect(end_time - start_time).to be < 30
-          # Verify content quality isn't compromised
-          sample_content = File.read("large-project/page-010.html")
-          expect(sample_content).to include("Page 10")
-          expect(sample_content).to include("Lorem ipsum")
+          # Verify all files were processed
+          (1..50).each do |i|
+            expect(File.exist?("doc#{i}.html")).to be true
+          end
         end
       end
     end

data/spec/cli/original_style_integration_spec.rb ADDED Viewed

@@ -0,0 +1,58 @@
+require "spec_helper"
+describe "Original style mode integration" 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 "with --style-mode original" do
+      it "works with built-in templates in original mode" do
+        create_markdown_path("test.md", "# Test Document\n\nThis is a test.")
+        # Create output directory structure
+        Dir.chdir(@test_dir) do
+          config = Mint::Config.with_defaults(
+            style_mode: :original,
+            layout_name: "default",
+            style_name: "default"
+          )
+          expect {
+            Mint::Commandline.publish!([Pathname.new("test.md")], config: config)
+          }.not_to raise_error
+          expect(File.exist?("test.html")).to be true
+          content = File.read("test.html")
+          expect(content).to include("<h1>Test Document</h1>")
+          expect(content).to include("<p>This is a test.</p>")
+        end
+      end
+      it "correctly outputs original style mode with different templates" do
+        create_markdown_path("test.md", "# Nord Test\n\nTesting with Nord theme.")
+        create_template_directory("nord")
+        Dir.chdir(@test_dir) do
+          config = Mint::Config.with_defaults(
+            style_mode: :original,
+            layout_name: "nord",
+            style_name: "nord"
+          )
+          # Should work with any template that exists, or fall back gracefully
+          expect {
+            Mint::Commandline.publish!([Pathname.new("test.md")], config: config)
+          }.not_to raise_error
+          expect(File.exist?("test.html")).to be true
+        end
+      end
+    end
+  end
+end