middleman-more 3.0.0.beta.1 → 3.0.0.beta.2

data/lib/middleman-more/extensions/asset_hash.rb

@@ -0,0 +1,132 @@
+require 'digest/sha1'
+module Middleman::Extensions
+  module AssetHash
+    class << self
+      def registered(app, options)
+        exts = options[:exts] || %w(.ico .manifest .jpg .jpeg .png .gif .js .css)
+
+        app.ready do
+          sitemap.register_resource_list_manipulator(
+            :asset_hash, 
+            AssetHashManager.new(self, exts)
+          )
+
+          use Middleware, :exts => exts, :middleman_app => self
+        end
+      end
+      alias :included :registered
+    end
+
+    class AssetHashManager
+      def initialize(app, exts)
+        @app = app
+        @exts = exts
+      end
+      
+      # Update the main sitemap resource list
+      # @return [void]
+      def manipulate_resource_list(resources)
+        resources.each do |resource|
+          if @exts.include? resource.ext
+            # figure out the path Sprockets would use for this asset
+            if resource.ext == '.js'
+              sprockets_path = resource.path.sub(@app.js_dir,'').sub(/^\//,'')
+            elsif resource.ext == '.css'
+              sprockets_path = resource.path.sub(@app.css_dir,'').sub(/^\//,'')
+            end
+
+            # See if Sprockets knows about the file
+            asset = @app.sprockets.find_asset(sprockets_path) if sprockets_path
+
+            if asset # if it's a Sprockets asset, ask sprockets for its digest
+              digest = asset.digest[0..7]
+            elsif resource.template? # if it's a template, render it out
+              digest = Digest::SHA1.hexdigest(resource.render)[0..7]
+            else # if it's a static file, just hash it
+              digest = Digest::SHA1.file(resource.source_file).hexdigest[0..7]
+            end
+
+            resource.destination_path = resource.destination_path.sub(/\.(\w+)$/) { |ext| "-#{digest}#{ext}" }
+          end
+        end
+      end
+    end
+
+    # The asset hash middleware is responsible for rewriting references to
+    # assets to include their new, hashed name.
+    class Middleware
+      def initialize(app, options={})
+        @rack_app      = app
+        @exts           = options[:exts]
+        @exts_regex_text = @exts.map {|e| Regexp.escape(e) }.join('|')
+        @middleman_app = options[:middleman_app]
+      end
+
+      def call(env)
+        status, headers, response = @rack_app.call(env)
+
+        path = @middleman_app.full_path(env["PATH_INFO"])
+        dirpath = Pathname.new(File.dirname(path))
+
+        if path =~ /(^\/$)|(\.(htm|html|php|css|js)$)/
+          body = extract_response_text(response)
+
+          if body
+            # TODO: This regex will change some paths in plan HTML (not in a tag) - is that OK?
+            body.gsub! /([=\'\"\(]\s*)([^\s\'\"\)]+(#{@exts_regex_text}))/ do |match|
+              asset_path = $2
+              relative_path = Pathname.new(asset_path).relative?
+
+              asset_path = dirpath.join(asset_path).to_s if relative_path
+
+              if asset_page = @middleman_app.sitemap.find_resource_by_path(asset_path)
+                replacement_path = "/#{asset_page.destination_path}"
+                replacement_path = Pathname.new(replacement_path).relative_path_from(dirpath).to_s if relative_path
+
+                "#{$1}#{replacement_path}"
+              else
+                match
+              end
+            end
+
+            status, headers, response = Rack::Response.new(body, status, headers).finish
+          end
+        end
+        [status, headers, response]
+      end
+
+      private
+
+      def extract_response_text(response)
+        case(response)
+        when String
+          response
+        when Array
+          response.join
+        when Rack::Response
+          response.body.join
+        when Rack::File
+          File.read(response.path)
+        else
+          response.to_s
+        end
+      end
+    end
+  end
+  
+  register :asset_hash, AssetHash
+end
+
+
+# =================Temp Generate Test data==============================
+#   ["jpg", "png", "gif"].each do |ext|
+#     [["<p>", "</p>"], ["<p><img src=", " /></p>"], ["<p>background-image:url(", ");</p>"]].each do |outer|
+#       [["",""], ["'", "'"], ['"','"']].each do |inner|
+#         [["", ""], ["/", ""], ["../", ""], ["../../", ""], ["../../../", ""], ["http://example.com/", ""], ["a","a"], ["1","1"], [".", "."], ["-","-"], ["_","_"]].each do |path_parts|
+#           name = 'images/100px.'
+#           puts outer[0] + inner[0] + path_parts[0] + name + ext + path_parts[1] + inner[1] + outer[1]
+#         end
+#       end
+#     end
+#     puts "<br /><br /><br />"
+#   end

data/lib/middleman-more/extensions/cache_buster.rb

@@ -51,10 +51,9 @@ module Middleman::Extensions
             real_path_dynamic = File.join(build_dir, prefix, path)
             real_path_dynamic = File.expand_path(real_path_dynamic, root)
             http_path << "?" + File.mtime(real_path_dynamic).strftime("%s") if File.readable?(real_path_dynamic)
-          elsif sitemap.exists?(real_path_static)
-            page = sitemap.page(real_path_static)
-            if !page.template?
-              http_path << "?" + File.mtime(result[0]).strftime("%s")
+          elsif resource = sitemap.find_resource_by_path(real_path_static)
+            if !resource.template?
+              http_path << "?" + File.mtime(resource.source_file).strftime("%s")
             else
               # It's a template, possible with partials. We can't really know when
               # it's updated, so generate fresh cache buster every time durin
@@ -70,5 +69,5 @@ module Middleman::Extensions
   end
   
   # Register the extension
-  register :cache_buster, CacheBuster
-end
+  # register :cache_buster, CacheBuster
+end

data/lib/middleman-more/extensions/gzip.rb

@@ -0,0 +1,57 @@
+require 'zlib'
+require 'stringio'
+require 'find'
+
+module Middleman::Extensions
+  
+  # This extension Gzips assets and pages when building. 
+  # Gzipped assets and pages can be served directly by Apache or
+  # Nginx with the proper configuration, and pre-zipping means that we
+  # can use a more agressive compression level at no CPU cost per request.
+  #
+  # Use Nginx's gzip_static directive, or AddEncoding and mod_rewrite in Apache
+  # to serve your Gzipped files whenever the normal (non-.gz) filename is requested.
+  #
+  # Pass the :exts options to customize which file extensions get zipped (defaults
+  # to .html, .htm, .js and .css.
+  #
+  module Gzip
+    class << self
+      def registered(app, options={})
+        exts = options[:exts] || %w(.js .css .html .htm)
+        
+        app.send :include, InstanceMethods
+
+        app.after_build do |builder|
+          Find.find(self.class.inst.build_dir) do |path|
+            next if File.directory? path
+            if exts.include? File.extname(path)
+              new_size = gzip_file(path, builder)
+            end
+          end
+        end
+      end
+        
+      alias :included :registered
+    end
+
+    module InstanceMethods
+      def gzip_file(path, builder)
+        input_file = File.open(path, 'r').read
+        output_filename = path + '.gz'
+        File.open(output_filename, 'w') do |f|
+          gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
+          gz.write input_file
+          gz.close
+        end
+
+        old_size = File.size(path)
+        new_size = File.size(output_filename)
+
+        size_change_word = (old_size - new_size) > 0 ? 'smaller' : 'larger'
+
+        builder.say_status :gzip, "#{output_filename} (#{number_to_human_size((old_size - new_size).abs)} #{size_change_word})"
+      end
+    end
+  end
+end

data/lib/middleman-more/extensions/minify_css.rb

@@ -9,18 +9,84 @@ module Middleman::Extensions
       
       # Once registered
       def registered(app)
-        # Tell Sprockets to use the built in CSSMin
+        app.set :css_compressor, false
+
         app.after_configuration do
-          if !css_compressor
-            require "middleman-more/extensions/minify_css/cssmin"
-            set :css_compressor, ::CSSMin
+          unless respond_to?(:css_compressor) && css_compressor
+            require "middleman-more/extensions/minify_css/rainpress"
+            set :css_compressor, ::Rainpress
           end
+
+          # Setup Rack to watch for inline JS
+          use InlineCSSRack, :compressor => css_compressor
         end
       end
       alias :included :registered
     end
   end
-  
+
+  # Rack middleware to look for JS in HTML and compress it
+  class InlineCSSRack
+      
+    # Init
+    # @param [Class] app
+    # @param [Hash] options
+    def initialize(app, options={})
+      @app = app
+      @compressor = options[:compressor]
+    end
+
+    # Rack interface
+    # @param [Rack::Environmemt] env
+    # @return [Array]
+    def call(env)
+      status, headers, response = @app.call(env)
+
+      path = env["PATH_INFO"]
+
+      if path.end_with?('.html') || path.end_with?('.php')
+        uncompressed_source = extract_response_text(response)
+
+        minified = uncompressed_source.gsub(/(<style[^>]*>\s*(?:\/\*<!\[CDATA\[\*\/\n)?)(.*?)((?:(?:\n\s*)?\/\*\]\]>\*\/)?\s*<\/style>)/m) do |match|
+          first = $1
+          css = $2
+          last = $3
+
+          minified_css = @compressor.compress(css)
+
+          first << minified_css << last
+        end
+
+        headers["Content-Length"] = ::Rack::Utils.bytesize(minified).to_s
+        response = [minified]
+      elsif path.end_with?('.css') && path !~ /\.min\./
+        uncompressed_source = extract_response_text(response)
+        minified_css = @compressor.compress(uncompressed_source)
+
+        headers["Content-Length"] = ::Rack::Utils.bytesize(minified_css).to_s
+        response = [minified_css]
+      end
+
+      [status, headers, response]
+    end
+
+    private
+
+    def extract_response_text(response)
+      case(response)
+      when String
+        response
+      when Array
+        response.join
+      when Rack::Response
+        response.body.join
+      when Rack::File
+        File.read(response.path)
+      else
+        response.to_s
+      end
+    end
+  end
   # Register extension
-  register :minify_css, MinifyCss
-end
+  # register :minify_css, MinifyCss
+end

data/lib/middleman-more/extensions/minify_css/rainpress.rb

@@ -0,0 +1,168 @@
+# == Information
+#
+# This is the main class of Rainpress, create an instance of it to compress
+# your CSS-styles.
+#
+# Author:: Uwe L. Korn <uwelk@xhochy.org>
+#
+# <b>Options:</b>
+#
+# * <tt>:comments</tt> - if set to false, comments will not be removed
+# * <tt>:newlines</tt> - if set to false, newlines will not be removed
+# * <tt>:spaces</tt> - if set to false, spaces will not be removed
+# * <tt>:colors</tt> - if set to false, colors will not be modified
+# * <tt>:misc</tt> - if set to false, miscellaneous compression parts will be skipped
+class Rainpress
+  # Quick-compress the styles.
+  # This eliminates the need to create an instance of the class
+  def self.compress(style, options = {})
+    self.new(style, options).compress!
+  end
+
+  def initialize(style, opts = {})
+    @style = style
+    @opts = {
+      :comments => true,
+      :newlines => true,
+      :spaces   => true,
+      :colors   => true,
+      :misc     => true
+    }
+    @opts.merge! opts
+  end
+
+  # Run the compressions and return the newly compressed text
+  def compress!
+    remove_comments!  if @opts[:comments]
+    remove_newlines!  if @opts[:newlines]
+    remove_spaces!    if @opts[:spaces]
+    shorten_colors!   if @opts[:colors]
+    do_misc!          if @opts[:misc]
+    @style
+  end
+
+  # Remove all comments out of the CSS-Document
+  #
+  # Only /* text */ comments are supported.
+  # Attention: If you are doing css hacks for IE using the comment tricks,
+  # they will be removed using this function. Please consider for IE css style
+  # corrections the usage of conditionals comments in your (X)HTML document.
+	def remove_comments!
+    input = @style
+    @style = ''
+
+    while input.length > 0 do
+      pos = input.index("/*");
+
+      # No more comments
+      if pos == nil
+        @style += input
+        input = '';
+      else # Comment beginning at pos
+        @style += input[0..(pos-1)] if pos > 0 # only append text if there is some
+        input = input[(pos+2)..-1]
+        # Comment ending at pos
+        pos = input.index("*/")
+        input = input[(pos+2)..-1]
+      end
+    end
+	end
+
+  # Remove all newline characters
+  #
+  # We take care of Windows(\r\n), Unix(\n) and Mac(\r) newlines.
+	def remove_newlines!
+		@style.gsub! /\n|\r/, ''
+	end
+
+	# Remove unneeded spaces
+	#
+  # 1. Turn mutiple spaces into a single
+  # 2. Remove spaces around ;:{},
+  # 3. Remove tabs
+  def remove_spaces!
+    @style.gsub! /\s*(\s|;|:|\}|\{|,)\s*/, '\1'
+    @style.gsub! "\t", ''
+	end
+
+	# Replace color values with their shorter equivalent
+	#
+	# 1. Turn rgb(,,)-colors into #-values
+	# 2. Shorten #AABBCC down to #ABC
+	# 3. Replace names with their shorter hex-equivalent
+	#    * white -> #fff
+ 	#    * black -> #000
+	# 4. Replace #-values with their shorter name
+	#    * #f00 -> red
+	def shorten_colors!
+	  # rgb(50,101,152) to #326598
+    @style.gsub! /rgb\s*\(\s*([0-9,\s]+)\s*\)/ do |match|
+      out = '#'
+      $1.split(',').each do |num|
+        out += '0' if num.to_i < 16
+        out += num.to_i.to_s(16) # convert to hex
+      end
+      out
+    end
+    # Convert #AABBCC to #ABC, keep if preceed by a '='
+    @style.gsub! /([^\"'=\s])(\s*)#([\da-f])\3([\da-f])\4([\da-f])\5/i, '\1#\3\4\5'
+
+    # At the moment we assume that colours only appear before ';' or '}' and
+    # after a ':', if there could be an occurence of a color before or after
+    # an other character, submit either a bug report or, better, a patch that
+    # enables Rainpress to take care of this.
+
+    # shorten several names to numbers
+    ## shorten white -> #fff
+    @style.gsub! /:\s*white\s*(;|\})/, ':#fff\1'
+
+    ## shorten black -> #000
+    @style.gsub! /:\s*black\s*(;|\})/, ':#000\1'
+
+    # shotern several numbers to names
+    ## shorten #f00 or #ff0000 -> red
+    @style.gsub! /:\s*#f{1,2}0{2,4}(;|\})/i, ':red\1'
+  end
+
+  # Do miscellaneous compression methods on the style.
+  def do_misc!
+    # Replace 0(pt,px,em,%) with 0 but only when preceded by : or a white-space
+    @style.gsub! /([\s:]+)(0)(px|em|%|in|cm|mm|pc|pt|ex)/i, '\1\2'
+
+    # Replace :0 0 0 0(;|}) with :0(;|})
+    @style.gsub! /:0 0 0 0(;|\})/, ':0\1'
+
+    # Replace :0 0 0(;|}) with :0(;|})
+    @style.gsub! /:0 0 0(;|\})/, ':0\1'
+
+    # Replace :0 0(;|}) with :0(;|})
+    @style.gsub! /:0 0(;|\})/, ':0\1'
+
+    # Replace background-position:0; with background-position:0 0;
+    @style.gsub! 'background-position:0;', 'background-position:0 0;'
+
+    # Replace 0.6 to .6, but only when preceded by : or a white-space
+    @style.gsub! /[:\s]0+\.(\d+)/ do |match|
+      match.sub '0', '' # only first '0' !!
+    end
+
+    # Replace multiple ';' with a single ';'
+    @style.gsub! /[;]+/, ';'
+
+    # Replace ;} with }
+    @style.gsub! ';}', '}'
+
+    # Replace font-weight:normal; with 400
+    @style.gsub! /font-weight[\s]*:[\s]*normal[\s]*(;|\})/i,'font-weight:400\1'
+    @style.gsub! /font[\s]*:[\s]*normal[\s;\}]*/ do |match|
+      match.sub 'normal', '400'
+    end
+
+    # Replace font-weight:bold; with 700
+    @style.gsub! /font-weight[\s]*:[\s]*bold[\s]*(;|\})/,'font-weight:700\1'
+    @style.gsub! /font[\s]*:[\s]*bold[\s;\}]*/ do |match|
+      match.sub 'bold', '700'
+    end
+  end
+
+end