middleman-core 3.0.0.alpha.7

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

@@ -0,0 +1,139 @@
+module Middleman::Sitemap
+  class Store
+    attr_accessor :app
+    
+    def initialize(app)
+      @app = app
+      @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)
+    end
+    
+    def file_to_path(file)
+      file = File.expand_path(file, @app.root)
+      
+      prefix = @app.source_dir.sub(/\/$/, "") + "/"
+      return false unless file.include?(prefix)
+      
+      path = file.sub(prefix, "")
+      path = extensionless_path(path)
+      
+      path
+    end
+    
+    def touch_file(file)
+      return false if file == @app.source_dir || File.directory?(file)
+      
+      path = file_to_path(file)
+      return false unless path
+      
+      return false if @app.ignored_sitemap_matchers.any? do |name, callback|
+        callback.call(file, path)
+      end
+          
+      # Add generic path
+      p = page(path)
+      p.source_file = File.expand_path(file, @app.root)
+      p.touch
+      
+      true
+    end
+    
+    def sitemap_should_ignore?(file, path)
+      @app.sitemap_ignore.every(&:call)
+    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-core/sitemap/template.rb

@@ -0,0 +1,82 @@
+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 touch
+      app.cache.remove(:metadata, source_file)
+    end
+    
+    def metadata
+      metadata = app.cache.fetch(:metadata, source_file) do
+        data = { :options => {}, :locals => {}, :page => {} }
+        
+        app.provides_metadata.each do |callback, matcher|
+          next if !matcher.nil? && !source_file.match(matcher)
+          result = app.instance_exec(source_file, &callback)
+          data = data.deep_merge(result)
+        end
+        
+        data
+      end
+      
+      app.provides_metadata_for_path.each do |callback, matcher|
+        next if !matcher.nil? && !path.match(matcher)
+        result = app.instance_exec(path, &callback)
+        metadata = metadata.deep_merge(result)
+      end
+      
+      metadata
+    end
+
+    def render(opts={}, locs={}, &block)
+      puts "== Render Start: #{source_file}" if app.logging?
+      
+      md   = metadata.dup
+      opts = options.deep_merge(md[:options]).deep_merge(opts)
+      locs = locals.deep_merge(md[:locals]).deep_merge(locs)
+      
+      # Forward remaining data to helpers
+      if md.has_key?(:page)
+        app.data_content("page", md[:page])
+      end
+      
+      blocks.compact.each do |block|
+        app.instance_eval(&block)
+      end
+      
+      app.instance_eval(&block) if block_given?
+      result = app.render_template(source_file, locs, opts)
+      
+      puts "== Render End: #{source_file}" if app.logging?
+      result
+    end
+  end
+end

data/lib/middleman-core/step_definitions.rb

@@ -0,0 +1,12 @@
+MIDDLEMAN_ROOT_PATH = File.dirname(File.dirname(File.dirname(__FILE__)))
+MIDDLEMAN_BIN_PATH  = File.join(MIDDLEMAN_ROOT_PATH, "bin")
+ENV['PATH'] = "#{MIDDLEMAN_BIN_PATH}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+
+require "aruba/cucumber"
+require "middleman-core/step_definitions/middleman_steps"
+require "middleman-core/step_definitions/builder_steps"
+require "middleman-core/step_definitions/server_steps"
+
+Before do
+  @aruba_timeout_seconds = 30
+end

data/lib/middleman-core/step_definitions/builder_steps.rb

@@ -0,0 +1,42 @@
+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(current_dir, "config.rb")
+  FileUtils.cp(config_path, config_dest)
+end
+
+Given /^a fixture app "([^\"]*)"$/ do |path|
+  step %Q{a directory named "#{path}"}
+
+  target_path = File.join(PROJECT_ROOT_PATH, "fixtures", path)
+  FileUtils.cp_r(target_path, current_dir)
+  
+  step %Q{I cd to "#{path}"}
+end
+
+Given /^a built app at "([^\"]*)"$/ do |path|
+  step %Q{a fixture app "#{path}"}
+  step %Q{I run `middleman build`}
+end
+
+Given /^was successfully built$/ do
+  step %Q{a directory named "build" should exist}
+  step %Q{the exit status should be 0}
+end
+
+Given /^a successfully built app at "([^\"]*)"$/ do |path|
+  step %Q{a built app at "#{path}"}
+  step %Q{was successfully built}
+end
+
+Given /^a built app at "([^\"]*)" with flags "([^\"]*)"$/ do |path, flags|
+  step %Q{a fixture app "#{path}"}
+  step %Q{I run `middleman build #{flags}`}
+end
+
+Given /^a successfully built app at "([^\"]*)" with flags "([^\"]*)"$/ do |path, flags|
+  step %Q{a built app at "#{path}" with flags "#{flags}"}
+  step %Q{was successfully built}
+end

data/lib/middleman-core/step_definitions/middleman_steps.rb

@@ -0,0 +1,15 @@
+require "fileutils"
+
+Given /^a project at "([^\"]*)"$/ do |dirname|
+  @target = File.join(PROJECT_ROOT_PATH, "fixtures", dirname)
+end
+
+Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
+  file_path = File.expand_path(path, @target)
+  File.open(file_path, 'w') { |f| f.write(contents) }
+  step %Q{the file "#{path}" did change}
+end
+
+Then /^the file "([^\"]*)" did change$/ do |path|
+  @server_inst.file_did_change(path)
+end

data/lib/middleman-core/step_definitions/server_steps.rb

@@ -0,0 +1,73 @@
+require "rack/test"
+
+Given /^a clean server$/ do
+  @initialize_commands = []
+end
+
+Given /^"([^\"]*)" feature is "([^\"]*)"$/ do |feature, state|
+  @initialize_commands ||= []
+  
+  if state == "enabled"
+    @initialize_commands << lambda { activate(feature.to_sym) }
+  end
+end
+
+Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
+  @initialize_commands ||= []
+  @initialize_commands << lambda { set(variable.to_sym, value) }
+end
+
+Given /^current environment is "([^\"]*)"$/ do |env|
+  @current_env = env.to_sym
+end
+
+Given /^the Server is running at "([^\"]*)"$/ do |app_path|
+  step %Q{a project at "#{app_path}"}
+
+  root_dir = File.join(PROJECT_ROOT_PATH, "fixtures", app_path)
+  if File.exists?(File.join(root_dir, "source"))
+    ENV["MM_SOURCE"] = "source"
+  else
+    ENV["MM_SOURCE"] = ""
+  end
+  
+  initialize_commands = @initialize_commands || []
+  initialize_commands.unshift lambda { 
+    set :root, root_dir
+    set :environment, @current_env || :development
+    set :show_exceptions, false
+  }
+  
+  @server_inst = Middleman.server.inst do
+    initialize_commands.each do |p|
+      instance_exec(&p)
+    end
+  end
+  
+  app_rack = @server_inst.class.to_rack_app
+  @browser = ::Rack::Test::Session.new(::Rack::MockSession.new(app_rack))
+end
+
+When /^I go to "([^\"]*)"$/ do |url|
+  @browser.get(url)
+end
+
+Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
+  lambda { @browser.get(url) }.should_not raise_exception
+end
+
+Then /^I should see "([^\"]*)"$/ do |expected|
+  @browser.last_response.body.should include(expected)
+end
+
+Then /^I should see '([^\']*)'$/ do |expected|
+  @browser.last_response.body.should include(expected)
+end
+
+Then /^I should not see "([^\"]*)"$/ do |expected|
+  @browser.last_response.body.should_not include(expected)
+end
+
+Then /^I should see "([^\"]*)" lines$/ do |lines|
+  @browser.last_response.body.chomp.split($/).length.should == lines.to_i
+end

data/lib/middleman-core/templates.rb

@@ -0,0 +1,82 @@
+# Use thor for template generation
+require "thor"
+require "thor/group"
+
+# Templates namespace
+module Middleman::Templates
+  
+  # Static methods
+  class << self
+    
+    # Get list of registered templates and add new ones
+    # 
+    #     Middleman::Templates.register(:ext_name, klass)
+    #
+    # @param [Symbol] name The name of the template
+    # @param [Class] klass The class to be executed for this template
+    # @return [Hash] List of registered templates
+    def register(*args)
+      @_template_mappings ||= {}
+      @_template_mappings[args[0]] = args[1] if args.length == 2
+      @_template_mappings
+    end
+    
+    # Middleman::Templates.register(name, klass)
+    alias :registered :register
+  end
+  
+  # Base Template class. Handles basic options and paths.
+  class Base < ::Thor::Group
+    include Thor::Actions
+    
+    # Required path for the new project to be generated
+    argument :location, :type => :string
+    
+    # Name of the template being used to generate the project.
+    class_option :template, :default => "default"
+    
+    # What to call the directory which CSS will be searched for.
+    class_option :css_dir, :default => "stylesheets"
+    
+    # What to call the directory which JS will be searched for.
+    class_option :js_dir, :default => "javascripts"
+    
+    # What to call the directory which images will be searched for.
+    class_option :images_dir, :default => "images"
+    
+    # Output a config.ru file for Rack if --rack is passed
+    class_option :rack, :type => :boolean, :default => false
+    
+    # Write a Rack config.ru file for project
+    # @return [void]
+    def generate_rack!
+      return unless options[:rack]
+      template "shared/config.ru", File.join(location, "config.ru")
+    end
+    
+    # Output a Gemfile file for Bundler if --bundler is passed
+    class_option :bundler, :type => :boolean, :default => false
+    
+    # Write a Bundler Gemfile file for project
+    # @return [void]
+    def generate_bundler!
+      return unless options[:bundler]
+      template "shared/Gemfile.tt", File.join(location, "Gemfile")
+      
+      say_status :run, "bundle install"
+      print `cd #{location} && "#{Gem.ruby}" -rubygems "#{Gem.bin_path('bundler', 'bundle')}" install`
+    end
+  end
+end
+
+# Default template
+require "middleman-core/templates/default"
+
+# HTML5 template
+require "middleman-core/templates/html5"
+
+# HTML5 Mobile template
+require "middleman-core/templates/mobile"
+
+# Local templates
+require "middleman-core/templates/local"