mint 0.8.1 → 0.10.0

data/lib/mint/config.rb

@@ -0,0 +1,162 @@
+require "toml"
+
+module Mint
+  class Config
+    attr_accessor :files
+    attr_accessor :stdin_mode
+    attr_accessor :help
+    attr_accessor :verbose
+    attr_accessor :layout_name
+    attr_accessor :style_name
+    attr_accessor :style_mode
+    attr_accessor :output_file_format
+    attr_accessor :working_directory            # This can't be set by the user
+    attr_accessor :destination_directory
+    attr_accessor :style_destination_directory
+    attr_accessor :preserve_structure
+    attr_accessor :insert_title_heading
+    attr_accessor :autodrop
+    attr_accessor :navigation
+    attr_accessor :navigation_depth
+    attr_accessor :navigation_title
+    
+    DEFAULT_STDIN_MODE                  = false
+    DEFAULT_VERBOSE                     = false
+    DEFAULT_LAYOUT_NAME                 = "default"
+    DEFAULT_STYLE_NAME                  = "default"
+    DEFAULT_STYLE_MODE                  = :inline
+    DEFAULT_OUTPUT_FILE_FORMAT          = '%{name}.%{ext}'
+    DEFAULT_WORKING_DIRECTORY           = lambda { Pathname.getwd.expand_path }
+    DEFAULT_DESTINATION_DIRECTORY       = lambda { Pathname.getwd.expand_path }
+    DEFAULT_PRESERVE_STRUCTURE          = true
+    DEFAULT_INSERT_TITLE_HEADING        = false
+    DEFAULT_AUTODROP                    = true
+    DEFAULT_NAVIGATION                  = false
+    DEFAULT_NAVIGATION_DEPTH            = 3
+    DEFAULT_NAVIGATION_TITLE            = nil
+    
+    def initialize(options = {})
+      @stdin_mode = options[:stdin_mode] if options.key?(:stdin_mode)
+      @help = options[:help]
+      @verbose = options[:verbose] if options.key?(:verbose)
+      @layout_name = options[:layout_name] || options[:template_name]
+      @style_name = options[:style_name] || options[:template_name]
+      @style_mode = options[:style_mode]
+      @output_file_format = options[:output_file_format]
+      @working_directory = options[:working_directory]&.expand_path
+      @destination_directory = options[:destination_directory]
+      @style_destination_directory = options[:style_destination_directory]
+      @preserve_structure = options[:preserve_structure] if options.key?(:preserve_structure)
+      @insert_title_heading = options[:insert_title_heading] if options.key?(:insert_title_heading)
+      @autodrop = options[:autodrop] if options.key?(:autodrop)
+      @navigation = options[:navigation] if options.key?(:navigation)
+      @navigation_depth = options[:navigation_depth] if options.key?(:navigation_depth)
+      @navigation_title = options[:navigation_title]
+    end
+    
+    def to_h
+      {
+        stdin_mode: @stdin_mode,
+        help: @help,
+        verbose: @verbose,
+        layout_name: @layout_name,
+        style_name: @style_name,
+        style_mode: @style_mode,
+        output_file_format: @output_file_format,
+        working_directory: @working_directory,
+        destination_directory: @destination_directory,
+        style_destination_directory: @style_destination_directory,
+        preserve_structure: @preserve_structure,
+        insert_title_heading: @insert_title_heading,
+        autodrop: @autodrop,
+        navigation: @navigation,
+        navigation_depth: @navigation_depth,
+        navigation_title: @navigation_title
+      }
+    end
+    
+    def merge(config = Config.new)
+      Config.new(to_h.merge(config.to_h.reject {|_, v| v.nil? }))
+    end
+
+    def self.ensure_config(config)
+      case config
+      when Config
+        config
+      when Hash
+        Config.new(config)
+      else
+        raise ArgumentError, "config must be a Config object or Hash"
+      end
+    end
+    
+    def self.load_file(file)
+      toml_config = TOML.load_file(file)
+      mapped_config = map_toml_keys_to_config(toml_config) if toml_config.is_a?(Hash)
+      Config.new(mapped_config || {})
+    end
+
+    def self.defaults
+      dest_dir = DEFAULT_DESTINATION_DIRECTORY.call
+      Config.new({
+        stdin_mode: DEFAULT_STDIN_MODE,
+        verbose: DEFAULT_VERBOSE,
+        layout_name: DEFAULT_LAYOUT_NAME,
+        style_name: DEFAULT_STYLE_NAME,
+        style_mode: DEFAULT_STYLE_MODE,
+        output_file_format: DEFAULT_OUTPUT_FILE_FORMAT,
+        working_directory: DEFAULT_WORKING_DIRECTORY.call,
+        destination_directory: dest_dir,
+        style_destination_directory: Pathname.new('.'),
+        preserve_structure: DEFAULT_PRESERVE_STRUCTURE,
+        insert_title_heading: DEFAULT_INSERT_TITLE_HEADING,
+        autodrop: DEFAULT_AUTODROP,
+        navigation: DEFAULT_NAVIGATION,
+        navigation_depth: DEFAULT_NAVIGATION_DEPTH,
+        navigation_title: DEFAULT_NAVIGATION_TITLE
+      })
+    end
+
+    def self.with_defaults(overrides = {})
+      defaults.merge(new(overrides))
+    end
+
+    private
+
+    def self.map_toml_keys_to_config(toml_config)
+      mapping = {
+        'verbose' => :verbose,
+        'template' => :template_name,
+        'layout' => :layout_name,
+        'style' => :style_name,
+        'output-file' => :output_file_format,
+        'destination' => :destination_directory,
+        'style-mode' => :style_mode,
+        'style-destination' => :style_destination_directory,
+        'preserve-structure' => :preserve_structure,
+        'insert-title-heading' => :insert_title_heading,
+        'autodrop' => :autodrop,
+        'navigation' => :navigation,
+        'navigation-depth' => :navigation_depth,
+        'navigation-title' => :navigation_title
+      }
+
+      mapped = {}
+      toml_config.each do |key, value|
+        mapped_key = mapping[key] || key.to_sym
+        
+        # Handle special conversions
+        case mapped_key
+        when :destination_directory
+          mapped[mapped_key] = Pathname.new(value) if value
+        when :style_mode
+          mapped[mapped_key] = value.to_sym if value
+        else
+          mapped[mapped_key] = value
+        end
+      end
+      
+      mapped
+    end
+  end
+end

data/lib/mint/{css.rb → css_dsl.rb}

@@ -2,18 +2,17 @@ require "sass-embedded"
 
 module Mint
   module CSS
-    def self.container
-      "container"
-    end
+    CONTAINER = "container"
 
-    # Maps a "DSL" onto actual CSS. Translates this ...
+    # Allows for a human-readable DSL to be used to generate CSS. Translates the following:
     #
     # ---
     # Font: Helvetica
     # Margin: 1in
     # Orientation: Landscape
+    # ---
     #
-    # ... into something like:
+    # ... into something like this:
     #
     # #container {
     #   font-family: Helvetica;
@@ -43,13 +42,14 @@ module Mint
         indent: "p+p { text-indent: %s }",
         bullet: "li { list-style-type: %s }",
         bullet_image: "li { list-style-image: url(%s) }",
-        after_paragraph: "margin-bottom",
-        before_paragraph: "margin-top"
+        after_paragraph: "p { margin-bottom: %s }",
+        before_paragraph: "p { margin-top: %s }"
       }
     end
 
     def self.stylify(key, value)
-      selector = mappings[Helpers.symbolize key]
+      symbol_key = key.to_s.downcase.gsub(' ', '_').to_sym
+      selector = mappings[symbol_key]
 
       if selector.nil?
         ""
@@ -62,7 +62,7 @@ module Mint
 
     def self.parse(style)
       css = style.map {|k,v| stylify(k, v) }.join("\n  ")
-      container_scope = "##{container}\n  #{css.strip}\n"
+      container_scope = "##{CONTAINER}\n  #{css.strip}\n"
       
       # Suppress warnings by capturing $stderr
       original_stderr = $stderr

data/lib/mint/css_parser.rb

@@ -1,9 +1,9 @@
 require "pathname"
+require "set"
 
 module Mint
   # Parses CSS files to extract @import statements and calculate relative paths
   class CssParser
-    
     # Extracts @import statements from CSS content
     #
     # @param [String] css_content the CSS content to parse
@@ -11,58 +11,78 @@ module Mint
     def self.extract_imports(css_content)
       imports = []
       
-      # Match @import statements with various formats:
+      # Remove CSS comments first to avoid matching commented @import statements
+      # Remove /* ... */ style comments
+      css_without_comments = css_content.gsub(/\/\*.*?\*\//m, '')
+      
+      # Matched formats include:
       # @import "file.css";
       # @import 'file.css';
       # @import url("file.css");
       # @import url('file.css');
-      css_content.scan(/@import\s+(?:url\()?['"]([^'"]+)['"](?:\))?;?/i) do |match|
+      css_without_comments.scan(/@import\s+(?:url\()?['"]([^'"]+)['"](?:\))?;?/i) do |match|
         imports << match[0]
       end
       
       imports
     end
     
-    # Resolves all CSS files (main + imports) and calculates their paths relative to HTML output
+    # Recursively resolves a CSS file and its imports
     #
-    # @param [String] main_css_path absolute path to the main CSS file
-    # @param [String] html_output_path absolute path to the HTML output file
+    # @param [Pathname] css_file absolute path to the CSS file as Pathname
+    # @param [Pathname] html_dir directory of the HTML output file as Pathname
+    # @param [Set] visited set of already processed files to prevent circular imports
     # @return [Array<String>] array of relative paths from HTML to CSS files
-    def self.resolve_css_files(main_css_path, html_output_path)
+    def self.resolve_css_file_recursive(css_file, html_dir, visited = Set.new)
       css_files = []
-      main_css_file = Pathname.new(main_css_path)
-      html_file = Pathname.new(html_output_path)
       
-      # Add the main CSS file
-      css_files << main_css_file.relative_path_from(html_file.dirname).to_s
+      # Prevent circular imports
+      return css_files if visited.include?(css_file.to_s)
+      visited.add(css_file.to_s)
       
-      # Only process if main CSS file exists and is a .css file
-      return css_files unless main_css_file.exist? && main_css_file.extname == '.css'
+      return css_files unless css_file.exist? && css_file.extname == '.css'
       
       begin
-        css_content = File.read(main_css_path)
+        css_content = File.read(css_file)
         imports = extract_imports(css_content)
         
+        # Recursively process imported files first (they should load before the file that imports them)
         imports.each do |import_path|
-          # Resolve import path relative to the main CSS file's directory
-          import_file = main_css_file.dirname + import_path
-          
-          # Only include if it's a .css file and exists
-          if import_file.exist? && import_file.extname == '.css'
-            # Calculate path relative to HTML output
-            relative_import = import_file.relative_path_from(html_file.dirname).to_s
-            css_files << relative_import
-          end
+          import_file = (css_file.dirname + import_path).expand_path
+          css_files.concat(resolve_css_file_recursive(import_file, html_dir, visited))
         end
         
-      rescue => e
-        # If we can't read the CSS file, just return the main file
+        # Add this file after its imports
+        relative_path = css_file.relative_path_from(html_dir).to_s
+        css_files << relative_path unless css_files.include?(relative_path)
+        
+      rescue => _
+        # If we can't read the CSS file, skip it
         # This allows the system to gracefully handle missing or unreadable files
       end
       
       css_files
     end
     
+    # Resolves all CSS files (main + imports) and calculates their paths relative to HTML output
+    #
+    # @param [String] main_css_path absolute path to the main CSS file
+    # @param [String] html_output_path absolute path to the HTML output file
+    # @return [Array<String>] array of relative paths from HTML to CSS files
+    def self.resolve_css_files(main_css_path, html_output_path)
+      main_css_file = Pathname.new(main_css_path).expand_path
+      html_file = Pathname.new(html_output_path).expand_path
+      html_dir = html_file.dirname
+      
+      # If the file doesn't exist or isn't CSS, return just the relative path
+      unless main_css_file.exist? && main_css_file.extname == '.css'
+        return [main_css_file.relative_path_from(html_dir).to_s]
+      end
+      
+      # Use recursive resolution
+      resolve_css_file_recursive(main_css_file, html_dir)
+    end
+    
     # Generates HTML link tags for CSS files
     #
     # @param [Array<String>] css_file_paths array of relative paths to CSS files