compass-sass37 1.1.0

data/features/step_definitions/command_line_steps.rb

@@ -0,0 +1,268 @@
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../../test')))
+
+require 'bundler/setup'
+require 'test_helper'
+
+require 'compass/exec'
+include Compass::TestCaseHelper
+include Compass::CommandLineHelper
+include Compass::IoHelper
+
+Before do
+  Compass.reset_configuration!
+  @cleanup_directories = []
+  @original_working_directory = Dir.pwd
+end
+ 
+After do
+  Dir.chdir @original_working_directory
+  @cleanup_directories.each do |dir|
+    FileUtils.rm_rf dir
+  end
+end
+
+Given "ruby supports fork" do
+  if RUBY_PLATFORM == "java"
+    pending
+  end
+end
+
+# Given Preconditions
+Given %r{^I am using the existing project in ([^\s]+)$} do |project|
+  tmp_project = "tmp_#{File.basename(project)}"
+  @cleanup_directories << tmp_project
+  FileUtils.cp_r project, tmp_project
+  Dir.chdir tmp_project
+end
+
+Given %r{^I am in the parent directory$} do
+  Dir.chdir ".."
+end
+
+Given /^I should clean up the directory: (\w+)$/ do |directory|
+  @cleanup_directories << directory
+end
+
+Given %r{^the project has a file named "([^"]*)" containing:$} do |arg1, string|
+  File.open(arg1, "w") do |f|
+    f << string
+  end
+end
+
+
+# When Actions are performed
+When /^I create a project using: compass create ([^\s]+) ?(.+)?$/ do |dir, args|
+  @cleanup_directories << dir
+  compass 'create', dir, *(args || '').split
+end
+
+When /^I initialize a project using: compass init ?(.+)?$/ do |args|
+  compass 'init', *(args || '').split
+end
+
+When /^I run: compass ([^\s]+) ?(.+)?$/ do |command, args|
+  compass command, *(args || '').split
+end
+
+When /^I run in a separate process: compass ([^\s]+) ?(.+)?$/ do |command, args|
+  unless @other_process = fork 
+    @last_result = ''
+    @last_error = ''
+    Signal.trap("HUP") do
+      open('/tmp/last_result.compass_test.txt', 'w') do |file|
+        file.puts $stdout.string
+      end
+      open('/tmp/last_error.compass_test.txt', 'w') do |file|
+        file.puts $stderr.string
+      end
+      exit!
+    end
+    # this command will run forever
+    # we kill it with a HUP signal from the parent process.
+    args = (args || '').split
+    args << { :wait => 5 }
+    compass command, *args
+    exit!
+  end
+end
+
+When /^I shutdown the other process$/ do
+  Process.kill("HUP", @other_process)
+  Process.wait
+  @last_result = File.read('/tmp/last_result.compass_test.txt')
+  @last_error = File.read('/tmp/last_error.compass_test.txt')
+end
+
+When /^I touch ([^\s]+)$/ do |filename|
+  FileUtils.touch filename
+end
+
+When /^I wait ([\d.]+) seconds?$/ do |count|
+  sleep count.to_f
+end
+
+When /^I add some sass to ([^\s]+)$/ do |filename|
+  open(filename, "w+") do |file|
+    file.puts ".added .some .arbitrary"
+    file.puts "  sass: code"
+  end
+end
+
+# Then postconditions
+Then /^a directory ([^ ]+) is (not )?created$/ do |directory, negated|
+  File.directory?(directory).should == !negated
+end
+ 
+Then /an? \w+ file ([^ ]+) is (not )?removed/ do |filename, negated|
+  File.exist?(filename).should == !!negated
+end
+
+Then /an? \w+ file ([^ ]+) is (not )?created/ do |filename, negated|
+  File.exist?(filename).should == !negated
+end
+
+Then "the following files are reported removed:" do |table|
+  table.rows.each do |css_file|
+    #need to find a better way but this works for now
+    step %Q{a css file #{css_file.first} is reported removed}
+  end
+end
+
+Then "the following files are removed:" do |table|
+  table.rows.each do |css_file|
+    step %Q{a css file #{css_file.first} is removed}
+  end
+end
+
+Then /an? \w+ file ([^ ]+) is reported removed/ do |filename|
+  @last_result.should =~ /delete.*#{Regexp.escape(filename)}/
+end
+
+Then /an? \w+ file ([^ ]+) is reported written/ do |filename|
+  @last_result.should =~ /write.*#{Regexp.escape(filename)}/
+end
+
+Then /a \w+ file ([^ ]+) is (?:reported )?compiled/ do |filename|
+  @last_result.should =~ /compile.*#{Regexp.escape(filename)}/
+end
+
+Then /a \w+ file ([^ ]+) is reported unchanged/ do |filename|
+  @last_result.should =~ /unchanged.*#{Regexp.escape(filename)}/
+end
+
+Then /a \w+ file ([^ ]+) is reported identical/ do |filename|
+  @last_result.should =~ /identical.*#{Regexp.escape(filename)}/
+end
+
+Then /a \w+ file ([^ ]+) is reported overwritten/ do |filename|
+  @last_result.should =~ /overwrite.*#{Regexp.escape(filename)}/
+end
+
+Then /a \w+ file ([^ ]+) is not mentioned/ do |filename|
+  @last_result.should_not =~ /#{Regexp.escape(filename)}/
+end
+
+Then /I am told how to link to ([^ ]+) for media "([^"]+)"/ do |stylesheet, media|
+  @last_result.should =~ %r{<link href="#{stylesheet}" media="#{media}" rel="stylesheet" type="text/css" />}
+end
+
+Then /I am told how to conditionally link "([^"]+)" to ([^ ]+) for media "([^"]+)"/ do |condition, stylesheet, media|
+  @last_result.should =~ %r{<!--\[if #{condition}\]>\s+<link href="#{stylesheet}" media="#{media}" rel="stylesheet" type="text/css" />\s+<!\[endif\]-->}mi
+end
+
+Then /^an error message is printed out: (.+)$/ do |error_message|
+  @last_error.should =~ Regexp.new(Regexp.escape(error_message))
+end
+
+Then /^the command exits with a non\-zero error code$/ do
+  @last_exit_code.should_not == 0
+end
+
+Then /^the command exits normally$/ do
+  @last_exit_code.should == 0
+end
+
+Then /^I am congratulated$/ do
+  @last_result.should =~ /Congratulations!/
+end
+
+Then /^I am told that I can place stylesheets in the ([^\s]+) subdirectory$/ do |subdir|
+  @last_result.should =~ /You may now add sass stylesheets to the #{subdir} subdirectory of your project./
+end
+
+Then /^I am told how to compile my sass stylesheets$/ do
+  @last_result.should =~ /You must compile your sass stylesheets into CSS when they change.\nThis can be done in one of the following ways:/
+end
+
+Then /^I should be shown a list of "([^"]+)" commands$/ do |kind|
+  @last_result.should =~ /^#{kind.capitalize} Commands:$/
+  @last_command_list = []
+  found = false
+  indent = nil
+  @last_result.split("\n").each do |line|
+    if line =~ /^#{kind.capitalize} Commands:$/
+      found = true
+    elsif found && line =~ /^\s+/
+      @last_command_list << line
+    elsif found && line =~ /^$|^\w/
+      break
+    end
+  end
+
+end
+
+Then /^the list of commands should describe the ([^ ]+) command$/ do |command|
+  @last_result.should =~ /^\s+\* #{command}\s+- [A-Z].+$/
+end
+
+Then /^the following configuration properties are set in ([^ ]+):$/ do |config_file, table|
+  
+  config = Compass::Configuration::FileData.new_from_file(config_file)
+  table.hashes.each do |hash|
+   config.send(hash['property']).should == hash['value']
+  end
+end
+
+Then /^my css is validated$/ do
+  if @last_error =~ /The Compass CSS Validator could not be loaded/
+    pending "Missing Dependency: sudo gem install compass-validator"
+  else
+    @last_result.should =~ /files? validated/
+  end
+end
+
+Then /^I am informed that my css is valid.$/ do
+  @last_result.should =~ /Result: Valid/
+end
+
+Then /^I am told statistics for each file:$/ do |table|
+  # table is a Cucumber::Ast::Table
+  table.raw.each do |row|
+    re = Regexp.new row.join(' *\| *')
+    @last_result.should =~ re
+  end
+end
+
+Then /^I should see the following "([^"]+)" commands:$/ do |kind, table|
+
+
+  step %Q{I should be shown a list of "#{kind}" commands}
+
+  commands = @last_command_list.map{|c| c =~ /^\s+\* ([^ ]+)\s+- [A-Z].+$/; [$1]}
+  table.diff!(commands)
+end
+     
+
+Then /^the image ([^ ]+) has a size of (\d+)x(\d+)$/ do |file, width, height| 
+  # see http://snippets.dzone.com/posts/show/805
+  size = File.open(file, "rb") {|io| io.read}[0x10..0x18].unpack('NN')
+  size.should == [width.to_i, height.to_i]
+end
+
+Then /^I should see the following lines of output:$/ do |table|
+  table.diff!([['compass']])
+end
+
+Then /^I should see the following output: (.+)$/ do |expected|
+  (@last_result.strip + @last_error.strip).should == expected.gsub(/\$PROJECT_PATH/,Dir.pwd).strip
+end

data/features/step_definitions/extension_steps.rb

@@ -0,0 +1,24 @@
+Given /^the "([^\"]*)" directory exists$/ do |directory|
+  directory.gsub!('~', ENV["HOME"]) if directory.include?('~/')
+  FileUtils.mkdir_p directory
+end
+
+Given /^and I have a fake extension at (.*)$/ do |directory|
+  directory.gsub!('~', ENV["HOME"]) if directory.include?('~/')
+  FileUtils.mkdir_p File.join(directory, 'stylesheets')
+  FileUtils.mkdir_p File.join(directory, 'templates/project')
+  open(File.join(directory, 'templates/project/manifest.rb'),"w") do |f|
+    f.puts %Q{
+      description "This is a fake extension"
+
+      help "this is the fake help"
+
+      welcome_message "this is a fake welcome"
+    }
+  end
+end
+
+Then /^the list of frameworks includes "([^\"]*)"$/ do |framework|
+  @last_result.split("\n").map{|f| f.gsub(/(^\s+[*-]\s+)|(\s+$)/,'')}.should include(framework)
+end
+

data/lib/compass/actions.rb

@@ -0,0 +1,116 @@
+module Compass
+  module Actions
+
+    attr_writer :logger
+
+    def logger
+      @logger ||= ::Compass::Logger.new
+    end
+
+    # copy/process a template in the compass template directory to the project directory.
+    def copy(from, to, options = nil, binary = false)
+      options ||= self.options if self.respond_to?(:options)
+      if binary
+        contents = File.new(from,"rb").read
+      else
+        contents = File.new(from).read
+      end  
+      write_file to, contents, options, binary
+    end
+
+    # create a directory and all the directories necessary to reach it.
+    def directory(dir, options = nil)
+      options ||= self.options if self.respond_to?(:options)
+      options ||= {}
+      if File.exist?(dir) && File.directory?(dir)
+          # do nothing
+      elsif File.exist?(dir)
+        msg = "#{basename(dir)} already exists and is not a directory."
+        raise Compass::FilesystemConflict.new(msg)
+      else
+        log_action :directory, separate("#{basename(dir)}/"), options
+        FileUtils.mkdir_p(dir)
+      end
+    end
+
+    # Write a file given the file contents as a string
+    def write_file(file_name, contents, options = nil, binary = false)
+      options ||= self.options if self.respond_to?(:options)
+      skip_write = false
+      contents = process_erb(contents, options[:erb]) if options[:erb]
+      if File.exist?(file_name)
+        existing_contents = IO.read(file_name)
+        if existing_contents == contents
+          log_action :identical, basename(file_name), options
+          skip_write = true
+        elsif options[:force]
+          log_action :overwrite, basename(file_name), options
+        else
+          msg = "File #{basename(file_name)} already exists. Run with --force to force overwrite."
+          raise Compass::FilesystemConflict.new(msg)
+        end
+      else
+        log_action :create, basename(file_name), options
+      end
+      if skip_write
+        FileUtils.touch file_name
+      else
+        mode = "w"
+        mode << "b" if binary
+        open(file_name, mode) do |file|
+          file.write(contents)
+        end
+      end
+    end
+
+    def process_erb(contents, ctx = nil)
+      ctx = Object.new.instance_eval("binding") unless ctx.is_a? Binding
+      ERB.new(contents).result(ctx)
+    end
+
+    def remove(file_name)
+      file_name ||= ''
+      if File.directory?(file_name)
+        FileUtils.rm_rf file_name
+        log_action :remove, basename(file_name)+"/", options
+      elsif File.exist?(file_name)
+        File.unlink file_name
+        log_action :remove, basename(file_name), options
+      end
+    end
+
+    def basename(file)
+      relativize(file) {|f| File.basename(file)}
+    end
+
+    def relativize(path)
+      path = File.expand_path(path)
+      if path.index(working_path+File::SEPARATOR) == 0
+        path[(working_path+File::SEPARATOR).length..-1]
+      elsif block_given?
+        yield path
+      else
+        path
+      end
+    end
+
+    # Write paths like we're on unix and then fix it
+    def separate(path)
+      path.gsub(%r{/}, File::SEPARATOR)
+    end
+
+    # Removes the trailing separator, if any, from a path.
+    def strip_trailing_separator(path)
+      (path[-1..-1] == File::SEPARATOR) ? path[0..-2] : path
+    end
+
+    def log_action(action, file, options)
+      quiet = !!options[:quiet]
+      quiet = false if options[:loud] && options[:loud] == true
+      quiet = false if options[:loud] && options[:loud].is_a?(Array) && options[:loud].include?(action)
+      unless quiet
+        logger.record(action, file, options[:extra].to_s)
+      end
+    end
+  end
+end

data/lib/compass/app_integration/stand_alone/configuration_defaults.rb

@@ -0,0 +1,32 @@
+module Compass
+  module AppIntegration
+    module StandAlone
+      module ConfigurationDefaults
+        def default_project_type
+          :stand_alone
+        end
+
+        def sass_dir_without_default
+          "sass"
+        end
+
+        def javascripts_dir_without_default
+          "javascripts"
+        end
+
+        def css_dir_without_default
+          "stylesheets"
+        end
+
+        def images_dir_without_default
+          "images"
+        end
+
+        def default_cache_dir
+          ".sass-cache"
+        end
+      end
+
+    end
+  end
+end

data/lib/compass/app_integration/stand_alone/installer.rb

@@ -0,0 +1,83 @@
+module Compass
+  module Installers
+    class Base
+    end
+    class ManifestInstaller < Base
+    end
+  end
+
+  module AppIntegration
+    module StandAlone
+      class Installer < Compass::Installers::ManifestInstaller
+
+        def init
+          directory targetize("")
+          super
+        end
+
+        def write_configuration_files(config_file = nil)
+          config_file ||= targetize('config.rb')
+          write_file config_file, config_contents
+        end
+
+        def config_files_exist?
+          File.exist? targetize('config.rb')
+        end
+
+        def config_contents
+          project_path, Compass.configuration.project_path = Compass.configuration.project_path, nil
+          Compass.configuration.serialize
+        ensure
+          Compass.configuration.project_path = project_path
+        end
+
+        def prepare
+          write_configuration_files unless config_files_exist? || !@manifest.generate_config?
+        end
+
+        def completed_configuration
+          nil
+        end
+
+        def finalize(options = {})
+          if options[:create] && !manifest.welcome_message_options[:replace]
+            puts <<-NEXTSTEPS
+
+*********************************************************************
+Congratulations! Your compass project has been created.
+
+You may now add and edit sass stylesheets in the #{Compass.configuration.sass_dir} subdirectory of your project.
+
+Sass files beginning with an underscore are called partials and won't be
+compiled to CSS, but they can be imported into other sass stylesheets.
+
+You can configure your project by editing the config.rb configuration file.
+
+You must compile your sass stylesheets into CSS when they change.
+This can be done in one of the following ways:
+  1. To compile on demand:
+     compass compile [path/to/project]
+  2. To monitor your project for changes and automatically recompile:
+     compass watch [path/to/project]
+
+More Resources:
+  * Website: http://compass-style.org/
+  * Sass: http://sass-lang.com
+  * Community: http://groups.google.com/group/compass-users/
+
+NEXTSTEPS
+          end
+          puts manifest.welcome_message if manifest.welcome_message
+          if manifest.has_stylesheet? && !manifest.welcome_message_options[:replace]
+            puts "\nTo import your new stylesheets add the following lines of HTML (or equivalent) to your webpage:"
+            puts stylesheet_links
+          end
+        end
+
+        def compilation_required?
+          @manifest.compile?
+        end
+      end
+    end
+  end
+end

data/lib/compass/app_integration/stand_alone.rb

@@ -0,0 +1,22 @@
+%w(configuration_defaults installer).each do |lib|
+  require "compass/app_integration/stand_alone/#{lib}"
+end
+
+module Compass
+  module AppIntegration
+    module StandAlone
+
+      extend self
+
+      def installer(*args)
+        Installer.new(*args)
+      end
+
+      def configuration
+        Compass::Configuration::Data.new('stand_alone').
+          extend(ConfigurationDefaults)
+      end
+
+    end
+  end
+end

data/lib/compass/app_integration.rb

@@ -0,0 +1,39 @@
+require "compass/app_integration/stand_alone"
+
+module Compass
+  module AppIntegration
+    module Helpers
+      #attr_accessor :project_types
+      DEAFULT_PROJECT_TYPES = {
+        :stand_alone => "Compass::AppIntegration::StandAlone"
+      }
+
+      def init
+        @project_types ||= DEAFULT_PROJECT_TYPES.dup
+      end
+
+      def project_types
+        @project_types
+      end
+
+      def default?
+        @project_types.keys === DEAFULT_PROJECT_TYPES.keys
+      end
+
+      def lookup(type)
+        unless @project_types[type].nil?
+          eval @project_types[type]
+        else
+          raise Compass::Error, "No application integration exists for #{type}"
+        end
+      end
+
+      def register(type, klass)
+        @project_types[type] = klass
+      end
+
+    end
+    extend Helpers
+    init
+  end
+end

data/lib/compass/commands/base.rb

@@ -0,0 +1,44 @@
+module Compass
+  module Commands
+    class Base
+      def self.register(command_name)
+        Compass::Commands[command_name] = self
+      end
+
+      include Actions
+
+      attr_accessor :working_path, :options
+
+      def initialize(working_path, options)
+        self.working_path = working_path.to_s
+        self.options = options
+      end
+      
+      def execute
+        perform
+      end
+
+      def perform
+        raise StandardError.new("Not Implemented")
+      end
+
+      def successful?
+        !@failed
+      end
+
+      def failed!
+        @failed = true
+      end
+
+      protected
+
+      def framework
+        unless Compass::Frameworks[options[:framework]]
+          raise Compass::Error.new("No such framework: #{options[:framework].inspect}")
+        end
+        Compass::Frameworks[options[:framework]]
+      end
+
+    end
+  end
+end