middleman 2.0.16.1 → 3.0.0.alpha.2

data/lib/middleman/core_extensions/features.rb

@@ -30,16 +30,38 @@
 
 module Middleman::CoreExtensions::Features
   
-  # The Feature API is itself a Feature. Mind blowing!
   class << self
-    def registered(app)
-      app.set :default_features, []
+    def included(app)
+      # app.set :default_features, []
+      app.define_hook :after_configuration
+      app.define_hook :before_configuration
+      app.define_hook :build_config
+      app.define_hook :development_config
       app.extend ClassMethods
+      app.send :include, InstanceMethods
     end
-    alias :included :registered
   end
 
   module ClassMethods
+    def configure(env, &block)
+      send("#{env}_config", &block)
+    end
+    
+    def extensions
+      @extensions ||= []
+    end
+    
+    def register(*new_extensions)
+      @extensions ||= []
+      @extensions += new_extensions
+      new_extensions.each do |extension|
+        extend extension
+        extension.registered(self) if extension.respond_to?(:registered)
+      end
+    end
+  end
+  
+  module InstanceMethods
     # This method is available in the project's `config.rb`.
     # It takes a underscore-separated symbol, finds the appropriate
     # feature module and includes it.
@@ -56,47 +78,47 @@ module Middleman::CoreExtensions::Features
 
       if feature.is_a? String
         feature = feature.camelize
-        feature = Middleman::Features.const_get(feature)
+        feature = ::Middleman::Features.const_get(feature)
       end
       
-      $stderr.puts "== Activating:  #{feature}" if logging?
-      register feature
-    end
-    
-    # Add a block/proc to be run after features have been setup
-    def after_configuration(&block)
-      @run_after_features ||= []
-      @run_after_features << block
+      puts "== Activating:  #{feature}" if logging?
+      self.class.register feature
     end
-    
-    def run_after_features
-      @run_after_features || []
+
+    def configure(env, &block)
+      self.class.configure(env, &block)
     end
     
     # Load features before starting server
-    def new
+    def initialize
+      super
+    
+      run_hook :before_configuration
+    
       # Check for and evaluate local configuration
       local_config = File.join(self.root, "config.rb")
       if File.exists? local_config
-        $stderr.puts "== Reading:  Local config" if logging?
-        class_eval File.read(local_config)
-        set :app_file, File.expand_path(local_config)
+        puts "== Reading:  Local config" if logging?
+        instance_eval File.read(local_config)
       end
       
+      run_hook :build_config if build?
+      run_hook :development_config if development?
+      
+      run_hook :after_configuration
+      
       # Add in defaults
       default_features.each do |ext|
-        activate ext
+        # activate ext
       end
       
-      run_after_features.each { |block| class_eval(&block) }
-      
       if logging?
-        extensions.each do |ext|
-          $stderr.puts "== Extension: #{ext}"
+        self.class.extensions.each do |ext|
+          puts "== Extension: #{ext}"
         end
       end
       
-      super
+      run_hook :ready
     end
   end
 end

data/lib/middleman/core_extensions/file_watcher.rb

@@ -0,0 +1,66 @@
+require "find"
+
+module Middleman::CoreExtensions::FileWatcher
+  class << self
+    def registered(app)
+      app.extend ClassMethods
+      app.send :include, InstanceMethods
+      
+      app.before_configuration do
+        data_path = File.join(root, data_dir)
+        Find.find(data_path) do |path|
+          next if File.directory?(path)
+          file_did_change(path.sub("#{root}/", ""))
+        end if File.exists?(data_path)
+      end
+      
+      app.ready do
+        Find.find(root) do |path|
+          next if File.directory?(path)
+          file_did_change(path.sub("#{root}/", ""))
+        end
+      end
+    end
+    alias :included :registered
+  end
+  
+  module ClassMethods
+    def file_changed(matcher=nil, &block)
+      @_file_changed ||= []
+      @_file_changed << [block, matcher] if block_given?
+      @_file_changed
+    end
+    
+    def file_deleted(matcher=nil, &block)
+      @_file_deleted ||= []
+      @_file_deleted << [block, matcher] if block_given?
+      @_file_deleted
+    end
+  end
+  
+  module InstanceMethods
+    def file_changed(*args, &block)
+      self.class.file_changed(*args, &block)
+    end
+    
+    def file_did_change(path)
+      file_changed.each do |callback, matcher|
+        next if path.match(%r{^#{build_dir}/})
+        next if !matcher.nil? && !path.match(matcher)
+        instance_exec(path, &callback)
+      end
+    end
+    
+    def file_deleted(*args)
+      self.class.file_deleted(*args)
+    end
+
+    def file_did_delete(path)
+      file_deleted.each do |callback, matcher|
+        next if path.match(%r{^#{build_dir}/})
+        next unless matcher.nil? || path.match(matcher)
+        instance_exec(path, &callback)
+      end
+    end
+  end
+end

data/lib/middleman/core_extensions/front_matter.rb

@@ -4,54 +4,102 @@ require "tilt"
 module Middleman::CoreExtensions::FrontMatter
   class << self
     def registered(app)
-      app.extend ClassMethods
-      
-      ::Tilt::register RDiscountTemplate, 'markdown', 'mkd', 'md'
-      ::Tilt::register RedcarpetTemplate, 'markdown', 'mkd', 'md'
-      ::Tilt::register MarukuTemplate, 'markdown', 'mkd', 'md'
-      ::Tilt::register KramdownTemplate, 'markdown', 'mkd', 'md'
-      app.set :markdown_engine_prefix, ::Middleman::CoreExtensions::FrontMatter
-      
-      ::Tilt::register RedClothTemplate,  'textile'
-      ::Tilt.prefer(RedClothTemplate)
-      
-      ::Tilt::register ERBTemplate,       'erb', 'rhtml'
-      ::Tilt.prefer(ERBTemplate)
+      app.send :include, InstanceMethods
+    end
+    alias :included :registered
+  end
+  
+  module InstanceMethods
+    def initialize
+      file_changed FrontMatter.matcher do |file|
+        frontmatter.touch_file(file)
+      end
       
-      ::Tilt::register LiquidTemplate,    'liquid'
-      ::Tilt.prefer(LiquidTemplate)
+      file_deleted do |file|
+        frontmatter.remove_file(file)
+      end
       
-      ::Tilt::register SlimTemplate,      'slim'
-      ::Tilt.prefer(SlimTemplate)
+      provides_metadata FrontMatter.matcher do |path|
+        relative_path = path.sub(source_dir, "")
+        
+        data = if frontmatter.has_data?(relative_path)
+          frontmatter.data(relative_path).first
+        else
+          {}
+        end
+        
+        # Forward remaining data to helpers
+        data_content("page", data)
+        
+        %w(layout layout_engine).each do |opt|
+          if data.has_key?(opt)
+            data[opt.to_sym] = data.delete(opt)
+          end
+        end
+        
+        @options.merge!(data)
+      end
+        
+      super
+    end
+    
+    def frontmatter
+      @frontmatter ||= FrontMatter.new(self)
+    end
+  end
+  
+  class FrontMatter
+    def self.matcher
+      %r{source/.*\.html}
+    end
+    
+    def initialize(app)
+      @app = app
+      @source = File.expand_path(@app.views, @app.root)
+      @local_data = {}
+    end
+    
+    def has_data?(path)
+      @local_data.has_key?(path.to_s)
+    end
+    
+    def touch_file(file)
+      extension = File.extname(file).sub(/\./, "")
+      return unless ::Tilt.mappings.has_key?(extension)
       
-      ::Tilt::register HamlTemplate,      'haml'
-      ::Tilt.prefer(HamlTemplate)
+      file = File.expand_path(file, @app.root)
+      content = File.read(file)
       
-      app.after_configuration do
-        app.before_processing(:front_matter, 0) do |result|
-          if result && Tilt.mappings.has_key?(result[1].to_s)
-            extensionless_path, template_engine = result
-            full_file_path = "#{extensionless_path}.#{template_engine}"
-            system_path = File.join(settings.views, full_file_path)
-            data, content = app.parse_front_matter(File.read(system_path))
-  
-            request['custom_options'] = {}
-            %w(layout layout_engine).each do |opt|
-              if data.has_key?(opt)
-                request['custom_options'][opt.to_sym] = data.delete(opt)
-              end
-            end
-  
-            # Forward remaining data to helpers
-            app.data_content("page", data)
-          end
+      # @app.logger.debug :frontmatter_update, Time.now, file if @app.logging?
+      result = parse_front_matter(content)
         
-          true
-        end
+      if result
+        file = file.sub(@app.source_dir, "")
+        @local_data[file] = result
+        path = File.join(@app.source_dir, file)
+        @app.raw_templates_cache[path] = result[1]
+      end
+    end
+    
+    def remove_file(file)
+      file = File.expand_path(file, @app.root)
+      file = file.sub(@app.source_dir, "")
+      # @app.logger.debug :frontmatter_remove, Time.now, file if @app.logging?
+      
+      if @local_data.has_key?(file)
+        @local_data.delete(file) 
+      end
+    end
+    
+    def data(path)
+      if @local_data.has_key?(path.to_s)
+        @local_data[path.to_s]
+      else
+        nil
       end
     end
-    alias :included :registered
     
+  private
     def parse_front_matter(content)
       yaml_regex = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
       if content =~ yaml_regex
@@ -59,58 +107,15 @@ module Middleman::CoreExtensions::FrontMatter
           data = YAML.load($1)
         rescue => e
           puts "YAML Exception: #{e.message}"
+          return false
         end
 
         content = content.split(yaml_regex).last
+      else
+        return false
       end
 
-      data ||= {}
       [data, content]
     end
   end
-  
-  module ClassMethods
-    def parse_front_matter(content)
-      Middleman::CoreExtensions::FrontMatter.parse_front_matter(content)
-    end
-  end
-  
-  module YamlAware
-    def prepare
-      @frontmatter, @data = Middleman::CoreExtensions::FrontMatter.parse_front_matter(@data)
-      super
-    end
-  end
-
-  class RDiscountTemplate < ::Tilt::RDiscountTemplate
-    include Middleman::CoreExtensions::FrontMatter::YamlAware
-  end
-  class RedcarpetTemplate < ::Tilt::RedcarpetTemplate
-    include Middleman::CoreExtensions::FrontMatter::YamlAware
-  end
-  class MarukuTemplate < ::Tilt::MarukuTemplate
-    include Middleman::CoreExtensions::FrontMatter::YamlAware
-  end
-  class RedClothTemplate < ::Tilt::RedClothTemplate
-    include Middleman::CoreExtensions::FrontMatter::YamlAware
-  end
-  class KramdownTemplate < ::Tilt::KramdownTemplate
-    include Middleman::CoreExtensions::FrontMatter::YamlAware
-  end
- 
-  class ERBTemplate < ::Tilt::ERBTemplate
-    include Middleman::CoreExtensions::FrontMatter::YamlAware
-  end
-
-  class LiquidTemplate < ::Tilt::LiquidTemplate
-    include Middleman::CoreExtensions::FrontMatter::YamlAware
-  end
-
-  class HamlTemplate < ::Tilt::HamlTemplate
-    include Middleman::CoreExtensions::FrontMatter::YamlAware
-  end
-  
-  class SlimTemplate < ::Slim::Template
-    include Middleman::CoreExtensions::FrontMatter::YamlAware
-  end
 end

data/lib/middleman/core_extensions/rendering.rb

@@ -1,17 +1,18 @@
-require "padrino-core/application/rendering"
-
 module Middleman::CoreExtensions::Rendering
   class << self
     def registered(app)
-      # Tilt-aware renderer
-      app.register Padrino::Rendering
-
+      # Autoload
+      require "coffee_script"
+      
+      begin
+        require "slim"
+      rescue LoadError
+      end
+      
       # Activate custom renderers
-      app.register Middleman::Renderers::Slim
-      app.register Middleman::Renderers::Haml
       app.register Middleman::Renderers::Sass
       app.register Middleman::Renderers::Markdown
-      app.register Middleman::Renderers::CoffeeScript
+      app.register Middleman::Renderers::ERb
       app.register Middleman::Renderers::Liquid
     end
     alias :included :registered

data/lib/middleman/core_extensions/routing.rb

@@ -1,87 +1,53 @@
 module Middleman::CoreExtensions::Routing
   class << self
     def registered(app)
-      app.extend ClassMethods
-      
-      app.set :proxied_paths, {}
-      app.set :excluded_paths, []
-      
-      app.build_reroute do |destination, request_path|
-        throw if app.settings.excluded_paths.include?(request_path)
-      end
+      app.send :include, InstanceMethods
     end
     alias :included :registered
   end
   
-  module ClassMethods    
-    def path_to_index(path)
-      parts = path ? path.split('/') : []
-      if parts.last.nil? || parts.last.split('.').length == 1
-        path = File.join(path, settings.index_file) 
-      end
-      path.gsub(%r{^/}, '')
-    end
-  
+  module InstanceMethods
     # Takes a block which allows many pages to have the same layout
     # with_layout :admin do
     #   page "/admin/"
     #   page "/admin/login.html"
     # end
     def with_layout(layout_name, &block)
-      old_layout = settings.layout
+      old_layout = layout
     
       set :layout, layout_name
-      class_eval(&block) if block_given?
+      instance_exec(&block) if block_given?
     ensure
       set :layout, old_layout
     end
-  
-    def paths_for_url(url)
-      url = url.gsub(%r{\/#{settings.index_file}$}, "")
-      url = url.gsub(%r{(\/)$}, "") if url.length > 1
-      url = "/" if url.length == 0
-    
-      paths = [url]
-      paths << "#{url}/" if url.length > 1 && url.split("/").last.split('.').length <= 1
-      paths << "/#{path_to_index(url)}"
-      paths
-    end
-  
-    # Keep a path from building
-    def ignore(path)
-      settings.excluded_paths << paths_for_url(path)
-      settings.excluded_paths.flatten!
-      settings.excluded_paths.uniq!
-    end
     
     # The page method allows the layout to be set on a specific path
     # page "/about.html", :layout => false
     # page "/", :layout => :homepage_layout
     def page(url, options={}, &block)
-      has_block = block_given?
-      options[:layout] = settings.layout if options[:layout].nil?
+      options[:layout] = layout if options[:layout].nil?
       
+      url = full_path(url)
+
       if options.has_key?(:proxy)
-        settings.proxied_paths[url] = options[:proxy]
+        reroute(url, options[:proxy])
+        
         if options.has_key?(:ignore) && options[:ignore]
-          settings.ignore(options[:proxy])
-        end
+          ignore(options[:proxy])
+          options.delete(:ignore)
+        end  
+        
+        options.delete(:proxy)
       else
         if options.has_key?(:ignore) && options[:ignore]
-          settings.ignore(url)
+          ignore(url)
+          options.delete(:ignore)
         end
       end
 
-      paths_for_url(url).each do |p|
-        get(p) do
-          if settings.proxied_paths.has_key?(url)
-            request["is_proxy"] = true
-            request.path_info = settings.proxied_paths[url]
-          end
-          
-          instance_eval(&block) if has_block
-          process_request(options)
-        end
+      a_block = block_given? ? block : nil
+      if a_block || !options.empty?
+        sitemap.set_context(url, options, a_block)
       end
     end
   end