guard-sass 0.7.1 → 1.0.0

data/README.md

@@ -15,7 +15,7 @@ Install the gem with:
 
 Add it to your Gemfile:
 
-    gem 'guard-sass'
+    gem 'guard-sass', :require => false
 
 And finally add a basic setup to your Guardfile with:
 
@@ -92,8 +92,24 @@ The following options can be passed to guard-sass:
     :all_on_start => true               # Compiles all sass files on start
                                         # default: false
 
-    :extension => ''                    # Extension used for written files.
-                                        # default: '.css'
+    :compass => true                    # Enable Compass support with default Rails 3.1-compatible
+                                        # options. You can overwrite any of these options by passing
+                                        # a hash.
+
+    :compass => {
+      :images_dir       => "app/assets/images",
+      :images_path      => File.join(Dir.pwd, "app/assets/images"),
+      :http_images_path => "/assets",
+      :http_images_dir  => "/assets",
+      :http_fonts_path  => "/assets",
+      :http_fonts_dir   => "/assets"
+    }
+
+    :smart_partials => true             # Causes guard-sass to do dependency resolution and only
+                                        # recompile the files that need it when you update partials.
+                                        # If not on, then guard-sass will update all files when a
+                                        # partial is changed.
+                                        # default: false
 
     :hide_success => true               # Disable successful compilation messages.
                                         # default: false

data/lib/guard/sass/formatter.rb

@@ -1,6 +1,6 @@
 module Guard
   class Sass
-  
+
     # The formatter handles providing output to the user.
     class Formatter
 
@@ -10,35 +10,39 @@ module Guard
       def initialize(opts={})
         @hide_success = opts.fetch(:hide_success, false)
       end
-      
+
       # Show a success message and notification if successes are being shown.
       #
       # @param msg [String]
       # @param opts [Hash]
       def success(msg, opts={})
         unless @hide_success
-          ::Guard::UI.info(msg, opts)      
+          benchmark = nil
+          if time = opts.delete(:time)
+            benchmark = "[\e[33m%2.2fs\e[0m] " % time
+          end
+          ::Guard::UI.info("\t\e[1;37mSass\e[0m %s%s" % [benchmark, msg], opts)
           notify(opts[:notification], :image => :success)
         end
       end
-      
+
       # Show an error message and notification.
       #
       # @param msg [String]
       # @param opts [Hash]
       def error(msg, opts={})
-        ::Guard::UI.error(msg, opts)
-        notify(opts[:notification], :image => :failed) 
+        ::Guard::UI.error("[Sass] #{msg}", opts)
+        notify(opts[:notification], :image => :failed)
       end
-      
+
       # Show a system notification.
-      # 
+      #
       # @param msg [String]
       # @param opts [Hash] See http://rubydoc.info/github/guard/guard/master/Guard/Notifier.notify
       def notify(msg, opts={})
         ::Guard::Notifier.notify(msg, ({:title => "Guard::Sass"}).merge(opts))
       end
-    
+
     end
   end
 end

data/lib/guard/sass/runner.rb

@@ -1,4 +1,5 @@
 require 'sass'
+require 'benchmark'
 
 module Guard
   class Sass
@@ -32,11 +33,33 @@ module Guard
         changed_files = []
 
         # Assume partials have been checked for previously, so no partials are included here
+        rinput  = (options[:input]  || "").reverse
+        routput = (options[:output] || "").reverse
+
+        input   = options[:input]  || ''
+        output  = options[:output] || ''
+
+        max_length = files.map do |file|
+          file.sub(/^#{input}/, '').gsub(/^\//, '').length
+        end.max || 0
+
         files.each do |file|
           begin
-            css_file = write_file(compile(file), get_output_dir(file), file)
-            message = options[:noop] ? "verified #{file}" : "compiled #{file} to #{css_file}"
-            @formatter.success "-> #{message}", :notification => message
+            css_file = nil
+            time = Benchmark.realtime do
+              css_file = write_file(compile(file), get_output_dir(file), file)
+            end
+
+            short_file     = file.sub(/^#{input}/, '').gsub(/^\//, '')
+            short_css_file = css_file.sub(/^#{output}/, '').gsub(/^\//, '')
+
+            message = if options[:noop]
+                        "verified #{file} (#{time})"
+                      else
+                        "%s -> %s" % [short_file.ljust(max_length), short_css_file]
+                      end
+
+            @formatter.success "#{message}", :notification => message, :time => time
             changed_files << css_file
 
           rescue ::Sass::SyntaxError => e
@@ -61,7 +84,6 @@ module Guard
           :debug_info   => options[:debug_info],
           :line_numbers => options[:line_numbers]
         }
-
         ::Sass::Engine.new(content, sass_options).render
       end
 
@@ -91,7 +113,8 @@ module Guard
       # @param file [String] Name of the file
       # @return [String] Path of file written
       def write_file(content, dir, file)
-        path = File.join(dir, File.basename(file, '.*')) << options[:extension]
+        filename = File.basename(file).gsub(/(\.s?[ac]ss)+/, '.css')
+        path = File.join(dir, filename)
 
         unless options[:noop]
           FileUtils.mkdir_p(dir)
@@ -100,7 +123,6 @@ module Guard
 
         path
       end
-
     end
   end
 end

data/lib/guard/sass/version.rb

@@ -1,5 +1,5 @@
 module Guard
   class SassVersion
-    VERSION = '0.7.1'
+    VERSION = '1.0.0'
   end
 end

data/lib/guard/sass.rb

@@ -46,16 +46,41 @@ module Guard
       if options[:input]
         load_paths << options[:input]
         options[:output] = options[:input] unless options.has_key?(:output)
-        watchers << ::Guard::Watcher.new(%r{^#{ options.delete(:input) }/(.+\.s[ac]ss)$})
+        watchers << ::Guard::Watcher.new(%r{^#{ options[:input] }/(.+\.s[ac]ss)$})
       end
-
       options = DEFAULTS.merge(options)
+
+      if compass = options.delete(:compass)
+        require 'compass'
+        compass = {} unless compass.is_a?(Hash)
+
+        Compass.add_project_configuration
+        Compass.configuration.project_path   ||= Dir.pwd
+        Compass.configuration.images_dir       = compass[:images_dir]       || "app/assets/images"
+        Compass.configuration.images_path      = compass[:images_path]      || File.join(Dir.pwd, "app/assets/images")
+        Compass.configuration.http_images_path = compass[:http_images_path] || "/assets"
+        Compass.configuration.http_images_dir  = compass[:http_images_dir]  || "/assets"
+
+        Compass.configuration.http_fonts_path  = compass[:http_fonts_path]  || "/assets"
+        Compass.configuration.http_fonts_dir   = compass[:http_fonts_dir]   || "/assets"
+
+        Compass.configuration.asset_cache_buster = Proc.new {|*| {:query => Time.now.to_i} }
+        options[:load_paths] ||= []
+        options[:load_paths] << Compass.configuration.sass_load_paths
+      end
+
       options[:load_paths] += load_paths
+      options[:load_paths].flatten!
 
       @runner = Runner.new(watchers, options)
       super(watchers, options)
     end
 
+    # @return [Array<String>] Paths of all sass/scss files
+    def files
+      Watcher.match_files self, Dir['**/*.s[ac]ss']
+    end
+
     # If option set to run all on start, run all when started.
     #
     # @raise [:task_has_failed]
@@ -67,17 +92,66 @@ module Guard
     #
     # @raise [:task_has_failed]
     def run_all
-      files = Dir.glob('**/*.s[ac]ss').reject {|f| partial?(f) }
-      run_on_changes Watcher.match_files(self, files)
+      run_on_changes files.reject {|f| partial?(f) }
+    end
+
+    def resolve_partials_to_owners(paths, depth = 0)
+      # If we get more than 10 levels of includes deep, we're probably in an
+      # import loop.
+      return run_all if depth > 10
+
+      # Get all files that might have imports
+      root = options[:input]
+      root += '/' unless root.end_with?('/')
+
+      partials  = paths.find_all {|f| partial?(f) }
+      paths    -= partials
+      sub_paths = partials.map {|p|
+        # Remove root, need relative paths
+        p.sub(/^#{root}/, '')
+      }.map {|p|
+        # Make version without underscores
+        [p, p.gsub(/(\/|^)_/, '\\1')]
+      }.map {|ps|
+        # For each of those, make a version with extensions
+        ps.map {|p|
+          [p, p.gsub(/\.s[ac]ss$/, '')]
+        }
+      }.flatten
+
+      # Search through all eligible files and find those we need to recompile
+      joined_paths = sub_paths.map {|p| Regexp.escape(p) }.join('|')
+      matcher = /@import.*(:?#{joined_paths})/
+      importing = files.find_all {|file| open(file, 'r').read.match(matcher) }
+      paths += importing
+
+      # If any of the matched files were partials, then go ahead and walk up the
+      # import tree
+      if paths.any? {|f| partial?(f) }
+        paths = resolve_partials_to_owners(paths, depth + 1)
+      end
+
+      # Return our resolved set of paths to recompile
+      paths
+    end
+
+    def run_with_partials(paths)
+      if options[:smart_partials]
+        paths = resolve_partials_to_owners(paths)
+        run_on_changes Watcher.match_files(self, paths) unless paths.nil?
+      else
+        run_all
+      end
     end
 
-    # Build the files given. If a 'partial' file is found (begins with '_') calls
-    # {#run_all} as we don't know which other files need to use it.
+    # Builds the files given. If a 'partial' file is found (name begins with
+    # '_'), calls {#run_with_partials} so that files which include it are
+    # rebuilt.
     #
     # @param paths [Array<String>]
     # @raise [:task_has_failed]
     def run_on_changes(paths)
-      return run_all if paths.any? {|f| partial?(f) }
+      return run_with_partials(paths) if paths.any? {|f| partial?(f) }
 
       changed_files, success = @runner.run(paths)
       notify changed_files
@@ -102,8 +176,9 @@ module Guard
       end
     end
 
+    # @return Whether +path+ is a partial
     def partial?(path)
-      File.basename(path)[0,1] == "_"
+      File.basename(path).start_with? '_'
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: guard-sass
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-06 00:00:00.000000000 Z
+date: 2012-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
@@ -114,3 +114,4 @@ signing_key:
 specification_version: 3
 summary: Guard gem for Sass
 test_files: []
+has_rdoc: