mint 0.8.1 → 0.10.0

data/lib/mint/workspace.rb

@@ -0,0 +1,171 @@
+require "pathname"
+require "fileutils"
+
+require_relative "./document"
+require_relative "./helpers"
+require_relative "./css_parser"
+
+module Mint
+  class Workspace
+    def initialize(markdown_paths, config)
+      @config = config
+      @documents = []
+      
+      # 1. Create destination_html_paths, mapped 1:1 with markdown_paths,
+      #    and autodropping any directories that are common to all files,
+      #    if config.autodrop is on.
+      # 2. Zip markdown_paths and destination_html_paths together so they
+      #    are paired
+      # 3. For each pair, create a document with the source and destination
+      #    paths, and create navigation tree JSON that's relative to
+      #    the specific document at hand
+      #
+      # NOTE: All directories at this stage are relative so that they can be
+      # concatenated and manipulated. The working directory is passed into
+      # the Document, which is where it's used to calculate its actual
+      # absolute destination.
+      
+      autodrop_levels = calculate_autodrop_levels_for(markdown_paths)
+      style_path = find_style_path(@config.style_name)
+      layout_path = find_layout_path(@config.layout_name)
+      style_destination_path = @config.destination_directory + @config.style_destination_directory
+
+      markdown_paths.each_with_index do |path, index|
+        destination_path = destination_path_for(path,
+                                                autodrop_levels: autodrop_levels,
+                                                preserve_structure: @config.preserve_structure,
+                                                output_file_format: @config.output_file_format)
+
+        @documents << Document.new(
+          working_directory: @config.working_directory,
+          source_path: path,
+          destination_path: destination_path,
+          destination_directory_path: @config.destination_directory,
+          layout_path: layout_path,
+          style_path: style_path,
+          style_destination_path: style_destination_path,
+          style_mode: @config.style_mode,
+          insert_title_heading: @config.insert_title_heading,
+          transform_links: lambda {|link_basename| update_basename(link_basename, new_extension: "html", format_string: @config.output_file_format) },
+          render_style: index == 0
+        )
+      end
+    end
+    
+    def publish!
+      if @config.navigation
+        @documents.map do |document|
+          document.publish!(show_navigation: true, navigation: @documents, navigation_depth: @config.navigation_depth, navigation_title: @config.navigation_title)
+        end
+      else
+        @documents.map do |document|
+          document.publish!(show_navigation: false, navigation: nil, navigation_depth: 0, navigation_title: nil)
+        end
+      end
+    end
+    
+    # Returns the style path relative to the working directory
+    # 
+    # @param [String] style_name name of the style to find
+    # @return [Pathname] the style path relative to the working directory
+    def find_style_path(style_name)
+      style_source = Style.find_by_name(style_name)
+      raise StyleNotFoundException, "Style '#{style_name}' does not exist." unless style_source
+      
+      if style_source.absolute?
+        style_source.relative_path_from(@config.working_directory)
+      else
+        style_source
+      end
+    end
+    
+    # Returns the layout path relative to the working directory
+    # 
+    # @param [String] layout_name name of the layout to find
+    # @return [Pathname] the layout path relative to the working directory
+    def find_layout_path(layout_name)
+      layout_source = Layout.find_by_name(layout_name) || 
+                      Layout.find_by_name(Config::DEFAULT_LAYOUT_NAME)
+      raise LayoutNotFoundException, "Layout '#{layout_name}' does not exist." unless layout_source
+      
+      if layout_source.absolute?
+        layout_source.relative_path_from(@config.working_directory)
+      else
+        layout_source
+      end
+    end
+    
+    # Updates the basename of a filename with a new extension and format string
+    # 
+    # @param [String] filename the filename to update
+    # @param [String] new_extension the new extension to use
+    # @param [String] format_string the format string to use
+    # @return [String] the updated filename
+    def update_basename(filename, new_extension:, format_string:)
+      filename_no_ext = File.basename(filename, ".*")
+      format_string % {
+        name: filename_no_ext,
+        ext: new_extension,
+        original_ext: File.extname(filename)[1..-1]
+      }
+    end
+
+    # Updates the basename of a path with a new extension and format string
+    # 
+    # @param [Pathname] path the path to update
+    # @param [String] new_extension the new extension to use
+    # @param [String] format_string the format string to use
+    # @return [Pathname] the updated path
+    def update_path_basename(path, new_extension:, format_string:)
+      path.sub(path.basename.to_s, update_basename(path.basename, new_extension: new_extension, format_string: format_string))
+    end
+    
+    # Calculates the number of levels to "autodrop" from the paths. Autodropping is dropping
+    # any parent directories that are common to all paths. This makes it easy for users to pass
+    # in directories not in the current working directory and have them automatically removed
+    # from the final output paths. Autodropping is only done if @config.autodrop is true. 
+    # 
+    # @param [Array<Pathname>] markdown_paths the paths to calculate the autodrop levels for
+    # @return [Integer] the number of levels to drop
+    def calculate_autodrop_levels_for(markdown_paths)
+      return 0 unless @config.autodrop
+      return 0 if markdown_paths.length <= 1
+      
+      # Find common parent directories by splitting paths and finding common prefix
+      path_parts = markdown_paths.map {|path| path.to_s.split('/').reject(&:empty?) }
+      return 0 if path_parts.empty?
+      
+      # Find the minimum length to avoid index errors
+      min_length = path_parts.map(&:length).min
+      return 0 if min_length == 0
+      
+      # Find common prefix length
+      common_prefix_length = 0
+      (0...min_length).each do |i|
+        if path_parts.all? {|parts| parts[i] == path_parts.first[i] }
+          common_prefix_length = i + 1
+        else
+          break
+        end
+      end
+      
+      # Only drop if there's a meaningful common prefix and it leaves at least one level
+      if common_prefix_length > 0 && path_parts.any? {|parts| parts.length > common_prefix_length }
+        common_prefix_length
+      else
+        0
+      end
+    end
+
+    def destination_path_for(path, autodrop_levels:, preserve_structure:, output_file_format:)
+      if preserve_structure
+        # Keep directory structure, but apply autodrop if enabled and convert extension to HTML
+        dropped_path = Helpers.drop_pathname(path, autodrop_levels)
+        update_path_basename(dropped_path, new_extension: "html", format_string: output_file_format)
+      else
+        # Flatten all files directly into destination directory (no subdirectories)
+        Pathname.new(update_basename(path.basename, new_extension: "html", format_string: output_file_format))
+      end
+    end
+  end
+end

data/lib/mint.rb

@@ -1,12 +1,44 @@
-require "mint/helpers"
-require "mint/mint"
-require "mint/resource"
-require "mint/layout"
-require "mint/style"
-require "mint/document"
-require "mint/version"
-require "mint/css"
-require "mint/command_line"
-require "mint/exceptions"
-require "mint/plugin"
-require "mint/css_template"
+require "pathname"
+require "fileutils"
+require "yaml"
+require "active_support/core_ext/string/output_safety"
+
+require_relative "mint/version"
+require_relative "mint/commandline/run"
+require_relative "mint/commandline/parse"
+require_relative "mint/commandline/publish"
+require_relative "mint/css_dsl"
+require_relative "mint/css_parser"
+require_relative "mint/config"
+require_relative "mint/exceptions"
+require_relative "mint/renderers/css_renderer"
+require_relative "mint/renderers/markdown_renderer"
+require_relative "mint/renderers/erb_renderer"
+require_relative "mint/document"
+require_relative "mint/workspace"
+require_relative "mint/layout"
+require_relative "mint/style"
+require_relative "mint/template"
+
+module Mint
+  PROJECT_ROOT        = (Pathname.new(__FILE__).realpath.dirname + "..").to_s
+  LOCAL_SCOPE         = Pathname.new(".mint")
+  USER_SCOPE          = Pathname.new("~/.config/mint").expand_path
+  GLOBAL_SCOPE        = Pathname.new("#{PROJECT_ROOT}/config").expand_path
+  PATH                = [LOCAL_SCOPE, USER_SCOPE, GLOBAL_SCOPE]
+  CONFIG_FILE         = "config.toml"
+  TEMPLATES_DIRECTORY = "templates"
+  
+  # Returns a hash of all active config, merging global, user, and local
+  # scoped config. Local overrides user, which overrides global config.
+  #
+  # @return [Config] a structured set of configuration options
+  def self.configuration
+    Mint::PATH.
+      reverse.
+      map {|p| p + Mint::CONFIG_FILE }.
+      select(&:exist?).
+      map {|p| Config.load_file p }.
+      reduce(Config.defaults) {|agg, cfg| agg.merge cfg }
+  end
+end

data/man/mint.1

@@ -15,10 +15,13 @@ Mint processes Markdown, Textile, and other templating languages into styled HTM
 Transform one or more source files into HTML documents
 .SH OPTIONS
 .TP
+.BR \-h ", " \-\-help
+Show mint usage information
+.TP
 .BR \-d ", " \-\-destination " " \fIDIRECTORY\fR
 Specify a destination directory, relative to the root
 .TP
-.BR \-\-style\-mode " " \fIMODE\fR
+.BR \-m ", " \-\-style\-mode " " \fIMODE\fR
 Specify how styles are included (inline, external, original). Default is inline.
 .TP
 .BR \-\-style\-destination " " \fIDESTINATION\fR
@@ -28,74 +31,124 @@ Create stylesheet at specified directory or file path and link it. This sets sty
 Specify a template to use for both layout and styling
 .TP
 .BR \-l ", " \-\-layout " " \fILAYOUT\fR
-Specify a specific layout template
+Specify a specific layout template by name
 .TP
 .BR \-\-style " " \fISTYLE\fR
-Specify a specific style template
+Specify a specific style template by name
 .TP
-.BR \-g ", " \-\-global
-Specify config changes on a global level
+.BR \-w ", " \-\-working\-dir " " \fIWORKING_DIR\fR
+Specify a working directory outside the current directory
 .TP
-.BR \-u ", " \-\-user
-Specify config changes on a user-wide level
+.BR \-o ", " \-\-output\-file " " \fIFORMAT\fR
+Specify output filename format with substitutions (%{basename}, %{original_ext}, %{new_extension})
 .TP
-.BR \-\-local
-Specify config changes on a local level (default)
+.BR \-\-preserve\-structure
+Preserve source directory structure (e.g., nesting) in destination (default: true)
 .TP
-.BR \-r ", " \-\-recursive
-Recursively find all Markdown files in subdirectories
+.BR \-\-no\-preserve\-structure
+Flatten all files into destination directory
 .TP
-.BR \-v ", " \-\-verbose
-Enable verbose output
+.BR \-\-navigation
+Enable navigation panel showing all files
 .TP
-.BR \-h ", " \-\-help
-Display help information
+.BR \-\-no\-navigation
+Disable navigation panel
+.TP
+.BR \-\-navigation\-title " " \fITITLE\fR
+Set title for navigation panel
+.TP
+.BR \-\-autodrop
+Automatically drop common directory levels from output paths and navigation (default: true)
+.TP
+.BR \-\-no\-autodrop
+Don't automatically drop common directory levels
+.TP
+.BR \-\-navigation\-depth " " \fIDEPTH\fR
+Maximum depth to show in navigation (default: 3)
+.TP
+.BR \-\-insert\-title\-heading
+Insert document title as H1 heading into content
+.TP
+.BR \-\-no\-insert\-title\-heading
+Don't insert title as H1 heading
 .SH STYLE OPTIONS
 Mint offers flexible control over how stylesheets are incorporated into your documents:
 
-.SS Inline Styles (Default)
+.SS Inline styles (Default)
 By default, Mint inlines CSS directly into your HTML documents, creating self-contained files:
 .RS
 .nf
-mint publish document.md
+mint publish Document.md
 .fi
 .RE
 
-.SS External Stylesheets
+.SS External stylesheets
 Create external stylesheets that are linked from your HTML documents:
 .RS
 .nf
-mint publish document.md --style-destination css
-mint publish document.md --style-destination styles/main.css
+mint publish Document.md --style-destination css
+mint publish Document.md --style-destination styles/main.css
 .fi
 .RE
 
 External stylesheets are useful when you want to share stylesheets across multiple documents, keep HTML files smaller, or allow separate caching of styles.
+
+.SH DIRECTORY STRUCTURE
+Mint provides flexible control over how source directory structure is handled in the output:
+
+By default, Mint preserves the source directory structure but applies "autodrop" to remove common directory levels. For example, if all files are under docs/content/, that common prefix is automatically dropped.
+
+Use --no-preserve-structure to flatten all files into the destination directory, ignoring source directory structure entirely.
+
+Use --no-autodrop with --preserve-structure to keep the complete original directory structure without dropping any levels.
+.SH CONFIGURATION
+Mint can be configured using TOML configuration files in the following order of precedence:
+.IP 1. 2
+Command-line arguments (highest priority)
+.IP 2. 2
+Local config file: .mint/config.toml
+.IP 3. 2
+User config file: ~/.config/mint/config.toml  
+.IP 4. 2
+Built-in defaults (lowest priority)
+
+Boolean options set to true in configuration files can be overridden using --no- flags:
+.RS
+.nf
+# If config.toml has: navigation = true
+mint publish Document.md --no-navigation
+.fi
+.RE
 .SH EXAMPLES
 .TP
 Transform a single Markdown file:
 .nf
-mint publish document.md
+mint publish Document.md
 .fi
 .TP
 Transform multiple files:
 .nf
-mint publish doc1.md doc2.md doc3.md
+mint publish Document1.md Document2.md Document3.md
+.fi
+.TP
+Insert title as H1 heading:
+.nf
+mint publish Document.md --insert-title-heading
 .fi
 .TP
 Use a specific template:
 .nf
-mint publish resume.md --template resume
+mint publish Document.md --template nord
 .fi
 .TP
 Create external stylesheet:
 .nf
-mint publish document.md --style-destination css
+mint publish Document.md --style-destination css
 .fi
 .TP
-Recursively process all Markdown files:
+Override boolean config file settings with --no-* variants:
 .nf
-mint publish --recursive
+mint publish Document.md --no-navigation --no-insert-title-heading
 .fi
 .SH TEMPLATES
 Mint comes with several built-in templates:
@@ -103,32 +156,20 @@ Mint comes with several built-in templates:
 .B default
 \- Clean, professional styling
 .IP \(bu 2
-.B zen
-\- Minimalist design
-.IP \(bu 2
-.B protocol
-\- Technical documentation style
-.IP \(bu 2
-.B newspaper
-\- Multi-column layout
+.B basic
+\- Minimalist design focused on the text
 .IP \(bu 2
 .B nord/nord-dark
-\- Modern color schemes
+\- Modern color schemes using the Nord color scheme
 .PP
-Templates can be written in any format accepted by the Tilt template interface library (ERB, Haml, etc.).
+Templates use ERB-flavored HTML for layouts and CSS for styling.
 .SH FILES
 .TP
 .I ~/.config/mint/
-User-specific configuration and templates
+User-level configuration and templates ('user' scope)
 .TP
 .I .mint/
-Project-specific configuration and templates
-.TP
-.I config.yaml
-Configuration file (can exist at global, user, or local levels)
-.SH SEE ALSO
-.BR markdown (1),
-.BR tilt (1)
+Project-level configuration and templates ('local' scope)
 .SH AUTHOR
 David Jacobs <david@wit.io>
 .SH HOMEPAGE

data/spec/cli/README.md

@@ -60,11 +60,11 @@ end
 
 # Output capture
 stdout, stderr = capture_output do
-  Mint::CommandLine.some_method
+  Mint::Commandline.some_method
 end
 
 # File creation
-create_markdown_file("test.md", "# Content")
+create_markdown_path("test.md", "# Content")
 create_template_directory("custom", with_layout: true)
 
 # Command execution