alphasights-compass 0.8.12

data/lib/compass/sass_extensions/monkey_patches.rb

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

data/lib/compass/sass_extensions/monkey_patches/stylesheet_updating.rb

@@ -0,0 +1,23 @@
+require 'sass/plugin'
+
+# XXX: We can remove this monkeypatch once Sass 2.2 is released.
+module Sass::Plugin
+  class << self
+    unless method_defined?(:exact_stylesheet_needs_update?)
+      def stylesheet_needs_update?(name, template_path, css_path)
+        css_file = css_filename(name, css_path)
+        template_file = template_filename(name, template_path)
+        exact_stylesheet_needs_update?(css_file, template_file)
+      end
+      def exact_stylesheet_needs_update?(css_file, template_file)
+        if !File.exists?(css_file)
+          return true
+        else
+          css_mtime = File.mtime(css_file)
+          File.mtime(template_file) > css_mtime ||
+            dependencies(template_file).any?(&dependency_updated?(css_mtime))
+        end
+      end
+    end
+  end
+end

data/lib/compass/test_case.rb

@@ -0,0 +1,38 @@
+module Compass
+  # Write your unit test like this if you want to make sure all your stylesheets compile.
+  #
+  # require 'compass/test_case'
+  # class StylesheetsTest < Compass::TestCase
+  #   def test_stylesheets
+  #     my_sass_files.each do |sass_file|
+  #       assert_compiles(sass_file) do |result|
+  #         assert_not_blank result
+  #       end
+  #     end
+  #   end
+  #   protected
+  #   def my_sass_files
+  #     Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), "../..", "app/stylesheets/**/[^_]*.sass")))
+  #   end
+  # end
+  class TestCase < (defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase)
+
+    def setup
+      super
+      @last_compile = nil
+    end
+
+    def compile(stylesheet)
+      input =  open(stylesheet)
+      template = input.read()
+      input.close()
+      @last_compile = ::Sass::Engine.new(template, ::Sass::Plugin.engine_options(:filename => stylesheet)).render
+      yield @last_compile if block_given?
+    end
+
+    def assert_compiles(stylesheet, &block)
+      compile(stylesheet, &block)
+    end
+
+  end
+end

data/lib/compass/validator.rb

@@ -0,0 +1,10 @@
+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/compass/version.rb

@@ -0,0 +1,57 @@
+module Compass
+  module Version
+    # Returns a hash representing the version.
+    # The :major, :minor, and :teeny keys have their respective numbers.
+    # The :string key contains a human-readable string representation of the version.
+    # The :rev key will have the current revision hash.
+    #
+    # This method swiped from Haml and then modified, some credit goes to Nathan Weizenbaum
+    attr_writer :version
+    def version
+      return @version if defined?(@version)
+
+      read_version_file
+
+      if r = revision
+        @version[:rev] = r
+        @version[:string] << " [#{r[0...7]}]"
+      end
+
+      @version
+    end
+
+    protected
+
+    def scope(file) # :nodoc:
+      File.join(File.dirname(__FILE__), '..', '..', file)
+    end
+
+    def read_version_file
+      require 'yaml'
+      @version = YAML::load(File.read(scope('VERSION.yml')))
+      @version[:string] = "#{@version[:major]}.#{@version[:minor]}.#{@version[:patch]}"
+      @version[:teeny] = @version[:patch]
+    end
+
+    def revision
+      revision_from_git || revision_from_file
+    end
+
+    def revision_from_file
+      if File.exists?(scope('REVISION'))
+        rev = File.read(scope('REVISION')).strip
+        rev if rev =~ /[a-f0-9]+/
+      end
+    end
+
+    def revision_from_git
+      if File.exists?(scope('.git/HEAD'))
+        rev = File.read(scope('.git/HEAD')).strip
+        if rev =~ /^ref: (.*)$/
+          rev = File.read(scope(".git/#{$1}")).strip
+        end
+      end
+    end
+
+  end
+end

data/test/command_line_helper.rb

@@ -0,0 +1,102 @@
+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/test/command_line_test.rb

@@ -0,0 +1,66 @@
+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/test/compass_test.rb

@@ -0,0 +1,141 @@
+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