middleman 3.0.0.alpha.3 → 3.0.0.alpha.4

data/lib/middleman/core_extensions/rendering.rb

@@ -39,10 +39,13 @@ module Middleman::CoreExtensions::Rendering
       engine = extension[1..-1].to_sym
 
       @current_engine, engine_was = engine, @current_engine
-      @_out_buf, _buf_was = "", @_out_buf
       
+      # 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
+
       while ::Tilt[path]
-        content = render_individual_file(path, locs, opts)
+        content = render_individual_file(path, locs, opts, context)
         path = File.basename(path, File.extname(path))
         cache.set([:raw_template, path], content)
       end
@@ -50,13 +53,12 @@ module Middleman::CoreExtensions::Rendering
       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) { content }
+        content = render_individual_file(layout_path, locs, opts, context) { content }
       end
         
       content
     ensure
       @current_engine = engine_was
-      @_out_buf = _buf_was
       @content_blocks = nil
     end
     
@@ -94,16 +96,18 @@ module Middleman::CoreExtensions::Rendering
       end
 
       if found_partial
-        render_individual_file(found_partial, locals, options, &block)
+        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 = {}, &block)
+    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
@@ -116,7 +120,9 @@ module Middleman::CoreExtensions::Rendering
         ::Tilt.new(path, 1, options) { body }
       end
 
-      template.render(self, locs, &block)
+      template.render(context, locs, &block)
+    ensure  
+      @_out_buf = _buf_was
     end
     
     # @private
@@ -169,11 +175,11 @@ module Middleman::CoreExtensions::Rendering
     # @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)
@@ -227,8 +233,8 @@ module Middleman::CoreExtensions::Rendering
         found_path = Dir[path_with_ext].find do |path|
           ::Tilt[path]
         end
-
-        if found_path || File.exists?(on_disk_path)
+        
+        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
@@ -237,4 +243,4 @@ module Middleman::CoreExtensions::Rendering
       end
     end
   end
-end
+end

data/lib/middleman/core_extensions/routing.rb

@@ -25,6 +25,18 @@ module Middleman::CoreExtensions::Routing
     # page "/about.html", :layout => false
     # page "/", :layout => :homepage_layout
     def page(url, opts={}, &block)
+      if url.include?("*")
+        url = Regexp.new(url.gsub("*", "(.*)").gsub(/^\//, "^"))
+      end
+      
+      if url.is_a?(Regexp) && !opts.empty?
+        provides_metadata_for_path url do |url|
+          { :options => opts }
+        end
+        
+        return
+      end
+      
       opts[:layout] = layout if opts[:layout].nil?
       
       url = full_path(url)

data/lib/middleman/core_extensions/show_exceptions.rb

@@ -0,0 +1,16 @@
+require 'rack/showexceptions'
+
+module Middleman::CoreExtensions::ShowExceptions
+  class << self
+    def registered(app)
+      app.configure :development do
+        if show_exceptions
+          use ::Middleman::CoreExtensions::ShowExceptions::Middleware
+        end
+      end
+    end
+  end
+  
+  class Middleware < ::Rack::ShowExceptions
+  end
+end

data/lib/middleman/core_extensions/sitemap.rb

@@ -12,12 +12,12 @@ module Middleman::CoreExtensions::Sitemap
   module InstanceMethods
     def initialize
       super
-    
-      file_changed do |file|
+
+      file_changed %r{^source/} do |file|
         sitemap.touch_file(file)
       end
-    
-      file_deleted do |file|
+
+      file_deleted %r{^source/} do |file|
         sitemap.remove_file(file)
       end
     end
@@ -40,5 +40,11 @@ module Middleman::CoreExtensions::Sitemap
       @_provides_metadata << [block, matcher] if block_given?
       @_provides_metadata
     end
+    
+    def provides_metadata_for_path(matcher=nil, &block)
+      @_provides_metadata_for_path ||= []
+      @_provides_metadata_for_path << [block, matcher] if block_given?
+      @_provides_metadata_for_path
+    end
   end
 end

data/lib/middleman/extensions/minify_css.rb

@@ -2,9 +2,11 @@ module Middleman::Extensions
   module MinifyCss
     class << self
       def registered(app)
-        require "middleman/extensions/minify_css/cssmin"
         app.after_configuration do
-          set :css_compressor, ::CSSMin
+          if !css_compressor
+            require "middleman/extensions/minify_css/cssmin"
+            set :css_compressor, ::CSSMin
+          end
         end
       end
       alias :included :registered

data/lib/middleman/extensions/minify_javascript.rb

@@ -2,11 +2,14 @@ module Middleman::Extensions
   module MinifyJavascript
     class << self
       def registered(app)
-        require 'uglifier'
         app.after_configuration do
-          set :js_compressor, ::Uglifier.new
+          if !js_compressor
+            require 'uglifier'
+            set :js_compressor, ::Uglifier.new
+          end
+          
+          use InlineJavascriptRack, :compressor => js_compressor
         end
-        app.use InlineJavascriptRack
       end
       alias :included :registered
     end
@@ -14,14 +17,13 @@ module Middleman::Extensions
     class InlineJavascriptRack
       def initialize(app, options={})
         @app = app
+        @compressor = options[:compressor]
       end
 
       def call(env)
         status, headers, response = @app.call(env)
 
         if env["PATH_INFO"].match(/\.html$/)
-          compressor = ::Uglifier.new
-
           uncompressed_source = case(response)
             when String
               response
@@ -37,7 +39,7 @@ module Middleman::Extensions
             first = $1
             uncompressed_source = $2
             last = $3
-            minified_js = compressor.compile(uncompressed_source)
+            minified_js = @compressor.compress(uncompressed_source)
 
             first << minified_js << "\n" << last
           end

data/lib/middleman/guard.rb

@@ -1,85 +1,50 @@
+# Guard watches the filesystem for changes
 require "guard"
 require "guard/guard"
-require "rbconfig"
+
+# File changes are forwarded to the currently running app via HTTP
 require "net/http"
 
-if RbConfig::CONFIG['host_os'].downcase =~ %r{mingw}
-  require "win32/process"
-end
+# Support forking on Windows
+require "rbconfig"
+require "win32/process" if RbConfig::CONFIG['host_os'].downcase =~ %r{mingw}
 
-module Middleman
-  module Guard
-    class << self
-      def add_guard(&block)
-        # Deprecation Warning
-        puts "== Middleman::Guard.add_guard has been removed. Update your extensions to versions which support this change."
-      end
+module Middleman::Guard
+  def self.start(options={})
+    # Forward CLI options to Guard
+    options_hash = options.map { |k,v| ", :#{k} => '#{v}'" }.join
   
-      def start(options={})
-        options_hash = ""
-        options.each do |k,v|
-          options_hash << ", :#{k} => '#{v}'"
+    # Watch all files in project, even hidden ones.
+    ::Guard.start({
+      :guardfile_contents      => %Q{
+        guard 'middleman'#{options_hash} do 
+          watch(%r{(.*)})
         end
-      
-        guardfile_contents = %Q{
-          guard 'middleman'#{options_hash} do 
-            watch(%r{(.*)})
-          end
-        }
-
-        ::Guard.start({ :guardfile_contents => guardfile_contents })
-      end
-    end
+      },
+      :watch_all_modifications => true
+    })
   end
 end
 
 # @private
 module Guard
+  # Monkeypatch Guard into being quiet
+  module UI
+    class << self
+      def info(message, options = { }); end
+    end
+  end
+  
+  # Guards must be in the Guard module to be picked up
   class Middleman < Guard
+    # Save the options for later
     def initialize(watchers = [], options = {})
       super
       @options = options
     end
     
+    # Start Middleman in a fork
     def start
-      server_start
-    end
-    
-    def reload
-      server_stop
-      server_start
-    end
-  
-    def run_on_change(paths)
-      needs_to_restart = false
-      
-      paths.each do |path|
-        if path.match(%{^config\.rb}) || path.match(%r{^lib/^[^\.](.*)\.rb$})
-          needs_to_restart = true
-          break
-        end
-      end
-      
-      if needs_to_restart
-        reload
-      else
-        paths.each do |path|
-          file_did_change(path)
-        end
-      end
-    end
-
-    def run_on_deletion(paths)
-      paths.each do |path|
-        file_did_delete(path)
-      end
-    end
-    
-  private
-    def server_start
-      # Quiet down Guard
-      # ENV['GUARD_ENV'] = 'test' if @options[:debug] == "true"
-      
       @server_job = fork do
         env = (@options[:environment] || "development").to_sym
         is_logging = @options.has_key?(:debug) && (@options[:debug] == "true")
@@ -87,35 +52,74 @@ module Guard
           set :environment, env
           set :logging, is_logging
         end
-      
+        
+        require "thin"
+        ::Thin::Logging.silent = !is_logging
+        
         app_rack = app.class.to_rack_app
-      
+        
         opts = @options.dup
         opts[:app] = app_rack
         puts "== The Middleman is standing watch on port #{opts[:port]||4567}"
         ::Middleman.start_server(opts)
       end
     end
-  
-    def server_stop
+    
+    # Stop the forked Middleman
+    def stop
       puts "== The Middleman is shutting down"
       Process.kill("KILL", @server_job)
       Process.wait @server_job
       @server_job = nil
-      # @app = nil
     end
     
-    def talk_to_server(params={})
-      uri = URI.parse("http://#{@options[:host]}:#{@options[:port]}/__middleman__")
-      Net::HTTP.post_form(uri, {}.merge(params))
+    # Simply stop, then start
+    def reload
+      stop
+      start
     end
-    
-    def file_did_change(path)
-      talk_to_server :change => path
+  
+    # What to do on file change
+    # @param [Array<String>] paths Array of paths that changed
+    def run_on_change(paths)
+      # See if the changed file is config.rb or lib/*.rb
+      return reload if needs_to_reload?(paths)
+      
+      # Otherwise forward to Middleman
+      paths.each { |path| tell_server(:change => path) }
+    end
+
+    # What to do on file deletion
+    # @param [Array<String>] paths Array of paths that were removed
+    def run_on_deletion(paths)
+      # See if the changed file is config.rb or lib/*.rb
+      return reload if needs_to_reload?(paths)
+      
+      # Otherwise forward to Middleman
+      paths.each { |path| tell_server(:delete => path) }
     end
     
-    def file_did_delete(path)
-      talk_to_server :delete => path
+  private
+    # Whether the passed files are config.rb or lib/*.rb
+    # @param [Array<String>] paths Array of paths to check
+    # @return [Boolean] Whether the server needs to reload
+    def needs_to_reload?(paths)
+      paths.any? do |path|
+        path.match(%{^config\.rb}) || path.match(%r{^lib/^[^\.](.*)\.rb$})
+      end
+    end
+  
+    # Send a message to the running server
+    # @param [Hash] params Keys to be hashed and sent to server
+    def tell_server(params={})
+      uri = URI.parse("http://#{@options[:host]}:#{@options[:port]}/__middleman__")
+      Net::HTTP.post_form(uri, {}.merge(params))
     end
   end
+end
+
+# Trap the interupt signal and shut down Guard (and thus the server) smoothly
+trap(:INT) do 
+  ::Guard.stop
+  exit
 end

data/lib/middleman/renderers/markdown.rb

@@ -1,19 +1,14 @@
 module Middleman::Renderers::Markdown
   class << self
     def registered(app)
-      app.set :markdown_engine, nil
-    
-      begin
-        require "maruku"
-        app.set :markdown_engine, :maruku
-      rescue LoadError
-        begin
-          require "rdiscount"
-          app.set :markdown_engine, :rdiscount
-        rescue LoadError
-        end
-      end
-
+      require "redcarpet"
+      
+      # Forcably disable Redcarpet1 support.
+      # Tilt defaults to this if available, but the compat
+      # layer disables extensions.
+      Object.send(:remove_const, :RedcarpetCompat) if defined? ::RedcarpetCompat
+      
+      app.set :markdown_engine, :redcarpet
       app.set :markdown_engine_prefix, ::Tilt
       
       app.after_configuration do

data/lib/middleman/sitemap/page.rb

@@ -69,9 +69,10 @@ module Middleman::Sitemap
     end
     
     def touch
+      template.touch if template?
     end
     
-    def custom_render(&block)
+    def custom_renderer(&block)
       @_custom_renderer ||= nil
       @_custom_renderer = block if block_given?
       @_custom_renderer
@@ -89,7 +90,7 @@ module Middleman::Sitemap
             instance_exec(&block)
           end
         end
-      elsif !custom_render.nil?
+      elsif !custom_renderer.nil?
         params = args.dup
         params << block if block_given?
         instance_exec(*params, &custom_renderer)