compass 0.12.4 → 1.0.0

data/lib/compass/compiler.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 module Compass
   class Compiler
 
@@ -6,6 +8,8 @@ module Compass
     attr_accessor :working_path, :from, :to, :options, :sass_options, :staleness_checker, :importer
 
     def initialize(working_path, from, to, options)
+      Compass::Deprecation.deprecated!(:compass_compiler_constructor,
+        "Compass::Compiler is deprecated. Use Compass::SassCompiler instead.")
       self.working_path = working_path.to_s
       self.from, self.to = File.expand_path(from), to
       self.logger = options.delete(:logger)
@@ -15,10 +19,18 @@ module Compass
       self.sass_options.delete(:quiet)
       self.sass_options.update(sass_opts)
       self.sass_options[:cache_location] ||= determine_cache_location
-      self.sass_options[:importer] = self.importer = Sass::Importers::Filesystem.new(from)
+      self.sass_options[:filesystem_importer] ||= Sass::Importers::Filesystem
+      self.sass_options[:importer] = self.importer = self.sass_options[:filesystem_importer].new(from)
       self.sass_options[:compass] ||= {}
       self.sass_options[:compass][:logger] = self.logger
       self.sass_options[:compass][:environment] = Compass.configuration.environment
+      self.sass_options[:compass][:compiler_in_use] = true
+      reset_staleness_checker!
+    end
+
+    def reset_staleness_checker!
+      self.staleness_checker = nil
+      #Sass::Plugin::StalenessChecker.dependencies_cache = {}
       self.staleness_checker = Sass::Plugin::StalenessChecker.new(sass_options)
     end
 
@@ -47,10 +59,18 @@ module Compass
       @css_files ||= sass_files.map{|sass_file| corresponding_css_file(sass_file)}
     end
 
+    def sourcemap_files
+      @sourcemap_files ||= sass_files.map{|sass_file| corresponding_sourcemap_file(sass_file)}
+    end
+
     def corresponding_css_file(sass_file)
       "#{to}/#{stylesheet_name(sass_file)}.css"
     end
 
+    def corresponding_sourcemap_file(sass_file)
+      "#{to}/#{stylesheet_name(sass_file)}.css.map"
+    end
+
     def target_directories
       css_files.map{|css_file| File.dirname(css_file)}.uniq.sort.sort_by{|d| d.length }
     end
@@ -78,10 +98,18 @@ module Compass
       nil
     end
 
+    def reset!
+      reset_staleness_checker!
+      @sass_files = nil
+      @css_files = nil
+      @sourcemap_files = nil
+    end
+
     def clean!
       remove options[:cache_location]
-      css_files.each do |css_file|
+      css_files.zip(sourcemap_files).each do |css_file, sourcemap_file|
         remove css_file
+        remove sourcemap_file
       end
     end
 
@@ -98,9 +126,9 @@ module Compass
 
       # Compile each sass file.
       result = timed do
-        sass_files.zip(css_files).each do |sass_filename, css_filename|
+        sass_files.zip(css_files, sourcemap_files).each do |sass_filename, css_filename, sourcemap_filename|
           begin
-            compile_if_required sass_filename, css_filename
+            compile_if_required sass_filename, css_filename, sourcemap_filename
           rescue Sass::SyntaxError => e
             failure_count += 1
             handle_exception(sass_filename, css_filename, e)
@@ -113,69 +141,102 @@ module Compass
       return failure_count
     end
 
-    def compile_if_required(sass_filename, css_filename)
-      if should_compile?(sass_filename, css_filename)
-        compile sass_filename, css_filename
+    def compile_if_required(sass_filename, css_filename, sourcemap_filename = nil)
+      if should_compile?(sass_filename, css_filename, sourcemap_filename)
+        compile sass_filename, css_filename, sourcemap_filename
       else
         logger.record :unchanged, basename(sass_filename) unless options[:quiet]
+        remove(sourcemap_filename) if sourcemap_filename && !options[:sourcemap]
       end
     end
 
-    def timed
+    def timed(timed_thing = lambda {|res| res})
       start_time = Time.now
       res = yield
       end_time = Time.now
-      res.instance_variable_set("@__duration", end_time - start_time)
-      def res.__duration
+      has_duration = timed_thing.call(res)
+      has_duration.instance_variable_set("@__duration", end_time - start_time)
+      def has_duration.__duration
         @__duration
       end
       res
     end
 
     # Compile one Sass file
-    def compile(sass_filename, css_filename)
-      css_content = logger.red do
-        timed do
-          engine(sass_filename, css_filename).render
+    def compile(sass_filename, css_filename, sourcemap_filename = nil)
+      css_content, sourcemap = logger.red do
+        timed(lambda {|r| r[0]}) do
+          engine = engine(sass_filename, css_filename, sourcemap_filename)
+          if sourcemap_filename && options[:sourcemap]
+            engine.render_with_sourcemap(relative_path(css_filename, sourcemap_filename))
+          else
+            [engine.render, nil]
+          end
         end
       end
       duration = options[:time] ? "(#{(css_content.__duration * 1000).round / 1000.0}s)" : ""
-      write_file(css_filename, css_content, options.merge(:force => true, :extra => duration))
+      write_file(css_filename, css_content, options.merge(:force => true, :extra => duration), sass_options[:unix_newlines])
       Compass.configuration.run_stylesheet_saved(css_filename)
+      if sourcemap && sourcemap_filename
+        sourcemap_content = sourcemap.to_json(:css_path => css_filename,
+                                              :sourcemap_path => sourcemap_filename)
+        write_file(sourcemap_filename, sourcemap_content, options.merge(:force => true), sass_options[:unix_newlines])
+        Compass.configuration.run_sourcemap_saved(sourcemap_filename)
+      elsif sourcemap_filename && File.exist?(sourcemap_filename)
+        remove sourcemap_filename
+        Compass.configuration.run_sourcemap_removed(sourcemap_filename)
+      end
+    end
+
+    def relative_path(from_path, to_path)
+      Pathname.new(to_path).relative_path_from(Pathname.new(from_path).dirname).to_s
     end
 
-    def should_compile?(sass_filename, css_filename)
-      options[:force] || needs_update?(css_filename, sass_filename)
+    def should_compile?(sass_filename, css_filename, sourcemap_filename = nil)
+      return true if css_filename && !File.exist?(css_filename)
+      return true if sourcemap_filename && options[:sourcemap] && !File.exist?(sourcemap_filename)
+      options[:force] ||
+        needs_update?(css_filename, sass_filename) ||
+        (options[:sourcemap] && needs_update?(sourcemap_filename, sass_filename))
     end
 
     # A sass engine for compiling a single file.
-    def engine(sass_filename, css_filename)
+    def engine(sass_filename, css_filename, sourcemap_filename = nil)
       syntax = (sass_filename =~ /\.(s[ac]ss)$/) && $1.to_sym || :sass
-      opts = sass_options.merge(:filename => sass_filename, :css_filename => css_filename, :syntax => syntax)
-      Sass::Engine.new(File.read(sass_filename), opts)
+      opts = sass_options.merge(:filename => sass_filename,
+                                :css_filename => css_filename,
+                                :syntax => syntax,
+                                :sourcemap_filename => sourcemap_filename)
+      Sass::Engine.new(open(sass_filename).read, opts)
     end
 
     # Place the syntax error into the target css file,
     # formatted to display in the browser (in development mode)
     # if there's an error.
     def handle_exception(sass_filename, css_filename, e)
-      exception_file = basename(e.sass_filename)
+      exception_file = basename(e.sass_filename || sass_filename)
       file = basename(sass_filename)
       exception_file = nil if exception_file == file
       formatted_error = "(Line #{e.sass_line}#{ " of #{exception_file}" if exception_file}: #{e.message})"
       logger.record :error, file, formatted_error
       Compass.configuration.run_stylesheet_error(sass_filename, formatted_error)
-      write_file css_filename, error_contents(e, sass_filename), options.merge(:force => true)
+      write_file css_filename, error_contents(e, sass_filename), options.merge(:force => true), sass_options[:unix_newlines]
     end
 
     # Haml refactored this logic in 2.3, this is backwards compatibility for either one
     def error_contents(e, sass_filename)
-      if Sass::SyntaxError.respond_to?(:exception_to_css)
+      if show_full_exception?
         e.sass_template = sass_filename
-        Sass::SyntaxError.exception_to_css(e, :full_exception => show_full_exception?)
+        Sass::SyntaxError.exception_to_css(e)
       else
-        Sass::Plugin.options[:full_exception] ||= show_full_exception?
-        Sass::Plugin.send(:exception_string, e)
+        header = Sass::SyntaxError.send(:header_string, e, 1)
+        <<END
+/*
+#{header.gsub("*/", "*\\/")}
+
+Backtrace:\n#{e.backtrace.join("\n").gsub("*/", "*\\/")}
+*/
+END
       end
     end
 

data/lib/compass/configuration/comments.rb

@@ -42,7 +42,7 @@ module Compass
       end
 
       def comment_for_preferred_syntax
-        if top_level.preferred_syntax == :scss && top_level.sass_dir
+        if top_level.preferred_syntax_without_default.nil? && top_level.sass_dir
           %Q{
 # If you prefer the indented syntax, you might want to regenerate this
 # project again passing --syntax sass, or you can uncomment this:
@@ -55,5 +55,8 @@ module Compass
         end
       end
     end
+    class Data
+      include Comments
+    end
   end
 end

data/lib/compass/configuration/helpers.rb

@@ -3,36 +3,13 @@ module Compass
     @callbacks_loaded = false
     # The helpers are available as methods on the Compass module. E.g. Compass.configuration
     module Helpers
-      def configuration
-        @configuration ||= default_configuration
-        if block_given?
-          yield @configuration
-        end
-        @configuration
-      end
-
-      def default_configuration
-        Data.new('defaults').extend(Defaults).extend(Comments)
-      end
-
-      def add_configuration(config, filename = nil)
-        return if config.nil?
-
-
-        data = configuration_for(config, filename)
-
-        # puts "New configuration: #{data.name}"
-        # puts caller.join("\n")
-        data.inherit_from!(configuration)
-        data.on_top!
-        @configuration = data
-      end
-
       def configuration_for(config, filename = nil, defaults = nil)
         if config.nil?
           nil
         elsif config.is_a?(Compass::Configuration::Data)
           config
+        elsif config.instance_of?(Hash)
+          Compass::Configuration::Data.new(filename, config)
         elsif config.respond_to?(:read)
           filename ||= config.to_s if config.is_a?(Pathname)
           Compass::Configuration::FileData.new_from_string(config.read, filename, defaults)
@@ -47,11 +24,6 @@ module Compass
         end
       end
 
-      # Support for testing.
-      def reset_configuration!
-        @configuration = nil
-      end
-
       def sass_plugin_configuration
         configuration.to_sass_plugin_options
       end
@@ -104,33 +76,7 @@ module Compass
           end
           add_configuration(data)
         else
-          add_configuration(options[:project_type] || configuration.project_type_without_default || (yield if block_given?) || :stand_alone)  
-        end
-      end
-
-      def discover_extensions!
-        Compass.shared_extension_paths.each do |extensions_path|
-          if File.directory?(extensions_path)
-            Compass::Frameworks.discover(extensions_path)
-          end
-        end
-        if File.directory?(configuration.extensions_path)
-          Compass::Frameworks.discover(configuration.extensions_path)
-        end
-      end
-
-      # Returns a full path to the relative path to the project directory
-      def projectize(path, project_path = nil)
-        project_path ||= configuration.project_path
-        File.join(project_path, *path.split('/'))
-      end
-
-      def deprojectize(path, project_path = nil)
-        project_path ||= configuration.project_path
-        if path[0..(project_path.size - 1)] == project_path
-          path[(project_path.size + 1)..-1]
-        else
-          path
+          add_configuration(options[:project_type] || configuration.project_type_without_default || (yield if block_given?) || :stand_alone)
         end
       end
 
@@ -149,12 +95,19 @@ module Compass
         end
       end
 
+      # @deprecated
       def compiler
+        Compass::Deprecation.deprecated!(:compiler_accessor,
+          "Compass.compiler is deprecated. Use Compass.sass_compiler instead.")
+        Compass::Deprecation.mark_as_issued(:compass_compiler_constructor)
         Compass::Compiler.new(*Compass.configuration.to_compiler_arguments)
       end
+
+      def sass_compiler(*args)
+        Compass::SassCompiler.new(*args)
+      end
     end
   end
 
   extend Configuration::Helpers
-  
 end

data/lib/compass/configuration/serialization.rb

@@ -31,9 +31,9 @@ module Compass
           end
         end
         if @added_import_paths
-          self.additional_import_paths ||= []
-          self.additional_import_paths += @added_import_paths
-          self.additional_import_paths.uniq!
+          @added_import_paths.each do |p|
+            self.additional_import_paths << p unless self.additional_import_paths.include?(p)
+          end
         end
         issue_deprecation_warnings
       end
@@ -43,6 +43,10 @@ module Compass
         (required_libraries || []).each do |lib|
           contents << %Q{require '#{lib}'\n}
         end
+        unless (required_libraries || []).include?("compass/import-once/activate") ||
+               (required_libraries || []).include?("compass/import-once")
+          contents << "require 'compass/import-once/activate'\n"
+        end
         (loaded_frameworks || []).each do |lib|
           contents << %Q{load '#{lib}'\n}
         end
@@ -84,5 +88,8 @@ module Compass
       end
 
     end
+    class Data
+      include Serialization
+    end
   end
 end

data/lib/compass/deprecation.rb

@@ -0,0 +1,19 @@
+module Compass
+  module Deprecation
+    class << self
+      attr_accessor :issued_deprecations
+    end
+    self.issued_deprecations = {}
+
+    def self.deprecated!(identifier, message)
+      return if Deprecation.issued_deprecations[identifier]
+      Deprecation.issued_deprecations[identifier] = true
+      warn message
+      warn "Called from #{caller[1]}"
+    end
+
+    def self.mark_as_issued(identifier)
+      Deprecation.issued_deprecations[identifier] = true
+    end
+  end
+end

data/lib/compass/errors.rb

@@ -1,7 +1,5 @@
+require 'compass/error'
 module Compass
-  class Error < StandardError
-  end
-
   class FilesystemConflict < Error
   end
 

data/lib/compass/exec/global_options_parser.rb

@@ -45,10 +45,6 @@ module Compass::Exec::GlobalOptionsParser
       self.options[:force] = true
     end
 
-    opts.on('--dry-run', :NONE, 'Dry Run. Tells you what it plans to do.') do
-      self.options[:dry_run] = true
-    end
-
     opts.on('--boring', :NONE, 'Turn off colorized output.') do
       self.options[:color_output] = false
     end

data/lib/compass/exec/project_options_parser.rb

@@ -61,6 +61,14 @@ module Compass::Exec::ProjectOptionsParser
     opts.on('--no-line-comments', :NONE, 'Disable line comments.') do
       self.options[:line_comments] = false
     end
+
+    opts.on('--http-path HTTP_PATH', 'Set this to the root of your project when deployed') do |http_path|
+      self.options[:http_path] = http_path
+    end
+
+    opts.on('--generated-images-path GENERATED_IMAGES_PATH', 'The path where you generate your images') do |generated_images_path|
+      self.options[:generated_images_path] = generated_images_path
+    end
   end
 
 end

data/lib/compass/generated_version.rb

@@ -0,0 +1,4 @@
+module Compass
+  VERSION = "1.0.0"
+  VERSION_NAME = "Polaris"
+end

data/lib/compass/logger.rb

@@ -2,17 +2,22 @@ module Compass
 
   class Logger
 
-    DEFAULT_ACTIONS = [:directory, :exists, :remove, :create, :overwrite, :compile, :error, :identical, :warning]
-
-    COLORS = { :clear => 0, :red => 31, :green => 32, :yellow => 33 }
+    COLORS = { :clear => 0, :red => 31, :green => 32, :yellow => 33, :blue => 34 }
 
     ACTION_COLORS = {
       :error     => :red,
       :warning   => :yellow,
+      :info      => :green,
       :compile   => :green,
       :overwrite => :yellow,
+      :modified  => :yellow,
+      :clean     => :yellow,
+      :write     => :green,
       :create    => :green,
       :remove    => :yellow,
+      :delete    => :yellow,
+      :deleted   => :yellow,
+      :created   => :yellow,
       :exists    => :green,
       :directory => :green,
       :identical => :green,
@@ -20,8 +25,30 @@ module Compass
       :unchanged => :yellow
     }
 
+    DEFAULT_ACTIONS = ACTION_COLORS.keys
+
+    ACTION_CAN_BE_QUIET = {
+      :error     => false,
+      :warning   => true,
+      :info      => true,
+      :compile   => true,
+      :overwrite => true,
+      :modified  => true,
+      :clean     => true,
+      :write     => true,
+      :create    => true,
+      :remove    => true,
+      :delete    => true,
+      :deleted   => true,
+      :created   => true,
+      :exists    => true,
+      :directory => true,
+      :identical => true,
+      :convert   => true,
+      :unchanged => true
+    }
 
-    attr_accessor :actions, :options
+    attr_accessor :actions, :options, :time
 
     def initialize(*actions)
       self.options = actions.last.is_a?(Hash) ? actions.pop : {}
@@ -31,7 +58,11 @@ module Compass
 
     # Record an action that has occurred
     def record(action, *arguments)
+      return if options[:quiet] && ACTION_CAN_BE_QUIET[action]
       msg = ""
+      if time
+        msg << Time.now.strftime("%I:%M:%S.%3N %p")
+      end
       msg << color(ACTION_COLORS[action]) if Compass.configuration.color_output
       msg << "#{action_padding(action)}#{action}"
       msg << color(:clear) if Compass.configuration.color_output
@@ -39,22 +70,26 @@ module Compass
       log msg
     end
 
+    def green
+      wrap(:green) { yield }
+    end
+
     def red
-      $stderr.write(color(:red))
-      $stdout.write(color(:red))
-      yield
-    ensure
-      $stderr.write(color(:clear))
-      $stdout.write(color(:clear))
+      wrap(:red) { yield }
     end
 
     def yellow
-      $stderr.write(color(:yellow))
-      $stdout.write(color(:yellow))
+      wrap(:yellow) { yield }
+    end
+
+    def wrap(c, reset_to = :clear)
+      $stderr.write(color(c))
+      $stdout.write(color(c))
       yield
     ensure
-      $stderr.write(color(:clear))
-      $stdout.write(color(:clear))
+      $stderr.write(color(reset_to))
+      $stdout.write(color(reset_to))
+      $stdout.flush
     end
 
     def color(c)
@@ -69,13 +104,16 @@ module Compass
       end
     end
 
+    # Emit a log message without a trailing newline
     def emit(msg)
       print msg
+      $stdout.flush
     end
 
-    # Emit a log message
+    # Emit a log message with a trailing newline
     def log(msg)
       puts msg
+      $stdout.flush
     end
 
     # add padding to the left of an action that was performed.
@@ -89,15 +127,14 @@ module Compass
     end
   end
 
-  class NullLogger
+  class NullLogger < Logger
     def record(*args)
     end
 
     def log(msg)
     end
 
-    def red
-      yield
+    def emit(msg)
     end
   end
 end