middleman-core-x86-mingw32 3.0.1.pre

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

@@ -0,0 +1,219 @@
+# Used for merging results of metadata callbacks
+require "active_support/core_ext/hash/deep_merge"
+
+module Middleman
+
+  # Sitemap namespace
+  module Sitemap
+
+    # The Store class
+    #
+    # The Store manages a collection of Resource objects, which represent
+    # individual items in the sitemap. Resources are indexed by "source path",
+    # which is the path relative to the source directory, minus any template
+    # extensions. All "path" parameters used in this class are source paths.
+    class Store
+
+      # @return [Middleman::Application]
+      attr_accessor :app
+
+      # Initialize with parent app
+      # @param [Middleman::Application] app
+      def initialize(app)
+        @app   = app
+        @resources = []
+        @_cached_metadata = {}
+        @_lookup_cache = { :path => {}, :destination_path => {} }
+        @resource_list_manipulators = []
+
+        # Register classes which can manipulate the main site map list
+        register_resource_list_manipulator(:on_disk, Middleman::Sitemap::Extensions::OnDisk.new(self),  false)
+
+        # Proxies
+        register_resource_list_manipulator(:proxies, @app.proxy_manager, false)
+      end
+
+      # Register a klass which can manipulate the main site map list
+      # @param [Symbol] name Name of the manipulator for debugging
+      # @param [Class, Module] inst Abstract namespace which can update the resource list
+      # @param [Boolean] immediately_rebuild Whether the resource list should be immediately recalculated
+      # @return [void]
+      def register_resource_list_manipulator(name, inst, immediately_rebuild=true)
+        @resource_list_manipulators << [name, inst]
+        rebuild_resource_list!(:registered_new) if immediately_rebuild
+      end
+
+      # Rebuild the list of resources from scratch, using registed manipulators
+      # @return [void]
+      def rebuild_resource_list!(reason=nil)
+        @resources = @resource_list_manipulators.inject([]) do |result, (_, inst)|
+          newres = inst.manipulate_resource_list(result)
+
+          # Reset lookup cache
+          @_lookup_cache = { :path => {}, :destination_path => {} }
+          newres.each do |resource|
+            @_lookup_cache[:path][resource.path] = resource
+            @_lookup_cache[:destination_path][resource.destination_path] = resource
+          end
+
+          newres
+        end
+      end
+
+      # Find a resource given its original path
+      # @param [String] request_path The original path of a resource.
+      # @return [Middleman::Sitemap::Resource]
+      def find_resource_by_path(request_path)
+        request_path = ::Middleman::Util.normalize_path(request_path)
+        @_lookup_cache[:path][request_path]
+      end
+
+      # Find a resource given its destination path
+      # @param [String] request_path The destination (output) path of a resource.
+      # @return [Middleman::Sitemap::Resource]
+      def find_resource_by_destination_path(request_path)
+        request_path = ::Middleman::Util.normalize_path(request_path)
+        @_lookup_cache[:destination_path][request_path]
+      end
+
+      # Get the array of all resources
+      # @param [Boolean] include_ignored Whether to include ignored resources
+      # @return [Array<Middleman::Sitemap::Resource>]
+      def resources(include_ignored=false)
+        if include_ignored
+          @resources
+        else
+          @resources.reject(&:ignored?)
+        end
+      end
+
+      # Register a handler to provide metadata on a file path
+      # @param [Regexp] matcher
+      # @return [Array<Array<Proc, Regexp>>]
+      def provides_metadata(matcher=nil, &block)
+        @_provides_metadata ||= []
+        @_provides_metadata << [block, matcher] if block_given?
+        @_provides_metadata
+      end
+
+      # Get the metadata for a specific file
+      # @param [String] source_file
+      # @return [Hash]
+      def metadata_for_file(source_file)
+        blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }
+
+        provides_metadata.inject(blank_metadata) do |result, (callback, matcher)|
+          next result if !matcher.nil? && !source_file.match(matcher)
+
+          metadata = callback.call(source_file)
+
+          if metadata.has_key?(:blocks)
+            result[:blocks] << metadata[:blocks]
+            metadata.delete(:blocks)
+          end
+
+          result.deep_merge(metadata)
+        end
+      end
+
+      # Register a handler to provide metadata on a url path
+      # @param [Regexp] matcher
+      # @param [Symbol] origin an indicator of where this metadata came from - only one
+      #                        block per [matcher, origin] pair may exist.
+      # @return [Array<Array<Proc, Regexp>>]
+      def provides_metadata_for_path(matcher=nil, origin=nil, &block)
+        @_provides_metadata_for_path ||= []
+        if block_given?
+          if origin
+            existing_provider = @_provides_metadata_for_path.find {|b,m,o| o == origin && m == matcher}
+          end
+
+          if existing_provider
+            existing_provider[0] = block
+          else
+            @_provides_metadata_for_path << [block, matcher, origin]
+          end
+
+          @_cached_metadata = {}
+        end
+        @_provides_metadata_for_path
+      end
+
+      # Get the metadata for a specific URL
+      # @param [String] request_path
+      # @return [Hash]
+      def metadata_for_path(request_path)
+        return @_cached_metadata[request_path] if @_cached_metadata[request_path]
+
+        blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }
+
+        @_cached_metadata[request_path] = provides_metadata_for_path.inject(blank_metadata) do |result, (callback, matcher)|
+          case matcher
+          when Regexp
+            next result unless request_path.match(matcher)
+          when String
+            next result unless File.fnmatch("/" + matcher.sub(%r{^/}, ''), "/#{request_path}")
+          end
+
+          metadata = callback.call(request_path)
+
+          if metadata.has_key?(:blocks)
+            result[:blocks] << metadata[:blocks]
+            metadata.delete(:blocks)
+          end
+
+          result.deep_merge(metadata)
+        end
+      end
+
+      # Get the URL path for an on-disk file
+      # @param [String] file
+      # @return [String]
+      def file_to_path(file)
+        file = File.expand_path(file, @app.root)
+
+        prefix = @app.source_dir.sub(/\/$/, "") + "/"
+        return false unless file.start_with?(prefix)
+
+        path = file.sub(prefix, "")
+
+        # Replace a file name containing automatic_directory_matcher with a folder
+        unless @app.automatic_directory_matcher.nil?
+          path = path.gsub(@app.automatic_directory_matcher, "/")
+        end
+
+        extensionless_path(path)
+      end
+
+      # Get a path without templating extensions
+      # @param [String] file
+      # @return [String]
+      def extensionless_path(file)
+        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
+
+        # If there is no extension, look for one
+        if File.extname(path).empty?
+          input_ext = File.extname(file)
+
+          if !input_ext.empty?
+            input_ext = input_ext.split(".").last.to_sym
+            if @app.template_extensions.has_key?(input_ext)
+              path << ".#{@app.template_extensions[input_ext]}"
+            end
+          end
+        end
+
+        path
+      end
+    end
+  end
+end

data/lib/middleman-core/sitemap.rb

@@ -0,0 +1,78 @@
+require "middleman-core/sitemap/store"
+require "middleman-core/sitemap/resource"
+
+require "middleman-core/sitemap/extensions/on_disk"
+require "middleman-core/sitemap/extensions/proxies"
+require "middleman-core/sitemap/extensions/ignores"
+
+# Core Sitemap Extensions
+module Middleman
+
+  module Sitemap
+
+    # Setup Extension
+    class << self
+
+      # Once registered
+      def registered(app)
+
+        app.register Middleman::Sitemap::Extensions::Proxies
+        app.register Middleman::Sitemap::Extensions::Ignores
+
+        # Set to automatically convert some characters into a directory
+        app.set :automatic_directory_matcher, nil
+
+        # Setup callbacks which can exclude paths from the sitemap
+        app.set :ignored_sitemap_matchers, {
+          # dotfiles and folders in the root
+          :root_dotfiles => proc { |file| file.match(%r{^\.}) },
+
+          # Files starting with an dot, but not .htaccess
+          :source_dotfiles => proc { |file|
+            file.match(%r{/\.}) && !file.match(%r{/\.htaccess})
+          },
+
+          # Files starting with an underscore, but not a double-underscore
+          :partials => proc { |file| file.match(%r{/_}) && !file.match(%r{/__}) },
+
+          :layout => proc { |file|
+            file.match(%r{^source/layout\.}) || file.match(%r{^source/layouts/})
+          }
+        }
+
+        # Include instance methods
+        app.send :include, InstanceMethods
+
+        # Initialize Sitemap
+        app.before_configuration do
+          sitemap
+        end
+      end
+      alias :included :registered
+
+    end
+
+    # Sitemap instance methods
+    module InstanceMethods
+
+      # Get the sitemap class instance
+      # @return [Middleman::Sitemap::Store]
+      def sitemap
+        @_sitemap ||= Store.new(self)
+      end
+
+      # Get the resource object for the current path
+      # @return [Middleman::Sitemap::Resource]
+      def current_page
+        current_resource
+      end
+
+      # Get the resource object for the current path
+      # @return [Middleman::Sitemap::Resource]
+      def current_resource
+        sitemap.find_resource_by_destination_path(current_path)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'fileutils'
+
+Given /^app "([^\"]*)" is using config "([^\"]*)"$/ do |path, config_name|
+  target = File.join(PROJECT_ROOT_PATH, "fixtures", path)
+  config_path = File.join(current_dir, "config-#{config_name}.rb")
+  config_dest = File.join(current_dir, "config.rb")
+  FileUtils.cp(config_path, config_dest)
+end
+
+Given /^an empty app$/ do
+  step %Q{a directory named "empty_app"}
+  step %Q{I cd to "empty_app"}
+end
+
+Given /^a fixture app "([^\"]*)"$/ do |path|
+  # This step can be reentered from several places but we don't want
+  # to keep re-copying and re-cd-ing into ever-deeper directories
+  next if File.basename(current_dir) == 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
+
+# Provide this Aruba overload in case we're matching something with quotes in it
+Then /^the file "([^"]*)" should contain '([^']*)'$/ do |file, partial_content|
+  check_file_content(file, partial_content, true)
+end

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

@@ -0,0 +1,17 @@
+Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
+  write_file(path, contents)
+  step %Q{the file "#{path}" did change}
+end
+
+Then /^the file "([^\"]*)" is removed$/ do |path|
+  step %Q{I remove the file "#{path}"}
+  step %Q{the file "#{path}" did delete}
+end
+
+Then /^the file "([^\"]*)" did change$/ do |path|
+  @server_inst.files.did_change(path)
+end
+
+Then /^the file "([^\"]*)" did delete$/ do |path|
+  @server_inst.files.did_delete(path)
+end

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

@@ -0,0 +1,91 @@
+# encoding: UTF-8
+
+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 /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_str|
+  @initialize_commands ||= []
+
+  options = eval("{#{options_str}}")
+
+  @initialize_commands << lambda { activate(feature.to_sym, options) }
+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$/ do
+  root_dir = File.expand_path(current_dir)
+
+  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::Application.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
+
+Given /^the Server is running at "([^\"]*)"$/ do |app_path|
+  step %Q{a fixture app "#{app_path}"}
+  step %Q{the Server is running}
+end
+
+When /^I go to "([^\"]*)"$/ do |url|
+  @browser.get(URI.escape(url))
+end
+
+Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
+  lambda { @browser.get(URI.escape(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 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/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/templates/default/source/index.html.erb

@@ -0,0 +1,10 @@
+---
+title: Welcome to Middleman
+---
+
+<div class="welcome">
+  <h1>Middleman is Watching</h1>
+  <p class="doc">
+    <%= link_to "Read Online Documentation", "http://middlemanapp.com/" %>
+  </p><!-- .doc -->
+</div><!-- .welcome -->

data/lib/middleman-core/templates/default/source/javascripts/all.js

@@ -0,0 +1 @@
+//= require_tree .

data/lib/middleman-core/templates/default/source/layouts/layout.erb

@@ -0,0 +1,19 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    
+    <!-- Always force latest IE rendering engine or request Chrome Frame -->
+    <meta content="IE=edge,chrome=1" http-equiv="X-UA-Compatible">
+    
+    <!-- Use title if it's in the page YAML frontmatter -->
+    <title><%= data.page.title || "The Middleman" %></title>
+    
+    <%= stylesheet_link_tag "normalize", "all" %>
+    <%= javascript_include_tag  "all" %>
+  </head>
+  
+  <body class="<%= page_classes %>">
+    <%= yield %>
+  </body>
+</html>

data/lib/middleman-core/templates/default/source/stylesheets/all.css

@@ -0,0 +1,55 @@
+@charset "utf-8";
+
+body {
+  background: #d4d4d4 url("../images/background.png");
+  text-align: center;
+  font-family: sans-serif; }
+
+h1 {
+  color: rgba(0, 0, 0, .3);
+  font-weight: bold;
+  font-size: 32px;
+  letter-spacing: -1px;
+  text-transform: uppercase;
+  text-shadow: 0 1px 0 rgba(255, 255, 255, .5);
+  background: url("../images/middleman.png") no-repeat center 100px;
+  padding: 350px 0 10px;
+  margin: 0; }
+
+.doc {
+  font-size: 14px;
+  margin: 0; }
+  .doc:before,
+  .doc:after {
+    opacity: .2;
+    padding: 6px;
+    font-style: normal;
+    position: relative;
+    content: "•"; }
+  .doc a {
+    color: rgba(0, 0, 0, 0.3); }
+    .doc a:hover {
+      color: #666; }
+
+.welcome {
+  -webkit-animation-name: welcome;
+  -webkit-animation-duration: .9s; }
+
+@-webkit-keyframes welcome {
+  from {
+    -webkit-transform: scale(0);
+    opacity: 0;
+  }
+  50% {
+   -webkit-transform: scale(0);
+   opacity: 0;
+  }
+  82.5% {
+    -webkit-transform: scale(1.03);
+    -webkit-animation-timing-function: ease-out;
+    opacity: 1;
+  }
+  to {
+    -webkit-transform: scale(1);
+  }
+}