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

middleman 2.0.16.1 → 3.0.0.alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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