middleman 0.5.5 → 0.9.0.pre

data/lib/middleman/config.ru

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

data/lib/middleman/features.rb

@@ -0,0 +1,39 @@
+module Middleman
+  module Features
+    # Top-level method to register a new feature
+    @@features = {}
+    def self.register(feature_name, feature_class=nil, options={})
+      @@features[feature_name] = feature_class
+    
+      # Default to disabled, unless the class asks to auto-enable
+      activate_method = (options.has_key?(:auto_enable) && options[:auto_enable]) ? :enable : :disable
+      Middleman::Base.send(activate_method, feature_name)
+    end
+    
+    def self.run(feature_name, scope)
+      feature_class = @@features[feature_name]
+      feature_class.new(scope) unless feature_class.nil?
+    end
+
+    def self.all
+      @@features
+    end
+
+  end
+end
+
+# livereload
+%w(asset_host 
+   automatic_image_sizes
+   cache_buster
+   default_helpers
+   minify_css
+   minify_javascript
+   relative_assets
+   slickmap
+   smush_pngs
+   ugly_haml).each do |feature| 
+     
+  require File.join("middleman/features", feature)
+
+end

data/lib/middleman/features/asset_host.rb

@@ -0,0 +1,21 @@
+class Middleman::Features::AssetHost
+  def initialize(app)
+    Middleman::Base.after_feature_init do
+      if Middleman::Base.asset_host.is_a?(Proc)
+        ::Compass.configuration.asset_host(&Middleman::Base.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::Base.asset_host.call(original_output)
+
+      File.join(asset_prefix, original_output)
+    end
+  end
+end
+
+Middleman::Features.register :asset_host, Middleman::Features::AssetHost

data/lib/middleman/features/automatic_image_sizes.rb

@@ -0,0 +1,31 @@
+class Middleman::Features::AutomaticImageSizes
+  def initialize(app)
+    require "middleman/features/automatic_image_sizes/fastimage"
+
+    Middleman::Base.send :alias_method, :pre_automatic_image_tag, :image_tag
+    Middleman::Base.helpers do
+      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 = Middleman::FastImage.size(real_path, :raise_on_failure => true)
+              params[:width]  ||= dimensions[0]
+              params[:height] ||= dimensions[1]
+            end
+          rescue
+          end
+
+          capture_haml { haml_tag(:img, params.merge(:src => asset_url(path, http_prefix))) }
+        else
+          pre_automatic_image_tag(path, params)
+        end
+      end
+    end
+  end
+end
+
+Middleman::Features.register :automatic_image_sizes, Middleman::Features::AutomaticImageSizes

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

@@ -0,0 +1,282 @@
+# 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'
+
+module Middleman
+  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
+      @parsed_uri = URI.parse(uri.gsub(/\s/, "%20"))
+      if @parsed_uri.scheme == "http" || @parsed_uri.scheme == "https"
+        fetch_using_http
+      else
+        fetch_using_open_uri
+      end
+      raise SizeNotFound if options[:raise_on_failure] && @property == :size && !@size
+    rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET, ImageFetchFailure
+      raise ImageFetchFailure if options[:raise_on_failure]
+    rescue Errno::ENOENT
+      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
+      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(9)[4..8].unpack('SS')
+    end
+
+    def parse_size_for_png
+      get_chars(23)[14..22].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(27)[12..26]
+      d[0] == 40 ? d[4..-1].unpack('LL') : d[4..8].unpack('SS')
+    end
+  end
+end

data/lib/middleman/features/cache_buster.rb

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

data/lib/middleman/features/default_helpers.rb

@@ -0,0 +1,68 @@
+class Middleman::Features::DefaultHelpers
+  def initialize(app)
+    Middleman::Base.helpers Helpers
+  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")
+    
+      if File.exists?(css_file) || File.exists?(sass_file) || File.exists?(scss_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
+    
+    def link_to(title, url="#", params={})
+      params.merge!(:href => url)
+      params = params.map { |k,v| %Q{#{k}="#{v}"}}.join(' ')
+      %Q{<a #{params}>#{title}</a>}
+    end
+
+    def image_tag(path, params={})
+      params[:alt] ||= ""
+      prefix = settings.http_images_path rescue settings.images_dir
+      params = params.merge(:src => asset_url(path, prefix))
+      params = params.map { |k,v| %Q{#{k}="#{v}"}}.join(' ')
+      "<img #{params} />"
+    end
+
+    def javascript_include_tag(path, params={})
+      params = params.merge(:src => asset_url(path, settings.js_dir), :type => "text/javascript")
+      params = params.map { |k,v| %Q{#{k}="#{v}"}}.join(' ')
+      "<script #{params}></script>"
+    end
+
+    def stylesheet_link_tag(path, params={})
+      params[:rel] ||= "stylesheet"
+      params = params.merge(:href => asset_url(path, settings.css_dir), :type => "text/css")
+      params = params.map { |k,v| %Q{#{k}="#{v}"}}.join(' ')
+      "<link #{params} />"
+    end
+  end
+end
+
+Middleman::Features.register :default_helpers, Middleman::Features::DefaultHelpers, { :auto_enable => true }