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

data/lib/middleman-core/application.rb

@@ -1,7 +1,3 @@
-# Built on Rack
-require "rack"
-require "rack/file"
-
 # Using Tilt for templating
 require "tilt"
 
@@ -12,6 +8,8 @@ require "active_support/json"
 require "middleman-core/vendor/hooks-0.2.0/lib/hooks"
 
 require "middleman-core/sitemap"
+
+require "middleman-core/core_extensions"
   
 # Core Middleman Class
 module Middleman
@@ -26,97 +24,6 @@ module Middleman
     define_hook :ready
   
     class << self
-    
-      # 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
-      # @return [void]
-      def use(middleware, *args, &block)
-        @middleware ||= []
-        @middleware << [middleware, args, block]
-      end
-    
-      # Add Rack App mapped to specific path
-      #
-      # @param [String] Path to map
-      # @return [void]
-      def map(map, &block)
-        @mappings ||= []
-        @mappings << [map, block]
-      end
-    
       # Mix-in helper methods. Accepts either a list of Modules
       # and/or a block to be evaluated
       # @return [void]
@@ -135,8 +42,8 @@ module Middleman
     
       # Set class-wide defaults
       #
-      # @param [Symbol] Unique key name
-      # @param Default value
+      # @param [Symbol] key Unique key name
+      # @param value Default value
       # @return [void]
       def set(key, value=nil, &block)
         @defaults ||= {}
@@ -145,11 +52,13 @@ module Middleman
         @inst.set(key, value, &block) if @inst
       end
     end
-  
+    
+    delegate :helpers, :to => :"self.class"
+    
     # Set attributes (global variables)
     #
-    # @param [Symbol] Name of the attribue
-    # @param Attribute value
+    # @param [Symbol] key Name of the attribue
+    # @param value Attribute value
     # @return [void]
     def set(key, value=nil, &block)
       setter = "#{key}=".to_sym
@@ -212,6 +121,9 @@ module Middleman
   
     # Activate custom features and extensions
     include Middleman::CoreExtensions::Extensions
+    
+    # Basic Rack Request Handling
+    include Middleman::CoreExtensions::Request
   
     # Handle exceptions
     register Middleman::CoreExtensions::ShowExceptions
@@ -224,13 +136,14 @@ module Middleman
   
     # Activate Data package
     register Middleman::CoreExtensions::Data
-  
-    # Parse YAML from templates
-    register Middleman::CoreExtensions::FrontMatter
 
     # Setup custom rendering
     register Middleman::CoreExtensions::Rendering
   
+    # Parse YAML from templates. Must be before sitemap so sitemap
+    # extensions see updated frontmatter!
+    register Middleman::CoreExtensions::FrontMatter
+
     # Sitemap
     register Middleman::Sitemap
   
@@ -250,34 +163,34 @@ module Middleman
     register Middleman::CoreExtensions::I18n
   
     # Built-in Extensions
-    Middleman::Extensions.register(:directory_indexes) {
-      Middleman::Extensions::DirectoryIndexes }
-    Middleman::Extensions.register(:lorem) {
-      Middleman::Extensions::Lorem }
-    Middleman::Extensions.register(:automatic_image_sizes) {
-      Middleman::Extensions::AutomaticImageSizes }
-    Middleman::Extensions.register(:asset_host) {
-      Middleman::Extensions::AssetHost }
-  
-    # Backwards-compatibility with old request.path signature
-    attr :request
-  
-    # Accessor for current path
-    # @return [String]
-    def current_path
-      @_current_path
+    
+    # Provide Apache-style index.html files for directories
+    Middleman::Extensions.register(:directory_indexes) do
+      require "middleman-core/extensions/directory_indexes"
+      Middleman::Extensions::DirectoryIndexes 
     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({ 
-        :path   => path, 
-        :params => req ? ::Thor::CoreExt::HashWithIndifferentAccess.new(req.params) : {} 
-      })
+    
+    # Lorem provides a handful of helpful prototyping methods to generate
+    # words, paragraphs, fake images, names and email addresses.
+    Middleman::Extensions.register(:lorem) do
+      require "middleman-core/extensions/lorem"
+      Middleman::Extensions::Lorem 
+    end
+    
+    # AutomaticImageSizes inspects the images used in your dynamic templates
+    # and automatically adds width and height attributes to their HTML
+    # elements.
+    Middleman::Extensions.register(:automatic_image_sizes) do
+      require "middleman-core/extensions/automatic_image_sizes"
+      Middleman::Extensions::AutomaticImageSizes
+    end
+    
+    # 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.
+    Middleman::Extensions.register(:asset_host) do
+      require "middleman-core/extensions/asset_host"
+      Middleman::Extensions::AssetHost 
     end
   
     # Initialize the Middleman project
@@ -311,60 +224,7 @@ module Middleman
       @_cache ||= ::Middleman::Util::Cache.new
     end
     delegate :cache, :to => :"self.class"
-  
-    # Rack env
-    attr :env
-  
-    # Rack request
-    # @return [Rack::Request]
-    attr :req
-  
-    # Rack response
-    # @return [Rack::Response]
-    attr :res
-  
-    # Rack Interface
-    #
-    # @private
-    # @param Rack environment
-    def call(env)
-      # Store environment, request and response for later
-      @env = env
-      @req = Rack::Request.new(env)
-      @res = Rack::Response.new
 
-      if env["PATH_INFO"] == "/__middleman__"
-        if env["REQUEST_METHOD"] == "POST"
-          if req.params.has_key?("change")
-            self.files.did_change(req.params["change"])
-          elsif req.params.has_key?("delete")
-            self.files.did_delete(req.params["delete"])
-          end
-        end
-      
-        res.status = 200
-        return res.finish
-      end
-
-      puts "== Request: #{env["PATH_INFO"]}" if logging?
-    
-      # Catch :halt exceptions and use that response if given
-      catch(:halt) do
-        process_request
-
-        res.status = 404
-        res.finish
-      end
-    end
-  
-    # Halt the current request and return a response
-    #
-    # @private
-    # @param [String] Response value
-    def halt(response)
-      throw :halt, response
-    end
-  
     # Whether we're in development mode
     # @return [Boolean] If we're in dev mode
     def development?; environment == :development; end
@@ -372,55 +232,6 @@ module Middleman
     # Whether we're in build mode
     # @return [Boolean] If we're in build mode
     def build?; environment == :build; end
-  
-    # Core response method. We process the request, check with the sitemap,
-    # and return the correct file, response or status message.
-    #
-    # @private
-    def process_request
-      # Normalize the path and add index if we're looking at a directory
-      @original_path = env["PATH_INFO"].dup
-      @escaped_path  = @original_path.gsub("%20", " ")
-      @request_path  = full_path(@escaped_path)
-    
-      # Run before callbacks
-      run_hook :before
-
-      if @escaped_path != @request_path
-        # Get the resource object for this path
-        resource = sitemap.find_resource_by_destination_path(@escaped_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 unless resource && !resource.ignored?
-
-      # If this path is a static file, send it immediately
-      return send_file(resource.source_file) 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 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}" if logging?
-      halt res.finish
-    end
 
     # Backwards compatibilty with old Sinatra template interface
     #
@@ -451,108 +262,5 @@ module Middleman
       end
     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
-  
-  protected
-
-    # Halt request and return 404
-    def not_found
-      @res.status == 404
-      @res.write "<html><body><h1>File Not Found</h1><p>#{@request_path}</p></body>"
-      @res.finish
-    end
-  
-    delegate :helpers, :use, :map, :to => :"self.class"
-  
-    # Immediately send static file
-    #
-    # @param [String] path File to send
-    def send_file(path)
-      extension = File.extname(path)
-      matched_mime = mime_type(extension)
-      matched_mime = "application/octet-stream" if matched_mime.nil?
-      content_type 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(type = nil, 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
-  
-  class << self
-    # 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 ||= 1
-      @@servercounter += 1
-      const_set("MiddlemanApplication#{@@servercounter}", Class.new(Middleman::Application))
-    end
-
-    # Creates a new Rack::Server
-    #
-    # @param [Hash] options to pass to Rack::Server.new
-    # @return [Rack::Server]
-    def start_server(options={})
-      require "webrick"
-
-      opts = {
-        :Port      => options[:port] || 4567,
-        :Host      => options[:host] || "0.0.0.0",
-        :AccessLog => []
-      }
-
-      # opts[:Logger] = WEBrick::Log::new("/dev/null", 7) if !options[:logging]
-
-      app_class = options[:app] ||= ::Middleman.server.inst
-      opts[:app] = app_class
-
-      # Disable for Beta 1. See if people notice.
-      require "thin"
-      ::Thin::Logging.silent = !options[:logging]
-      opts[:server] = 'thin'
-      # opts[:server] = 'webrick'
-
-      server = ::Rack::Server.new(opts)
-      server.start
-      server
-    end
   end
 end

data/lib/middleman-core/cli/build.rb

@@ -61,7 +61,7 @@ module Middleman::Cli
       #
       # @return [Middleman::Application]
       def shared_instance(verbose=false)
-        @_shared_instance ||= ::Middleman.server.inst do
+        @_shared_instance ||= ::Middleman::Application.server.inst do
           set :environment, :build
           set :logging,     verbose
         end
@@ -104,7 +104,8 @@ module Middleman::Cli
       output_file = File.join(build_dir, resource.destination_path)
 
       begin
-        response = self.class.shared_rack.get(resource.destination_path.gsub(/\s/, "%20"))
+        response = self.class.shared_rack.get(URI.escape(resource.destination_path))
+
         if response.status == 200
           create_file(output_file, response.body, { :force => true })
         else
@@ -196,19 +197,25 @@ module Middleman::Cli
       sort_order = %w(.png .jpeg .jpg .gif .bmp .svg .svgz .ico .woff .otf .ttf .eot .js .css)
       
       # Pre-request CSS to give Compass a chance to build sprites
+      puts "== Prerendering CSS" if @app.logging?
+
       @app.sitemap.resources.select do |resource|
         resource.ext == ".css"
       end.each do |resource|
-        Middleman::Cli::Build.shared_rack.get(resource.destination_path.gsub(/\s/, "%20"))
+        Middleman::Cli::Build.shared_rack.get(URI.escape(resource.destination_path))
       end
       
+      puts "== Checking for Compass sprites" if @app.logging?
+
       # Double-check for compass sprites
-      @app.files.reload_path(File.join(@app.source_dir, @app.images_dir))
+      @app.files.find_new_files(File.join(@app.source_dir, @app.images_dir))
 
       # Sort paths to be built by the above order. This is primarily so Compass can
       # find files in the build folder when it needs to generate sprites for the
       # css files
 
+      puts "== Building files" if @app.logging?
+
       resources = @app.sitemap.resources.sort do |a, b|
         a_idx = sort_order.index(a.ext) || 100
         b_idx = sort_order.index(b.ext) || 100

data/lib/middleman-core/cli/bundler.rb

@@ -0,0 +1,40 @@
+# CLI Module
+module Middleman::Cli
+  
+  # A initializing Bundler
+  class Bundle < Thor
+    include Thor::Actions
+    check_unknown_options!
+    
+    namespace :bundle
+    
+    desc "bundle", "Setup initial bundle", :hide => true
+    
+    # The setup task
+    def bundle
+      run('bundle install --without development test')#, :capture => true)
+    end
+  end
+  
+  # A upgrading Bundler
+  class Upgrade < Thor
+    include Thor::Actions
+    check_unknown_options!
+    
+    namespace :upgrade
+
+    desc "upgrade", "Upgrade installed bundle"
+
+    # The upgrade task
+    def upgrade
+      inside(ENV["MM_ROOT"]) do
+        run('bundle update')#, :capture => true)
+      end
+    end
+  end
+  
+  # Map "u" to "upgrade"
+  Base.map({
+    "u" => "upgrade"
+  })
+end

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

@@ -0,0 +1,36 @@
+# CLI Module
+module Middleman::Cli
+  
+  # A thor task for creating new projects
+  class Extension < Thor
+    include Thor::Actions
+    
+    check_unknown_options!
+    
+    namespace :extension
+    
+    # Required path for the new project to be generated
+    argument :name, :type => :string
+
+    desc "extension NAME [options]", "Create Middleman extension scaffold NAME"
+    
+    # The extension task
+    # @param [String] name
+    def extension
+      template "Rakefile", File.join(name, "Rakefile")
+      template "gemspec", File.join(name, "#{name}.gemspec")
+      template "Gemfile", File.join(name, "Gemfile")
+      template "lib/middleman_extension.rb", File.join(name, "lib", "middleman_extension.rb")
+      template "lib/lib.rb", File.join(name, "lib", "#{name}.rb")
+      template "features/support/env.rb", File.join(name, "features", "support", "env.rb")
+      empty_directory File.join(name, "fixtures")
+    end
+    
+    # Template files are relative to this file
+    # @return [String]
+    def self.source_root
+      File.join(File.dirname(__FILE__), "..", "templates", "extension")
+    end
+
+  end
+end

data/lib/middleman-core/cli/server.rb

@@ -1,4 +1,4 @@
-require "middleman-core/watcher"
+require "middleman-core/preview_server"
 
 # CLI Module
 module Middleman::Cli
@@ -50,7 +50,7 @@ module Middleman::Cli
       }
       
       puts "== The Middleman is loading"
-      Middleman::Watcher.start(params)
+      Middleman::PreviewServer.start(params)
     end
   end
 

data/lib/middleman-core/cli.rb

@@ -5,12 +5,6 @@ require "thor/group"
 # CLI Module
 module Middleman::Cli
   
-  module Cli
-    autoload :Build,        "middleman-core/cli/build"
-    autoload :Init,         "middleman-core/cli/init"
-    autoload :Server,       "middleman-core/cli/server"
-  end
-  
   # The base task from which everything else etends
   class Base < Thor
     
@@ -73,5 +67,7 @@ end
 
 # Include the core CLI items
 require "middleman-core/cli/init"
+require "middleman-core/cli/bundler"
+require "middleman-core/cli/extension"
 require "middleman-core/cli/server"
 require "middleman-core/cli/build"

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

@@ -1,39 +1,43 @@
-# Base helper to manipulate asset paths
-module Middleman::CoreExtensions::Assets
+module Middleman
+  module CoreExtensions
+    
+    # Base helper to manipulate asset paths
+    module Assets
   
-  # Extension registered
-  class << self
-    # @private
-    def registered(app)
-      # Disable Padrino cache buster
-      app.set :asset_stamp, false
+      # Extension registered
+      class << self
+        def registered(app)
+          # Disable Padrino cache buster
+          app.set :asset_stamp, false
       
-      # Include helpers
-      app.send :include, InstanceMethod
-    end
-    alias :included :registered
-  end
+          # Include helpers
+          app.send :include, InstanceMethod
+        end
+        alias :included :registered
+      end
   
-  # Methods to be mixed-in to Middleman::Application
-  module InstanceMethod
+      # Methods to be mixed-in to Middleman::Application
+      module InstanceMethod
     
-    # Get the URL of an asset given a type/prefix
-    #
-    # @param [String] path The path (such as "photo.jpg")
-    # @param [String] prefix The type prefix (such as "images")
-    # @return [String] The fully qualified asset url
-    def asset_url(path, prefix="")
-      # Don't touch assets which already have a full path
-      if path.include?("//")
-        path
-      else # rewrite paths to use their destination path
-        path = File.join(prefix, path)
-        if resource = sitemap.find_resource_by_path(path)
-          path = resource.destination_path
-        end
+        # Get the URL of an asset given a type/prefix
+        #
+        # @param [String] path The path (such as "photo.jpg")
+        # @param [String] prefix The type prefix (such as "images")
+        # @return [String] The fully qualified asset url
+        def asset_url(path, prefix="")
+          # Don't touch assets which already have a full path
+          if path.include?("//")
+            path
+          else # rewrite paths to use their destination path
+            path = File.join(prefix, path)
+            if resource = sitemap.find_resource_by_path(path)
+              path = resource.destination_path
+            end
 
-        File.join(http_prefix, path)
+            File.join(http_prefix, path)
+          end
+        end
       end
     end
   end
-end
+end