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

data/lib/middleman-core/extensions.rb

@@ -1,69 +1,7 @@
 module Middleman
 
-  # Backwards compatibility namespace
-  module Features
-  end
-
-  module CoreExtensions
-    # File Change Notifier
-    autoload :FileWatcher,    "middleman-core/core_extensions/file_watcher"
-
-    # In-memory Sitemap
-    autoload :Sitemap,        "middleman-core/core_extensions/sitemap"
-
-    # Add Builder callbacks
-    autoload :Builder,        "middleman-core/core_extensions/builder"
-
-    # Custom Feature API
-    autoload :Extensions,     "middleman-core/core_extensions/extensions"
-
-    # Asset Path Pipeline
-    autoload :Assets,         "middleman-core/core_extensions/assets"
-
-    # Data looks at the data/ folder for YAML files and makes them available
-    # to dynamic requests.
-    autoload :Data,           "middleman-core/core_extensions/data"
-
-    # Parse YAML from templates
-    autoload :FrontMatter,    "middleman-core/core_extensions/front_matter"
-
-    # External helpers looks in the helpers/ folder for helper modules
-    autoload :ExternalHelpers, "middleman-core/core_extensions/external_helpers"
-
-    # DefaultHelpers are the built-in dynamic template helpers.
-    autoload :DefaultHelpers, "middleman-core/core_extensions/default_helpers"
-
-    # Extended version of Padrino's rendering
-    autoload :Rendering,      "middleman-core/core_extensions/rendering"
-
-    # Pass custom options to views
-    autoload :Routing,        "middleman-core/core_extensions/routing"
-
-    # Catch and show exceptions at the Rack level
-    autoload :ShowExceptions, "middleman-core/core_extensions/show_exceptions"
-    
-    # i18n
-    autoload :I18n,           "middleman-core/core_extensions/i18n"
-  end
-  
   module Extensions
-    # Provide Apache-style index.html files for directories
-    autoload :DirectoryIndexes,    "middleman-core/extensions/directory_indexes"
-
-    # Lorem provides a handful of helpful prototyping methods to generate
-    # words, paragraphs, fake images, names and email addresses.
-    autoload :Lorem,               "middleman-core/extensions/lorem"
-
-    # AutomaticImageSizes inspects the images used in your dynamic templates
-    # and automatically adds width and height attributes to their HTML
-    # elements.
-    autoload :AutomaticImageSizes, "middleman-core/extensions/automatic_image_sizes"
 
-    # AssetHost allows you to setup multiple domains to host your static
-    # assets. Calls to asset paths in dynamic templates will then rotate
-    # through each of the asset servers to better spread the load.
-    autoload :AssetHost,           "middleman-core/extensions/asset_host"
-  
     class << self
       def registered
         @_registered ||= {}
@@ -168,8 +106,8 @@ module Middleman
     # to discover extensions and Sprockets-supporting gems.
     #
     # @private
-    # @param [Gem::Specification]
-    # @param [String] Path to look for
+    # @param [Gem::Specification] spec
+    # @param [String] path Path to look for
     # @return [Boolean] Whether the file exists
     def spec_has_file?(spec, path)
       full_path = File.join(spec.full_gem_path, path)

data/lib/middleman-core/preview_server.rb

@@ -0,0 +1,157 @@
+module Middleman
+  
+  WINDOWS = !!(RUBY_PLATFORM =~ /(mingw|bccwin|wince|mswin32)/i) unless const_defined?(:WINDOWS)
+
+  module PreviewServer
+    
+    DEFAULT_PORT = 4567
+    
+    class << self
+      
+      # Start an instance of Middleman::Application
+      # @return [void]
+      def start(options={})
+        require "webrick"
+        
+        app = ::Middleman::Application.server.inst do
+          if options[:environment]
+            set :environment, options[:environment]
+          end
+          
+          if options[:debug]
+            set :logging, true
+          end
+        end
+    
+        puts "== The Middleman is standing watch on port #{options[:port]||4567}"
+
+        @webrick ||= setup_webrick(
+          options[:host]  || "0.0.0.0",
+          options[:port]  || DEFAULT_PORT,
+          options[:debug] || false
+        )
+        
+        mount_instance(app)
+        
+        @initialized ||= false
+        unless @initialized
+          @initialized = true
+          
+          register_signal_handlers unless ::Middleman::WINDOWS
+          
+          start_file_watcher unless options[:"disable-watcher"]
+          
+          @webrick.start
+        end
+      end
+
+      # Detach the current Middleman::Application instance
+      # @return [void]
+      def stop
+        puts "== The Middleman is shutting down"
+        unmount_instance
+      end
+    
+      # Simply stop, then start the server
+      # @return [void]
+      def reload
+        stop
+        start
+      end
+
+      # Stop the current instance, exit Webrick
+      # @return [void]
+      def shutdown
+        stop
+        @webrick.shutdown
+      end
+      
+    private
+      
+      def start_file_watcher
+        # Watcher Library
+        require "listen"
+    
+        listener = Listen.to(Dir.pwd, :relative_paths => true)
+      
+        listener.change do |modified, added, removed|
+          added_and_modified = (modified + added)
+
+          if added_and_modified.length > 0
+            # See if the changed file is config.rb or lib/*.rb
+            return reload if needs_to_reload?(added_and_modified)
+
+            # Otherwise forward to Middleman
+            added_and_modified.each do |path|
+              @app.files.did_change(path)
+            end
+          end
+      
+          if removed.length > 0
+            # See if the changed file is config.rb or lib/*.rb
+            return reload if needs_to_reload?(removed)
+
+            # Otherwise forward to Middleman
+            removed.each do |path|
+              @app.files.did_delete(path)
+            end
+          end
+        end
+    
+        # Don't block this thread
+        listener.start(false)
+      end
+      
+      # Trap the interupt signal and shut down smoothly
+      # @return [void]
+      def register_signal_handlers
+        trap("INT")  { shutdown }
+        trap("TERM") { shutdown }
+        trap("QUIT") { shutdown }
+      end
+      
+      # Initialize webrick 
+      # @return [void]
+      def setup_webrick(host, port, is_logging)
+        @host = host
+        @port = port
+        
+        http_opts = {
+          :BindAddress => @host,
+          :Port        => @port,
+          :AccessLog   => []
+        }
+        
+        unless is_logging
+          http_opts[:Logger] = ::WEBrick::Log::new(nil, 0)
+        end
+      
+        ::WEBrick::HTTPServer.new(http_opts)
+      end
+    
+      # Attach a new Middleman::Application instance
+      # @param [Middleman::Application] app
+      # @return [void]
+      def mount_instance(app)
+        @app = app
+        @webrick.mount "/", ::Rack::Handler::WEBrick, @app.class.to_rack_app
+      end
+    
+      # Detach the current Middleman::Application instance
+      # @return [void]
+      def unmount_instance
+        @webrick.unmount "/"
+        @app = nil
+      end
+
+      # Whether the passed files are config.rb, lib/*.rb or helpers
+      # @param [Array<String>] paths Array of paths to check
+      # @return [Boolean] Whether the server needs to reload
+      def needs_to_reload?(paths)
+        paths.any? do |path|
+          path.match(%{^config\.rb}) || path.match(%r{^lib/^[^\.](.*)\.rb$}) || path.match(%r{^helpers/^[^\.](.*)_helper\.rb$})
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/sitemap/extensions/ignores.rb

@@ -1,86 +1,91 @@
-module Middleman::Sitemap::Extensions
+module Middleman
+
+  module Sitemap
+
+    module Extensions
   
-  module Ignores
+      module Ignores
     
-    # Setup extension
-    class << self
+        # Setup extension
+        class << self
     
-      # Once registered
-      def registered(app)
-        # Include methods
-        app.send :include, InstanceMethods
+          # Once registered
+          def registered(app)
+            # Include methods
+            app.send :include, InstanceMethods
         
-        ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
-      end
+            ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
+          end
     
-      alias :included :registered
-    end
+          alias :included :registered
+        end
     
-    module ResourceInstanceMethods
-      def ignored?
-        @app.ignore_manager.ignored?(path) || 
-        (!proxy? &&
-          @app.ignore_manager.ignored?(source_file.sub("#{@app.source_dir}/", ""))
-        )
-      end
-    end
+        # Helpers methods for Resources
+        module ResourceInstanceMethods
+      
+          # Whether the Resource is ignored
+          # @return [Boolean]
+          def ignored?
+            @app.ignore_manager.ignored?(path) || 
+            (!proxy? &&
+              @app.ignore_manager.ignored?(source_file.sub("#{@app.source_dir}/", ""))
+            )
+          end
+        end
     
-    module InstanceMethods
-      def ignore_manager
-        @_ignore_manager ||= IgnoreManager.new(self)
-      end
+        # Ignore-related instance methods
+        module InstanceMethods
+          def ignore_manager
+            @_ignore_manager ||= IgnoreManager.new(self)
+          end
       
-      def ignore(*args, &block)
-        ignore_manager.ignore(*args, &block)
-      end
-    end
+          # Ignore a path or add an ignore callback
+          # @param [String, Regexp] path Path glob expression, or path regex
+          # @return [void]
+          def ignore(path=nil, &block)
+            ignore_manager.ignore(path, &block)
+          end
+        end
     
-    class IgnoreManager
-      def initialize(app)
-        @app = app
+        # Class to handle managing ignores
+        class IgnoreManager
+          def initialize(app)
+            @app = app
 
-        @ignored_callbacks = []
-      end
+            # Array of callbacks which can ass ignored
+            @ignored_callbacks = []
+          end
       
-      # Ignore a path or add an ignore callback
-      # @param [String, Regexp] path, path glob expression, or path regex
-      # @return [void]
-      def ignore(path=nil, &block)
-        original_callback_size = @ignored_callbacks.size
+          # Ignore a path or add an ignore callback
+          # @param [String, Regexp] path Path glob expression, or path regex
+          # @return [void]
+          def ignore(path=nil, &block)
+            original_callback_size = @ignored_callbacks.size
 
-        if path.is_a? Regexp
-          @ignored_callbacks << Proc.new {|p| p =~ path }
-        elsif path.is_a? String
-          path_clean = ::Middleman::Util.normalize_path(path)
-          if path_clean.include?("*") # It's a glob
-            @ignored_callbacks << Proc.new {|p| File.fnmatch(path_clean, p) }
-          else
-            # Add a specific-path ignore unless that path is already covered
-            @ignored_callbacks << Proc.new {|p| p == path_clean } unless ignored?(path_clean)
+            if path.is_a? Regexp
+              @ignored_callbacks << Proc.new {|p| p =~ path }
+            elsif path.is_a? String
+              path_clean = ::Middleman::Util.normalize_path(path)
+              if path_clean.include?("*") # It's a glob
+                @ignored_callbacks << Proc.new {|p| File.fnmatch(path_clean, p) }
+              else
+                # Add a specific-path ignore unless that path is already covered
+                @ignored_callbacks << Proc.new {|p| p == path_clean } unless ignored?(path_clean)
+              end
+            elsif block_given?
+              @ignored_callbacks << block
+            end
           end
-        elsif block_given?
-          @ignored_callbacks << block
-        end
 
-        if @ignored_callbacks.size > original_callback_size
-          @app.sitemap.rebuild_resource_list!(:added_ignore_rule)
+          # Whether a path is ignored
+          # @param [String] path
+          # @return [Boolean]
+          def ignored?(path)
+            path_clean = ::Middleman::Util.normalize_path(path)
+            @ignored_callbacks.any? { |b| b.call(path_clean) }
+          end
         end
       end
-
-      # Whether a path is ignored
-      # @param [String] path
-      # @return [Boolean]
-      def ignored?(path)
-        path_clean = ::Middleman::Util.normalize_path(path)
-        @ignored_callbacks.any? { |b| b.call(path_clean) }
-      end
-
-      # Update the main sitemap resource list
-      # @return [void]
-      def manipulate_resource_list(resources)
-        # No op
-        resources
-      end
     end
   end
-end
+end

data/lib/middleman-core/sitemap/extensions/on_disk.rb

@@ -1,77 +1,84 @@
 require 'set'
 
-module Middleman::Sitemap::Extensions
-  class OnDisk
+module Middleman
+  
+  module Sitemap
+    
+    module Extensions
+      
+      class OnDisk
 
-    attr_accessor :sitemap
-    attr_accessor :waiting_for_ready
+        attr_accessor :sitemap
+        attr_accessor :waiting_for_ready
 
-    def initialize(sitemap)
-      @sitemap = sitemap
-      @app     = @sitemap.app
+        def initialize(sitemap)
+          @sitemap = sitemap
+          @app     = @sitemap.app
       
-      @file_paths_on_disk = Set.new
+          @file_paths_on_disk = Set.new
 
-      scoped_self = self
-      @waiting_for_ready = true
+          scoped_self = self
+          @waiting_for_ready = true
       
-      # Register file change callback
-      @app.files.changed do |file|
-        scoped_self.touch_file(file, !scoped_self.waiting_for_ready)
-      end
+          # Register file change callback
+          @app.files.changed do |file|
+            scoped_self.touch_file(file, !scoped_self.waiting_for_ready)
+          end
       
-      # Register file delete callback
-      @app.files.deleted do |file|
-        scoped_self.remove_file(file, !scoped_self.waiting_for_ready)
-      end
+          # Register file delete callback
+          @app.files.deleted do |file|
+            scoped_self.remove_file(file, !scoped_self.waiting_for_ready)
+          end
       
-      @app.ready do
-        scoped_self.waiting_for_ready = false
-        scoped_self.sitemap.rebuild_resource_list!(:on_disk_ready)
-      end
-    end
+          @app.ready do
+            scoped_self.waiting_for_ready = false
+            scoped_self.sitemap.rebuild_resource_list!(:on_disk_ready)
+          end
+        end
 
-    # Update or add an on-disk file path
-    # @param [String] file
-    # @return [Boolean]
-    def touch_file(file, rebuild=true)
-      return false if file == @app.source_dir || File.directory?(file)
+        # Update or add an on-disk file path
+        # @param [String] file
+        # @return [Boolean]
+        def touch_file(file, rebuild=true)
+          return false if file == @app.source_dir || File.directory?(file)
 
-      path = @sitemap.file_to_path(file)
-      return false unless path
+          path = @sitemap.file_to_path(file)
+          return false unless path
 
-      ignored = @app.ignored_sitemap_matchers.any? do |name, callback|
-        callback.call(file, path)
-      end
+          ignored = @app.ignored_sitemap_matchers.any? do |name, callback|
+            callback.call(file, path)
+          end
 
-      @file_paths_on_disk << file unless ignored
+          @file_paths_on_disk << file unless ignored
 
-      # Rebuild the sitemap any time a file is touched
-      # in case one of the other manipulators
-      # (like asset_hash) cares about the contents of this file,
-      # whether or not it belongs in the sitemap (like a partial)
-      @sitemap.rebuild_resource_list!(:touched_file) if rebuild
-    end
+          # Rebuild the sitemap any time a file is touched
+          # in case one of the other manipulators
+          # (like asset_hash) cares about the contents of this file,
+          # whether or not it belongs in the sitemap (like a partial)
+          @sitemap.rebuild_resource_list!(:touched_file) if rebuild
+        end
     
-    # Remove a file from the store
-    # @param [String] file
-    # @return [void]
-    def remove_file(file, rebuild=true)
-      if @file_paths_on_disk.delete?(file)
-        @sitemap.rebuild_resource_list!(:removed_file) if rebuild
-      end
-    end
+        # Remove a file from the store
+        # @param [String] file
+        # @return [void]
+        def remove_file(file, rebuild=true)
+          if @file_paths_on_disk.delete?(file)
+            @sitemap.rebuild_resource_list!(:removed_file) if rebuild
+          end
+        end
    
-    # Update the main sitemap resource list
-    # @return [void]
-    def manipulate_resource_list(resources)
-      resources + @file_paths_on_disk.map do |file|
-        ::Middleman::Sitemap::Resource.new(
-          @sitemap,
-          @sitemap.file_to_path(file),
-          File.expand_path(file, @app.root)
-        )
+        # Update the main sitemap resource list
+        # @return [void]
+        def manipulate_resource_list(resources)
+          resources + @file_paths_on_disk.map do |file|
+            ::Middleman::Sitemap::Resource.new(
+              @sitemap,
+              @sitemap.file_to_path(file),
+              File.expand_path(file, @app.root)
+            )
+          end
+        end
       end
     end
   end
-end
+end