RubyGems - mint - Versions diffs - 0.7.4 → 0.8.0 - Mend

mint 0.7.4 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (71) hide show

checksums.yaml +7 -0
data/Gemfile +23 -14
data/LICENSE +22 -0
data/README.md +82 -56
data/bin/mint +47 -10
data/bin/mint-epub +1 -4
data/config/templates/base/style.css +187 -0
data/config/templates/default/css/style.css +126 -79
data/config/templates/default/layout.erb +10 -0
data/config/templates/default/style.css +237 -0
data/config/templates/garden/layout.erb +38 -0
data/config/templates/garden/style.css +303 -0
data/config/templates/newspaper/layout.erb +16 -0
data/config/templates/nord/layout.erb +11 -0
data/config/templates/nord/style.css +339 -0
data/config/templates/nord-dark/layout.erb +11 -0
data/config/templates/nord-dark/style.css +339 -0
data/config/templates/protocol/layout.erb +9 -0
data/config/templates/protocol/style.css +25 -0
data/config/templates/zen/layout.erb +11 -0
data/config/templates/zen/style.css +114 -0
data/lib/mint/command_line.rb +253 -111
data/lib/mint/css.rb +11 -4
data/lib/mint/css_template.rb +37 -0
data/lib/mint/document.rb +185 -43
data/lib/mint/helpers.rb +50 -10
data/lib/mint/layout.rb +2 -3
data/lib/mint/markdown_template.rb +47 -0
data/lib/mint/mint.rb +181 -114
data/lib/mint/plugin.rb +3 -3
data/lib/mint/plugins/epub.rb +1 -2
data/lib/mint/resource.rb +19 -9
data/lib/mint/style.rb +10 -14
data/lib/mint/version.rb +1 -1
data/lib/mint.rb +1 -0
data/man/mint.1 +135 -0
data/spec/cli/README.md +99 -0
data/spec/cli/argument_parsing_spec.rb +207 -0
data/spec/cli/bin_integration_spec.rb +348 -0
data/spec/cli/configuration_management_spec.rb +363 -0
data/spec/cli/full_workflow_integration_spec.rb +527 -0
data/spec/cli/publish_workflow_spec.rb +368 -0
data/spec/cli/template_management_spec.rb +300 -0
data/spec/css_spec.rb +1 -1
data/spec/document_spec.rb +102 -69
data/spec/helpers_spec.rb +42 -42
data/spec/mint_spec.rb +104 -80
data/spec/plugin_spec.rb +86 -88
data/spec/run_cli_tests.rb +95 -0
data/spec/spec_helper.rb +8 -1
data/spec/style_spec.rb +18 -16
data/spec/support/cli_helpers.rb +169 -0
data/spec/support/fixtures/content-2.md +16 -0
data/spec/support/matchers.rb +1 -1
metadata +116 -223
data/config/syntax.yaml +0 -71
data/config/templates/base/style.sass +0 -144
data/config/templates/default/layout.haml +0 -8
data/config/templates/default/style.sass +0 -36
data/config/templates/protocol/layout.haml +0 -7
data/config/templates/protocol/style.sass +0 -20
data/config/templates/zen/css/style.css +0 -145
data/config/templates/zen/layout.haml +0 -7
data/config/templates/zen/style.sass +0 -24
data/features/config.feature +0 -21
data/features/plugins/epub.feature +0 -23
data/features/publish.feature +0 -73
data/features/support/env.rb +0 -15
data/features/templates.feature +0 -79
data/spec/command_line_spec.rb +0 -87
data/spec/plugins/epub_spec.rb +0 -242

data/spec/cli/publish_workflow_spec.rb ADDED Viewed

@@ -0,0 +1,368 @@
+require "spec_helper"
+RSpec.describe "CLI Publishing Workflow" do
+  describe "Mint::CommandLine.publish!" do
+    context "in isolated environment" do
+      around(:each) do |example|
+        in_temp_dir do |dir|
+          @test_dir = dir
+          setup_basic_config
+          create_template_directory("default")
+          example.run
+        end
+      end
+      describe "basic publishing" do
+        it "publishes a single markdown file" do
+          markdown_file = create_markdown_file("test.md", "# Hello World\n\nThis is a test.")
+          expect {
+            Mint::CommandLine.publish!([markdown_file], {})
+          }.not_to raise_error
+          verify_file_content("test.html") do |content|
+            expect(content).to include("<h1>Hello World</h1>")
+            expect(content).to include("<p>This is a test.</p>")
+          end
+        end
+        it "publishes multiple markdown files" do
+          file1 = create_markdown_file("doc1.md", "# Document 1")
+          file2 = create_markdown_file("doc2.md", "# Document 2")
+          expect {
+            Mint::CommandLine.publish!([file1, file2], {})
+          }.not_to raise_error
+          verify_file_content("doc1.html") do |content|
+            expect(content).to include("<h1>Document 1</h1>")
+          end
+          verify_file_content("doc2.html") do |content|
+            expect(content).to include("<h1>Document 2</h1>")
+          end
+        end
+        it "uses default template when none specified" do
+          markdown_file = create_markdown_file("test.md", "# Test")
+          Mint::CommandLine.publish!([markdown_file], {})
+          verify_file_content("test.html") do |content|
+            expect(content).to include("<!DOCTYPE html>")
+            expect(content).to include("<html>")
+            expect(content).to include("</html>")
+          end
+        end
+      end
+      describe "with custom options" do
+        it "publishes with custom destination" do
+          markdown_file = create_markdown_file("test.md", "# Test")
+          FileUtils.mkdir_p("output")
+          Mint::CommandLine.publish!([markdown_file], { destination: "output" })
+          expect(File.exist?("output/test.html")).to be true
+          expect(File.exist?("test.html")).to be false
+        end
+        it "publishes with custom root directory" do
+          # Create a subdirectory structure
+          FileUtils.mkdir_p("docs")
+          Dir.chdir("docs") do
+            create_markdown_file("readme.md", "# Documentation")
+          end
+          # Publish from parent directory with current directory as root
+          Mint::CommandLine.publish!(["docs/readme.md"], { root: Dir.getwd })
+          expect(File.exist?("docs/readme.html")).to be true
+        end
+        it "uses custom template" do
+          create_template_directory("custom", with_layout: true, with_style: true)
+          File.write(".mint/templates/custom/layout.erb",
+            "<html><body class='custom'><%= content %></body></html>")
+          markdown_file = create_markdown_file("test.md", "# Test")
+          Mint::CommandLine.publish!([markdown_file], { layout: "custom" })
+          verify_file_content("test.html") do |content|
+            expect(content).to include("class='custom'")
+          end
+        end
+        it "applies custom style template" do
+          create_template_directory("styled", with_layout: true, with_style: true)
+          File.write(".mint/templates/styled/style.css",
+            "body { background: red; }")
+          markdown_file = create_markdown_file("test.md", "# Test")
+          Mint::CommandLine.publish!([markdown_file], { style: "styled" })
+          # Check if style file was created and linked
+          expect(File.exist?("test.html")).to be true
+          # Style files are typically processed to a temp directory
+        end
+      end
+      describe "recursive publishing" do
+        it "discovers and publishes markdown files recursively" do
+          # Create nested directory structure with markdown files
+          FileUtils.mkdir_p("docs/section1")
+          FileUtils.mkdir_p("docs/section2")
+          create_markdown_file("docs/index.md", "# Main Documentation")
+          create_markdown_file("docs/section1/intro.md", "# Introduction")
+          create_markdown_file("docs/section2/advanced.md", "# Advanced Topics")
+          # Also create non-markdown files that should be ignored
+          File.write("docs/config.yaml", "key: value")
+          File.write("docs/section1/script.js", "console.log('test');")
+          Mint::CommandLine.publish!(["docs"], { recursive: true })
+          expect(File.exist?("docs/index.html")).to be true
+          expect(File.exist?("docs/section1/intro.html")).to be true
+          expect(File.exist?("docs/section2/advanced.html")).to be true
+          # Non-markdown files should not be converted
+          expect(File.exist?("docs/config.html")).to be false
+          expect(File.exist?("docs/section1/script.html")).to be false
+        end
+        it "handles empty directories gracefully" do
+          FileUtils.mkdir_p("empty/nested/dirs")
+          expect {
+            Mint::CommandLine.publish!(["empty"], { recursive: true })
+          }.not_to raise_error
+        end
+        it "processes current directory when no files specified" do
+          create_markdown_file("current.md", "# Current Directory")
+          FileUtils.mkdir_p("sub")
+          create_markdown_file("sub/nested.md", "# Nested File")
+          Mint::CommandLine.publish!([], { recursive: true })
+          expect(File.exist?("current.html")).to be true
+          expect(File.exist?("sub/nested.html")).to be true
+        end
+      end
+      describe "file discovery" do
+        it "recognizes various markdown extensions" do
+          # Create files with different markdown extensions
+          extensions = %w[md markdown mkd]
+          extensions.each_with_index do |ext, i|
+            create_markdown_file("test#{i}.#{ext}", "# Test #{i}")
+          end
+          files = extensions.map.with_index {|ext, i| "test#{i}.#{ext}" }
+          Mint::CommandLine.publish!(files, {})
+          extensions.each_with_index do |ext, i|
+            expect(File.exist?("test#{i}.html")).to be true
+          end
+        end
+        it "processes files with complex content" do
+          complex_content = <<~MARKDOWN
+            # Main Title
+            ## Subtitle
+            This is a paragraph with **bold** and *italic* text.
+            - List item 1
+            - List item 2
+            - List item 3
+            ```ruby
+            def hello
+              puts "Hello, World!"
+            end
+            ```
+            | Column 1 | Column 2 |
+            |----------|----------|
+            | Cell 1   | Cell 2   |
+            | Cell 3   | Cell 4   |
+            [Link to example](https://example.com)
+          MARKDOWN
+          create_markdown_file("complex.md", complex_content)
+          Mint::CommandLine.publish!(["complex.md"], {})
+          verify_file_content("complex.html") do |content|
+            expect(content).to include("<h1>Main Title</h1>")
+            expect(content).to include("<h2>Subtitle</h2>")
+            expect(content).to include("<strong>bold</strong>")
+            expect(content).to include("<em>italic</em>")
+            expect(content).to include("<ul>")
+            expect(content).to include("<code")
+            expect(content).to include("href=\"https://example.com\"")
+          end
+        end
+      end
+      describe "error handling" do
+        it "handles missing source files gracefully" do
+          expect {
+            Mint::CommandLine.publish!(["nonexistent.md"], {})
+          }.to raise_error(Errno::ENOENT) # Should raise an error for missing file
+        end
+        it "handles permission errors" do
+          # Create a file, then make directory read-only
+          markdown_file = create_markdown_file("test.md", "# Test")
+          # Try to publish to a non-writable location
+          # This test might be platform-specific
+          expect {
+            Mint::CommandLine.publish!([markdown_file], { destination: "/root" })
+          }.to raise_error(Errno::EROFS) # Should fail due to permissions
+        end
+        it "handles invalid templates gracefully" do
+          markdown_file = create_markdown_file("test.md", "# Test")
+          expect {
+            Mint::CommandLine.publish!([markdown_file], { layout: "nonexistent" })
+          }.to raise_error(Mint::TemplateNotFoundException)
+        end
+      end
+      describe "output file naming" do
+        it "preserves directory structure in output" do
+          FileUtils.mkdir_p("input/subdir")
+          create_markdown_file("input/subdir/doc.md", "# Nested Document")
+          Mint::CommandLine.publish!(["input/subdir/doc.md"], {})
+          expect(File.exist?("input/subdir/doc.html")).to be true
+        end
+        it "handles files with no extension" do
+          File.write("README", "# Readme\n\nThis is a readme file.")
+          # This might fail if README is not recognized as markdown
+          # The behavior depends on how Mint determines file types
+        end
+        it "overwrites existing output files" do
+          markdown_file = create_markdown_file("test.md", "# Version 1")
+          File.write("test.html", "<html>Old content</html>")
+          Mint::CommandLine.publish!([markdown_file], {})
+          verify_file_content("test.html") do |content|
+            expect(content).to include("Version 1")
+            expect(content).not_to include("Old content")
+          end
+        end
+      end
+      describe "configuration integration" do
+        it "respects configuration file settings" do
+          # Create custom config
+          config_content = {
+            'layout' => 'custom',
+            'style' => 'minimal',
+            'destination' => 'build'
+          }
+          File.write(".mint/config.yaml", config_content.to_yaml)
+          # Create the referenced templates
+          create_template_directory("custom")
+          create_template_directory("minimal")
+          FileUtils.mkdir_p("build")
+          markdown_file = create_markdown_file("test.md", "# Test")
+          Mint::CommandLine.publish!([markdown_file], {})
+          expect(File.exist?("build/test.html")).to be true
+        end
+        it "allows command-line options to override config" do
+          # Set config with default destination
+          config_content = { 'destination' => 'config_output' }
+          File.write(".mint/config.yaml", config_content.to_yaml)
+          FileUtils.mkdir_p("cli_output")
+          markdown_file = create_markdown_file("test.md", "# Test")
+          # Override with CLI option
+          Mint::CommandLine.publish!([markdown_file], { destination: "cli_output" })
+          expect(File.exist?("cli_output/test.html")).to be true
+          expect(File.exist?("config_output/test.html")).to be false
+        end
+      end
+      describe "multi-file processing" do
+        it "processes multiple files efficiently" do
+          files = []
+          10.times do |i|
+            files << create_markdown_file("doc#{i}.md", "# Document #{i}")
+          end
+          start_time = Time.now
+          Mint::CommandLine.publish!(files, {})
+          end_time = Time.now
+          # All files should be processed
+          10.times do |i|
+            expect(File.exist?("doc#{i}.html")).to be true
+          end
+          # Should complete in reasonable time (this is somewhat arbitrary)
+          expect(end_time - start_time).to be < 5.0
+        end
+        it "passes file list to templates for navigation" do
+          # This tests the all_files feature for multi-file processing
+          files = []
+          3.times do |i|
+            files << create_markdown_file("page#{i}.md", "# Page #{i}")
+          end
+          # Create a template that uses the all_files variable
+          nav_template = <<~ERB
+            <html>
+            <body>
+              <nav>
+                <% if files && files.any? %>
+                  <% files.each do |file| %>
+                    <a href="<%= file[:html_path] %>"><%= file[:title] %></a>
+                  <% end %>
+                <% end %>
+              </nav>
+              <%= content %>
+            </body>
+            </html>
+          ERB
+          FileUtils.mkdir_p(".mint/templates/nav")
+          File.write(".mint/templates/nav/layout.erb", nav_template)
+          Mint::CommandLine.publish!(files, { layout: "nav" })
+          # Check that navigation was included
+          verify_file_content("page0.html") do |content|
+            expect(content).to include("<nav>")
+            expect(content).to include("Page 1")
+            expect(content).to include("Page 2")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cli/template_management_spec.rb ADDED Viewed

@@ -0,0 +1,300 @@
+require "spec_helper"
+RSpec.describe "CLI Template Management" do
+  describe "template operations" do
+    context "in isolated environment" do
+      around(:each) do |example|
+        in_temp_dir do |dir|
+          @test_dir = dir
+          example.run
+        end
+      end
+      describe "Mint::CommandLine.templates" do
+        it "lists templates from specified scope" do
+          create_template_directory("custom")
+          create_template_directory("minimal")
+          stdout, stderr = capture_output do
+            Mint::CommandLine.templates("", :local)
+          end
+          expect(stdout).to include("custom")
+          expect(stdout).to include("minimal")
+        end
+        it "filters templates by pattern" do
+          create_template_directory("custom-dark")
+          create_template_directory("custom-light")
+          create_template_directory("minimal")
+          stdout, stderr = capture_output do
+            Mint::CommandLine.templates("custom", :local)
+          end
+          expect(stdout).to include("custom-dark")
+          expect(stdout).to include("custom-light")
+          expect(stdout).not_to include("minimal")
+        end
+        it "shows template paths in output" do
+          create_template_directory("test-template")
+          stdout, stderr = capture_output do
+            Mint::CommandLine.templates("", :local)
+          end
+          expect(stdout).to include("test-template")
+          expect(stdout).to include(".mint/templates/test-template")
+        end
+        it "handles empty template directory" do
+          stdout, stderr = capture_output do
+            Mint::CommandLine.templates("", :local)
+          end
+          expect(stdout.strip).to eq("")
+        end
+      end
+      describe "Mint::CommandLine.install" do
+        it "installs a layout template file" do
+          layout_content = "<html><body><%= yield %></body></html>"
+          create_template_file("custom.erb", :layout, layout_content)
+          expect {
+            Mint::CommandLine.install("custom.erb", "mytemplate", :local)
+          }.not_to raise_error
+          installed_file = ".mint/templates/mytemplate/layout.erb"
+          expect(File.exist?(installed_file)).to be true
+          expect(File.read(installed_file)).to eq(layout_content)
+        end
+        it "installs a style template file" do
+          style_content = "body { background: #f0f0f0; }"
+          create_template_file("custom.css", :style, style_content)
+          expect {
+            Mint::CommandLine.install("custom.css", "mystyle", :local)
+          }.not_to raise_error
+          installed_file = ".mint/templates/mystyle/style.css"
+          expect(File.exist?(installed_file)).to be true
+          expect(File.read(installed_file)).to eq(style_content)
+        end
+        it "creates template directory if it doesn't exist" do
+          create_template_file("layout.erb", :layout)
+          expect(File.exist?(".mint/templates/newtemplate")).to be false
+          Mint::CommandLine.install("layout.erb", "newtemplate", :local)
+          expect(File.exist?(".mint/templates/newtemplate")).to be true
+          expect(File.exist?(".mint/templates/newtemplate/layout.erb")).to be true
+        end
+        it "determines template type by file extension" do
+          # Create different file types
+          File.write("layout.haml", "%html\n  %body= yield")
+          File.write("style.scss", "$primary: #333;\nbody { color: $primary; }")
+          Mint::CommandLine.install("layout.haml", "haml-template", :local)
+          Mint::CommandLine.install("style.scss", "scss-template", :local)
+          expect(File.exist?(".mint/templates/haml-template/layout.haml")).to be true
+          expect(File.exist?(".mint/templates/scss-template/style.scss")).to be true
+        end
+        it "raises error for non-existent source file" do
+          expect {
+            Mint::CommandLine.install("nonexistent.erb", "test", :local)
+          }.to raise_error(RuntimeError, /No such file/)
+        end
+      end
+      describe "Mint::CommandLine.uninstall" do
+        it "removes an entire template directory" do
+          create_template_directory("removeme", with_layout: true, with_style: true)
+          expect(File.exist?(".mint/templates/removeme")).to be true
+          Mint::CommandLine.uninstall("removeme", :local)
+          expect(File.exist?(".mint/templates/removeme")).to be false
+        end
+        it "handles non-existent templates gracefully" do
+          expect {
+            Mint::CommandLine.uninstall("nonexistent", :local)
+          }.to raise_error(Errno::ENOENT)
+        end
+      end
+      describe "Mint::CommandLine.edit" do
+        it "opens layout template in editor" do
+          create_template_directory("editable", with_layout: true)
+          template_file = ".mint/templates/editable/layout.erb"
+          silence_output do
+            mock_editor do
+              expect {
+                Mint::CommandLine.edit("editable", :layout, :local)
+              }.not_to raise_error
+            end
+          end
+        end
+        it "opens style template in editor" do
+          create_template_directory("editable", with_style: true)
+          silence_output do
+            mock_editor do
+              expect {
+                Mint::CommandLine.edit("editable", :style, :local)
+              }.not_to raise_error
+            end
+          end
+        end
+        it "prompts to create template if it doesn't exist" do
+          # Mock STDIN to simulate user input
+          allow(STDIN).to receive(:gets).and_return("y\n")
+          silence_output do
+            mock_editor do
+              expect {
+                Mint::CommandLine.edit("newtemplate", :layout, :local)
+              }.not_to raise_error
+            end
+          end
+          expect(File.exist?(".mint/templates/newtemplate/layout.erb")).to be true
+        end
+        it "cancels creation when user says no" do
+          allow(STDIN).to receive(:gets).and_return("n\n")
+          silence_output do
+            expect {
+              Mint::CommandLine.edit("newtemplate", :layout, :local)
+            }.to raise_error(SystemExit)
+          end
+        end
+        it "rejects invalid template types" do
+          silence_output do
+            expect {
+              Mint::CommandLine.edit("template", :invalid, :local)
+            }.to raise_error(SystemExit, /Invalid template type/)
+          end
+        end
+        it "requires template name" do
+          silence_output do
+            expect {
+              Mint::CommandLine.edit("", :layout, :local)
+            }.to raise_error(SystemExit, /No template specified/)
+            expect {
+              Mint::CommandLine.edit(nil, :layout, :local)
+            }.to raise_error(SystemExit, /No template specified/)
+          end
+        end
+      end
+      describe "template creation helpers" do
+        describe "Mint::CommandLine.create_template" do
+          it "creates a layout template with default content" do
+            template_file = Mint::CommandLine.create_template("newlayout", :layout, :local)
+            expect(File.exist?(template_file)).to be true
+            content = File.read(template_file)
+            expect(content).to include("<!DOCTYPE html>")
+            expect(content).to include("<%= content %>")
+            expect(template_file).to end_with("/layout.erb")
+          end
+          it "creates a style template with default content" do
+            template_file = Mint::CommandLine.create_template("newstyle", :style, :local)
+            expect(File.exist?(template_file)).to be true
+            content = File.read(template_file)
+            expect(content).to include("body {")
+            expect(content).to include("font-family:")
+            expect(template_file).to end_with("/style.css")
+          end
+          it "creates template directory structure" do
+            Mint::CommandLine.create_template("organized", :layout, :local)
+            expect(File.exist?(".mint/templates/organized")).to be true
+            expect(File.directory?(".mint/templates/organized")).to be true
+          end
+          it "rejects invalid template types" do
+            silence_output do
+              expect {
+                Mint::CommandLine.create_template("test", :invalid, :local)
+              }.to raise_error(SystemExit, /Invalid template type/)
+            end
+          end
+        end
+        describe "default template content" do
+          it "provides valid HTML5 layout template" do
+            content = Mint::CommandLine.default_layout_content
+            expect(content).to include("<!DOCTYPE html>")
+            expect(content).to include("<html>")
+            expect(content).to include("<title>Document</title>")
+            expect(content).to include("<%= content %>")
+            expect(content).to include("<%= style %>")
+          end
+          it "provides basic CSS style template" do
+            content = Mint::CommandLine.default_style_content
+            expect(content).to include("body {")
+            expect(content).to include("font-family:")
+            expect(content).to include("max-width:")
+            expect(content).to include("code {")
+          end
+        end
+      end
+      describe "template lookup integration" do
+        it "finds installed templates via lookup methods" do
+          create_template_directory("findme", with_layout: true, with_style: true)
+          layout_file = Mint.lookup_layout("findme")
+          style_file = Mint.lookup_style("findme")
+          template_dir = Mint.lookup_template("findme")
+          expect(layout_file).to include("findme/layout.erb")
+          expect(style_file).to include("findme/style.css")
+          expect(template_dir.to_s).to include("findme")
+          expect(File.exist?(layout_file)).to be true
+          expect(File.exist?(style_file)).to be true
+          expect(File.directory?(template_dir)).to be true
+        end
+        it "raises TemplateNotFoundException for missing templates" do
+          expect {
+            Mint.lookup_layout("missing")
+          }.to raise_error(Mint::TemplateNotFoundException)
+          expect {
+            Mint.lookup_style("missing")
+          }.to raise_error(Mint::TemplateNotFoundException)
+          expect {
+            Mint.lookup_template("missing")
+          }.to raise_error(Mint::TemplateNotFoundException)
+        end
+      end
+    end
+  end
+end

data/spec/css_spec.rb CHANGED Viewed

@@ -39,7 +39,7 @@ module Mint
     describe ".parse" do
       it "transforms a map of human-readable styles into a CSS string" do
-        CSS.parse({ "Font" => "Helvetica" }).should == "#container {\n  font-family: Helvetica; }\n"
+        expect(CSS.parse({ "Font" => "Helvetica" })).to eq("#container {\n  font-family: Helvetica;\n}")
       end
     end
   end