RubyGems - middleman - Versions diffs - 2.0.16.1 → 3.0.0.alpha.2 - Mend

middleman 2.0.16.1 → 3.0.0.alpha.2

Files changed (259) hide show

data/lib/middleman/base.rb CHANGED Viewed

@@ -1,137 +1,70 @@
-# require 'sinatra/synchrony'
+require "rack"
+require "tilt"
 require "i18n"
+require "middleman/vendor/hooks-0.2.0/lib/hooks"
 require "active_support"
 require "active_support/json"
-require "active_support/core_ext/class/attribute_accessors"
+require "active_support/core_ext/string/inflections"
-module Middleman::Base
+class Middleman::Base
+  include Hooks
+  define_hook :before
+  define_hook :ready
+  define_hook :initialized
   class << self
-    def registered(app)
-      # app.register ::Sinatra::Synchrony
-      app.extend ClassMethods
-      app.send :include, InstanceMethods
-      # Basic Sinatra config
-      app.set :app_file,    __FILE__
-      app.set :root,        Dir.pwd
-      app.set :sessions,    false
-      app.set :logging,     false
-      app.set :environment, (ENV['MM_ENV'] && ENV['MM_ENV'].to_sym) || :development
-      # Middleman-specific options
-      app.set :index_file,  "index.html"  # What file responds to folder requests
-                                      # Such as the homepage (/) or subfolders (/about/)
-      # These directories are passed directly to Compass
-      app.set :js_dir,      "javascripts" # Where to look for javascript files
-      app.set :css_dir,     "stylesheets" # Where to look for CSS files
-      app.set :images_dir,  "images"      # Where to look for images
-      app.set :build_dir,   "build"       # Which folder are builds output to
-      app.set :http_prefix, nil           # During build, add a prefix for absolute paths
-      # Pass all request to Middleman, even "static" files
-      app.set :static, false
-      app.set :views, "source"
-      # Add Builder Callbacks
-      app.register Middleman::CoreExtensions::Builder
-      # Add Rack::Builder.map to Sinatra
-      app.register Middleman::CoreExtensions::RackMap
-      # Activate custom features
-      app.register Middleman::CoreExtensions::Features
-      # Activate Yaml Data package
-      app.register Middleman::CoreExtensions::Data
-      # Setup custom rendering
-      app.register Middleman::CoreExtensions::Rendering
-      # Compass framework
-      app.register Middleman::CoreExtensions::Compass
-      # Sprockets asset handling
-      app.register Middleman::CoreExtensions::Sprockets
-      # Setup asset path pipeline
-      app.register Middleman::CoreExtensions::Assets
-      # Activate built-in helpers
-      app.register Middleman::CoreExtensions::DefaultHelpers
-      # with_layout and page routing
-      app.register Middleman::CoreExtensions::Routing
-      # Parse YAML from templates
-      app.register Middleman::CoreExtensions::FrontMatter
-      app.set :default_features, [
-        :lorem
-      ]
-      # Default layout name
-      app.set :layout, :layout
-      # This will match all requests not overridden in the project's config.rb
-      app.not_found do
-        process_request
-      end
-      # Custom 404 handler (to be styled)
-      app.error Sinatra::NotFound do
-        content_type 'text/html'
-        "<html><body><h1>File Not Found</h1><p>#{request.path_info}</p></body>"
-      end
-      # See if Tilt cannot handle this file
-      app.before_processing(:base) do |result|
-        request_path = request.path_info.gsub("%20", " ")
-        should_be_ignored = !(request["is_proxy"]) && settings.excluded_paths.include?("/#{request_path}")
-        if result && !should_be_ignored
-          extensionless_path, template_engine = result
+    def reset!
+      @app = nil
+      @prototype = nil
+    end
+    def app
+      @app ||= Rack::Builder.new
+    end
+    def inst(&block)
+      @inst ||= new(&block)
+    end
+    def to_rack_app(&block)
+      inner_app = inst(&block)
+      app.map("/") { run inner_app }
+      app
+    end
+    def prototype
+      @prototype ||= app.to_app
+    end
-          # Return static files
-          if !::Tilt.mappings.has_key?(template_engine.to_s)
-            matched_mime = mime_type(File.extname(request_path))
-            matched_mime = "application/octet-stream" if matched_mime.nil?
-            content_type matched_mime, :charset => 'utf-8'
-            status 200
-            send_file File.join(settings.views, request_path)
-            false
-          else
-            true
-          end
-        else
-          if !%w(favicon.ico).include?(request_path)
-            $stderr.puts "File not found: #{request_path}"
-          end
-          status 404
-          false
-        end
-      end
+    def call(env)
+      prototype.call(env)
+    end
+    def use(middleware, *args, &block)
+      app.use(middleware, *args, &block)
     end
-    alias :included :registered
-  end
-  module ClassMethods
-    # Override Sinatra's set to accept a block
-    # Specifically for the asset_host feature
-    def set(option, value = (not_set = true), ignore_setter = false, &block)
-      if block_given?
-        value = Proc.new { block }
-      end
-      super(option, value, ignore_setter, &nil)
+    def map(map, &block)
+      app.map(map, &block)
     end
+    def helpers(*extensions, &block)
+      class_eval(&block)   if block_given?
+      include(*extensions) if extensions.any?
+    end
+    def defaults
+      @defaults ||= {}
+    end
+    def set(key, value)
+      @defaults ||= {}
+      @defaults[key] = value
+    end
+    def asset_stamp; false; end
     def before_processing(name=:unnamed, idx=-1, &block)
       @before_processes ||= []
       @before_processes.insert(idx, [name, block])
@@ -144,64 +77,373 @@ module Middleman::Base
         inst.instance_exec(resolved_template, &block)
       end
     end
+  end
+  def set(key, value=nil, &block)
+    setter = "#{key}=".to_sym
+    self.class.send(:attr_accessor, key) if !respond_to?(setter)
+    value = block if block_given?
+    send(setter, value)
+  end
+  # Basic Sinatra config
+  set :root,        Dir.pwd
+  set :source,      "source"
+  set :environment, (ENV['MM_ENV'] && ENV['MM_ENV'].to_sym) || :development
+  set :logging, false
+  # Middleman-specific options
+  set :index_file,  "index.html"  # What file responds to folder requests
+                                  # Such as the homepage (/) or subfolders (/about/)
+  # These directories are passed directly to Compass
+  set :js_dir,      "javascripts" # Where to look for javascript files
+  set :css_dir,     "stylesheets" # Where to look for CSS files
+  set :images_dir,  "images"      # Where to look for images
+  set :build_dir,   "build"       # Which folder are builds output to
+  set :http_prefix, nil           # During build, add a prefix for absolute paths
+  set :views, "source"
+  set :default_features, [
+    :lorem,
+    # :sitemap_tree
+  ]
+  # Default layout name
+  set :layout, :layout
+  # Activate custom features and extensions
+  include Middleman::CoreExtensions::Features
+  # Add Builder Callbacks
+  register Middleman::CoreExtensions::Builder
+  # Add Guard Callbacks
+  register Middleman::CoreExtensions::FileWatcher
+  # Sitemap
+  register Middleman::CoreExtensions::Sitemap
+  # Activate Data package
+  register Middleman::CoreExtensions::Data
+  # Setup custom rendering
+  register Middleman::CoreExtensions::Rendering
+  # Compass framework
+  register Middleman::CoreExtensions::Compass
+  # Sprockets asset handling
+  register Middleman::CoreExtensions::Sprockets
+  # Setup asset path pipeline
+  register Middleman::CoreExtensions::Assets
+  # Activate built-in helpers
+  register Middleman::CoreExtensions::DefaultHelpers
+  # with_layout and page routing
+  register Middleman::CoreExtensions::Routing
+  # Parse YAML from templates
+  register Middleman::CoreExtensions::FrontMatter
+  def initialize(&block)
+    self.class.superclass.defaults.each do |k, v|
+      set(k, v)
+    end
+    instance_exec(&block) if block_given?
+    set :source_dir, File.join(root, source)
+    super
-    # Convenience method to check if we're in build mode
-    def build?; environment == :build; end
+    run_hook :initialized
   end
-  module InstanceMethods
-    def forward
-      raise ::Sinatra::NotFound
+  attr :env
+  attr :req
+  attr :res
+  attr :options
+  attr :locals
+  def call(env)
+    @env = env
+    @req = Rack::Request.new(env)
+    @res = Rack::Response.new
+    catch(:halt) do
+      process_request
+      res.status = 404
+      res.finish
     end
+  end
+  def halt(response)
+    throw :halt, response
+  end
+  # Convenience methods to check if we're in a mode
+  def development?; environment == :development; end
+  def build?; environment == :build; end
-    # Internal method to look for templates and evaluate them if found
-    def process_request(options={})
-      if !settings.views.include?(settings.root)
-        settings.set :views, File.join(settings.root, settings.views)
-      end
+  # Internal method to look for templates and evaluate them if found
+  def process_request
+    # Normalize the path and add index if we're looking at a directory
+    @original_path = env["PATH_INFO"].dup
+    @request_path  = full_path(env["PATH_INFO"].gsub("%20", " "))
+    run_hook :before
+    return not_found if sitemap.ignored_path?(@request_path)
+    if sitemap.path_is_proxy?(@request_path)
+      @request_path = "/" + sitemap.path_target(@request_path)
+    end
+    found_template = resolve_template(@request_path)
+    return not_found unless found_template
+    @current_path = @request_path.dup
+    path, engine = found_template
+    # Static File
+    return send_file(path) if engine.nil?
+    return unless self.class.execute_before_processing!(self, found_template)
+    context = sitemap.get_context(full_path(@original_path.gsub("%20", " "))) || {}
+    @options = context.has_key?(:options) ? context[:options] : {}
+    @locals  = context.has_key?(:locals)  ? context[:locals] : {}
+    provides_metadata.each do |callback, matcher|
+      next if !matcher.nil? && !path.match(matcher)
+      instance_exec(path, &callback)
+    end
+    local_layout = if options.has_key?(:layout)
+      options[:layout]
+    elsif %w(.js .css .txt).include?(File.extname(@request_path))
+      false
+    else
+      layout
+    end
+    if context.has_key?(:block) && context[:block]
+      instance_eval(&context[:block])
+    end
+    output = if local_layout
+      engine_options = respond_to?(engine.to_sym) ? send(engine.to_sym) : {}
-      # Normalize the path and add index if we're looking at a directory
-      request.path_info = self.class.path_to_index(request.path)
+      layout_engine = if options.has_key?(:layout_engine)
+        options[:layout_engine]
+      elsif engine_options.has_key?(:layout_engine)
+        engine_options[:layout_engine]
+      else
+        engine
+      end
-      request_path = request.path_info.gsub("%20", " ")
-      found_template = resolve_template(request_path, :raise_exceptions => false)
-      return status(404) unless found_template
-      return unless settings.execute_before_processing!(self, found_template)
+      layout_path, *etc = resolve_template(local_layout, :preferred_engine => layout_engine)
-      options.merge!(request['custom_options'] || {})
-      old_layout = settings.layout
-      settings.set :layout, options[:layout] if !options[:layout].nil?
-      local_layout = if settings.layout
-        if options[:layout] == false || request.path_info =~ /\.(css|js)$/
-          false
+      if !layout_path
+        local_layout = File.join("layouts", local_layout.to_s)
+        layout_path, *etc = resolve_template(local_layout, :preferred_engine => layout_engine)
+      end
+      throw "Could not locate layout: #{local_layout}" unless layout_path
+      render(layout_path, locals, options) do
+        render(path, locals, options)
+      end
+    else
+      render(path, locals)
+    end
+    content_type mime_type(File.extname(@request_path))
+    res.status = 200
+    res.write output
+    halt res.finish
+  end
+public
+  def extensionless_path(file)
+    @_extensionless_path_cache ||= {}
+    if @_extensionless_path_cache.has_key?(file)
+      @_extensionless_path_cache[file]
+    else
+      path = file.dup
+      end_of_the_line = false
+      while !end_of_the_line
+        if !Tilt[path].nil?
+          path = path.sub(File.extname(path), "")
         else
-          settings.fetch_layout_path(settings.layout).to_sym
+          end_of_the_line = true
         end
-      else
-        false
       end
+      @_extensionless_path_cache[file] = path
+      path
+    end
+  end
-      render_options = { :layout => local_layout }
-      render_options[:layout_engine] = options[:layout_engine] if options.has_key? :layout_engine
+  def logging?
+    logging
+  end
+  def current_path
+    @current_path || nil
+  end
+  def raw_templates_cache
+    @_raw_templates_cache ||= {}
+  end
+  def read_raw_template(path)
+    if raw_templates_cache.has_key?(path)
+      raw_templates_cache[path]
+    else
+      File.read(path)
+    end
+  end
+  def map(map, &block)
+    self.class.map(map, &block)
+  end
+  def full_path(path)
+    parts = path ? path.split('/') : []
+    if parts.last.nil? || parts.last.split('.').length == 1
+      path = File.join(path, index_file)
+    end
+    "/" + path.sub(%r{^/}, '')
+  end
+  def not_found
+    @res.status == 404
+    @res.write "<html><body><h1>File Not Found</h1><p>#{@request_path}</p></body>"
+    @res.finish
+  end
+  def resolve_template(request_path, options={})
+    request_path = request_path.to_s
+    @_resolved_templates ||= {}
+    if !@_resolved_templates.has_key?(request_path)
+      relative_path = request_path.sub(%r{^/}, "")
+      on_disk_path  = File.expand_path(relative_path, source_dir)
-      path, engine = found_template
-      locals = request['custom_locals'] || {}
+      preferred_engine = if options.has_key?(:preferred_engine)
+        extension_class = Tilt[options[:preferred_engine]]
+        matched_exts = []
+        # TODO: Cache this
+        Tilt.mappings.each do |ext, engines|
+          next unless engines.include? extension_class
+          matched_exts << ext
+        end
+        "{" + matched_exts.join(",") + "}"
+      else
+        "*"
+      end
-      begin
-        result = render(engine, path, render_options, locals)
+      path_with_ext = on_disk_path + "." + preferred_engine
+      found_path = Dir[path_with_ext].find do |path|
+        ::Tilt[path]
+      end
+      result = if found_path || File.exists?(on_disk_path)
+        engine = found_path ? File.extname(found_path)[1..-1].to_sym : nil
+        [ found_path || on_disk_path, engine ]
+      else
+        false
+      end
-        if result
-          content_type mime_type(File.extname(request_path)), :charset => 'utf-8'
-          status 200
-          body result
-        end
-      # rescue
-      #   status(404)
-      ensure
-        settings.set :layout, old_layout
+      @_resolved_templates[request_path] = result
+    end
+    @_resolved_templates[request_path]
+  end
+  def send_file(path)
+    matched_mime = mime_type(File.extname(path))
+    matched_mime = "application/octet-stream" if matched_mime.nil?
+    content_type matched_mime
+    file      = ::Rack::File.new nil
+    file.path = path
+    halt file.serving(env)
+  end
+  def render(path, locals = {}, options = {}, &block)
+    path = path.to_s
+    options.merge!(options_for_ext(File.extname(path)))
+    body = read_raw_template(path)
+    template = ::Tilt.new(path, 1, options) { body }
+    template.render(self, locals, &block)
+  end
+  def options_for_ext(ext)
+    @_options_for_ext_cache ||= {}
+    if !@_options_for_ext_cache.has_key?(ext)
+      options = {}
+      extension_class = Tilt[ext]
+      matched_exts = []
+      Tilt.mappings.each do |ext, engines|
+        next unless engines.include? extension_class
+        engine_options = respond_to?(ext.to_sym) ? send(ext.to_sym) : {}
+        options.merge!(engine_options)
       end
+      @_options_for_ext_cache[ext] = options
+    end
+    @_options_for_ext_cache[ext]
+  end
+  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
+  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
+  def helpers(*extensions, &block)
+    self.class.helpers(*extensions, &block)
+  end
+  def use(middleware, *args, &block)
+    self.class.use(middleware, *args, &block)
+  end
+  def map(map, &block)
+    self.class.map(map, &block)
   end
 end