beans-middleman 1.0.5

data/fixtures/test-app/views/stylesheets/relative_assets.css.sass

@@ -0,0 +1,3 @@
+@import "compass"
+h1
+  background: image-url("blank.gif")

data/fixtures/test-app/views/stylesheets/site.css.sass

@@ -0,0 +1 @@
+@import "compass/reset"

data/fixtures/test-app/views/stylesheets/site_scss.css.scss

@@ -0,0 +1 @@
+@import "compass/reset";

data/fixtures/test-app/views/stylesheets/test_less.css.less

@@ -0,0 +1,5 @@
+@brand_color: #666666;
+
+#header {
+  color: @brand_color;
+}

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::Server.http_prefix || "/", prefix, path)
+end

data/lib/middleman/builder.rb

@@ -0,0 +1,60 @@
+require 'middleman/server'
+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
+    
+    # Support all Tilt-enabled templates and treat js like a template
+    @@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::Server.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::Server.views)}/", "").gsub("#{File.basename(Middleman::Server.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::Server.views)}/", "").gsub("#{File.basename(Middleman::Server.public)}/", "")
+      end
+      super(name, *args, &block)
+    end
+
+    def self.init!
+      glob! File.basename(Middleman::Server.public),  @@template_extensions
+      glob! File.basename(Middleman::Server.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

data/lib/middleman/config.ru

@@ -0,0 +1,2 @@
+require 'middleman'
+run Middleman::Server

data/lib/middleman/features/asset_host.rb

@@ -0,0 +1,22 @@
+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)
+        end
+      end
+
+      Middleman::Assets.register :asset_host do |path, prefix, request|
+        original_output = Middleman::Assets.before(:asset_host, path, prefix, request)
+
+        valid_extensions = %w(.png .gif .jpg .jpeg .js .css)
+
+        asset_prefix = Middleman::Server.asset_host.call(original_output)
+
+        File.join(asset_prefix, original_output)
+      end
+    end
+    alias :included :registered
+  end
+end

data/lib/middleman/features/automatic_image_sizes/fastimage.rb

@@ -0,0 +1,287 @@
+# FastImage finds the size or type of an image given its uri.
+# It is careful to only fetch and parse as much of the image as is needed to determine the result.
+# It does this by using a feature of Net::HTTP that yields strings from the resource being fetched
+# as soon as the packets arrive.
+#
+# No external libraries such as ImageMagick are used here, this is a very lightweight solution to 
+# finding image information.
+#
+# FastImage knows about GIF, JPEG, BMP and PNG files.
+#
+# FastImage can also read files from the local filesystem by supplying the path instead of a uri.
+# In this case FastImage uses the open-uri library to read the file in chunks of 256 bytes until
+# it has enough. This is possibly a useful bandwidth-saving feature if the file is on a network
+# attached disk rather than truly local.
+#
+# === Examples
+#   require 'fastimage'
+#
+#   FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
+#   => [266, 56]
+#   FastImage.type("http://stephensykes.com/images/pngimage")
+#   => :png
+#   FastImage.type("/some/local/file.gif")
+#   => :gif
+#
+# === References
+# * http://snippets.dzone.com/posts/show/805
+# * http://www.anttikupila.com/flash/getting-jpg-dimensions-with-as3-without-loading-the-entire-file/
+# * http://pennysmalls.com/2008/08/19/find-jpeg-dimensions-fast-in-ruby/
+# * http://imagesize.rubyforge.org/
+#
+require 'net/https'
+require 'open-uri'
+
+class FastImage
+  attr_reader :size, :type
+
+  class FastImageException < StandardError # :nodoc:
+  end
+  class MoreCharsNeeded < FastImageException # :nodoc:
+  end
+  class UnknownImageType < FastImageException # :nodoc:
+  end
+  class ImageFetchFailure < FastImageException # :nodoc:
+  end
+  class SizeNotFound < FastImageException # :nodoc:
+  end
+
+  DefaultTimeout = 2
+  
+  LocalFileChunkSize = 256
+
+  # Returns an array containing the width and height of the image.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot size the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # FastImage knows about GIF, JPEG, BMP and PNG files.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
+  #   => [266, 56]
+  #   FastImage.size("http://stephensykes.com/images/pngimage")
+  #   => [16, 16]
+  #   FastImage.size("http://farm4.static.flickr.com/3023/3047236863_9dce98b836.jpg")
+  #   => [500, 375]
+  #   FastImage.size("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
+  #   => [512, 512]
+  #   FastImage.size("test/fixtures/test.jpg")
+  #   => [882, 470]
+  #   FastImage.size("http://pennysmalls.com/does_not_exist")
+  #   => nil
+  #   FastImage.size("http://pennysmalls.com/does_not_exist", :raise_on_failure=>true)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://stephensykes.com/favicon.ico", :raise_on_failure=>true)
+  #   => raises FastImage::UnknownImageType
+  #   FastImage.size("http://stephensykes.com/favicon.ico", :raise_on_failure=>true, :timeout=>0.01)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://stephensykes.com/images/faulty.jpg", :raise_on_failure=>true)
+  #   => raises FastImage::SizeNotFound
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image size cannot be found for any reason.
+  #
+  def self.size(uri, options={})
+    new(uri, options).size
+  end
+
+  # Returns an symbol indicating the image type fetched from a uri.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot find the type of the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.type("http://stephensykes.com/images/ss.com_x.gif")
+  #   => :gif
+  #   FastImage.type("http://stephensykes.com/images/pngimage")
+  #   => :png
+  #   FastImage.type("http://farm4.static.flickr.com/3023/3047236863_9dce98b836.jpg")
+  #   => :jpeg
+  #   FastImage.type("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
+  #   => :bmp
+  #   FastImage.type("test/fixtures/test.jpg")
+  #   => :jpeg
+  #   FastImage.type("http://pennysmalls.com/does_not_exist")
+  #   => nil
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image type cannot be found for any reason.
+  #
+  def self.type(uri, options={})
+    new(uri, options.merge(:type_only=>true)).type
+  end
+
+  def initialize(uri, options={})
+    @property = options[:type_only] ? :type : :size
+    @timeout = options[:timeout] || DefaultTimeout
+    @uri = uri
+    begin
+      @parsed_uri = URI.parse(uri)
+    rescue URI::InvalidURIError
+      fetch_using_open_uri
+    else
+      if @parsed_uri.scheme == "http" || @parsed_uri.scheme == "https"
+        fetch_using_http
+      else
+        fetch_using_open_uri
+      end
+    end
+    raise SizeNotFound if options[:raise_on_failure] && @property == :size && !@size
+  rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET, 
+    ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT
+    raise ImageFetchFailure if options[:raise_on_failure]
+  rescue NoMethodError  # 1.8.7p248 can raise this due to a net/http bug
+    raise ImageFetchFailure if options[:raise_on_failure]
+  rescue UnknownImageType
+    raise UnknownImageType if options[:raise_on_failure]
+  end
+
+  private
+
+  def fetch_using_http
+    setup_http
+    @http.request_get(@parsed_uri.request_uri) do |res|
+      raise ImageFetchFailure unless res.is_a?(Net::HTTPSuccess)
+      res.read_body do |str|
+        break if parse_packet(str)
+      end
+    end
+  end
+
+  def setup_http
+    @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
+    @http.use_ssl = (@parsed_uri.scheme == "https")
+    @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    @http.open_timeout = @timeout
+    @http.read_timeout = @timeout
+  end
+
+  def fetch_using_open_uri
+    open(@uri) do |s|
+      while str = s.read(LocalFileChunkSize)
+        break if parse_packet(str)
+      end
+    end
+  end
+
+  # returns true once result is achieved
+  #
+  def parse_packet(str)
+    @str = (@unused_str || "") + str
+    @strpos = 0
+    begin
+      result = send("parse_#{@property}")
+      if result 
+        instance_variable_set("@#{@property}", result)
+        true
+      end
+    rescue MoreCharsNeeded
+      false
+    end
+  end
+
+  def parse_size
+    @type = parse_type unless @type
+    @strpos = 0
+    send("parse_size_for_#{@type}")
+  end
+
+  def get_chars(n)
+    if @strpos + n - 1 >= @str.size
+      @unused_str = @str[@strpos..-1]
+      raise MoreCharsNeeded
+    else
+      result = @str[@strpos..(@strpos + n - 1)]
+      @strpos += n
+      result
+    end
+  end
+
+  def get_byte
+    get_chars(1).unpack("C")[0]
+  end
+
+  def read_int(str)
+    size_bytes = str.unpack("CC")
+    (size_bytes[0] << 8) + size_bytes[1]
+  end
+
+  def parse_type
+    case get_chars(2)
+    when "BM"
+      :bmp
+    when "GI"
+      :gif
+    when 0xff.chr + 0xd8.chr
+      :jpeg
+    when 0x89.chr + "P"
+      :png
+    else
+      raise UnknownImageType
+    end
+  end
+
+  def parse_size_for_gif
+    get_chars(11)[6..10].unpack('SS')
+  end
+
+  def parse_size_for_png
+    get_chars(25)[16..24].unpack('NN')
+  end
+
+  def parse_size_for_jpeg
+    loop do
+      @state = case @state
+      when nil
+        get_chars(2)
+        :started
+      when :started
+        get_byte == 0xFF ? :sof : :started          
+      when :sof
+        c = get_byte
+        if (0xe0..0xef).include?(c)
+          :skipframe
+        elsif [0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF].detect {|r| r.include? c}
+          :readsize
+        else
+          :skipframe
+        end
+      when :skipframe
+        @skip_chars = read_int(get_chars(2)) - 2
+        :do_skip
+      when :do_skip
+        get_chars(@skip_chars)
+        :started
+      when :readsize
+        s = get_chars(7)
+        return [read_int(s[5..6]), read_int(s[3..4])]
+      end
+    end
+  end
+
+  def parse_size_for_bmp
+    d = get_chars(29)[14..28]
+    d.unpack("C")[0] == 40 ? d[4..-1].unpack('LL') : d[4..8].unpack('SS')
+  end
+end

data/lib/middleman/features/automatic_image_sizes.rb

@@ -0,0 +1,33 @@
+module Middleman::Features::AutomaticImageSizes
+  class << self
+    def registered(app)
+      require "middleman/features/automatic_image_sizes/fastimage"
+
+      app.helpers Helpers
+    end
+    alias :included :registered
+  end
+  
+  module Helpers
+    def image_tag(path, params={})
+      if (!params[:width] || !params[:height]) && !path.include?("://")
+        params[:alt] ||= ""
+        http_prefix = settings.http_images_path rescue settings.images_dir
+
+        begin
+          real_path = File.join(settings.public, settings.images_dir, path)
+          if File.exists? real_path
+            dimensions = ::FastImage.size(real_path, :raise_on_failure => true)
+            params[:width]  ||= dimensions[0]
+            params[:height] ||= dimensions[1]
+          end
+        rescue
+        end
+
+        super(asset_url(path, http_prefix), params)
+      else
+        super(path, params)
+      end
+    end
+  end
+end

data/lib/middleman/features/cache_buster.rb

@@ -0,0 +1,44 @@
+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)
+
+        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
+          rescue
+          end
+
+          real_path_static  = File.join(Middleman::Server.public, 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)
+            http_path << "?" + File.mtime(real_path_dynamic).strftime("%s") if File.readable?(real_path_dynamic)
+          end
+
+          http_path
+        end
+      end
+
+      app.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::Server.root, Middleman::Server.build_dir), Middleman::Server.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
+    alias :included :registered
+  end
+end

data/lib/middleman/features/code_ray.rb

@@ -0,0 +1,12 @@
+module Middleman::Features::CodeRay
+  class << self
+    def registered(app)
+      begin
+        require 'haml-coderay'
+      rescue LoadError
+        puts "CodeRay not available. Install it with: gem install haml-coderay"
+      end
+    end
+    alias :included :registered
+  end
+end

data/lib/middleman/features/default_helpers.rb

@@ -0,0 +1,61 @@
+module Middleman::Features::DefaultHelpers
+  class << self
+    def registered(app)
+      app.helpers Middleman::Features::DefaultHelpers::Helpers
+    end
+    alias :included :registered
+  end
+  
+  module Helpers
+    def auto_stylesheet_link_tag(separator="/")
+      path = request.path_info.dup
+      path << self.class.index_file if path.match(%r{/$})
+      path = path.gsub(%r{^/}, '')
+      path = path.gsub(File.extname(path), '')
+      path = path.gsub("/", separator)
+
+      css_file = File.join(self.class.public, self.class.css_dir, "#{path}.css")
+      sass_file = File.join(self.class.views, self.class.css_dir, "#{path}.css.sass")
+      scss_file = File.join(self.class.views, self.class.css_dir, "#{path}.css.scss")
+      less_file = File.join(self.class.views, self.class.css_dir, "#{path}.css.less")
+    
+      if File.exists?(css_file) || File.exists?(sass_file) || File.exists?(scss_file) || File.exists?(less_file)
+        stylesheet_link_tag "#{path}.css"
+      end
+    end
+    
+    def page_classes
+      path = request.path_info.dup
+      path << settings.index_file if path.match(%r{/$})
+      path = path.gsub(%r{^/}, '')
+  
+      classes = []
+      parts = path.split('.')[0].split('/')
+      parts.each_with_index { |path, i| classes << parts.first(i+1).join('_') }
+      
+      classes.join(' ')
+    end
+    
+    def asset_url(path, prefix="")
+      Middleman::Assets.get_url(path, prefix, request)
+    end
+    
+    # Padrino's asset handling needs to pass through ours
+    def asset_path(kind, source)
+       return source if source =~ /^http/
+       asset_folder  = case kind
+         when :css    then settings.css_dir
+         when :js     then settings.js_dir
+         when :images then settings.images_dir
+         else kind.to_s
+       end
+       source = source.to_s.gsub(/\s/, '')
+       ignore_extension = (asset_folder.to_s == kind.to_s) # don't append extension
+       source << ".#{kind}" unless ignore_extension or source =~ /\.#{kind}/
+       result_path   = source if source =~ %r{^/} # absolute path
+       result_path ||= asset_url(source, asset_folder)
+       timestamp = asset_timestamp(result_path)
+       "#{result_path}#{timestamp}"
+     end
+  end
+end

data/lib/middleman/features/live_reload.rb

@@ -0,0 +1,21 @@
+module Middleman::Features::LiveReload
+  class << self
+    def registered(app)
+      return unless Middleman::Server.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 = ::Tilt.mappings.keys
+      end
+
+      # Middleman::Server.public
+      ::LiveReload.run [Middleman::Server.views], new_config
+    end
+    alias :included :registered
+  end
+end

data/lib/middleman/features/minify_css.rb

@@ -0,0 +1,10 @@
+module Middleman::Features::MinifyCss
+  class << self
+    def registered(app)
+      app.after_feature_init do
+        ::Compass.configuration.output_style = :compressed
+      end
+    end
+    alias :included :registered
+  end
+end

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/minify_javascript.rb

@@ -0,0 +1,21 @@
+module Middleman::Features::MinifyJavascript
+  class << self
+    def registered(app)
+      Middleman::Features::MinifyJavascript::Haml::Javascript.send :include, ::Haml::Filters::Base
+
+      require "middleman/features/minify_javascript/rack"
+      app.use Middleman::Rack::MinifyJavascript
+    end
+    alias :included :registered
+  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

data/lib/middleman/features/partials.rb

@@ -0,0 +1,15 @@
+def partial(template, *args)
+  options = args.last.is_a?(Hash) ? args.pop : { }
+  options.merge!(:layout => false)
+  if collection = options.delete(:collection) then
+      haml_concat(collection.inject([]) do |buffer, member|
+        buffer << haml(template, options.merge(
+                                :layout => false,
+                                :locals => {template.to_sym => member}
+                              )
+                   )
+    end.join("\n"))
+  else
+    haml_concat(haml(template, options))
+  end
+end