middleman 2.0.16.1 → 3.0.0.alpha.2

data/lib/middleman/core_extensions/assets.rb

@@ -2,56 +2,16 @@ module Middleman::CoreExtensions::Assets
   class << self
     def registered(app)
       # Disable Padrino cache buster until explicitly enabled
-      app.set :asset_stamp, false
+      # app.set :asset_stamp, false
       
-      app.extend ClassMethods
-      
-      app.helpers Helpers
-      
-      app.register_asset_handler :base do |path, prefix, request|
-        path.include?("://") ? path : File.join(app.http_prefix || "/", prefix, path)
-      end
+      app.send :include, InstanceMethod
     end
     alias :included :registered
   end
   
-  module ClassMethods
-    def register_asset_handler(handler_name, &block)
-      @asset_handler_map   ||= []
-      @asset_handler_stack ||= []
-      
-      if block_given?
-        @asset_handler_stack << block
-        @asset_handler_map   << handler_name
-      end
-    end
-    
-    def asset_handler_get_url(path, prefix="", request=nil)
-      @asset_handler_map   ||= []
-      @asset_handler_stack ||= []
-      
-      @asset_handler_stack.last.call(path, prefix, request)
-    end
-    
-    def before_asset_handler(position, *args)
-      @asset_handler_map   ||= []
-      @asset_handler_stack ||= []
-      
-      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
-  
-  module Helpers
+  module InstanceMethod
     def asset_url(path, prefix="")
-      self.class.asset_handler_get_url(path, prefix, request)
+      path.include?("://") ? path : File.join(self.http_prefix || "/", prefix, path)
     end
   end
 end

data/lib/middleman/core_extensions/builder.rb

@@ -1,34 +1,30 @@
 module Middleman::CoreExtensions::Builder
   class << self
     def registered(app)
+      app.define_hook :after_build
       app.extend ClassMethods
+      app.send :include, InstanceMethods
     end
   end
   
   module ClassMethods
-    # Add a block/proc to be run after features have been setup
-    def after_build(&block)
-      @run_after_build ||= []
-      @run_after_build << block
-    end
-
-    def after_build_callbacks
-      @run_after_build ||= []
-      @run_after_build
-    end
-    
     def build_reroute(&block)
       @build_rerouters ||= []
-      @build_rerouters << block
+      @build_rerouters << block if block_given?
+      @build_rerouters
+    end
+  end
+  
+  module InstanceMethods
+    def build_reroute(&block)
+      self.class.build_reroute(&block)
     end
     
     def reroute_builder(desination, request_path)
-      @build_rerouters ||= []
-      
       result = [desination, request_path]
       
-      @build_rerouters.each do |block|
-        output = block.call(desination, request_path)
+      build_reroute.each do |block|
+        output = instance_exec(desination, request_path, &block)
         if output
           result = output
           break

data/lib/middleman/core_extensions/compass.rb

@@ -1,18 +1,12 @@
+require "compass"
+
 module Middleman::CoreExtensions::Compass
   class << self
     def registered(app)
       # Where to look for fonts
       app.set :fonts_dir, "fonts"
-    
-      app.extend ClassMethods
-        
-      require "compass"
-      
-      # Susy grids
-      begin
-        require "susy"
-      rescue LoadError
-      end
+      app.define_hook :compass_config
+      app.define_hook :after_compass_config
 
       app.after_configuration do
         # Support a stand-alone compass config file
@@ -24,60 +18,51 @@ module Middleman::CoreExtensions::Compass
         # * line_comments
         # * sprite_engine
         # * chunky_png_options
-        compass_config_file = File.join(app.root, "compass.config")
+        compass_config_file = File.join(self.root, "compass.config")
         if File.exists?(compass_config_file)
           ::Compass.add_project_configuration(compass_config_file)
         end
         
         ::Compass.configuration do |config|
-          config.project_path          = app.root
+          config.project_path          = self.root
           config.environment           = :development
-          config.cache_path            = File.join(app.root, ".sass-cache")
+          config.cache_path            = File.join(self.root, ".sass-cache")
           
-          views_root = File.basename(app.views)
-          config.sass_dir              = File.join(views_root, app.css_dir)
-          config.css_dir               = File.join(views_root, app.css_dir)
-          config.javascripts_dir       = File.join(views_root, app.js_dir)
-          config.fonts_dir             = File.join(views_root, app.fonts_dir)
-          config.images_dir            = File.join(views_root, app.images_dir)
+          views_root = File.basename(self.views)
+          config.sass_dir              = File.join(views_root, self.css_dir)
+          config.css_dir               = File.join(views_root, self.css_dir)
+          config.javascripts_dir       = File.join(views_root, self.js_dir)
+          config.fonts_dir             = File.join(views_root, self.fonts_dir)
+          config.images_dir            = File.join(views_root, self.images_dir)
           
-          config.http_images_path = if app.respond_to? :http_images_path
-            app.http_images_path
+          config.http_images_path = if self.respond_to? :http_images_path
+            self.http_images_path
           else
-            File.join(app.http_prefix || "/", app.images_dir)
-          end
-          
-          # Correctly support HTTP paths with generated sprites
-          if config.respond_to? :http_generated_images_path
-            config.http_generated_images_path = if app.respond_to? :http_generated_images_path
-              app.http_generated_images_path
-            else
-              File.join(app.http_prefix || "/", app.images_dir)
-            end
+            File.join(self.http_prefix || "/", self.images_dir)
           end
           
-          config.http_stylesheets_path = if app.respond_to? :http_css_path
-            app.http_css_path
+          config.http_stylesheets_path = if self.respond_to? :http_css_path
+            self.http_css_path
           else
-            File.join(app.http_prefix || "/", app.css_dir)
+            File.join(self.http_prefix || "/", self.css_dir)
           end
           
-          config.http_javascripts_path = if app.respond_to? :http_js_path
-            app.http_js_path
+          config.http_javascripts_path = if self.respond_to? :http_js_path
+            self.http_js_path
           else
-            File.join(app.http_prefix || "/", app.js_dir)
+            File.join(self.http_prefix || "/", self.js_dir)
           end
 
-          config.http_fonts_path = if app.respond_to? :http_fonts_path
-            app.http_fonts_path
+          config.http_fonts_path = if self.respond_to? :http_fonts_path
+            self.http_fonts_path
           else
-            File.join(app.http_prefix || "/", app.fonts_dir)
+            File.join(self.http_prefix || "/", self.fonts_dir)
           end
           
           config.asset_cache_buster :none
           config.output_style = :nested
 
-          config.add_import_path(config.sass_dir)
+          # config.add_import_path(config.sass_dir)
         end
         
         # Required for relative paths
@@ -92,24 +77,10 @@ module Middleman::CoreExtensions::Compass
           end
         end
         
-        app.execute_after_compass_init!
-        
-        app.set :sass, ::Compass.configuration.to_sass_engine_options
+        run_hook :compass_config, ::Compass.configuration
+        run_hook :after_compass_config
       end
     end
     alias :included :registered
   end
-  
-  module ClassMethods
-    # Add a block/proc to be run after features have been setup
-    def compass_config(&block)
-      @run_after_compass ||= []
-      @run_after_compass << block
-    end
-    
-    def execute_after_compass_init!
-      @run_after_compass ||= []
-      @run_after_compass.each { |block| block.call(::Compass.configuration) }
-    end
-  end
 end

data/lib/middleman/core_extensions/data.rb

@@ -6,21 +6,70 @@ module Middleman::CoreExtensions::Data
   class << self
     def registered(app)
       app.set :data_dir, "data"
-      app.extend ClassMethods
-      app.helpers Helpers
+      app.send :include, InstanceMethods
     end
     alias :included :registered
   end
   
-  module Helpers
+  module InstanceMethods
+    def initialize
+      file_changed DataStore.matcher do |file|
+        data.touch_file(file) if file.match(%r{^#{data_dir}\/})
+      end
+    
+      file_deleted DataStore.matcher do |file|
+        data.remove_file(file) if file.match(%r{^#{data_dir}\/})
+      end
+      
+      super
+    end
+    
     def data
-      self.class.data
+      @data ||= DataStore.new(self)
+    end
+
+    # Makes a hash available on the data var with a given name
+    def data_content(name, content)
+      DataStore.data_content(name, content)
+    end
+
+    # Makes a hash available on the data var with a given name
+    def data_callback(name, &block)
+      DataStore.data_callback(name, block)
     end
   end
   
-  class DataObject
+  class DataStore
+    def self.matcher
+      %r{[\w-]+\.(yml|yaml|json)$}
+    end
+    
     def initialize(app)
       @app = app
+      @local_data = {}
+    end
+    
+    def touch_file(file)
+      file = File.expand_path(file, @app.root)
+      extension = File.extname(file)
+      basename  = File.basename(file, extension)
+      
+      if %w(.yaml .yml).include?(extension)
+        data = YAML.load_file(file)
+      elsif extension == ".json"
+        data = ActiveSupport::JSON.decode(File.read(file))
+      else
+        return
+      end
+
+      # @app.logger.debug :data_update, Time.now, basename if @app.logging?
+      @local_data[basename] = recursively_enhance(data)
+    end
+    
+    def remove_file(file)
+      extension = File.extname(file)
+      basename  = File.basename(file, extension)
+      @local_data.delete(basename) if @local_data.has_key?(basename)
     end
     
     def data_for_path(path)
@@ -33,32 +82,23 @@ module Middleman::CoreExtensions::Data
         response = @@local_sources[path.to_s]
       elsif @@callback_sources.has_key?(path.to_s)
         response = @@callback_sources[path.to_s].call()
-      else
-        file_path = File.join(@app.root, @app.data_dir, "#{path}.yml")
-        if File.exists? file_path
-          response = YAML.load_file(file_path) 
-        else
-          file_path = File.join(@app.root, @app.data_dir, "#{path}.yaml")
-          if File.exists? file_path
-            response = YAML.load_file(file_path)
-          else
-            file_path = File.join(@app.root, @app.data_dir, "#{path}.json")
-            response = ActiveSupport::JSON.decode(File.read(file_path)) if File.exists? file_path
-          end
-        end
       end
       
       response
     end
     
     def method_missing(path)
-      result = data_for_path(path)
-      
-      if result
-        recursively_enhance(result)
+      if @local_data.has_key?(path.to_s)
+        return @local_data[path.to_s]
       else
-        super
+        result = data_for_path(path)
+      
+        if result
+          return recursively_enhance(result)
+        end
       end
+      
+      super
     end
     
     def to_h
@@ -75,16 +115,8 @@ module Middleman::CoreExtensions::Data
         data[k] = data_for_path(k)
       end
       
-      yaml_path = File.join(@app.root, @app.data_dir, "*.{yaml,yml}")
-      Dir[yaml_path].each do |f|
-        p = f.split("/").last.gsub(".yml", "").gsub(".yaml", "")
-        data[p] = data_for_path(p)
-      end
-      
-      json_path = File.join(@app.root, @app.data_dir, "*.json")
-      Dir[json_path].each do |f|
-        p = f.split("/").last.gsub(".json", "")
-        data[p] = data_for_path(p)
+      (@local_data || {}).each do |k, v|
+        data[k] = v
       end
       
       data
@@ -118,20 +150,4 @@ module Middleman::CoreExtensions::Data
       end
     end
   end
-  
-  module ClassMethods
-    def data
-      @data ||= DataObject.new(self)
-    end
-    
-    # Makes a hash available on the data var with a given name
-    def data_content(name, content)
-      DataObject.data_content(name, content)
-    end
-    
-    # Makes a hash available on the data var with a given name
-    def data_callback(name, &block)
-      DataObject.data_callback(name, block)
-    end
-  end
 end

data/lib/middleman/core_extensions/default_helpers.rb

@@ -1,12 +1,26 @@
-require "padrino-helpers"
+require "middleman/vendor/padrino-core-0.10.5/lib/padrino-core/support_lite"
+require 'i18n'
+require 'enumerator'
+require 'active_support/core_ext/string/conversions'  # to_date
+require 'active_support/core_ext/float/rounding'      # round
+require 'active_support/option_merger'                # with_options
+require 'active_support/core_ext/object/with_options' # with_options
+require 'active_support/inflector'                    # humanize
+
+FileSet.glob_require('../vendor/padrino-helpers-0.10.5/lib/padrino-helpers/**/*.rb', __FILE__)
 
 module Middleman::CoreExtensions::DefaultHelpers
   class << self
     def registered(app)
-      # Use Padrino Helpers
-      app.register Padrino::Helpers
+      app.helpers ::Padrino::Helpers::OutputHelpers
+      app.helpers ::Padrino::Helpers::TagHelpers
+      app.helpers ::Padrino::Helpers::AssetTagHelpers
+      app.helpers ::Padrino::Helpers::FormHelpers
+      app.helpers ::Padrino::Helpers::FormatHelpers
+      app.helpers ::Padrino::Helpers::RenderHelpers
+      app.helpers ::Padrino::Helpers::NumberHelpers
+      app.helpers ::Padrino::Helpers::TranslationHelpers
       
-      # Middleman Helpers
       app.helpers Helpers
     end
     alias :included :registered
@@ -28,25 +42,27 @@ module Middleman::CoreExtensions::DefaultHelpers
     def auto_tag(asset_ext, separator="/", asset_dir=nil)
       if asset_dir.nil?
         asset_dir = case asset_ext
-          when :js  then self.class.js_dir
-          when :css then self.class.css_dir
+          when :js  then self.js_dir
+          when :css then self.css_dir
         end
       end
-      path = request.path_info.dup
+      
       # If the basename of the request as no extension, assume we are serving a
       # directory and join index_file to the path.
-      path = File.join(path, self.class.index_file) if File.extname(path).empty?
-      path = path.gsub(%r{^/}, '')
+      path = full_path(current_path.dup)
+        
+      path = path.sub(%r{^/}, '')
       path = path.gsub(File.extname(path), ".#{asset_ext}")
       path = path.gsub("/", separator)
 
-      view = File.join(self.class.views, asset_dir, path)
-      yield path if File.exists?(view) or Dir["#{view}.*"].any?
+      matching_file = resolve_template(File.join(asset_dir, path))
+        
+      yield path if matching_file
     end
 
     def page_classes
-      path = request.path_info.dup
-      path << settings.index_file if path.match(%r{/$})
+      path = current_path.dup
+      path << self.index_file if path.match(%r{/$})
       path = path.gsub(%r{^/}, '')
   
       classes = []
@@ -60,9 +76,9 @@ module Middleman::CoreExtensions::DefaultHelpers
     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
+         when :css    then self.css_dir
+         when :js     then self.js_dir
+         when :images then self.images_dir
          else kind.to_s
        end
        source = source.to_s.gsub(/\s/, '')
@@ -70,8 +86,7 @@ module Middleman::CoreExtensions::DefaultHelpers
        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}"
+       "#{result_path}"
      end
   end
 end