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

data/lib/middleman-core/base.rb

@@ -1,494 +0,0 @@
-# Built on Rack
-require "rack"
-require "rack/file"
-
-# Using Tilt for templating
-require "tilt"
-
-# Use ActiveSupport JSON
-require "active_support/json"
-  
-# Core Middleman Class
-class Middleman::Base
-  # Uses callbacks
-  include Hooks
-  
-  # Before request hook
-  define_hook :before
-  
-  # Ready (all loading and parsing of extensions complete) hook
-  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::Base]
-    def inst(&block)
-      @inst ||= begin
-        mm = new(&block)
-        mm.run_hook :ready
-        mm
-      end
-    end
-    
-    # Set the shared instance
-    #
-    # @private
-    # @param [Middleman::Base] 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]
-    def helpers(*extensions, &block)
-      class_eval(&block)   if block_given?
-      include(*extensions) if extensions.any?
-    end
-    
-    # Access class-wide defaults
-    #
-    # @private
-    # @return [Hash] Hash of default values
-    def defaults
-      @defaults ||= {}
-    end
-    
-    # Set class-wide defaults
-    #
-    # @param [Symbol] Unique key name
-    # @param Default value
-    # @return [void]
-    def set(key, value=nil, &block)
-      @defaults ||= {}
-      @defaults[key] = value
-      
-      @inst.set(key, value, &block) if @inst
-    end
-  end
-  
-  # Set attributes (global variables)
-  #
-  # @param [Symbol] Name of the attribue
-  # @param Attribute value
-  # @return [void]
-  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
-  
-  # Root project directory (overwritten in middleman build/server)
-  # @return [String]
-  set :root,        ENV["MM_ROOT"] || Dir.pwd
-  
-  # Name of the source directory
-  # @return [String]
-  set :source,      "source"
-  
-  # Middleman environment. Defaults to :development, set to :build by the build process
-  # @return [String]
-  set :environment, (ENV['MM_ENV'] && ENV['MM_ENV'].to_sym) || :development
-  
-  # Whether logging is active, disabled by default
-  # @return [String]
-  set :logging, false
-
-  # Which file should be used for directory indexes
-  # @return [String]
-  set :index_file,  "index.html"
-
-  # Location of javascripts within source. Used by Sprockets.
-  # @return [String]
-  set :js_dir,      "javascripts"
-  
-  # Location of stylesheets within source. Used by Compass.
-  # @return [String]
-  set :css_dir,     "stylesheets"
-  
-  # Location of images within source. Used by HTML helpers and Compass.
-  # @return [String]
-  set :images_dir,  "images"
-
-  # Where to build output files
-  # @return [String]
-  set :build_dir,   "build"
-  
-  # Default prefix for building paths. Used by HTML helpers and Compass.
-  # @return [String]
-  set :http_prefix, "/"
-
-  # Whether to catch and display exceptions
-  # @return [Boolean]
-  set :show_exceptions, true
-
-  # Automatically loaded extensions
-  # @return [Array<Symbol>]
-  set :default_extensions, [ :lorem ]
-
-  # Default layout name
-  # @return [String, Symbold]
-  set :layout, :_auto_layout
-  
-  # Activate custom features and extensions
-  include Middleman::CoreExtensions::Extensions
-  
-  # Handle exceptions
-  register Middleman::CoreExtensions::ShowExceptions
-    
-  # Add Builder Callbacks
-  register Middleman::CoreExtensions::Builder
-  
-  # Add Watcher Callbacks
-  register Middleman::CoreExtensions::FileWatcher
-  
-  # Activate Data package
-  register Middleman::CoreExtensions::Data
-  
-  # Setup custom rendering
-  register Middleman::CoreExtensions::Rendering
-  
-  # Sitemap
-  register Middleman::CoreExtensions::Sitemap
-  
-  # Setup default helpers
-  register Middleman::CoreExtensions::DefaultHelpers
-  
-  # Setup asset path pipeline
-  register Middleman::CoreExtensions::Assets
-  
-  # with_layout and page routing
-  register Middleman::CoreExtensions::Routing
-  
-  # Parse YAML from templates
-  register Middleman::CoreExtensions::FrontMatter
-  
-  # 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
-  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 })
-  end
-  
-  # Initialize the Middleman project
-  def initialize(&block)
-    # Current path defaults to nil, used in views.
-    self.current_path = nil
-    
-    # Clear the static class cache
-    cache.clear
-    
-    # Setup the default values from calls to set before initialization
-    self.class.superclass.defaults.each { |k,v| set(k,v) }
-    
-    # Evaluate a passed block if given
-    instance_exec(&block) if block_given?
-    
-    # Build expanded source path once paths have been parsed
-    path = root.dup
-    source_path = ENV["MM_SOURCE"] || self.source
-    path = File.join(root, source_path) unless source_path.empty?
-    set :source_dir, path
-    
-    super
-  end
-  
-  # Shared cache instance
-  #
-  # @private
-  # @return [Middleman::Cache] The cache
-  def self.cache
-    @_cache ||= ::Middleman::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
-
-    puts "== Request: #{env["PATH_INFO"]}" if logging?
-
-    if env["PATH_INFO"] == "/__middleman__" && 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
-      
-      res.status = 200
-      return res.finish
-    end
-    
-    # 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] Reponse 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
-  
-  # Whether we're in build mode
-  # @return [Boolean] If we're in build mode
-  def build?; environment == :build; end
-  
-  # Core repsonse 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
-    @request_path  = full_path(env["PATH_INFO"].gsub("%20", " "))
-    
-    # Run before callbacks
-    run_hook :before
-    
-    # Return 404 if not in sitemap
-    return not_found unless sitemap.exists?(@request_path)
-    
-    # Get the page object for this path
-    sitemap_page = sitemap.page(@request_path)
-    
-    # Return 404 if this path is specifically ignored
-    return not_found if sitemap_page.ignored?
-
-    # If this path is a static file, send it immediately
-    return send_file(sitemap_page.source_file) unless sitemap_page.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 sitemap_page.mime_type
-    
-    begin
-      # Write out the contents of the page
-      res.write sitemap_page.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
-  #
-  # @return [Middleman::Base]
-  def settings
-    self
-  end
-
-  # Whether we're logging
-  #
-  # @return [Boolean] If we're logging
-  def logging?
-    logging
-  end
-  
-  # Expand a path to include the index file if it's a directory
-  #
-  # @private
-  # @param [String] path Request path
-  # @return [String] Path with index file if necessary
-  def full_path(path)
-    cache.fetch(:full_path, path) do
-      parts = path ? path.split('/') : []
-      if parts.last.nil? || parts.last.split('.').length == 1
-        path = File.join(path, index_file) 
-      end
-      "/" + path.sub(%r{^/}, '')
-    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

data/lib/middleman-core/cache.rb

@@ -1,57 +0,0 @@
-module Middleman
-  # Simple shared cache implementation
-  class Cache
-    
-    # Initialize
-    def initialize
-      self.clear
-    end
-
-    # Either get the cached key or save the contents of the block
-    #
-    # @param Anything Hash can use as a key
-    # @return Cached value
-    def fetch(*key)
-      @cache[key] ||= yield
-    end
-    
-    # Whether the key is in the cache
-    # 
-    # @param Anything Hash can use as a key
-    # @return [Boolean]
-    def has_key?(key)
-      @cache.has_key?(key)
-    end
-    
-    # Get a specific key
-    #
-    # @param Anything Hash can use as a key
-    # @return Cached value
-    def get(key)
-      @cache[key]
-    end
-    
-    def keys
-      @cache.keys
-    end
-    
-    # Clear the entire cache
-    def clear
-      @cache = {}
-    end
-    
-    # Set a specific key
-    #
-    # @param Anything Hash can use as a key
-    # @param Cached value
-    def set(key, value)
-      @cache[key] = value
-    end
-    
-    # Remove a specific key
-    # @param Anything Hash can use as a key
-    def remove(*key)
-      @cache.delete(key)
-    end
-  end
-end

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

@@ -1,72 +0,0 @@
-require "active_support/core_ext/hash/deep_merge"
-require 'find'
-
-module Middleman::CoreExtensions::Sitemap
-  class << self
-    def registered(app)
-      app.set :ignored_sitemap_matchers, {
-        # dotfiles and folders in the root
-        :root_dotfiles => proc { |file, path| file.match(/^\./) },
-        
-        # Files starting with an dot, but not .htaccess
-        :source_dotfiles => proc { |file, path| 
-          (file.match(/\/\./) && !file.match(/\/\.htaccess/)) 
-        },
-        
-        # Files starting with an underscore, but not a double-underscore
-        :partials => proc { |file, path| (file.match(/\/_/) && !file.match(/\/__/)) },
-        
-        # Files without any output extension (layouts, partials)
-        :extensionless => proc { |file, path| !path.match(/\./) },
-      }
-      app.send :include, InstanceMethods
-    end
-    alias :included :registered
-  end
-  
-  module InstanceMethods
-    def initialize
-      super
-
-      static_path = source_dir.sub(self.root, "").sub(/^\//, "")
-      sitemap_regex = static_path.empty? ? // : (%r{^#{static_path + "/"}})
-      
-      self.files.changed sitemap_regex do |file|
-        self.sitemap.touch_file(file)
-      end
-
-      self.files.deleted sitemap_regex do |file|
-        self.sitemap.remove_file(file)
-      end
-    end
-    
-    def sitemap
-      @sitemap ||= ::Middleman::Sitemap::Store.new(self)
-    end
-    
-    def current_page
-      sitemap.page(current_path)
-    end
-    
-    # Keep a path from building
-    def ignore(path)
-      sitemap.ignore(path)
-    end
-    
-    def reroute(url, target)
-      sitemap.proxy(url, target)
-    end
-    
-    def provides_metadata(matcher=nil, &block)
-      @_provides_metadata ||= []
-      @_provides_metadata << [block, matcher] if block_given?
-      @_provides_metadata
-    end
-    
-    def provides_metadata_for_path(matcher=nil, &block)
-      @_provides_metadata_for_path ||= []
-      @_provides_metadata_for_path << [block, matcher] if block_given?
-      @_provides_metadata_for_path
-    end
-  end
-end