mint 0.8.0 → 0.10.0

data/spec/config_file_integration_spec.rb

@@ -0,0 +1,362 @@
+require "spec_helper"
+
+RSpec.describe "Config File Integration" do
+  include CLIHelpers
+
+
+  describe "TOML config file support" do
+    context "with local config file" do
+      # Note: Tests run in tmp directory from spec_helper
+      
+      before do
+        FileUtils.mkdir_p(".mint") # Ensure directory exists for each test
+      end
+      
+      after do
+        cleanup_test_files("*.html", "*.css")
+        # Don't clean up .mint directory - let spec_helper handle it
+      end
+
+      it "loads template option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          template = "custom"
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.layout_name).to eq("custom")
+        expect(config.style_name).to eq("custom")
+      end
+
+      it "loads layout option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          layout = "minimal"
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.layout_name).to eq("minimal")
+      end
+
+      it "loads style option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          style = "dark"
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.style_name).to eq("dark")
+      end
+
+
+      it "loads output-file option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          output-file = "%{ext}_custom.%{ext}"
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.output_file_format).to eq("%{ext}_custom.%{ext}")
+      end
+
+      it "loads destination option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          destination = "build"
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.destination_directory).to eq(Pathname.new("build"))
+      end
+
+      it "loads style-mode option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          style-mode = "external"
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.style_mode).to eq(:external)
+      end
+
+      it "loads style-destination option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          style-destination = "assets/css"
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.style_destination_directory).to eq("assets/css")
+      end
+
+      it "loads preserve-structure option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          preserve-structure = true
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.preserve_structure).to be true
+      end
+
+      it "loads navigation option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          navigation = true
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.navigation).to be true
+      end
+
+
+      it "loads navigation-depth option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          navigation-depth = 5
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.navigation_depth).to eq(5)
+      end
+
+      it "loads navigation-title option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          navigation-title = "Custom Navigation"
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.navigation_title).to eq("Custom Navigation")
+      end
+
+      it "loads autodrop option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          autodrop = false
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.autodrop).to be false
+      end
+
+      it "loads insert-title-heading option from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          insert-title-heading = true
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.insert_title_heading).to be true
+      end
+
+      it "loads multiple options from config file" do
+        File.write(".mint/config.toml", <<~TOML)
+          template = "blog"
+          destination = "public"
+          style-mode = "external"
+          preserve-structure = true
+          navigation = true
+          navigation-depth = 2
+          insert-title-heading = true
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.layout_name).to eq("blog")
+        expect(config.style_name).to eq("blog")
+        expect(config.destination_directory).to eq(Pathname.new("public"))
+        expect(config.style_mode).to eq(:external)
+        expect(config.preserve_structure).to be true
+        expect(config.navigation).to be true
+        expect(config.navigation_depth).to eq(2)
+        expect(config.insert_title_heading).to be true
+      end
+
+      context "command-line options override config file" do
+        before do
+          File.write(".mint/config.toml", <<~TOML)
+            template = "config"
+            destination = "config-dest"
+            style-mode = "external"
+            preserve-structure = true
+            navigation-depth = 5
+          TOML
+        end
+
+        it "command-line template overrides config file template" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--template", "cli", "test.md"])
+          
+          expect(config.layout_name).to eq("cli")
+          expect(config.style_name).to eq("cli")
+        end
+
+        it "command-line layout overrides config file template layout" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--layout", "cli-layout", "test.md"])
+          
+          expect(config.layout_name).to eq("cli-layout")
+          expect(config.style_name).to eq("config") # should still use config for style
+        end
+
+        it "command-line destination overrides config file destination" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--destination", "cli-dest", "test.md"])
+          
+          expect(config.destination_directory).to eq(Pathname.new("cli-dest"))
+        end
+
+        it "command-line style-mode overrides config file style-mode" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--style-mode", "inline", "test.md"])
+          
+          expect(config.style_mode).to eq(:inline)
+        end
+
+        it "command-line preserve-structure overrides config file preserve-structure" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+          
+          expect(config.preserve_structure).to be true # from config
+        end
+
+        it "command-line navigation-depth overrides config file navigation-depth" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--navigation-depth", "3", "test.md"])
+          
+          expect(config.navigation_depth).to eq(3)
+        end
+      end
+
+      context "--no- flags override config file boolean values" do
+        before do
+          File.write(".mint/config.toml", <<~TOML)
+            preserve-structure = true
+            navigation = true
+            insert-title-heading = true
+          TOML
+        end
+
+        it "--no-preserve-structure overrides config file preserve-structure=true" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--no-preserve-structure", "test.md"])
+          
+          expect(config.preserve_structure).to be false
+        end
+
+        it "--no-navigation overrides config file navigation=true" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--no-navigation", "test.md"])
+          
+          expect(config.navigation).to be false
+        end
+
+        it "--no-insert-title-heading overrides config file insert-title-heading=true" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--no-insert-title-heading", "test.md"])
+          
+          expect(config.insert_title_heading).to be false
+        end
+
+        it "positive flags still work to override config file false values" do
+          File.write(".mint/config.toml", <<~TOML)
+            preserve-structure = false
+            navigation = false
+            insert-title-heading = false
+          TOML
+
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--preserve-structure", "--navigation", "--insert-title-heading", "test.md"])
+          
+          expect(config.preserve_structure).to be true
+          expect(config.navigation).to be true
+          expect(config.insert_title_heading).to be true
+        end
+
+        it "combines positive and negative flags" do
+          command, config, files, help = Mint::Commandline.parse!(["publish", "--preserve-structure", "--no-navigation", "test.md"])
+          
+          expect(config.preserve_structure).to be true  # overridden by CLI flag
+          expect(config.navigation).to be false         # overridden by --no- flag
+          expect(config.insert_title_heading).to be true          # from config file
+        end
+      end
+
+      it "handles boolean values correctly" do
+        File.write(".mint/config.toml", <<~TOML)
+          preserve-structure = false
+          navigation = false
+          insert-title-heading = false
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.preserve_structure).to be false
+        expect(config.navigation).to be false
+        expect(config.insert_title_heading).to be false
+      end
+
+      it "handles integer values correctly" do
+        File.write(".mint/config.toml", <<~TOML)
+          navigation-depth = 10
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.navigation_depth).to eq(10)
+      end
+
+      it "handles missing config file gracefully" do
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.layout_name).to eq("default")
+        expect(config.style_name).to eq("default")
+        expect(config.preserve_structure).to be true
+        expect(config.navigation).to be false
+      end
+
+      it "handles empty config file gracefully" do
+        File.write(".mint/config.toml", "")
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.layout_name).to eq("default")
+        expect(config.style_name).to eq("default")
+      end
+
+      it "handles config file with comments" do
+        File.write(".mint/config.toml", <<~TOML)
+          # This is a comment
+          template = "documented" # inline comment
+          
+          # Another section
+          destination = "output" # destination comment
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.layout_name).to eq("documented")
+        expect(config.style_name).to eq("documented")
+        expect(config.destination_directory).to eq(Pathname.new("output"))
+      end
+    end
+
+    context "config file scope priority" do
+      before do
+        FileUtils.mkdir_p(".mint")
+        FileUtils.mkdir_p(File.expand_path("~/.config/mint"))
+      end
+
+      after do
+        cleanup_test_files(".mint", File.expand_path("~/.config/mint/config.toml"))
+      end
+
+      it "local config overrides user config" do
+        File.write(File.expand_path("~/.config/mint/config.toml"), <<~TOML)
+          template = "user"
+          destination = "user-dest"
+        TOML
+        
+        File.write(".mint/config.toml", <<~TOML)
+          template = "local"
+        TOML
+
+        command, config, files, help = Mint::Commandline.parse!(["publish", "test.md"])
+        
+        expect(config.layout_name).to eq("local") # local overrides user
+        expect(config.destination_directory).to eq(Pathname.new("user-dest")) # user config still applies for non-overridden values
+      end
+    end
+  end
+end

data/spec/{css_spec.rb → css_dsl_spec.rb}

@@ -31,15 +31,19 @@ module Mint
           # "Bullet: checkbox.png"    => "li { list-style-image: url(checkbox.png) }",
         }
 
-        table.each do |human, machine|
-          CSS.stylify(*human.split(":").map(&:strip))
+        table.each do |human, expected|
+          key, value = human.split(":").map(&:strip)
+          actual = CSS.stylify(key, value)
+          expect(actual).to eq(expected), "Expected '#{human}' to produce '#{expected}', got '#{actual}'"
         end
       end
     end
 
     describe ".parse" do
       it "transforms a map of human-readable styles into a CSS string" do
-        expect(CSS.parse({ "Font" => "Helvetica" })).to eq("#container {\n  font-family: Helvetica;\n}") 
+        result = CSS.parse({ "Font" => "Helvetica" })
+        expect(result).to include("container")
+        expect(result).to include("font-family: Helvetica")
       end
     end
   end

data/spec/css_parser_spec.rb

@@ -0,0 +1,207 @@
+require "spec_helper"
+require "mint/css_parser"
+require "tempfile"
+require "pathname"
+
+describe Mint::CssParser do
+  describe ".extract_imports" do
+    it "extracts @import statements with double quotes" do
+      css = '@import "reset.css"; body { margin: 0; }'
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["reset.css"])
+    end
+
+    it "extracts @import statements with single quotes" do
+      css = "@import 'normalize.css'; .class { color: red; }"
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["normalize.css"])
+    end
+
+    it "extracts @import url() statements" do
+      css = '@import url("fonts.css"); @import url(\'colors.css\');'
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["fonts.css", "colors.css"])
+    end
+
+    it "extracts multiple @import statements" do
+      css = <<~CSS
+        @import "reset.css";
+        @import 'normalize.css';
+        @import url("fonts.css");
+        body { margin: 0; }
+      CSS
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["reset.css", "normalize.css", "fonts.css"])
+    end
+
+    it "returns empty array when no imports found" do
+      css = "body { margin: 0; color: blue; }"
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq([])
+    end
+
+    it "ignores commented out @import statements" do
+      css = <<~CSS
+        /* @import "commented.css"; */
+        @import "active.css";
+        body { 
+          /* @import url("also-commented.css"); */
+          margin: 0; 
+        }
+      CSS
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["active.css"])
+    end
+
+    it "ignores multi-line commented imports" do
+      css = <<~CSS
+        /*
+         * @import "multi-line-comment.css";
+         * @import 'another-commented.css';
+         */
+        @import "valid.css";
+      CSS
+      imports = Mint::CssParser.extract_imports(css)
+      expect(imports).to eq(["valid.css"])
+    end
+  end
+
+  describe ".resolve_css_files" do
+    let(:temp_dir) { Dir.mktmpdir }
+    
+    after do
+      FileUtils.rm_rf(temp_dir)
+    end
+
+    it "resolves main CSS file path relative to HTML output" do
+      # Create directory structure:
+      # temp_dir/
+      #   css/
+      #     main.css
+      #   output/
+      #     index.html (output file)
+      
+      css_dir = File.join(temp_dir, "css")
+      output_dir = File.join(temp_dir, "output")
+      FileUtils.mkdir_p([css_dir, output_dir])
+      
+      main_css = File.join(css_dir, "main.css")
+      html_output = File.join(output_dir, "index.html")
+      
+      File.write(main_css, "body { margin: 0; }")
+      
+      css_files = Mint::CssParser.resolve_css_files(main_css, html_output)
+      expect(css_files).to eq(["../css/main.css"])
+    end
+
+    it "resolves main CSS and imported files" do
+      # Create directory structure:
+      # temp_dir/
+      #   css/
+      #     main.css (imports reset.css)
+      #     reset.css
+      #   output/
+      #     index.html
+      
+      css_dir = File.join(temp_dir, "css")
+      output_dir = File.join(temp_dir, "output")
+      FileUtils.mkdir_p([css_dir, output_dir])
+      
+      main_css = File.join(css_dir, "main.css")
+      reset_css = File.join(css_dir, "reset.css")
+      html_output = File.join(output_dir, "index.html")
+      
+      File.write(main_css, '@import "reset.css"; body { margin: 0; }')
+      File.write(reset_css, "* { box-sizing: border-box; }")
+      
+      css_files = Mint::CssParser.resolve_css_files(main_css, html_output)
+      expect(css_files).to eq(["../css/reset.css", "../css/main.css"])
+    end
+
+    it "ignores non-existent imported files" do
+      css_dir = File.join(temp_dir, "css")
+      output_dir = File.join(temp_dir, "output")
+      FileUtils.mkdir_p([css_dir, output_dir])
+      
+      main_css = File.join(css_dir, "main.css")
+      html_output = File.join(output_dir, "index.html")
+      
+      File.write(main_css, '@import "nonexistent.css"; body { margin: 0; }')
+      
+      css_files = Mint::CssParser.resolve_css_files(main_css, html_output)
+      expect(css_files).to eq(["../css/main.css"])
+    end
+
+    it "only processes .css files" do
+      scss_dir = File.join(temp_dir, "scss")
+      output_dir = File.join(temp_dir, "output")
+      FileUtils.mkdir_p([scss_dir, output_dir])
+      
+      main_scss = File.join(scss_dir, "main.scss")
+      html_output = File.join(output_dir, "index.html")
+      
+      File.write(main_scss, '@import "reset"; body { margin: 0; }')
+      
+      css_files = Mint::CssParser.resolve_css_files(main_scss, html_output)
+      expect(css_files).to eq(["../scss/main.scss"])
+    end
+
+    it "places imported CSS files before main CSS file for correct cascade order" do
+      # Create directory structure:
+      # temp_dir/
+      #   css/
+      #     base.css (imports reset.css and fonts.css)
+      #     reset.css
+      #     fonts.css
+      #   output/
+      #     index.html
+      
+      css_dir = File.join(temp_dir, "css")
+      output_dir = File.join(temp_dir, "output")
+      FileUtils.mkdir_p([css_dir, output_dir])
+      
+      base_css = File.join(css_dir, "base.css")
+      reset_css = File.join(css_dir, "reset.css")
+      fonts_css = File.join(css_dir, "fonts.css")
+      html_output = File.join(output_dir, "index.html")
+      
+      File.write(base_css, '@import "reset.css"; @import "fonts.css"; body { margin: 0; }')
+      File.write(reset_css, "* { box-sizing: border-box; }")
+      File.write(fonts_css, "@font-face { font-family: 'MyFont'; }")
+      
+      css_files = Mint::CssParser.resolve_css_files(base_css, html_output)
+      
+      # Imports should come first, then the main file
+      expect(css_files).to eq([
+        "../css/reset.css",
+        "../css/fonts.css", 
+        "../css/base.css"
+      ])
+    end
+  end
+
+  describe ".generate_link_tags" do
+    it "generates HTML link tags for CSS files" do
+      css_paths = ["../css/main.css", "../css/reset.css"]
+      
+      html = Mint::CssParser.generate_link_tags(css_paths)
+      
+      expected = <<~HTML.strip
+        <link rel="stylesheet" href="../css/main.css">
+            <link rel="stylesheet" href="../css/reset.css">
+      HTML
+      
+      expect(html).to eq(expected)
+    end
+
+    it "handles empty array" do
+      html = Mint::CssParser.generate_link_tags([])
+      expect(html).to eq("")
+    end
+
+    it "handles single CSS file" do
+      html = Mint::CssParser.generate_link_tags(["styles.css"])
+      expect(html).to eq('<link rel="stylesheet" href="styles.css">')
+    end
+  end
+end