mint 0.8.1 → 0.10.0

data/lib/mint/document.rb

@@ -1,403 +1,288 @@
-require "mint/resource"
-require "mint/layout"
-require "mint/style"
-require "mint/css_parser"
+require "pathname"
+require "yaml"
+require "active_support/core_ext/string/output_safety"
+
+require_relative "./renderers/markdown_renderer"
+require_relative "./renderers/erb_renderer"
+require_relative "./renderers/css_renderer"
+require_relative "./helpers"
+require_relative "./document_tree"
 
 module Mint
-  class Document < Resource
+  class Document
     METADATA_DELIM = "\n\n"
+    
+    attr_reader :title, :destination_path
+    
+    # @param [Pathname] working_directory path by which relative links should be resolved
+    # @param [Pathname] source_path path to markdown file (relative to working_directory)
+    # @param [Pathname] destination_path path to output file (relative to destination_directory_path)
+    # @param [Pathname] destination_directory_path path to destination directory
+    # @param [Pathname] layout_path path to layout file (relative to working_directory)
+    # @param [Pathname] style_path path to style file (relative to working_directory)
+    # @param [Pathname] style_destination_path path to style destination file
+    # @param [Symbol] style_mode style mode (:inline, :external, :original)
+    # @param [Boolean] insert_title_heading whether to inject title as H1 heading
+    # @param [Boolean] show_navigation whether to show navigation
+    # @param [Integer] navigation_depth navigation depth (optional)
+    # @param [Array<Hash>] navigation_data array of navigation items with :path and :title
+    # @param [String] navigation_title title for navigation panel (optional)
+    # @param [Proc] transform_links proc to transform link basenames; yields the basename of the link
+    # @param [Boolean] render_style whether to render style
+    def initialize(working_directory:,
+                   source_path:,
+                   destination_path:,
+                   destination_directory_path:,
+                   layout_path:,
+                   style_path:,
+                   style_destination_path:,
+                   style_mode:,
+                   insert_title_heading:,
+                   transform_links: Proc.new,
+                   render_style: true)
+      @working_directory = working_directory
+      @source_path = source_path
+      @destination_path = destination_path
+      @destination_directory_path = destination_directory_path
+      @layout_path = layout_path
+      @style_path = style_path
+      @style_destination_path = style_destination_path
+      @style_mode = style_mode
+      @insert_title_heading = insert_title_heading
+      @transform_links = transform_links
+      @render_style = render_style
+      @title = guess_title
+    end
 
-    # Creates a new Mint Document object. Can be block initialized.
-    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)
+    # Publishes the markdown document to HTML
+    # 
+    # Reads the markdown source file, transforms links, renders to HTML,
+    # applies the layout template, and writes to the destination directory.
+    # The destination path is resolved at publish time by combining
+    # destination_directory_path + destination_path.
+    #
+    # @return [Pathname] the destination path relative to working_directory
+    def publish!(show_navigation: nil, navigation: nil, navigation_depth: nil, navigation_title: nil)
+      if @style_mode == :external && @render_style
+        create_external_stylesheet
+      end
+    
+      # Read and parse Markdown into metadata + content
+      source_content = File.read(@source_path)
+      metadata, body = parse_metadata_from(source_content)
       
-      @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, root: root, destination: destination, context: context, name: name)
-      self.type = :document
-
-      # Each of these should invoke explicitly defined method
-      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
+      # Transform Markdown links, taking output format into account
+      body_with_rewritten_links = transform_markdown_links(body, &@transform_links)
+      
+      # Render Markdown to HTML
+      rendered_content = Renderers::Markdown.render(body_with_rewritten_links)
+      
+      # Create layout variables, for use in the layout template
+      layout_variables = {
+        working_directory: @working_directory,
+        current_path: @source_path.to_s,
+        metadata: metadata,
+        title: @title,
+        insert_title_heading: @insert_title_heading,
+        content: rendered_content.html_safe,
+        stylesheet_tag: render_stylesheet_tag(@style_path, @style_mode),
+        files: navigation ? generate_navigation_tree(navigation: navigation) : [],
+        show_navigation: show_navigation,
+        navigation_title: navigation_title
+      }
+      
+      # Render the layout
+      layout_content = File.read(@layout_path)
+      rendered_content = Renderers::Erb.render(layout_content, layout_variables)
+      
+      # Write the rendered content to the destination path
+      full_destination_path = @destination_directory_path.absolute? ? 
+        @destination_directory_path + @destination_path : 
+        @working_directory + @destination_directory_path + @destination_path
+      
+      full_destination_path.dirname.mkpath
+      full_destination_path.open("w+") do |f|
+        f << rendered_content
       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 = 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
-    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, {})
-    end
-
-    # Writes all rendered content where a) possible, b) required,
-    # and c) specified. Outputs to specified file.
-    def publish!(opts={})
-      options = { :render_style => true }.merge(opts)
-      super
-
-      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
-        end
+      # Return the destination path used, for use in verbose output
+      begin
+        full_destination_path.relative_path_from(@working_directory)
+      rescue ArgumentError
+        # If, for some reason, the paths don't share a common prefix,
+        # return the full path to avoid an error
+        full_destination_path
       end
-
-      Mint.after_publish(self, opts)
-    end
-
-    # Implicit readers are paired with explicit accessors. This
-    # allows for processing variables before storing them.
-    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
+    
+    # Transforms Markdown links from .md extensions
     #
-    # @param [File, #read, #basename] content the content to be rendered
-    #   from a templating language into HTML
-    # @return [void]
-    def content=(content)
-      tempfile = Helpers.generate_temp_file! content
-      original_content = File.read content
-
-      @metadata, text = Document.parse_metadata_from original_content
-      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
+    # @param [String] text the Markdown text containing links to Markdown documents
+    # @yield [String] block used to transform the basename of each Markdown link found
+    # @return [String] the text with transformed links
+    def transform_markdown_links(text, &block)
+      text.gsub(/(\[([^\]]*)\]\(([^)]*\.md)\))/) do |match|
+        link_text = $2
+        link_url = $3
+        
+        # Only transform relative links (not absolute URLs)
+        if link_url !~ /^https?:\/\//
+          # Preserve directory structure in links
+          dirname = File.dirname(link_url)
+          basename = File.basename(link_url, ".*")
+          
+          new_filename = yield basename
+          
+          new_url = if dirname == "."
+            new_filename
+          else
+            File.join(dirname, new_filename)
+          end
+          
+          "[#{link_text}](#{new_url})"
+        else
+          match
+        end
       end
-
-      @renderer = Mint.renderer tempfile
-      @content = @renderer.render
     end
 
-    # Sets layout to an existing Layout object or looks it up by name
+    # Generates navigation tree data for use in layout templates
     #
-    # @param [String, Layout, #render] layout a Layout object or name
-    #   of a layout to be looked up
-    # @return [void]
-    def layout=(layout)
-      @layout =
-        if layout.respond_to? :render
-          layout
-        else
-          layout_file = Mint.lookup_layout layout
-          Layout.new(layout_file, root: self.root, destination: self.destination, context: self.context)
-        end
+    # @return [Array<Hash>] array of navigation items with keys:
+    #   - :title (String) - display title for the item
+    #   - :html_path (String) - path to the HTML file (for files) or nil (for directories)  
+    #   - :source_path (String) - path to the source file relative to working directory
+    #   - :depth (Integer) - nesting depth in the tree
+    #   - :is_directory (Boolean) - true if this is a directory entry (optional key)
+    def generate_navigation_tree(navigation:)
+      # Build DocumentTree with documents (path + title pairs)
+      document_tree = DocumentTree.new(navigation)
+      reoriented_tree = document_tree.reorient(@destination_path)
+      
+      # Serialize to flat array for ERB template consumption
+      reoriented_tree.serialize(max_depth: @navigation_depth)
     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 =
-        if style.respond_to? :render
-          style
+    private
+    
+    # Calculates the relative path of a target pathname to a reference pathname; this is an
+    # extension of Pathname#relative_path_from that handles the case where the reference pathname
+    # is a file and the target pathname is a directory. In this case, the relative path should be
+    # the target pathname.
+    # 
+    # @param [Pathname] target_pathname the pathname to calculate the relative path for
+    # @param [Pathname] reference_pathname the pathname to use as the reference
+    # @return [Pathname] the relative path of the target pathname to the reference pathname
+    def calculate_relative_path(target_pathname, reference_pathname)
+      # Determine if reference is a file based on extension (since the file may not exist on disk yet)
+      reference_is_file = !reference_pathname.extname.empty?
+      reference_dir = reference_is_file ? reference_pathname.dirname : reference_pathname
+      
+      begin
+        relative_path = target_pathname.relative_path_from(reference_dir)
+        
+        # Prepend './' to relative paths that don't start with '../'
+        # to make it clear they are relative paths within the same directory tree
+        relative_str = relative_path.to_s
+        if relative_str.start_with?('../')
+          relative_path
         else
-          style_file = Mint.lookup_style style
-          Style.new(style_file, root: self.root, destination: self.destination, context: self.context)
+          Pathname.new("./#{relative_str}")
         end
-    end
-
-    # Overrides layout and style settings with named template.
-    #
-    # @param [String] template the name of the template to set as
-    #   layout and string
-    def template=(template)
-      if template
-        self.layout = template
-        self.style = template
+      rescue
+        target_pathname
       end
     end
-
-    # Explanation of style_destination:
-    #
-    # I'm going to maintain a document's official style_destination
-    # outside of its style object. If a document has no
-    # style_destination defined when it needs one, the document will
-    # use the original style's source directory.
-    #
-    # This decision eliminates edge cases, including the case where
-    # we want to generate, but not move, a document's style. It also
-    # lets us keep style information separate from document-specific
-    # information. (Without this separation, funky things happen when
-    # you assign a new style template to an existing document -- if
-    # you had specified a custom style_destination before changing
-    # the template, that custom destination would be overridden.)
-    #
-    # The style_destination attribute is lazy. It's exposed via
-    # virtual attributes like #style_destination_file.
-    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]
-    def style_destination=(style_destination)
-      @style_destination = style_destination
+    
+    def metadata_chunk(text)
+      text.split(METADATA_DELIM).first
     end
-
-    # Exposes style_destination as a Pathname object.
-    #
-    # @return [Pathname]
-    def style_destination_file_path
-      if style_destination
-        path = Pathname.new style_destination
-        dir = path.absolute? ?
-          path : destination_directory_path + path
-        dir + style.name
+    
+    def metadata_from(text)
+      raw_metadata = YAML.load(metadata_chunk(text))
+      
+      case raw_metadata
+      when String, false, nil
+        {}
       else
-        style.destination_file_path
+        raw_metadata
       end
+    rescue Psych::SyntaxError, Exception
+      {}
     end
 
-    # Exposes style_destination as a String.
-    #
-    # @return [String]
-    def style_destination_file
-      style_destination_file_path.to_s
-    end
-
-    # Exposes style_destination directory as a Pathname object.
-    #
-    # @return [Pathname]
-    def style_destination_directory_path
-      style_destination_file_path.dirname
-    end
-
-    # Exposes style_destination directory as a String.
-    #
-    # @return [String]
-    def style_destination_directory
-      style_destination_directory_path.to_s
-    end
-
-    # Convenience methods for views
-
-    # Returns a relative path from the document to its stylesheet. Can
-    # be called directly from inside a layout template.
-    def stylesheet
-      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
+    # Renders a stylesheet tag (either <style> or <link>) based on the style mode
+    # 
+    # @param [Pathname] style_path the path to the style file
+    # @param [Symbol] style_mode the style mode (:inline, :external, :original)
+    # @return [String] the stylesheet tag
+    def render_stylesheet_tag(style_path, style_mode)
+      return "" unless style_path&.exist?
+      
+      case style_mode
+      when :inline
+        "<style>#{Renderers::Css.render_file(style_path)}</style>"
       when :external
-        "<link rel=\"stylesheet\" href=\"#{stylesheet}\">".html_safe
+        full_destination_path = @destination_directory_path.absolute? ? 
+          @destination_directory_path + @destination_path : 
+          @working_directory + @destination_directory_path + @destination_path
+        absolute_stylesheet_path = external_stylesheet_destination_path
+        unless absolute_stylesheet_path.absolute?
+          absolute_stylesheet_path = @working_directory + absolute_stylesheet_path
+        end
+        relative_path_to_stylesheet = absolute_stylesheet_path.relative_path_from(full_destination_path.dirname)
+        "<link rel=\"stylesheet\" href=\"#{relative_path_to_stylesheet}\">"
       when :original
-        original_stylesheet_tags.html_safe
-      else # :inline (default)
-        "<style>#{self.style.render}</style>".html_safe
+        full_destination_path = @destination_directory_path.absolute? ? 
+          @destination_directory_path + @destination_path : 
+          @working_directory + @destination_directory_path + @destination_path
+        absolute_style_path = style_path.absolute? ? style_path : @working_directory + style_path
+        relative_path_to_original = absolute_style_path.relative_path_from(full_destination_path.dirname)
+        "<link rel=\"stylesheet\" href=\"#{relative_path_to_original}\">"
+      else
+        style_content = Renderers::Css.render_file(style_path)
+        "<style>#{style_content}</style>"
       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
+    
+    # Returns the destination path for the external stylesheet
     # 
-    # TODO: Implement injection of these styles
-    def inline_styles
-      CSS.parse(metadata)
+    # @return [Pathname] the destination path for the external stylesheet
+    def external_stylesheet_destination_path
+      @style_destination_path + "style.css"
     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
+    
+    # Creates an external stylesheet if the style mode is :external
+    def create_external_stylesheet
+      return unless @style_mode == :external
+      style_output_file = external_stylesheet_destination_path
+      style_output_file.dirname.mkpath
+      style_output_file.open("w+") do |f|
+        f << Renderers::Css.render_file(@style_path)
       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(' ')
+    
+    # Extracts title from Markdown file name
+    # 
+    # @param [Pathname] file_path path to Markdown file
+    # @return [String] extracted title
+    def guess_title
+      Helpers.extract_title_from_file(@source_path)
     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
+    
+    # Parse YAML metadata from markdown content
+    # 
+    # @param [String] text markdown content
+    # @return [Array] array of [metadata_hash, content_without_metadata]
+    def parse_metadata_from(text)
+      metadata = metadata_from(text)
+      new_text = if !metadata.empty?
+        text.sub(metadata_chunk(text) + METADATA_DELIM, "")
+      else
+        text
       end
       
-      destination
-    end
-
-    class << self
-      def metadata_chunk(text)
-        text.split(METADATA_DELIM).first
-      end
-
-      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 Psych::SyntaxError
-        {}
-      rescue Exception
-        {}
-      end
-
-      def parse_metadata_from(text)
-        metadata = metadata_from text
-        new_text =
-          if !metadata.empty?
-            text.sub metadata_chunk(text) + METADATA_DELIM, ""
-          else
-            text
-          end
-
-        [metadata, new_text]
-      end
+      [metadata, new_text]
     end
   end
-end
+end