middleman 3.0.0.alpha.4 → 3.0.0.alpha.5

data/lib/middleman/cli/init.rb

@@ -0,0 +1,47 @@
+module Middleman::Cli
+  class Init < Thor
+    check_unknown_options!
+    
+    namespace :init
+    
+    desc "init NAME [options]", "Create new project NAME"
+    available_templates = ::Middleman::Templates.registered.keys.join(", ")
+    # argument :name
+    method_option "template", 
+      :aliases => "-T", 
+      :default => "default",
+      :desc    => "Use a project template: #{available_templates}"
+    method_option "css_dir", 
+      :default => "stylesheets", 
+      :desc    => 'The path to the css files'
+    method_option "js_dir", 
+      :default => "javascripts", 
+      :desc    => 'The path to the javascript files'
+    method_option "images_dir", 
+      :default => "images", 
+      :desc    => 'The path to the image files'
+    method_option "rack", 
+      :type    => :boolean, 
+      :default => false, 
+      :desc    => 'Include a config.ru file'
+    method_option "bundler", 
+      :type    => :boolean, 
+      :default => false, 
+      :desc    => 'Create a Gemfile and use Bundler to manage gems'
+    def init(name)
+      key = options[:template].to_sym
+      unless ::Middleman::Templates.registered.has_key?(key)
+        raise Thor::Error.new "Unknown project template '#{key}'"
+      end
+      
+      thor_group = ::Middleman::Templates.registered[key]
+      thor_group.new([name], options).invoke_all
+    end
+  end
+  
+  Base.map({
+    "i"   => "init",
+    "new" => "init",
+    "n"   => "init"
+  })
+end

data/lib/middleman/cli/server.rb

@@ -0,0 +1,41 @@
+module Middleman::Cli
+  class Server < Thor
+    check_unknown_options!
+    
+    namespace :server
+    
+    desc "server [options]", "Start the preview server"
+    method_option "environment", 
+      :aliases => "-e", 
+      :default => ENV['MM_ENV'] || ENV['RACK_ENV'] || 'development', 
+      :desc    => "The environment Middleman will run under"
+    method_option :host,
+      :type => :string,
+      :aliases => "-h",
+      # :required => true,
+      :default => "0.0.0.0", 
+      :desc => "Bind to HOST address"
+    method_option "port",
+      :aliases => "-p", 
+      :default => "4567", 
+      :desc    => "The port Middleman will listen on"
+    method_option "debug", 
+      :type    => :boolean, 
+      :default => false,
+      :desc    => 'Print debug messages'
+    def server
+      params = {
+        :port        => options["port"],
+        :host        => options["host"],
+        :environment => options["environment"],
+        :debug       => options["debug"]
+      }
+      
+      puts "== The Middleman is loading"
+      Middleman::Guard.start(params)
+    end
+  end
+  
+  Base.map({ "s" => "server" })
+  Base.default_task :server
+end

data/lib/middleman/core_extensions/assets.rb

@@ -21,6 +21,7 @@ module Middleman::CoreExtensions::Assets
     #
     # @param [String] path The path (such as "photo.jpg")
     # @param [String] prefix The type prefix (such as "images")
+    # @return [String] The fully qualified asset url
     def asset_url(path, prefix="")
       # Don't touch assets which already have a full path
       path.include?("://") ? path : File.join(http_prefix, prefix, path)

data/lib/middleman/core_extensions/builder.rb

@@ -1,13 +1,22 @@
+# Convenience methods to allow config.rb to talk to the Builder
 module Middleman::CoreExtensions::Builder
+  
+  # Extension registered
   class << self
+    # @private
     def registered(app)
       app.define_hook :after_build
       app.extend ClassMethods
       app.send :include, InstanceMethods
     end
+    alias :included :registered
   end
   
+  # Build Class Methods
   module ClassMethods
+    # Get a list of callbacks which can modify a files build path
+    #
+    # @return [Array<Proc>]
     def build_reroute(&block)
       @build_rerouters ||= []
       @build_rerouters << block if block_given?
@@ -15,11 +24,20 @@ module Middleman::CoreExtensions::Builder
     end
   end
   
+  # Build Instance Methods
   module InstanceMethods
+    # Forward to class method
+    #
+    # @return [Array<Proc>]
     def build_reroute(&block)
       self.class.build_reroute(&block)
     end
     
+    # Run through callbacks and get the new values
+    #
+    # @param [String] destination The current destination of the built file
+    # @param [String] request_path The current request path of the file
+    # @return [Array<String>] The new values
     def reroute_builder(destination, request_path)
       result = [destination, request_path]
       

data/lib/middleman/core_extensions/compass.rb

@@ -1,5 +1,10 @@
+# Forward the settings on config.rb and the result of registered extensions
+# to Compass
 module Middleman::CoreExtensions::Compass
+  
+  # Extension registered
   class << self
+    # @private
     def registered(app)
       require "compass"
       
@@ -47,7 +52,7 @@ module Middleman::CoreExtensions::Compass
           config.output_style = :nested
         end
         
-        # Required for relative paths
+        # Change paths when in build mode. Required for relative paths
         configure :build do
           ::Compass.configuration do |config|
             config.environment = :production

data/lib/middleman/core_extensions/data.rb

@@ -1,9 +1,17 @@
+# Data formats
 require "yaml"
 require "active_support/json"
+
+# Using Thor's indifferent hash access
 require "thor"
 
+# The data extension parses YAML and JSON files in the data/ directory
+# and makes them available to config.rb, templates and extensions
 module Middleman::CoreExtensions::Data
+  
+  # Extension registered
   class << self
+    # @private
     def registered(app)
       app.set :data_dir, "data"
       app.send :include, InstanceMethods
@@ -11,7 +19,10 @@ module Middleman::CoreExtensions::Data
     alias :included :registered
   end
   
+  # Instance methods
   module InstanceMethods
+    # Setup data files before anything else so they are available when
+    # parsing config.rb
     def initialize
       file_changed DataStore.matcher do |file|
         data.touch_file(file) if file.match(%r{^#{data_dir}\/})
@@ -24,43 +35,77 @@ module Middleman::CoreExtensions::Data
       super
     end
     
+    # The data object
+    #
+    # @return [DataStore]
     def data
       @data ||= DataStore.new(self)
     end
 
     # Makes a hash available on the data var with a given name
+    #
+    # @param [Symbol] name Name of the data, used for namespacing
+    # @param [Hash] content The content for this data
+    # @return [void]
     def data_content(name, content)
       DataStore.data_content(name, content)
     end
 
     # Makes a hash available on the data var with a given name
+    #
+    # @param [Symbol] name Name of the data, used for namespacing
+    # @return [void]
     def data_callback(name, &block)
       DataStore.data_callback(name, block)
     end
   end
   
+  # The core logic behind the data extension.
   class DataStore
+    
+    # Static methods
     class << self
+      
+      # The regex which tells Middleman which files are for data
+      #
+      # @return [Regexp]
       def matcher
         %r{[\w-]+\.(yml|yaml|json)$}
       end
 
+      # Store static data hash
+      #
+      # @param [Symbol] name Name of the data, used for namespacing
+      # @param [Hash] content The content for this data
+      # @return [void]
       def data_content(name, content)
         @@local_sources ||= {}
         @@local_sources[name.to_s] = content
       end
 
+      # Store callback-based data
+      #
+      # @param [Symbol] name Name of the data, used for namespacing
+      # @param [Proc] proc The callback which will return data
+      # @return [void]
       def data_callback(name, proc)
         @@callback_sources ||= {}
         @@callback_sources[name.to_s] = proc
       end
     end
     
+    # Setup data store
+    #
+    # @param [Middleman::Base] app The current instance of Middleman
     def initialize(app)
       @app = app
       @local_data = {}
     end
     
+    # Update the internal cache for a given file path
+    #
+    # @param [String] file The file to be re-parsed
+    # @return [void]
     def touch_file(file)
       file = File.expand_path(file, @app.root)
       extension = File.extname(file)
@@ -74,16 +119,23 @@ module Middleman::CoreExtensions::Data
         return
       end
 
-      # @app.logger.debug :data_update, Time.now, basename if @app.logging?
       @local_data[basename] = recursively_enhance(data)
     end
     
+    # Remove a given file from the internal cache
+    #
+    # @param [String] file The file to be cleared
+    # @return [void]
     def remove_file(file)
       extension = File.extname(file)
       basename  = File.basename(file, extension)
       @local_data.delete(basename) if @local_data.has_key?(basename)
     end
     
+    # Get a hash hash from either internal static data or a callback
+    #
+    # @param [String, Symbol] path The name of the data namespace
+    # @return [Hash, nil]
     def data_for_path(path)
       response = nil
       
@@ -99,6 +151,10 @@ module Middleman::CoreExtensions::Data
       response
     end
     
+    # "Magically" find namespaces of data if they exist
+    #
+    # @param [String] path The namespace to search for
+    # @return [Hash, nil]
     def method_missing(path)
       if @local_data.has_key?(path.to_s)
         return @local_data[path.to_s]
@@ -113,6 +169,9 @@ module Middleman::CoreExtensions::Data
       super
     end
     
+    # Convert all the data into a static hash
+    #
+    # @return [Hash]
     def to_h
       data = {}
       
@@ -134,7 +193,12 @@ module Middleman::CoreExtensions::Data
       data
     end
   
-  private
+  private 
+    # Recursively convert a normal Hash into a HashWithIndifferentAccess
+    #
+    # @private
+    # @param [Hash] data Normal hash
+    # @return [Thor::CoreExt::HashWithIndifferentAccess]
     def recursively_enhance(data)
       if data.is_a? Hash
         data = Thor::CoreExt::HashWithIndifferentAccess.new(data)

data/lib/middleman/core_extensions/sprockets.rb

@@ -1,5 +1,4 @@
 require 'pathname'
-require 'rbconfig'
 require "sprockets"
 
 module Middleman::CoreExtensions::Sprockets

data/lib/middleman/guard.rb

@@ -6,8 +6,7 @@ require "guard/guard"
 require "net/http"
 
 # Support forking on Windows
-require "rbconfig"
-require "win32/process" if RbConfig::CONFIG['host_os'].downcase =~ %r{mingw}
+require "win32/process" if Middleman::WINDOWS
 
 module Middleman::Guard
   def self.start(options={})
@@ -21,7 +20,8 @@ module Middleman::Guard
           watch(%r{(.*)})
         end
       },
-      :watch_all_modifications => true
+      :watch_all_modifications => true,
+      :no_interactions => true
     })
   end
 end
@@ -41,36 +41,50 @@ module Guard
     def initialize(watchers = [], options = {})
       super
       @options = options
+
+      # Trap the interupt signal and shut down Guard (and thus the server) smoothly
+      trap(kill_command) do 
+        ::Guard.stop
+        exit!(0)
+      end
     end
     
     # Start Middleman in a fork
     def start
-      @server_job = fork do
-        env = (@options[:environment] || "development").to_sym
-        is_logging = @options.has_key?(:debug) && (@options[:debug] == "true")
-        app = ::Middleman.server.inst do
-          set :environment, env
-          set :logging, is_logging
-        end
-        
-        require "thin"
-        ::Thin::Logging.silent = !is_logging
-        
-        app_rack = app.class.to_rack_app
-        
-        opts = @options.dup
-        opts[:app] = app_rack
-        puts "== The Middleman is standing watch on port #{opts[:port]||4567}"
-        ::Middleman.start_server(opts)
+      if ::Middleman::JRUBY
+        thread = Thread.new { bootup }
+        thread.join
+      else
+        @server_job = fork { bootup }
       end
     end
     
+    def bootup
+      env = (@options[:environment] || "development").to_sym
+      is_logging = @options.has_key?(:debug) && (@options[:debug] == "true")
+      app = ::Middleman.server.inst do
+        set :environment, env
+        set :logging, is_logging
+      end
+      
+      app_rack = app.class.to_rack_app
+      
+      opts = @options.dup
+      opts[:app] = app_rack
+      opts[:logging] = is_logging
+      puts "== The Middleman is standing watch on port #{opts[:port]||4567}"
+      ::Middleman.start_server(opts)
+    end
+    
     # Stop the forked Middleman
     def stop
       puts "== The Middleman is shutting down"
-      Process.kill("KILL", @server_job)
-      Process.wait @server_job
-      @server_job = nil
+      if ::Middleman::JRUBY
+      else
+        Process.kill(kill_command, @server_job)
+        Process.wait @server_job
+        @server_job = nil
+      end
     end
     
     # Simply stop, then start
@@ -115,11 +129,9 @@ module Guard
       uri = URI.parse("http://#{@options[:host]}:#{@options[:port]}/__middleman__")
       Net::HTTP.post_form(uri, {}.merge(params))
     end
+    
+    def kill_command
+      ::Middleman::WINDOWS ? 1 : :INT
+    end
   end
-end
-
-# Trap the interupt signal and shut down Guard (and thus the server) smoothly
-trap(:INT) do 
-  ::Guard.stop
-  exit
 end

data/lib/middleman/step_definitions.rb

@@ -1,7 +1,13 @@
 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/step_definitions/middleman_steps"
 require "middleman/step_definitions/builder_steps"
 require "middleman/step_definitions/generator_steps"
-require "middleman/step_definitions/server_steps"
+require "middleman/step_definitions/server_steps"
+
+Before do
+  @aruba_timeout_seconds = 30
+end