middleman-core 3.0.14 → 3.1.0.beta.1

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

@@ -1,6 +1,7 @@
 # Built on Rack
 require "rack"
 require "rack/file"
+require "rack/lint"
 
 module Middleman
   module CoreExtensions
@@ -36,15 +37,7 @@ module Middleman
         #
         # @private
         def reset!
-          @app = nil
-        end
-
-        # The shared Rack instance being build
-        #
-        # @private
-        # @return [Rack::Builder]
-        def app
-          @app ||= ::Rack::Builder.new
+          @rack_app = nil
         end
 
         # Get the static instance
@@ -73,19 +66,23 @@ module Middleman
         # @private
         # @return [Rack::Builder]
         def to_rack_app(&block)
-          inner_app = inst(&block)
+          @rack_app ||= begin
+            app = ::Rack::Builder.new
+            app.use Rack::Lint
 
-          (@middleware || []).each do |m|
-            app.use(m[0], *m[1], &m[2])
-          end
+            Array(@middleware).each do |klass, options, blockm|
+              app.use(klass, *options, &block)
+            end
 
-          app.map("/") { run inner_app }
+            inner_app = inst(&block)
+            app.map("/") { run inner_app }
 
-          (@mappings || []).each do |m|
-            app.map(m[0], &m[1])
-          end
+            Array(@mappings).each do |path, block|
+              app.map(path, &block)
+            end
 
-          app
+            app
+          end
         end
 
         # Prototype app. Used in config.ru
@@ -152,37 +149,39 @@ module Middleman
       # Methods to be mixed-in to Middleman::Application
       module InstanceMethods
         # Backwards-compatibility with old request.path signature
-        attr_reader :request
+        def request
+          Thread.current[:legacy_request]
+        end
 
         # Accessor for current path
         # @return [String]
-        attr_reader :current_path
+        def current_path
+          Thread.current[:current_path]
+        end
 
         # Set the current path
         #
         # @param [String] path The new current path
         # @return [void]
         def current_path=(path)
-          @current_path = path
-          @request = ::Thor::CoreExt::HashWithIndifferentAccess.new({
+          Thread.current[:current_path] = path
+          Thread.current[:legacy_request] = ::Thor::CoreExt::HashWithIndifferentAccess.new({
             :path   => path,
             :params => req ? ::Thor::CoreExt::HashWithIndifferentAccess.new(req.params) : {}
           })
         end
 
-        def use(*args, &block); self.class.use(*args, &block); end
-        def map(*args, &block); self.class.map(*args, &block); end
-
-        # Rack env
-        attr_accessor :env
+        delegate :use, :to => :"self.class" 
+        delegate :map, :to => :"self.class" 
 
         # Rack request
         # @return [Rack::Request]
-        attr_accessor :req
-
-        # Rack response
-        # @return [Rack::Response]
-        attr_accessor :res
+        def req
+          Thread.current[:req]
+        end
+        def req=(value)
+          Thread.current[:req] = value
+        end
 
         def call(env)
           dup.call!(env)
@@ -192,10 +191,9 @@ module Middleman
         #
         # @param env Rack environment
         def call!(env)
-          self.env = env
           # Store environment, request and response for later
           self.req = req = ::Rack::Request.new(env)
-          self.res = res = ::Rack::Response.new
+          res = ::Rack::Response.new
 
           logger.debug "== Request: #{env["PATH_INFO"]}"
 
@@ -225,7 +223,7 @@ module Middleman
         # @param [Rack::Response] res
         def process_request(env, req, res)
           start_time = Time.now
-          @current_path = nil
+          current_path = nil
 
           request_path = URI.decode(env["PATH_INFO"].dup)
           if request_path.respond_to? :force_encoding
@@ -243,12 +241,11 @@ module Middleman
           return not_found(res, request_path) unless resource && !resource.ignored?
 
           # If this path is a binary file, send it immediately
-          return send_file(resource.source_file, env, res) if resource.binary?
+          return send_file(resource, env) if resource.binary?
 
           current_path = resource.destination_path
 
-          # Set a HTTP content type based on the request's extensions
-          content_type(res, mime_type(resource.ext))
+          res['Content-Type'] = resource.content_type || 'text/plain'
 
           begin
             # Write out the contents of the page
@@ -275,17 +272,14 @@ module Middleman
         # @param [Symbol] type File extension
         # @param [String] value Mime type
         # @return [void]
-        def mime_type(type, value=nil)
-          return type if type.nil? || type.to_s.include?('/')
-          return ::Rack::Mime.mime_type('.txt') if type.empty?
+        def mime_type(type, value)
           type = ".#{type}" unless type.to_s[0] == ?.
-          return ::Rack::Mime.mime_type(type, nil) unless value
           ::Rack::Mime::MIME_TYPES[type] = value
         end
 
         # Halt request and return 404
         def not_found(res, path)
-          res.status == 404
+          res.status = 404
           res.write "<html><body><h1>File Not Found</h1><p>#{path}</p></body>"
           res.finish
         end
@@ -293,40 +287,14 @@ module Middleman
         # Immediately send static file
         #
         # @param [String] path File to send
-        def send_file(path, env, res)
-          extension = File.extname(path)
-          matched_mime = mime_type(extension)
-          matched_mime = "application/octet-stream" if matched_mime.nil?
-          content_type res, matched_mime
-
+        def send_file(resource, env)
           file      = ::Rack::File.new nil
-          file.path = path
+          file.path = resource.source_file
           response = file.serving(env)
-          response[1]['Content-Encoding'] = 'gzip' if %w(.svgz).include?(extension)
+          response[1]['Content-Encoding'] = 'gzip' if %w(.svgz .gz).include?(resource.ext)
+          response[1]['Content-Type'] = resource.content_type || "application/octet-stream"
           halt response
         end
-
-        # Set the content type for the current request
-        #
-        # @param [String] type Content type
-        # @param [Hash] params
-        # @return [void]
-        def content_type(res, type, params={})
-          return unless type
-          default = params.delete :default
-          mime_type = mime_type(type) || default
-          throw "Unknown media type: %p" % type if mime_type.nil?
-          mime_type = mime_type.dup
-          unless params.include? :charset
-            params[:charset] = params.delete('charset') || "utf-8"
-          end
-          params.delete :charset if mime_type.include? 'charset'
-          unless params.empty?
-            mime_type << (mime_type.include?(';') ? ', ' : ';')
-            mime_type << params.map { |kv| kv.join('=') }.join(', ')
-          end
-          res['Content-Type'] = mime_type
-        end
       end
     end
   end

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

@@ -2,22 +2,6 @@
 module Middleman
   module CoreExtensions
     module Routing
-
-      # Setup extension
-      class << self
-
-        # Once registered
-        def registered(app)
-          # Include methods
-          app.send :include, InstanceMethods
-        end
-
-        alias :included :registered
-      end
-
-      # Routing instance methods
-      module InstanceMethods
-
         # Takes a block which allows many pages to have the same layout
         #
         #   with_layout :admin do
@@ -28,12 +12,12 @@ module Middleman
         # @param [String, Symbol] layout_name
         # @return [void]
         def with_layout(layout_name, &block)
-          old_layout = layout
+          old_layout = config[:layout]
 
-          set :layout, layout_name
+          config[:layout] = layout_name
           instance_exec(&block) if block_given?
         ensure
-          set :layout, old_layout
+          config[:layout] = old_layout
         end
 
         # The page method allows the layout to be set on a specific path
@@ -48,13 +32,13 @@ module Middleman
           blocks = Array(block)
 
           # Default layout
-          opts[:layout] = layout if opts[:layout].nil?
+          opts[:layout] = config[:layout] if opts[:layout].nil?
 
           # If the url is a regexp
           if url.is_a?(Regexp) || url.include?("*")
 
             # Use the metadata loop for matching against paths at runtime
-            sitemap.provides_metadata_for_path url do |url|
+            sitemap.provides_metadata_for_path(url) do |_|
               { :options => opts, :blocks => blocks }
             end
 
@@ -64,7 +48,7 @@ module Middleman
           # Normalized path
           url = '/' + Middleman::Util.normalize_path(url)
           if url.end_with?('/') || File.directory?(File.join(source_dir, url))
-            url = File.join(url, index_file)
+            url = File.join(url, config[:index_file])
           end
 
           # Setup proxy
@@ -77,11 +61,10 @@ module Middleman
           end
 
           # Setup a metadata matcher for rendering those options
-          sitemap.provides_metadata_for_path url do |url|
+          sitemap.provides_metadata_for_path(url) do |_|
             { :options => opts, :blocks => blocks }
           end
         end
-      end
     end
   end
 end

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

@@ -11,21 +11,19 @@ module Middleman
 
         # Once registered
         def registered(app)
+          # Whether to catch and display exceptions
+          # @return [Boolean]
+          app.config.define_setting :show_exceptions, true, 'Whether to catch and display exceptions'
+
           # When in dev
           app.configure :development do
             # Include middlemare
-            if show_exceptions
-              use ::Middleman::CoreExtensions::ShowExceptions::Middleware
+            if config[:show_exceptions]
+              use ::Rack::ShowExceptions
             end
           end
         end
       end
-
-      # Custom exception class
-      # TODO: Style this ourselves
-      class Middleware < ::Rack::ShowExceptions
-      end
-
     end
   end
 end

data/lib/middleman-core/extensions.rb

@@ -100,4 +100,39 @@ module Middleman
       File.exists?(full_path)
     end
   end
+
+  class Extension
+    class << self
+      def config
+        @_config ||= ::Middleman::Configuration::ConfigurationManager.new
+      end
+
+      def option(key, default=nil, description=nil)
+        config.define_setting(key, default, description)
+      end
+    end
+
+    attr_accessor :app, :options
+
+    def initialize(klass, options_hash={})
+      @options = self.class.config.dup
+      @options.finalize!
+
+      options_hash.each do |k, v|
+        @options[k] = v
+      end
+
+      yield @options if block_given?
+
+      ext = self
+      klass.after_configuration do
+        ext.app = self
+        ext.after_configuration
+      end
+    end
+
+    def after_configuration
+      nil
+    end
+  end
 end

data/lib/middleman-core/logger.rb

@@ -1,5 +1,6 @@
 # Use the Ruby/Rails logger
 require 'active_support/core_ext/logger'
+require 'thread'
 
 module Middleman
 
@@ -16,6 +17,14 @@ module Middleman
       if @instrumenting != false
         ::ActiveSupport::Notifications.subscribe(/\.middleman$/, self)
       end
+
+      @mutex = Mutex.new
+    end
+
+    def add(*args)
+      @mutex.synchronize do
+        super
+      end
     end
 
     def call(message, *args)

data/lib/middleman-core/meta_pages.rb

@@ -0,0 +1,93 @@
+require 'rack/builder'
+require 'rack/static'
+require 'tilt'
+require 'middleman-core/meta_pages/sitemap_tree'
+require 'middleman-core/meta_pages/config_setting'
+
+module Middleman
+  module MetaPages
+    # Metadata pages to be served in preview, in order to present information about the Middleman
+    # application and its configuration. Analogous to Firefox/Chrome's "about:" pages.
+    #
+    # Built using a ghetto little Rack web framework cobbled together because I didn't want to depend
+    # on Sinatra or figure out how to host Middleman inside Middleman.
+    class Application
+      def initialize(middleman)
+        # Hold a reference to the middleman application
+        @middleman = middleman
+
+        meta_pages = self
+        @rack_app = Rack::Builder.new do
+          # Serve assets from metadata/assets
+          use Rack::Static, :urls => ["/assets"], :root => File.join(File.dirname(__FILE__), 'meta_pages')
+
+          map '/' do
+            run meta_pages.method(:index)
+          end
+
+          map '/sitemap' do
+            run meta_pages.method(:sitemap)
+          end
+
+          map '/config' do
+            run meta_pages.method(:config)
+          end
+        end
+      end
+
+      def call(*args)
+        @rack_app.call(*args)
+      end
+
+      # The index page
+      def index(env)
+        template('index.html.erb')
+      end
+
+      # Inspect the sitemap
+      def sitemap(env)
+        resources = @middleman.inst.sitemap.resources(true)
+
+        sitemap_tree = SitemapTree.new
+
+        resources.each do |resource|
+          sitemap_tree.add_resource resource
+        end
+
+        template('sitemap.html.erb', :sitemap_tree => sitemap_tree)
+      end
+
+      # Inspect configuration
+      def config(env)
+        global_config = @middleman.inst.config.all_settings.map {|c| ConfigSetting.new(c) }
+        extension_config = Hash[@middleman.inst.extensions.map do |ext_name, extension|
+                                  opts = if extension.is_a?(::Middleman::Extension)
+                                           extension.options.all_settings.map {|c| ConfigSetting.new(c) }
+                                         else 
+                                           nil
+                                         end
+                                  [ext_name, opts]
+                                end]
+
+        template('config.html.erb', 
+                 :global_config => global_config,
+                 :extension_config => extension_config, 
+                 :registered_extensions => Middleman::Extensions.registered.dup)
+      end
+
+      private
+
+      # Render a template with the given name and locals
+      def template(template_name, locals={})
+        template_path = File.join(File.dirname(__FILE__), 'meta_pages', 'templates', template_name)
+        content = Tilt.new(template_path).render(nil, locals)
+        response(content)
+      end
+
+      # Respond to an HTML request
+      def response(content)
+        [ 200, {"Content-Type" => "text/html"}, Array(content) ]
+      end
+    end
+  end
+end