mint 0.8.0 → 0.10.0

data/spec/mint_spec.rb

@@ -1,242 +1,47 @@
 require "spec_helper"
 
 describe Mint do
-  subject { Mint }
-
-  describe "::ROOT" do
+  describe "::PROJECT_ROOT" do
     it "contains the root of the Mint gem as a string" do
-      expect(Mint::ROOT).to eq(File.expand_path("../..", __FILE__))
+      expect(Mint::PROJECT_ROOT).to eq(File.expand_path("../..", __FILE__))
     end
   end
 
-  describe ".path" do
-    def as_pathname(files)
-      files.map {|file| Pathname.new(file) }
-    end
-
+  describe "::PATH" do
     it "returns the paths corresponding to all scopes as an array" do
-      expect(Mint.path).to eq([Pathname.new(".mint"),
+      expect(Mint::PATH).to eq([Pathname.new(".mint"),
                                Pathname.new("~/.config/mint").expand_path,
-                               Pathname.new(Mint::ROOT + "/config").expand_path])
-    end
-
-    it "can filter paths by one scope" do
-      expect(Mint.path([:user])).to eq([Pathname.new("~/.config/mint").expand_path])
-    end
-
-    it "can filter paths by many scopes" do
-      expect(Mint.path([:local, :user])).to eq([Pathname.new(".mint"),
-                                                Pathname.new("~/.config/mint").expand_path])
+                               Pathname.new(Mint::PROJECT_ROOT + "/config").expand_path])
     end
   end
 
-
   describe ".configuration" do
-    let(:defaults) do
-      {
-        root: Dir.getwd,
-        destination: nil,
-        style_mode: :inline,
-        style_destination: nil,
-        output_file: '#{basename}.#{new_extension}',
-        layout_or_style_or_template: [:template, 'default'],
-        scope: :local,
-        recursive: false,
-        verbose: false
-      }
-    end
-
-    context "when there is no config.yaml file on the Mint path" do
-      it "returns a default set of options" do
-        expect(Mint.configuration).to eq(defaults)
+    context "when there is no config.toml file on the Mint path" do
+      it "returns a default Config object" do
+        config = Mint.configuration
+        expect(config).to be_a(Mint::Config)
+        expect(config.layout_name).to eq('default')
+        expect(config.style_name).to eq('default')
+        expect(config.style_mode).to eq(:inline)
+        expect(config.output_file_format).to eq('%{name}.%{ext}')
       end
     end
 
-    context "when there is a config.yaml file on the Mint path" do
+    context "when there is a config.toml file on the Mint path" do
       before do
-        FileUtils.mkdir_p ".mint"
-        File.open(".mint/config.yaml", "w") do |file|
-          file << "layout: zen"
-        end
+        FileUtils.mkdir_p(".mint")
+        File.write(".mint/config.toml", "style = \"custom\"")
       end
 
       after do
-        FileUtils.rm_rf ".mint"
-      end
-
-      it "merges all specified options with precedence according to scope" do
-        expect(Mint.configuration[:layout]).to eq("zen")
-      end
-
-      it "can filter by scope (but always includes defaults)" do
-        expect(Mint.configuration(scopes: [:user])).to eq(defaults)
-      end
-    end
-  end
-
-  describe ".configuration_with" do
-    it "displays the sum of all configuration files with other options added" do
-      expect(Mint.configuration_with(local: true)).to eq({
-        root: Dir.getwd,
-        destination: nil,
-        style_mode: :inline,
-        style_destination: nil,
-        output_file: '#{basename}.#{new_extension}',
-        layout_or_style_or_template: [:template, 'default'],
-        scope: :local,
-        recursive: false,
-        verbose: false,
-        local: true
-      })
-    end
-  end
-
-  describe ".templates" do
-    it "returns local templates by default" do
-      # Note: Now defaults to local scope, will include global templates only if explicitly requested
-      expect(Mint.templates).to be_an(Array)
-    end
-
-    it "returns global templates when global scope is specified" do
-      expect(Mint.templates(:global)).to include(Mint::ROOT + "/config/templates/default")
-    end
-  end
-
-  describe ".formats" do
-    it "includes Markdown" do
-      expect(Mint.formats).to include("md")
-    end
-
-    it "includes Haml" do
-      expect(Mint.formats).to include("haml")
-    end
-  end
-
-  describe ".css_formats" do
-    it "includes Sass" do
-      expect(Mint.css_formats).to include("sass")
-    end
-  end
-
-  describe ".renderer" do
-    it "creates a valid renderer" do
-      expect(Mint.renderer(@content_file)).to respond_to(:render)
-    end
-  end
-
-  describe ".path_for_scope" do
-    it "chooses the appropriate path for scope" do
-      expectations = {
-        local: Pathname.new(".mint"),
-        user: Pathname.new("~/.config/mint").expand_path,
-        global: Pathname.new(Mint::ROOT + "/config").expand_path
-      }
-
-      expectations.each do |scope, path|
-        expect(Mint.path_for_scope(scope)).to eq(path)
+        FileUtils.rm_rf(".mint")
       end
-    end
-  end
-
-  # Refactored lookup methods for explicit parameter interface
-  describe ".lookup_template" do
-    it "returns template directory path by name" do
-      result = Mint.lookup_template("default")
-      expect(result.to_s).to include("templates/default")
-      expect(File.directory?(result)).to be true
-    end
-  end
-
-  describe ".lookup_layout" do
-    it "returns layout file path by template name" do
-      result = Mint.lookup_layout("default")
-      expect(result).to include("templates/default")
-      expect(result).to end_with("layout.erb")
-    end
-  end
-
-  describe ".lookup_style" do
-    it "returns style file path by template name" do
-      result = Mint.lookup_style("default")
-      expect(result).to include("templates/default")
-      expect(result).to end_with("style.css")
-    end
-  end
 
-  describe ".find_template" do
-    it "finds the correct template file by name and type" do
-      layout_file = Mint.find_template("default", :layout)
-      style_file = Mint.find_template("default", :style)
-      
-      expect(layout_file).to include("templates/default")
-      expect(layout_file).to end_with("layout.erb")
-      expect(style_file).to include("templates/default")
-      expect(style_file).to end_with("style.css")
-    end
-
-    it "determines if a file is a template file" do
-      actual_template = Mint.lookup_layout("default")
-      fake_template = "#{Mint::ROOT}/config/templates/default.css"
-      obvious_nontemplate = @dynamic_style_file
-
-      expect(Mint.template?(actual_template)).to be_truthy
-      expect(Mint.template?(fake_template)).to be_falsy
-      expect(Mint.template?(obvious_nontemplate)).to be_falsy
-    end
-  end
-
-  describe ".guess_name_from" do
-    it "properly guesses destination file names based on source file names" do
-      expect(Mint.guess_name_from("content.md")).to eq("content.html")
-      expect(Mint.guess_name_from("content.textile")).to eq("content.html")
-      expect(Mint.guess_name_from("layout.haml")).to eq("layout.html")
-      expect(Mint.guess_name_from("dynamic.sass")).to eq("dynamic.css")
-    end
-  end
-
-  describe ".destination_file_path and .style_destination_file_path" do
-    context "before it publishes a document" do
-      let(:document) { Mint::Document.new @content_file }
-      subject { document }
-
-      its(:destination_file_path) { should_not exist }
-      it "style destination file should not exist initially" do
-        # Clean up any existing style file first
-        FileUtils.rm_f(document.style_destination_file_path) if document.style_destination_file_path && File.exist?(document.style_destination_file_path)
-        expect(document.style_destination_file_path).not_to exist
+      it "merges config files with defaults" do
+        config = Mint.configuration
+        expect(config.style_name).to eq("custom")
+        expect(config.layout_name).to eq("default") # still has defaults
       end
     end
-
-    # These are copied from document_spec.rb. I eventually want to move
-    # to this non-OO style of publishing, and this is the transition
-    context "when it publishes a document" do
-      let(:document) { Mint::Document.new @content_file }
-      before { Mint.publish! document }
-      subject { document }
-
-      its(:destination_file_path) { should exist }
-      
-      it "creates style file only for external style mode" do
-        if document.style_mode == :external
-          expect(document.style_destination_file_path).to exist
-        else
-          expect(document.style_destination_file_path).not_to exist
-        end
-      end
-    end
-  end
-
-  describe ".template_path" do
-    it "returns template directory for given name and scope" do
-      expect(Mint.template_path("pro", :local)).to eq(Pathname.new(".mint/templates/pro"))
-    end
-
-    it "works with user scope" do
-      expect(Mint.template_path("pro", :user)).to eq(Pathname.new("~/.config/mint/templates/pro").expand_path)
-    end
-
-    it "works with global scope" do
-      expect(Mint.template_path("pro", :global)).to eq(Pathname.new("#{Mint::ROOT}/config/templates/pro"))
-    end
   end
-end
+end

data/spec/path_handling_spec.rb

@@ -0,0 +1,237 @@
+require "spec_helper"
+
+RSpec.describe "Path Handling in Workspace.publish!" 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 "relative path preservation (with preserve_structure: true)" do
+      it "preserves single-level directory structure" do
+        FileUtils.mkdir_p(["docs", "output"])
+        create_markdown_path("docs/readme.md", "# Documentation")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("output"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("docs/readme.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("output/docs/readme.html")).to be true
+        expect(File.exist?("output/readme.html")).to be false
+      end
+
+      it "preserves multi-level directory structure" do
+        FileUtils.mkdir_p(["src/guides/advanced", "build"])
+        create_markdown_path("src/guides/advanced/config.md", "# Advanced Configuration")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("build"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("src/guides/advanced/config.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("build/src/guides/advanced/config.html")).to be true
+        expect(File.exist?("build/config.html")).to be false
+      end
+
+      it "handles files in root directory" do
+        create_markdown_path("index.md", "# Home Page")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("site"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("index.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("site/index.html")).to be true
+      end
+
+      it "handles nested destination directories" do
+        FileUtils.mkdir_p("content")
+        create_markdown_path("content/about.md", "# About Us")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("public/website"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("content/about.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("public/website/content/about.html")).to be true
+        expect(Dir.exist?("public/website/content")).to be true
+      end
+    end
+
+    describe "complex directory structures" do
+      it "handles deeply nested source with shallow destination" do
+        FileUtils.mkdir_p(["project/src/docs/api/v1", "api-docs"])
+        create_markdown_path("project/src/docs/api/v1/users.md", "# Users API")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("api-docs"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("project/src/docs/api/v1/users.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("api-docs/project/src/docs/api/v1/users.html")).to be true
+      end
+
+      it "handles multiple files with different nesting levels" do
+        FileUtils.mkdir_p(["src", "src/components", "src/pages/admin", "build"])
+        
+        create_markdown_path("src/readme.md", "# Project README")
+        create_markdown_path("src/components/button.md", "# Button Component")  
+        create_markdown_path("src/pages/admin/dashboard.md", "# Admin Dashboard")
+        
+        files = [
+          "src/readme.md",
+          "src/components/button.md", 
+          "src/pages/admin/dashboard.md"
+        ]
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("build"), preserve_structure: true)
+        
+        workspace = Mint::Workspace.new(files.map {|f| Pathname.new(f) }, config)
+        workspace.publish!
+        
+        expect(File.exist?("build/readme.html")).to be true
+        expect(File.exist?("build/components/button.html")).to be true
+        expect(File.exist?("build/pages/admin/dashboard.html")).to be true
+      end
+    end
+
+    describe "edge cases" do
+      it "handles files with dots in directory names" do
+        FileUtils.mkdir_p(["v1.0/docs", "output"])
+        create_markdown_path("v1.0/docs/changelog.md", "# Changelog")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("output"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("v1.0/docs/changelog.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("output/v1.0/docs/changelog.html")).to be true
+      end
+
+      it "handles files with spaces in directory names" do
+        FileUtils.mkdir_p(["My Documents/Notes", "website"])
+        create_markdown_path("My Documents/Notes/ideas.md", "# Ideas")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("website"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("My Documents/Notes/ideas.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("website/My Documents/Notes/ideas.html")).to be true
+      end
+
+      it "handles symlinked directories" do
+        FileUtils.mkdir_p(["real-content", "output"])
+        create_markdown_path("real-content/page.md", "# Page")
+        
+        # Create symlink (skip if not supported)
+        begin
+          File.symlink("real-content", "linked-content")
+          
+          config = Mint::Config.with_defaults(destination_directory: Pathname.new("output"), preserve_structure: true)
+          workspace = Mint::Workspace.new([Pathname.new("linked-content/page.md")], config)
+          workspace.publish!
+          
+          expect(File.exist?("output/linked-content/page.html")).to be true
+        rescue NotImplementedError
+          skip "Symlinks not supported on this system"
+        end
+      end
+
+      it "handles current directory references" do
+        FileUtils.mkdir_p(["docs", "site"])
+        create_markdown_path("docs/manual.md", "# Manual")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("./site"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("./docs/manual.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("site/docs/manual.html")).to be true
+      end
+
+      it "handles parent directory references" do
+        FileUtils.mkdir_p(["project/content", "project/build", "output"])
+        create_markdown_path("project/content/info.md", "# Information")
+        
+        Dir.chdir("project") do
+          config = Mint::Config.with_defaults(destination_directory: Pathname.new("../output"), preserve_structure: true)
+          workspace = Mint::Workspace.new([Pathname.new("content/info.md")], config)
+          workspace.publish!
+        end
+        
+        expect(File.exist?("output/content/info.html")).to be true
+      end
+    end
+
+    describe "destination directory creation" do
+      it "creates missing destination directories automatically" do
+        create_markdown_path("test.md", "# Test")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("deeply/nested/output/dir"))
+        workspace = Mint::Workspace.new([Pathname.new("test.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("deeply/nested/output/dir/test.html")).to be true
+        expect(Dir.exist?("deeply/nested/output/dir")).to be true
+      end
+
+      it "creates missing intermediate directories for nested sources" do
+        FileUtils.mkdir_p("src/a/b/c")
+        create_markdown_path("src/a/b/c/deep.md", "# Deep File")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("output"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("src/a/b/c/deep.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("output/src/a/b/c/deep.html")).to be true
+        expect(Dir.exist?("output/src/a/b/c")).to be true
+      end
+    end
+
+    describe "path sanitization" do
+      it "preserves valid special characters in paths" do
+        FileUtils.mkdir_p(["docs-2023", "output"])
+        create_markdown_path("docs-2023/v1.0_final.md", "# Version 1.0")
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("output"), preserve_structure: true)
+        workspace = Mint::Workspace.new([Pathname.new("docs-2023/v1.0_final.md")], config)
+        workspace.publish!
+        
+        expect(File.exist?("output/docs-2023/v1.0_final.html")).to be true
+      end
+    end
+
+    describe "multiple file processing with paths" do
+      it "processes multiple files maintaining their relative structure" do
+        # Create a realistic project structure
+        FileUtils.mkdir_p([
+          "content/blog/2023", 
+          "content/docs/guides",
+          "content/pages",
+          "public"
+        ])
+        
+        files = [
+          "content/blog/2023/hello-world.md",
+          "content/docs/guides/getting-started.md", 
+          "content/docs/guides/advanced.md",
+          "content/pages/about.md",
+          "content/pages/contact.md"
+        ]
+        
+        files.each_with_index do |file, i|
+          create_markdown_path(file, "# Document #{i + 1}")
+        end
+        
+        config = Mint::Config.with_defaults(destination_directory: Pathname.new("public"), preserve_structure: true)
+        
+        workspace = Mint::Workspace.new(files.map {|f| Pathname.new(f) }, config)
+        workspace.publish!
+        
+        # Verify all files maintain their structure (with common "content" prefix dropped by autodrop)
+        expect(File.exist?("public/blog/2023/hello-world.html")).to be true
+        expect(File.exist?("public/docs/guides/getting-started.html")).to be true
+        expect(File.exist?("public/docs/guides/advanced.html")).to be true
+        expect(File.exist?("public/pages/about.html")).to be true
+        expect(File.exist?("public/pages/contact.html")).to be true
+      end
+    end
+  end
+end

data/spec/run_cli_tests.rb

@@ -81,7 +81,7 @@ if ARGV.length > 0
     puts "\nAvailable test suites:".yellow
     Dir.glob("spec/cli/*_spec.rb").each do |file|
       basename = File.basename(file, "_spec.rb")
-      puts "  - #{basename}"
+      puts "  - #{name}"
     end
     exit 1
   end

data/spec/spec_helper.rb

@@ -7,8 +7,8 @@ require_relative "support/cli_helpers"
 RSpec.configure do |config|
   config.before(:all) do
     @old_dir = Dir.getwd
-    FileUtils.mkdir_p "/tmp/mint-test"
-    @tmp_dir = File.realpath "/tmp/mint-test"
+    FileUtils.mkdir_p "./tmp/mint-test"
+    @tmp_dir = File.realpath "./tmp/mint-test"
 
     @content_file = "content.md"
     @content_file_2 = "content-2.md"
@@ -33,15 +33,8 @@ RSpec.configure do |config|
   end
 
   config.after(:each) do
-    ["content.html", ".mint/defaults.yaml"].map {|file| Pathname.new file }.
+    ["content.html", ".mint/config.toml"].map {|file| Pathname.new file }.
       select(&:exist?).
       each {|file| FileUtils.rm_rf file }
-
-    Mint.templates.
-      map {|template| Pathname.new(template) + "css" }.
-      select(&:exist?).
-      map(&:children).
-      flatten.
-      each {|cache| File.delete(cache) }
   end
 end

data/spec/style_spec.rb

@@ -1,69 +1,44 @@
 require "spec_helper"
 
-module Mint
-  describe Style do
-    context "when it's created from a static file" do
-      let(:style) { Style.new @static_style_file }
-      subject { style }
-
-      its(:destination) { is_expected.to be_nil }
-      its(:destination_file) { is_expected.to eq("#{@tmp_dir}/static.css") }
-
-      it { is_expected.to be_rendered }
-      it "'renders' itself verbatim" do
-        expect(style.render).to eq(File.read(@static_style_file))
-      end
+describe Mint::Style do
+  describe ".valid?" do
+    it "determines if a file is a valid stylesheet" do
+      expect(Mint::Style.valid?(Pathname.new("style.css"))).to be true
+      expect(Mint::Style.valid?(Pathname.new("other.css"))).to be false
     end
+  end
 
-    context "when it's created from a dynamic file" do
-      let(:style) { Style.new @dynamic_style_file }
-      subject { style }
-
-      its(:destination) { is_expected.to be_nil }
-      its(:destination_file) { is_expected.to eq("#{@tmp_dir}/dynamic.css") }
-
-      it { is_expected.to be_rendered }
-      it "renders itself from a templating language to CSS" do
-        expect(style.render.gsub("\n", " ").strip).to eq(
-          File.read(@static_style_file).gsub("\n", " ").strip)
+  describe ".find_by_name" do
+    it "returns style file path by template name" do
+      result = Mint::Style.find_by_name("default")
+      if result
+        expect(result).to be_a(Pathname)
+        expect(Mint::Style.valid?(result)).to be true
+      else
+        expect(result).to be_nil
       end
     end
+  end
 
-    context "when it's created with a specified destination" do
-      let(:style) { Style.new @static_style_file,
-                    :destination => "destination" }
-      subject { style }
-
-      its(:destination) { is_expected.to eq("destination") }
-      its(:destination_file) do
-        is_expected.to eq("#{@tmp_dir}/destination/static.css")
+  describe ".find_in_directory" do
+    it "finds style file in a specific directory" do
+      Dir.mktmpdir do |tmpdir|
+        template_dir = Pathname.new(tmpdir)
+        style_file = template_dir + "style.css"
+        style_file.write("body { color: black; }")
+        
+        result = Mint::Style.find_in_directory(template_dir)
+        expect(result).to eq(style_file)
+        expect(Mint::Style.valid?(result)).to be true
       end
     end
 
-    # TODO: Create local-scope templates directory that I can test this with,
-    # and use it to beef up other specs (like document_spec and mint_spec)
-    # context "when it's created from a static template file" do
-    #  let(:style) { Style.new(Mint.lookup_template(:static_test, :style)) }
-    #  it "#destination" do
-    #    style.destination.should be_nil
-    #  end
-
-    #  it "#destination_file" do
-    #    style.destination_file.should == 
-    #      Mint.path_for_scope(:local) + "/templates/static_test/style.css"
-    #  end
-    # end
-
-    context "when it's created from a dynamic template file" do
-      let(:style) { Style.new(Mint.lookup_style("default")) }
-      subject { style }
-
-      it "has destination in user tmp directory" do
-        expect(style.destination).to match(/\.config\/mint\/tmp$/)
-      end
-      it "has destination file in user tmp directory" do  
-        expect(style.destination_file).to match(/\.config\/mint\/tmp\/style\.css$/)
+    it "returns nil when no style file exists" do
+      Dir.mktmpdir do |tmpdir|
+        template_dir = Pathname.new(tmpdir)
+        result = Mint::Style.find_in_directory(template_dir)
+        expect(result).to be_nil
       end
     end
   end
-end
+end

data/spec/support/cli_helpers.rb

@@ -52,7 +52,7 @@ module CLIHelpers
   end
 
   # Create a sample markdown file with content
-  def create_markdown_file(name = "test.md", content = "# Test\n\nHello world!")
+  def create_markdown_path(name = "test.md", content = "# Test\n\nHello world!")
     File.write(name, content)
     name
   end
@@ -114,19 +114,16 @@ module CLIHelpers
     config_dir = case scope
                  when :local then ".mint"
                  when :user then File.expand_path("~/.config/mint") 
-                 when :global then "#{Mint::ROOT}/config"
+                 when :global then "#{Mint::PROJECT_ROOT}/config"
                  end
     
     FileUtils.mkdir_p(config_dir)
-    config_file = "#{config_dir}/config.yaml"
+    config_file = "#{config_dir}/config.toml"
     
-    basic_config = {
-      'layout' => 'default',
-      'style' => 'default',
-      'destination' => nil
-    }
-    
-    File.write(config_file, basic_config.to_yaml)
+    File.write(config_file, <<~TOML)
+      layout = "default"
+      style = "default"
+    TOML
     config_file
   end