middleman 2.0.9.pre.2-x86-mingw32

data/lib/middleman/core_extensions/front_matter.rb

@@ -0,0 +1,116 @@
+require "yaml"
+require "tilt"
+
+module Middleman::CoreExtensions::FrontMatter
+  class << self
+    def registered(app)
+      app.extend ClassMethods
+      
+      ::Tilt::register RDiscountTemplate, 'markdown', 'mkd', 'md'
+      ::Tilt::register RedcarpetTemplate, 'markdown', 'mkd', 'md'
+      ::Tilt::register MarukuTemplate, 'markdown', 'mkd', 'md'
+      ::Tilt::register KramdownTemplate, 'markdown', 'mkd', 'md'
+      app.set :markdown_engine_prefix, ::Middleman::CoreExtensions::FrontMatter
+      
+      ::Tilt::register RedClothTemplate,  'textile'
+      ::Tilt.prefer(RedClothTemplate)
+      
+      ::Tilt::register ERBTemplate,       'erb', 'rhtml'
+      ::Tilt.prefer(ERBTemplate)
+      
+      ::Tilt::register LiquidTemplate,    'liquid'
+      ::Tilt.prefer(LiquidTemplate)
+      
+      ::Tilt::register SlimTemplate,      'slim'
+      ::Tilt.prefer(SlimTemplate)
+      
+      ::Tilt::register HamlTemplate,      'haml'
+      ::Tilt.prefer(HamlTemplate)
+      
+      app.after_configuration do
+        app.before_processing(:front_matter) do |result|
+          if result && Tilt.mappings.has_key?(result[1].to_s)
+            extensionless_path, template_engine = result
+            full_file_path = "#{extensionless_path}.#{template_engine}"
+            system_path = File.join(settings.views, full_file_path)
+            data, content = app.parse_front_matter(File.read(system_path))
+  
+            request['custom_options'] = {}
+            %w(layout layout_engine).each do |opt|
+              if data.has_key?(opt)
+                request['custom_options'][opt.to_sym] = data.delete(opt)
+              end
+            end
+  
+            # Forward remaining data to helpers
+            app.data_content("page", data)
+          end
+        
+          true
+        end
+      end
+    end
+    alias :included :registered
+    
+    def parse_front_matter(content)
+      yaml_regex = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+      if content =~ yaml_regex
+        begin
+          data = YAML.load($1)
+        rescue => e
+          puts "YAML Exception: #{e.message}"
+        end
+
+        content = content.split(yaml_regex).last
+      end
+
+      data ||= {}
+      [data, content]
+    end
+  end
+  
+  module ClassMethods
+    def parse_front_matter(content)
+      Middleman::CoreExtensions::FrontMatter.parse_front_matter(content)
+    end
+  end
+  
+  module YamlAware
+    def prepare
+      @frontmatter, @data = Middleman::CoreExtensions::FrontMatter.parse_front_matter(@data)
+      super
+    end
+  end
+
+  class RDiscountTemplate < ::Tilt::RDiscountTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+  class RedcarpetTemplate < ::Tilt::RedcarpetTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+  class MarukuTemplate < ::Tilt::MarukuTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+  class RedClothTemplate < ::Tilt::RedClothTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+  class KramdownTemplate < ::Tilt::KramdownTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+ 
+  class ERBTemplate < ::Tilt::ERBTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+
+  class LiquidTemplate < ::Tilt::LiquidTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+
+  class HamlTemplate < ::Tilt::HamlTemplate
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+  
+  class SlimTemplate < ::Slim::Template
+    include Middleman::CoreExtensions::FrontMatter::YamlAware
+  end
+end

data/lib/middleman/core_extensions/rack_map.rb

@@ -0,0 +1,35 @@
+module Middleman::CoreExtensions::RackMap
+  class << self
+    def registered(app)
+      app.extend ClassMethods
+    end
+    alias :included :registered
+  end
+  
+  module ClassMethods
+    def map(path, &block)
+      @maps ||= []
+      @maps << [path, block]
+    end
+  
+    def maps
+      @maps || []
+    end
+  
+    # Creates a Rack::Builder instance with all the middleware set up and
+    # an instance of this class as end point.
+    def build(*args, &bk)
+      builder = ::Rack::Builder.new
+      builder.use ::Sinatra::ShowExceptions       if show_exceptions?
+      builder.use ::Rack::CommonLogger   if logging?
+      builder.use ::Rack::Head
+      middleware.each { |c,a,b| builder.use(c, *a, &b) }
+      maps.each { |p,b| builder.map(p, &b) }
+      app = self
+      builder.map "/" do
+        run app.new!(*args, &bk)
+      end
+      builder
+    end
+  end
+end

data/lib/middleman/core_extensions/rendering.rb

@@ -0,0 +1,19 @@
+require "padrino-core/application/rendering"
+
+module Middleman::CoreExtensions::Rendering
+  class << self
+    def registered(app)
+      # Tilt-aware renderer
+      app.register Padrino::Rendering
+
+      # Activate custom renderers
+      app.register Middleman::Renderers::Slim
+      app.register Middleman::Renderers::Haml
+      app.register Middleman::Renderers::Sass
+      app.register Middleman::Renderers::Markdown
+      app.register Middleman::Renderers::CoffeeScript
+      app.register Middleman::Renderers::Liquid
+    end
+    alias :included :registered
+  end
+end

data/lib/middleman/core_extensions/routing.rb

@@ -0,0 +1,87 @@
+module Middleman::CoreExtensions::Routing
+  class << self
+    def registered(app)
+      app.extend ClassMethods
+      
+      app.set :proxied_paths, {}
+      app.set :excluded_paths, []
+      
+      app.build_reroute do |destination, request_path|
+        throw if app.settings.excluded_paths.include?(request_path)
+      end
+    end
+    alias :included :registered
+  end
+  
+  module ClassMethods    
+    def path_to_index(path)
+      parts = path ? path.split('/') : []
+      if parts.last.nil? || parts.last.split('.').length == 1
+        path = File.join(path, settings.index_file) 
+      end
+      path.gsub(%r{^/}, '')
+    end
+  
+    # Takes a block which allows many pages to have the same layout
+    # with_layout :admin do
+    #   page "/admin/"
+    #   page "/admin/login.html"
+    # end
+    def with_layout(layout_name, &block)
+      old_layout = settings.layout
+    
+      set :layout, layout_name
+      class_eval(&block) if block_given?
+    ensure
+      set :layout, old_layout
+    end
+  
+    def paths_for_url(url)
+      url = url.gsub(%r{\/#{settings.index_file}$}, "")
+      url = url.gsub(%r{(\/)$}, "") if url.length > 1
+    
+      paths = [url]
+      paths << "#{url}/" if url.length > 1 && url.split("/").last.split('.').length <= 1
+      paths << "/#{path_to_index(url)}"
+      paths
+    end
+  
+    # Keep a path from building
+    def ignore(path)
+      settings.excluded_paths << paths_for_url(path)
+      settings.excluded_paths.flatten!
+      settings.excluded_paths.uniq!
+    end
+    
+    # The page method allows the layout to be set on a specific path
+    # page "/about.html", :layout => false
+    # page "/", :layout => :homepage_layout
+    def page(url, options={}, &block)
+      has_block = block_given?
+      options[:layout] = settings.layout if options[:layout].nil?
+      
+      if options.has_key?(:proxy)
+        settings.proxied_paths[url] = options[:proxy]
+        if options.has_key?(:ignore) && options[:ignore]
+          settings.ignore(options[:proxy])
+        end
+      else
+        if options.has_key?(:ignore) && options[:ignore]
+          settings.ignore(url)
+        end
+      end
+
+      paths_for_url(url).each do |p|
+        get(p) do
+          if settings.proxied_paths.has_key?(url)
+            request["is_proxy"] = true
+            request.path_info = settings.proxied_paths[url]
+          end
+          
+          instance_eval(&block) if has_block
+          process_request(options)
+        end
+      end
+    end
+  end
+end

data/lib/middleman/core_extensions/sprockets.rb

@@ -0,0 +1,102 @@
+require 'pathname'
+require 'rbconfig'
+require "sprockets"
+
+module Middleman::CoreExtensions::Sprockets
+  class << self
+    def registered(app)
+      app.set :js_compressor, false
+      
+      # Cut off every extension after .js (which sprockets eats up)
+      app.build_reroute do |destination, request_path|
+        if !request_path.match(/\.js\./i)
+          false
+        else
+          [
+            destination.gsub(/\.js(\..*)$/, ".js"),
+            request_path.gsub(/\.js(\..*)$/, ".js")
+          ]
+        end
+      end
+      
+      app.after_configuration do
+        js_env = Middleman::CoreExtensions::Sprockets::JavascriptEnvironment.new(app)
+        
+        js_dir = File.join("vendor", "assets", "javascripts")
+        gems_with_js = ::Middleman.rubygems_latest_specs.select do |spec|
+          ::Middleman.spec_has_file?(spec, js_dir)
+        end.each do |spec|
+          js_env.append_path File.join(spec.full_gem_path, js_dir)
+        end
+        
+        # add paths to js_env (vendor/assets/javascripts)
+        app.map "/#{app.js_dir}" do
+          run js_env
+        end
+        
+        # app.map "/#{app.css_dir}" do
+        #   run Middleman::CoreExtensions::Sprockets::StylesheetEnvironment.new(app)
+        # end
+      end
+    end
+    alias :included :registered
+  end
+
+  class MiddlemanEnvironment < ::Sprockets::Environment
+    def initialize(app)
+      full_path = app.views
+      full_path = File.join(app.root, app.views) unless app.views.include?(app.root)
+      
+      super File.expand_path(full_path)
+      
+      # Make the app context available to Sprockets
+      context_class.send(:define_method, :app) { app }
+      context_class.class_eval do
+        def method_missing(name)
+          if app.respond_to?(name)
+            app.send(name)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+    
+  class JavascriptEnvironment < MiddlemanEnvironment
+    def initialize(app)
+      super
+
+      # Disable css
+      unregister_processor "text/css", ::Sprockets::DirectiveProcessor
+      
+      self.js_compressor = app.settings.js_compressor
+
+      # configure search paths
+      append_path app.js_dir
+    end
+    
+    def javascript_exception_response(exception)
+      expire_index!
+      super(exception)
+    end
+  end
+  
+  # class StylesheetEnvironment < MiddlemanEnvironment
+  #   def initialize(app)
+  #     super
+  # 
+  #     # Disable js
+  #     unregister_processor "application/javascript", ::Sprockets::DirectiveProcessor
+  # 
+  #     # configure search paths
+  #     stylesheets_path = File.join(File.expand_path(app.views), app.css_dir)
+  #     append_path stylesheets_path
+  #   end
+  #
+  #   def css_exception_response(exception)
+  #     expire_index!
+  #     super(exception)
+  #   end
+  # end
+end

data/lib/middleman/features/asset_host.rb

@@ -0,0 +1,22 @@
+module Middleman::Features::AssetHost
+  class << self
+    def registered(app)
+      app.compass_config do |config|
+        if app.asset_host.is_a?(Proc)
+          config.asset_host(&app.asset_host)
+        end
+      end
+
+      app.register_asset_handler :asset_host do |path, prefix, request|
+        original_output = app.before_asset_handler(:asset_host, path, prefix, request)
+
+        valid_extensions = %w(.png .gif .jpg .jpeg .js .css)
+
+        asset_prefix = app.asset_host.call(original_output)
+
+        File.join(asset_prefix, original_output)
+      end
+    end
+    alias :included :registered
+  end
+end

data/lib/middleman/features/automatic_image_sizes.rb

@@ -0,0 +1,31 @@
+module Middleman::Features::AutomaticImageSizes
+  class << self
+    def registered(app)
+      require "middleman/features/automatic_image_sizes/fastimage"
+
+      app.helpers Helpers
+    end
+    alias :included :registered
+  end
+  
+  module Helpers
+    def image_tag(path, params={})
+      if (!params[:width] || !params[:height]) && !path.include?("://")
+        params[:alt] ||= ""
+        http_prefix = settings.http_images_path rescue settings.images_dir
+
+        begin
+          real_path = File.join(settings.views, settings.images_dir, path)
+          if File.exists? real_path
+            dimensions = ::FastImage.size(real_path, :raise_on_failure => true)
+            params[:width]  ||= dimensions[0]
+            params[:height] ||= dimensions[1]
+          end
+        rescue
+        end
+      end
+      
+      super(path, params)
+    end
+  end
+end

data/lib/middleman/features/automatic_image_sizes/fastimage.rb

@@ -0,0 +1,287 @@
+# FastImage finds the size or type of an image given its uri.
+# It is careful to only fetch and parse as much of the image as is needed to determine the result.
+# It does this by using a feature of Net::HTTP that yields strings from the resource being fetched
+# as soon as the packets arrive.
+#
+# No external libraries such as ImageMagick are used here, this is a very lightweight solution to 
+# finding image information.
+#
+# FastImage knows about GIF, JPEG, BMP and PNG files.
+#
+# FastImage can also read files from the local filesystem by supplying the path instead of a uri.
+# In this case FastImage uses the open-uri library to read the file in chunks of 256 bytes until
+# it has enough. This is possibly a useful bandwidth-saving feature if the file is on a network
+# attached disk rather than truly local.
+#
+# === Examples
+#   require 'fastimage'
+#
+#   FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
+#   => [266, 56]
+#   FastImage.type("http://stephensykes.com/images/pngimage")
+#   => :png
+#   FastImage.type("/some/local/file.gif")
+#   => :gif
+#
+# === References
+# * http://snippets.dzone.com/posts/show/805
+# * http://www.anttikupila.com/flash/getting-jpg-dimensions-with-as3-without-loading-the-entire-file/
+# * http://pennysmalls.com/2008/08/19/find-jpeg-dimensions-fast-in-ruby/
+# * http://imagesize.rubyforge.org/
+#
+require 'net/https'
+require 'open-uri'
+
+class FastImage
+  attr_reader :size, :type
+
+  class FastImageException < StandardError # :nodoc:
+  end
+  class MoreCharsNeeded < FastImageException # :nodoc:
+  end
+  class UnknownImageType < FastImageException # :nodoc:
+  end
+  class ImageFetchFailure < FastImageException # :nodoc:
+  end
+  class SizeNotFound < FastImageException # :nodoc:
+  end
+
+  DefaultTimeout = 2
+  
+  LocalFileChunkSize = 256
+
+  # Returns an array containing the width and height of the image.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot size the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # FastImage knows about GIF, JPEG, BMP and PNG files.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
+  #   => [266, 56]
+  #   FastImage.size("http://stephensykes.com/images/pngimage")
+  #   => [16, 16]
+  #   FastImage.size("http://farm4.static.flickr.com/3023/3047236863_9dce98b836.jpg")
+  #   => [500, 375]
+  #   FastImage.size("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
+  #   => [512, 512]
+  #   FastImage.size("test/fixtures/test.jpg")
+  #   => [882, 470]
+  #   FastImage.size("http://pennysmalls.com/does_not_exist")
+  #   => nil
+  #   FastImage.size("http://pennysmalls.com/does_not_exist", :raise_on_failure=>true)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://stephensykes.com/favicon.ico", :raise_on_failure=>true)
+  #   => raises FastImage::UnknownImageType
+  #   FastImage.size("http://stephensykes.com/favicon.ico", :raise_on_failure=>true, :timeout=>0.01)
+  #   => raises FastImage::ImageFetchFailure
+  #   FastImage.size("http://stephensykes.com/images/faulty.jpg", :raise_on_failure=>true)
+  #   => raises FastImage::SizeNotFound
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image size cannot be found for any reason.
+  #
+  def self.size(uri, options={})
+    new(uri, options).size
+  end
+
+  # Returns an symbol indicating the image type fetched from a uri.
+  # It will return nil if the image could not be fetched, or if the image type was not recognised.
+  #
+  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
+  # This can be changed by passing a :timeout => number_of_seconds in the options.
+  #
+  # If you wish FastImage to raise if it cannot find the type of the image for any reason, then pass
+  # :raise_on_failure => true in the options.
+  #
+  # === Example
+  #
+  #   require 'fastimage'
+  #
+  #   FastImage.type("http://stephensykes.com/images/ss.com_x.gif")
+  #   => :gif
+  #   FastImage.type("http://stephensykes.com/images/pngimage")
+  #   => :png
+  #   FastImage.type("http://farm4.static.flickr.com/3023/3047236863_9dce98b836.jpg")
+  #   => :jpeg
+  #   FastImage.type("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
+  #   => :bmp
+  #   FastImage.type("test/fixtures/test.jpg")
+  #   => :jpeg
+  #   FastImage.type("http://pennysmalls.com/does_not_exist")
+  #   => nil
+  #
+  # === Supported options
+  # [:timeout]
+  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
+  # [:raise_on_failure]
+  #   If set to true causes an exception to be raised if the image type cannot be found for any reason.
+  #
+  def self.type(uri, options={})
+    new(uri, options.merge(:type_only=>true)).type
+  end
+
+  def initialize(uri, options={})
+    @property = options[:type_only] ? :type : :size
+    @timeout = options[:timeout] || DefaultTimeout
+    @uri = uri
+    begin
+      @parsed_uri = URI.parse(uri)
+    rescue URI::InvalidURIError
+      fetch_using_open_uri
+    else
+      if @parsed_uri.scheme == "http" || @parsed_uri.scheme == "https"
+        fetch_using_http
+      else
+        fetch_using_open_uri
+      end
+    end
+    raise SizeNotFound if options[:raise_on_failure] && @property == :size && !@size
+  rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET, 
+    ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT
+    raise ImageFetchFailure if options[:raise_on_failure]
+  rescue NoMethodError  # 1.8.7p248 can raise this due to a net/http bug
+    raise ImageFetchFailure if options[:raise_on_failure]
+  rescue UnknownImageType
+    raise UnknownImageType if options[:raise_on_failure]
+  end
+
+  private
+
+  def fetch_using_http
+    setup_http
+    @http.request_get(@parsed_uri.request_uri) do |res|
+      raise ImageFetchFailure unless res.is_a?(Net::HTTPSuccess)
+      res.read_body do |str|
+        break if parse_packet(str)
+      end
+    end
+  end
+
+  def setup_http
+    @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
+    @http.use_ssl = (@parsed_uri.scheme == "https")
+    @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    @http.open_timeout = @timeout
+    @http.read_timeout = @timeout
+  end
+
+  def fetch_using_open_uri
+    open(@uri) do |s|
+      while str = s.read(LocalFileChunkSize)
+        break if parse_packet(str)
+      end
+    end
+  end
+
+  # returns true once result is achieved
+  #
+  def parse_packet(str)
+    @str = (@unused_str || "") + str
+    @strpos = 0
+    begin
+      result = send("parse_#{@property}")
+      if result 
+        instance_variable_set("@#{@property}", result)
+        true
+      end
+    rescue MoreCharsNeeded
+      false
+    end
+  end
+
+  def parse_size
+    @type = parse_type unless @type
+    @strpos = 0
+    send("parse_size_for_#{@type}")
+  end
+
+  def get_chars(n)
+    if @strpos + n - 1 >= @str.size
+      @unused_str = @str[@strpos..-1]
+      raise MoreCharsNeeded
+    else
+      result = @str[@strpos..(@strpos + n - 1)]
+      @strpos += n
+      result
+    end
+  end
+
+  def get_byte
+    get_chars(1).unpack("C")[0]
+  end
+
+  def read_int(str)
+    size_bytes = str.unpack("CC")
+    (size_bytes[0] << 8) + size_bytes[1]
+  end
+
+  def parse_type
+    case get_chars(2)
+    when "BM"
+      :bmp
+    when "GI"
+      :gif
+    when 0xff.chr + 0xd8.chr
+      :jpeg
+    when 0x89.chr + "P"
+      :png
+    else
+      raise UnknownImageType
+    end
+  end
+
+  def parse_size_for_gif
+    get_chars(11)[6..10].unpack('SS')
+  end
+
+  def parse_size_for_png
+    get_chars(25)[16..24].unpack('NN')
+  end
+
+  def parse_size_for_jpeg
+    loop do
+      @state = case @state
+      when nil
+        get_chars(2)
+        :started
+      when :started
+        get_byte == 0xFF ? :sof : :started          
+      when :sof
+        c = get_byte
+        if (0xe0..0xef).include?(c)
+          :skipframe
+        elsif [0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF].detect {|r| r.include? c}
+          :readsize
+        else
+          :skipframe
+        end
+      when :skipframe
+        @skip_chars = read_int(get_chars(2)) - 2
+        :do_skip
+      when :do_skip
+        get_chars(@skip_chars)
+        :started
+      when :readsize
+        s = get_chars(7)
+        return [read_int(s[5..6]), read_int(s[3..4])]
+      end
+    end
+  end
+
+  def parse_size_for_bmp
+    d = get_chars(29)[14..28]
+    d.unpack("C")[0] == 40 ? d[4..-1].unpack('LL') : d[4..8].unpack('SS')
+  end
+end