middleman 0.9.0.pre → 0.9.3

data/lib/middleman/builder.rb

@@ -1,59 +1,12 @@
-require 'middleman/base'
-require 'templater'
-require 'middleman/templater+dynamic_renderer.rb'
+require 'rack/test'
 
-# Placeholder for any methods the builder needs to abstract to allow feature integration
 module Middleman
-  class Builder < ::Templater::Generator
-    
-    @@template_extensions = ::Tilt.mappings.keys << "js"
-    
-    # Define source and desintation
-    def self.source_root; Dir.pwd; end
-    def destination_root; File.join(Dir.pwd, Middleman::Base.build_dir); end
-
-    # Override template to ask middleman for the correct extension to output
-    def self.template(name, *args, &block)
-      return if args[0].include?('layout')
-
-      args.first.split('/').each do |part|
-        return if part[0,1] == '_'
-      end
-
-      if (args[0] === args[1])
-        args[1] = args[0].gsub("#{File.basename(Middleman::Base.views)}/", "").gsub("#{File.basename(Middleman::Base.public)}/", "")
-        if File.extname(args[1]) != ".js"
-          args[1] = args[1].gsub!(File.extname(args[1]), "") if File.basename(args[1]).split('.').length > 2
-        end
-      end
-
-      super(name, *args, &block)
-    end
-
-    def self.file(name, *args, &block)
-      file_ext = File.extname(args[0])
-      
-      return unless ::Tilt[file_ext].nil?
-      
-      if (args[0] === args[1])
-        args[1] = args[0].gsub("#{File.basename(Middleman::Base.views)}/", "").gsub("#{File.basename(Middleman::Base.public)}/", "")
-      end
-      super(name, *args, &block)
+  class Builder
+    def self.render_file(source, destination)      
+      request_path = destination.gsub(File.join(Dir.pwd, Middleman::Base.build_dir), "")
+      browser = Rack::Test::Session.new(Rack::MockSession.new(Middleman::Base))
+      browser.get(request_path)
+      browser.last_response.body
     end
-
-    def self.init!
-      glob! File.basename(Middleman::Base.public),  @@template_extensions
-      glob! File.basename(Middleman::Base.views),   @@template_extensions
-    end
-    
-    def after_run
-    end
-  end
-  
-  module Generators
-    extend ::Templater::Manifold
-    desc "Build a static site"
-
-    add :build, ::Middleman::Builder
   end
-end
+end

data/lib/middleman/features/cache_buster.rb

@@ -1,43 +1,9 @@
-class Middleman::Features::CacheBuster
-  def initialize(app)
-    Middleman::Assets.register :cache_buster do |path, prefix, request|
-      http_path = Middleman::Assets.before(: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::Base.images_dir if prefix == Middleman::Base.http_images_path
-        rescue
-        end
 
-        real_path_static  = File.join(Middleman::Base.public, prefix, path)
-
-        if File.readable?(real_path_static)
-          http_path << "?" + File.mtime(real_path_static).strftime("%s") 
-        elsif Middleman::Base.environment == "build"
-          real_path_dynamic = File.join(Middleman::Base.root, Middleman::Base.build_dir, prefix, path)
-          http_path << "?" + File.mtime(real_path_dynamic).strftime("%s") if File.readable?(real_path_dynamic)
-        end
-
-        http_path
-      end
-    end
-    
-    Middleman::Base.after_feature_init do 
-      ::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::Base.root, Middleman::Base.build_dir), Middleman::Base.public)
-          if File.readable?(real_path)
-            File.mtime(real_path).strftime("%s") 
-          else
-            $stderr.puts "WARNING: '#{File.basename(path)}' was not found (or cannot be read) in #{File.dirname(real_path)}"
-          end
-        end
-      end
-    end
-  end
-end
-
-Middleman::Features.register :cache_buster, Middleman::Features::CacheBuster
+# def cache_buster
+#   if File.readable?(real_path)
+#     File.mtime(real_path).strftime("%s") 
+#   else
+#     $stderr.puts "WARNING: '#{File.basename(path)}' was not found (or cannot be read) in #{File.dirname(real_path)}"
+#   end
+# end

data/lib/middleman/features/compass.rb

@@ -0,0 +1,28 @@
+require 'compass'
+
+class Middleman::Base
+  configure do
+    ::Compass.configuration do |config|
+      images_location = (self.environment == "build") ? self.build_dir : self.public
+      
+      config.project_path     = Dir.pwd
+      config.sass_dir         = File.join(File.basename(self.views), self.css_dir)
+      config.output_style     = self.minify_css? ? :compressed : :nested
+      config.css_dir          = File.join(File.basename(images_location), self.css_dir)
+      config.images_dir       = File.join(File.basename(images_location), self.images_dir)
+      # File.expand_path(self.images_dir, self.public)
+
+      if !cache_buster?
+        config.asset_cache_buster do
+          false
+        end
+      end
+    
+      config.http_images_path = "/#{self.images_dir}"
+      config.http_stylesheets_path = "/#{self.css_dir}"
+      config.add_import_path(config.sass_dir)
+    end
+    
+    ::Compass.configure_sass_plugin!
+  end
+end

data/lib/middleman/features/content_for.rb

@@ -0,0 +1,9 @@
+begin
+  require 'sinatra/content_for'
+
+  class Middleman::Base
+    helpers Sinatra::ContentFor
+  end
+rescue LoadError
+  puts "Sinatra::ContentFor not available. Install it with: gem install sinatra-content-for"
+end

data/lib/middleman/features/growl.rb

@@ -0,0 +1,2 @@
+# Errors to growl
+# Build complete to growl

data/lib/middleman/features/haml.rb

@@ -0,0 +1,128 @@
+module Middleman
+  module Haml
+    def self.included(base)
+      base.supported_formats << "haml"
+      base.helpers Middleman::HamlHelpers
+    end
+    
+    def render_path(path)
+      if template_exists?(path, :haml)
+        result = nil
+        begin
+          result = haml(path.to_sym, :layout => File.extname(path) != ".xml")
+        rescue ::Haml::Error => e
+          result = "Haml Error: #{e}"
+          result << "<pre>Backtrace: #{e.backtrace.join("\n")}</pre>"
+        end
+        result
+      else
+        super
+      end
+    end
+  end
+  
+  module HamlHelpers
+    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)
+      end
+    end
+  end
+  
+  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" : "" }">}
+
+        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>"
+      end
+      output + "</table></div>"
+    end
+  end
+  
+  module Sass  
+    def self.included(base)
+      base.supported_formats << "sass"
+    end
+  
+    def render_path(path)
+      if template_exists?(path, :sass)
+        begin
+          static_version = options.public + request.path_info
+          send_file(static_version) if File.exists? static_version
+
+          location_of_sass_file = options.environment == "build" ? "build" : "views"
+          css_filename = File.join(Dir.pwd, location_of_sass_file) + request.path_info
+          sass(path.to_sym, Compass.sass_engine_options.merge({ :css_filename => css_filename }))
+        rescue Exception => e
+          sass_exception_string(e)
+        end
+      else
+        super
+      end
+    end
+  
+    # Handle Sass errors
+    def sass_exception_string(e)
+      e_string = "#{e.class}: #{e.message}"
+
+      if e.is_a? ::Sass::SyntaxError
+        e_string << "\non line #{e.sass_line}"
+
+        if e.sass_filename
+          e_string << " of #{e.sass_filename}"
+
+          if File.exists?(e.sass_filename)
+            e_string << "\n\n"
+
+            min = [e.sass_line - 5, 0].max
+            begin
+              File.read(e.sass_filename).rstrip.split("\n")[
+                min .. e.sass_line + 5
+              ].each_with_index do |line, i|
+                e_string << "#{min + i + 1}: #{line}\n"
+              end
+            rescue
+              e_string << "Couldn't read sass file: #{e.sass_filename}"
+            end
+          end
+        end
+      end
+      <<END
+/*
+#{e_string}
+
+Backtrace:\n#{e.backtrace.join("\n")}
+*/
+body:before {
+  white-space: pre;
+  font-family: monospace;
+  content: "#{e_string.gsub('"', '\"').gsub("\n", '\\A ')}"; }
+END
+    end
+  end
+end
+
+class Middleman::Base
+  include Middleman::Haml
+  include Middleman::Sass
+end

data/lib/middleman/features/markaby.rb

@@ -0,0 +1,43 @@
+begin
+  require 'markaby'
+rescue LoadError
+  puts "Markaby not available. Install it with: gem install markaby"
+end
+
+module Middleman
+  module Markaby
+    def self.included(base)
+      base.supported_formats << "mab"
+    end
+    
+    def render_path(path)
+      if template_exists?(path, :mab)
+        markaby path.to_sym
+      else
+        super
+      end
+    end
+    
+    def markaby(template=nil, options={}, locals = {}, &block)
+      options, template = template, nil if template.is_a?(Hash)
+      template = lambda { block } if template.nil?
+      render :mab, template, options, locals
+    end
+
+  protected
+    def render_mab(template, data, options, locals, &block)
+      filename = options.delete(:filename) || '<MARKABY>'
+      line = options.delete(:line) || 1
+      mab = ::Markaby::Builder.new(locals)
+      if data.respond_to?(:to_str)
+        eval(data.to_str, binding, filename, line)
+      elsif data.kind_of?(Proc)
+        data.call(mab)
+      end
+    end
+  end
+  
+  class Base
+    include Middleman::Markaby
+  end
+end

data/lib/middleman/features/maruku.rb

@@ -0,0 +1,42 @@
+begin
+  require 'maruku'
+rescue LoadError
+  puts "Maruku not available. Install it with: gem install maruku"
+end
+
+module Middleman
+  module Maruku
+    def self.included(base)
+      base.supported_formats << "maruku"
+    end
+    
+    def render_path(path)
+      if template_exists?(path, :maruku)
+        maruku path.to_sym
+      else
+        super
+      end
+    end
+    
+    def maruku(template, options={}, locals={})
+      render :maruku, template, options, locals
+    end
+
+  private
+    def render_maruku(data, options, locals, &block)
+      maruku_src = render_erb(data, options, locals, &block)
+      instance = ::Maruku.new(maruku_src, options)
+      if block_given?
+        # render layout
+        instance.to_html_document
+      else
+        # render template
+        instance.to_html
+      end  
+    end
+  end
+  
+  class Base
+    include Middleman::Maruku
+  end
+end

data/lib/middleman/features/minify_css.rb

@@ -1,9 +1,2 @@
-class Middleman::Features::MinifyCSS
-  def initialize(app)
-    Middleman::Base.after_feature_init do
-      ::Compass.configuration.output_style = :compressed
-    end
-  end
-end
-
-Middleman::Features.register :minify_css, Middleman::Features::MinifyCSS
+# Otherwise use YUI
+# Fine a way to minify inline/css

data/lib/middleman/features/minify_javascript.rb

@@ -1,20 +1,31 @@
-class Middleman::Features::MinifyJavascript
-  def initialize(app)
-    Haml::Javascript.send :include, ::Haml::Filters::Base
-    
-    require "middleman/features/minify_javascript/rack"
-    app.use Middleman::Rack::MinifyJavascript
-  end
-  
-  module Haml
+require "yui/compressor"
+
+module Middleman
+  module Minified
     module Javascript
+      include ::Haml::Filters::Base
       def render_with_options(text, options)
         compressor = ::YUI::JavaScriptCompressor.new(:munge => true)
         data = compressor.compress(text)
-        %Q{<script type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}>#{data.chomp}</script>}
+        <<END
+<script type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}>#{data.chomp}</script>
+END
       end
     end
   end
-end
-
-Middleman::Features.register :minify_javascript, Middleman::Features::MinifyJavascript
+  
+  module Compressor
+    def render_path(path)
+      if template_exists?(path, :js)
+        compressor = YUI::JavaScriptCompressor.new(:munge => true)
+        compressor.compress(super)
+      else
+        super
+      end
+    end
+  end
+  
+  class Base
+    include Middleman::Compressor
+  end
+end

data/lib/middleman/features/relative_assets.rb

@@ -1,35 +1,28 @@
-class Middleman::Features::RelativeAssets
-  def initialize(app)
-    ::Compass.configuration.relative_assets = true
-  
-    Middleman::Assets.register :relative_assets do |path, prefix, request|
-      begin
-        prefix = Middleman::Base.images_dir if prefix == Middleman::Base.http_images_path
-      rescue
+class Middleman::Base
+  if compass?
+    configure do
+      ::Compass.configuration do |config|
+        config.relative_assets = true
       end
-    
+    end
+  end
+  
+  helpers do
+    def asset_url(path)
       if path.include?("://")
-        Middleman::Assets.before(: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::Base.index_file if path.match(%r{/$})
+        request_path << "index.html" if path.match(%r{/$})
         request_path.gsub!(%r{^/}, '')
         parts = request_path.split('/')
-
+      
         if parts.length > 1
-          arry = []
-          (parts.length - 1).times { arry << ".." }
-          arry << path
-          File.join(*arry)
+          "../" * (parts.length - 1) + path
         else
           path
         end
       end
     end
   end
-end
-
-Middleman::Features.register :relative_assets, Middleman::Features::RelativeAssets
+end