middleman 3.0.0.alpha.2 → 3.0.0.alpha.3

data/lib/middleman/renderers/haml.rb

@@ -0,0 +1,13 @@
+module Middleman::Renderers::Haml
+  class << self
+    def registered(app)
+      require "haml"
+      app.send :include, ::Haml::Helpers
+      
+      app.ready do
+        init_haml_helpers
+      end
+    end
+    alias :included :registered
+  end
+end

data/lib/middleman/renderers/liquid.rb

@@ -2,15 +2,15 @@ module Middleman::Renderers::Liquid
   class << self
     def registered(app)
       # Liquid is not included in the default gems,
-      # but we'll support it if necessary.
+      # but we'll support it if available.
       begin
         require "liquid"
         
         app.after_configuration do
-          Liquid::Template.file_system = Liquid::LocalFileSystem.new(self.source_dir)
+          Liquid::Template.file_system = Liquid::LocalFileSystem.new(source_dir)
             
           provides_metadata %r{\.liquid$} do |path|
-            @locals.merge!(:data => data.to_h)
+            { :locals => { :data => data.to_h } }
           end
         end
       rescue LoadError

data/lib/middleman/renderers/markdown.rb

@@ -1,13 +1,17 @@
 module Middleman::Renderers::Markdown
   class << self
     def registered(app)
-      app.send :include, InstanceMethods
-      
+      app.set :markdown_engine, nil
+    
       begin
         require "maruku"
         app.set :markdown_engine, :maruku
       rescue LoadError
-        app.set :markdown_engine, nil
+        begin
+          require "rdiscount"
+          app.set :markdown_engine, :rdiscount
+        rescue LoadError
+        end
       end
 
       app.set :markdown_engine_prefix, ::Tilt
@@ -15,7 +19,9 @@ module Middleman::Renderers::Markdown
       app.after_configuration do
         unless markdown_engine.nil?
           if markdown_engine.is_a? Symbol
-            markdown_engine = markdown_tilt_template_from_symbol(markdown_engine)
+            engine = engine.to_s
+            engine = engine == "rdiscount" ? "RDiscount" : engine.camelize
+            markdown_engine = markdown_engine_prefix.const_get("#{engine}Template")
           end
         
           ::Tilt.prefer(markdown_engine)
@@ -24,12 +30,4 @@ module Middleman::Renderers::Markdown
     end
     alias :included :registered
   end
-  
-  module InstanceMethods
-    def markdown_tilt_template_from_symbol(engine)
-      engine = engine.to_s
-      engine = engine == "rdiscount" ? "RDiscount" : engine.camelize
-      markdown_engine_prefix.const_get("#{engine}Template")
-    end
-  end
 end

data/lib/middleman/renderers/sass.rb

@@ -10,10 +10,8 @@ module Middleman::Renderers::Sass
     end
     alias :included :registered
   end
-
+  
   class SassPlusCSSFilenameTemplate < ::Sprockets::Sass::SassTemplate
-    self.default_mime_type = "text/css"
-    
     # Add exception messaging
     def evaluate(context, locals, &block)
       begin
@@ -28,16 +26,14 @@ module Middleman::Renderers::Sass
       location_of_sass_file = if @context.build?
         File.expand_path(@context.build_dir, @context.root)
       else
-        File.expand_path(@context.views, @context.root)
+        File.expand_path(@context.source, @context.root)
       end
       
       parts = basename.split('.')
       parts.pop
       css_filename = File.join(location_of_sass_file, @context.css_dir, parts.join("."))
       
-      super.merge(
-        :css_filename => css_filename
-      )
+      super.merge(:css_filename => css_filename)
     end
   end
   ::Sprockets.register_engine ".sass", SassPlusCSSFilenameTemplate
@@ -45,8 +41,6 @@ module Middleman::Renderers::Sass
   ::Tilt.prefer(SassPlusCSSFilenameTemplate)
   
   class ScssPlusCSSFilenameTemplate < SassPlusCSSFilenameTemplate
-    self.default_mime_type = "text/css"
-    
     # Define the expected syntax for the template
     def syntax
       :scss

data/lib/middleman/sitemap/page.rb

@@ -0,0 +1,106 @@
+module Middleman::Sitemap
+  class Page
+    attr_accessor :store, :path, :proxied_to, :status
+    
+    def initialize(store, path)
+      @store       = store
+      @path        = path
+      @status      = :generic
+      @source_file = nil
+      @proxied_to  = nil
+    end
+    
+    def template?
+      if proxy?
+        store.page(proxied_to).template?
+      else
+        return false if source_file.nil?
+        !::Tilt[source_file].nil?
+      end
+    end
+    
+    def source_file=(src)
+      @source_file = src
+    end
+    
+    def source_file
+      if proxy?
+        store.page(proxied_to).source_file
+      else
+        @source_file
+      end
+    end
+    
+    def template
+      @_template ||= ::Middleman::Sitemap::Template.new(self)
+    end
+    
+    def ext
+      File.extname(path)
+    end
+    
+    def mime_type
+      app.mime_type ext
+    end
+    
+    def proxy?
+      @status == :proxy
+    end
+    
+    def proxy_to(target)
+      @status = :proxy
+      @proxied_to = target
+    end
+    
+    def generic?
+      @status == :generic
+    end
+    
+    def make_generic
+      @status = :generic
+    end
+    
+    def ignored?
+      @status == :ignored
+    end
+    
+    def ignore
+      @status = :ignored
+    end
+    
+    def touch
+    end
+    
+    def custom_render(&block)
+      @_custom_renderer ||= nil
+      @_custom_renderer = block if block_given?
+      @_custom_renderer
+    end
+    
+    def render(*args, &block)
+      return unless template?
+      
+      if proxy?
+        # Forward blocks
+        forward_blocks = template.blocks.compact
+        forward_blocks << block if block_given?
+        store.page(proxied_to).template.render(*args) do
+          forward_blocks.each do |block|
+            instance_exec(&block)
+          end
+        end
+      elsif !custom_render.nil?
+        params = args.dup
+        params << block if block_given?
+        instance_exec(*params, &custom_renderer)
+      else
+        template.render(*args, &block)
+      end
+    end
+    
+  protected
+    def app
+      @store.app
+    end
+  end
+end

data/lib/middleman/sitemap/store.rb

@@ -0,0 +1,141 @@
+module Middleman::Sitemap
+  class Store
+    attr_accessor :app
+    
+    def initialize(app)
+      @app = app
+      @source = File.expand_path(@app.source, @app.root)
+      @pages = {}
+    end
+    
+    # Check to see if we know about a specific path
+    def exists?(path)
+      @pages.has_key?(path.sub(/^\//, ""))
+    end
+    
+    def set_context(path, opts={}, blk=nil)
+      page(path) do
+        template.options = opts
+        template.blocks  = [blk]
+      end
+    end
+    
+    def ignore(path)
+      page(path) { ignore }
+      app.cache.remove(:ignored_paths)
+    end
+    
+    def proxy(path, target)
+      page(path) { proxy_to(target.sub(%r{^/}, "")) }
+      app.cache.remove(:proxied_paths)
+    end
+    
+    def page(path, &block)
+      path = path.sub(/^\//, "").gsub("%20", " ")
+      @pages[path] = ::Middleman::Sitemap::Page.new(self, path) unless @pages.has_key?(path)
+      @pages[path].instance_exec(&block) if block_given?
+      @pages[path]
+    end
+    
+    def each(&block)
+      @pages.each do |k, v|
+        yield k, v
+      end
+    end
+    
+    def all_paths
+      @pages.keys
+    end
+    
+    def ignored?(path)
+      ignored_paths.include?(path.sub(/^\//, ""))
+    end
+    
+    def ignored_paths
+      app.cache.fetch :ignored_paths do
+        @pages.values.select(&:ignored?).map(&:path)
+      end
+    end
+    
+    def generic?(path)
+      generic_paths.include?(path.sub(/^\//, ""))
+    end
+    
+    def generic_paths
+      app.cache.fetch :generic_paths do
+        @pages.values.select(&:generic?).map(&:path)
+      end
+    end
+    
+    def proxied?(path)
+      proxied_paths.include?(path.sub(/^\//, ""))
+    end
+    
+    def proxied_paths
+      app.cache.fetch :proxied_paths do
+        @pages.values.select(&:proxy?).map(&:path)
+      end
+    end
+    
+    def remove_file(file)
+      path = file_to_path(file)
+      return false unless path
+      
+      path = path.sub(/^\//, "")
+      @pages.delete(path) if @pages.has_key?(path)
+      @context_map.delete(path) if @context_map.has_key?(path)
+    end
+    
+    def file_to_path(file)
+      file = File.expand_path(file, @app.root)
+      
+      prefix = @source + "/"
+      return false unless file.include?(prefix)
+      
+      path = file.sub(prefix, "")
+      path = extensionless_path(path)
+      
+      path
+    end
+    
+    def touch_file(file)
+      return false if file == @source ||
+                      file.match(/^\./) ||
+                      (file.match(/\/\./) && !file.match(/\/\.htaccess/)) ||
+                      (file.match(/\/_/) && !file.match(/\/__/)) ||
+                      File.directory?(file)
+                     
+      path = file_to_path(file)
+      
+      return false unless path
+      
+      return false if path.match(%r{^layout}) ||
+                      path.match(%r{^layouts/})
+    
+      # @app.logger.debug :sitemap_update, Time.now, path if @app.logging?
+      
+      # Add generic path
+      page(path).source_file = File.expand_path(file, @app.root)
+      
+      true
+    end
+    
+  protected
+    def extensionless_path(file)
+      app.cache.fetch(:extensionless_path, file) do
+        path = file.dup
+
+        end_of_the_line = false
+        while !end_of_the_line
+          if !::Tilt[path].nil?
+            path = path.sub(File.extname(path), "")
+          else
+            end_of_the_line = true
+          end
+        end
+
+        path
+      end
+    end
+  end
+end

data/lib/middleman/sitemap/template.rb

@@ -0,0 +1,57 @@
+module Middleman::Sitemap
+
+  class Template
+    attr_accessor :page, :options, :locals, :blocks#, :dependencies
+  
+    def initialize(page)
+      @page    = page
+      @options = {}
+      @locals  = {}
+      @blocks  = []
+    end
+  
+    def path
+      page.path
+    end
+    
+    def source_file
+      page.source_file
+    end
+    
+    def store
+      page.store
+    end
+    
+    def app
+      store.app
+    end
+    
+    def ext
+      page.ext
+    end
+
+    def metadata
+      app.cache.fetch(:metadata, source_file) do
+        metadata = { :options => {}, :locals => {} }
+        app.provides_metadata.each do |callback, matcher|
+          next if !matcher.nil? && !source_file.match(matcher)
+          result = app.instance_exec(source_file, &callback)
+          metadata = metadata.deep_merge(result)
+        end
+        metadata
+      end
+    end
+
+    def render(opts={}, locs={}, &block)
+      opts = options.deep_merge(metadata[:options]).deep_merge(opts)
+      locs = locals.deep_merge(metadata[:locals]).deep_merge(locs)
+      
+      blocks.compact.each do |block|
+        app.instance_eval(&block)
+      end
+      
+      app.instance_eval(&block) if block_given?
+      app.render_template(source_file, locs, opts)
+    end
+  end
+end

data/lib/middleman/step_definitions.rb

@@ -0,0 +1,6 @@
+MIDDLEMAN_ROOT_PATH = File.dirname(File.dirname(File.dirname(__FILE__)))
+MIDDLEMAN_BIN_PATH  = File.join(MIDDLEMAN_ROOT_PATH, "bin")
+
+require "middleman/step_definitions/builder_steps"
+require "middleman/step_definitions/generator_steps"
+require "middleman/step_definitions/server_steps"

data/lib/middleman/step_definitions/builder_steps.rb

@@ -0,0 +1,45 @@
+require 'fileutils'
+
+Given /^app "([^\"]*)" is using config "([^\"]*)"$/ do |path, config_name|
+  target = File.join(PROJECT_ROOT_PATH, "fixtures", path)
+  config_path = File.join(target, "config-#{config_name}.rb")
+  config_dest = File.join(target, "config.rb")
+  FileUtils.cp(config_path, config_dest)
+end
+
+Given /^a built app at "([^\"]*)"$/ do |path|
+  target = File.join(PROJECT_ROOT_PATH, "fixtures", path)
+  
+  build_target = File.join(target, "build")
+  FileUtils.rm_rf(build_target)
+  
+  build_cmd = File.join(MIDDLEMAN_BIN_PATH, "middleman build")
+  `cd #{target} && #{build_cmd}`
+end
+
+Then /^cleanup built app at "([^\"]*)"$/ do |path|
+  target = File.join(PROJECT_ROOT_PATH, "fixtures", path, "build")
+  FileUtils.rm_rf(target)
+end
+
+Given /^a built app at "([^\"]*)" with flags "([^\"]*)"$/ do |path, flags|
+  target = File.join(PROJECT_ROOT_PATH, "fixtures", path)
+  build_cmd = File.join(MIDDLEMAN_BIN_PATH, "middleman build")
+  `cd #{target} && #{build_cmd} #{flags}`
+end
+
+Then /^"([^\"]*)" should exist at "([^\"]*)"$/ do |target_file, path|
+  target = File.join(PROJECT_ROOT_PATH, "fixtures", path, "build", target_file)
+  File.exists?(target).should be_true
+end
+
+Then /^"([^\"]*)" should exist at "([^\"]*)" and include "([^\"]*)"$/ do |target_file, path, expected|
+  target = File.join(PROJECT_ROOT_PATH, "fixtures", path, "build", target_file)
+  File.exists?(target).should be_true
+  File.read(target).should include(expected)
+end
+
+Then /^"([^\"]*)" should not exist at "([^\"]*)"$/ do |target_file, path|
+  target = File.join(PROJECT_ROOT_PATH, "fixtures", path, "build", target_file)
+  File.exists?(target).should be_false
+end