middleman 0.5.5 → 0.9.0.pre

data/lib/middleman/features/livereload.rb

@@ -0,0 +1,19 @@
+class Middleman::Features::LiveReload
+  def initialize(app)
+    return unless Middleman::Base.environment == :development
+    
+    begin
+      require 'livereload'
+    rescue LoadError
+      puts "Livereload not available. Install it with: gem install livereload"
+    end
+  
+    new_config = ::LiveReload::Config.new do |config|
+      config.exts = %w(haml sass scss coffee less builder)
+    end
+  
+    ::LiveReload.run [Middleman::Base.public, Middleman::Base.views], new_config
+  end
+end
+
+Middleman::Features.register :livereload, Middleman::Features::LiveReload

data/lib/middleman/features/minify_css.rb

@@ -0,0 +1,9 @@
+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

data/lib/middleman/features/minify_javascript.rb

@@ -0,0 +1,20 @@
+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
+    module Javascript
+      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
+    end
+  end
+end
+
+Middleman::Features.register :minify_javascript, Middleman::Features::MinifyJavascript

data/lib/middleman/features/minify_javascript/rack.rb

@@ -0,0 +1,31 @@
+begin
+  require "yui/compressor"
+rescue LoadError
+  puts "YUI-Compressor not available. Install it with: gem install yui-compressor"
+end
+  
+module Middleman
+  module Rack
+  
+    class MinifyJavascript
+      def initialize(app, options={})
+        @app = app
+      end
+
+      def call(env)
+        status, headers, response = @app.call(env)
+    
+        if env["PATH_INFO"].match(/\.js$/)
+          compressor = ::YUI::JavaScriptCompressor.new(:munge => true)
+      
+          uncompressed_source = response.is_a?(::Rack::File) ? File.read(response.path) : response
+          response = compressor.compress(uncompressed_source)
+          headers["Content-Length"] = ::Rack::Utils.bytesize(response).to_s
+        end
+    
+        [status, headers, response]
+      end
+    end
+    
+  end
+end

data/lib/middleman/features/relative_assets.rb

@@ -0,0 +1,35 @@
+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
+      end
+    
+      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.gsub!(%r{^/}, '')
+        parts = request_path.split('/')
+
+        if parts.length > 1
+          arry = []
+          (parts.length - 1).times { arry << ".." }
+          arry << path
+          File.join(*arry)
+        else
+          path
+        end
+      end
+    end
+  end
+end
+
+Middleman::Features.register :relative_assets, Middleman::Features::RelativeAssets

data/lib/middleman/features/slickmap.rb

@@ -0,0 +1,118 @@
+Entry = Struct.new(:dir, :children)
+
+class Middleman::Features::Slickmap
+  def initialize(app)
+    require 'slickmap'
+
+    if Middleman::Base.environment == "build"
+      Middleman::Builder.template :slickmap, "sitemap.html", "sitemap.html"
+    end
+
+    def build_sitemap(&block)    
+      @@utility = []
+      [recurse_sitemap(Middleman::Base.views, &block), @@utility]
+    end
+
+    def recurse_sitemap(path, &block)
+      bad_ext = path.split('.html')[1]
+      path = path.gsub(bad_ext, '') if bad_ext
+      entry = Entry.new(path, [])
+
+      #no "." or ".." dirs
+      Dir[File.join(path, "*")].each do |e|
+        next if !File.directory?(e) && !e.include?(".html")
+        if File.directory?(e)
+          entry.children << recurse_sitemap(e, &block)
+        elsif block_given?
+          how_to_handle = block.call(e)
+          if how_to_handle == :valid
+            entry.children << recurse_sitemap(e, &block)
+          elsif how_to_handle == :utility
+            bad_ext = e.split('.html')[1]
+            e = e.gsub(bad_ext, '') if bad_ext
+            @@utility << e.gsub(Middleman::Base.views + "/", '')
+          end
+        end
+      end
+
+      entry
+    end
+    
+    Middleman::Base.helpers do
+      def sitemap_node(n, first=false)
+        if n.children.length < 1
+          if !first && File.extname(n.dir).length > 0
+            haml_tag :li do
+              path = n.dir.gsub(self.class.views, '')
+              haml_concat link_to(File.basename(path), path)
+            end
+          end
+        else  
+          haml_tag(:li, :id => first ? "home" : nil) do
+            if first
+              haml_concat link_to("Homepage", "/" + self.class.index_file)
+            else
+              # we are a dir
+              index = n.children.find { |c| c.dir.include?(self.class.index_file) }
+              haml_concat link_to(index.dir.gsub(self.class.views + "/", '').gsub("/" + File.basename(index.dir), '').capitalize, index.dir.gsub(self.class.views, ''))
+            end
+
+            other_children = n.children.select { |c| !c.dir.include?(self.class.index_file) }
+            if other_children.length > 0
+              if first
+                other_children.each { |i| sitemap_node(i) }
+              else
+                haml_tag :ul do
+                  other_children.each { |i| sitemap_node(i) }
+                end
+              end
+            end
+          end  
+        end
+      end
+    end
+
+    Middleman::Base.get '/sitemap.html' do
+      # Return :utility to put it util top menu. False to ignore
+      @tree, @utility = build_sitemap do |file_name|
+        :valid
+      end
+      haml :sitemap, :layout => false
+    end
+
+    Middleman::Base.use_in_file_templates!
+  end
+end
+
+Middleman::Features.register :slickmap, Middleman::Features::Slickmap
+
+__END__
+
+@@ sitemap
+!!!
+%html{ :xmlns => "http://www.w3.org/1999/xhtml" }
+  %head
+    %meta{ :content => "text/html; charset=utf-8", "http-equiv" => "Content-type" }
+    %title Sitemap
+    %style{ :type => "text/css" }
+      :sass
+        @import "slickmap"
+        +slickmap
+    :javascript
+      window.onload = function() {
+        document.getElementById('primaryNav').className = "col" + document.querySelectorAll("#primaryNav > li:not(#home)").length;
+      };
+
+  %body
+    .logo
+      %h1= @project_name || "Sitemap"
+      - if @project_subtitle
+        %h2= @project_subtitle
+    
+      - if @utility.length > 0
+        %ul#utilityNav
+          - @utility.each do |u|
+            %li= link_to u, u
+    
+    %ul#primaryNav
+      - sitemap_node(@tree, true)

data/lib/middleman/features/smush_pngs.rb

@@ -0,0 +1,38 @@
+class Middleman::Features::SmushPngs
+  def initialize(app)
+    require "middleman/builder"
+
+    Middleman::Base.alias_method  :pre_smush_after_run, :after_run
+    Middleman::Base.define_method :after_run do
+      pre_smush_after_run
+      smush_dir = File.join(Middleman::Base.build_dir, Middleman::Base.images_dir)
+      
+      # Read cache
+      cache_file = File.join(Middleman::Base.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
+
+          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::Base.build_dir+"/", '')
+          end
+        end
+      end
+    end
+  end
+end
+
+Middleman::Features.register :smush_pngs, Middleman::Features::SmushPngs

data/lib/middleman/features/ugly_haml.rb

@@ -0,0 +1,7 @@
+class Middleman::Features::UglyHaml
+  def initialize(app)
+    Middleman::Base.set :haml, Middleman::Base.settings.haml.merge({ :ugly_haml => true })
+  end
+end
+
+Middleman::Features.register :ugly_haml, Middleman::Features::UglyHaml

data/lib/middleman/renderers.rb

@@ -0,0 +1,26 @@
+module Middleman
+
+  module Renderers
+    @@render_method_for_template_types = {}
+  
+    def self.register(method_name, template_type)
+      @@render_method_for_template_types[template_type.to_s] = method_name
+    end
+  
+    def self.get_method(template_path)
+      template_type = Tilt[template_path].to_s
+      @@render_method_for_template_types[template_type]
+    end
+
+  end
+end
+
+# Types built into Sinatra
+Middleman::Renderers.register(:less,    Tilt::LessTemplate)
+Middleman::Renderers.register(:haml,    Tilt::HamlTemplate)
+Middleman::Renderers.register(:builder, Tilt::BuilderTemplate)
+Middleman::Renderers.register(:erb,     Tilt::ERBTemplate)
+
+%w(haml
+   sass
+   coffee).each { |renderer| require "middleman/renderers/#{renderer}" }

data/lib/middleman/renderers/coffee.rb

@@ -0,0 +1,28 @@
+class Middleman::Base
+  def coffee(template, options={}, locals={})
+    options[:layout] = false
+    render :coffee, template, options, locals
+  end
+end
+
+unless defined? Tilt::CoffeeTemplate
+  # CoffeeScript info:
+  # http://jashkenas.github.com/coffee-script/
+  class Tilt::CoffeeTemplate < Tilt::Template
+    def initialize_engine
+      return if defined? ::CoffeeScript
+      require_template_library 'coffee-script'
+    end
+
+    def prepare
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= ::CoffeeScript::compile(data, options)
+    end
+  end
+  Tilt.register 'coffee', Tilt::CoffeeTemplate
+end
+
+Middleman::Renderers.register(:coffee, Tilt::CoffeeTemplate)

data/lib/middleman/renderers/haml.rb

@@ -0,0 +1,47 @@
+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)
+        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
+  end
+end
+
+class Middleman::Base
+  helpers Middleman::Haml::Helpers
+end

data/lib/middleman/renderers/sass.rb

@@ -0,0 +1,67 @@
+require "sass"
+require "compass"
+
+class Middleman::Base
+  def scss(template, options={}, locals={})
+    options[:layout] = false
+    render :scss, template, options, locals
+  end
+
+  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)
+      end
+    end
+  end
+end
+
+class Tilt::SassPlusCSSFilenameTemplate < Tilt::SassTemplate
+  def sass_options
+    location_of_sass_file = Middleman::Base.environment == "build" ? 
+                              File.join(Middleman::Base.root, Middleman::Base.build_dir) : 
+                              Middleman::Base.public
+
+    parts = basename.split('.')
+    parts.pop
+    css_filename = File.join(location_of_sass_file, Middleman::Base.css_dir, parts.join("."))
+    super.merge(::Compass.configuration.to_sass_engine_options).merge(:css_filename => css_filename)
+  end
+end
+Tilt.register 'sass', Tilt::SassPlusCSSFilenameTemplate
+Middleman::Renderers.register(:sass, Tilt::SassPlusCSSFilenameTemplate)
+
+class Tilt::ScssPlusCSSFilenameTemplate < Tilt::SassPlusCSSFilenameTemplate
+  def sass_options
+    super.merge(:syntax => :scss)
+  end
+end
+Tilt.register 'scss', Tilt::ScssPlusCSSFilenameTemplate
+Middleman::Renderers.register(:scss, Tilt::ScssPlusCSSFilenameTemplate)
+
+
+module Middleman::Haml
+  module Sass
+    include ::Haml::Filters::Base
+
+    def render(text)
+      ::Sass::Engine.new(text, ::Compass.configuration.to_sass_engine_options).render
+    end
+  end
+end