middleman 2.0.16.1 → 3.0.0.alpha.2

data/lib/middleman/core_extensions/sitemap.rb

@@ -0,0 +1,229 @@
+require 'find'
+
+module Middleman::CoreExtensions::Sitemap
+  class << self
+    def registered(app)
+      app.send :include, InstanceMethods
+    end
+    alias :included :registered
+  end
+  
+  module InstanceMethods
+    def initialize
+      file_changed do |file|
+        sitemap.touch_file(file)
+      end
+    
+      file_deleted do |file|
+        sitemap.remove_file(file)
+      end
+      
+      super
+    end
+    
+    def sitemap
+      @sitemap ||= SitemapStore.new(self)
+    end
+    
+    # Keep a path from building
+    def ignore(path)
+      sitemap.ignore_path(path)
+    end
+    
+    def reroute(url, target)
+      sitemap.set_path(url, target)
+    end
+    
+    def provides_metadata(matcher=nil, &block)
+      @_provides_metadata ||= []
+      @_provides_metadata << [block, matcher] if block_given?
+      @_provides_metadata
+    end
+  end
+  
+  class SitemapStore
+    def initialize(app)
+      @app = app
+      @source = File.expand_path(@app.views, @app.root)
+      @map = {}
+      @context_map = {}
+      @source_map = {}
+      @ignored_paths = false
+      @generic_paths = false
+      @proxied_paths = false
+      
+      # build_static_map
+    end
+    
+    # Check to see if we know about a specific path
+    def path_exists?(path)
+      path = path.sub(/^\//, "")
+      @map.has_key?(path)
+    end
+    
+    def path_is_proxy?(path)
+      path = path.sub(/^\//, "")
+      return false if !path_exists?(path)
+      @map[path].is_a?(String)
+    end
+    
+    def path_target(path)
+      path = path.sub(/^\//, "")
+      @map[path]
+    end
+    
+    def path_context(path)
+      path = path.sub(/^\//, "")
+      @context_map[path]
+    end
+    
+    def set_path(path, target=true)
+      path   = path.sub(/^\//, "")
+      target = target.sub(/^\//, "") if target.is_a?(String)
+      
+      @map[path] = target
+      
+      @ignored_paths = false if target === false
+      @generic_paths = false if target === true
+      @proxied_paths = false if target.is_a?(String)
+    end
+    
+    def set_context(path, options={}, block=nil)
+      path = path.sub(/^\//, "")
+      @context_map[path] = {
+        :options => options,
+        :block   => block
+      }
+    end
+    
+    def get_context(path)
+      path = path.sub(/^\//, "")
+      @context_map[path]
+    end
+    
+    def ignore_path(path)
+      set_path(path, false)
+      @ignored_paths = false
+    end
+    
+    def each(&block)
+      @map.each do |k, v|
+        yield(k, v)
+      end
+    end
+    
+    def all_paths
+      @map.keys
+    end
+    
+    def all_values
+      @map.values
+    end
+    
+    def ignored_path?(path)
+      path = path.sub(/^\//, "")
+      ignored_paths.include?(path)
+    end
+    
+    def ignored_paths
+      @ignored_paths ||= begin
+        ignored = []
+        each do |k, v|
+          ignored << k if v === false
+        end
+        ignored
+      end
+    end
+    
+    def generic_path?(path)
+      path = path.sub(/^\//, "")
+      generic_paths.include?(path)
+    end
+    
+    def generic_paths
+      @generic_paths ||= begin
+        generic = []
+        each do |k, v|
+          generic << k if v === true
+        end
+        generic
+      end
+    end
+    
+    def proxied_path?(path)
+      path = path.sub(/^\//, "")
+      proxied_paths.include?(path)
+    end
+    
+    def proxied_paths
+      @proxied_paths ||= begin
+        proxied = []
+        each do |k, v|
+          proxied << k if v.is_a?(String)
+        end
+        proxied
+      end
+    end
+    
+    def touch_file(file)
+      add_file(file)
+    end
+    
+    def remove_file(file)
+      path = file_to_path(file)
+      remove_path(path) if path
+    end
+    
+    def remove_path(path)
+      path = path.sub(/^\//, "")
+      @map.delete(path) if path_exists?(path)
+      @context_map.delete(path) if @context_map.has_key?(path)
+    end
+    
+    def source_map
+      @source_map
+    end
+    
+  protected
+    def build_static_map
+      Find.find(@source) do |file|
+        add_file(file)
+      end
+    end
+    
+    def file_to_path(file)
+      file = File.expand_path(file, @app.root)
+      
+      prefix = @source + "/"
+      return false unless file.include?(prefix)
+      
+      path = file.sub(prefix, "")
+      path = @app.extensionless_path(path)
+      
+      @source_map[path] = file
+      path
+    end
+    
+    def add_file(file)
+      return false if file == @source ||
+                      file.match(/^\./) ||
+                      file.match(/\/\./) ||
+                      (file.match(/\/_/) && !file.match(/\/__/)) ||
+                      File.directory?(file)
+                     
+      path = file_to_path(file)
+      
+      add_path(path) if path && !path_exists?(path)
+    end
+    
+    def add_path(path)
+      return false if path.match(%r{^layout}) ||
+                      path.match(%r{^layouts/})
+    
+      # @app.logger.debug :sitemap_update, Time.now, path if @app.logging?
+      set_path(path)
+      
+      true
+    end
+  end
+end

data/lib/middleman/core_extensions/sprockets.rb

@@ -6,6 +6,7 @@ module Middleman::CoreExtensions::Sprockets
   class << self
     def registered(app)
       app.set :js_compressor, false
+      app.set :css_compressor, false
       
       # Cut off every extension after .js (which sprockets eats up)
       app.build_reroute do |destination, request_path|
@@ -19,24 +20,47 @@ module Middleman::CoreExtensions::Sprockets
         end
       end
       
-      app.after_configuration do
-        js_env = Middleman::CoreExtensions::Sprockets::JavascriptEnvironment.new(app)
-        
-        js_dir = File.join("vendor", "assets", "javascripts")
+      app.ready do
+        js_env = Middleman::CoreExtensions::Sprockets::JavascriptEnvironment.new(self)
+
+        vendor_dir = File.join("vendor", "assets", "javascripts")
         gems_with_js = ::Middleman.rubygems_latest_specs.select do |spec|
-          ::Middleman.spec_has_file?(spec, js_dir)
+          ::Middleman.spec_has_file?(spec, vendor_dir)
         end.each do |spec|
-          js_env.append_path File.join(spec.full_gem_path, js_dir)
+          js_env.append_path File.join(spec.full_gem_path, vendor_dir)
         end
-        
+
+        app_dir = File.join("app", "assets", "javascripts")
+        gems_with_js = ::Middleman.rubygems_latest_specs.select do |spec|
+          ::Middleman.spec_has_file?(spec, app_dir)
+        end.each do |spec|
+          js_env.append_path File.join(spec.full_gem_path, app_dir)
+        end
+
         # add paths to js_env (vendor/assets/javascripts)
-        app.map "/#{app.js_dir}" do
+        map "/#{self.js_dir}" do
           run js_env
         end
+
+        css_env = Middleman::CoreExtensions::Sprockets::StylesheetEnvironment.new(self)
+         
+        vendor_dir = File.join("vendor", "assets", "stylesheets")
+        gems_with_css = ::Middleman.rubygems_latest_specs.select do |spec|
+          ::Middleman.spec_has_file?(spec, vendor_dir)
+        end.each do |spec|
+          css_env.append_path File.join(spec.full_gem_path, vendor_dir)
+        end
+  
+        app_dir = File.join("app", "assets", "stylesheets")
+        gems_with_css = ::Middleman.rubygems_latest_specs.select do |spec|
+          ::Middleman.spec_has_file?(spec, app_dir)
+        end.each do |spec|
+          css_env.append_path File.join(spec.full_gem_path, app_dir)
+        end
         
-        # app.map "/#{app.css_dir}" do
-        #   run Middleman::CoreExtensions::Sprockets::StylesheetEnvironment.new(app)
-        # end
+        map("/#{self.css_dir}") do
+          run css_env
+        end
       end
     end
     alias :included :registered
@@ -44,10 +68,7 @@ module Middleman::CoreExtensions::Sprockets
 
   class MiddlemanEnvironment < ::Sprockets::Environment
     def initialize(app)
-      full_path = app.views
-      full_path = File.join(app.root, app.views) unless app.views.include?(app.root)
-      
-      super File.expand_path(full_path)
+      super app.source_dir
       
       # Make the app context available to Sprockets
       context_class.send(:define_method, :app) { app }
@@ -66,12 +87,9 @@ module Middleman::CoreExtensions::Sprockets
   class JavascriptEnvironment < MiddlemanEnvironment
     def initialize(app)
       super
-
-      # Disable css
-      unregister_processor "text/css", ::Sprockets::DirectiveProcessor
       
-      self.js_compressor = app.settings.js_compressor
-
+      self.js_compressor = app.js_compressor
+      
       # configure search paths
       append_path app.js_dir
     end
@@ -82,21 +100,19 @@ module Middleman::CoreExtensions::Sprockets
     end
   end
   
-  # class StylesheetEnvironment < MiddlemanEnvironment
-  #   def initialize(app)
-  #     super
-  # 
-  #     # Disable js
-  #     unregister_processor "application/javascript", ::Sprockets::DirectiveProcessor
-  # 
-  #     # configure search paths
-  #     stylesheets_path = File.join(File.expand_path(app.views), app.css_dir)
-  #     append_path stylesheets_path
-  #   end
-  #
-  #   def css_exception_response(exception)
-  #     expire_index!
-  #     super(exception)
-  #   end
-  # end
+  class StylesheetEnvironment < MiddlemanEnvironment
+    def initialize(app)
+      super
+      
+      self.css_compressor = app.css_compressor
+  
+      # configure search paths
+      append_path app.css_dir
+    end
+  
+    def css_exception_response(exception)
+      expire_index!
+      super(exception)
+    end
+  end
 end

data/lib/middleman/features/asset_host.rb

@@ -1,22 +1,32 @@
 module Middleman::Features::AssetHost
   class << self
     def registered(app)
+      app.set :asset_host, nil
+      
       app.compass_config do |config|
-        if app.asset_host.is_a?(Proc)
-          config.asset_host(&app.asset_host)
+        if self.asset_host.is_a?(Proc)
+          config.asset_host(&self.asset_host)
         end
       end
+      
+      app.send :include, InstanceMethods
+    end
+    alias :included :registered
+  end
+  
+  module InstanceMethods
+    def asset_url(path, prefix="")
+      original_output = super
 
-      app.register_asset_handler :asset_host do |path, prefix, request|
-        original_output = app.before_asset_handler(:asset_host, path, prefix, request)
-
-        valid_extensions = %w(.png .gif .jpg .jpeg .js .css)
-
-        asset_prefix = app.asset_host.call(original_output)
+      valid_extensions = %w(.png .gif .jpg .jpeg .js .css)
 
-        File.join(asset_prefix, original_output)
+      asset_prefix = if self.asset_host.is_a?(Proc)
+        self.asset_host.call(original_output)
+      elsif self.asset_host.is_a?(String)
+        self.asset_host
       end
+
+      File.join(asset_prefix, original_output)
     end
-    alias :included :registered
   end
 end

data/lib/middleman/features/automatic_image_sizes.rb

@@ -3,25 +3,28 @@ module Middleman::Features::AutomaticImageSizes
     def registered(app)
       require "middleman/features/automatic_image_sizes/fastimage"
 
-      app.helpers Helpers
+      app.send :include, InstanceMethods
     end
     alias :included :registered
   end
   
-  module Helpers
+  module InstanceMethods
     def image_tag(path, params={})
-      if (!params[:width] || !params[:height]) && !path.include?("://")
+      if !params.has_key?(:width) && !params.has_key?(:height) && !path.include?("://")
         params[:alt] ||= ""
-        http_prefix = settings.http_images_path rescue settings.images_dir
+        http_prefix = self.http_images_path rescue self.images_dir
 
         begin
-          real_path = File.join(settings.views, 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]
+          real_path = File.join(self.views, self.images_dir, path)
+          full_path = File.expand_path(real_path, self.root)
+          http_prefix = self.http_images_path rescue self.images_dir
+          if File.exists? full_path
+            dimensions = ::FastImage.size(full_path, :raise_on_failure => true)
+            params[:width]  = dimensions[0]
+            params[:height] = dimensions[1]
           end
         rescue
+          # $stderr.puts params.inspect
         end
       end
       

data/lib/middleman/features/cache_buster.rb

@@ -1,34 +1,12 @@
 module Middleman::Features::CacheBuster
   class << self
     def registered(app)
-      app.register_asset_handler :cache_buster do |path, prefix, request|
-        http_path = app.before_asset_handler(: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 = app.images_dir if prefix == app.http_images_path
-          rescue
-          end
-
-          real_path_static  = File.join(app.views, prefix, path)
-
-          if File.readable?(real_path_static)
-            http_path << "?" + File.mtime(real_path_static).strftime("%s") 
-          elsif app.build?
-            real_path_dynamic = File.join(app.root, app.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.send :include, InstanceMethods
+      
       app.compass_config 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(app.root, app.build_dir), app.views)
+          real_path = real_path.gsub(File.join(self.root, self.build_dir), self.views)
           if File.readable?(real_path)
             File.mtime(real_path).strftime("%s") 
           else
@@ -39,4 +17,39 @@ module Middleman::Features::CacheBuster
     end
     alias :included :registered
   end
+  
+  module InstanceMethods
+    def asset_url(path, prefix="")
+      http_path = super
+
+      if http_path.include?("://") || !%w(.css .png .jpg .js .gif).include?(File.extname(http_path))
+        http_path
+      else
+        begin
+          prefix = self.images_dir if prefix == self.http_images_path
+        rescue
+        end
+
+        real_path_static = File.join(prefix, path)
+        result = resolve_template(real_path_static)
+        
+        if self.build?
+          real_path_dynamic = File.join(self.build_dir, prefix, path)
+          real_path_dynamic = File.expand_path(real_path_dynamic, self.root)
+          http_path << "?" + File.mtime(real_path_dynamic).strftime("%s") if File.readable?(real_path_dynamic)
+        elsif result
+          if result[1].nil?
+            http_path << "?" + File.mtime(result[0]).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
+            # developement
+            http_path << "?" + Time.now.strftime("%s")
+          end
+        end
+        
+        http_path
+      end
+    end
+  end
 end