mint 0.7.3 → 0.8.0

data/spec/cli/README.md

@@ -0,0 +1,99 @@
+# Mint CLI Test Suite
+
+This directory contains a comprehensive test suite for the Mint command-line interface.
+
+## Test structure
+
+### Core test files
+
+- **`argument_parsing_spec.rb`** - Tests command-line argument parsing and option handling
+- **`template_management_spec.rb`** - Tests template installation, uninstallation, editing, and listing
+- **`publish_workflow_spec.rb`** - Tests markdown publishing, file discovery, and output generation
+- **`configuration_management_spec.rb`** - Tests configuration setting, reading, and scope management
+- **`bin_integration_spec.rb`** - Tests actual `bin/mint` executable integration
+- **`full_workflow_integration_spec.rb`** - End-to-end workflow tests for common user scenarios
+
+### Support files
+
+- **`../support/cli_helpers.rb`** - Helper methods for CLI testing (temp directories, file creation, output capture)
+- **`run_cli_tests.rb`** - Custom test runner with better output formatting
+
+## Running tests
+
+### Run all CLI tests
+
+```bash
+# Using custom runner (recommended)
+spec/run_cli_tests.rb
+
+# Using RSpec directly
+rspec spec/cli/ --format documentation
+```
+
+### Run specific test suites
+
+```bash
+# Individual test suites
+spec/run_cli_tests.rb argument_parsing
+spec/run_cli_tests.rb template_management
+spec/run_cli_tests.rb publish_workflow
+
+# Or with RSpec
+rspec spec/cli/argument_parsing_spec.rb
+```
+
+### Run integration tests only
+
+```bash
+rspec spec/cli/full_workflow_integration_spec.rb
+```
+
+## Helper methods
+
+The `cli_helpers.rb` provides utilities for:
+
+```ruby
+# Temporary directories
+in_temp_dir do |dir|
+  # Test code runs in isolated temp directory
+end
+
+# Output capture
+stdout, stderr = capture_output do
+  Mint::CommandLine.some_method
+end
+
+# File creation
+create_markdown_file("test.md", "# Content")
+create_template_directory("custom", with_layout: true)
+
+# Command execution
+result = run_command("mint", "publish", "file.md")
+
+# Content verification
+verify_file_content("output.html") do |content|
+  expect(content).to include("expected text")
+end
+```
+
+## Debugging failed tests
+
+### Common issues
+1. **Missing templates** - Tests create minimal templates; check `create_template_directory`
+2. **File paths** - All paths should be relative within temp directory
+3. **Configuration** - Use `setup_basic_config` to establish minimal config
+
+### Debug helpers
+
+```ruby
+# Print current directory contents
+puts Dir.glob("**/*")
+
+# Print file contents
+puts File.read("problematic.html") rescue "FILE NOT FOUND"
+
+# Print configuration
+puts YAML.load_file(".mint/config.yaml") rescue "NO CONFIG"
+```
+
+This test suite provides comprehensive coverage of Mint's CLI functionality while being maintainable and fast to run.

data/spec/cli/argument_parsing_spec.rb

@@ -0,0 +1,207 @@
+require "spec_helper"
+
+RSpec.describe "CLI Argument Parsing" do
+  describe "Mint::CommandLine.parse" do
+    context "with no arguments" do
+      it "returns default options and empty argv" do
+        result = Mint::CommandLine.parse([])
+        
+        expect(result[:argv]).to eq([])
+        expect(result[:options][:root]).to eq(Dir.getwd)
+        expect(result[:options][:scope]).to eq(:local)
+        expect(result[:options][:layout_or_style_or_template]).to eq([:template, 'default'])
+        expect(result[:help]).to include("Usage: mint")
+      end
+    end
+
+    context "with template options" do
+      it "parses --template option" do
+        result = Mint::CommandLine.parse(["--template", "zen", "file.md"])
+        
+        expect(result[:argv]).to eq(["file.md"])
+        expect(result[:options][:layout_or_style_or_template]).to eq([:template, "zen"])
+      end
+
+      it "parses --layout option" do
+        result = Mint::CommandLine.parse(["--layout", "custom", "file.md"])
+        
+        expect(result[:argv]).to eq(["file.md"])
+        expect(result[:options][:layout_or_style_or_template]).to eq([:layout, "custom"])
+      end
+
+      it "parses --style option" do
+        result = Mint::CommandLine.parse(["--style", "minimal", "file.md"])
+        
+        expect(result[:argv]).to eq(["file.md"])
+        expect(result[:options][:layout_or_style_or_template]).to eq([:style, "minimal"])
+      end
+
+      it "handles short flags for templates" do
+        result = Mint::CommandLine.parse(["-t", "pro", "file.md"])
+        expect(result[:options][:layout_or_style_or_template]).to eq([:template, "pro"])
+
+        result = Mint::CommandLine.parse(["--layout", "custom", "file.md"])
+        expect(result[:options][:layout_or_style_or_template]).to eq([:layout, "custom"])
+
+        result = Mint::CommandLine.parse(["-s", "clean", "file.md"])
+        expect(result[:options][:layout_or_style_or_template]).to eq([:style, "clean"])
+      end
+    end
+
+    context "with path options" do
+      it "parses --root option" do
+        result = Mint::CommandLine.parse(["--root", "/custom/path", "file.md"])
+        
+        expect(result[:options][:root]).to eq("/custom/path")
+      end
+
+      it "parses --destination option" do
+        result = Mint::CommandLine.parse(["--destination", "output", "file.md"])
+        
+        expect(result[:options][:destination]).to eq("output")
+      end
+
+      it "parses --style-destination option" do
+        result = Mint::CommandLine.parse(["--style-destination", "css", "file.md"])
+        
+        expect(result[:options][:style_destination]).to eq("css")
+      end
+    end
+
+    context "with output options" do
+      it "parses --output-file option" do
+        result = Mint::CommandLine.parse(["--output-file", "custom.html", "file.md"])
+        
+        expect(result[:options][:output_file]).to eq("custom.html")
+      end
+
+      it "has default output file format" do
+        result = Mint::CommandLine.parse(["file.md"])
+        
+        expect(result[:options][:output_file]).to eq('#{basename}.#{new_extension}')
+      end
+    end
+
+    context "with scope options" do
+      it "parses --global scope" do
+        result = Mint::CommandLine.parse(["--global", "file.md"])
+        
+        expect(result[:options][:scope]).to eq(:global)
+      end
+
+      it "parses --user scope" do
+        result = Mint::CommandLine.parse(["--user", "file.md"])
+        
+        expect(result[:options][:scope]).to eq(:user)
+      end
+
+      it "parses --local scope (default)" do
+        result = Mint::CommandLine.parse(["--local", "file.md"])
+        
+        expect(result[:options][:scope]).to eq(:local)
+      end
+
+      it "handles short scope flags" do
+        result = Mint::CommandLine.parse(["-g"])
+        expect(result[:options][:scope]).to eq(:global)
+
+        result = Mint::CommandLine.parse(["-u"])
+        expect(result[:options][:scope]).to eq(:user)
+
+        result = Mint::CommandLine.parse(["-l"])
+        expect(result[:options][:scope]).to eq(:local)
+      end
+    end
+
+    context "with boolean flags" do
+      it "parses --recursive flag" do
+        result = Mint::CommandLine.parse(["--recursive"])
+        
+        expect(result[:options][:recursive]).to be true
+      end
+
+      it "handles short recursive flag" do
+        result = Mint::CommandLine.parse(["-r"])
+        
+        expect(result[:options][:recursive]).to be true
+      end
+
+      it "defaults recursive to false" do
+        result = Mint::CommandLine.parse([])
+        
+        expect(result[:options][:recursive]).to be false
+      end
+    end
+
+    context "with mixed arguments" do
+      it "parses complex argument combinations" do
+        args = [
+          "--template", "zen",
+          "--root", "/custom",
+          "--destination", "out", 
+          "--recursive",
+          "--global",
+          "file1.md", "file2.md"
+        ]
+        
+        result = Mint::CommandLine.parse(args)
+        
+        expect(result[:argv]).to eq(["file1.md", "file2.md"])
+        expect(result[:options][:layout_or_style_or_template]).to eq([:template, "zen"])
+        expect(result[:options][:root]).to eq("/custom")
+        expect(result[:options][:destination]).to eq("out")
+        expect(result[:options][:recursive]).to be true
+        expect(result[:options][:scope]).to eq(:global)
+      end
+    end
+
+    context "argument processing utilities" do
+      describe ".process_output_format" do
+        it "processes basename substitution" do
+          result = Mint::CommandLine.process_output_format(
+            '#{basename}.html', 
+            'document.md'
+          )
+          
+          expect(result).to eq('document.html')
+        end
+
+        it "processes original_extension substitution" do
+          result = Mint::CommandLine.process_output_format(
+            '#{basename}.#{original_extension}.bak',
+            'document.md' 
+          )
+          
+          expect(result).to eq('document.md.bak')
+        end
+
+        it "processes new_extension substitution" do
+          result = Mint::CommandLine.process_output_format(
+            '#{basename}.#{new_extension}',
+            'document.md'
+          )
+          
+          expect(result).to eq('document.html')
+        end
+
+        it "processes complex format strings" do
+          result = Mint::CommandLine.process_output_format(
+            'output/#{basename}-converted.#{new_extension}',
+            'docs/readme.md'
+          )
+          
+          expect(result).to eq('output/readme-converted.html')
+        end
+
+        it "handles files without extensions" do
+          result = Mint::CommandLine.process_output_format(
+            '#{basename}.#{new_extension}',
+            'README'
+          )
+          
+          expect(result).to eq('README.html')
+        end
+      end
+    end
+  end
+end

data/spec/cli/bin_integration_spec.rb

@@ -0,0 +1,348 @@
+require "spec_helper"
+
+RSpec.describe "Bin Script Integration" do
+  describe "mint executable" do
+    let(:mint_bin) { File.expand_path("../../../bin/mint", __FILE__) }
+    let(:project_root) { File.expand_path("../../..", __FILE__) }
+    
+    context "in isolated environment" do
+      around(:each) do |example|
+        in_temp_dir do |dir|
+          @test_dir = dir
+          # Copy bin scripts to test directory for isolation
+          FileUtils.cp_r("#{project_root}/bin", ".")
+          FileUtils.cp_r("#{project_root}/lib", ".")
+          
+          # Make sure bin script is executable
+          FileUtils.chmod(0755, "bin/mint")
+          example.run
+        end
+      end
+
+      describe "basic command functionality" do
+        it "shows help when run with no arguments" do
+          result = run_command("ruby", "bin/mint")
+          
+          expect(result.success?).to be true
+          expect(result.stdout).to include("Usage:")
+        end
+
+        it "shows help with --help flag" do
+          result = run_command("ruby", "bin/mint", "--help")
+          
+          expect(result.stdout).to include("Usage: mint [command] files [options]")
+          expect(result.stdout).to include("--template")
+          expect(result.stdout).to include("--layout")
+          expect(result.stdout).to include("--style")
+        end
+
+        it "shows version information" do
+          # Assuming there's a --version flag or similar
+          # This might need adjustment based on actual implementation
+          result = run_command("ruby", "bin/mint", "--version")
+          
+          # This test might fail if --version isn't implemented
+          # In that case, we could test a different way to get version info
+        end
+      end
+
+      describe "publish command" do
+        it "publishes markdown files via CLI" do
+          create_markdown_file("test.md", "# Hello from CLI")
+          setup_basic_config
+          create_template_directory("default")
+          
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "test.md")
+          
+          expect(result.success?).to be true
+          expect(File.exist?("test.html")).to be true
+          
+          content = File.read("test.html")
+          expect(content).to include("Hello from CLI")
+        end
+
+        it "handles multiple files" do
+          create_markdown_file("doc1.md", "# Document 1")
+          create_markdown_file("doc2.md", "# Document 2")
+          setup_basic_config
+          create_template_directory("default")
+          
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "doc1.md", "doc2.md")
+          
+          expect(result.success?).to be true
+          expect(File.exist?("doc1.html")).to be true
+          expect(File.exist?("doc2.html")).to be true
+        end
+
+        it "respects template options" do
+          create_markdown_file("styled.md", "# Styled Document")
+          setup_basic_config
+          create_template_directory("default")
+          create_template_directory("custom")
+          
+          # Write a distinctive custom template
+          File.write(".mint/templates/custom/layout.erb", 
+            "<html><body class='custom-style'><%= content %></body></html>")
+          File.write(".mint/templates/custom/style.css", 
+            "body { background: red; }")
+          
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "--template", "custom", "styled.md")
+          
+          expect(result.success?).to be true
+          expect(File.exist?("styled.html")).to be true
+          
+          content = File.read("styled.html")
+          expect(content).to include("custom-style")
+        end
+
+        it "handles recursive publishing" do
+          FileUtils.mkdir_p("docs/sub")
+          create_markdown_file("docs/index.md", "# Index")
+          create_markdown_file("docs/sub/page.md", "# Sub Page")
+          setup_basic_config
+          create_template_directory("default")
+          
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "--recursive", "docs")
+          
+          expect(result.success?).to be true
+          expect(File.exist?("docs/index.html")).to be true
+          expect(File.exist?("docs/sub/page.html")).to be true
+        end
+
+        it "handles errors gracefully" do
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "nonexistent.md")
+          
+          expect(result.success?).to be false
+          expect(result.stderr + result.stdout).to match(/error|Error|No such file|ENOENT/i)
+        end
+      end
+
+      describe "template management commands" do
+        it "lists templates" do
+          setup_basic_config
+          create_template_directory("custom1")
+          create_template_directory("custom2")
+          
+          result = run_command("ruby", "bin/mint", "templates")
+          
+          expect(result.success?).to be true
+          expect(result.stdout).to include("custom1")
+          expect(result.stdout).to include("custom2")
+        end
+
+        it "installs templates" do
+          create_template_file("my-layout.erb", :layout, "<html><%= yield %></html>")
+          
+          result = run_command("ruby", "bin/mint", "install", "my-layout.erb", "mynew")
+          
+          expect(result.success?).to be true
+          expect(File.exist?(".mint/templates/mynew/layout.erb")).to be true
+        end
+
+        it "uninstalls templates" do
+          setup_basic_config
+          create_template_directory("removeme")
+          
+          # Verify it exists first
+          expect(File.exist?(".mint/templates/removeme")).to be true
+          
+          result = run_command("ruby", "bin/mint", "uninstall", "removeme")
+          
+          expect(result.success?).to be true
+          expect(File.exist?(".mint/templates/removeme")).to be false
+        end
+
+        it "edits templates" do
+          setup_basic_config
+          create_template_directory("editable", with_layout: true)
+          
+          # Mock the editor to avoid opening a real editor
+          result = run_command(
+            {"EDITOR" => "echo 'edited'"}, 
+            "ruby", "bin/mint", "edit-layout", "editable"
+          )
+          
+          expect(result.success?).to be true
+        end
+      end
+
+      describe "configuration commands" do
+        it "displays current configuration" do
+          setup_basic_config
+          
+          result = run_command("ruby", "bin/mint", "config")
+          
+          expect(result.success?).to be true
+          expect(result.stdout).to include("layout")
+          expect(result.stdout).to include("default")
+        end
+
+        it "sets configuration values" do
+          result = run_command("ruby", "bin/mint", "set", "layout", "custom-layout")
+          
+          expect(result.success?).to be true
+          expect(File.exist?(".mint/config.yaml")).to be true
+          
+          config = YAML.load_file(".mint/config.yaml")
+          expect(config["layout"]).to eq("custom-layout")
+        end
+
+        it "handles scope flags for configuration" do
+          result = run_command("ruby", "bin/mint", "set", "--local", "style", "local-style")
+          
+          expect(result.success?).to be true
+          
+          config = YAML.load_file(".mint/config.yaml")
+          expect(config["style"]).to eq("local-style")
+        end
+      end
+
+      describe "plugin commands" do
+        it "handles epub plugin" do
+          create_markdown_file("book.md", "# My Book\n\nContent here.")
+          
+          # This might fail if epub dependencies aren't available
+          result = run_command("ruby", "bin/mint-epub", "publish", "book.md")
+          
+          # We expect this to either work or fail gracefully
+          # The specific behavior depends on whether epub dependencies are installed
+          expect([true, false]).to include(result.success?)
+        end
+      end
+
+      describe "error handling and edge cases" do
+        it "handles unknown commands gracefully" do
+          result = run_command("ruby", "bin/mint", "unknown-command")
+          
+          expect(result.success?).to be false
+          expect(result.stderr + result.stdout).to match(/error|Usage/)
+        end
+
+        it "handles malformed arguments" do
+          result = run_command("ruby", "bin/mint", "publish", "--invalid-flag")
+          
+          expect(result.success?).to be false
+        end
+
+        it "provides helpful error messages" do
+          result = run_command("ruby", "bin/mint", "edit", "nonexistent-template")
+          
+          expect(result.success?).to be false
+          # Should provide a helpful error about the missing template
+        end
+
+        it "handles permission errors" do
+          create_markdown_file("test.md", "# Test")
+          
+          # Try to publish to a location we can't write to
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "--destination", "/root", "test.md")
+          
+          expect(result.success?).to be false
+        end
+      end
+
+      describe "environment handling" do
+        it "respects EDITOR environment variable" do
+          setup_basic_config
+          create_template_directory("test", with_layout: true)
+          
+          result = run_command(
+            {"EDITOR" => "echo 'custom-editor'"},
+            "ruby", "bin/mint", "edit-layout", "test"
+          )
+          
+          expect(result.success?).to be true
+        end
+
+        it "works with different working directories" do
+          FileUtils.mkdir_p("subdir")
+          Dir.chdir("subdir") do
+            create_markdown_file("doc.md", "# From Subdir")
+            
+            result = run_command("ruby", "../bin/mint", "publish", "doc.md")
+            
+            # This might require the default template to exist
+            # The exact behavior depends on how Mint handles paths
+          end
+        end
+
+        it "handles Ruby load path correctly" do
+          # The bin script should be able to find the lib directory
+          result = run_command("ruby", "bin/mint", "--help")
+          
+          expect(result.success?).to be true
+          # Should not have load errors
+          expect(result.stderr).not_to include("LoadError")
+          expect(result.stderr).not_to include("cannot load such file")
+        end
+      end
+
+      describe "output formatting and verbosity" do
+        it "produces clean output for normal operations" do
+          create_markdown_file("test.md", "# Test")
+          setup_basic_config
+          create_template_directory("default")
+          
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "test.md")
+          
+          expect(result.success?).to be true
+          # Output should be minimal for successful operations
+          expect(result.stdout.length).to be < 100
+        end
+
+        it "provides detailed output in verbose mode" do
+          create_markdown_file("test.md", "# Test")
+          setup_basic_config
+          create_template_directory("default")
+          
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "--verbose", "test.md")
+          
+          # Verbose mode should provide more information
+          # This test depends on whether --verbose is implemented
+        end
+
+        it "formats template listings nicely" do
+          setup_basic_config
+          create_template_directory("template-one")
+          create_template_directory("template-two")
+          
+          result = run_command("ruby", "bin/mint", "templates")
+          
+          expect(result.success?).to be true
+          
+          # Should be formatted nicely, one per line
+          lines = result.stdout.split("\n").reject(&:empty?)
+          expect(lines.length).to be >= 2
+        end
+      end
+
+      describe "integration with system tools" do
+        it "can be used in shell pipelines" do
+          create_markdown_file("input.md", "# Pipeline Test")
+          setup_basic_config
+          create_template_directory("default")
+          
+          # Test that it works with shell redirection
+          result = run_command("bash", "-c", "MINT_NO_PIPE=1 ruby bin/mint publish input.md 2>&1")
+          
+          expect(result.success?).to be true
+          expect(File.exist?("input.html")).to be true
+        end
+
+        it "exits with appropriate status codes" do
+          # Success case
+          create_markdown_file("success.md", "# Success")
+          setup_basic_config
+          create_template_directory("default")
+          
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "success.md")
+          expect(result.exit_code).to eq(0)
+          
+          # Failure case
+          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "nonexistent.md")
+          expect(result.exit_code).not_to eq(0)
+        end
+      end
+    end
+  end
+end