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

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

@@ -1,92 +1,82 @@
 # Extensions namespace
-module Middleman::Extensions
+module Middleman
+  module Extensions
   
-  # Minify CSS Extension 
-  module MinifyCss
+    # Minify CSS Extension 
+    module MinifyCss
     
-    # Setup extension
-    class << self
+      # Setup extension
+      class << self
       
-      # Once registered
-      def registered(app)
-        app.set :css_compressor, false
+        # Once registered
+        def registered(app, options={})
+          app.set :css_compressor, false
 
-        app.after_configuration do
-          unless respond_to?(:css_compressor) && css_compressor
-            require "middleman-more/extensions/minify_css/rainpress"
-            set :css_compressor, ::Rainpress
-          end
+          ignore = Array(options[:ignore]) << /\.min\./
+          inline = options[:inline] || false
+
+          app.after_configuration do
+            chosen_compressor = css_compressor || options[:compressor] || begin
+              require "middleman-more/extensions/minify_css/rainpress"
+              ::Rainpress
+            end
 
-          # Setup Rack to watch for inline JS
-          use InlineCSSRack, :compressor => css_compressor
+            # Setup Rack middleware to minify CSS
+            use Rack, :compressor => chosen_compressor,
+                      :ignore     => ignore,
+                      :inline     => inline
+          end
         end
+        alias :included :registered
       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)
+    
+      # Rack middleware to look for CSS and compress it
+      class Rack
 
-      path = env["PATH_INFO"]
+        # Init
+        # @param [Class] app
+        # @param [Hash] options
+        def initialize(app, options={})
+          @app = app
+          @compressor = options[:compressor]
+          @ignore = options[:ignore]
+          @inline = options[:inline]
+        end
 
-      if path.end_with?('.html') || path.end_with?('.php')
-        uncompressed_source = extract_response_text(response)
+        # Rack interface
+        # @param [Rack::Environmemt] env
+        # @return [Array]
+        def call(env)
+          status, headers, response = @app.call(env)
 
-        minified = uncompressed_source.gsub(/(<style[^>]*>\s*(?:\/\*<!\[CDATA\[\*\/\n)?)(.*?)((?:(?:\n\s*)?\/\*\]\]>\*\/)?\s*<\/style>)/m) do |match|
-          first = $1
-          css = $2
-          last = $3
+          path = env["PATH_INFO"]
 
-          minified_css = @compressor.compress(css)
+          if (path.end_with?('.html') || path.end_with?('.php')) && @inline
+            uncompressed_source = ::Middleman::Util.extract_response_text(response)
 
-          first << minified_css << last
-        end
+            minified = uncompressed_source.gsub(/(<style[^>]*>\s*(?:\/\*<!\[CDATA\[\*\/\n)?)(.*?)((?:(?:\n\s*)?\/\*\]\]>\*\/)?\s*<\/style>)/m) do |match|
+              first = $1
+              css = $2
+              last = $3
 
-        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)
+              minified_css = @compressor.compress(css)
 
-        headers["Content-Length"] = ::Rack::Utils.bytesize(minified_css).to_s
-        response = [minified_css]
-      end
+              first << minified_css << last
+            end
 
-      [status, headers, response]
-    end
+            headers["Content-Length"] = ::Rack::Utils.bytesize(minified).to_s
+            response = [minified]
+          elsif path.end_with?('.css') && @ignore.none? {|ignore| path =~ ignore }
+            uncompressed_source = ::Middleman::Util.extract_response_text(response)
+            minified_css = @compressor.compress(uncompressed_source)
 
-    private
+            headers["Content-Length"] = ::Rack::Utils.bytesize(minified_css).to_s
+            response = [minified_css]
+          end
 
-    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
+          [status, headers, response]
+        end
       end
     end
   end
-  # Register extension
-  # register :minify_css, MinifyCss
 end

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

@@ -1,101 +1,94 @@
 # Extension namespace
-module Middleman::Extensions
+module Middleman
+  module Extensions
   
-  # Minify Javascript Extension
-  module MinifyJavascript
+    # Minify Javascript Extension
+    module MinifyJavascript
     
-    # Setup extension
-    class << self
+      # Setup extension
+      class << self
       
-      # Once registered
-      def registered(app)
-        app.set :js_compressor, false
+        # Once registered
+        def registered(app, options={})
+          app.set :js_compressor, false
 
-        # Once config is parsed
-        app.after_configuration do
-          unless respond_to?(:js_compressor) && js_compressor
-            require 'uglifier'
-            set :js_compressor, ::Uglifier.new
-          end
+          ignore = Array(options[:ignore]) << /\.min\./
+          inline = options[:inline] || false
+
+          # Once config is parsed
+          app.after_configuration do
+            chosen_compressor = js_compressor || options[:compressor] || begin
+              require 'uglifier'
+              ::Uglifier.new
+            end
           
-          # Setup Rack to watch for inline JS
-          use InlineJavascriptRack, :compressor => js_compressor
+            # Setup Rack middlware to minify JS
+            use Rack, :compressor => chosen_compressor, 
+                      :ignore     => ignore,
+                      :inline     => inline
+          end
         end
+        alias :included :registered
       end
-      alias :included :registered
-    end
 
-    # Rack middleware to look for JS in HTML and compress it
-    class InlineJavascriptRack
+      # Rack middleware to look for JS and compress it
+      class Rack
       
-      # 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"]
+        # Init
+        # @param [Class] app
+        # @param [Hash] options
+        def initialize(app, options={})
+          @app = app
+          @compressor = options[:compressor]
+          @ignore = options[:ignore]
+          @inline = options[:inline]
+        end
 
-        if path.end_with?('.html') || path.end_with?('.php')
-          uncompressed_source = extract_response_text(response)
+        # Rack interface
+        # @param [Rack::Environmemt] env
+        # @return [Array]
+        def call(env)
+          status, headers, response = @app.call(env)
 
-          minified = uncompressed_source.gsub(/(<script[^>]*>\s*(?:\/\/(?:(?:<!--)|(?:<!\[CDATA\[))\n)?)(.*?)((?:(?:\n\s*)?\/\/(?:(?:-->)|(?:\]\]>)))?\s*<\/script>)/m) do |match|
-            first = $1
-            javascript = $2
-            last = $3
+          path = env["PATH_INFO"]
 
-            # Only compress script tags that contain JavaScript (as opposed
-            # to something like jQuery templates, identified with a "text/html"
-            # type.
-            if first =~ /<script>/ || first.include?('text/javascript')
-              minified_js = @compressor.compress(javascript)
+          begin
+            if (path.end_with?('.html') || path.end_with?('.php')) && @inline
+              uncompressed_source = ::Middleman::Util.extract_response_text(response)
 
-              first << minified_js << last
-            else
-              match
-            end
-          end
+              minified = uncompressed_source.gsub(/(<script[^>]*>\s*(?:\/\/(?:(?:<!--)|(?:<!\[CDATA\[))\n)?)(.*?)((?:(?:\n\s*)?\/\/(?:(?:-->)|(?:\]\]>)))?\s*<\/script>)/m) do |match|
+                first = $1
+                javascript = $2
+                last = $3
 
-          headers["Content-Length"] = ::Rack::Utils.bytesize(minified).to_s
-          response = [minified]
-        elsif path.end_with?('.js') && path !~ /\.min\./
-          uncompressed_source = extract_response_text(response)
-          minified_js = @compressor.compress(uncompressed_source)
+                # Only compress script tags that contain JavaScript (as opposed
+                # to something like jQuery templates, identified with a "text/html"
+                # type.
+                if first =~ /<script>/ || first.include?('text/javascript')
+                  minified_js = @compressor.compress(javascript)
 
-          headers["Content-Length"] = ::Rack::Utils.bytesize(minified_js).to_s
-          response = [minified_js]
-        end
+                  first << minified_js << last
+                else
+                  match
+                end
+              end
 
-        [status, headers, response]
-      end
+              headers["Content-Length"] = ::Rack::Utils.bytesize(minified).to_s
+              response = [minified]
+            elsif path.end_with?('.js') && @ignore.none? {|ignore| path =~ ignore }
+              uncompressed_source = ::Middleman::Util.extract_response_text(response)
+              minified_js = @compressor.compress(uncompressed_source)
 
-      private
+              headers["Content-Length"] = ::Rack::Utils.bytesize(minified_js).to_s
+              response = [minified_js]
+            end
+          rescue ExecJS::ProgramError => e
+            warn "WARNING: Couldn't compress JavaScript in #{path}: #{e.message}"
+          end 
 
-      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
+          [status, headers, response]
         end
       end
     end
   end
-  
-  # Register extension
-  # register :minify_javascript, MinifyJavascript
 end

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

@@ -1,63 +1,63 @@
 # Extension namespace
-module Middleman::Extensions
+module Middleman
+  module Extensions
   
-  # Relative Assets extension
-  module RelativeAssets
+    # Relative Assets extension
+    module RelativeAssets
     
-    # Setup extension
-    class << self
+      # Setup extension
+      class << self
       
-      # Once registered
-      def registered(app)
-        # Tell compass to use relative assets
-        app.compass_config do |config|
-          config.relative_assets = true
+        # Once registered
+        def registered(app)
+          # Tell compass to use relative assets
+          app.compass_config do |config|
+            config.relative_assets = true
+          end
+      
+          # Include instance methods
+          app.send :include, InstanceMethods
         end
       
-        # Include instance methods
-        app.send :include, InstanceMethods
+        alias :included :registered
       end
-      
-      alias :included :registered
-    end
   
-    # Relative Assets instance method
-    module InstanceMethods
+      # Relative Assets instance method
+      module InstanceMethods
       
-      # asset_url override for relative assets
-      # @param [String] path
-      # @param [String] prefix
-      # @return [String]
-      def asset_url(path, prefix="")
-        begin
-          prefix = images_dir if prefix == http_images_path
-        rescue
-        end
-
-        if path.include?("://")
-          super(path, prefix)
-        elsif path[0,1] == "/"
-          path
-        else
-          path = File.join(prefix, path) if prefix.length > 0
-          request_path = @request_path.dup
-          request_path << index_file if path.match(%r{/$})
-          request_path.gsub!(%r{^/}, '')
-          parts = request_path.split('/')
+        # asset_url override for relative assets
+        # @param [String] path
+        # @param [String] prefix
+        # @return [String]
+        def asset_url(path, prefix="")
+          begin
+            prefix = images_dir if prefix == http_images_path
+          rescue
+          end
 
-          if parts.length > 1
-            arry = []
-            (parts.length - 1).times { arry << ".." }
-            arry << path
-            File.join(*arry)
-          else
+          if path.include?("://")
+            super(path, prefix)
+          elsif path[0,1] == "/"
             path
+          else
+            path = File.join(prefix, path) if prefix.length > 0
+            
+            request_path = current_path.dup
+            request_path << index_file if path.match(%r{/$})
+
+            parts = request_path.gsub(%r{^/}, '').split('/')
+
+            if parts.length > 1
+              arry = []
+              (parts.length - 1).times { arry << ".." }
+              arry << path
+              File.join(*arry)
+            else
+              path
+            end
           end
         end
       end
     end
   end
-  
-  # Register extension
-  # register :relative_assets, RelativeAssets
-end
+end

data/lib/middleman-more/register_extensions.rb

@@ -0,0 +1,82 @@
+### 
+# Setup renderers
+###
+
+# CoffeeScript Support
+require "middleman-more/renderers/coffee_script"
+Middleman::Application.register Middleman::Renderers::CoffeeScript
+
+# Haml Support
+require "middleman-more/renderers/haml"
+Middleman::Application.register Middleman::Renderers::Haml
+
+# Sass Support
+require "middleman-more/renderers/sass"
+Middleman::Application.register Middleman::Renderers::Sass
+
+# Markdown Support
+require "middleman-more/renderers/markdown"
+Middleman::Application.register Middleman::Renderers::Markdown
+
+# Liquid Support
+require "middleman-more/renderers/liquid"
+Middleman::Application.register Middleman::Renderers::Liquid
+
+# Slim Support
+require "middleman-more/renderers/slim"
+Middleman::Application.register Middleman::Renderers::Slim
+
+### 
+# Setup Core Extensions
+###
+
+# Compass framework
+require "middleman-more/core_extensions/compass"
+Middleman::Application.register Middleman::CoreExtensions::Compass
+
+# Sprockets asset handling
+require "middleman-more/core_extensions/sprockets"
+Middleman::Application.register Middleman::CoreExtensions::Sprockets
+
+### 
+# Setup Optional Extensions
+###
+
+# CacheBuster adds a query string to assets in dynamic templates to avoid
+# browser caches failing to update to your new content.
+Middleman::Extensions.register(:cache_buster) do
+  require "middleman-more/extensions/cache_buster"
+  Middleman::Extensions::CacheBuster 
+end
+
+# MinifyCss compresses CSS
+Middleman::Extensions.register(:minify_css) do
+  require "middleman-more/extensions/minify_css"
+  Middleman::Extensions::MinifyCss 
+end
+
+# MinifyJavascript compresses JS
+Middleman::Extensions.register(:minify_javascript) do
+  require "middleman-more/extensions/minify_javascript"
+  Middleman::Extensions::MinifyJavascript 
+end
+  
+# RelativeAssets allow any asset path in dynamic templates to be either
+# relative to the root of the project or use an absolute URL.
+Middleman::Extensions.register(:relative_assets) do
+  require "middleman-more/extensions/relative_assets"
+  Middleman::Extensions::RelativeAssets 
+end
+
+# GZIP assets and pages during build
+Middleman::Extensions.register(:gzip) do
+  require "middleman-more/extensions/gzip"
+  Middleman::Extensions::Gzip 
+end
+  
+# AssetHash appends a hash of the file contents to the assets filename
+# to avoid browser caches failing to update to your new content.
+Middleman::Extensions.register(:asset_hash) do
+  require "middleman-more/extensions/asset_hash"
+  Middleman::Extensions::AssetHash 
+end