beans-middleman 1.0.5

data/lib/middleman/features/relative_assets.rb

@@ -0,0 +1,36 @@
+module Middleman::Features::RelativeAssets
+  class << self
+    def registered(app)
+      ::Compass.configuration.relative_assets = true
+
+      Middleman::Assets.register :relative_assets do |path, prefix, request|
+        begin
+          prefix = Middleman::Server.images_dir if prefix == Middleman::Server.http_images_path
+        rescue
+        end
+
+        if path.include?("://")
+          Middleman::Assets.before(:relative_assets, path, prefix, request)
+        elsif path[0,1] == "/"
+          path
+        else
+          path = File.join(prefix, path) if prefix.length > 0
+          request_path = request.path_info.dup
+          request_path << Middleman::Server.index_file if path.match(%r{/$})
+          request_path.gsub!(%r{^/}, '')
+          parts = request_path.split('/')
+
+          if parts.length > 1
+            arry = []
+            (parts.length - 1).times { arry << ".." }
+            arry << path
+            File.join(*arry)
+          else
+            path
+          end
+        end
+      end
+    end
+    alias :included :registered
+  end
+end

data/lib/middleman/features/slickmap/template.html.haml

@@ -0,0 +1,27 @@
+!!!
+%html{ :xmlns => "http://www.w3.org/1999/xhtml" }
+  %head
+    %meta{ :content => "text/html; charset=utf-8", "http-equiv" => "Content-type" }
+    %title Sitemap
+    %style{ :type => "text/css" }
+      :sass
+        @import "slickmap"
+        +slickmap
+    :javascript
+      window.onload = function() {
+        document.getElementById('primaryNav').className = "col" + document.querySelectorAll("#primaryNav > li:not(#home)").length;
+      };
+
+  %body
+    .logo
+      %h1= @project_name || "Sitemap"
+      - if @project_subtitle
+        %h2= @project_subtitle
+    
+      - if @utility.length > 0
+        %ul#utilityNav
+          - @utility.each do |u|
+            %li= link_to u, u
+    
+    %ul#primaryNav
+      - sitemap_node(@tree, true)

data/lib/middleman/features/slickmap.rb

@@ -0,0 +1,89 @@
+Entry = Struct.new(:dir, :children)
+
+module Middleman::Features::Slickmap
+  class << self
+    def registered(app)
+      require 'slickmap'
+
+      @sitemap_url = config[:url] || "sitemap.html"
+
+      if Middleman::Server.environment == :build
+        Middleman::Builder.template :slickmap, @sitemap_url, @sitemap_url
+      end
+
+      Middleman::Server.helpers do
+        def sitemap_node(n, first=false)
+          if n.children.length < 1
+            if !first && File.extname(n.dir).length > 0
+              haml_tag :li do
+                path = n.dir.gsub(self.class.views, '')
+                haml_concat link_to(File.basename(path), path)
+              end
+            end
+          else  
+            haml_tag(:li, :id => first ? "home" : nil) do
+              if first
+                haml_concat link_to("Homepage", "/" + self.class.index_file)
+              else
+                # we are a dir
+                index = n.children.find { |c| c.dir.include?(self.class.index_file) }
+                haml_concat link_to(index.dir.gsub(self.class.views + "/", '').gsub("/" + File.basename(index.dir), '').capitalize, index.dir.gsub(self.class.views, ''))
+              end
+
+              other_children = n.children.select { |c| !c.dir.include?(self.class.index_file) }
+              if other_children.length > 0
+                if first
+                  other_children.each { |i| sitemap_node(i) }
+                else
+                  haml_tag :ul do
+                    other_children.each { |i| sitemap_node(i) }
+                  end
+                end
+              end
+            end  
+          end
+        end
+      end
+
+      Middleman::Server.get "/#{@sitemap_url}" do
+        # Return :utility to put it util top menu. False to ignore
+        @tree, @utility = Middleman::Features::Slickmap.build_sitemap do |file_name|
+          :valid
+        end
+
+        haml "template.html".to_sym, :layout => false, :views => File.expand_path(File.join(File.dirname(__FILE__), "slickmap"))
+      end
+    end
+    alias :included :registered
+  end
+  
+  def self.build_sitemap(&block)    
+    @@utility = []
+    [recurse_sitemap(Middleman::Server.views, &block), @@utility]
+  end
+
+  def self.recurse_sitemap(path, &block)
+    bad_ext = path.split('.html')[1]
+    path = path.gsub(bad_ext, '') if bad_ext
+    entry = Entry.new(path, [])
+
+    #no "." or ".." dirs
+    Dir[File.join(path, "*")].each do |e|
+      next if !File.directory?(e) && !e.include?(".html")
+      if File.directory?(e)
+        entry.children << recurse_sitemap(e, &block)
+      elsif block_given?
+        how_to_handle = block.call(e)
+        if how_to_handle == :valid
+          entry.children << recurse_sitemap(e, &block)
+        elsif how_to_handle == :utility
+          bad_ext = e.split('.html')[1]
+          e = e.gsub(bad_ext, '') if bad_ext
+          @@utility << e.gsub(Middleman::Server.views + "/", '')
+        end
+      end
+    end
+
+    entry
+  end
+end

data/lib/middleman/features/smush_pngs.rb

@@ -0,0 +1,38 @@
+module Middleman::Features::SmushPNGs
+  class << self
+    def registered(app)
+      require "middleman/builder"
+
+      app.alias_method  :pre_smush_after_run, :after_run
+      app.define_method :after_run do
+        pre_smush_after_run
+        smush_dir = File.join(Middleman::Server.build_dir, Middleman::Server.images_dir)
+      
+        # Read cache
+        cache_file = File.join(Middleman::Server.root, ".smush-cache")
+        cache_data = if File.exists?(cache_file)
+          Marshal.restore(File.read(cache_file))
+        else
+          {}
+        end
+      
+        require "smusher"
+        require "json/pure"
+        ::Smusher.class_eval do
+          images_in_folder(smush_dir).each do |file|
+            original_file_size = size(file)
+            return if original_file_size.zero?
+            return if cache_data[file] && cache_data[file] == original_file_size
+
+            with_logging(file, true) do
+              write_optimized_data(file)
+              cache_data[file] = size(file) # Add or update cache
+              File.open(cache_file, "w") { |f| f.write Marshal.dump(cache_data) } # Write cache
+              say "<%= color('#{"[SMUSHED]".rjust(12)}', :yellow) %>  " + file.gsub(Middleman::Server.build_dir+"/", '')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman/features/ugly_haml.rb

@@ -0,0 +1,8 @@
+module Middleman::Features::UglyHaml
+  class << self
+    def registered(app)
+      app.set :haml, app.settings.haml.merge({ :ugly_haml => true })
+    end
+    alias :included :registered
+  end
+end

data/lib/middleman/features.rb

@@ -0,0 +1,37 @@
+module Middleman::Features
+  autoload :RelativeAssets,      "middleman/features/relative_assets"
+  autoload :AssetHost,           "middleman/features/asset_host"
+  autoload :CacheBuster,         "middleman/features/cache_buster"
+  autoload :DefaultHelpers,      "middleman/features/default_helpers"
+  autoload :AutomaticImageSizes, "middleman/features/automatic_image_sizes"
+  autoload :UglyHaml,            "middleman/features/ugly_haml"
+  autoload :MinifyCss,           "middleman/features/minify_css"
+  autoload :MinifyJavascript,    "middleman/features/minify_javascript"
+  autoload :Slickmap,            "middleman/features/slickmap"
+  autoload :SmushPNGs,           "middleman/features/smush_pngs"
+  autoload :CodeRay,             "middleman/features/code_ray"
+  autoload :Partials,             "middleman/features/partials"
+  # autoload :LiveReload,          "middleman/features/live_reload"
+
+  class << self
+    def registered(app)
+      app.extend ClassMethods
+    end
+    alias :included :registered
+  end
+
+  module ClassMethods
+    def activate(feature_name)
+      mod_name = feature_name.to_s.camelize
+      if Middleman::Features.const_defined?(mod_name)
+        register Middleman::Features.const_get(mod_name)
+      end
+    end
+
+    def enable(feature_name)
+      $stderr.puts "Warning: Feature activation has been renamed from enable to activate"
+      activate(feature_name)
+      super(feature_name)
+    end
+  end
+end

data/lib/middleman/renderers/haml.rb

@@ -0,0 +1,42 @@
+require "haml"
+
+module Middleman
+  module Renderers
+    module Haml
+      class << self
+        def registered(app)
+          app.helpers Middleman::Renderers::Haml::Helpers
+        end
+        alias :included :registered
+      end
+      
+      module Helpers
+        def haml_partial(name, options = {})
+          partial(name, options)
+        end
+      end
+  
+      module Table
+        include ::Haml::Filters::Base
+
+        def render(text)
+          output = '<div class="table"><table cellspacing="0" cellpadding="0">'
+          line_num = 0
+          text.each_line do |line|
+            line_num += 1
+            next if line.strip.empty?
+            output << %Q{<tr class="#{(line_num % 2 == 0) ? "even" : "odd" }#{(line_num == 1) ? " first" : "" }">}
+
+            columns = line.split("|").map { |p| p.strip }
+            columns.each_with_index do |col, i|
+              output << %Q{<td class="col#{i+1}">#{col}</td>}
+            end
+
+            output << "</tr>"
+          end
+          output + "</table></div>"
+        end
+      end
+    end
+  end
+end

data/lib/middleman/renderers/sass.rb

@@ -0,0 +1,70 @@
+require "sass"
+require "compass"
+require "lemonade"
+
+module Middleman
+  module Renderers
+    module Sass
+      class << self
+        def registered(app)
+          app.after_feature_init do
+            ::Compass.configuration do |config|
+              config.cache_path            = File.join(self.root, ".sass-cache") # For sassc files
+              config.project_path          = self.root
+              config.sass_dir              = File.join(File.basename(self.views), self.css_dir)
+              config.output_style          = :nested
+              config.fonts_dir             = File.join(File.basename(self.public), self.fonts_dir)
+              config.css_dir               = File.join(File.basename(self.public), self.css_dir)
+              config.images_dir            = File.join(File.basename(self.public), self.images_dir)
+              config.http_images_path      = self.http_images_path rescue File.join(self.http_prefix || "/", self.images_dir)
+              config.http_stylesheets_path = self.http_css_path rescue File.join(self.http_prefix || "/", self.css_dir)
+              config.asset_cache_buster { false }
+
+              config.add_import_path(config.sass_dir)
+            end
+
+            configure :build do
+              ::Compass.configuration do |config|
+                config.css_dir       = File.join(File.basename(self.build_dir), self.css_dir)
+                config.images_dir    = File.join(File.basename(self.build_dir), self.images_dir)
+              end
+            end
+          end
+        end
+        alias :included :registered
+      end
+    end
+  end
+end
+
+class Tilt::SassPlusCSSFilenameTemplate < Tilt::SassTemplate
+  def sass_options
+    location_of_sass_file = Middleman::Server.environment == :build ?
+                              File.join(Middleman::Server.root, Middleman::Server.build_dir) :
+                              Middleman::Server.public
+
+    parts = basename.split('.')
+    parts.pop
+    css_filename = File.join(location_of_sass_file, Middleman::Server.css_dir, parts.join("."))
+    super.merge(::Compass.configuration.to_sass_engine_options).merge(:css_filename => css_filename)
+  end
+end
+Tilt.register 'sass', Tilt::SassPlusCSSFilenameTemplate
+
+class Tilt::ScssPlusCSSFilenameTemplate < Tilt::SassPlusCSSFilenameTemplate
+  def sass_options
+    super.merge(:syntax => :scss)
+  end
+end
+Tilt.register 'scss', Tilt::ScssPlusCSSFilenameTemplate
+
+
+module Middleman::Renderers::Haml
+  module Sass
+    include ::Haml::Filters::Base
+
+    def render(text)
+      ::Sass::Engine.new(text, ::Compass.configuration.to_sass_engine_options).render
+    end
+  end
+end

data/lib/middleman/server.rb

@@ -0,0 +1,165 @@
+# We're riding on Sinatra, so let's include it.
+require "sinatra/base"
+
+# Use the padrino project's helpers
+require "padrino-core/application/rendering"
+require "padrino-helpers"
+
+module Middleman
+  class Server < Sinatra::Base
+    # Basic Sinatra config
+    set :app_file,    __FILE__
+    set :root,        ENV["MM_DIR"] || Dir.pwd
+    set :reload,      false
+    set :sessions,    false
+    set :logging,     false
+    set :environment, (ENV['MM_ENV'] && ENV['MM_ENV'].to_sym) || :development
+
+    # Import padrino helper methods
+
+    # 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 :fonts_dir,   "fonts"       # Where to look for fonts
+
+    set :build_dir,   ENV['MM_ENV'] || 'build'       # Which folder are builds output to
+    set :http_prefix, nil           # During build, add a prefix for absolute paths
+
+    # Use Padrino Helpers
+    register Padrino::Helpers
+    set :asset_stamp, false         # Disable Padrino cache buster until explicitly enabled
+
+    # Activate custom features
+    register Middleman::Features
+
+    # Activate built-in helpers
+    register Middleman::Features::DefaultHelpers
+
+    # Tilt-aware renderer
+    register Padrino::Rendering
+
+    # Override Sinatra's set to accept a block
+    def self.set(option, value=self, &block)
+      if block_given?
+        value = Proc.new { block }
+      end
+
+      super(option, value, &nil)
+    end
+
+    # An array of callback procs to run after all features have been setup
+    @@run_after_features = []
+
+    # Add a block/proc to be run after features have been setup
+    def self.after_feature_init(&block)
+      @@run_after_features << block
+    end
+
+    # Activate custom renderers
+    register Middleman::Renderers::Haml
+    register Middleman::Renderers::Sass
+
+    # Rack helper for adding mime-types during local preview
+    def self.mime(ext, type)
+      ext = ".#{ext}" unless ext.to_s[0] == ?.
+      ::Rack::Mime::MIME_TYPES[ext.to_s] = type
+    end
+
+    # Default layout name
+    layout :layout
+
+    def self.current_layout
+      @layout
+    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 self.with_layout(layout_name, &block)
+      old_layout = current_layout
+
+      layout(layout_name)
+      class_eval(&block) if block_given?
+    ensure
+      layout(old_layout)
+    end
+
+    # The page method allows the layout to be set on a specific path
+    # page "/about.html", :layout => false
+    # page "/", :layout => :homepage_layout
+    def self.page(url, options={}, &block)
+      url << settings.index_file if url.match(%r{/$})
+
+      options[:layout] ||= current_layout
+      get(url) do
+        return yield if block_given?
+        process_request(options)
+      end
+    end
+
+    # This will match all requests not overridden in the project's config.rb
+    not_found do
+      process_request
+    end
+
+  private
+    # Internal method to look for templates and evaluate them if found
+    def process_request(options={})
+      # Normalize the path and add index if we're looking at a directory
+      path = request.path
+      path << settings.index_file if path.match(%r{/$})
+      path.gsub!(%r{^/}, '')
+
+      old_layout = settings.current_layout
+      settings.layout(options[:layout]) if !options[:layout].nil?
+      result = render(path, :layout => settings.fetch_layout_path.to_sym)
+      settings.layout(old_layout)
+
+      if result
+        content_type mime_type(File.extname(path)), :charset => 'utf-8'
+        status 200
+        return result
+      end
+
+      status 404
+    rescue Padrino::Rendering::TemplateNotFound
+      $stderr.puts "File not found: #{request.path}"
+      status 404
+    end
+  end
+end
+
+require "middleman/assets"
+
+# The Rack App
+class Middleman::Server
+  def self.new(*args, &block)
+    # If the old init.rb exists, use it, but issue warning
+    old_config = File.join(self.root, "init.rb")
+    if File.exists? old_config
+      $stderr.puts "== Warning: The init.rb file has been renamed to config.rb"
+      local_config = old_config
+    end
+
+    # Check for and evaluate local configuration
+    local_config ||= File.join(self.root, "config.rb")
+    if File.exists? local_config
+      $stderr.puts "== Reading:  Local config" if logging?
+      Middleman::Server.class_eval File.read(local_config)
+      set :app_file, File.expand_path(local_config)
+    end
+
+    use ::Rack::ConditionalGet if environment == :development
+
+    @@run_after_features.each { |block| class_eval(&block) }
+
+    super
+  end
+end

data/lib/middleman/template/config.rbt

@@ -0,0 +1,64 @@
+# Automatic sitemaps
+# activate :slickmap
+
+# CodeRay syntax highlighting in Haml
+# activate :code_ray
+
+# Automatic image dimension calculations
+# activate :automatic_image_sizes
+
+# Per-page layout changes
+# With no layout
+# page "/path/to/file.html", :layout => false
+# With alternative layout
+# page "/path/to/file.html", :layout => :otherlayout
+
+# Helpers
+helpers do
+  def some_helper(*args)
+    "Helping"
+  end
+end
+
+<% if css_dir %>
+set :css_dir, "<%= css_dir -%>"
+<% else %>
+# Change the CSS directory
+# set :css_dir, "alternative_css_directory"
+<% end %>
+
+<% if js_dir %>
+set :js_dir, "<%= js_dir -%>"
+<% else %>
+# Change the JS directory
+# set :js_dir, "alternative_js_directory"
+<% end %>
+
+<% if images_dir %>
+set :images_dir, "<%= images_dir -%>"
+<% else %>
+# Change the images directory
+# set :images_dir, "alternative_image_directory"
+<% end %>
+
+# Build-specific configuration
+configure :build do
+  # For example, change the Compass output style for deployment
+  # activate :minify_css
+  
+  # Minify Javascript on build
+  # activate :minify_javascript
+  
+  # Shrink/smush PNG/JPEGs on build
+  # activate :smush_pngs
+  
+  # Enable cache buster
+  # activate :cache_buster
+
+  # Generate ugly/obfuscated HTML from Haml
+  # activate :ugly_haml
+
+  
+  # Or use a different image path
+  # set :http_path, "/Content/images/"
+end

data/lib/middleman/template/views/index.html.haml

@@ -0,0 +1,4 @@
+- content_for :head do
+  %title The Middleman!
+
+%h1 The Middleman is watching.

data/lib/middleman/template/views/layout.haml

@@ -0,0 +1,13 @@
+!!! Strict
+%html{ :xmlns => "http://www.w3.org/1999/xhtml", "xml:lang" => "en", :lang => "en" }
+  %head
+    %meta{ :content => "text/html; charset=utf-8", "http-equiv" => "Content-Type" }
+    / Comment in layout
+    = stylesheet_link_tag "site.css"
+    :javascript
+      // Comment in javascript
+    = yield_content :head
+    
+  %body{ :class => page_classes }
+    #frame
+      = yield

data/lib/middleman/template/views/stylesheets/site.css.sass

@@ -0,0 +1,27 @@
+@import "compass"
+@import "blueprint"
+
+$font-color:         #2a2a2a
+$link-color:         #0388a6
+$link-hover-color:   #009ce0
+$link-focus-color:   $link-color
+$link-active-color:  $link-color
+$link-visited-color: $link-color
+
+$blueprint-font-family:  'Century Gothic', 'Apple Gothic', 'Helvetica Neue', arial, sans-serif
+$blueprint-font-size:    13px
+$blueprint-grid-columns: 12
+$blueprint-grid-width:   60px
+$blueprint-grid-margin:  20px
+
++global-reset
+
++blueprint-typography
+
+a
+  +link-colors($link-color, $link-hover-color, $link-focus-color, $link-active-color, $link-visited-color)
+
+#frame
+  padding: 50px
+  text-align: center
+  +container

data/lib/middleman/templater+dynamic_renderer.rb

@@ -0,0 +1,26 @@
+require 'rack/test' # Use Rack::Test to access Sinatra without starting up a full server
+
+# Monkey-patch to use a dynamic renderer
+class Templater::Actions::File
+  def identical?
+    if exists?
+      return true if File.mtime(source) < File.mtime(destination)
+      FileUtils.identical?(source, destination)
+    else
+      false
+    end
+  end
+end
+
+class Templater::Actions::Template
+  def render
+    @@rack_test ||= Rack::Test::Session.new(Rack::MockSession.new(Middleman::Server))
+    
+    @render_cache ||= begin
+      # The default render just requests the page over Rack and writes the response
+      request_path = destination.gsub(File.join(Dir.pwd, Middleman::Server.build_dir), "")
+      @@rack_test.get(request_path)
+      @@rack_test.last_response.body
+    end
+  end
+end

data/lib/middleman.rb

@@ -0,0 +1,15 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+
+require 'rubygems'
+
+module Middleman
+  autoload :Server, "middleman/server"
+  
+  module Renderers
+    autoload :Haml, "middleman/renderers/haml"
+    autoload :Sass, "middleman/renderers/sass"
+  end
+
+  autoload :Features, "middleman/features"
+end