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

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

@@ -0,0 +1,338 @@
+# Built on Rack
+require "rack"
+require "rack/file"
+
+module Middleman
+  module CoreExtensions
+    
+    # Base helper to manipulate asset paths
+    module Request
+  
+      # Extension registered
+      class << self
+        # @private
+        def registered(app)
+          
+          # CSSPIE HTC File
+          ::Rack::Mime::MIME_TYPES['.html'] = 'text/x-component'
+
+          # Let's serve all HTML as UTF-8
+          ::Rack::Mime::MIME_TYPES['.html'] = 'text/html;charset=utf8'
+          ::Rack::Mime::MIME_TYPES['.htm'] = 'text/html;charset=utf8'
+          
+          app.extend ClassMethods
+          app.extend ServerMethods
+      
+          # Include instance methods
+          app.send :include, InstanceMethods
+        end
+        alias :included :registered
+      end
+    
+      module ClassMethods
+        # Reset Rack setup
+        #
+        # @private
+        def reset!
+          @app = nil
+          @prototype = nil
+        end
+  
+        # The shared Rack instance being build
+        #
+        # @private
+        # @return [Rack::Builder]
+        def app
+          @app ||= ::Rack::Builder.new
+        end
+  
+        # Get the static instance
+        #
+        # @private
+        # @return [Middleman::Application]
+        def inst(&block)
+          @inst ||= begin
+            mm = new(&block)
+            mm.run_hook :ready
+            mm
+          end
+        end
+  
+        # Set the shared instance
+        #
+        # @private
+        # @param [Middleman::Application] inst
+        # @return [void]
+        def inst=(inst)
+          @inst = inst
+        end
+  
+        # Return built Rack app
+        #
+        # @private
+        # @return [Rack::Builder]
+        def to_rack_app(&block)
+          inner_app = inst(&block)
+    
+          (@middleware || []).each do |m|
+            app.use(m[0], *m[1], &m[2])
+          end
+    
+          app.map("/") { run inner_app }
+    
+          (@mappings || []).each do |m|
+            app.map(m[0], &m[1])
+          end
+    
+          app
+        end
+  
+        # Prototype app. Used in config.ru
+        #
+        # @private
+        # @return [Rack::Builder]
+        def prototype
+          @prototype ||= to_rack_app
+        end
+
+        # Call prototype, use in config.ru
+        #
+        # @private
+        def call(env)
+          prototype.call(env)
+        end
+  
+        # Use Rack middleware
+        #
+        # @param [Class] middleware Middleware module
+        # @return [void]
+        def use(middleware, *args, &block)
+          @middleware ||= []
+          @middleware << [middleware, args, block]
+        end
+  
+        # Add Rack App mapped to specific path
+        #
+        # @param [String] map Path to map
+        # @return [void]
+        def map(map, &block)
+          @mappings ||= []
+          @mappings << [map, block]
+        end
+      end
+  
+      module ServerMethods
+        # Create a new Class which is based on Middleman::Application
+        # Used to create a safe sandbox into which extensions and
+        # configuration can be included later without impacting
+        # other classes and instances.
+        #
+        # @return [Class]
+        def server(&block)
+          @@servercounter ||= 0
+          @@servercounter += 1
+          const_set("MiddlemanApplication#{@@servercounter}", Class.new(Middleman::Application))
+        end
+      end
+
+      # Methods to be mixed-in to Middleman::Application
+      module InstanceMethods
+        # Backwards-compatibility with old request.path signature
+        def request
+          Thread.current[:request]
+        end
+
+        # Accessor for current path
+        # @return [String]
+        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)
+          Thread.current[:current_path] = path
+          Thread.current[:request] = ::Thor::CoreExt::HashWithIndifferentAccess.new({ 
+            :path   => path, 
+            :params => req ? ::Thor::CoreExt::HashWithIndifferentAccess.new(req.params) : {} 
+          })
+        end
+        
+        def use(*args, &block); self.class.use(*args); end
+        def map(*args, &block); self.class.map(*args, &block); end
+        
+        # Rack env
+        def env
+          Thread.current[:env]
+        end
+        def env=(value)
+          Thread.current[:env] = value
+        end
+
+        # Rack request
+        # @return [Rack::Request]
+        def req
+          Thread.current[:req]
+        end
+        def req=(value)
+          Thread.current[:req] = value
+        end
+
+        # Rack response
+        # @return [Rack::Response]
+        def res
+          Thread.current[:res]
+        end
+        def res=(value)
+          Thread.current[:res] = value
+        end
+
+        def call(env)
+          dup.call!(env)
+        end
+        
+        # Rack Interface
+        #
+        # @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
+
+          puts "== Request: #{env["PATH_INFO"]}" if logging?
+
+          # Catch :halt exceptions and use that response if given
+          catch(:halt) do
+            process_request(env, req, res)
+
+            res.status = 404
+            res.finish
+          end
+        end
+
+        # Halt the current request and return a response
+        #
+        # @param [String] response Response value
+        def halt(response)
+          throw :halt, response
+        end
+        
+        # Core response method. We process the request, check with 
+        # the sitemap, and return the correct file, response or status
+        # message.
+        #
+        # @param env
+        # @param [Rack::Request] req
+        # @param [Rack::Response] res
+        def process_request(env, req, res)
+          start_time = Time.now
+
+          # Normalize the path and add index if we're looking at a directory
+          original_path = URI.decode(env["PATH_INFO"].dup)
+          if original_path.respond_to? :force_encoding
+            original_path.force_encoding('UTF-8')
+          end
+          request_path  = full_path(original_path)
+
+          # Run before callbacks
+          run_hook :before
+
+          if original_path != request_path
+            # Get the resource object for this path
+            resource = sitemap.find_resource_by_destination_path(original_path)
+          end
+
+          # Get the resource object for this full path
+          resource ||= sitemap.find_resource_by_destination_path(request_path)
+
+          # Return 404 if not in sitemap
+          return not_found(res) unless resource && !resource.ignored?
+
+          # If this path is a static file, send it immediately
+          return send_file(resource.source_file, env, res) unless resource.template?
+
+          # Set the current path for use in helpers
+          self.current_path = request_path.dup
+
+          # Set a HTTP content type based on the request's extensions
+          content_type(res, resource.mime_type)
+
+          begin
+            # Write out the contents of the page
+            res.write resource.render
+
+            # Valid content is a 200 status
+            res.status = 200
+          rescue Middleman::CoreExtensions::Rendering::TemplateNotFound => e
+            res.write "Error: #{e.message}"
+            res.status = 500
+          end
+
+          # End the request
+          puts "== Finishing Request: #{self.current_path} (#{(Time.now - start_time).round(2)}s)" if logging?
+          halt res.finish
+        end
+      
+        # Add a new mime-type for a specific extension
+        #
+        # @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?('/')
+          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)
+          res.status == 404
+          res.write "<html><body><h1>File Not Found</h1><p>#{@request_path}</p></body>"
+          res.finish
+        end
+
+        # 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
+
+          file      = ::Rack::File.new nil
+          file.path = path
+          response = file.serving(env)
+          response[1]['Content-Encoding'] = 'gzip' if %w(.svgz).include?(extension)
+          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 res['Content-Type'] 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
+end

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

@@ -1,88 +1,92 @@
 # Routing extension
-module Middleman::CoreExtensions::Routing
+module Middleman
+  module CoreExtensions
+    module Routing
   
-  # Setup extension
-  class << self
+      # Setup extension
+      class << self
     
-    # Once registered
-    def registered(app)
-      # Include methods
-      app.send :include, InstanceMethods
-    end
+        # Once registered
+        def registered(app)
+          # Include methods
+          app.send :include, InstanceMethods
+        end
     
-    alias :included :registered
-  end
+        alias :included :registered
+      end
   
-  # Routing instance methods
-  module InstanceMethods
+      # Routing instance methods
+      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
-    #
-    # @param [String, Symbol] layout_name
-    # @return [void]
-    def with_layout(layout_name, &block)
-      old_layout = layout
+        # Takes a block which allows many pages to have the same layout
+        #
+        #   with_layout :admin do
+        #     page "/admin/"
+        #     page "/admin/login.html"
+        #   end
+        #
+        # @param [String, Symbol] layout_name
+        # @return [void]
+        def with_layout(layout_name, &block)
+          old_layout = layout
     
-      set :layout, layout_name
-      instance_exec(&block) if block_given?
-    ensure
-      set :layout, old_layout
-    end
+          set :layout, layout_name
+          instance_exec(&block) if block_given?
+        ensure
+          set :layout, old_layout
+        end
     
-    # The page method allows the layout to be set on a specific path
-    #
-    #   page "/about.html", :layout => false
-    #   page "/", :layout => :homepage_layout
-    #
-    # @param [String] url
-    # @param [Hash] opts
-    # @return [void]
-    def page(url, opts={}, &block)
-      a_block = block_given? ? block : nil
+        # The page method allows the layout to be set on a specific path
+        #
+        #   page "/about.html", :layout => false
+        #   page "/", :layout => :homepage_layout
+        #
+        # @param [String] url
+        # @param [Hash] opts
+        # @return [void]
+        def page(url, opts={}, &block)
+          a_block = block_given? ? block : nil
       
-      # Default layout
-      opts[:layout] = layout if opts[:layout].nil?
+          # Default layout
+          opts[:layout] = layout if opts[:layout].nil?
 
-      # If the url is a regexp
-      if url.is_a?(Regexp) || url.include?("*")
+          # 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|
-          { :options => opts, :blocks => [a_block] }
-        end
+            # Use the metadata loop for matching against paths at runtime
+            sitemap.provides_metadata_for_path url do |url|
+              { :options => opts, :blocks => [a_block] }
+            end
         
-        return
-      end
+            return
+          end
       
-      # Normalized path
-      url = full_path(url)
+          # Normalized path
+          url = full_path(url)
 
-      # Setup proxy
-      if opts.has_key?(:proxy)
-        proxy(url, opts[:proxy])
+          # Setup proxy
+          if opts.has_key?(:proxy)
+            proxy(url, opts[:proxy])
         
-        if opts.has_key?(:ignore) && opts[:ignore]
-          ignore(opts[:proxy])
-          opts.delete(:ignore)
-        end  
+            if opts.has_key?(:ignore) && opts[:ignore]
+              ignore(opts[:proxy])
+              opts.delete(:ignore)
+            end  
         
-        opts.delete(:proxy)
-      else
-        if opts.has_key?(:ignore) && opts[:ignore]
-          ignore(url)
-          opts.delete(:ignore)
-        end
-      end
+            opts.delete(:proxy)
+          else
+            if opts.has_key?(:ignore) && opts[:ignore]
+              ignore(url)
+              opts.delete(:ignore)
+            end
+          end
       
-      # Setup a metadata matcher for rendering those options
-      sitemap.provides_metadata_for_path url do |url|
-        { :options => opts, :blocks => [a_block] }
+          # Setup a metadata matcher for rendering those options
+          sitemap.provides_metadata_for_path url do |url|
+            { :options => opts, :blocks => [a_block] }
+          end
+        end
       end
     end
   end
-end
+end

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

@@ -1,26 +1,31 @@
+# Require lib
+require 'rack/showexceptions'
+
 # Support rack/showexceptions during development
-module Middleman::CoreExtensions::ShowExceptions
+module Middleman
+  module CoreExtensions
+    module ShowExceptions
   
-  # Setup extension
-  class << self
+      # Setup extension
+      class << self
     
-    # Once registered
-    def registered(app)
-      # Require lib
-      require 'rack/showexceptions'
-      
-      # When in dev
-      app.configure :development do
-        # Include middlemare
-        if show_exceptions
-          use ::Middleman::CoreExtensions::ShowExceptions::Middleware
+        # Once registered
+        def registered(app)
+          # When in dev
+          app.configure :development do
+            # Include middlemare
+            if show_exceptions
+              use ::Middleman::CoreExtensions::ShowExceptions::Middleware
+            end
+          end
         end
       end
-    end
-  end
   
-  # Custom exception class
-  # TODO: Style this ourselves
-  class Middleware < ::Rack::ShowExceptions
+      # Custom exception class
+      # TODO: Style this ourselves
+      class Middleware < ::Rack::ShowExceptions
+      end
+      
+    end
   end
 end

data/lib/middleman-core/core_extensions.rb

@@ -0,0 +1,39 @@
+# Rack Request
+require "middleman-core/core_extensions/request"
+
+# File Change Notifier
+require "middleman-core/core_extensions/file_watcher"
+
+# Add Builder callbacks
+require "middleman-core/core_extensions/builder"
+
+# Custom Feature API
+require "middleman-core/core_extensions/extensions"
+
+# Asset Path Pipeline
+require "middleman-core/core_extensions/assets"
+
+# Data looks at the data/ folder for YAML files and makes them available
+# to dynamic requests.
+require "middleman-core/core_extensions/data"
+
+# Parse YAML from templates
+require "middleman-core/core_extensions/front_matter"
+
+# External helpers looks in the helpers/ folder for helper modules
+require "middleman-core/core_extensions/external_helpers"
+
+# DefaultHelpers are the built-in dynamic template helpers.
+require "middleman-core/core_extensions/default_helpers"
+
+# Extended version of Padrino's rendering
+require "middleman-core/core_extensions/rendering"
+
+# Pass custom options to views
+require "middleman-core/core_extensions/routing"
+
+# Catch and show exceptions at the Rack level
+require "middleman-core/core_extensions/show_exceptions"
+
+# i18n
+require "middleman-core/core_extensions/i18n"

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

@@ -46,12 +46,9 @@ module Middleman::Extensions
             next
           end
           
-          resource.destination_path = resource.path.chomp(File.extname(index_file)) + new_index_path
+          resource.destination_path = resource.destination_path.chomp(File.extname(index_file)) + new_index_path
         end
       end
     end
   end
-  
-  # Register the extension
-  register :directory_indexes, DirectoryIndexes
 end

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

@@ -138,6 +138,16 @@ module Middleman::Extensions
         names[rand(names.size)]
       end
 
+      # Get a placeholder 140 character tweet about Philip the Purple Otter
+      # Via http://www.kevadamson.com/talking-of-design/article/140-alternative-characters-to-lorem-ipsum
+      # @return [String]
+      def tweet
+        tweets = [ 'Far away, in a forest next to a river beneath the mountains, there lived a small purple otter called Philip. Philip likes sausages. The End.',
+                   'He liked the quality sausages from Marks & Spencer but due to the recession he had been forced to shop in a less desirable supermarket. End.',
+                   'He awoke one day to find his pile of sausages missing. Roger the greedy boar with human eyes, had skateboarded into the forest & eaten them!']
+        tweets[rand(tweets.size)]
+      end
+
       # Get a placeholder email address
       # @return [String]
       def email
@@ -182,7 +192,4 @@ module Middleman::Extensions
       end
     end
   end
-  
-  # Register the extension
-  register :lorem, Lorem
 end