middleman 2.0.0.beta6 → 2.0.0.rc1

data/lib/middleman/core_extensions/front_matter.rb

@@ -0,0 +1,83 @@
+require "yaml"
+require "tilt"
+
+module Middleman::CoreExtensions::FrontMatter
+  class << self
+    def registered(app)
+      app.extend ClassMethods
+      
+      ::Tilt::register RDiscountTemplate, 'markdown', 'mkd', 'md'
+      ::Tilt::register RedClothTemplate,  'textile'
+      ::Tilt::register ERBTemplate,       'erb', 'rhtml'
+      ::Tilt::register SlimTemplate,      'slim'
+      ::Tilt::register HamlTemplate,      'haml'
+      
+      app.before do
+        result = resolve_template(request.path_info, :raise_exceptions => false)
+      
+        if result && Tilt.mappings.has_key?(result[1].to_s)
+          extensionless_path, template_engine = result
+          full_file_path = "#{extensionless_path}.#{template_engine}"
+          system_path = File.join(settings.views, full_file_path)
+          data, content = app.parse_front_matter(File.read(system_path))
+    
+          request['custom_options'] = {}
+          %w(layout layout_engine).each do |opt|
+            if data.has_key?(opt)
+              request['custom_options'][opt.to_sym] = data.delete(opt)
+            end
+          end
+    
+          # Forward remaining data to helpers
+          app.data_content("page", data)
+        end
+      end
+    end
+    alias :included :registered
+  end
+  
+  module ClassMethods
+    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}"
+        end
+        
+        content = content.split(yaml_regex).last
+      end
+
+      data ||= {}
+      [data, content]
+    end
+  end
+  
+  module YamlAware
+    def prepare
+      options, @data = Middleman::Server.parse_front_matter(@data)
+      super
+    end
+  end
+
+  class RDiscountTemplate < ::Tilt::RDiscountTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+  
+  class RedClothTemplate < ::Tilt::RedClothTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+ 
+  class ERBTemplate < ::Tilt::ERBTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+
+  class HamlTemplate < ::Tilt::HamlTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+  
+  class SlimTemplate < ::Slim::Template
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+end

data/lib/middleman/core_extensions/rendering.rb

@@ -0,0 +1,18 @@
+require "padrino-core/application/rendering"
+
+module Middleman::CoreExtensions::Rendering
+  class << self
+    def registered(app)
+      # Tilt-aware renderer
+      app.register Padrino::Rendering
+
+      # Activate custom renderers
+      app.register Middleman::Renderers::Slim
+      app.register Middleman::Renderers::Haml
+      app.register Middleman::Renderers::Sass
+      app.register Middleman::Renderers::Markdown
+      app.register Middleman::Renderers::CoffeeScript
+    end
+    alias :included :registered
+  end
+end

data/lib/middleman/core_extensions/routing.rb

@@ -0,0 +1,62 @@
+module Middleman::CoreExtensions::Routing
+  class << self
+    def registered(app)
+      app.extend ClassMethods
+      
+      # Normalize the path and add index if we're looking at a directory
+      app.before do
+        request.path_info = self.class.path_to_index(request.path)
+      end
+    end
+    alias :included :registered
+  end
+  
+  module ClassMethods
+    def current_layout
+      @layout
+    end
+    
+    def path_to_index(path)
+      parts = path ? path.split('/') : []
+      if parts.last.nil? || parts.last.split('.').length == 1
+        path = File.join(path, settings.index_file) 
+      end
+      path.gsub(%r{^/}, '')
+    end
+  
+    # Takes a block which allows many pages to have the same layout
+    # with_layout :admin do
+    #   page "/admin/"
+    #   page "/admin/login.html"
+    # end
+    def with_layout(layout_name, &block)
+      old_layout = current_layout
+    
+      layout(layout_name)
+      class_eval(&block) if block_given?
+    ensure
+      layout(old_layout)
+    end
+  
+    # The page method allows the layout to be set on a specific path
+    # page "/about.html", :layout => false
+    # page "/", :layout => :homepage_layout
+    def page(url, options={}, &block)
+      url = url.gsub(%r{#{settings.index_file}$}, "")
+      url = url.gsub(%r{(\/)$}, "") if url.length > 1
+    
+      paths = [url]
+      paths << "#{url}/" if url.length > 1 && url.split("/").last.split('.').length <= 1
+      paths << "#{path_to_index(url)}"
+
+      options[:layout] = current_layout if options[:layout].nil?
+
+      paths.each do |p|
+        get(p) do
+          return yield if block_given?
+          process_request(options)
+        end
+      end
+    end
+  end
+end

data/lib/middleman/features/asset_host.rb

@@ -2,17 +2,17 @@ module Middleman::Features::AssetHost
   class << self
     def registered(app)
       app.after_feature_init do
-        if Middleman::Server.asset_host.is_a?(Proc)
-          ::Compass.configuration.asset_host(&Middleman::Server.asset_host)
+        if app.asset_host.is_a?(Proc)
+          ::Compass.configuration.asset_host(&app.asset_host)
         end
       end
 
-      Middleman::Assets.register :asset_host do |path, prefix, request|
-        original_output = Middleman::Assets.before(:asset_host, path, prefix, request)
+      app.register_asset_handler :asset_host do |path, prefix, request|
+        original_output = app.before_asset_handler(:asset_host, path, prefix, request)
 
         valid_extensions = %w(.png .gif .jpg .jpeg .js .css)
 
-        asset_prefix = Middleman::Server.asset_host.call(original_output)
+        asset_prefix = app.asset_host.call(original_output)
 
         File.join(asset_prefix, original_output)
       end

data/lib/middleman/features/blog.rb

@@ -10,11 +10,11 @@ module Middleman
 
           app.after_feature_init do
             if !app.settings.respond_to? :blog_permalink
-              app.set :blog_permalink, "/:year/:month/:day/:title.html"
+              app.set :blog_permalink, ":year/:month/:day/:title.html"
             end
 
             if !app.settings.respond_to? :blog_taglink
-              app.set :blog_taglink, "/tags/:tag.html"
+              app.set :blog_taglink, "tags/:tag.html"
             end
 
             if !app.settings.respond_to? :blog_layout
@@ -43,71 +43,58 @@ module Middleman
 
             $stderr.puts "== Blog: #{app.settings.blog_permalink}"
 
-            articles_glob = File.join(app.views, app.settings.blog_permalink.gsub(/(:\w+)/, "*") + ".*")
+            app.before do
+              articles_glob = File.join(app.views, app.settings.blog_permalink.gsub(/(:\w+)/, "*") + ".*")
 
-            articles = Dir[articles_glob].map do |article|
-              template_content = File.read(article)
-              data, content = parse_front_matter(template_content)
-              data["date"] = Date.parse(data["date"])
+              articles = Dir[articles_glob].map do |article|
+                template_content = File.read(article)
+                data, content = app.parse_front_matter(template_content)
+                data["date"] = Date.parse(data["date"])
 
-              yaml_regex = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
-              data["raw"]  = template_content.split(yaml_regex).last
-              data["url"] = article.gsub(app.views, "").split(".html").first + ".html"
+                data["raw"] = content
+                data["url"] = article.gsub(app.views, "").split(".html").first + ".html"
 
-              all_content = Tilt.new(article).render
-              data["body"] = all_content.gsub!(app.settings.blog_summary_separator, "")
+                all_content = Tilt.new(article).render
+                data["body"] = all_content.gsub!(app.settings.blog_summary_separator, "")
 
-              sum = if data["raw"] =~ app.settings.blog_summary_separator
-                data["raw"].split(app.settings.blog_summary_separator).first
-              else
-                data["raw"].match(/(.{1,#{app.settings.blog_summary_length}}.*?)(\n|\Z)/m).to_s
-              end
+                sum = if data["raw"] =~ app.settings.blog_summary_separator
+                  data["raw"].split(app.settings.blog_summary_separator).first
+                else
+                  data["raw"].match(/(.{1,#{app.settings.blog_summary_length}}.*?)(\n|\Z)/m).to_s
+                end
 
-              engine = RDiscount.new(sum)
-              data["summary"] = engine.to_html
-              data
-            end.sort { |a, b| b["date"] <=> a["date"] }
-
-            tags = {}
-            articles.each do |article|
-              article["tags"] ||= ""
-              if !article["tags"].empty?
-                tags_array = article["tags"].split(',').map{|t| t.strip}
-                tags_array.each do |tag_title|
-                  tag_key = tag_title.parameterize
-                  tag_path = blog_taglink.gsub(/(:\w+)/, tag_key)
-                  (tags[tag_path] ||= {})["title"] = tag_title
-                  tags[tag_path]["ident"] = tag_key
-                  (tags[tag_path]["pages"] ||= {})[article["title"]] = article["url"]
+                engine = RDiscount.new(sum)
+                data["summary"] = engine.to_html
+                data
+              end.sort { |a, b| b["date"] <=> a["date"] }
+
+              tags = {}
+              articles.each do |article|
+                article["tags"] ||= ""
+                if !article["tags"].empty?
+                  tags_array = article["tags"].split(',').map{|t| t.strip}
+                  tags_array.each do |tag_title|
+                    tag_key = tag_title.parameterize
+                    tag_path = blog_taglink.gsub(/(:\w+)/, tag_key)
+                    (tags[tag_path] ||= {})["title"] = tag_title
+                    tags[tag_path]["ident"] = tag_key
+                    (tags[tag_path]["pages"] ||= {})[article["title"]] = article["url"]
+                  end
                 end
               end
-            end
-
-            app.data_content("blog", { :articles => articles, :tags => tags })
 
+              app.data_content("blog", { :articles => articles, :tags => tags })
+            end
+            
             app.get(app.settings.blog_permalink) do
-              options = {}
-              options[:layout] = settings.blog_layout
-              options[:layout_engine] = settings.blog_layout_engine
-
-              extensionless_path, template_engine = resolve_template(request.path)
-
-              full_file_path = "#{extensionless_path}.#{template_engine}"
-              system_path = File.join(settings.views, full_file_path)
-              data, content = self.class.parse_front_matter(File.read(system_path))
-
-              # Forward remaining data to helpers
-              self.class.data_content("page", data)
-
-              output = render(request.path, options)
-
+              process_request({
+                :layout        => settings.blog_layout,
+                :layout_engine => settings.blog_layout_engine
+              })
+              
               # No need for separator on permalink page
-              output.gsub!(settings.blog_summary_separator, "")
-
-              status 200
-              output
+              body body.gsub!(settings.blog_summary_separator, "")
             end
-
           end
         end
         alias :included :registered

data/lib/middleman/features/cache_buster.rb

@@ -1,23 +1,23 @@
 module Middleman::Features::CacheBuster
   class << self
     def registered(app)
-      Middleman::Assets.register :cache_buster do |path, prefix, request|
-        http_path = Middleman::Assets.before(:cache_buster, path, prefix, request)
+      app.register_asset_handler :cache_buster do |path, prefix, request|
+        http_path = app.before_asset_handler(:cache_buster, path, prefix, request)
 
         if http_path.include?("://") || !%w(.css .png .jpg .js .gif).include?(File.extname(http_path))
           http_path
         else
           begin
-            prefix = Middleman::Server.images_dir if prefix == Middleman::Server.http_images_path
+            prefix = app.images_dir if prefix == app.http_images_path
           rescue
           end
 
-          real_path_static  = File.join(Middleman::Server.views, prefix, path)
+          real_path_static  = File.join(app.views, prefix, path)
 
           if File.readable?(real_path_static)
             http_path << "?" + File.mtime(real_path_static).strftime("%s") 
-          elsif Middleman::Server.environment == :build
-            real_path_dynamic = File.join(Middleman::Server.root, Middleman::Server.build_dir, prefix, path)
+          elsif app.environment == :build
+            real_path_dynamic = File.join(app.root, app.build_dir, prefix, path)
             http_path << "?" + File.mtime(real_path_dynamic).strftime("%s") if File.readable?(real_path_dynamic)
           end
 
@@ -29,7 +29,7 @@ module Middleman::Features::CacheBuster
         ::Compass.configuration do |config|
           config.asset_cache_buster do |path, real_path|
             real_path = real_path.path if real_path.is_a? File
-            real_path = real_path.gsub(File.join(Middleman::Server.root, Middleman::Server.build_dir), Middleman::Server.views)
+            real_path = real_path.gsub(File.join(app.root, app.build_dir), app.views)
             if File.readable?(real_path)
               File.mtime(real_path).strftime("%s") 
             else

data/lib/middleman/features/relative_assets.rb

@@ -3,20 +3,20 @@ module Middleman::Features::RelativeAssets
     def registered(app)
       ::Compass.configuration.relative_assets = true
 
-      Middleman::Assets.register :relative_assets do |path, prefix, request|
+      app.register_asset_handler :relative_assets do |path, prefix, request|
         begin
-          prefix = Middleman::Server.images_dir if prefix == Middleman::Server.http_images_path
+          prefix = app.images_dir if prefix == app.http_images_path
         rescue
         end
 
         if path.include?("://")
-          Middleman::Assets.before(:relative_assets, path, prefix, request)
+          app.before_asset_handler(:relative_assets, path, prefix, request)
         elsif path[0,1] == "/"
           path
         else
           path = File.join(prefix, path) if prefix.length > 0
           request_path = request.path_info.dup
-          request_path << Middleman::Server.index_file if path.match(%r{/$})
+          request_path << app.index_file if path.match(%r{/$})
           request_path.gsub!(%r{^/}, '')
           parts = request_path.split('/')
 

data/lib/middleman/features/tiny_src.rb

@@ -1,8 +1,8 @@
 module Middleman::Features::TinySrc
   class << self
     def registered(app)
-      Middleman::Assets.register :tiny_src do |path, prefix, request|
-        original_output = Middleman::Assets.before(:tiny_src, path, prefix, request)
+      app.register_asset_handler :tiny_src do |path, prefix, request|
+        original_output = app.before_asset_handler(:tiny_src, path, prefix, request)
         "http://i.tinysrc.mobi/#{original_output}"
       end
     end

data/lib/middleman/server.rb

@@ -1,16 +1,11 @@
 # We're riding on Sinatra, so let's include it.
 require "sinatra/base"
 
-# Use the padrino project's helpers
-require "padrino-core/application/rendering"
-require "padrino-helpers"
-
 module Middleman
   class Server < Sinatra::Base
     # Basic Sinatra config
     set :app_file,    __FILE__
     set :root,        ENV["MM_DIR"] || Dir.pwd
-    set :reload,      false
     set :sessions,    false
     set :logging,     false
     set :environment, (ENV['MM_ENV'] && ENV['MM_ENV'].to_sym) || :development
@@ -28,36 +23,38 @@ module Middleman
     set :build_dir,   "build"       # Which folder are builds output to
     set :http_prefix, nil           # During build, add a prefix for absolute paths
     
+    # Pass all request to Middleman, even "static" files
     set :static, false
+    
     set :views, "source"
     
-    # Disable Padrino cache buster until explicitly enabled
-    set :asset_stamp, false
+    # Activate custom features
+    register Middleman::CoreExtensions::Features
     
-    # Use Padrino Helpers
-    register Padrino::Helpers
+    # Setup custom rendering
+    register Middleman::CoreExtensions::Rendering
     
-    # Activate custom features
-    register Middleman::Features
+    # Setup asset path pipeline
+    register Middleman::CoreExtensions::Assets
     
     # Activate built-in helpers
-    register Middleman::Features::DefaultHelpers
+    register Middleman::CoreExtensions::DefaultHelpers
     
     # Activate Yaml Data package
-    register Middleman::Features::Data
-    
-    # Activate Webservices Proxy package
-    # register Middleman::Features::Proxy
+    register Middleman::CoreExtensions::Data
     
-    register Middleman::Features::FrontMatter
+    # with_layout and page routing
+    register Middleman::CoreExtensions::Routing
     
-    # Activate Lorem helpers
-    register Middleman::Features::Lorem
+    # Parse YAML from templates
+    register Middleman::CoreExtensions::FrontMatter
     
-    # Tilt-aware renderer
-    register Padrino::Rendering
+    set :default_extensions, [
+      :lorem
+    ]
     
     # Override Sinatra's set to accept a block
+    # Specifically for the asset_host feature
     def self.set(option, value=self, &block)
       if block_given?
         value = Proc.new { block }
@@ -66,153 +63,58 @@ module Middleman
       super(option, value, &nil)
     end
     
-    # An array of callback procs to run after all features have been setup
-    @@run_after_features = []
-    
-    # Add a block/proc to be run after features have been setup
-    def self.after_feature_init(&block)
-      @@run_after_features << block
-    end
-    
-    # Activate custom renderers
-    register Middleman::Renderers::Slim
-    register Middleman::Renderers::Haml
-    register Middleman::Renderers::Sass
-    register Middleman::Renderers::Markdown
-    register Middleman::Renderers::CoffeeScript
-    
-    # Rack helper for adding mime-types during local preview
-    def self.mime(ext, type)
-      ext = ".#{ext}" unless ext.to_s[0] == ?.
-      ::Rack::Mime::MIME_TYPES[ext.to_s] = type
-    end
-    
     # Default layout name
     layout :layout
-    
-    def self.current_layout
-      @layout
-    end
-    
-    # Takes a block which allows many pages to have the same layout
-    # with_layout :admin do
-    #   page "/admin/"
-    #   page "/admin/login.html"
-    # end
-    def self.with_layout(layout_name, &block)
-      old_layout = current_layout
-      
-      layout(layout_name)
-      class_eval(&block) if block_given?
-    ensure
-      layout(old_layout)
-    end
-    
-    # The page method allows the layout to be set on a specific path
-    # page "/about.html", :layout => false
-    # page "/", :layout => :homepage_layout
-    def self.page(url, options={}, &block)
-      url = url.gsub(%r{#{settings.index_file}$}, "")
-      url = url.gsub(%r{(\/)$}, "") if url.length > 1
-      
-      paths = [url]
-      paths << "#{url}/" if url.length > 1 && url.split("/").last.split('.').length <= 1
-      paths << "/#{path_to_index(url)}"
-  
-      options[:layout] = current_layout if options[:layout].nil?
-
-      paths.each do |p|
-        get(p) do
-          return yield if block_given?
-          process_request(options)
-        end
-      end
-    end
 
     # This will match all requests not overridden in the project's config.rb
     not_found do
       process_request
     end
     
-  private
-    def self.path_to_index(path)
-      parts = path ? path.split('/') : []
-      if parts.last.nil? || parts.last.split('.').length == 1
-        path = File.join(path, settings.index_file) 
+    # See if Tilt cannot handle this file
+    before do
+      result = resolve_template(request.path_info, :raise_exceptions => false)
+      if result
+        extensionless_path, template_engine = result
+      
+        # Return static files
+        if !::Tilt.mappings.has_key?(template_engine.to_s)
+          content_type mime_type(File.extname(request.path_info)), :charset => 'utf-8'
+          status 200
+          send_file File.join(Middleman::Server.views, request.path_info)
+          request["already_sent"] = true
+        end
+      else
+        $stderr.puts "File not found: #{request.path_info}"
+        status 404
+        request["already_sent"] = true
       end
-      path.gsub(%r{^/}, '')
     end
-  
+    
+  private
     # Internal method to look for templates and evaluate them if found
     def process_request(options={})
-      # Normalize the path and add index if we're looking at a directory
-      path = self.class.path_to_index(request.path)
-      
-      extensionless_path, template_engine = resolve_template(path)
-      
-      if !::Tilt.mappings.has_key?(template_engine.to_s)
-        content_type mime_type(File.extname(path)), :charset => 'utf-8'
-        status 200
-        send_file File.join(Middleman::Server.views, path)
-        return
-      end
-      
-      full_file_path = "#{extensionless_path}.#{template_engine}"
-      system_path = File.join(settings.views, full_file_path)
-      data, content = self.class.parse_front_matter(File.read(system_path))
+      return if request["already_sent"]
       
-      %w(layout layout_engine).each do |opt|
-        if data.has_key?(opt)
-          options[opt.to_sym] = data.delete(opt)
-        end
-      end
-      
-      # Forward remaining data to helpers
-      self.class.data_content("page", data)
+      options.merge!(request['custom_options'] || {})
       
       old_layout = settings.current_layout
       settings.layout(options[:layout]) if !options[:layout].nil?
       layout = settings.fetch_layout_path.to_sym
-      layout = false if options[:layout] == false or path =~ /\.(css|js)$/
+      layout = false if options[:layout] == false or request.path_info =~ /\.(css|js)$/
       
       render_options = { :layout => layout }
       render_options[:layout_engine] = options[:layout_engine] if options.has_key? :layout_engine
-      result = render(path, render_options)
+      result = render(request.path_info, render_options)
       settings.layout(old_layout)
       
       if result
-        content_type mime_type(File.extname(path)), :charset => 'utf-8'
+        content_type mime_type(File.extname(request.path_info)), :charset => 'utf-8'
         status 200
-        return result
-      end
-      
-      status 404
-    rescue Padrino::Rendering::TemplateNotFound
-      if settings.environment == :development
-        raise $!
+        body result
       else
-        $stderr.puts "File not found: #{request.path}"
         status 404
       end
     end
   end
-end
-
-require "middleman/assets"
-
-# The Rack App
-class Middleman::Server
-  def self.new(*args, &block)  
-    # Check for and evaluate local configuration
-    local_config = File.join(self.root, "config.rb")
-    if File.exists? local_config
-      $stderr.puts "== Reading:  Local config" if logging?
-      Middleman::Server.class_eval File.read(local_config)
-      set :app_file, File.expand_path(local_config)
-    end
-    
-    @@run_after_features.each { |block| class_eval(&block) }
-    
-    super
-  end
-end
+end