middleman-core 3.0.0.beta.1 → 3.0.0.beta.2

data/lib/middleman-core/core_extensions/front_matter.rb

@@ -1,18 +1,33 @@
+# Parsing YAML frontmatter
 require "yaml"
+
+# Looking up Tilt extensions
 require "tilt"
 
+# Frontmatter namespace
 module Middleman::CoreExtensions::FrontMatter
+  
+  # Setup extension
   class << self
+    
+    # Once registered
     def registered(app)
       app.set :frontmatter_extensions, %w(.htm .html .php)
       app.extend ClassMethods
       app.send :include, InstanceMethods
       app.delegate :frontmatter_changed, :to => :"self.class"
+      
+      ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
     end
     alias :included :registered
   end
   
+  # Frontmatter class methods
   module ClassMethods
+    
+    # Register callback on frontmatter updates
+    # @param [Regexp] matcher
+    # @return [Array<Array<Proc, Regexp>>]
     def frontmatter_changed(matcher=nil, &block)
       @_frontmatter_changed ||= []
       @_frontmatter_changed << [block, matcher] if block_given?
@@ -20,29 +35,40 @@ module Middleman::CoreExtensions::FrontMatter
     end
   end
   
+  module ResourceInstanceMethods
+
+    # This page's frontmatter
+    # @return [Hash]
+    def data
+      app.frontmatter(relative_path).first
+    end
+    
+  end
+  
+  # Frontmatter instance methods
   module InstanceMethods
+    
+    # Override init
     def initialize
-      super
-      
       exts = frontmatter_extensions.join("|").gsub(".", "\.")
       
-      static_path = source_dir.sub(self.root, "").sub(/^\//, "").sub(/\/$/, "") + "/"
+      static_path = source_dir.sub(root, "").sub(/^\//, "").sub(/\/$/, "") + "/"
 
       matcher = %r{#{static_path}.*(#{exts})}
       
-      self.files.changed matcher do |file|
-        self.frontmatter_extension.touch_file(file)
+      files.changed matcher do |file|
+        frontmatter_extension.touch_file(file)
       end
 
-      self.files.deleted matcher do |file|
-        self.frontmatter_extension.remove_file(file)
+      files.deleted matcher do |file|
+        frontmatter_extension.remove_file(file)
       end
 
-      provides_metadata matcher do |path|
-        relative_path = path.sub(source_dir, "")
+      sitemap.provides_metadata matcher do |path|
+        relative_path = path.sub(self.source_dir, "")
 
-        fmdata = if frontmatter_extension.has_data?(relative_path)
-          frontmatter(relative_path)[0]
+        fmdata = if self.frontmatter_extension.has_data?(relative_path)
+          self.frontmatter(relative_path)[0]
         else
           {}
         end
@@ -54,8 +80,16 @@ module Middleman::CoreExtensions::FrontMatter
 
         { :options => data, :page => fmdata }
       end
+
+      # Initialize class
+      frontmatter_extension
+
+      super
     end
 
+    # Notify callbacks that the frontmatter changed
+    # @param [String] path
+    # @return [void]
     def frontmatter_did_change(path)
       frontmatter_changed.each do |callback, matcher|
         next if path.match(%r{^#{build_dir}/})
@@ -64,26 +98,50 @@ module Middleman::CoreExtensions::FrontMatter
       end
     end
     
+    # Get the frontmatter object
+    # @return [Middleman::CoreExtensions::FrontMatter::FrontMatter]
     def frontmatter_extension
       @_frontmatter_extension ||= FrontMatter.new(self)
     end
     
+    # Get the frontmatter for the given params
+    # @param [String] path
+    # @return [Hash, nil]
     def frontmatter(*args)
       frontmatter_extension.data(*args)
     end
   end
   
+  # Core Frontmatter class
   class FrontMatter
+    
+    # Initialize frontmatter with current app
+    # @param [Middleman::Application] app
     def initialize(app)
       @app = app
       @source = File.expand_path(@app.source, @app.root)
       @local_data = {}
+      
+      # Setup ignore callback
+      @app.ignore do |path|
+        if p = @app.sitemap.find_resource_by_path(path)
+          !p.proxy? && p.data && p.data["ignored"] == true
+        else
+          false
+        end
+      end
     end
     
+    # Whether the frontmatter knows about a path
+    # @param [String] path
+    # @return [Boolean]
     def has_data?(path)
       @local_data.has_key?(path.to_s)
     end
     
+    # Update frontmatter if a file changes
+    # @param [String] file
+    # @return [void]
     def touch_file(file)
       extension = File.extname(file).sub(/\./, "")
       return unless ::Tilt.mappings.has_key?(extension)
@@ -95,7 +153,8 @@ module Middleman::CoreExtensions::FrontMatter
         
       if result
         data, content = result
-        data = ::Middleman.recursively_enhance(data)
+
+        data = ::Middleman::Util.recursively_enhance(data).freeze
         file = file.sub(@app.source_dir, "")
         @local_data[file] = [data, content]
         path = File.join(@app.source_dir, file)
@@ -104,28 +163,40 @@ module Middleman::CoreExtensions::FrontMatter
       end
     end
     
+    # Update frontmatter if a file is delted
+    # @param [String] file
+    # @return [void]
     def remove_file(file)
       file = File.expand_path(file, @app.root)
       file = file.sub(@app.source_dir, "")
-      # @app.logger.debug :frontmatter_remove, Time.now, file if @app.logging?
       
       if @local_data.has_key?(file)
+        path = File.join(@app.source_dir, file)
+        @app.cache.remove(:raw_template, path)
         @local_data.delete(file) 
       end
     end
     
+    # Get the frontmatter for a given path
+    # @param [String] path
+    # @return [Hash]
     def data(path)
       if @local_data.has_key?(path.to_s)
         @local_data[path.to_s]
       else
-        nil
+        {}.freeze
       end
     end
     
   private
+    # Parse frontmatter out of a string
+    # @param [String] content
+    # @return [Array<Hash, String>]
     def parse_front_matter(content)
       yaml_regex = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
       if content =~ yaml_regex
+        content = content[($1.size + $2.size)..-1]
+        
         begin
           data = YAML.load($1)
         rescue => e
@@ -133,7 +204,6 @@ module Middleman::CoreExtensions::FrontMatter
           return false
         end
 
-        content = content.split(yaml_regex).last
       else
         return false
       end

data/lib/middleman-core/core_extensions/i18n.rb

@@ -0,0 +1,137 @@
+# i18n Namespace
+module Middleman::CoreExtensions::I18n
+
+  # Setup extension
+  class << self
+    
+    # Once registerd
+    def registered(app)
+      app.set :locales_dir, "locales"
+
+      app.send :include, InstanceMethods
+      
+      # Needed for helpers as well
+      app.after_configuration do
+        ::I18n.load_path = [Dir[File.join(root, locales_dir, "*.yml")]]
+        ::I18n.reload!
+      end
+    end
+    alias :included :registered
+  end
+  
+  class Localizer
+    def initialize(app)
+      @app = app
+      @maps = {}
+    end
+    
+    def setup(options)
+      @options = options
+      
+      @lang_map      = @options[:lang_map]      || {}
+      @path          = @options[:path]          || "/:locale/"
+      @templates_dir = @options[:templates_dir] || "localizable"
+      @mount_at_root = @options.has_key?(:mount_at_root) ? @options[:mount_at_root] : langs.first
+      
+      if !@app.build?
+        puts "== Locales: #{langs.join(", ")}"
+      end
+      
+      # Don't output localizable files
+      @app.ignore File.join(@templates_dir, "**")
+      
+      @app.sitemap.provides_metadata_for_path do |url|
+        if d = get_localization_data(url)
+          lang, page_id = d
+          instance_vars = Proc.new {
+            ::I18n.locale = lang
+            @lang         = lang
+            @page_id      = page_id
+          }
+          { :blocks => [instance_vars] }
+        else
+          {}
+        end
+      end
+      
+      @app.sitemap.register_resource_list_manipulator(
+        :i18n,
+        @app.i18n
+      )
+    end
+    
+    def langs
+      @options[:langs] || begin
+        Dir[File.join(@app.root, @app.locales_dir, "*.yml")].map { |file| 
+          File.basename(file).gsub(".yml", "") 
+        }.sort.map(&:to_sym)
+      end
+    end
+    
+    def get_localization_data(path)
+      @_localization_data ||= {}
+      @_localization_data[path]
+    end
+    
+    # Update the main sitemap resource list
+    # @return [void]
+    def manipulate_resource_list(resources)
+      @_localization_data = {}
+      
+      new_resources = []
+      
+      resources.each do |resource|
+        next unless File.fnmatch(File.join(@templates_dir, "**"), resource.path)
+        
+        page_id = File.basename(resource.path, File.extname(resource.path))
+      
+        langs.map do |lang|
+          ::I18n.locale = lang
+        
+          localized_page_id = ::I18n.t("paths.#{page_id}", :default => page_id)
+          path = resource.path.sub(@templates_dir, "")
+          
+          # Build lang path
+          if @mount_at_root == lang
+            prefix = "/"
+          else
+            replacement = @lang_map.has_key?(lang) ? @lang_map[lang] : lang
+            prefix = @path.sub(":locale", replacement.to_s)
+          end
+          
+          path = ::Middleman::Util.normalize_path(
+            File.join(prefix, path.sub(page_id, localized_page_id))
+          )
+          
+          @_localization_data[path] = [lang, path, localized_page_id]
+          
+          p = ::Middleman::Sitemap::Resource.new(
+            @app.sitemap,
+            path
+          )
+          p.proxy_to(resource.path)
+          
+          new_resources << p
+        end
+      end
+      
+      resources + new_resources
+    end
+  end
+  
+  # Frontmatter class methods
+  module InstanceMethods
+    
+    # Initialize the i18n
+    def i18n
+      @_i18n ||= Localizer.new(self)
+    end
+    
+    # Main i18n API
+    def localize(options={})
+      settings.after_configuration do
+        i18n.setup(options)
+      end
+    end
+  end
+end

data/lib/middleman-core/core_extensions/rendering.rb

@@ -1,27 +1,44 @@
+require "middleman-core/renderers/erb"
+
 # Shutup Tilt Warnings
+# @private
 class Tilt::Template
   def warn(*args)
     # Kernel.warn(*args)
   end
 end
 
+# Rendering extension
 module Middleman::CoreExtensions::Rendering
+  
+  # Setup extension
   class << self
+    
+    # Once registered
     def registered(app)
+      # Include methods
       app.send :include, InstanceMethods
       
       # Activate custom renderers
       app.register Middleman::Renderers::ERb
     end
+    
     alias :included :registered
   end
   
+  # Custom error class for handling
   class TemplateNotFound < RuntimeError
   end
   
+  # Rendering instance methods
   module InstanceMethods
+    
+    # Override init to clear cache on file removal
     def initialize
-      super
+      # Default extension map
+      @_template_extensions = {
+        
+      }
       
       static_path = source_dir.sub(self.root, "").sub(/^\//, "")
       render_regex = static_path.empty? ? // : (%r{^#{static_path + "/"}})
@@ -30,41 +47,73 @@ module Middleman::CoreExtensions::Rendering
         path = File.expand_path(file, self.root)
         self.cache.remove(:raw_template, path)
       end
+
+      super
+    end
+    
+    # Add or overwrite a default template extension
+    #
+    # @param [Hash] extension_map
+    # @return [void]
+    def template_extensions(extension_map={})
+      @_template_extensions.merge!(extension_map)
     end
     
+    # Render a template, with layout, given a path
+    #
+    # @param [String] path
+    # @param [Hash] locs
+    # @param [Hash] opts
+    # @return [String]
     def render_template(path, locs={}, opts={})
+      # Detect the remdering engine from the extension
       extension = File.extname(path)
       engine = extension[1..-1].to_sym
 
+      # Store last engine for later (could be inside nested renders)
       @current_engine, engine_was = engine, @current_engine
       
       # Use a dup of self as a context so that instance variables set within 
       # the template don't persist for other templates.
       context = self.dup
 
+      # Store current locs/opts for later
       @current_locs = locs, @current_opts = opts
 
+      # Keep rendering template until we've used up all extensions. This handles
+      # cases like `style.css.sass.erb`
       while ::Tilt[path]
         content = render_individual_file(path, locs, opts, context)
         path = File.basename(path, File.extname(path))
         cache.set([:raw_template, path], content)
       end
       
-      needs_layout = !%w(.js .css .txt).include?(extension)
+      # Certain output file types don't use layouts
+      needs_layout = !%w(.js .json .css .txt).include?(extension)
       
+      # If we need a layout and have a layout, use it
       if needs_layout && layout_path = fetch_layout(engine, opts)
         content = render_individual_file(layout_path, locs, opts, context) { content }
       end
         
+      # Return result
       content
     ensure
+      # Pop all the saved variables from earlier as we may be returning to a 
+      # previous render (layouts, partials, nested layouts).
       @current_engine = engine_was
       @content_blocks = nil
       @current_locs = nil
       @current_opts = nil
     end
     
-    # Sinatra/Padrino render method signature.
+    # Sinatra/Padrino compatible render method signature referenced by some view
+    # helpers. Especially partials.
+    #
+    # @param [String, Symbol] engine
+    # @param [String, Symbol] data
+    # @param [Hash] options
+    # @return [String]
     def render(engine, data, options={}, &block)
       data = data.to_s
 
@@ -73,30 +122,36 @@ module Middleman::CoreExtensions::Rendering
       found_partial = false
       engine        = nil
 
-      if sitemap.exists?(current_path)
-        page = sitemap.page(current_path)
-        current_dir = File.dirname(page.source_file)
-        engine = File.extname(page.source_file)[1..-1].to_sym
+      # If the path is known to the sitemap
+      if resource = sitemap.find_resource_by_path(current_path)
+        current_dir = File.dirname(resource.source_file)
+        engine = File.extname(resource.source_file)[1..-1].to_sym
 
+        # Look for partials relative to the current path
         if current_dir != self.source_dir
           relative_dir = File.join(current_dir.sub("#{self.source_dir}/", ""), data)
 
-          found_partial, found_engine = resolve_template(relative_dir, :preferred_engine => engine)
+          # Try to use the current engine first
+          found_partial, found_engine = resolve_template(relative_dir, :preferred_engine => engine, :try_without_underscore => true)
 
+          # Fall back to any engine available
           if !found_partial
-            found_partial, found_engine = resolve_template(relative_dir)
+            found_partial, found_engine = resolve_template(relative_dir, :try_without_underscore => true)
           end
         end
       end
-
+      
+      # Look in the root for the partial with the current engine
       if !found_partial && !engine.nil?
-        found_partial, found_engine = resolve_template(data, :preferred_engine => engine)
+        found_partial, found_engine = resolve_template(data, :preferred_engine => engine, :try_without_underscore => true)
       end
 
+      # Look in the root with any engine
       if !found_partial
-        found_partial, found_engine = resolve_template(data)
+        found_partial, found_engine = resolve_template(data, :try_without_underscore => true)
       end
 
+      # Render the partial if found, otherwide throw exception
       if found_partial
         render_individual_file(found_partial, locals, options, self, &block)
       else
@@ -104,34 +159,53 @@ module Middleman::CoreExtensions::Rendering
       end
     end
 
-    # @private
+    # Render an on-disk file. Used for everything, including layouts.
+    #
+    # @param [String, Symbol] path
+    # @param [Hash] locs
+    # @param [Hash] opts
+    # @param [Class] context
+    # @return [String]
     def render_individual_file(path, locs = {}, opts = {}, context = self, &block)
       path = path.to_s
       
+      # Save current buffere for later
       @_out_buf, _buf_was = "", @_out_buf
       
+      # Read from disk or cache the contents of the file
       body = cache.fetch(:raw_template, path) do
         File.read(path)
       end
       
+      # Merge per-extension options from config
       extension = File.extname(path)
       options = opts.merge(options_for_ext(extension))
       options[:outvar] ||= '@_out_buf'
 
+      # Read compiled template from disk or cache
       template = cache.fetch(:compiled_template, options, body) do
         ::Tilt.new(path, 1, options) { body }
       end
 
+      # Render using Tilt
       template.render(context, locs, &block)
-    ensure  
+    ensure
+      # Reset stored buffer
       @_out_buf = _buf_was
     end
     
-    # @private
+    # Get a hash of configuration options for a given file extension, from 
+    # config.rb
+    #
+    # @param [String] ext
+    # @return [Hash]
     def options_for_ext(ext)
+      # Read options for extension from config/Tilt or cache
       cache.fetch(:options_for_ext, ext) do
         options = {}
 
+        # Find all the engines which handle this extension in tilt. Look for 
+        # config variables of that name and merge it
         extension_class = ::Tilt[ext]
         ::Tilt.mappings.each do |ext, engines|
           next unless engines.include? extension_class
@@ -143,13 +217,21 @@ module Middleman::CoreExtensions::Rendering
       end
     end
   
-    # @private
+    # Find a layout for a given engine
+    #
+    # @param [Symbol] engine
+    # @param [Hash] opts
+    # @return [String]
     def fetch_layout(engine, opts)
+      # The layout name comes from either the system default or the options
       local_layout = opts.has_key?(:layout) ? opts[:layout] : layout
       return false unless local_layout
     
+      # Look for engine-specific options
       engine_options = respond_to?(engine) ? send(engine) : {}
 
+      # The engine for the layout can be set in options, engine_options or passed
+      # into this method
       layout_engine = if opts.has_key?(:layout_engine)
         opts[:layout_engine]
       elsif engine_options.has_key?(:layout_engine)
@@ -158,7 +240,7 @@ module Middleman::CoreExtensions::Rendering
         engine
       end
 
-      # Automatic
+      # Automatic mode
       if local_layout == :_auto_layout
         # Look for :layout of any extension
         # If found, use it. If not, continue
@@ -174,10 +256,15 @@ module Middleman::CoreExtensions::Rendering
       end
     end
   
-    # @private
+    # Find a layout on-disk, optionally using a specific engine
+    # @param [String] name
+    # @param [Symbol] preferred_engine
+    # @return [String]
     def locate_layout(name, preferred_engine=nil)
+      # Whether we've found the layout
       layout_path = false
       
+      # If we prefer a specific engine
       if !preferred_engine.nil?
         # Check root
         layout_path, layout_engine = resolve_template(name, :preferred_engine => preferred_engine)
@@ -198,38 +285,52 @@ module Middleman::CoreExtensions::Rendering
         layout_path, layout_engine = resolve_template(File.join("layouts", name.to_s))
       end
     
+      # Return the path
       layout_path
     end
     
+    # Allow layouts to be wrapped in the contents of other layouts
+    # @param [String, Symbol] layout_name
+    # @return [void]
     def wrap_layout(layout_name, &block)
       content = capture(&block) if block_given?
       layout_path = locate_layout(layout_name, current_engine)
       concat render_individual_file(layout_path, @current_locs || {}, @current_opts || {}, self) { content }
     end
-  
+    
+    # The currently rendering engine
+    # @return [Symbol, nil]
     def current_engine
       @current_engine ||= nil
     end
     
-    # @private
+    # Find a template on disk given a output path
+    # @param [String] request_path
+    # @param [Hash] options
+    # @return [Array<String, Symbol>, Boolean]
     def resolve_template(request_path, options={})
+      # Find the path by searching or using the cache
       request_path = request_path.to_s
       cache.fetch(:resolve_template, request_path, options) do
         relative_path = request_path.sub(%r{^/}, "")
         on_disk_path  = File.expand_path(relative_path, self.source_dir)
 
+        # By default, any engine will do
         preferred_engine = "*"
       
+        # Unless we're specifically looking for a preferred engine
         if options.has_key?(:preferred_engine)
           extension_class = ::Tilt[options[:preferred_engine]]
           matched_exts = []
 
+          # Get a list of extensions for a preferred engine
           # TODO: Cache this
           ::Tilt.mappings.each do |ext, engines|
             next unless engines.include? extension_class
             matched_exts << ext
           end
 
+          # Change the glob to only look for the matched extensions
           if matched_exts.length > 0
             preferred_engine = "{" + matched_exts.join(",") + "}"
           else
@@ -237,11 +338,23 @@ module Middleman::CoreExtensions::Rendering
           end
         end
 
+        # Look for files that match
         path_with_ext = on_disk_path + "." + preferred_engine
+        
         found_path = Dir[path_with_ext].find do |path|
           ::Tilt[path]
         end
         
+        if !found_path && options[:try_without_underscore] && 
+          path_no_underscore = path_with_ext.
+            sub(relative_path, relative_path.sub(/^_/, "").
+            sub(/\/_/, "/"))
+          found_path = Dir[path_no_underscore].find do |path|
+            ::Tilt[path]
+          end
+        end
+        
+        # If we found one, return it and the found engine
         if found_path || (File.exists?(on_disk_path) && !File.directory?(on_disk_path))
           engine = found_path ? File.extname(found_path)[1..-1].to_sym : nil
           [ found_path || on_disk_path, engine ]
@@ -251,4 +364,4 @@ module Middleman::CoreExtensions::Rendering
       end
     end
   end
-end
+end