middleman 0.99.1.pre → 0.99.2.pre

data/lib/middleman/features/smush_pngs.rb

@@ -1,38 +1,38 @@
-class Middleman::Features::SmushPngs
-  def initialize(app, config)
-    require "middleman/builder"
+module Middleman::Features::SmushPNGs
+  class << self
+    def registered(app)
+      require "middleman/builder"
 
-    Middleman::Server.alias_method  :pre_smush_after_run, :after_run
-    Middleman::Server.define_method :after_run do
-      pre_smush_after_run
-      smush_dir = File.join(Middleman::Server.build_dir, Middleman::Server.images_dir)
+      app.alias_method  :pre_smush_after_run, :after_run
+      app.define_method :after_run do
+        pre_smush_after_run
+        smush_dir = File.join(Middleman::Server.build_dir, Middleman::Server.images_dir)
       
-      # Read cache
-      cache_file = File.join(Middleman::Server.root, ".smush-cache")
-      cache_data = if File.exists?(cache_file)
-        Marshal.restore(File.read(cache_file))
-      else
-        {}
-      end
+        # Read cache
+        cache_file = File.join(Middleman::Server.root, ".smush-cache")
+        cache_data = if File.exists?(cache_file)
+          Marshal.restore(File.read(cache_file))
+        else
+          {}
+        end
       
-      require "smusher"
-      require "json/pure"
-      ::Smusher.class_eval do
-        images_in_folder(smush_dir).each do |file|
-          original_file_size = size(file)
-          return if original_file_size.zero?
-          return if cache_data[file] && cache_data[file] == original_file_size
+        require "smusher"
+        require "json/pure"
+        ::Smusher.class_eval do
+          images_in_folder(smush_dir).each do |file|
+            original_file_size = size(file)
+            return if original_file_size.zero?
+            return if cache_data[file] && cache_data[file] == original_file_size
 
-          with_logging(file, true) do
-            write_optimized_data(file)
-            cache_data[file] = size(file) # Add or update cache
-            File.open(cache_file, "w") { |f| f.write Marshal.dump(cache_data) } # Write cache
-            say "<%= color('#{"[SMUSHED]".rjust(12)}', :yellow) %>  " + file.gsub(Middleman::Server.build_dir+"/", '')
+            with_logging(file, true) do
+              write_optimized_data(file)
+              cache_data[file] = size(file) # Add or update cache
+              File.open(cache_file, "w") { |f| f.write Marshal.dump(cache_data) } # Write cache
+              say "<%= color('#{"[SMUSHED]".rjust(12)}', :yellow) %>  " + file.gsub(Middleman::Server.build_dir+"/", '')
+            end
           end
         end
       end
     end
   end
-end
-
-Middleman::Features.register :smush_pngs, Middleman::Features::SmushPngs
+end

data/lib/middleman/features/ugly_haml.rb

@@ -1,7 +1,8 @@
-class Middleman::Features::UglyHaml
-  def initialize(app, config)
-    Middleman::Server.set :haml, Middleman::Server.settings.haml.merge({ :ugly_haml => true })
+module Middleman::Features::UglyHaml
+  class << self
+    def registered(app)
+      app.set :haml, app.settings.haml.merge({ :ugly_haml => true })
+    end
+    alias :included :registered
   end
-end
-
-Middleman::Features.register :ugly_haml, Middleman::Features::UglyHaml
+end

data/lib/middleman/renderers/{coffee.rb → coffee_script.rb}

@@ -1,7 +1,13 @@
-class Middleman::Server
-  def coffee(template, options={}, locals={})
-    options[:layout] = false
-    render :coffee, template, options, locals
+module Middleman
+  module Renderers
+    module CoffeeScript
+      class << self
+        def registered(app)
+          Tilt.register 'coffee', Tilt::CoffeeTemplate
+        end
+        alias :included :registered
+      end
+    end
   end
 end
 
@@ -22,7 +28,4 @@ unless defined? Tilt::CoffeeTemplate
       @output ||= ::CoffeeScript::compile(data, options)
     end
   end
-  Tilt.register 'coffee', Tilt::CoffeeTemplate
-end
-
-Middleman::Renderers.register(:coffee, Tilt::CoffeeTemplate)
+end

data/lib/middleman/renderers/haml.rb

@@ -1,47 +1,42 @@
 require "haml"
 
 module Middleman
-  module Haml  
-    module Helpers
-      def haml_partial(name, options = {})
-        item_name = name.to_sym
-        counter_name = "#{name}_counter".to_sym
-        if collection = options.delete(:collection)
-          collection.enum_for(:each_with_index).collect do |item,index|
-            haml_partial name, options.merge(:locals => {item_name => item, counter_name => index+1})
-          end.join
-        elsif object = options.delete(:object)
-          haml_partial name, options.merge(:locals => {item_name => object, counter_name => nil})
-        else
-          haml "_#{name}".to_sym, options.merge(:layout => false)
+  module Renderers
+    module Haml
+      class << self
+        def registered(app)
+          app.helpers Middleman::Renderers::Haml::Helpers
+        end
+        alias :included :registered
+      end
+      
+      module Helpers
+        def haml_partial(name, options = {})
+          partial(name, options)
         end
       end
-    end
   
-    module Table
-      include ::Haml::Filters::Base
+      module Table
+        include ::Haml::Filters::Base
 
-      def render(text)
-        output = '<div class="table"><table cellspacing="0" cellpadding="0">'
-        line_num = 0
-        text.each_line do |line|
-          line_num += 1
-          next if line.strip.empty?
-          output << %Q{<tr class="#{(line_num % 2 == 0) ? "even" : "odd" }#{(line_num == 1) ? " first" : "" }">}
+        def render(text)
+          output = '<div class="table"><table cellspacing="0" cellpadding="0">'
+          line_num = 0
+          text.each_line do |line|
+            line_num += 1
+            next if line.strip.empty?
+            output << %Q{<tr class="#{(line_num % 2 == 0) ? "even" : "odd" }#{(line_num == 1) ? " first" : "" }">}
 
-          columns = line.split("|").map { |p| p.strip }
-          columns.each_with_index do |col, i|
-            output << %Q{<td class="col#{i+1}">#{col}</td>}
-          end
+            columns = line.split("|").map { |p| p.strip }
+            columns.each_with_index do |col, i|
+              output << %Q{<td class="col#{i+1}">#{col}</td>}
+            end
 
-          output << "</tr>"
+            output << "</tr>"
+          end
+          output + "</table></div>"
         end
-        output + "</table></div>"
       end
     end
   end
-end
-
-class Middleman::Server
-  helpers Middleman::Haml::Helpers
 end

data/lib/middleman/renderers/sass.rb

@@ -1,32 +1,36 @@
 require "sass"
 require "compass"
 
-class Middleman::Server
-  def scss(template, options={}, locals={})
-    options[:layout] = false
-    render :scss, template, options, locals
-  end
+module Middleman
+  module Renderers
+    module Sass
+      class << self
+        def registered(app)
+          app.after_feature_init do
+            ::Compass.configuration do |config|
+              config.cache_path            = File.join(self.root, ".sass-cache") # For sassc files
+              config.project_path          = self.root
+              config.sass_dir              = File.join(File.basename(self.views), self.css_dir)
+              config.output_style          = :nested
+              config.fonts_dir             = File.join(File.basename(self.public), self.fonts_dir)
+              config.css_dir               = File.join(File.basename(self.public), self.css_dir)
+              config.images_dir            = File.join(File.basename(self.public), self.images_dir)      
+              config.http_images_path      = self.http_images_path rescue File.join(self.http_prefix || "/", self.images_dir)
+              config.http_stylesheets_path = self.http_css_path rescue File.join(self.http_prefix || "/", self.css_dir)
+              config.asset_cache_buster { false }
 
-  after_feature_init do
-    ::Compass.configuration do |config|
-      config.cache_path            = File.join(self.root, ".sass-cache") # For sassc files
-      config.project_path          = self.root
-      config.sass_dir              = File.join(File.basename(self.views), self.css_dir)
-      config.output_style          = :nested
-      config.fonts_dir             = File.join(File.basename(self.public), self.fonts_dir)
-      config.css_dir               = File.join(File.basename(self.public), self.css_dir)
-      config.images_dir            = File.join(File.basename(self.public), self.images_dir)      
-      config.http_images_path      = self.http_images_path rescue File.join(self.http_prefix || "/", self.images_dir)
-      config.http_stylesheets_path = self.http_css_path rescue File.join(self.http_prefix || "/", self.css_dir)
-      config.asset_cache_buster { false }
-      
-      config.add_import_path(config.sass_dir)
-    end
-    
-    configure :build do
-      ::Compass.configuration do |config|
-        config.css_dir       = File.join(File.basename(self.build_dir), self.css_dir)
-        config.images_dir    = File.join(File.basename(self.build_dir), self.images_dir)
+              config.add_import_path(config.sass_dir)
+            end
+
+            configure :build do
+              ::Compass.configuration do |config|
+                config.css_dir       = File.join(File.basename(self.build_dir), self.css_dir)
+                config.images_dir    = File.join(File.basename(self.build_dir), self.images_dir)
+              end
+            end
+          end
+        end
+        alias :included :registered
       end
     end
   end
@@ -45,7 +49,6 @@ class Tilt::SassPlusCSSFilenameTemplate < Tilt::SassTemplate
   end
 end
 Tilt.register 'sass', Tilt::SassPlusCSSFilenameTemplate
-Middleman::Renderers.register(:sass, Tilt::SassPlusCSSFilenameTemplate)
 
 class Tilt::ScssPlusCSSFilenameTemplate < Tilt::SassPlusCSSFilenameTemplate
   def sass_options
@@ -53,10 +56,9 @@ class Tilt::ScssPlusCSSFilenameTemplate < Tilt::SassPlusCSSFilenameTemplate
   end
 end
 Tilt.register 'scss', Tilt::ScssPlusCSSFilenameTemplate
-Middleman::Renderers.register(:scss, Tilt::ScssPlusCSSFilenameTemplate)
 
 
-module Middleman::Haml
+module Middleman::Renderers::Haml
   module Sass
     include ::Haml::Filters::Base
 

data/lib/middleman/server.rb

@@ -1,14 +1,9 @@
 # We're riding on Sinatra, so let's include it.
 require "sinatra/base"
 
-# The content_for plugin allows Sinatra to use the throw/yield block
-# system similar to Rails views.
-require "sinatra/content_for"
-
-# Monkey-patch Sinatra to expose the layout parameter
-class Sinatra::Request
-  attr_accessor :layout
-end
+# Use the padrino project's helpers
+require "padrino-core/application/rendering"
+require "padrino-helpers"
 
 module Middleman
   class Server < Sinatra::Base
@@ -20,8 +15,7 @@ module Middleman
     set :logging,     false
     set :environment, (ENV['MM_ENV'] && ENV['MM_ENV'].to_sym) || :development
     
-    # Import content_for methods
-    helpers Sinatra::ContentFor
+    # Import padrino helper methods
     
     # Middleman-specific options
     set :index_file,  "index.html"  # What file responds to folder requests
@@ -36,20 +30,18 @@ module Middleman
     set :build_dir,   "build"       # Which folder are builds output to
     set :http_prefix, nil           # During build, add a prefix for absolute paths
     
-    # A hash of enabled features
-    @@enabled_features = {}
+    # Use Padrino Helpers
+    register Padrino::Helpers
+    set :asset_stamp, false         # Disable Padrino cache buster until explicitly enabled
     
-    # Override Sinatra's enable to keep track of enabled features
-    def self.enable(feature_name, config={})
-      @@enabled_features[feature_name] = config
-      super(feature_name)
-    end
+    # Activate custom features
+    register Middleman::Features
     
-    # Disable a feature, then pass to Sinatra's method
-    def self.disable(feature_name)
-      @@enabled_features.delete(feature_name)
-      super(feature_name)
-    end
+    # Activate built-in helpers
+    register Middleman::Features::DefaultHelpers
+    
+    # Tilt-aware renderer
+    register Padrino::Rendering
     
     # Override Sinatra's set to accept a block
     def self.set(option, value=self, &block)
@@ -68,37 +60,48 @@ module Middleman
       @@run_after_features << block
     end
     
+    # Activate custom renderers
+    register Middleman::Renderers::CoffeeScript
+    register Middleman::Renderers::Haml
+    register Middleman::Renderers::Sass
+    
     # 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
     
-    # Keep track of a block-specific layout
-    @@layout = nil
+    # 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, &block)
-      @@layout = layout
+    def self.with_layout(layout_name, &block)
+      old_layout = current_layout
+      
+      layout(layout_name)
       class_eval(&block) if block_given?
     ensure
-      @@layout = nil
+      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)
-      layout = @@layout
-      layout = options[:layout] if !options[:layout].nil?
-      
+      url << settings.index_file if url.match(%r{/$})
+  
+      options[:layout] ||= current_layout
       get(url) do
         return yield if block_given?
-        process_request(layout)
+        process_request(options)
       end
     end
 
@@ -109,20 +112,21 @@ module Middleman
     
   private
     # Internal method to look for templates and evaluate them if found
-    def process_request(layout = :layout)
+    def process_request(options={})
       # Normalize the path and add index if we're looking at a directory
       path = request.path
       path << settings.index_file if path.match(%r{/$})
       path.gsub!(%r{^/}, '')
-
-      if template_path = Dir.glob(File.join(settings.views, "#{path}.*")).first
+      
+      old_layout = settings.current_layout
+      settings.layout(options[:layout]) if !options[:layout].nil?
+      result = render(path, :layout => settings.fetch_layout_path.to_sym)
+      settings.layout(old_layout)
+      
+      if result
         content_type mime_type(File.extname(path)), :charset => 'utf-8'
-        
-        renderer = Middleman::Renderers.get_method(template_path)
-        if respond_to? renderer
-          status 200
-          return send(renderer, path.to_sym, { :layout => layout })
-        end
+        status 200
+        return result
       end
       
       status 404
@@ -131,8 +135,6 @@ module Middleman
 end
 
 require "middleman/assets"
-require "middleman/renderers"
-require "middleman/features"
 
 # The Rack App
 class Middleman::Server
@@ -152,13 +154,6 @@ class Middleman::Server
       set :app_file, File.expand_path(local_config)
     end
     
-    # loop over enabled feature
-    @@enabled_features.each do |feature_name, feature_config|
-      next unless send(:"#{feature_name}?")
-      $stderr.puts "== Enabling: #{feature_name.to_s.capitalize}" if logging?
-      Middleman::Features.run(feature_name, feature_config, self)
-    end
-    
     use ::Rack::ConditionalGet if environment == :development
     
     @@run_after_features.each { |block| class_eval(&block) }

data/lib/middleman/template/config.rbt

@@ -1,8 +1,8 @@
 # Automatic sitemaps
-# enable :slickmap
+# activate :slickmap
 
 # Automatic image dimension calculations
-# enable :automatic_image_sizes
+# activate :automatic_image_sizes
 
 # Per-page layout changes
 # With no layout
@@ -41,16 +41,16 @@ set :images_dir, "<%= images_dir -%>"
 # Build-specific configuration
 configure :build do
   # For example, change the Compass output style for deployment
-  # enable :minify_css
+  # activate :minify_css
   
   # Minify Javascript on build
-  # enable :minify_javascript
+  # activate :minify_javascript
   
   # Shrink/smush PNG/JPEGs on build
-  # enable :smush_pngs
+  # activate :smush_pngs
   
   # Enable cache buster
-  # enable :cache_buster
+  # activate :cache_buster
   
   # Or use a different image path
   # set :http_path, "/Content/images/"