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

data/lib/middleman-core/core_extensions/extensions.rb

@@ -28,124 +28,130 @@
 # methods to use in your views. Some modify the output on-the-fly. And some
 # apply computationally-intensive changes to your final build files.
 
-# Using for version parsing
-require "rubygems"
-
 # Namespace extensions module
-module Middleman::CoreExtensions::Extensions
+module Middleman
+  module CoreExtensions
+    module Extensions
   
-  # Register extension
-  class << self
-    # @private
-    def included(app)
-      # app.set :default_extensions, []
-      app.define_hook :after_configuration
-      app.define_hook :before_configuration
-      app.define_hook :build_config
-      app.define_hook :development_config
+      # Register extension
+      class << self
+        # @private
+        def registered(app)
+          # Using for version parsing
+          require "rubygems"
+
+          # app.set :default_extensions, []
+          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
-      app.delegate :configure, :to => :"self.class"
-    end
-  end
+          app.extend ClassMethods
+          app.send :include, InstanceMethods
+          app.delegate :configure, :to => :"self.class"
+        end
+        alias :included :registered
+      end
 
-  # Class methods
-  module ClassMethods
-    # Add a callback to run in a specific environment
-    #
-    # @param [String, Symbol] env The environment to run in
-    # @return [void]
-    def configure(env, &block)
-      send("#{env}_config", &block)
-    end
+      # Class methods
+      module ClassMethods
+        # Add a callback to run in a specific environment
+        #
+        # @param [String, Symbol] env The environment to run in
+        # @return [void]
+        def configure(env, &block)
+          send("#{env}_config", &block)
+        end
     
-    # Alias `extensions` to access registered extensions
-    #
-    # @return [Array<Module]
-    def extensions
-      @extensions ||= []
-    end
+        # Alias `extensions` to access registered extensions
+        #
+        # @return [Array<Module>]
+        def extensions
+          @extensions ||= []
+        end
     
-    # Register a new extension
-    # 
-    # @param [Array<Module>] new_extensions Extension modules to register
-    # @return [Array<Module]
-    def register(extension, options={}, &block)
-      @extensions ||= []
-      @extensions += [extension]
+        # Register a new extension
+        # 
+        # @param [Module] extension Extension modules to register
+        # @param [Hash] options Per-extension options hash
+        # @return [void]
+        def register(extension, options={}, &block)
+          @extensions ||= []
+          @extensions += [extension]
       
-      extend extension
-      if extension.respond_to?(:registered)
-        if extension.method(:registered).arity === 1
-          extension.registered(self, &block)
-        else
-          extension.registered(self, options, &block)
+          extend extension
+          if extension.respond_to?(:registered)
+            if extension.method(:registered).arity === 1
+              extension.registered(self, &block)
+            else
+              extension.registered(self, options, &block)
+            end
+          end
         end
       end
-    end
-  end
   
-  # Instance methods
-  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.
-    #
-    #     activate :lorem
-    #
-    # @param [Symbol, Module] ext Which extension to activate
-    # @return [void]
-    def activate(ext, options={}, &block)
-      # Make :i18n a no-op
-      return if ext == :i18n
+      # Instance methods
+      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.
+        #
+        #     activate :lorem
+        #
+        # @param [Symbol, Module] ext Which extension to activate
+        # @return [void]
+        def activate(ext, options={}, &block)
+          # Make :i18n a no-op
+          return if ext == :i18n
       
-      ext_module = if ext.is_a?(Module)
-        ext
-      else
-        ::Middleman::Extensions.load(ext.to_sym)
-      end
+          ext_module = if ext.is_a?(Module)
+            ext
+          else
+            ::Middleman::Extensions.load(ext.to_sym)
+          end
       
-      if ext_module.nil?
-        puts "== Unknown Extension: #{ext}"
-      else
-        puts "== Activating: #{ext}" if logging?
-        self.class.register(ext_module, options, &block)
-      end
-    end
+          if ext_module.nil?
+            puts "== Unknown Extension: #{ext}"
+          else
+            puts "== Activating: #{ext}" if logging?
+            self.class.register(ext_module, options, &block)
+          end
+        end
     
-    # Load features before starting server
-    def initialize
-      super
+        # Load features before starting server
+        def initialize
+          super
       
-      self.class.inst = self
-      run_hook :before_configuration
+          self.class.inst = self
+          run_hook :before_configuration
     
-      # Search the root of the project for required files
-      $LOAD_PATH.unshift(root)
+          # Search the root of the project for required files
+          $LOAD_PATH.unshift(root)
       
-      # Check for and evaluate local configuration
-      local_config = File.join(root, "config.rb")
-      if File.exists? local_config
-        puts "== Reading:  Local config" if logging?
-        instance_eval File.read(local_config), local_config, 1
-      end
+          # Check for and evaluate local configuration
+          local_config = File.join(root, "config.rb")
+          if File.exists? local_config
+            puts "== Reading:  Local config" if logging?
+            instance_eval File.read(local_config), local_config, 1
+          end
       
-      run_hook :build_config if build?
-      run_hook :development_config if development?
+          run_hook :build_config if build?
+          run_hook :development_config if development?
       
-      run_hook :after_configuration
+          run_hook :after_configuration
       
-      # Add in defaults
-      default_extensions.each do |ext|
-        activate ext
-      end
+          # Add in defaults
+          default_extensions.each do |ext|
+            activate ext
+          end
       
-      if logging?
-        self.class.extensions.each do |ext|
-          puts "== Extension: #{ext}"
+          if logging?
+            self.class.extensions.each do |ext|
+              puts "== Extension: #{ext}"
+            end
+          end
         end
       end
     end
   end
-end
+end

data/lib/middleman-core/core_extensions/external_helpers.rb

@@ -1,35 +1,39 @@
 # Load helpers in helpers/
-module Middleman::CoreExtensions::ExternalHelpers
+module Middleman
+  module CoreExtensions
+    module ExternalHelpers
   
-  # Setup extension
-  class << self
+      # Setup extension
+      class << self
     
-    # once registered
-    def registered(app)
-      # Setup a default helpers paths
-      app.set :helpers_dir, "helpers"
-      app.set :helpers_filename_glob, "**/*_helper.rb"
-      app.set :helpers_filename_to_module_name_proc, Proc.new { |filename|
-        basename = File.basename(filename, File.extname(filename))
-        basename.camelcase
-      }
+        # once registered
+        def registered(app)
+          # Setup a default helpers paths
+          app.set :helpers_dir, "helpers"
+          app.set :helpers_filename_glob, "**/*_helper.rb"
+          app.set :helpers_filename_to_module_name_proc, Proc.new { |filename|
+            basename = File.basename(filename, File.extname(filename))
+            basename.camelcase
+          }
       
-      # After config
-      app.after_configuration do
-        helpers_path = File.expand_path(helpers_dir, root)
-        next unless File.exists?(helpers_path)
+          # After config
+          app.after_configuration do
+            helpers_path = File.expand_path(helpers_dir, root)
+            next unless File.exists?(helpers_path)
         
-        Dir[File.join(helpers_path, helpers_filename_glob)].each do |filename|
-          module_name = helpers_filename_to_module_name_proc.call(filename)
-          next unless module_name
+            Dir[File.join(helpers_path, helpers_filename_glob)].each do |filename|
+              module_name = helpers_filename_to_module_name_proc.call(filename)
+              next unless module_name
           
-          require filename
-          next unless Object.const_defined?(module_name.to_sym)
+              require filename
+              next unless Object.const_defined?(module_name.to_sym)
           
-          helpers Object.const_get(module_name.to_sym)
+              helpers Object.const_get(module_name.to_sym)
+            end
+          end
         end
+        alias :included :registered
       end
     end
-    alias :included :registered
   end
 end

data/lib/middleman-core/core_extensions/file_watcher.rb

@@ -1,135 +1,165 @@
 require "find"
-require "middleman-core/watcher"
 require "set"
 
 # API for watching file change events
-module Middleman::CoreExtensions::FileWatcher
+module Middleman
+  module CoreExtensions
+    module FileWatcher
   
-  # Setup extension
-  class << self
+      IGNORE_LIST = [
+        /^\.sass-cache\//,
+        /^\.git\//,
+        /^\.gitignore$/,
+        /^\.DS_Store$/,
+        /^build\//,
+        /^\.rbenv-.*$/,
+        /^Gemfile$/,
+        /^Gemfile\.lock$/,
+        /~$/
+      ]
+
+      # Setup extension
+      class << self
     
-    # Once registered
-    def registered(app)
-      app.extend ClassMethods
-      app.send :include, InstanceMethods
+        # Once registered
+        def registered(app)
+          app.extend ClassMethods
+          app.send :include, InstanceMethods
       
-      # Before parsing config, load the data/ directory
-      app.before_configuration do
-        data_path = File.join(self.root, self.data_dir)
-        self.files.reload_path(data_path) if File.exists?(data_path)
-      end
+          # Before parsing config, load the data/ directory
+          app.before_configuration do
+            data_path = File.join(root, data_dir)
+            files.reload_path(data_path) if File.exists?(data_path)
+          end
       
-      # After config, load everything else
-      app.ready do
-        self.files.reload_path(self.root)
+          # After config, load everything else
+          app.ready do
+            files.reload_path(root)
+          end
+        end
+        alias :included :registered
       end
-    end
-    alias :included :registered
-  end
   
-  # Class methods
-  module ClassMethods
+      # Class methods
+      module ClassMethods
     
-    # Access the file api
-    # @return [Middleman::CoreExtensions::FileWatcher::API]
-    def files
-      @_files_api ||= API.new
-    end
-  end
+        # Access the file api
+        # @return [Middleman::CoreExtensions::FileWatcher::API]
+        def files
+          @_files_api ||= API.new
+        end
+      end
   
-  # Instance methods
-  module InstanceMethods
+      # Instance methods
+      module InstanceMethods
     
-    # Access the file api
-    # @return [Middleman::CoreExtensions::FileWatcher::API]
-    def files
-      api = self.class.files
-      api.instance ||= self
-      api
-    end
-  end
+        # Access the file api
+        # @return [Middleman::CoreExtensions::FileWatcher::API]
+        def files
+          @_files_api ||= API.new(self)
+        end
+      end
   
-  # Core File Change API class
-  class API
-    attr_accessor :instance, :known_paths
+      # Core File Change API class
+      class API
+        
+        # Initialize api and internal path cache
+        def initialize(app)
+          @app = app
+          @known_paths = Set.new
+          
+          @_changed = []
+          @_deleted = []
+        end
     
-    # Initialize api and internal path cache
-    def initialize
-      self.known_paths = Set.new
-    end
+        # Add callback to be run on file change
+        #
+        # @param [nil,Regexp] matcher A Regexp to match the change path against
+        # @return [Array<Proc>]
+        def changed(matcher=nil, &block)
+          @_changed << [block, matcher] if block_given?
+          @_changed
+        end
     
-    # Add callback to be run on file change
-    #
-    # @param [nil,Regexp] matcher A Regexp to match the change path against
-    # @return [Array<Proc>]
-    def changed(matcher=nil, &block)
-      @_changed ||= []
-      @_changed << [block, matcher] if block_given?
-      @_changed
-    end
-    
-    # Add callback to be run on file deletion
-    #
-    # @param [nil,Regexp] matcher A Regexp to match the deleted path against
-    # @return [Array<Proc>]
-    def deleted(matcher=nil, &block)
-      @_deleted ||= []
-      @_deleted << [block, matcher] if block_given?
-      @_deleted
-    end
+        # Add callback to be run on file deletion
+        #
+        # @param [nil,Regexp] matcher A Regexp to match the deleted path against
+        # @return [Array<Proc>]
+        def deleted(matcher=nil, &block)
+          @_deleted << [block, matcher] if block_given?
+          @_deleted
+        end
   
-    # Notify callbacks that a file changed
-    #
-    # @param [String] path The file that changed
-    # @return [void]
-    def did_change(path)
-      puts "== File Change: #{path}" if instance.logging? && !::Middleman::Watcher.ignore_list.any? { |r| path.match(r) }
-      self.known_paths << path
-      self.run_callbacks(path, :changed)
-    end
+        # Notify callbacks that a file changed
+        #
+        # @param [String] path The file that changed
+        # @return [void]
+        def did_change(path)
+          return if IGNORE_LIST.any? { |r| path.match(r) }
+          puts "== File Change: #{path}" if @app.logging?
+          @known_paths << path
+          self.run_callbacks(path, :changed)
+        end
 
-    # Notify callbacks that a file was deleted
-    #
-    # @param [String] path The file that was deleted
-    # @return [void]
-    def did_delete(path)
-      puts "== File Deletion: #{path}" if instance.logging? && !::Middleman::Watcher.ignore_list.any? { |r| path.match(r) }
-      self.known_paths.delete(path)
-      self.run_callbacks(path, :deleted)
-    end
+        # Notify callbacks that a file was deleted
+        #
+        # @param [String] path The file that was deleted
+        # @return [void]
+        def did_delete(path)
+          return if IGNORE_LIST.any? { |r| path.match(r) }
+          puts "== File Deletion: #{path}" if @app.logging?
+          @known_paths.delete(path)
+          self.run_callbacks(path, :deleted)
+        end
     
-    # Manually trigger update events
-    #
-    # @param [String] path The path to reload
-    # @return [void]
-    def reload_path(path)
-      subset = self.known_paths.select { |p| p.match(%r{^#{path}}) }
+        # Manually trigger update events
+        #
+        # @param [String] path The path to reload
+        # @return [void]
+        def reload_path(path)
+          relative_path = path.sub("#{@app.root}/", "")
+          subset = @known_paths.select { |p| p.match(%r{^#{relative_path}}) }
       
-      Find.find(path) do |path|
-        next if File.directory?(path)
-        relative_path = path.sub("#{self.instance.root}/", "")
-        subset.delete(relative_path) if subset.include?(relative_path)
-        self.did_change(relative_path)
-      end if File.exists?(path)
+          Find.find(path) do |path|
+            next if File.directory?(path)
+            relative_path = path.sub("#{@app.root}/", "")
+            subset.delete(relative_path)
+            self.did_change(relative_path)
+          end if File.exists?(path)
       
-      subset.each do |removed_path|
-        self.did_delete(removed_path)
-      end
-    end
-    
-  protected
-    # Notify callbacks for a file given an array of callbacks
-    #
-    # @param [String] path The file that was changed
-    # @param [Symbol] callbacks_name The name of the callbacks method
-    # @return [void]
-    def run_callbacks(path, callbacks_name)
-      return if ::Middleman::Watcher.ignore_list.any? { |r| path.match(r) }
+          subset.each do |removed_path|
+            self.did_delete(removed_path)
+          end
+        end
 
-      self.send(callbacks_name).each do |callback, matcher|
-        next if path.match(%r{^#{self.instance.build_dir}/})
-        next unless matcher.nil? || path.match(matcher)
-        self.instance.instance_exec(path, &callback)
+        # Like reload_path, but only triggers events on new files
+        #
+        # @param [String] path The path to reload
+        # @return [void]
+        def find_new_files(path)
+          relative_path = path.sub("#{@app.root}/", "")
+          subset = @known_paths.select { |p| p.match(%r{^#{relative_path}}) }
+      
+          Find.find(path) do |file|
+            next if File.directory?(file)
+            relative_path = file.sub("#{@app.root}/", "")
+            self.did_change(relative_path) unless subset.include?(relative_path)
+          end if File.exists?(path)
+        end
+    
+      protected
+        # Notify callbacks for a file given an array of callbacks
+        #
+        # @param [String] path The file that was changed
+        # @param [Symbol] callbacks_name The name of the callbacks method
+        # @return [void]
+        def run_callbacks(path, callbacks_name)
+          self.send(callbacks_name).each do |callback, matcher|
+            next if path.match(%r{^#{@app.build_dir}/})
+            next unless matcher.nil? || path.match(matcher)
+            @app.instance_exec(path, &callback)
+          end
+        end
       end
     end
   end