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

data/lib/middleman-core/sitemap/store.rb

@@ -1,190 +1,211 @@
 # Used for merging results of metadata callbacks
 require "active_support/core_ext/hash/deep_merge"
 
-# Sitemap namespace
-module Middleman::Sitemap
+module Middleman
   
-  # The Store class
-  #
-  # The Store manages a collection of Resource objects, which represent
-  # individual items in the sitemap. Resources are indexed by "source path",
-  # which is the path relative to the source directory, minus any template
-  # extensions. All "path" parameters used in this class are source paths.
-  class Store
+  # Sitemap namespace
+  module Sitemap
+  
+    # The Store class
+    #
+    # The Store manages a collection of Resource objects, which represent
+    # individual items in the sitemap. Resources are indexed by "source path",
+    # which is the path relative to the source directory, minus any template
+    # extensions. All "path" parameters used in this class are source paths.
+    class Store
     
-    # @return [Middleman::Application]
-    attr_accessor :app
+      # @return [Middleman::Application]
+      attr_accessor :app
     
-    # Initialize with parent app
-    # @param [Middleman::Application] app
-    def initialize(app)
-      @app   = app
-      @resources = []
-      
-      @_lookup_cache = { :path => {}, :destination_path => {} }
-      @resource_list_manipulators = []
-      
-      # Register classes which can manipulate the main site map list
-      register_resource_list_manipulator(:on_disk, Middleman::Sitemap::Extensions::OnDisk.new(self),  false)
+      # Initialize with parent app
+      # @param [Middleman::Application] app
+      def initialize(app)
+        @app   = app
+        @resources = []
+        @_cached_metadata = {}
+        @_lookup_cache = { :path => {}, :destination_path => {} }
+        @resource_list_manipulators = []
       
-      # Proxies
-      register_resource_list_manipulator(:proxies, @app.proxy_manager, false)
+        # Register classes which can manipulate the main site map list
+        register_resource_list_manipulator(:on_disk, Middleman::Sitemap::Extensions::OnDisk.new(self),  false)
       
-      # Ignores
-      register_resource_list_manipulator(:ignores, @app.ignore_manager, false)
-      
-      rebuild_resource_list!(:after_base_init)
-    end
+        # Proxies
+        register_resource_list_manipulator(:proxies, @app.proxy_manager, false)
+      end
 
-    # Register a klass which can manipulate the main site map list
-    # @param [Class] klass
-    # @param [Boolean] immediately_rebuild
-    # @return [void]
-    def register_resource_list_manipulator(name, inst, immediately_rebuild=true)
-      @resource_list_manipulators << [name, inst]
-      rebuild_resource_list!(:registered_new) if immediately_rebuild
-    end
-    
-    # Rebuild the list of resources from scratch, using registed manipulators
-    # @return [void]
-    def rebuild_resource_list!(reason=nil)
-      @resources = @resource_list_manipulators.inject([]) do |result, (_, inst)|
-        inst.manipulate_resource_list(result)
+      # Register a klass which can manipulate the main site map list
+      # @param [Symbol] name Name of the manipulator for debugging
+      # @param [Class, Module] inst Abstract namespace which can update the resource list
+      # @param [Boolean] immediately_rebuild Whether the resource list should be immediately recalculated
+      # @return [void]
+      def register_resource_list_manipulator(name, inst, immediately_rebuild=true)
+        @resource_list_manipulators << [name, inst]
+        rebuild_resource_list!(:registered_new) if immediately_rebuild
       end
+    
+      # Rebuild the list of resources from scratch, using registed manipulators
+      # @return [void]
+      def rebuild_resource_list!(reason=nil)
+        @resources = @resource_list_manipulators.inject([]) do |result, (_, inst)|
+          inst.manipulate_resource_list(result)
+        end
       
-      # Reset lookup cache
-      @_lookup_cache = { :path => {}, :destination_path => {} }
-      @resources.each do |resource|
-        @_lookup_cache[:path][resource.path] = resource
-        @_lookup_cache[:destination_path][resource.destination_path] = resource
+        # Reset lookup cache
+        @_lookup_cache = { :path => {}, :destination_path => {} }
+        @resources.each do |resource|
+          @_lookup_cache[:path][resource.path] = resource
+          @_lookup_cache[:destination_path][resource.destination_path] = resource
+        end
       end
-    end
     
-    # Find a resource given its original path
-    # @param [String] request_path The original path of a resource.
-    # @return [Middleman::Sitemap::Resource]
-    def find_resource_by_path(request_path)
-      request_path = ::Middleman::Util.normalize_path(request_path)
-      @_lookup_cache[:path][request_path]
-    end
+      # Find a resource given its original path
+      # @param [String] request_path The original path of a resource.
+      # @return [Middleman::Sitemap::Resource]
+      def find_resource_by_path(request_path)
+        request_path = ::Middleman::Util.normalize_path(request_path)
+        @_lookup_cache[:path][request_path]
+      end
     
-    # Find a resource given its destination path
-    # @param [String] request_path The destination (output) path of a resource.
-    # @return [Middleman::Sitemap::Resource]
-    def find_resource_by_destination_path(request_path)
-      request_path = ::Middleman::Util.normalize_path(request_path)
-      @_lookup_cache[:destination_path][request_path]
-    end
+      # Find a resource given its destination path
+      # @param [String] request_path The destination (output) path of a resource.
+      # @return [Middleman::Sitemap::Resource]
+      def find_resource_by_destination_path(request_path)
+        request_path = ::Middleman::Util.normalize_path(request_path)
+        @_lookup_cache[:destination_path][request_path]
+      end
     
-    # Get the array of all resources
-    # @param [Boolean] include_ignored Whether to include ignored resources
-    # @return [Array<Middleman::Sitemap::Resource>]
-    def resources(include_ignored=false)
-      if include_ignored
-        @resources
-      else
-        @resources.reject(&:ignored?)
+      # Get the array of all resources
+      # @param [Boolean] include_ignored Whether to include ignored resources
+      # @return [Array<Middleman::Sitemap::Resource>]
+      def resources(include_ignored=false)
+        if include_ignored
+          @resources
+        else
+          @resources.reject(&:ignored?)
+        end
       end
-    end
     
-    # Register a handler to provide metadata on a file path
-    # @param [Regexp] matcher
-    # @return [Array<Array<Proc, Regexp>>]
-    def provides_metadata(matcher=nil, &block)
-      @_provides_metadata ||= []
-      @_provides_metadata << [block, matcher] if block_given?
-      @_provides_metadata
-    end
+      # Register a handler to provide metadata on a file path
+      # @param [Regexp] matcher
+      # @return [Array<Array<Proc, Regexp>>]
+      def provides_metadata(matcher=nil, &block)
+        @_provides_metadata ||= []
+        @_provides_metadata << [block, matcher] if block_given?
+        @_provides_metadata
+      end
     
-    # Get the metadata for a specific file
-    # @param [String] source_file
-    # @return [Hash]
-    def metadata_for_file(source_file)
-      blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }
+      # Get the metadata for a specific file
+      # @param [String] source_file
+      # @return [Hash]
+      def metadata_for_file(source_file)
+        blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }
       
-      provides_metadata.inject(blank_metadata) do |result, (callback, matcher)|
-        next result if !matcher.nil? && !source_file.match(matcher)
+        provides_metadata.inject(blank_metadata) do |result, (callback, matcher)|
+          next result if !matcher.nil? && !source_file.match(matcher)
         
-        metadata = callback.call(source_file)
-        result.deep_merge(metadata)
+          metadata = callback.call(source_file)
+
+          if metadata.has_key?(:blocks)
+            result[:blocks] << metadata[:blocks]
+            metadata.delete(:blocks)
+          end
+
+          result.deep_merge(metadata)
+        end
       end
-    end
     
-    # Register a handler to provide metadata on a url path
-    # @param [Regexp] matcher
-    # @return [Array<Array<Proc, Regexp>>]
-    def provides_metadata_for_path(matcher=nil, &block)
-      @_provides_metadata_for_path ||= []
-      @_provides_metadata_for_path << [block, matcher] if block_given?
-      @_provides_metadata_for_path
-    end
+      # Register a handler to provide metadata on a url path
+      # @param [Regexp] matcher
+      # @param [Symbol] origin an indicator of where this metadata came from - only one 
+      #                        block per [matcher, origin] pair may exist.
+      # @return [Array<Array<Proc, Regexp>>]
+      def provides_metadata_for_path(matcher=nil, origin=nil, &block)
+        @_provides_metadata_for_path ||= []
+        if block_given?
+          if origin
+            existing_provider = @_provides_metadata_for_path.find {|b,m,o| o == origin && m == matcher}
+          end
+
+          if existing_provider
+            existing_provider[0] = block
+          else
+            @_provides_metadata_for_path << [block, matcher, origin]
+          end
+
+          @_cached_metadata = {}
+        end
+        @_provides_metadata_for_path
+      end
     
-    # Get the metadata for a specific URL
-    # @param [String] request_path
-    # @return [Hash]
-    def metadata_for_path(request_path)
-      blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }
+      # Get the metadata for a specific URL
+      # @param [String] request_path
+      # @return [Hash]
+      def metadata_for_path(request_path)
+        return @_cached_metadata[request_path] if @_cached_metadata[request_path]
+
+        blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }
       
-      provides_metadata_for_path.inject(blank_metadata) do |result, (callback, matcher)|
-        case matcher
-        when Regexp
-          next result unless request_path.match(matcher)
-        when String
-          next result unless File.fnmatch("/" + matcher.sub(%r{^/}, ''), "/#{request_path}")
-        end
+        @_cached_metadata[request_path] = provides_metadata_for_path.inject(blank_metadata) do |result, (callback, matcher)|
+          case matcher
+          when Regexp
+            next result unless request_path.match(matcher)
+          when String
+            next result unless File.fnmatch("/" + matcher.sub(%r{^/}, ''), "/#{request_path}")
+          end
         
-        metadata = callback.call(request_path)
+          metadata = callback.call(request_path)
         
-        if metadata.has_key?(:blocks)
-          result[:blocks] << metadata[:blocks]
-          metadata.delete(:blocks)
-        end
+          if metadata.has_key?(:blocks)
+            result[:blocks] << metadata[:blocks]
+            metadata.delete(:blocks)
+          end
 
-        result.deep_merge(metadata)
+          result.deep_merge(metadata)
+        end
       end
-    end
     
-    # Get the URL path for an on-disk file
-    # @param [String] file
-    # @return [String]
-    def file_to_path(file)
-      file = File.expand_path(file, @app.root)
+      # Get the URL path for an on-disk file
+      # @param [String] file
+      # @return [String]
+      def file_to_path(file)
+        file = File.expand_path(file, @app.root)
   
-      prefix = @app.source_dir.sub(/\/$/, "") + "/"
-      return false unless file.include?(prefix)
+        prefix = @app.source_dir.sub(/\/$/, "") + "/"
+        return false unless file.include?(prefix)
   
-      path = file.sub(prefix, "")
-      extensionless_path(path)
-    end
+        path = file.sub(prefix, "")
+        extensionless_path(path)
+      end
     
-    # Get a path without templating extensions
-    # @param [String] file
-    # @return [String]
-    def extensionless_path(file)
-      path = file.dup
+      # Get a path without templating extensions
+      # @param [String] file
+      # @return [String]
+      def extensionless_path(file)
+        path = file.dup
 
-      end_of_the_line = false
-      while !end_of_the_line
-        if !::Tilt[path].nil?
-          path = path.sub(File.extname(path), "")
-        else
-          end_of_the_line = true
+        end_of_the_line = false
+        while !end_of_the_line
+          if !::Tilt[path].nil?
+            path = path.sub(File.extname(path), "")
+          else
+            end_of_the_line = true
+          end
         end
-      end
 
-      # If there is no extension, look for one
-      if File.extname(path).empty?
-        input_ext = File.extname(file)
+        # If there is no extension, look for one
+        if File.extname(path).empty?
+          input_ext = File.extname(file)
 
-        if !input_ext.empty?
-          input_ext = input_ext.split(".").last.to_sym
-          if @app.template_extensions.has_key?(input_ext)
-            path << ".#{@app.template_extensions[input_ext]}"
+          if !input_ext.empty?
+            input_ext = input_ext.split(".").last.to_sym
+            if @app.template_extensions.has_key?(input_ext)
+              path << ".#{@app.template_extensions[input_ext]}"
+            end
           end
         end
-      end
 
-      path
+        path
+      end
     end
   end
-end
+end

data/lib/middleman-core/sitemap.rb

@@ -1,78 +1,78 @@
+require "middleman-core/sitemap/store"
+require "middleman-core/sitemap/resource"
+
+require "middleman-core/sitemap/extensions/on_disk"
+require "middleman-core/sitemap/extensions/proxies"
+require "middleman-core/sitemap/extensions/ignores"
+
 # Core Sitemap Extensions
-module Middleman::Sitemap
+module Middleman
   
-  autoload :Store,        "middleman-core/sitemap/store"
-  autoload :Resource,     "middleman-core/sitemap/resource"
+  module Sitemap
   
-  module Extensions
-    autoload :OnDisk,     "middleman-core/sitemap/extensions/on_disk"
-    autoload :Proxies,    "middleman-core/sitemap/extensions/proxies"
-    autoload :Ignores,    "middleman-core/sitemap/extensions/ignores"
-    autoload :Traversal,  "middleman-core/sitemap/extensions/traversal"
-  end
-  
-  # Setup Extension
-  class << self
+    # Setup Extension
+    class << self
     
-    # Once registered
-    def registered(app)
+      # Once registered
+      def registered(app)
       
-      app.register Middleman::Sitemap::Extensions::Proxies
-      app.register Middleman::Sitemap::Extensions::Ignores
+        app.register Middleman::Sitemap::Extensions::Proxies
+        app.register Middleman::Sitemap::Extensions::Ignores
       
-      # Setup callbacks which can exclude paths from the sitemap
-      app.set :ignored_sitemap_matchers, {
-        # dotfiles and folders in the root
-        :root_dotfiles => proc { |file, path| file.match(/^\./) },
+        # Setup callbacks which can exclude paths from the sitemap
+        app.set :ignored_sitemap_matchers, {
+          # dotfiles and folders in the root
+          :root_dotfiles => proc { |file, path| file.match(/^\./) },
         
-        # Files starting with an dot, but not .htaccess
-        :source_dotfiles => proc { |file, path| 
-          (file.match(/\/\./) && !file.match(/\/\.htaccess/)) 
-        },
+          # Files starting with an dot, but not .htaccess
+          :source_dotfiles => proc { |file, path| 
+            (file.match(/\/\./) && !file.match(/\/\.htaccess/)) 
+          },
         
-        # Files starting with an underscore, but not a double-underscore
-        :partials => proc { |file, path| (file.match(/\/_/) && !file.match(/\/__/)) },
+          # Files starting with an underscore, but not a double-underscore
+          :partials => proc { |file, path| (file.match(/\/_/) && !file.match(/\/__/)) },
         
-        :layout => proc { |file, path| 
-          file.match(/^source\/layout\./) || file.match(/^source\/layouts\//)
-        },
+          :layout => proc { |file, path| 
+            file.match(/^source\/layout\./) || file.match(/^source\/layouts\//)
+          },
         
-        # Files without any output extension (layouts, partials)
-        # :extensionless => proc { |file, path| !path.match(/\./) },
-      }
+          # Files without any output extension (layouts, partials)
+          # :extensionless => proc { |file, path| !path.match(/\./) },
+        }
       
-      # Include instance methods
-      app.send :include, InstanceMethods
+        # Include instance methods
+        app.send :include, InstanceMethods
       
-      # Initialize Sitemap
-      app.before_configuration do
-        sitemap
+        # Initialize Sitemap
+        app.before_configuration do
+          sitemap
+        end
       end
-    end
-    alias :included :registered
+      alias :included :registered
   
-  end
+    end
   
-  # Sitemap instance methods
-  module InstanceMethods
+    # Sitemap instance methods
+    module InstanceMethods
     
-    # Get the sitemap class instance
-    # @return [Middleman::Sitemap::Store]
-    def sitemap
-      @_sitemap ||= Store.new(self)
-    end
+      # Get the sitemap class instance
+      # @return [Middleman::Sitemap::Store]
+      def sitemap
+        @_sitemap ||= Store.new(self)
+      end
     
-    # Get the resource object for the current path
-    # @return [Middleman::Sitemap::Resource]
-    def current_page
-      current_resource
-    end
+      # Get the resource object for the current path
+      # @return [Middleman::Sitemap::Resource]
+      def current_page
+        current_resource
+      end
     
-    # Get the resource object for the current path
-    # @return [Middleman::Sitemap::Resource]
-    def current_resource
-      sitemap.find_resource_by_destination_path(current_path)
-    end
+      # Get the resource object for the current path
+      # @return [Middleman::Sitemap::Resource]
+      def current_resource
+        sitemap.find_resource_by_destination_path(current_path)
+      end
     
+    end
   end
 end

data/lib/middleman-core/step_definitions/server_steps.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require "rack/test"
 
 Given /^a clean server$/ do
@@ -12,6 +14,14 @@ Given /^"([^\"]*)" feature is "([^\"]*)"$/ do |feature, state|
   end
 end
 
+Given /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_str|
+  @initialize_commands ||= []
+  
+  options = eval("{#{options_str}}")
+
+  @initialize_commands << lambda { activate(feature.to_sym, options) }
+end
+
 Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
   @initialize_commands ||= []
   @initialize_commands << lambda { set(variable.to_sym, value) }
@@ -37,7 +47,7 @@ Given /^the Server is running$/ do
     set :show_exceptions, false
   }
   
-  @server_inst = Middleman.server.inst do
+  @server_inst = Middleman::Application.server.inst do
     initialize_commands.each do |p|
       instance_exec(&p)
     end
@@ -53,11 +63,11 @@ Given /^the Server is running at "([^\"]*)"$/ do |app_path|
 end
 
 When /^I go to "([^\"]*)"$/ do |url|
-  @browser.get(url)
+  @browser.get(URI.escape(url))
 end
 
 Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
-  lambda { @browser.get(url) }.should_not raise_exception
+  lambda { @browser.get(URI.escape(url)) }.should_not raise_exception
 end
 
 Then /^I should see "([^\"]*)"$/ do |expected|

data/lib/middleman-core/templates/extension/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# Specify your gem's dependencies in <%= name %>.gemspec
+gemspec

data/lib/middleman-core/templates/extension/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new(:cucumber, 'Run features that should pass') do |t|
+  t.cucumber_opts = "--color --tags ~@wip --strict --format #{ENV['CUCUMBER_FORMAT'] || 'Fivemat'}"
+end
+
+require 'rake/clean'
+
+task :test => ["cucumber"]

data/lib/middleman-core/templates/extension/features/support/env.rb

@@ -0,0 +1,4 @@
+PROJECT_ROOT_PATH = File.dirname(File.dirname(File.dirname(__FILE__)))
+require "middleman-core"
+require "middleman-core/step_definitions"
+require File.join(PROJECT_ROOT_PATH, 'lib', '<%= name %>')

data/lib/middleman-core/templates/extension/gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "<%= name %>"
+  s.version     = "0.0.1"
+  s.platform    = Gem::Platform::RUBY
+  # s.authors     = ["Your Name"]
+  # s.email       = ["email@example.com"]
+  # s.homepage    = "http://example.com"
+  # s.summary     = %q{A short summary of your extension}
+  # s.description = %q{A longer description of your extension}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  # The version of middleman-core your extension depends on
+  s.add_runtime_dependency("middleman-core", [">= 3.0.0.beta.2"])
+  
+  # Additional dependencies
+  # s.add_runtime_dependency("gem-name", "gem-version")
+end

data/lib/middleman-core/templates/extension/lib/lib.rb

@@ -0,0 +1,49 @@
+# Require core library
+require "middleman-core"
+
+# Extension namespace
+module MyExtension
+  class << self
+    
+    # Called when user `activate`s your extension
+    def registered(app, options={})
+      # Setup extension-specific config
+      app.set :config_variable, false
+      
+      # Include class methods
+      # app.extend ClassMethods
+      
+      # Include instance methods
+      # app.send :include, InstanceMethods
+      
+      app.after_configuration do
+        # Do something
+        
+        # config_variable is now either the default or the user's 
+        # setting from config.rb
+      end
+    end
+    alias :included :registered
+  end
+
+  # module ClassMethods
+  #   def a_class_method
+  #   end
+  # end
+  
+  # module InstanceMethods
+  #   def an_instance_method
+  #   end
+  # end
+    
+end
+
+
+# Register extensions which can be activated
+# Make sure we have the version of Middleman we expect
+# ::Middleman::Extensions.register(:extension_name, ">= 3.0.0.beta.2") do
+#   
+#   # Return the extension module
+#   ::MyExtension
+#   
+# end

data/lib/middleman-core/templates/extension/lib/middleman_extension.rb

@@ -0,0 +1 @@
+require "<%= name %>"

data/lib/middleman-core/templates/shared/gitignore

@@ -0,0 +1,14 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+# git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+
+# Ignore the build directory
+/build
+
+# Ignore Sass' cache
+/.sass-cache