mint 0.8.1 → 0.10.0

data/spec/cli/argument_parsing_spec.rb

@@ -1,237 +1,179 @@
 require "spec_helper"
 
 RSpec.describe "CLI Argument Parsing" do
-  describe "Mint::CommandLine.parse" do
+  describe "Mint::Commandline.parse!" do
     context "with no arguments" do
-      it "returns default options and empty argv" do
-        result = Mint::CommandLine.parse([])
+      it "returns nil command and default config" do
+        command, config, files, help = 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")
+        expect(command).to be_nil
+        expect(config.working_directory).to be_a(Pathname)
+        expect(config.layout_name).to eq('default')
+        expect(config.style_name).to eq('default')
+        expect(files).to eq([])
+        expect(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"])
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--template", "basic", "file.md"])
         
-        expect(result[:argv]).to eq(["file.md"])
-        expect(result[:options][:layout_or_style_or_template]).to eq([:template, "zen"])
+        expect(command).to eq("publish")
+        expect(config.layout_name).to eq("basic")
+        expect(config.style_name).to eq("basic")
+        expect(files.map(&:basename).map(&:to_s)).to include("file.md")
       end
 
       it "parses --layout option" do
-        result = Mint::CommandLine.parse(["--layout", "custom", "file.md"])
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--layout", "custom", "file.md"])
         
-        expect(result[:argv]).to eq(["file.md"])
-        expect(result[:options][:layout_or_style_or_template]).to eq([:layout, "custom"])
+        expect(command).to eq("publish")
+        expect(config.layout_name).to eq("custom")
+        expect(files.map(&:basename).map(&:to_s)).to include("file.md")
       end
 
       it "parses -l option for layout" do
-        result = Mint::CommandLine.parse(["-l", "custom", "file.md"])
+        command, config, files, help = Mint::Commandline.parse!(["publish", "-l", "custom", "file.md"])
         
-        expect(result[:argv]).to eq(["file.md"])
-        expect(result[:options][:layout_or_style_or_template]).to eq([:layout, "custom"])
+        expect(command).to eq("publish")
+        expect(config.layout_name).to eq("custom")
       end
 
       it "parses --style option" do
-        result = Mint::CommandLine.parse(["--style", "minimal", "file.md"])
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--style", "minimal", "file.md"])
         
-        expect(result[:argv]).to eq(["file.md"])
-        expect(result[:options][:layout_or_style_or_template]).to eq([:style, "minimal"])
+        expect(command).to eq("publish")
+        expect(config.style_name).to eq("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"])
+        command, config, files, help = Mint::Commandline.parse!(["publish", "-t", "pro", "file.md"])
+        
+        expect(command).to eq("publish")
+        expect(config.layout_name).to eq("pro")
+        expect(config.style_name).to eq("pro")
       end
     end
 
     context "with path options" do
-      it "parses --root option" do
-        result = Mint::CommandLine.parse(["--root", "/custom/path", "file.md"])
+      it "parses --working-dir option" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--working-dir", "/custom/path", "file.md"])
         
-        expect(result[:options][:root]).to eq("/custom/path")
+        expect(config.working_directory).to eq(Pathname.new("/custom/path"))
       end
 
       it "parses --destination option" do
-        result = Mint::CommandLine.parse(["--destination", "output", "file.md"])
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--destination", "output", "file.md"])
         
-        expect(result[:options][:destination]).to eq("output")
+        expect(config.destination_directory).to eq(Pathname.new("output"))
       end
 
       it "parses --style-destination option" do
-        result = Mint::CommandLine.parse(["--style-destination", "css", "file.md"])
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--style-destination", "css", "file.md"])
         
-        expect(result[:options][:style_destination]).to eq("css")
+        expect(config.style_mode).to eq(:external)
+        expect(config.style_destination_directory).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"])
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--output-file", "%{name}_custom.%{ext}", "file.md"])
         
-        expect(result[:options][:output_file]).to eq("custom.html")
+        expect(config.output_file_format).to eq("%{name}_custom.%{ext}")
       end
 
       it "has default output file format" do
-        result = Mint::CommandLine.parse(["file.md"])
+        command, config, files, help = Mint::Commandline.parse!(["publish", "file.md"])
         
-        expect(result[:options][:output_file]).to eq('#{basename}.#{new_extension}')
+        expect(config.output_file_format).to eq("%{name}.%{ext}")
       end
     end
 
-    context "with scope options" do
-      it "parses --global scope" do
-        result = Mint::CommandLine.parse(["--global", "file.md"])
+    context "with style mode options" do
+      it "parses --style-mode inline" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--style-mode", "inline", "file.md"])
         
-        expect(result[:options][:scope]).to eq(:global)
+        expect(config.style_mode).to eq(:inline)
       end
 
-      it "parses --user scope" do
-        result = Mint::CommandLine.parse(["--user", "file.md"])
+      it "parses --style-mode external" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--style-mode", "external", "file.md"])
         
-        expect(result[:options][:scope]).to eq(:user)
+        expect(config.style_mode).to eq(:external)
       end
+    end
 
-      it "parses --local scope (default)" do
-        result = Mint::CommandLine.parse(["--local", "file.md"])
+    context "with file handling" do
+      it "processes multiple files" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "file1.md", "file2.md", "file3.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)
+        expect(files.length).to eq(3)
+        expect(files.map(&:basename).map(&:to_s)).to eq(["file1.md", "file2.md", "file3.md"])
       end
     end
 
-    context "with boolean flags" do
-      it "parses --recursive flag" do
-        result = Mint::CommandLine.parse(["--recursive"])
+    context "style destination behavior" do
+      it "automatically sets external mode when style-destination is used" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--style-destination", "css", "file.md"])
         
-        expect(result[:options][:recursive]).to be true
+        expect(config.style_mode).to eq(:external)
+        expect(config.style_destination_directory).to eq("css")
       end
+    end
 
-      it "handles short recursive flag" do
-        result = Mint::CommandLine.parse(["-r"])
+    context "boolean flags" do
+      it "parses --preserve-structure flag" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--preserve-structure", "file.md"])
         
-        expect(result[:options][:recursive]).to be true
+        expect(config.preserve_structure).to be true
       end
 
-      it "defaults recursive to false" do
-        result = Mint::CommandLine.parse([])
+      it "parses --navigation flag" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--navigation", "file.md"])
         
-        expect(result[:options][:recursive]).to be false
+        expect(config.navigation).to be true
       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)
+      it "parses --insert-title-heading flag" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--insert-title-heading", "file.md"])
+        
+        expect(config.insert_title_heading).to be true
       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
+      it "parses --autodrop flag" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--autodrop", "file.md"])
+        
+        expect(config.autodrop).to be true
       end
     end
 
-    context "with style mode options" do
-      it "parses --style-mode inline" do
-        result = Mint::CommandLine.parse(["--style-mode", "inline", "file.md"])
+    context "negative boolean flags" do
+      it "parses --no-preserve-structure flag" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--no-preserve-structure", "file.md"])
         
-        expect(result[:options][:style_mode]).to eq(:inline)
+        expect(config.preserve_structure).to be false
       end
 
-      it "parses --style-mode external" do
-        result = Mint::CommandLine.parse(["--style-mode", "external", "file.md"])
+      it "parses --no-navigation flag" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--no-navigation", "file.md"])
         
-        expect(result[:options][:style_mode]).to eq(:external)
+        expect(config.navigation).to be false
       end
 
-      it "parses --style-mode original" do
-        result = Mint::CommandLine.parse(["--style-mode", "original", "file.md"])
+      it "parses --no-insert-title-heading flag" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--no-insert-title-heading", "file.md"])
         
-        expect(result[:options][:style_mode]).to eq(:original)
+        expect(config.insert_title_heading).to be false
       end
 
-      it "defaults to inline style mode" do
-        result = Mint::CommandLine.parse(["file.md"])
+      it "parses --no-autodrop flag" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "--no-autodrop", "file.md"])
         
-        expect(result[:options][:style_mode]).to eq(:inline)
+        expect(config.autodrop).to be false
       end
     end
+    
   end
 end

data/spec/cli/bin_integration_spec.rb

@@ -35,39 +35,29 @@ RSpec.describe "Bin Script Integration" do
           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")
+          create_markdown_path("test.md", "# Hello CLI\n\nThis works!")
           
-          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "test.md")
+          result = run_command({}, "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")
+          expect(content).to include("<h1>Hello CLI</h1>")
+          expect(content).to include("<p>This works!</p>")
         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")
+          create_markdown_path("doc1.md", "# Document 1")
+          create_markdown_path("doc2.md", "# Document 2")
           
-          result = run_command({"MINT_NO_PIPE" => "1"}, "ruby", "bin/mint", "publish", "doc1.md", "doc2.md")
+          result = run_command({}, "ruby", "bin/mint", "publish", "doc1.md", "doc2.md")
           
           expect(result.success?).to be true
           expect(File.exist?("doc1.html")).to be true
@@ -75,138 +65,15 @@ RSpec.describe "Bin Script Integration" do
         end
 
         it "respects template options" do
-          create_markdown_file("styled.md", "# Styled Document")
-          setup_basic_config
           create_template_directory("default")
           create_template_directory("custom")
+          create_markdown_path("styled.md", "# Custom Style")
           
-          # 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")
+          result = run_command({}, "ruby", "bin/mint", "publish", "--template", "custom", "styled.md")
           
+          # Should succeed even if template doesn't exist (will use default)
           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
 
@@ -215,7 +82,7 @@ RSpec.describe "Bin Script Integration" do
           result = run_command("ruby", "bin/mint", "unknown-command")
           
           expect(result.success?).to be false
-          expect(result.stderr + result.stdout).to match(/error|Usage/)
+          expect(result.stderr).to include("Unknown command")
         end
 
         it "handles malformed arguments" do
@@ -225,122 +92,35 @@ RSpec.describe "Bin Script Integration" do
         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")
+          result = run_command("ruby", "bin/mint", "unknown-command")
           
-          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")
+          expect(result.stderr).to include("Error:")
         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")
+          create_markdown_path("test.md", "# Test")
           
-          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")
+          result = run_command({}, "ruby", "bin/mint", "publish", "test.md")
           
           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
+          # Should not have excessive debug output
+          expect(result.stdout.lines.length).to be < 10
         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")
+          create_markdown_path("success.md", "# Success")
           
-          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)
+          success_result = run_command({}, "ruby", "bin/mint", "publish", "success.md")
+          expect(success_result.exit_code).to eq(0)
+
+          failure_result = run_command({}, "ruby", "bin/mint", "publish", "nonexistent.md")
+          expect(failure_result.exit_code).not_to eq(0)
         end
       end
     end