middleman-core-x86-mingw32 3.0.1.pre

data/lib/middleman-core/application.rb

@@ -0,0 +1,245 @@
+# Using Tilt for templating
+require "tilt"
+
+# Use ActiveSupport JSON
+require "active_support/json"
+require "active_support/core_ext/integer/inflections"
+require "active_support/core_ext/float/rounding"
+
+# Simple callback library
+require "middleman-core/vendor/hooks-0.2.0/lib/hooks"
+
+require "middleman-core/sitemap"
+
+require "middleman-core/core_extensions"
+
+# Core Middleman Class
+module Middleman
+  class Application
+    # Uses callbacks
+    include Hooks
+
+    # Before request hook
+    define_hook :before
+
+    # Ready (all loading and parsing of extensions complete) hook
+    define_hook :ready
+
+    class << self
+
+      # Mix-in helper methods. Accepts either a list of Modules
+      # and/or a block to be evaluated
+      # @return [void]
+      def helpers(*extensions, &block)
+        class_eval(&block)   if block_given?
+        include(*extensions) if extensions.any?
+      end
+
+      # Access class-wide defaults
+      #
+      # @private
+      # @return [Hash] Hash of default values
+      def defaults
+        @defaults ||= {}
+      end
+
+      # Set class-wide defaults
+      #
+      # @param [Symbol] key Unique key name
+      # @param value Default value
+      # @return [void]
+      def set(key, value=nil, &block)
+        @defaults ||= {}
+        @defaults[key] = value
+
+        @inst.set(key, value, &block) if @inst
+      end
+    end
+
+    delegate :helpers, :to => :"self.class"
+
+    # Set attributes (global variables)
+    #
+    # @param [Symbol] key Name of the attribue
+    # @param value Attribute value
+    # @return [void]
+    def set(key, value=nil, &block)
+      setter = "#{key}=".to_sym
+      self.class.send(:attr_accessor, key) if !respond_to?(setter)
+      value = block if block_given?
+      send(setter, value)
+    end
+
+    # Root project directory (overwritten in middleman build/server)
+    # @return [String]
+    set :root,        ENV["MM_ROOT"] || Dir.pwd
+
+    # Pathname-addressed root
+    def root_path
+      @_root_path ||= Pathname.new(root)
+    end
+
+    # Name of the source directory
+    # @return [String]
+    set :source,      "source"
+
+    # Middleman environment. Defaults to :development, set to :build by the build process
+    # @return [String]
+    set :environment, (ENV['MM_ENV'] && ENV['MM_ENV'].to_sym) || :development
+
+    # Which file should be used for directory indexes
+    # @return [String]
+    set :index_file,  "index.html"
+
+    # Whether to strip the index file name off links to directory indexes
+    # @return [Boolean]
+    set :strip_index_file, true
+
+    # Whether to include a trailing slash when stripping the index file
+    # @return [Boolean]
+    set :trailing_slash, true
+
+    # Location of javascripts within source.
+    # @return [String]
+    set :js_dir,      "javascripts"
+
+    # Location of stylesheets within source. Used by Compass.
+    # @return [String]
+    set :css_dir,     "stylesheets"
+
+    # Location of images within source. Used by HTML helpers and Compass.
+    # @return [String]
+    set :images_dir,  "images"
+
+    # Location of fonts within source. Used by Compass.
+    # @return [String]
+    set :fonts_dir,   "fonts"
+
+    # Where to build output files
+    # @return [String]
+    set :build_dir,   "build"
+
+    # Default prefix for building paths. Used by HTML helpers and Compass.
+    # @return [String]
+    set :http_prefix, "/"
+
+    # Default string encoding for templates and output.
+    # @return [String]
+    set :encoding,    "utf-8"
+
+    # Whether to catch and display exceptions
+    # @return [Boolean]
+    set :show_exceptions, true
+
+    # Default layout name
+    # @return [String, Symbold]
+    set :layout, :_auto_layout
+
+    # Activate custom features and extensions
+    include Middleman::CoreExtensions::Extensions
+
+    # Manage Ruby string encodings
+    include Middleman::CoreExtensions::RubyEncoding
+
+    # Basic Rack Request Handling
+    include Middleman::CoreExtensions::Request
+
+    # Handle exceptions
+    register Middleman::CoreExtensions::ShowExceptions
+
+    # Add Builder Callbacks
+    register Middleman::CoreExtensions::Builder
+
+    # Add Watcher Callbacks
+    register Middleman::CoreExtensions::FileWatcher
+
+    # Activate Data package
+    register Middleman::CoreExtensions::Data
+
+    # Setup custom rendering
+    register Middleman::CoreExtensions::Rendering
+
+    # Parse YAML from templates. Must be before sitemap so sitemap
+    # extensions see updated frontmatter!
+    register Middleman::CoreExtensions::FrontMatter
+
+    # Sitemap
+    register Middleman::Sitemap
+
+    # Setup external helpers
+    register Middleman::CoreExtensions::ExternalHelpers
+
+    # with_layout and page routing
+    register Middleman::CoreExtensions::Routing
+
+    # Initialize the Middleman project
+    def initialize(&block)
+      # Clear the static class cache
+      cache.clear
+
+      # Setup the default values from calls to set before initialization
+      self.class.superclass.defaults.each { |k,v| set(k,v) }
+
+      # Evaluate a passed block if given
+      instance_exec(&block) if block_given?
+
+      # Build expanded source path once paths have been parsed
+      path = root.dup
+      source_path = ENV["MM_SOURCE"] || self.source
+      path = File.join(root, source_path) unless source_path.empty?
+      set :source_dir, path
+
+      super
+    end
+
+    # Shared cache instance
+    #
+    # @private
+    # @return [Middleman::Util::Cache] The cache
+    def self.cache
+      @_cache ||= ::Middleman::Util::Cache.new
+    end
+    delegate :cache, :to => :"self.class"
+
+    # Whether we're in development mode
+    # @return [Boolean] If we're in dev mode
+    def development?; environment == :development; end
+
+    # Whether we're in build mode
+    # @return [Boolean] If we're in build mode
+    def build?; environment == :build; end
+
+    # Backwards compatibilty with old Sinatra template interface
+    #
+    # @return [Middleman::Application]
+    def settings
+      self
+    end
+
+    delegate :logger, :instrument, :to => ::Middleman::Util
+
+    # Work around this bug: http://bugs.ruby-lang.org/issues/4521
+    # where Ruby will call to_s/inspect while printing exception
+    # messages, which can take a long time (minutes at full CPU)
+    # if the object is huge or has cyclic references, like this.
+    def to_s
+      "#<Middleman::Application>"
+    end
+
+    # Expand a path to include the index file if it's a directory
+    #
+    # @private
+    # @param [String] path Request path
+    # @return [String] Path with index file if necessary
+    def full_path(path)
+      cache.fetch(:full_path, path) do
+        parts = path ? path.split('/') : []
+        if parts.last.nil? || parts.last.split('.').length == 1
+          path = File.join(path, index_file)
+        end
+        "/" + path.sub(%r{^/}, '')
+      end
+    end
+
+  end
+end

data/lib/middleman-core/cli/build.rb

@@ -0,0 +1,286 @@
+require "middleman-core"
+
+# CLI Module
+module Middleman::Cli
+
+  # The CLI Build class
+  class Build < Thor
+    include Thor::Actions
+
+    attr_reader :debugging
+
+    check_unknown_options!
+
+    namespace :build
+
+    desc "build [options]", "Builds the static site for deployment"
+    method_option :clean,
+      :type    => :boolean,
+      :aliases => "-c",
+      :default => false,
+      :desc    => 'Removes orphaned files or directories from build'
+    method_option :glob,
+      :type    => :string,
+      :aliases => "-g",
+      :default => nil,
+      :desc    => 'Build a subset of the project'
+    method_option :verbose,
+      :type    => :boolean,
+      :default => false,
+      :desc    => 'Print debug messages'
+    method_option :instrument,
+      :type    => :string,
+      :default => false,
+      :desc    => 'Print instrument messages'
+    method_option :profile,
+      :type    => :boolean,
+      :default => false,
+      :desc    => 'Generate profiling report for the build'
+
+    # Core build Thor command
+    # @return [void]
+    def build
+      if !ENV["MM_ROOT"]
+        raise Thor::Error, "Error: Could not find a Middleman project config, perhaps you are in the wrong folder?"
+      end
+
+      # Use Rack::Test for inspecting a running server for output
+      require "rack"
+      require "rack/test"
+
+      require 'find'
+
+      @debugging = Middleman::Cli::Base.respond_to?(:debugging) && Middleman::Cli::Base.debugging
+      @had_errors = false
+
+      self.class.shared_instance(options["verbose"], options["instrument"])
+
+      self.class.shared_rack
+
+      opts = {}
+      opts[:glob]  = options["glob"]  if options.has_key?("glob")
+      opts[:clean] = options["clean"] if options.has_key?("clean")
+
+      action GlobAction.new(self, opts)
+
+      if @had_errors && !@debugging
+        self.shell.say "There were errors during this build, re-run with --verbose to see the full exception."
+      end
+
+      exit(1) if @had_errors
+
+      self.class.shared_instance.run_hook :after_build, self
+    end
+
+    # Static methods
+    class << self
+      def exit_on_failure?
+        true
+      end
+
+      # Middleman::Application singleton
+      #
+      # @return [Middleman::Application]
+      def shared_instance(verbose=false, instrument=false)
+        @_shared_instance ||= ::Middleman::Application.server.inst do
+          set :environment, :build
+          logger(verbose ? 0 : 1, instrument)
+        end
+      end
+
+      # Middleman::Application class singleton
+      #
+      # @return [Middleman::Application]
+      def shared_server
+        @_shared_server ||= shared_instance.class
+      end
+
+      # Rack::Test::Session singleton
+      #
+      # @return [Rack::Test::Session]
+      def shared_rack
+        @_shared_rack ||= begin
+          mock = ::Rack::MockSession.new(shared_server.to_rack_app)
+          ::Rack::Test::Session.new(mock)
+        end
+      end
+
+      # Set the root path to the Middleman::Application's root
+      def source_root
+        shared_instance.root
+      end
+    end
+
+    no_tasks {
+      # Render a resource to a file.
+      #
+      # @param [Middleman::Sitemap::Resource] resource
+      # @return [String] The full path of the file that was written
+      def render_to_file(resource)
+        build_dir = self.class.shared_instance.build_dir
+        output_file = File.join(build_dir, resource.destination_path)
+
+        begin
+          response = self.class.shared_rack.get(URI.escape(resource.destination_path))
+
+          if response.status == 200
+            create_file(output_file, response.body)
+          else
+            handle_error(output_file, response.body)
+          end
+        rescue => e
+          handle_error(output_file, "#{e}\n#{e.backtrace.join("\n")}", e)
+        end
+
+        output_file
+      end
+
+      def handle_error(file_name, response, e=Thor::Error.new(response))
+        @had_errors = true
+
+        say_status :error, file_name, :red
+        if self.debugging
+          raise e
+          exit(1)
+        elsif options["verbose"]
+          self.shell.error(response)
+        end
+      end
+    }
+  end
+
+  # A Thor Action, modular code, which does the majority of the work.
+  class GlobAction < ::Thor::Actions::EmptyDirectory
+    attr_reader :source
+    attr_reader :logger
+
+    # Setup the action
+    #
+    # @param [Middleman::Cli::Build] base
+    # @param [Hash] config
+    def initialize(base, config={})
+      @app         = base.class.shared_instance
+      source       = @app.source
+      @destination = @app.build_dir
+
+      @source = File.expand_path(base.find_in_source_paths(source.to_s))
+
+      @logger = Middleman::Cli::Build.shared_instance.logger
+
+      super(base, @destination, config)
+    end
+
+    # Execute the action
+    # @return [void]
+    def invoke!
+      queue_current_paths if cleaning?
+      execute!
+      clean! if cleaning?
+    end
+
+  protected
+
+    # Remove files which were not built in this cycle
+    # @return [void]
+    def clean!
+      files       = @cleaning_queue.select { |q| q.file? }
+      directories = @cleaning_queue.select { |q| q.directory? }
+
+      files.each do |f|
+        base.remove_file f, :force => true
+      end
+
+      directories = directories.sort_by {|d| d.to_s.length }.reverse!
+
+      directories.each do |d|
+        base.remove_file d, :force => true if directory_empty? d
+      end
+    end
+
+    # Whether we should clean the build
+    # @return [Boolean]
+    def cleaning?
+      @config.has_key?(:clean) && @config[:clean]
+    end
+
+    # Whether the given directory is empty
+    # @param [String] directory
+    # @return [Boolean]
+    def directory_empty?(directory)
+      directory.children.empty?
+    end
+
+    # Get a list of all the paths in the destination folder and save them
+    # for comparison against the files we build in this cycle
+    # @return [void]
+    def queue_current_paths
+      @cleaning_queue = []
+      return unless File.exist?(@destination)
+
+      paths = ::Middleman::Util.all_files_under(@destination)
+      @cleaning_queue += paths.select do |path|
+        !path.to_s.match(/\/\./) || path.to_s.match(/\.htaccess/)
+      end
+    end
+
+    # Actually build the app
+    # @return [void]
+    def execute!
+      # Sort order, images, fonts, js/css and finally everything else.
+      sort_order = %w(.png .jpeg .jpg .gif .bmp .svg .svgz .ico .woff .otf .ttf .eot .js .css)
+
+      # Pre-request CSS to give Compass a chance to build sprites
+      logger.debug "== Prerendering CSS"
+
+      @app.sitemap.resources.select do |resource|
+        resource.ext == ".css"
+      end.each do |resource|
+        Middleman::Cli::Build.shared_rack.get(URI.escape(resource.destination_path))
+      end
+
+      logger.debug "== Checking for Compass sprites"
+
+      # Double-check for compass sprites
+      @app.files.find_new_files((Pathname(@app.source_dir) + @app.images_dir).relative_path_from(@app.root_path))
+
+      # Sort paths to be built by the above order. This is primarily so Compass can
+      # find files in the build folder when it needs to generate sprites for the
+      # css files
+
+      logger.debug "== Building files"
+
+      resources = @app.sitemap.resources.sort_by do |r|
+        sort_order.index(r.ext) || 100
+      end
+
+      # Loop over all the paths and build them.
+      resources.each do |resource|
+        next if @config[:glob] && !File.fnmatch(@config[:glob], resource.destination_path)
+
+        output_path = base.render_to_file(resource)
+
+        if cleaning?
+          pn = Pathname(output_path)
+          @cleaning_queue.delete(pn.realpath) if pn.exist?
+        end
+      end
+
+      ::Middleman::Profiling.report("build")
+    end
+  end
+
+  # Alias "b" to "build"
+  Base.map({ "b" => "build" })
+end
+
+# Quiet down create file
+class ::Thor::Actions::CreateFile
+  def on_conflict_behavior(&block)
+    if identical?
+      say_status :identical, :blue
+    else
+      say_status :update, :yellow
+      block.call unless pretend?
+    end
+  end
+end

data/lib/middleman-core/cli/bundler.rb

@@ -0,0 +1,40 @@
+# CLI Module
+module Middleman::Cli
+
+  # A initializing Bundler
+  class Bundle < Thor
+    include Thor::Actions
+    check_unknown_options!
+
+    namespace :bundle
+
+    desc "bundle", "Setup initial bundle", :hide => true
+
+    # The setup task
+    def bundle
+      run('bundle install --without development test')#, :capture => true)
+    end
+  end
+
+  # A upgrading Bundler
+  class Upgrade < Thor
+    include Thor::Actions
+    check_unknown_options!
+
+    namespace :upgrade
+
+    desc "upgrade", "Upgrade installed bundle"
+
+    # The upgrade task
+    def upgrade
+      inside(ENV["MM_ROOT"]) do
+        run('bundle update')#, :capture => true)
+      end
+    end
+  end
+
+  # Map "u" to "upgrade"
+  Base.map({
+    "u" => "upgrade"
+  })
+end

data/lib/middleman-core/cli/extension.rb

@@ -0,0 +1,49 @@
+# CLI Module
+module Middleman::Cli
+
+  # A thor task for creating new projects
+  class Extension < Thor
+    include Thor::Actions
+
+    check_unknown_options!
+
+    namespace :extension
+
+    # Required path for the new project to be generated
+    argument :name, :type => :string
+    
+    # Template files are relative to this file
+    # @return [String]
+    def self.source_root
+      File.join(File.dirname(__FILE__), "..", "templates", "extension")
+    end
+    
+    desc "extension [options]", "Create Middleman extension scaffold NAME"
+
+    # The extension task
+    # @param [String] name
+    def extension
+      generate_gitignore!
+      template "Rakefile", File.join(name, "Rakefile")
+      template "gemspec", File.join(name, "#{name}.gemspec")
+      template "Gemfile", File.join(name, "Gemfile")
+      template "lib/middleman_extension.rb", File.join(name, "lib", "middleman_extension.rb")
+      template "lib/lib.rb", File.join(name, "lib", "#{name}.rb")
+      template "features/support/env.rb", File.join(name, "features", "support", "env.rb")
+      empty_directory File.join(name, "fixtures")
+    end
+
+    # Output a .gitignore file
+    class_option :git, :type => :boolean, :default => true
+
+    no_tasks {
+      # Write a .gitignore file for project
+      # @return [void]
+      def generate_gitignore!
+        return unless options[:git]
+        copy_file "gitignore", File.join(name, ".gitignore")
+      end
+    }
+
+  end
+end

data/lib/middleman-core/cli/init.rb

@@ -0,0 +1,58 @@
+require "middleman-core/templates"
+
+# CLI Module
+module Middleman::Cli
+
+  # A thor task for creating new projects
+  class Init < Thor
+    check_unknown_options!
+
+    namespace :init
+
+    desc "init NAME [options]", "Create new project NAME"
+    available_templates = ::Middleman::Templates.registered.keys.join(", ")
+    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'
+    # The init task
+    # @param [String] name
+    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
+
+  def self.exit_on_failure?
+    true
+  end
+
+  # Map "i", "new" and "n" to "init"
+  Base.map({
+    "i"   => "init",
+    "new" => "init",
+    "n"   => "init"
+  })
+end