mint 0.8.1 → 0.10.0

data/lib/mint/document_tree.rb

@@ -0,0 +1,163 @@
+require "pathname"
+
+module Mint
+  class DocumentTree
+    attr_reader :nodes
+    
+    # Initializes a new DocumentTree with the given documents
+    #
+    # @param [Array<Document>] documents array of documents to add to the tree
+    def initialize(documents)
+      @nodes = []
+      documents.each do |document|
+        add_document(document.destination_path, document.title)
+      end
+      sort_nodes!
+    end
+    
+    # Returns new DocumentTree with paths relative to reference_pathname
+    # Preserves the tree structure but reorients all paths
+    #
+    # @param [Pathname] reference_pathname path to the reference pathname
+    # @return [DocumentTree] new DocumentTree with paths relative to reference_pathname
+    def reorient(reference_pathname)
+      reoriented_nodes = reorient_nodes(@nodes, reference_pathname)
+      new_tree = DocumentTree.allocate
+      new_tree.instance_variable_set(:@nodes, reoriented_nodes)
+      new_tree
+    end
+    
+    # Serializes the tree to a flat array for ERB template consumption
+    # 
+    # ERB templates cannot easily handle recursive tree structures with arbitrary depth,
+    # so we flatten the tree into a simple array of hashes that the template can iterate over.
+    # Each hash contains the navigation item data (title, paths, depth) needed for rendering.
+    #
+    # @param [Integer] max_depth maximum navigation depth (optional)
+    # @return [Array<Hash>] flattened array of navigation items
+    def serialize(max_depth: nil)
+      result = []
+      flatten_nodes(@nodes, result, max_depth: max_depth)
+      result
+    end
+    
+    private
+    
+    def add_document(path, title)
+      parts = path.to_s.split('/').reject(&:empty?)
+      current_nodes = @nodes
+      
+      parts.each_with_index do |part, idx|
+        # Find or create node for this part
+        node = current_nodes.find {|n| n.name == part }
+        
+        if node.nil?
+          # Create new node
+          path_so_far = Pathname.new(parts[0..idx].join('/'))
+          is_file = (idx == parts.length - 1)
+          
+          node = DocumentTreeNode.new(
+            name: part,
+            pathname: path_so_far,
+            title: is_file ? title : part,
+            depth: idx,
+            is_file: is_file
+          )
+          current_nodes << node
+        end
+        
+        current_nodes = node.children
+      end
+    end
+    
+    def sort_nodes!
+      sort_nodes_recursive(@nodes)
+    end
+    
+    def sort_nodes_recursive(nodes)
+      nodes.sort_by! {|node| [node.directory? ? 0 : 1, node.name] }
+      nodes.each {|node| sort_nodes_recursive(node.children) }
+    end
+    
+    def reorient_nodes(nodes, reference_pathname)
+      nodes.map do |node|
+        new_pathname = calculate_relative_path(node.pathname, reference_pathname)
+        new_children = reorient_nodes(node.children, reference_pathname)
+        
+        DocumentTreeNode.new(
+          name: node.name,
+          pathname: new_pathname,
+          title: node.title,
+          depth: node.depth,
+          is_file: node.file?
+        ).tap do |new_node|
+          new_node.instance_variable_set(:@children, new_children)
+        end
+      end
+    end
+    
+    def flatten_nodes(nodes, result, depth = 0, max_depth: nil)
+      return if max_depth && depth >= max_depth
+      
+      nodes.each do |node|
+        if node.file?
+          result << {
+            title: node.title,
+            html_path: node.pathname.to_s,
+            source_path: node.pathname.to_s,
+            depth: depth
+          }
+        else
+          result << {
+            title: node.title,
+            html_path: nil,
+            source_path: nil,
+            depth: depth,
+            is_directory: true
+          }
+          
+          flatten_nodes(node.children, result, depth + 1, max_depth: max_depth)
+        end
+      end
+    end
+    
+    def calculate_relative_path(target_pathname, reference_pathname)
+      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)
+        
+        relative_str = relative_path.to_s
+        if relative_str.start_with?('../')
+          relative_path
+        else
+          Pathname.new("./#{relative_str}")
+        end
+      rescue
+        target_pathname
+      end
+    end
+  end
+
+  class DocumentTreeNode
+    attr_reader :name, :pathname, :title, :children, :depth
+    
+    def initialize(name:, pathname:, title:, depth: 0, is_file: false)
+      @name = name
+      @pathname = pathname
+      @title = title
+      @depth = depth
+      @is_file = is_file
+      @children = []
+    end
+    
+    def file?
+      @is_file
+    end
+    
+    def directory?
+      !@is_file
+    end
+  end
+end

data/lib/mint/exceptions.rb

@@ -1,5 +1,4 @@
 module Mint
-  # Indicates that a named template is not located anywhere
-  # in the Mint path.
-  class TemplateNotFoundException < Exception; end
+  class LayoutNotFoundException < Exception; end
+  class StyleNotFoundException < Exception; end
 end

data/lib/mint/helpers.rb

@@ -1,193 +1,36 @@
 require "pathname"
-require "tempfile"
-require "yaml"
-require "active_support/core_ext/string/inflections"
 
 module Mint
   module Helpers
-    def self.underscore(obj, opts={})
-      namespaces = obj.to_s.split("::").map do |namespace|
-        if opts[:ignore_prefix]
-          namespace[0..1].downcase + namespace[2..-1]
-        else
-          namespace
-        end
-      end
-
-      string = opts[:namespaces] ? namespaces.join("::") : namespaces.last
-      string.underscore
-    end
-
-    # Transforms a String into a URL-ready slug. Properly handles
-    # ampersands, non-alphanumeric characters, extra hyphens and spaces.
-    #
-    # @param [String, #to_s] obj an object to be turned into a slug
-    # @return [String] a URL-ready slug
-    def self.slugize(obj)
-      obj.to_s.downcase.
-        gsub(/&/, "and").
-        gsub(/[\s-]+/, "-").
-        gsub(/[^a-z0-9-]/, "").
-        gsub(/[-]+/, "-")
-    end
-
-    # Transforms a potentially hyphenated String into a symbol name.
-    #
-    # @param [String, #to_s] obj an object to be turned into a symbol name
-    # @return [Symbol] a symbol representation of obj
-    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
-    # @return [Pathname] an expanded representation of str_or_path
-    def self.pathize(str_or_path)
-      case str_or_path
-      when String
-        Pathname.new str_or_path
-      when Pathname
-        str_or_path
-      end.expand_path
-    end
-
-    # Recursively transforms all keys in a Hash into Symbols.
-    #
-    # @param [Hash, #[]] map a potentially nested Hash containing symbolizable keys
-    # @return [Hash] a version of map where all keys are symbols
-    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] =
-          case v
-          when Hash
-            self.symbolize_keys(v, opts)
-          else
-            v
-          end
-        syms
-      end
-    end
-
-    def self.listify(list)
-      if list.length > 2
-        list[0..-2].join(", ") + " & " + list.last
+    def self.drop_pathname(pathname, levels_to_drop)
+      parts = pathname.to_s.split('/').reject(&:empty?)
+      if levels_to_drop >= parts.length
+        pathname
       else
-        list.join(" & ")
-      end
-    end
-
-    def self.standardize(metadata, opts={})
-      table = opts[:table] || {}
-      metadata.reduce({}) do |hash, (key,value)|
-        if table[key] && table[key].length == 2
-          standard_key, standard_type = table[key]
-          standard_value =
-            case standard_type
-            when :array
-              [*value]
-            when :string
-              value
-            else
-              # If key/type were not in table
-              value
-            end
-
-          hash[standard_key] = standard_value
+        dropped_parts = parts.drop(levels_to_drop)
+        if dropped_parts.empty?
+          Pathname.new('.')
         else
-          hash[key] = value
+          Pathname.new(dropped_parts.join('/'))
         end
-        hash
       end
     end
-
-    def self.hashify(list1, list2)
-      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 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
-    #   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_path.relative_path_from(from_path) :
-        to_path
-    end
-
-    # Reads Yaml options from file. Updates values with new_opts. Writes
-    # merged data back to the same file, overwriting previous data.
-    #
-    # @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]
-    def self.update_yaml!(file, opts={})
-      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)
+    
+    def self.extract_title_from_file(file_path)
+      content = File.read(file_path.to_s)
+      
+      # Check for Title metadata in Markdown front matter
+      if content =~ /^---\n.*?^title:\s*(.+)$/m
+        return $1.strip.gsub(/^["']|["']$/, '')
       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
-      content   = File.read file
-
-      tempfile = Tempfile.new([basename, extension])
-      tempfile << content
-      tempfile.flush
-      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
+      
+      # Check for first markdown heading  
+      if content =~ /^#\s+(.+)$/
+        return $1.strip
       end
+      
+      # Fall back to upcased filename with underscores/hyphens converted to spaces
+      file_path.basename('.*').to_s.tr('_-', ' ').upcase
     end
   end
-end
+end

data/lib/mint/layout.rb

@@ -1,14 +1,31 @@
-require "mint/resource"
+require "pathname"
 
 module Mint
-  class Layout < Resource
-    # Creates a new Layout object using a mandatory source file
-    # and optional configuration options.
+  module Layout
+    HTML_EXTENSIONS = ["html", "erb"]
+    
+    # Indicates whether the file is a valid layout file
     #
-    # @param [String] source the absolute or relative file path
-    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
+    # @param [Pathname] pathname the pathname to check
+    # @return [Boolean] true if the file is a valid layout file
+    def self.valid?(pathname)
+      HTML_EXTENSIONS.map {|ext| "layout.#{ext}" }.include? pathname.basename.to_s
+    end
+    
+    # Returns the layout file for the given template name
+    #
+    # @param [String] name the template name or directory path to look up
+    # @return [Pathname] path to the layout file
+    def self.find_by_name(name)
+      find_in_directory Template.find_directory_by_name(name)
+    end
+    
+    # Finds the layout file in a specific directory
+    #
+    # @param [Pathname] directory the directory to look in
+    # @return [Pathname] path to the layout file
+    def self.find_in_directory(directory)
+      directory&.children&.select(&:file?)&.select(&method(:valid?))&.first
     end
   end
-end
+end

data/lib/mint/renderers/css_renderer.rb

@@ -0,0 +1,32 @@
+module Mint
+  module Renderers
+    class Css
+      def self.render_file(css_file)
+        self.process(css_file.read, css_file.dirname)
+      end
+      
+      def self.process(css_content, base_dir)
+        css_content.gsub(/@import\s+["']([^"']+)["'];?/) do |match|
+          import_path = Pathname.new $1
+          
+          if import_path.relative?
+            full_path = import_path.expand_path base_dir
+          else
+            full_path = base_dir + import_path
+          end
+  
+          if full_path.extname != '.css'
+            full_path.rename(full_path.to_s + '.css') 
+          end
+  
+          if full_path.exist?
+            imported_content = full_path.read
+            self.process(imported_content, full_path.dirname)
+          else
+            match
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mint/renderers/erb_renderer.rb

@@ -0,0 +1,11 @@
+require "erb"
+
+module Mint
+  module Renderers
+    class Erb
+      def self.render(content, variables)
+        ERB.new(content).result_with_hash(variables)
+      end
+    end
+  end
+end

data/lib/mint/renderers/markdown_renderer.rb

@@ -0,0 +1,45 @@
+require 'redcarpet'
+
+module Mint
+  module Renderers
+    class Markdown
+      def self.render(text, variables = {}, **markdown_options)
+        # Use default rendering options (all extra options turned off)
+        # See documentation for more information:
+        # https://github.com/vmg/redcarpet#darling-i-packed-you-a-couple-renderers-for-lunch
+        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
+        }
+        
+        markdown_options = {
+          tables: true,
+          autolink: true,
+          no_intra_emphasis: true,
+          fenced_code_blocks: true,
+          strikethrough: true,
+          superscript: true,
+          footnotes: true,
+          highlight: true,
+          quote: true,
+          space_after_headers: true,
+          underline: true,
+          # Additional options
+          # lax_html_blocks: false,
+          # disable_indented_code_blocks: false
+          }.merge(markdown_options)
+        
+        renderer = Redcarpet::Render::HTML.new(renderer_options)
+        parser = Redcarpet::Markdown.new(renderer, markdown_options)
+        parser.render text
+      end
+    end
+  end
+end

data/lib/mint/style.rb

@@ -1,41 +1,31 @@
-require "mint/resource"
+require "pathname"
 
 module Mint
-  class Style < Resource
-    # Creates a new Style object using a mandatory source file
-    # and optional configuration options.
+  module Style
+    CSS_EXTENSIONS = ["css"]
+    
+    # Indicates whether the file is a valid stylesheet
     #
-    # @param [String] source the absolute or relative file path
-    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 = :style
-
-      # We want to render final stylesheet to the /css subdirectory if
-      # an output directory is not specified and we are dealing with
-      # a named template (not a local file). If we don't do this, the rendered
-      # CSS file might be picked up next time we look for a named template
-      # in this directory, and the (correct) SASS file won't be picked up.
-      # However, if a destination directory is already specified, we
-      # leave it alone.
-      if Mint.template?(self.source_directory) and rendered?
-        tmp_dir = Mint.path_for_scope(:user) + "tmp"
-        self.destination ||= tmp_dir.to_s
-        self.root = "/"
-      end
+    # @param [Pathname] pathname the pathname to check
+    # @return [Boolean] true if the file is a valid stylesheet
+    def self.valid?(pathname)
+      CSS_EXTENSIONS.map {|ext| "style.#{ext}" }.include? pathname.basename.to_s
     end
-
-    # Determines whether a Style object is supposed to be rendered.
+    
+    # Returns the style file for the given template name
     #
-    # @return [Boolean] whether or not style should be rendered
-    def rendered?
-      true  # All styles need rendering now (CSS for imports, Sass for compilation)
+    # @param [String] name the template name to look up
+    # @return [Pathname] path to the style file
+    def self.find_by_name(name)
+      find_in_directory Template.find_directory_by_name(name)
     end
 
-    # Renders a Style object through Tilt template system
+    # Finds the style file in a specific directory
     #
-    # @return [String] a rendered stylesheet  
-    def render
-      super
+    # @param [Pathname] directory the directory to look in
+    # @return [Pathname] path to the style file
+    def self.find_in_directory(directory)
+      directory&.children&.select(&:file?)&.select(&method(:valid?))&.first
     end
   end
-end
+end

data/lib/mint/template.rb

@@ -0,0 +1,30 @@
+require "pathname"
+
+module Mint
+  module Template
+    # Indicates whether the directory is a valid template directory.
+    #
+    # @param [Pathname] directory the directory to check
+    # @return [Boolean] true if the directory is a valid template directory
+    def self.valid?(directory)
+      # Note that typically templates have only a stylesheet, although they can
+      # optionally include a layout file. Most templates can get by with the layout
+      # provided by the default template, which is automatically used if no layout
+      # file is provided in the template directory.
+      directory.children.
+        select(&:file?).
+        select(&Style.method(:valid?))
+    end
+    
+    # Finds a template directory by name
+    #
+    # @param [String] name the template name to find
+    # @return [Pathname] path to the template directory
+    def self.find_directory_by_name(name)
+      Mint::PATH.
+        map {|p| p + Mint::TEMPLATES_DIRECTORY + name }.
+        select(&:exist?).
+        first
+    end
+  end
+end

data/lib/mint/version.rb

@@ -1,3 +1,3 @@
 module Mint
-  VERSION = "0.8.1"
+  VERSION = "0.10.0"
 end