middleman 0.5.5 → 0.9.0.pre

data/features/page_alias_and_layouts.feature

@@ -0,0 +1,12 @@
+Feature: Custom layouts
+  In order easily switch between relative and absolute paths
+  
+  Scenario: Using custom :layout attribute
+    Given page "/custom-layout.html" has layout "custom"
+    When I go to "/custom-layout.html"
+    Then I should see "Custom Layout"
+    
+  Scenario: Using with_layout block
+    Given "/custom-layout.html" with_layout block has layout "custom"
+    When I go to "/custom-layout.html"
+    Then I should see "Custom Layout"

data/features/relative_assets.feature

@@ -0,0 +1,12 @@
+Feature: Relative Assets
+  In order easily switch between relative and absolute paths
+    
+  Scenario: Rendering css with the feature disabled
+    Given "relative_assets" feature is "disabled"
+    When I go to "/stylesheets/relative_assets.css"
+    Then I should not see "url('../"
+
+  Scenario: Rendering css with the feature enabled
+    Given "relative_assets" feature is "enabled"
+    When I go to "/stylesheets/relative_assets.css"
+    Then I should see "url('../"

data/features/step_definitions/asset_host_steps.rb

@@ -0,0 +1,7 @@
+Given /^I am using an asset host$/ do
+  Middleman::Base.enable :asset_host
+  Middleman::Base.set :asset_host do |asset|
+    "http://assets%d.example.com" % (asset.hash % 4)
+  end
+  @browser = Rack::Test::Session.new(Rack::MockSession.new(Middleman::Base.new))
+end

data/features/step_definitions/env.rb

@@ -0,0 +1,3 @@
+ENV["MM_DIR"] = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec", "fixtures", "sample")
+require File.join(File.dirname(File.dirname(File.dirname(__FILE__))), 'lib', 'middleman')
+require "rack/test"

data/features/step_definitions/generator_steps.rb

@@ -0,0 +1,24 @@
+require 'fileutils'
+
+Then /^template files should exist at "([^\"]*)"$/ do |dirname|
+  target = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec", "fixtures", dirname)
+  template_glob = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "lib", "middleman", "template", "*/**/*")
+  
+  Dir[template_glob].each do |f|
+    next if File.directory?(f)
+    File.exists?("#{target}/#{f.split('template/')[1]}").should be_true
+  end
+end
+
+Then /^empty directories should exist at "([^\"]*)"$/ do |dirname|
+  target = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec", "fixtures", dirname)
+  
+  %w(views/stylesheets public/stylesheets public/javascripts public/images).each do |d|
+    File.exists?("#{target}/#{d}").should be_true
+  end
+end
+
+Then /^cleanup at "([^\"]*)"$/ do |dirname|
+  target = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec", "fixtures", dirname)
+  FileUtils.rm_rf(target)
+end

data/features/step_definitions/middleman_steps.rb

@@ -0,0 +1,28 @@
+Given /^"([^\"]*)" feature is "([^\"]*)"$/ do |feature, state|
+  enable_or_disable = (state == "enabled") ? :enable : :disable
+  Middleman::Base.send(enable_or_disable, feature.to_sym)
+  @browser = Rack::Test::Session.new(Rack::MockSession.new(Middleman::Base.new))
+end
+
+Given /^generated directory at "([^\"]*)"$/ do |dirname|
+  target = File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec", "fixtures", dirname)
+  init_cmd = File.expand_path(File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "bin", "mm-init"))
+  `cd #{File.dirname(target)} && #{init_cmd} #{File.basename(target)}`
+end
+
+When /^I go to "([^\"]*)"$/ do |url|
+  @browser.get(url)
+end
+
+Then /^I should see "([^\"]*)"$/ do |expected|
+  @browser.last_response.body.should include(expected)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |expected|
+  @browser.last_response.body.should_not include(expected)
+end
+
+Then /^I should see "([^\"]*)" lines$/ do |lines|
+  $stderr.puts @browser.last_response.body
+  @browser.last_response.body.chomp.split($/).length.should == lines.to_i
+end

data/features/step_definitions/page_layout_steps.rb

@@ -0,0 +1,13 @@
+Given /^page "([^\"]*)" has layout "([^\"]*)"$/ do |url, layout|
+  Middleman::Base.set :root, File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec", "fixtures", "sample")
+  Middleman::Base.page(url, :layout => layout.to_sym)
+  @browser = Rack::Test::Session.new(Rack::MockSession.new(Middleman::Base.new))
+end
+
+Given /^"([^\"]*)" with_layout block has layout "([^\"]*)"$/ do |url, layout|
+  Middleman::Base.set :root, File.join(File.dirname(File.dirname(File.dirname(__FILE__))), "spec", "fixtures", "sample")
+  Middleman::Base.with_layout(:layout => layout.to_sym) do
+    page(url)
+  end
+  @browser = Rack::Test::Session.new(Rack::MockSession.new(Middleman::Base.new))
+end

data/lib/middleman.rb

@@ -1,134 +1,8 @@
-require 'haml'
-require 'compass' #must be loaded before sinatra
-require 'sinatra/base'
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
 
-# Sprockets ruby 1.9 hack
-require 'sprockets'
-require File.join(File.dirname(__FILE__), 'middleman', 'sprockets_ext')
+require 'rubygems'
 
-require "yui/compressor"
-
-# Include content_for support
-require File.join(File.dirname(__FILE__), '..', 'vendor', 'sinatra-content-for', 'lib', 'sinatra', 'content_for')
-
-class Middleman < Sinatra::Base
-  set :app_file, __FILE__
-  set :static, true
-  set :root, Dir.pwd
-  set :environment, defined?(MIDDLEMAN_BUILDER) ? :build : :development
-  set :default_ext, 'html'
-  set :supported_formats, %w(haml erb builder)
-  
-  helpers Sinatra::ContentFor
-
-  def self.run!(options={}, &block)
-    set options
-    handler      = detect_rack_handler
-    handler_name = handler.name.gsub(/.*::/, '')
-    puts "== The Middleman is standing watch on port #{port}"
-    handler.run self, :Host => host, :Port => port do |server|
-      trap(:INT) do
-        ## Use thins' hard #stop! if available, otherwise just #stop
-        server.respond_to?(:stop!) ? server.stop! : server.stop
-        puts "\n== The Middleman has ended his patrol"
-      end
-      
-      if block_given?
-        block.call
-        ## Use thins' hard #stop! if available, otherwise just #stop
-        server.respond_to?(:stop!) ? server.stop! : server.stop
-      end
-    end
-  rescue Errno::EADDRINUSE => e
-    puts "== The Middleman is already standing watch on port #{port}!"
-  end
-  
-  configure do
-    Compass.configuration do |config|
-      config.project_path     = Dir.pwd
-      config.sass_dir         = File.join(File.basename(self.views), "stylesheets")
-      config.output_style     = :nested
-      config.css_dir          = File.join(File.basename(self.public), "stylesheets")
-      config.images_dir       = File.join(File.basename(self.public), "images")
-      config.http_images_path = "/images"
-      config.http_stylesheets_path = "/stylesheets"
-      config.add_import_path(config.sass_dir)
-    end
-  end
-  
-  # include helpers
-  class_eval File.read(File.join(File.dirname(__FILE__), 'middleman', 'helpers.rb'))
-  
-  # Check for local config
-  local_config = File.join(self.root, "init.rb")
-  if File.exists? local_config
-    puts "== Local config at: #{local_config}"
-    class_eval File.read(local_config)
-  end
-  
-  configure do
-    Compass.configure_sass_plugin!
-  end
-  
-  configure :build do
-    Compass.configuration do |config|
-      config.output_style = :compressed
-    end
-    
-    module Minified
-      module Javascript
-        include ::Haml::Filters::Base
-        def render_with_options(text, options)
-          compressor = ::YUI::JavaScriptCompressor.new(:munge => true)
-          data = compressor.compress(text.rstrip.gsub("\n", "\n    "))
-          %Q{<script type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}>#{data.chomp}</script>}
-        end
-      end
-    end
-  end
-  
-  # CSS files
-  get %r{/(.*).css} do |path|
-    content_type 'text/css', :charset => 'utf-8'
-    begin
-      static_version = File.join(Dir.pwd, 'public') + request.path_info
-      send_file(static_version) if File.exists? static_version
-      
-      location_of_sass_file = defined?(MIDDLEMAN_BUILDER) ? "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
-  end
-  
-  # All other files
-  get /(.*)/ do |path|
-    path << "index.#{options.default_ext}" if path.match(%r{/$})
-    path.gsub!(%r{^/}, '')
-    path_without_ext = path.gsub(File.extname(path), '')
-    
-    result = nil
-    begin
-      options.supported_formats.detect do |renderer|
-        if File.exists?(File.join(options.views, "#{path}.#{renderer}"))
-          result = send(renderer.to_sym, path.to_sym)
-        elsif File.exists?(File.join(options.views, "#{path_without_ext}.#{renderer}"))
-          result = send(renderer.to_sym, path_without_ext.to_sym)
-        else
-          false
-        end
-      end
-    rescue Haml::Error => e
-      result = "Haml Error: #{e}"
-      result << "<pre>Backtrace: #{e.backtrace.join("\n")}</pre>"
-    end
-    
-    result || pass
-  end
-  
-  get %r{/(.*\.xml)} do |path|
-    content_type 'text/xml', :charset => 'utf-8'
-    haml(path.to_sym, :layout => false)
-  end
-end
+module Middleman
+  autoload :Base, "middleman/base"  
+end

data/lib/middleman/assets.rb

@@ -0,0 +1,33 @@
+module Middleman
+  module Assets
+    @@asset_handler_map   = []
+    @@asset_handler_stack = []
+    
+    def self.register(handler_name, &block)
+      if block_given?
+        @@asset_handler_stack << block
+        @@asset_handler_map   << handler_name
+      end
+    end
+    
+    def self.get_url(path, prefix="", request=nil)
+      @@asset_handler_stack.last.call(path, prefix, request)
+    end
+    
+    def self.before(position, *args)
+      current_index = @@asset_handler_map.index(position)
+      return nil unless current_index
+
+      previous = current_index - 1
+      if (previous >= 0) && (previous < @@asset_handler_map.length)
+        @@asset_handler_stack[previous].call(*args)
+      else
+        nil
+      end
+    end
+  end
+end
+
+Middleman::Assets.register :base do |path, prefix, request|
+  path.include?("://") ? path : File.join(Middleman::Base.http_prefix || "/", prefix, path)
+end

data/lib/middleman/base.rb

@@ -0,0 +1,147 @@
+# We're riding on Sinatra, so let's include it
+require "sinatra/base"
+require "sinatra/content_for"
+
+class Sinatra::Request
+  attr_accessor :layout
+end
+
+module Middleman
+  class Base < Sinatra::Base
+    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'] || :development
+    set :index_file, "index.html"
+    set :js_dir, "javascripts"
+    set :css_dir, "stylesheets"
+    set :images_dir, "images"
+    set :fonts_dir, "fonts"
+    set :build_dir, "build"
+    set :http_prefix, nil
+    
+    helpers Sinatra::ContentFor
+    
+    set :features, []
+    def self.enable(*opts)
+      set :features, (self.features << opts).flatten
+      super
+    end
+    
+    def self.disable(*opts)
+      current = self.features
+      current -= opts.flatten
+      set :features, current
+      super
+    end
+    
+    def self.set(option, value=self, &block)
+      if block_given?
+        value = Proc.new { block }
+      end
+      
+      super(option, value, &nil)
+    end
+    
+    @@afters = []
+    def self.after_feature_init(&block)
+      @@afters << block
+    end
+    
+    # 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
+    
+    @@layout = nil
+    def self.page(url, options={}, &block)
+      layout = @@layout
+      layout = options[:layout] if !options[:layout].nil?
+      
+      get(url) do
+        return yield if block_given?
+        process_request(layout)
+      end
+    end
+    
+    def self.with_layout(layout, &block)
+      @@layout = layout
+      class_eval(&block) if block_given?
+    ensure
+      @@layout = nil
+    end
+    
+    def self.enabled?(name)
+      name = (name.to_s << "?").to_sym
+      self.respond_to?(name) && self.send(name)
+    end
+    
+    def enabled?(name)
+      self.class.enabled?(name)
+    end
+
+    # This will match all requests not overridden in the project's init.rb
+    not_found do
+      process_request
+    end
+    
+  private
+    def process_request(layout = :layout)
+      # 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{^/}, '')
+
+      template_path = locate_template_file(path)
+      if template_path
+        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
+      end
+      
+      status 404
+    end
+    
+    def locate_template_file(path)
+      template_path = File.join(settings.views, "#{path}.*")
+      Dir.glob(template_path).first
+    end
+  end
+end
+
+require "middleman/assets"
+require "middleman/renderers"
+require "middleman/features"
+
+# The Rack App
+class Middleman::Base
+  def self.new(*args, &block)
+    # Check for and evaluate local configuration
+    local_config = File.join(self.root, "init.rb")
+    if File.exists? local_config
+      puts "== Reading:  Local config" if logging?
+      Middleman::Base.class_eval File.read(local_config)
+      set :app_file, File.expand_path(local_config)
+    end
+    
+    # loop over enabled feature
+    features.flatten.each do |feature_name|
+      next unless send(:"#{feature_name}?")
+      $stderr.puts "== Enabling: #{feature_name.to_s.capitalize}" if logging?
+      Middleman::Features.run(feature_name, self)
+    end
+    
+    use ::Rack::ConditionalGet if environment == :development
+    
+    @@afters.each { |block| class_eval(&block) }
+    
+    super
+  end
+end

data/lib/middleman/builder.rb

@@ -0,0 +1,59 @@
+require 'middleman/base'
+require 'templater'
+require 'middleman/templater+dynamic_renderer.rb'
+
+# 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)
+    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