mint 0.7.4 → 0.8.1

data/lib/mint/css_template.rb

@@ -0,0 +1,37 @@
+require 'tilt/template'
+
+module Mint
+  class CSSTemplate < Tilt::Template
+    self.default_mime_type = 'text/css'
+
+    def prepare
+      @data = data
+    end
+
+    def evaluate(scope, locals, &block)
+      process_imports(@data, File.dirname(file))
+    end
+
+    def process_imports(css_content, base_dir)
+      css_content.gsub(/@import\s+["']([^"']+)["'];?/) do |match|
+        import_path = $1
+        
+        # If we find a relative path, resolve it
+        if import_path.start_with?('../', './')
+          full_path = File.expand_path(import_path, base_dir)
+        else
+          full_path = File.join(base_dir, import_path)
+        end
+
+        full_path += '.css' unless full_path.end_with?('.css')
+
+        if File.exist?(full_path)
+          imported_content = File.read(full_path)
+          process_imports(imported_content, File.dirname(full_path))
+        else
+          match
+        end
+      end
+    end
+  end
+end

data/lib/mint/document.rb

@@ -1,57 +1,81 @@
 require "mint/resource"
 require "mint/layout"
 require "mint/style"
+require "mint/css_parser"
 
 module Mint
   class Document < Resource
     METADATA_DELIM = "\n\n"
 
     # Creates a new Mint Document object. Can be block initialized.
-    # Accepts source and options. Block initialization occurs after
-    # all defaults are set, so not all options must be specified.
-    def initialize(source, opts={})
-      options = Mint.default_options.merge opts
+    def initialize(source, 
+                   root: nil, 
+                   destination: nil, 
+                   context: nil, 
+                   name: nil, 
+                   style_mode: :inline, 
+                   style_destination: nil, 
+                   layout: nil, 
+                   style: nil, 
+                   template: nil,
+                   layout_or_style_or_template: [:template, 'default'],
+                   all_files: nil,
+                   &block)
+                   
+      destination = preserve_folder_structure!(source, root, destination)
+      
+      @all_files = all_files if all_files && all_files.any?
+
+      style_mode = :external if style_destination && style_mode == :inline
 
       # Loads source and destination, which will be used for
       # all source_* and destination_* virtual attributes.
-      super(source, options)
-      self.type     = :document
+      super(source, root: root, destination: destination, context: context, name: name)
+      self.type = :document
 
       # Each of these should invoke explicitly defined method
-      self.content  = source
-      self.layout   = options[:layout]
-      self.style    = options[:style]
-      self.style_destination = options[:style_destination]
+      self.content = source
+      self.style_mode = style_mode
+      self.style_destination = style_destination
+
+      if layout_or_style_or_template
+        type, name = layout_or_style_or_template
+        case type
+        when :template
+          self.template = name
+        when :layout
+          self.layout = name
+        when :style
+          self.style = name
+        end
+      end
+
+      # Individual layout/style options can override the above
+      self.layout = layout if layout
+      self.style = style if style
 
       # The template option will override layout and style choices
-      self.template = options[:template]
+      self.template = template if template
 
       # Yield self to block after all other parameters are loaded,
       # so we only have to tweak. (We don't have to give up our
       # defaults or re-test blocks beyond them being tweaked.)
-      yield self if block_given?
+      yield self if block
     end
 
     # Renders content in the context of layout and returns as a String.
     def render(args={})
       intermediate_content = layout.render self, args
-      Mint.after_render(intermediate_content)
+      Mint.after_render(intermediate_content, {})
     end
 
     # Writes all rendered content where a) possible, b) required,
     # and c) specified. Outputs to specified file.
-    def publish!(opts={})      
+    def publish!(opts={})
       options = { :render_style => true }.merge(opts)
-      FileUtils.mkdir_p self.destination_directory
-      File.open(self.destination_file, "w+") do |f|
-        f << self.render
-      end
+      super
 
-      # Only renders style if a) it's specified by the options path and
-      # b) it actually needs rendering (i.e., it's in template form and
-      # not raw, browser-parseable CSS) or it if it doesn't need
-      # rendering but there is an explicit style_destination.
-      if options[:render_style]
+      if @style_mode == :external && options[:render_style]
         FileUtils.mkdir_p style_destination_directory
         File.open(self.style_destination_file, "w+") do |f|
           f << self.style.render
@@ -63,7 +87,12 @@ module Mint
 
     # Implicit readers are paired with explicit accessors. This
     # allows for processing variables before storing them.
-    attr_reader :content, :metadata, :layout, :style
+    attr_reader :metadata, :layout, :style
+
+    # Returns HTML content marked as safe for template rendering
+    def content
+      @content.html_safe
+    end
 
     # Passes content through a renderer before assigning it to be
     # the Document's content
@@ -76,7 +105,8 @@ module Mint
       original_content = File.read content
 
       @metadata, text = Document.parse_metadata_from original_content
-      intermediate_content = Mint.before_render text
+      text_with_links = Helpers.transform_markdown_links text
+      intermediate_content = Mint.before_render text_with_links, {}
 
       File.open(tempfile, "w") do |file|
         file << intermediate_content
@@ -91,33 +121,29 @@ module Mint
     # @param [String, Layout, #render] layout a Layout object or name
     #   of a layout to be looked up
     # @return [void]
-    def layout=(layout)      
-      @layout = 
+    def layout=(layout)
+      @layout =
         if layout.respond_to? :render
           layout
         else
-          layout_file = Mint.lookup_template layout, :layout
-          Layout.new layout_file
+          layout_file = Mint.lookup_layout layout
+          Layout.new(layout_file, root: self.root, destination: self.destination, context: self.context)
         end
-    rescue TemplateNotFoundException
-      abort "Template '#{layout}' does not exist."
     end
-    
+
     # Sets layout to an existing Style object or looks it up by name
     #
     # @param [String, Style, #render] layout a Layout object or name
     #   of a layout to be looked up
     # @return [void]
     def style=(style)
-      @style = 
+      @style =
         if style.respond_to? :render
           style
         else
-          style_file = Mint.lookup_template style, :style
-          Style.new style_file
+          style_file = Mint.lookup_style style
+          Style.new(style_file, root: self.root, destination: self.destination, context: self.context)
         end
-    rescue TemplateNotFoundException
-      abort "Template '#{style}' does not exist."
     end
 
     # Overrides layout and style settings with named template.
@@ -148,8 +174,14 @@ module Mint
     #
     # The style_destination attribute is lazy. It's exposed via
     # virtual attributes like #style_destination_file.
-    attr_reader :style_destination
-    
+    attr_reader :style_destination, :style_mode
+
+    # @param [Symbol] style_mode how styles should be incorporated (:inline or :external)
+    # @return [void]
+    def style_mode=(style_mode)
+      @style_mode = style_mode
+    end
+
     # @param [String] style_destination the subdirectory into
     #   which styles will be rendered or copied
     # @return [void]
@@ -163,7 +195,7 @@ module Mint
     def style_destination_file_path
       if style_destination
         path = Pathname.new style_destination
-        dir = path.absolute? ? 
+        dir = path.absolute? ?
           path : destination_directory_path + path
         dir + style.name
       else
@@ -197,16 +229,140 @@ module Mint
     # Returns a relative path from the document to its stylesheet. Can
     # be called directly from inside a layout template.
     def stylesheet
-      Helpers.normalize_path(self.style_destination_file,
+      tmp_style_dir = Mint.path_for_scope(:user) + "tmp"
+      tmp_style_file = tmp_style_dir + File.basename(style.name)
+      Helpers.normalize_path(tmp_style_file.to_s,
                              self.destination_directory).to_s
     end
 
+    # Returns the rendered CSS content for inline inclusion
+    def inline_stylesheet
+      self.style.render
+    end
+
+    # Returns either inline CSS or stylesheet link based on style mode
+    # Use this helper in layouts instead of stylesheet or inline_stylesheet directly
+    def stylesheet_tag
+      case @style_mode
+      when :external
+        "<link rel=\"stylesheet\" href=\"#{stylesheet}\">".html_safe
+      when :original
+        original_stylesheet_tags.html_safe
+      else # :inline (default)
+        "<style>#{self.style.render}</style>".html_safe
+      end
+    end
+
+    # Generates stylesheet link tags for original mode
+    # Links directly to original CSS files without processing
+    def original_stylesheet_tags
+      return "" unless self.style&.template_path
+      
+      main_css_path = self.style.template_path
+      html_output_path = self.output_file
+      
+      # Only process .css files
+      return "" unless File.extname(main_css_path) == '.css'
+      
+      css_file_paths = CssParser.resolve_css_files(main_css_path, html_output_path)
+      CssParser.generate_link_tags(css_file_paths)
+    end
+
+    # Parses styles defined in YAML metadata in content, including it
+    # in output CSS style
+    # 
+    # TODO: Implement injection of these styles
     def inline_styles
       CSS.parse(metadata)
     end
 
+    # Returns information about all files for navigation in some templates (e.g., garden)
+    # Available when processing multiple files
+    def files
+      return [] unless @all_files
+      
+      # Get the base directories
+      source_base_dir = Pathname.new(root_directory_path).expand_path
+      
+      # Calculate where the current file will actually be placed
+      current_source_path = Pathname.new(source_file_path).expand_path
+      current_relative_to_source = current_source_path.relative_path_from(source_base_dir)
+      current_html_filename = current_relative_to_source.to_s.gsub(/\.(#{Mint::MARKDOWN_EXTENSIONS.join('|')})$/i, '.html')
+      
+      dest_base = Pathname.new(root_directory_path).expand_path
+      if destination && !destination.empty?
+        dest_base = dest_base + destination
+      end
+      
+      current_full_path = dest_base + current_html_filename
+      current_destination_dir = current_full_path.dirname
+      
+      @all_files.map do |file|
+        title = extract_title_from_file(file)
+        
+        # Calculate where this target file will be placed
+        file_path = Pathname.new(file).expand_path
+        relative_to_source = file_path.relative_path_from(source_base_dir)
+        html_filename = relative_to_source.to_s.gsub(/\.(#{Mint::MARKDOWN_EXTENSIONS.join('|')})$/i, '.html')
+        
+        target_full_path = dest_base + html_filename
+        
+        # Calculate the relative path from the current file's destination directory to the target file
+        relative_link = target_full_path.relative_path_from(current_destination_dir)
+        
+        {
+          source_path: relative_to_source.to_s,
+          html_path: relative_link.to_s,
+          title: title,
+          depth: relative_to_source.to_s.count('/')
+        }
+      end.sort_by {|f| f[:source_path] }
+    end
+
     # Functions
 
+    private
+
+    # Extracts the title from a markdown file, trying H1 first, then filename
+    def extract_title_from_file(file)
+      content = File.read(file)
+      
+      if content =~ /^#\s+(.+)$/
+        return $1.strip
+      end
+      
+      File.basename(file, '.*').tr('_-', ' ').split.map(&:capitalize).join(' ')
+    rescue
+      File.basename(file, '.*').tr('_-', ' ').split.map(&:capitalize).join(' ')
+    end
+
+    # Preserves folder structure when --recursive is used
+    #
+    # @param [String] source the source file path
+    # @param [Hash] options the options hash to modify
+    def preserve_folder_structure!(source, root, destination)
+      source_path = Pathname.new(source).expand_path
+      root_path = Pathname.new(root || Dir.getwd).expand_path
+      
+      relative_path = source_path.relative_path_from(root_path)
+      
+      relative_dir = relative_path.dirname
+      filename = relative_path.basename
+      
+      # Set destination to preserve directory structure
+      if relative_dir.to_s != "."
+        # Combine base destination with relative directory structure
+        base_destination = destination || ""
+        if base_destination.empty?
+          destination = relative_dir.to_s
+        else
+          destination = File.join(base_destination, relative_dir.to_s)
+        end
+      end
+      
+      destination
+    end
+
     class << self
       def metadata_chunk(text)
         text.split(METADATA_DELIM).first
@@ -214,16 +370,20 @@ module Mint
 
       def metadata_from(text)
         raw_metadata = YAML.load metadata_chunk(text)
-        
+
         case raw_metadata
         when String
           {}
         when false
           {}
+        when nil
+          {}
         else
           raw_metadata
         end
-      rescue
+      rescue Psych::SyntaxError
+        {}
+      rescue Exception
         {}
       end
 

data/lib/mint/helpers.rb

@@ -4,7 +4,7 @@ require "yaml"
 require "active_support/core_ext/string/inflections"
 
 module Mint
-  module Helpers    
+  module Helpers
     def self.underscore(obj, opts={})
       namespaces = obj.to_s.split("::").map do |namespace|
         if opts[:ignore_prefix]
@@ -38,7 +38,7 @@ module Mint
     def self.symbolize(obj)
       slugize(obj).gsub(/-/, "_").to_sym
     end
-  
+
     # Transforms a String or Pathname into a fully expanded Pathname.
     #
     # @param [String, Pathname] str_or_path a path to be expanded
@@ -59,8 +59,8 @@ module Mint
     def self.symbolize_keys(map, opts={})
       transform = lambda {|x| opts[:downcase] ? x.downcase : x }
 
-      map.reduce(Hash.new) do |syms,(k,v)| 
-        syms[transform[k].to_sym] = 
+      map.reduce(Hash.new) do |syms,(k,v)|
+        syms[transform[k].to_sym] =
           case v
           when Hash
             self.symbolize_keys(v, opts)
@@ -107,19 +107,19 @@ module Mint
       Hash[*list1.zip(list2).flatten]
     end
 
-    # Returns the relative path to to_directory from from_directory. 
-    # If to_directory and from_directory have no parents in common besides 
+    # Returns the relative path to to_directory from from_directory.
+    # If to_directory and from_directory have no parents in common besides
     # /, returns the absolute directory of to_directory. Assumes no symlinks.
     #
     # @param [String, Pathname] to_directory the target directory
     # @param [String, Pathname] from_directory the starting directory
-    # @return [Pathname] the relative path to to_directory from 
+    # @return [Pathname] the relative path to to_directory from
     #   from_directory, or an absolute path if they have no parents in common
     #   other than /
     def self.normalize_path(to_directory, from_directory)
       to_path, from_path = [to_directory, from_directory].map {|d| pathize d }
       to_root, from_root = [to_path, from_path].map {|p| p.each_filename.first }
-      to_root == from_root ? 
+      to_root == from_root ?
         to_path.relative_path_from(from_path) :
         to_path
     end
@@ -129,15 +129,33 @@ module Mint
     #
     # @param [Hash, #[]] new_opts a set of options to add to the Yaml file
     # @param [Pathname, #exist] file a file to read from and write to
-    # @return [void] 
+    # @return [void]
     def self.update_yaml!(file, opts={})
-      curr_opts = File.exist?(file) ? YAML.load_file(file) : {}
+      curr_opts = if File.exist?(file)
+                    begin
+                      YAML.load_file(file) || {}
+                    rescue Psych::SyntaxError, StandardError
+                      # Handle corrupted YAML gracefully by treating it as empty
+                      {}
+                    end
+                  else
+                    {}
+                  end
 
       File.open file, "w" do |f|
         YAML.dump(curr_opts.merge(opts), f)
       end
     end
 
+    def self.create_temp_file!(basename, extension=nil, &block)
+      tmp_args = basename && extension ? [basename, extension] : basename
+      tempfile = Tempfile.new(tmp_args)
+      block.call(tempfile)
+      tempfile.flush
+      tempfile.close
+      tempfile.path
+    end
+
     def self.generate_temp_file!(file)
       basename  = File.basename file
       extension = File.extname file
@@ -149,5 +167,27 @@ module Mint
       tempfile.close
       tempfile.path
     end
+
+    # Transforms markdown links from .md extensions to .html for digital gardens
+    #
+    # @param [String] text the markdown text containing links
+    # @return [String] the text with transformed links
+    def self.transform_markdown_links(text)
+      # Transform relative markdown links like [text](path/file.md) to [text](path/file.html)
+      text.gsub(/(\[([^\]]*)\]\()([^)]*\.md)(\))/) do |match|
+        link_start = $1
+        link_text = $2
+        link_url = $3
+        link_end = $4
+        
+        # Only transform relative links (not absolute URLs)
+        if link_url !~ /^https?:\/\//
+          new_url = link_url.gsub(/\.md$/, '.html')
+          "#{link_start}#{new_url}#{link_end}"
+        else
+          match
+        end
+      end
+    end
   end
 end

data/lib/mint/layout.rb

@@ -6,9 +6,8 @@ module Mint
     # and optional configuration options.
     #
     # @param [String] source the absolute or relative file path
-    # @param [Hash, #[]] opts layout options
-    def initialize(source, opts=Mint.default_options)
-      super(source, opts)
+    def initialize(source, root: nil, destination: nil, context: nil, name: nil, &block)
+      super(source, root: root, destination: destination, context: context, name: name, &block)
       self.type = :layout
     end
   end

data/lib/mint/markdown_template.rb

@@ -0,0 +1,47 @@
+require 'tilt/template'
+require 'redcarpet'
+
+module Mint
+  class MarkdownTemplate < Tilt::Template
+    self.default_mime_type = 'text/html'
+
+    def prepare
+      @options = options.dup
+      
+      renderer_options = {
+        filter_html: false,
+        no_images: false,
+        no_links: false,
+        no_styles: false,
+        escape_html: false,
+        safe_links_only: false,
+        with_toc_data: false,
+        hard_wrap: false,
+        prettify: false
+      }.merge(@options)
+      
+      markdown_options = {
+        tables: true,
+        autolink: true,
+        no_intra_emphasis: true,
+        fenced_code_blocks: true,
+        lax_html_blocks: false,
+        strikethrough: true,
+        superscript: false,
+        footnotes: false,
+        highlight: false,
+        quote: false,
+        disable_indented_code_blocks: false,
+        space_after_headers: false,
+        underline: false
+      }
+      
+      @renderer = @options.delete(:renderer) || Redcarpet::Render::HTML.new(renderer_options)
+      @markdown = Redcarpet::Markdown.new(@renderer, markdown_options)
+    end
+
+    def evaluate(scope, locals, &block)
+      @markdown.render(data)
+    end
+  end
+end