middleman-core 3.0.0.alpha.7

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

@@ -0,0 +1,83 @@
+require "find"
+
+# API for watching file change events
+module Middleman::CoreExtensions::FileWatcher
+  # Setup extension
+  class << self
+    # @private
+    def registered(app)
+      app.extend ClassMethods
+      app.send :include, InstanceMethods
+      
+      app.delegate :file_changed, :file_deleted, :to => :"self.class"
+      
+      # Before parsing config, load the data/ directory
+      app.before_configuration do
+        data_path = File.join(root, data_dir)
+        Find.find(data_path) do |path|
+          next if File.directory?(path)
+          file_did_change(path.sub("#{root}/", ""))
+        end if File.exists?(data_path)
+      end
+      
+      # After config, load everything else
+      app.ready do
+        Find.find(root) do |path|
+          next if File.directory?(path)
+          file_did_change(path.sub("#{root}/", ""))
+        end
+      end
+    end
+    alias :included :registered
+  end
+  
+  # Class methods
+  module ClassMethods
+    # Add callback to be run on file change
+    #
+    # @param [nil,Regexp] matcher A Regexp to match the change path against
+    # @return [Array<Proc>]
+    def file_changed(matcher=nil, &block)
+      @_file_changed ||= []
+      @_file_changed << [block, matcher] if block_given?
+      @_file_changed
+    end
+    
+    # Add callback to be run on file deletion
+    #
+    # @param [nil,Regexp] matcher A Regexp to match the deleted path against
+    # @return [Array<Proc>]
+    def file_deleted(matcher=nil, &block)
+      @_file_deleted ||= []
+      @_file_deleted << [block, matcher] if block_given?
+      @_file_deleted
+    end
+  end
+  
+  # Instance methods
+  module InstanceMethods
+    # Notify callbacks that a file changed
+    #
+    # @param [String] path The file that changed
+    # @return [void]
+    def file_did_change(path)
+      file_changed.each do |callback, matcher|
+        next if path.match(%r{^#{build_dir}/})
+        next if !matcher.nil? && !path.match(matcher)
+        instance_exec(path, &callback)
+      end
+    end
+
+    # Notify callbacks that a file was deleted
+    #
+    # @param [String] path The file that was deleted
+    # @return [void]
+    def file_did_delete(path)
+      file_deleted.each do |callback, matcher|
+        next if path.match(%r{^#{build_dir}/})
+        next unless matcher.nil? || path.match(matcher)
+        instance_exec(path, &callback)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+require "yaml"
+require "tilt"
+
+module Middleman::CoreExtensions::FrontMatter
+  class << self
+    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"
+    end
+    alias :included :registered
+  end
+  
+  module ClassMethods
+    def frontmatter_changed(matcher=nil, &block)
+      @_frontmatter_changed ||= []
+      @_frontmatter_changed << [block, matcher] if block_given?
+      @_frontmatter_changed
+    end
+  end
+  
+  module InstanceMethods
+    def initialize
+      super
+      
+      exts = frontmatter_extensions.join("|").gsub(".", "\.")
+      
+      static_path = source_dir.sub(self.root, "").sub(/^\//, "").sub(/\/$/, "") + "/"
+
+      matcher = %r{#{static_path}.*(#{exts})}
+      
+      file_changed matcher do |file|
+        frontmatter_extension.touch_file(file)
+      end
+
+      file_deleted matcher do |file|
+        frontmatter_extension.remove_file(file)
+      end
+
+      provides_metadata matcher do |path|
+        relative_path = path.sub(source_dir, "")
+
+        fmdata = if frontmatter_extension.has_data?(relative_path)
+          frontmatter(relative_path)[0]
+        else
+          {}
+        end
+
+        data = {}
+        %w(layout layout_engine).each do |opt|
+          data[opt.to_sym] = fmdata[opt] if fmdata.has_key?(opt)
+        end
+
+        { :options => data, :page => fmdata }
+      end
+    end
+
+    def frontmatter_did_change(path)
+      frontmatter_changed.each do |callback, matcher|
+        next if path.match(%r{^#{build_dir}/})
+        next if !matcher.nil? && !path.match(matcher)
+        instance_exec(path, &callback)
+      end
+    end
+    
+    def frontmatter_extension
+      @_frontmatter_extension ||= FrontMatter.new(self)
+    end
+    
+    def frontmatter(*args)
+      frontmatter_extension.data(*args)
+    end
+  end
+  
+  class FrontMatter
+    def initialize(app)
+      @app = app
+      @source = File.expand_path(@app.source, @app.root)
+      @local_data = {}
+    end
+    
+    def has_data?(path)
+      @local_data.has_key?(path.to_s)
+    end
+    
+    def touch_file(file)
+      extension = File.extname(file).sub(/\./, "")
+      return unless ::Tilt.mappings.has_key?(extension)
+      
+      file = File.expand_path(file, @app.root)
+      content = File.read(file)
+      
+      # @app.logger.debug :frontmatter_update, Time.now, file if @app.logging?
+      result = parse_front_matter(content)
+        
+      if result
+        data, content = result
+        data = ::Middleman.recursively_enhance(data)
+        file = file.sub(@app.source_dir, "")
+        @local_data[file] = [data, content]
+        path = File.join(@app.source_dir, file)
+        @app.cache.set([:raw_template, path], result[1])
+        @app.frontmatter_did_change(path)
+      end
+    end
+    
+    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)
+        @local_data.delete(file) 
+      end
+    end
+    
+    def data(path)
+      if @local_data.has_key?(path.to_s)
+        @local_data[path.to_s]
+      else
+        nil
+      end
+    end
+    
+  private
+    def parse_front_matter(content)
+      yaml_regex = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+      if content =~ yaml_regex
+        begin
+          data = YAML.load($1)
+        rescue => e
+          puts "YAML Exception: #{e.message}"
+          return false
+        end
+
+        content = content.split(yaml_regex).last
+      else
+        return false
+      end
+
+      [data, content]
+    end
+  end
+end

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

@@ -0,0 +1,247 @@
+module Middleman::CoreExtensions::Rendering
+  class << self
+    def registered(app)
+      app.send :include, InstanceMethods
+      
+      # Activate custom renderers
+      app.register Middleman::Renderers::ERb
+    end
+    alias :included :registered
+  end
+  
+  class TemplateNotFound < RuntimeError
+  end
+  
+  module InstanceMethods
+    def initialize
+      super
+      
+      static_path = source_dir.sub(self.root, "").sub(/^\//, "")
+      render_regex = static_path.empty? ? // : (%r{^#{static_path + "/"}})
+      
+      file_changed render_regex do |file|
+        path = File.expand_path(file, root)
+        cache.remove(:raw_template, path)
+      end
+    end
+    
+    def render_template(path, locs={}, opts={})
+      extension = File.extname(path)
+      engine = extension[1..-1].to_sym
+
+      @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
+
+      @current_locs = locs, @current_opts = opts
+
+      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)
+      
+      if needs_layout && layout_path = fetch_layout(engine, opts)
+        content = render_individual_file(layout_path, locs, opts, context) { content }
+      end
+        
+      content
+    ensure
+      @current_engine = engine_was
+      @content_blocks = nil
+      @current_locs = nil
+      @current_opts = nil
+    end
+    
+    # Sinatra/Padrino render method signature.
+    def render(engine, data, options={}, &block)
+      data = data.to_s
+
+      locals = options[:locals]
+
+      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 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)
+
+          if !found_partial
+            found_partial, found_engine = resolve_template(relative_dir)
+          end
+        end
+      end
+
+      if !found_partial && !engine.nil?
+        found_partial, found_engine = resolve_template(data, :preferred_engine => engine)
+      end
+
+      if !found_partial
+        found_partial, found_engine = resolve_template(data)
+      end
+
+      if found_partial
+        render_individual_file(found_partial, locals, options, self, &block)
+      else
+        raise ::Middleman::CoreExtensions::Rendering::TemplateNotFound, "Could not locate partial: #{data}"
+      end
+    end
+
+    # @private
+    def render_individual_file(path, locs = {}, opts = {}, context = self, &block)
+      path = path.to_s
+      
+      @_out_buf, _buf_was = "", @_out_buf
+      
+      body = cache.fetch(:raw_template, path) do
+        File.read(path)
+      end
+      
+      extension = File.extname(path)
+      options = opts.merge(options_for_ext(extension))
+      options[:outvar] ||= '@_out_buf'
+
+      template = cache.fetch(:compiled_template, options, body) do
+        ::Tilt.new(path, 1, options) { body }
+      end
+
+      template.render(context, locs, &block)
+    ensure  
+      @_out_buf = _buf_was
+    end
+    
+    # @private
+    def options_for_ext(ext)
+      cache.fetch(:options_for_ext, ext) do
+        options = {}
+
+        extension_class = ::Tilt[ext]
+        ::Tilt.mappings.each do |ext, engines|
+          next unless engines.include? extension_class
+          engine_options = respond_to?(ext.to_sym) ? send(ext.to_sym) : {}
+          options.merge!(engine_options)
+        end
+
+        options
+      end
+    end
+  
+    # @private
+    def fetch_layout(engine, opts)
+      local_layout = opts.has_key?(:layout) ? opts[:layout] : layout
+      return false unless local_layout
+    
+      engine_options = respond_to?(engine) ? send(engine) : {}
+
+      layout_engine = if opts.has_key?(:layout_engine)
+        opts[:layout_engine]
+      elsif engine_options.has_key?(:layout_engine)
+        engine_options[:layout_engine]
+      else
+        engine
+      end
+
+      # Automatic
+      if local_layout == :_auto_layout
+        # Look for :layout of any extension
+        # If found, use it. If not, continue
+        locate_layout(:layout, layout_engine) || false
+      else
+        # Look for specific layout
+        # If found, use it. If not, error.
+        if layout_path = locate_layout(local_layout, layout_engine)
+          layout_path
+        else
+          raise ::Middleman::CoreExtensions::Rendering::TemplateNotFound, "Could not locate layout: #{local_layout}"
+        end
+      end
+    end
+  
+    # @private
+    def locate_layout(name, preferred_engine=nil)
+      layout_path = false
+      
+      if !preferred_engine.nil?
+        # Check root
+        layout_path, layout_engine = resolve_template(name, :preferred_engine => preferred_engine)
+        
+        # Check layouts folder
+        if !layout_path
+          layout_path, layout_engine = resolve_template(File.join("layouts", name.to_s), :preferred_engine => preferred_engine)
+        end
+      end
+    
+      # Check root, no preference
+      if !layout_path
+        layout_path, layout_engine = resolve_template(name)
+      end
+    
+      # Check layouts folder, no preference
+      if !layout_path
+        layout_path, layout_engine = resolve_template(File.join("layouts", name.to_s))
+      end
+    
+      layout_path
+    end
+    
+    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
+  
+    def current_engine
+      @current_engine ||= nil
+    end
+    
+    # @private
+    def resolve_template(request_path, options={})
+      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)
+
+        preferred_engine = "*"
+      
+        if options.has_key?(:preferred_engine)
+          extension_class = ::Tilt[options[:preferred_engine]]
+          matched_exts = []
+
+          # TODO: Cache this
+          ::Tilt.mappings.each do |ext, engines|
+            next unless engines.include? extension_class
+            matched_exts << ext
+          end
+
+          if matched_exts.length > 0
+            preferred_engine = "{" + matched_exts.join(",") + "}"
+          else
+            return false
+          end
+        end
+
+        path_with_ext = on_disk_path + "." + preferred_engine
+        found_path = Dir[path_with_ext].find do |path|
+          ::Tilt[path]
+        end
+        
+        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 ]
+        else
+          false
+        end
+      end
+    end
+  end
+end