middleman 0.12.0.pre → 0.12.0.pre2

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/compass/sass_extensions/monkey_patches.rb

@@ -1,3 +0,0 @@
-['stylesheet_updating'].each do |patch|
-  require File.join(File.dirname(__FILE__), 'monkey_patches', patch)
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/compass/validator.rb

@@ -1,10 +0,0 @@
-begin
-  require 'rubygems'
-  require 'compass-validator'
-rescue LoadError
-  puts %Q{The Compass CSS Validator could not be loaded. Please install it:
-
-sudo gem install chriseppstein-compass-validator --source http://gems.github.com/
-}
-  exit(1)
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/lib/vendor/fssm/state.rb

@@ -1,54 +0,0 @@
-require 'yaml'
-class FSSM::State
-  def initialize(path)
-    @path = path
-    @cache = FSSM::Tree::Cache.new
-  end
-
-  def refresh(base=nil, skip_callbacks=false)
-    previous, current = recache(base || @path.to_pathname)
-
-    unless skip_callbacks
-      deleted(previous, current)
-      created(previous, current)
-      modified(previous, current)
-    end
-  end
-
-  private
-
-  def created(previous, current)
-    (current.keys - previous.keys).each {|created| @path.create(created)}
-  end
-
-  def deleted(previous, current)
-    (previous.keys - current.keys).each {|deleted| @path.delete(deleted)}
-  end
-
-  def modified(previous, current)
-    (current.keys & previous.keys).each do |file|
-      @path.update(file) if (current[file] <=> previous[file]) != 0
-    end
-  end
-
-  def recache(base)
-    base = Pathname.for(base)
-    previous = @cache.files
-    snapshot(base)
-    current = @cache.files
-    [previous, current]
-  end
-
-  def snapshot(base)
-    base = Pathname.for(base)
-    @cache.unset(base)
-    @path.glob.each {|glob| add_glob(base, glob)}
-  end
-
-  def add_glob(base, glob)
-    Pathname.glob(base.join(glob)).each do |fn|
-      @cache.set(fn)
-    end
-  end
-
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/test/command_line_helper.rb

@@ -1,102 +0,0 @@
-module Compass::CommandLineHelper
-  def compass(*arguments)
-    options = arguments.last.is_a?(Hash) ? arguments.pop : {}
-    options[:wait] = 0.25
-    if block_given?
-      responder = Responder.new
-      yield responder
-      IO.popen("-", "w+") do |io|
-        if io
-          #parent process
-          output = ""
-          eof_at = nil
-          while !eof_at || (Time.now - eof_at < options[:wait])
-            if io.eof?
-              eof_at ||= Time.now
-              sleep 0.1
-            else
-              eof_at = nil
-              timeout(1) do
-                output << io.readpartial(1024)
-              end
-              prompt = output.split("\n").last
-              if response = responder.response_for(prompt)
-                io.puts response
-              end
-            end
-          end
-          responder.assert_required_responses!
-          @last_result = output
-        else
-          #child process
-          execute *arguments
-        end
-      end
-    else
-      @last_result = capture_output do
-        execute *arguments
-      end
-    end
-  rescue Timeout::Error
-    fail "Read from child process timed out"
-  end
-
-  class Responder
-    Response = Struct.new(:prompt, :text, :required, :responded)
-    def initialize
-      @responses = []
-    end
-    def respond_to(prompt, options = {})
-      @responses << Response.new(prompt, options[:with], options[:required])
-    end
-    def response_for(prompt)
-      response = @responses.detect{|r| r.prompt == prompt}
-      if response
-        response.responded = true
-        response.text
-      end
-    end
-    def assert_required_responses!
-      @responses.each do |response|
-        if response.required && !response.responded
-          raise "Prompt not encountered: \"#{response.prompt}\""
-        end
-      end
-    end
-  end
-
-  def assert_action_performed(action, path)
-    actions_found = []
-    @last_result.split("\n").each do |line|
-      line = line.split
-      return if line.first == action.to_s && line.last == path
-      actions_found << line.first if line.last == path
-    end
-    message = "Action #{action.inspect} was not performed on: #{path}."
-    message += "The following actions were performed: #{actions_found.join(", ")}" if actions_found.any?
-    puts @last_result
-    fail message
-  end
-
-  def within_tmp_directory(dir = "tmp")
-    d = absolutize(dir)
-    FileUtils.mkdir_p(d)
-    Dir.chdir(d) do
-      yield
-    end
-  ensure
-    FileUtils.rm_rf(d)
-  end
-
-  def capture_output
-    real_stdout, $stdout = $stdout, StringIO.new
-    yield
-    $stdout.string
-  ensure
-    $stdout = real_stdout
-  end
-
-  def execute(*arguments)
-    Compass::Exec::Compass.new(arguments).run!
-  end
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/test/command_line_test.rb

@@ -1,66 +0,0 @@
-require  File.dirname(__FILE__)+'/test_helper'
-require 'fileutils'
-require 'compass'
-require 'compass/exec'
-require 'timeout'
-
-class CommandLineTest < Test::Unit::TestCase
-  include Compass::TestCaseHelper
-  include Compass::CommandLineHelper
-
-  def teardown
-    Compass.configuration.reset!
-  end
-
-  def test_print_version
-    compass "-vq"
-    assert_match /\d+\.\d+\.\d+( [0-9a-f]+)?/, @last_result
-  end
-
-  def test_list_frameworks
-    compass "--list-frameworks"
-    assert_equal(%w(blueprint compass yui), @last_result.split.sort)
-  end
-
-  def test_basic_install
-    within_tmp_directory do
-      compass "basic"
-      assert File.exists?("basic/src/screen.sass")
-      assert File.exists?("basic/stylesheets/screen.css")
-      assert_action_performed :directory, "basic/"
-      assert_action_performed    :create, "basic/src/screen.sass"
-      assert_action_performed   :compile, "basic/src/screen.sass"
-      assert_action_performed    :create, "basic/stylesheets/screen.css"
-    end
-  end
-
-  def test_framework_installs
-    Compass::Frameworks::ALL.each do |framework|
-      within_tmp_directory do
-        compass *%W(--framework #{framework.name} #{framework.name}_project)
-        assert File.exists?("#{framework.name}_project/src/screen.sass")
-        assert File.exists?("#{framework.name}_project/stylesheets/screen.css")
-        assert_action_performed :directory, "#{framework.name}_project/"
-        assert_action_performed    :create, "#{framework.name}_project/src/screen.sass"
-        assert_action_performed   :compile, "#{framework.name}_project/src/screen.sass"
-        assert_action_performed    :create, "#{framework.name}_project/stylesheets/screen.css"
-      end
-    end
-  end
-
-  def test_basic_update
-    within_tmp_directory do
-      compass "basic"
-      Dir.chdir "basic" do
-        # basic update with timestamp caching
-        compass
-        assert_action_performed :unchanged, "src/screen.sass"
-        # basic update with force option set
-        compass "--force"
-        assert_action_performed :compile, "src/screen.sass"
-        assert_action_performed :identical, "stylesheets/screen.css"
-      end
-    end
-  end
-
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/test/compass_test.rb

@@ -1,141 +0,0 @@
-require  File.dirname(__FILE__)+'/test_helper'
-require 'fileutils'
-require 'compass'
-
-class CompassTest < Test::Unit::TestCase
-  include Compass::TestCaseHelper
-  def setup
-    Compass.configuration.reset!
-  end
-
-  def teardown
-    teardown_fixtures :blueprint, :yui, :empty, :compass, :image_urls
-  end
-
-  def teardown_fixtures(*project_names)
-    project_names.each do |project_name|
-      FileUtils.rm_rf tempfile_path(project_name)
-    end
-  end
-
-  def test_empty_project
-    # With no sass files, we should have no css files.
-    within_project(:empty) do |proj|
-      return unless proj.css_path && File.exists?(proj.css_path)
-      Dir.new(proj.css_path).each do |f|
-        fail "This file should not have been generated: #{f}" unless f == "." || f == ".."
-      end
-    end
-  end
-
-  def test_blueprint
-    within_project(:blueprint) do |proj|
-      each_css_file(proj.css_path) do |css_file|
-        assert_no_errors css_file, :blueprint
-      end
-      assert_renders_correctly :typography
-    end
-  end
-
-  def test_yui
-    within_project('yui') do |proj|
-      each_css_file(proj.css_path) do |css_file|
-        assert_no_errors css_file, 'yui'
-      end
-      assert_renders_correctly :mixins
-    end
-  end
-
-  def test_compass
-    within_project('compass') do |proj|
-      each_css_file(proj.css_path) do |css_file|
-        assert_no_errors css_file, 'compass'
-      end
-      assert_renders_correctly :reset, :layout, :utilities
-    end
-  end
-
-  def test_image_urls
-    within_project('image_urls') do |proj|
-      each_css_file(proj.css_path) do |css_file|
-        assert_no_errors css_file, 'image_urls'
-      end
-      assert_renders_correctly :screen
-    end
-  end
-
-private
-  def assert_no_errors(css_file, project_name)
-    file = css_file[(tempfile_path(project_name).size+1)..-1]
-    msg = "Syntax Error found in #{file}. Results saved into #{save_path(project_name)}/#{file}"
-    assert_equal 0, open(css_file).readlines.grep(/Sass::SyntaxError/).size, msg
-  end
-
-  def assert_renders_correctly(*arguments)
-    options = arguments.last.is_a?(Hash) ? arguments.pop : {}
-    for name in arguments
-      actual_result_file = "#{tempfile_path(@current_project)}/#{name}.css"
-      expected_result_file = "#{result_path(@current_project)}/#{name}.css"
-      actual_lines = File.read(actual_result_file).split("\n")
-      expected_lines = File.read(expected_result_file).split("\n")
-      expected_lines.zip(actual_lines).each_with_index do |pair, line|
-        message = "template: #{name}\nline:     #{line + 1}"
-        assert_equal(pair.first, pair.last, message)
-      end
-      if expected_lines.size < actual_lines.size
-        assert(false, "#{actual_lines.size - expected_lines.size} Trailing lines found in #{actual_result_file}.css: #{actual_lines[expected_lines.size..-1].join('\n')}")
-      end
-    end
-  end
-
-  def within_project(project_name)
-    @current_project = project_name
-    Compass.configuration.parse(configuration_file(project_name)) if File.exists?(configuration_file(project_name))
-    Compass.configuration.project_path = project_path(project_name)
-    args = Compass.configuration.to_compiler_arguments(:logger => Compass::NullLogger.new)
-    if Compass.configuration.sass_path && File.exists?(Compass.configuration.sass_path)
-      compiler = Compass::Compiler.new *args
-      compiler.run
-    end
-    yield Compass.configuration
-  rescue
-    save_output(project_name)    
-    raise
-  end
-  
-  def each_css_file(dir)
-    Dir.glob("#{dir}/**/*.css").each do |css_file|
-      yield css_file
-    end
-  end
-
-  def save_output(dir)
-    FileUtils.rm_rf(save_path(dir))
-    FileUtils.cp_r(tempfile_path(dir), save_path(dir)) if File.exists?(tempfile_path(dir))
-  end
-
-  def project_path(project_name)
-    absolutize("fixtures/stylesheets/#{project_name}")
-  end
-
-  def configuration_file(project_name)
-    File.join(project_path(project_name), "config.rb")
-  end
-
-  def tempfile_path(project_name)
-    File.join(project_path(project_name), "tmp")
-  end
-  
-  def template_path(project_name)
-    File.join(project_path(project_name), "sass")
-  end
-  
-  def result_path(project_name)
-    File.join(project_path(project_name), "css")
-  end
-  
-  def save_path(project_name)
-    File.join(project_path(project_name), "saved")
-  end
-
-end

data/lib/middleman/vendor/gems/gems/compass-0.8.17/test/configuration_test.rb

@@ -1,118 +0,0 @@
-require  File.dirname(__FILE__)+'/test_helper'
-require 'compass'
-
-class ConfigurationTest < Test::Unit::TestCase
-
-  def setup
-    Compass.configuration.reset!
-  end
-
-  def test_parse_and_serialize
-    contents = <<-CONFIG
-      require 'compass'
-      # Require any additional compass plugins here.
-
-      project_type = :stand_alone
-      # Set this to the root of your project when deployed:
-      http_path = "/"
-      css_dir = "css"
-      sass_dir = "sass"
-      images_dir = "img"
-      javascripts_dir = "js"
-      output_style = :nested
-      # To enable relative paths to assets via compass helper functions. Uncomment:
-      # relative_assets = true
-    CONFIG
-
-    Compass.configuration.parse_string(contents, "test_parse")
-
-    assert_equal 'sass', Compass.configuration.sass_dir
-    assert_equal 'css', Compass.configuration.css_dir
-    assert_equal 'img', Compass.configuration.images_dir
-    assert_equal 'js', Compass.configuration.javascripts_dir
-
-    expected_lines = contents.split("\n").map{|l|l.strip}
-    actual_lines = Compass.configuration.serialize.split("\n").map{|l|l.strip}
-    assert_equal expected_lines, actual_lines
-  end
-
-  def test_serialization_fails_with_asset_host_set
-    contents = <<-CONFIG
-      asset_host do |path|
-        "http://example.com"
-      end
-    CONFIG
-
-    Compass.configuration.parse_string(contents, "test_serialization_fails_with_asset_host_set")
-
-    assert_raise Compass::Error do
-      Compass.configuration.serialize
-    end
-  end
-
-  def test_serialization_fails_with_asset_cache_buster_set
-    contents = <<-CONFIG
-      asset_cache_buster do |path|
-        "http://example.com"
-      end
-    CONFIG
-
-    Compass.configuration.parse_string(contents, "test_serialization_fails_with_asset_cache_buster_set")
-
-    assert_raise Compass::Error do
-      Compass.configuration.serialize
-    end
-  end
-
-  def test_additional_import_paths
-    contents = <<-CONFIG
-      http_path = "/"
-      project_path = "/home/chris/my_compass_project"
-      css_dir = "css"
-      additional_import_paths = ["../foo"]
-      add_import_path "/path/to/my/framework"
-    CONFIG
-
-    Compass.configuration.parse_string(contents, "test_additional_import_paths")
-
-    assert Compass.configuration.to_sass_engine_options[:load_paths].include?("/home/chris/my_compass_project/../foo")
-    assert Compass.configuration.to_sass_engine_options[:load_paths].include?("/path/to/my/framework"), Compass.configuration.to_sass_engine_options[:load_paths].inspect
-    assert_equal "/home/chris/my_compass_project/css/framework", Compass.configuration.to_sass_plugin_options[:template_location]["/path/to/my/framework"]
-    assert_equal "/home/chris/my_compass_project/css/foo", Compass.configuration.to_sass_plugin_options[:template_location]["/home/chris/my_compass_project/../foo"]
-
-    expected_serialization = <<EXPECTED
-# Require any additional compass plugins here.
-project_path = "/home/chris/my_compass_project"
-# Set this to the root of your project when deployed:
-http_path = "/"
-css_dir = "css"
-# To enable relative paths to assets via compass helper functions. Uncomment:
-# relative_assets = true
-additional_import_paths = ["../foo", "/path/to/my/framework"]
-EXPECTED
-    assert_equal "/", Compass.configuration.http_path
-    assert_equal expected_serialization, Compass.configuration.serialize
-  end
-
-    def test_sass_options
-      contents = <<-CONFIG
-        sass_options = {:foo => 'bar'}
-      CONFIG
-
-      Compass.configuration.parse_string(contents, "test_sass_options")
-
-      assert_equal 'bar', Compass.configuration.to_sass_engine_options[:foo]
-      assert_equal 'bar', Compass.configuration.to_sass_plugin_options[:foo]
-
-      expected_serialization = <<EXPECTED
-# Require any additional compass plugins here.
-# Set this to the root of your project when deployed:
-# To enable relative paths to assets via compass helper functions. Uncomment:
-# relative_assets = true
-sass_options = {:foo=>"bar"}
-EXPECTED
-
-      assert_equal expected_serialization, Compass.configuration.serialize
-    end
-
-end