compass 0.12.4 → 1.0.0

data/features/step_definitions/command_line_steps.rb

@@ -1,5 +1,6 @@
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../../test')))
 
+require 'bundler/setup'
 require 'test_helper'
 
 require 'compass/exec'
@@ -9,8 +10,6 @@ include Compass::IoHelper
 
 Before do
   Compass.reset_configuration!
-  Compass::Frameworks::ALL.clear
-  Compass::Frameworks.discover :defaults
   @cleanup_directories = []
   @original_working_directory = Dir.pwd
 end
@@ -136,11 +135,11 @@ Then "the following files are removed:" do |table|
 end
 
 Then /an? \w+ file ([^ ]+) is reported removed/ do |filename|
-  @last_result.should =~ /remove.*#{Regexp.escape(filename)}/
+  @last_result.should =~ /delete.*#{Regexp.escape(filename)}/
 end
 
-Then /an? \w+ file ([^ ]+) is reported created/ do |filename|
-  @last_result.should =~ /create.*#{Regexp.escape(filename)}/
+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|
@@ -256,11 +255,12 @@ end
 
 Then /^the image ([^ ]+) has a size of (\d+)x(\d+)$/ do |file, width, height| 
   # see http://snippets.dzone.com/posts/show/805
-  open(file, "rb").read[0x10..0x18].unpack('NN').should == [width.to_i, height.to_i]
+  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!([['blueprint'],['compass']])
+  table.diff!([['compass']])
 end
 
 Then /^I should see the following output: (.+)$/ do |expected|

data/lib/compass.rb

@@ -1,7 +1,16 @@
 module Compass
 end
 
-%w(dependencies util browser_support sass_extensions version errors quick_cache logger).each do |lib|
+%w(core
+   deprecation
+   dependencies
+   sass_extensions
+   version
+   errors
+   quick_cache
+   logger
+   actions
+).each do |lib|
   require "compass/#{lib}"
 end
 
@@ -14,24 +23,17 @@ module Compass
   def lib_directory
     File.expand_path(File.join(File.dirname(__FILE__)))
   end
-  def shared_extension_paths
-    @shared_extension_paths ||= begin
-      if ENV["HOME"] && File.directory?(ENV["HOME"])
-        [File.join(ENV["HOME"], ".compass", "extensions")]
-      else
-        []
-      end
-    rescue ArgumentError # If HOME is relative
-      []
-    end
-  end
-  module_function :base_directory, :lib_directory, :shared_extension_paths
+  module_function :base_directory, :lib_directory
   extend QuickCache
 end
 
-%w(configuration frameworks app_integration actions compiler).each do |lib|
+%w(configuration/helpers
+   configuration/comments
+   configuration/serialization
+   configuration/file_data
+   app_integration
+   compiler
+   sprite_importer
+).each do |lib|
   require "compass/#{lib}"
 end
-
-# for rails upgrade warnings in 0.12
-require 'compass/app_integration/rails'

data/lib/compass/actions.rb

@@ -29,14 +29,14 @@ module Compass
         raise Compass::FilesystemConflict.new(msg)
       else
         log_action :directory, separate("#{basename(dir)}/"), options
-        FileUtils.mkdir_p(dir) unless options[:dry_run]
+        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 = options[:dry_run]
+      skip_write = false
       contents = process_erb(contents, options[:erb]) if options[:erb]
       if File.exists?(file_name)
         existing_contents = IO.read(file_name)
@@ -53,9 +53,11 @@ module Compass
         log_action :create, basename(file_name), options
       end
       if skip_write
-        FileUtils.touch file_name unless options[:dry_run]
+        FileUtils.touch file_name
       else
-        Sass::Util.atomic_create_and_write_file(file_name) do |file|
+        mode = "w"
+        mode << "b" if binary
+        open(file_name, mode) do |file|
           file.write(contents)
         end
       end
@@ -82,6 +84,7 @@ module Compass
     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?

data/lib/compass/commands.rb

@@ -3,10 +3,12 @@ end
 
 require 'compass/commands/registry'
 
-%w(base generate_grid_background default help list_frameworks project_base
+%w(base project_base default help list_frameworks 
    update_project watch_project create_project clean_project extension_command
    imports installer_command print_version project_stats stamp_pattern
    sprite validate_project write_configuration interactive unpack_extension
 ).each do |lib|
   require "compass/commands/#{lib}"
 end
+
+Compass.discover_extensions!

data/lib/compass/commands/print_version.rb

@@ -28,10 +28,6 @@ Options:
           self.options[:patch] = true
           self.options[:custom] = true
         end
-        opts.on("--revision", "Include the source control revision") do
-          self.options[:revision] = true
-          self.options[:custom] = true
-        end
       end
     end
 
@@ -79,14 +75,7 @@ Options:
           version = ""
           version << "#{Compass.version[:major]}" if options[:major]
           version << ".#{Compass.version[:minor]}" if options[:minor]
-          version << ".#{Compass.version[:teeny]}" if options[:patch]
-          if options[:revision]
-            if version.size > 0
-              version << " [#{Compass.version[:rev][0..6]}]"
-            else
-              version << Compass.version[:rev]
-            end
-          end
+          version << ".#{Compass.version[:patch]}" if options[:patch]
           puts version
         elsif options[:quiet]
           puts ::Compass.version[:string]

data/lib/compass/commands/project_stats.rb

@@ -66,7 +66,7 @@ module Compass
           print "\n"
         end
         if @missing_css_parser
-          puts "\nInstall css_parser to enable stats on your css files:\n\n\tgem install css_parser"
+          puts "\nInstall #{@missing_css_parser} to enable stats on your css files:\n\n\tgem install #{@missing_css_parser}"
         end
       end
 
@@ -96,7 +96,7 @@ module Compass
       end
 
       def sorted_sass_files(compiler)
-        sass_files = compiler.sass_files(:exclude_partials => false)
+        sass_files = compiler.sass_files
         sass_files.map! do |s| 
           filename = Compass.deprojectize(s, File.join(Compass.configuration.project_path, Compass.configuration.sass_dir))
           [s, File.dirname(filename), File.basename(filename)]
@@ -130,9 +130,9 @@ module Compass
         else
           return [ '--', '--' , '--']
         end
-      rescue LoadError
-        @missing_css_parser = true
-        return [ 'DISABLED', 'DISABLED' ]
+      rescue LoadError => e
+        @missing_css_parser = e.message =~ /iconv/ ? "iconv" : "css_parser"
+        return [ 'DISABLED', 'DISABLED', 'DISABLED' ]
       end
 
       class << self

data/lib/compass/commands/update_project.rb

@@ -14,6 +14,10 @@ module Compass
           Options:
         }.split("\n").map{|l| l.gsub(/^ */,'')}.join("\n")
 
+        opts.on("--[no-]sourcemap", "Generate a sourcemap during compilation.") do |sm|
+          self.options[:sourcemap] = sm
+        end
+
         opts.on("--time", "Display compilation times.") do
           self.options[:time] = true
         end
@@ -35,68 +39,69 @@ module Compass
 
       def initialize(working_path, options)
         super
-        assert_project_directory_exists! unless dry_run?
+        assert_project_directory_exists!
       end
 
       def perform
         compiler = new_compiler_instance
         check_for_sass_files!(compiler)
-        compiler.clean! if compiler.new_config?
-        error_count = compiler.run
-        failed! if error_count > 0
+        prepare_project!(compiler)
+        compiler.compile!
+        if compiler.error_count > 0
+          compiler.logger.red do
+            compiler.logger.log "Compilation failed in #{compiler.error_count} files."
+          end
+          failed! 
+        end
       end
 
-      def check_for_sass_files!(compiler)
-        if compiler.sass_files.empty? && !dry_run?
-          message = "Nothing to compile. If you're trying to start a new project, you have left off the directory argument.\n"
-          message << "Run \"compass -h\" to get help."
-          raise Compass::Error, message
+      def prepare_project!(compiler)
+        if options[:project_name]
+          Compass.configuration.project_path = File.expand_path(options[:project_name])
         end
-      end
 
-      def dry_run?
-        options[:dry_run]
+        if config_file = new_config?(compiler)
+          compiler.logger.record :modified, relativize(config_file)
+          compiler.logger.record :clean, relativize(Compass.configuration.css_path)
+          compiler.clean!
+        end
       end
 
-      def new_compiler_instance(additional_options = {})
-        @compiler_opts ||= begin
-          compiler_opts = {:sass => Compass.sass_engine_options}
-          compiler_opts.merge!(options)
-          compiler_opts[:sass_files] = explicit_sass_files
-          compiler_opts[:cache_location] = determine_cache_location
-          if options.include?(:debug_info) && options[:debug_info]
-            compiler_opts[:sass][:debug_info] = options.delete(:debug_info)
-          end
-          compiler_opts
+      # Determines if the configuration file is newer than any css file
+      def new_config?(compiler)
+        config_file = Compass.detect_configuration_file
+        return false unless config_file
+        config_mtime = File.mtime(config_file)
+        compiler.file_list.each do |(_, css_filename, _)|
+          return config_file if File.exists?(css_filename) && config_mtime > File.mtime(css_filename)
         end
+        nil
+      end
 
-        @memory_store ||= Sass::CacheStores::Memory.new
-        @backing_store ||= compiler_opts[:cache_store]
-        @backing_store ||= Sass::CacheStores::Filesystem.new(determine_cache_location)
-        @cache_store ||= Sass::CacheStores::Chain.new(@memory_store, @backing_store)
-        @memory_store.reset!
+      def check_for_sass_files!(compiler)
+        file_list = compiler.file_list
+        if file_list.empty?
+          message = "Compass can't find any Sass files to compile.\nIs your compass configuration correct?.\nIf you're trying to start a new project, you have left off the directory argument.\n"
+          message << "Run \"compass -h\" to get help."
+          raise Compass::Error, message
+        elsif missing = file_list.find {|(sass_file, _, _)| !File.exist?(sass_file)}
+          raise Compass::Error, "File not found: #{missing[0]}"
+        end
+      end
 
-        Compass::Compiler.new(
-          working_path,
-          Compass.configuration.sass_path,
-          Compass.configuration.css_path,
-          @compiler_opts.merge(:cache_store => @cache_store).merge(additional_options)
-        )
+      def new_compiler_instance
+        Compass::SassCompiler.new(compiler_options)
       end
 
-      def explicit_sass_files
-        return unless options[:sass_files]
-        options[:sass_files].map do |sass_file|
-          if absolute_path? sass_file
-            sass_file
-          else
-            File.join(Dir.pwd, sass_file)
-          end
-        end
+      def compiler_options
+        transfer_options(options, {}, :time, :debug_info, :only_sass_files, :force, :quiet)
       end
 
-      def determine_cache_location
-        Compass.configuration.cache_path || Sass::Plugin.options[:cache_location] || File.join(working_path, ".sass-cache")
+      def transfer_options(from, to, *keys)
+        keys.each do |k|
+          to[k] = from[k] unless from[k].nil?
+        end
+        to
       end
 
       class << self
@@ -128,11 +133,15 @@ module Compass
           if arguments.size > 0
             parser.options[:project_name] = arguments.shift if File.directory?(arguments.first)
             unless arguments.empty?
-              parser.options[:sass_files] = arguments.dup
-              parser.options[:force] = true
+              parser.options[:only_sass_files] = absolutize(*arguments)
             end
           end
         end
+
+        def absolutize(*paths)
+          paths.map {|path| File.expand_path(path) }
+        end
+
       end
     end
   end

data/lib/compass/commands/watch_project.rb

@@ -1,8 +1,8 @@
+# encoding: UTF-8
 require 'fileutils'
 require 'pathname'
-require 'compass/commands/base'
 require 'compass/commands/update_project'
-require 'sass/plugin'
+require "compass/sass_compiler"
 
 module Compass
   module Commands
@@ -25,131 +25,78 @@ module Compass
 
       end
     end
-    module MemoryDebugger
-      def report_on_instances(type, options = {})
-        @@runs ||= 0
-        @@runs += 1
-        @@object_id_tracker ||= {}
-        @@object_id_tracker[type] ||= []
-        GC.start
-        sleep options.fetch(:gc_pause, 1)
-        count = ObjectSpace.each_object(type) do |obj|
-          if options.fetch(:verbose, true)
-            if @@runs > 2
-              if !@@object_id_tracker[type].include?(obj.object_id)
-                begin
-                  puts obj.inspect
-                rescue
-                end
-                puts "#{obj.class.name}:#{obj.object_id}"
-              end
-            end
-            @@object_id_tracker[type] << obj.object_id
-          end
-        end
-        puts "#{type}: #{count} instances."
-      end
-    end
+
     class WatchProject < UpdateProject
 
       register :watch
 
       attr_accessor :last_update_time, :last_sass_files
 
-      include MemoryDebugger
-
       def perform
-        Signal.trap("INT") do
-          puts ""
-          exit 0
+        compiler = new_compiler_instance
+        compiler.logger.time = true if options[:time]
+        prepare_project!(compiler)
+        compiler.logger.log ">>> #{compiler.logger.color(:green)}Compass is watching for changes.#{compiler.logger.color(:clear)} #{compiler.logger.color(:red)}Press Ctrl-C to Stop.#{compiler.logger.color(:clear)}"
+        begin
+          compiler.watch!(:additional_watch_paths => additional_watch_paths, &method(:notify_watches))
+          happy_styling!(compiler.logger)
+        rescue Interrupt
+          happy_styling!(compiler.logger)
         end
+      end
 
-        check_for_sass_files!(new_compiler_instance)
-        recompile
-
-        require 'fssm'
+      def happy_styling!(logger)
+          logger.log "\n#{logger.color(:yellow)}★★★ #{logger.color(:blue)}Happy Styling!#{logger.color(:yellow)} ★★★#{logger.color(:clear)}"
+      end
 
+      def compiler_options
+        super.merge(:poll => options[:poll], :full_exception => true)
+      end
 
-        if options[:poll]
-          require "fssm/backends/polling"
-          # have to silence the ruby warning about chaning a constant.
-          stderr, $stderr = $stderr, StringIO.new
-          FSSM::Backends.const_set("Default", FSSM::Backends::Polling)
-          $stderr = stderr
-        end
+      def additional_watch_paths
+        Compass.configuration.watches.map do |watch|
+          pathname = Pathname.new(File.join(Compass.configuration.project_path, watch.glob))
+          real_path = nil
+          pathname.ascend do |p|
+            if p.exist?
+              real_path = p
+              break
+            end
+          end
+          real_path
+        end.compact.uniq
+      end
 
-        action = FSSM::Backends::Default.to_s == "FSSM::Backends::Polling" ? "polling" : "watching"
+      def notify_watches(modified, added, removed)
+        project_path = Compass.configuration.project_path
+        files = {:modified => modified,
+                 :added    => added,
+                 :removed  => removed}
 
-        puts ">>> Compass is #{action} for changes. Press Ctrl-C to Stop."
-        $stdout.flush
+        run_once, run_each = Compass.configuration.watches.partition {|w| w.run_once_per_changeset?}
 
-        begin
-        FSSM.monitor do |monitor|
-          Compass.configuration.sass_load_paths.each do |load_path|
-            load_path = load_path.root if load_path.respond_to?(:root)
-            next unless load_path.is_a? String
-            monitor.path load_path do |path|
-              path.glob '**/*.s[ac]ss'
-
-              path.update &method(:recompile)
-              path.delete {|base, relative| remove_obsolete_css(base,relative); recompile(base, relative)}
-              path.create &method(:recompile)
-            end
+        run_once.each do |watcher|
+          if file = files.values.flatten.detect{|f| watcher.match?(f) }
+            action = files.keys.detect{|k| files[k].include?(file) }
+            watcher.run_callback(project_path, relative_to(file, project_path), action)
           end
-          Compass.configuration.watches.each do |glob, callback|
-            monitor.path Compass.configuration.project_path do |path|
-              path.glob glob
-              path.update do |base, relative|
-                puts ">>> Change detected to: #{relative}"
-                $stdout.flush
-                callback.call(base, relative)
-              end
-              path.create do |base, relative|
-                puts ">>> New file detected: #{relative}"
-                $stdout.flush
-                callback.call(base, relative)
-              end
-              path.delete do |base, relative|
-                puts ">>> File Removed: #{relative}"
-                $stdout.flush
-                callback.call(base, relative)
+        end
+
+        run_each.each do |watcher|
+          files.each do |action, list|
+            list.each do |file|
+              if watcher.match?(file)
+                watcher.run_callback(project_path, relative_to(file, project_path), action)
               end
             end
           end
-
         end
-      rescue FSSM::CallbackError => e
-        # FSSM catches exit? WTF.
-        if e.message =~ /exit/
-          exit
-        end
-      end
       end
 
-      def remove_obsolete_css(base = nil, relative = nil)
-        compiler = new_compiler_instance(:quiet => true)
-        sass_files = compiler.sass_files
-        deleted_sass_files = (last_sass_files || []) - sass_files
-        deleted_sass_files.each do |deleted_sass_file|
-          css_file = compiler.corresponding_css_file(deleted_sass_file)
-          remove(css_file) if File.exists?(css_file)
-        end
-        self.last_sass_files = sass_files
-      end
-
-      def recompile(base = nil, relative = nil)
-        @memory_cache.reset! if @memory_cache
-        compiler = new_compiler_instance(:quiet => true, :loud => [:identical, :overwrite, :create])
-        if file = compiler.out_of_date?
-          begin
-            puts ">>> Change detected at "+Time.now.strftime("%T")+" to: #{relative || compiler.relative_stylesheet_name(file)}"
-            $stdout.flush
-            compiler.run
-            GC.start
-          rescue StandardError => e
-            ::Compass::Exec::Helpers.report_error(e, options)
-          end
-        end
+      def relative_to(f, dir)
+        Pathname.new(f).relative_path_from(Pathname.new(dir))
+      rescue ArgumentError # does not share a common path.
+        f
       end
 
       class << self