middleman 3.0.0.alpha.6 → 3.0.0.alpha.7

data/lib/middleman/core_extensions/file_watcher.rb

@@ -1,83 +0,0 @@
-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_extensions/front_matter.rb

@@ -1,136 +0,0 @@
-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(".", "\.")
-      matcher = %r{source/.*(#{exts})}
-      
-      file_changed matcher do |file|
-        frontmatter.touch_file(file)
-      end
-
-      file_deleted matcher do |file|
-        frontmatter.remove_file(file)
-      end
-
-      provides_metadata matcher do |path|
-        relative_path = path.sub(source_dir, "")
-
-        fmdata = if frontmatter.has_data?(relative_path)
-          frontmatter.data(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
-      @frontmatter ||= FrontMatter.new(self)
-    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
-        file = file.sub(@app.source_dir, "")
-        @local_data[file] = result
-        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_extensions/rendering.rb

@@ -1,256 +0,0 @@
-module Middleman::CoreExtensions::Rendering
-  class << self
-    def registered(app)
-      # Autoload
-      require "coffee_script"
-      
-      app.send :include, InstanceMethods
-      
-      # Activate custom renderers
-      app.register Middleman::Renderers::Haml
-      app.register Middleman::Renderers::Sass
-      app.register Middleman::Renderers::Markdown
-      app.register Middleman::Renderers::ERb
-      app.register Middleman::Renderers::Liquid
-      
-      begin
-        require "slim"
-      rescue LoadError
-      end
-    end
-    alias :included :registered
-  end
-  
-  class TemplateNotFound < RuntimeError
-  end
-  
-  module InstanceMethods
-    def initialize
-      super
-      
-      file_changed %r{^source/} 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