guard-sass 0.3.4 → 0.4.0

data/README.md

@@ -33,15 +33,11 @@ guard-sass can be adapted to all kind of projects. Please read the
 
 In a Ruby project you want to configure your input and output directories.
 
-```ruby
-guard 'sass', :input => 'sass', :output => 'styles'
-```
+    guard 'sass', :input => 'sass', :output => 'styles'
 
 If your output directory is the same as the input directory, you can simply skip it:
 
-```ruby
-guard 'sass', :input => 'styles'
-```
+    guard 'sass', :input => 'styles'
 
 ### Rails app with the asset pipeline
 
@@ -51,65 +47,57 @@ still like to have feedback on the validation of your stylesheets (preferably
 with a Growl notification) directly after you save a change, then you can still 
 use this Guard and simply skip generation of the output file:
 
-```ruby
-guard 'sass', :input => 'app/assets/stylesheets', :noop => true
-```
+    guard 'sass', :input => 'app/assets/stylesheets', :noop => true
 
 This gives you (almost) immediate feedback on whether the changes made are valid, 
 and is much faster than making a subsequent request to your Rails application. 
 If you just want to be notified when an error occurs you can hide the success 
 compilation message:
 
-```ruby
-guard 'sass', 
-  :input => 'app/assets/stylesheets', 
-  :noop => true, 
-  :hide_success => true
-```
+    guard 'sass', 
+      :input => 'app/assets/stylesheets', 
+      :noop => true, 
+      :hide_success => true
 
 ### Rails app without the asset pipeline
 
 Without the asset pipeline you just define an input and output directory as in
 a normal Ruby project:
 
-```ruby
-guard 'sass', :input => 'app/stylesheets', :output => 'public/stylesheets'
-```
+    guard 'sass', :input => 'app/stylesheets', :output => 'public/stylesheets'
 
 ## Options
 
 The following options can be passed to guard-sass:
 
-```ruby
-:input => 'sass'                    # Relative path to the input directory.
-                                    # A suffix `/(.+\.s[ac]ss)` will be added to this option.
-                                    # default: nil
-
-:output => 'css'                    # Relative path to the output directory.
-                                    # default: 'css' or the :input option when supplied
-
-:notification => false              # Whether to display success and error notifications.
-                                    # default: true
-
-:hide_success => true               # Disable successful compilation messages.
-                                    # default: false
-
-:shallow => true                    # Do not create nested output directories.
-                                    # default: false
-
-:style => :nested                   # Controls the output style. Accepted options are :nested, 
-                                    # :compact, :compressed and :expanded
-                                    # default: :nested
-
-:load_paths => ['sass/partials']    # Paths for sass to find imported sass files from.
-                                    # default: all directories under current
-
-:noop => true                       # No operation: Do not write output file
-                                    # default: false
-
-:debug_info_ => true                # File and line number info for FireSass.
-                                    # default: false
-```
+    :input => 'sass'                    # Relative path to the input directory.
+                                        # A suffix `/(.+\.s[ac]ss)` will be added to this option.
+                                        # default: nil
+    
+    :output => 'css'                    # Relative path to the output directory.
+                                        # default: 'css' or the :input option when supplied
+    
+    :notification => false              # Whether to display success and error notifications.
+                                        # default: true
+    
+    :hide_success => true               # Disable successful compilation messages.
+                                        # default: false
+    
+    :shallow => true                    # Do not create nested output directories.
+                                        # default: false
+    
+    :style => :nested                   # Controls the output style. Accepted options are :nested, 
+                                        # :compact, :compressed and :expanded
+                                        # default: :nested
+    
+    :load_paths => ['sass/partials']    # Paths for sass to find imported sass files from.
+                                        # default: all directories under current
+    
+    :noop => true                       # No operation: Do not write output file
+                                        # default: false
+    
+    :debug_info_ => true                # File and line number info for FireSass.
+                                        # default: false
 
 ### Output short notation
 
@@ -117,23 +105,19 @@ guard-sass also has a short notation like [guard-coffeescript][gcs], this lets
 you define an input folder (with an optional output folder) automatically creating
 the required watcher.
 
-```ruby
-guard 'sass', :input => 'sass', :output => 'styles'
-# or
-guard 'sass', :input => 'stylesheets'
-```
+    guard 'sass', :input => 'sass', :output => 'styles'
+    # or
+    guard 'sass', :input => 'stylesheets'
 
 These are equivalent to
 
-```ruby
-guard 'sass', :output => 'styles' do
-  watch %r{^sass/(.+\.s[ac]ss)$}
-end
-
-guard 'sass' do
-  watch %r{^stylesheets/(.+\.s[ac]ss)$}
-end
-```
+    guard 'sass', :output => 'styles' do
+      watch %r{^sass/(.+\.s[ac]ss)$}
+    end
+    
+    guard 'sass' do
+      watch %r{^stylesheets/(.+\.s[ac]ss)$}
+    end
 
 ### Nested directories
 
@@ -145,27 +129,19 @@ output directory. The detection is based on the match of the watch regular expre
 
 A file
 
-```
-/app/stylesheets/form/button.sass
-```
+    /app/stylesheets/form/button.sass
 
 that has been detected by the watch
 
-```ruby
-watch(%r{^app/stylesheets/(.+\.s[ac]ss)$})
-```
+    watch(%r{^app/stylesheets/(.+\.s[ac]ss)$})
 
 with an output directory of
 
-```ruby
-:output => 'public/stylesheets'
-```
+    :output => 'public/stylesheets'
 
 will be compiled to
 
-```
-public/stylesheets/form/button.css
-```
+    public/stylesheets/form/button.css
 
 Note the parenthesis around `.+\.s[ac]ss`. This enables guard-sass to place 
 the full path that was matched inside the parenthesis into the proper output directory.

data/lib/guard/sass/formatter.rb

@@ -0,0 +1,49 @@
+module Guard
+  class Sass
+  
+    # The formatter handles providing output to the user.
+    class Formatter
+
+      # @param opts [Hash]
+      # @option opts [Boolean] :notification
+      #   Whether to show notifications  
+      # @option otps [Boolean] :success
+      #   Whether to print success messages
+      def initialize(opts={})
+        @notification = opts.fetch(:notification, true)
+        @success      = opts.fetch(:show_success, true)
+      end
+      
+      # Show a success message and notification if successes are being shown.
+      #
+      # @param msg [String]
+      # @param opts [Hash]
+      def success(msg, opts={})
+        if @success
+          ::Guard::UI.info(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) 
+      end
+      
+      # Show a system notification, if notifications are enabled.
+      # 
+      # @param msg [String]
+      # @param opts [Hash] See http://rubydoc.info/github/guard/guard/master/Guard/Notifier.notify
+      def notify(msg, opts={})
+        if @notification
+          ::Guard::Notifier.notify(msg, ({:title => "Guard::Sass"}).merge(opts))
+        end
+      end
+    
+    end
+  end
+end

data/lib/guard/sass/runner.rb

@@ -0,0 +1,110 @@
+require 'sass'
+
+module Guard
+  class Sass
+    
+    class Runner
+    
+      attr_reader :options
+    
+      # @param watchers [Array<Guard::Watcher>]
+      # @param options [Hash] See Guard::Sass::DEFAULTS for available options
+      def initialize(watchers, options={})
+        @watchers = watchers
+        @options  = options
+        @formatter = Formatter.new(
+          :notification => options[:notification], 
+          :show_success => !options[:hide_success]
+        )
+      end
+    
+      # @param files [Array<String>]
+      # @return [Array<Array,Boolean>]
+      def run(files)
+        changed_files, errors =  compile_files(files)
+        [changed_files, errors.empty?]
+      end
+      
+      private
+
+      # @param files [Array<String>] Files to compile
+      # @return [Array<Array,Array>] The files which have been changed and an array
+      #  of any error messages if any errors occurred.
+      def compile_files(files)
+        errors        = []
+        changed_files = []
+        
+        # Assume partials have been checked for previously, so no partials are included here
+        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
+            
+            changed_files << css_file
+            
+          rescue ::Sass::SyntaxError => e
+            message = (options[:noop] ? 'validation' : 'rebuild') + " of #{file} failed"
+            errors << message
+            @formatter.error "Sass > #{e.sass_backtrace_str(file)}", :notification => message
+          end
+        end
+        
+        [changed_files.compact, errors]
+      end
+      
+      # @param file [String] Path to sass/scss file to compile
+      # @return [String] Compiled css.
+      def compile(file)
+        content = IO.read(file)
+        
+        sass_options = {
+          :syntax     => file[-4..-1].to_sym,
+          :load_paths => options[:load_paths],
+          :style      => options[:style],
+          :debug_info => options[:debug_info]
+        }
+        
+        ::Sass::Engine.new(content, sass_options).render
+      end
+      
+      # @param file [String]
+      # @return [String] Directory to write +file+ to
+      def get_output_dir(file)
+        folder = options[:output]
+  
+        unless options[:shallow]
+          @watchers.product([file]).each do |watcher, file|
+            if matches = file.match(watcher.pattern)
+              if matches[1]
+                folder = File.join(options[:output], File.dirname(matches[1])).gsub(/\/\.$/, '')
+                break
+              end
+            end
+          end
+        end
+  
+        folder
+      end
+      
+      # Write file contents, creating directories where required.
+      #
+      # @param content [String] Contents of the file
+      # @param dir [String] Directory to write to
+      # @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.split('.')[0])) << '.css'
+      
+        unless options[:noop]
+          FileUtils.mkdir_p(dir)
+          File.open(path, 'w') {|f| f.write(content) }
+        end
+        
+        path
+      end
+    
+    end
+  end
+end

data/lib/guard/sass/version.rb

@@ -1,5 +1,5 @@
 module Guard
   class SassVersion
-    VERSION = '0.3.4'
+    VERSION = '0.4.0'
   end
 end

data/lib/guard/sass.rb

@@ -2,79 +2,52 @@ require 'guard'
 require 'guard/guard'
 require 'guard/watcher'
 
-require 'sass'
-
 module Guard
   class Sass < Guard
+  
+    autoload :Runner,    'guard/sass/runner'
+    autoload :Formatter, 'guard/sass/formatter'
 
     DEFAULTS = {
-      :output       => 'css',     # Output directory
-      :notification => true,      # Enable notifications?
-      :shallow      => false,     # Output nested directories?
-      :style        => :nested,   # Nested output
-      :debug_info   => false,     # File and line number info for FireSass
-      :noop         => false,     # Do no write output file
-      :hide_success => false,     # Do not show success message
+      :output       => 'css',
+      :style        => :nested,
+      :notification => true,
+      :shallow      => false,
+      :debug_info   => false,
+      :noop         => false,
+      :hide_success => false,
       :load_paths   => Dir.glob('**/**').find_all {|i| File.directory?(i) }
     }
 
-    def initialize(watchers = [], options = {})
+    # @param watchers [Array<Guard::Watcher>]
+    # @param options [Hash]
+    # @option options [String] :input
+    #   The input directory
+    # @option options [String] :output 
+    #   The output directory
+    # @option options [Array<String>] :load_paths
+    #   List of directories you can @import from 
+    # @option options [Boolean] :notification 
+    #   Whether to show notifications
+    # @option options [Boolean] :shallow 
+    #   Whether to output nested directories
+    # @option options [Boolean] :debug_info
+    #   Whether to output file and line number info for FireSass
+    # @option options [Boolean] :noop
+    #   Whether to run in "asset pipe" mode, no ouput, just validation
+    # @option options [Boolean] :hide_success
+    #   Whether to hide all success messages
+    # @option options [Symbol] :style
+    #   See http://sass-lang.com/docs/yardoc/file.SASS_REFERENCE.html#output_style
+    def initialize(watchers=[], options={})
       if options[:input]
         options[:output] = options[:input] unless options.has_key?(:output)
         watchers << ::Guard::Watcher.new(%r{^#{options.delete(:input)}/(.+\.s[ac]ss)$})
       end
-
-      super(watchers, DEFAULTS.merge(options))
-    end
-
-
-    # Builds the sass or scss. Determines engine to use by extension
-    # of path given.
-    #
-    # @param file [String] path to file to build
-    # @return [String] the output css
-    #
-    def build_sass(file)
-      content = File.new(file).read
-      # sass or scss?
-      type = file[-4..-1].to_sym
-      sass_options = {
-        :syntax => type,
-        :load_paths => options[:load_paths],
-        :style => options[:style].to_sym,
-        :debug_info => options[:debug_info],
-      }
       
-      ::Sass::Engine.new(content, sass_options).render
-    end
-
-    # Get the file path to output the css based on the file being
-    # built.
-    #
-    # @param file [String] path to file being built
-    # @return [String] path to file where output should be written
-    #
-    def get_output(file)
-      folder = File.join ::Guard.listener.directory, options[:output]
-
-      unless options[:shallow]
-        watchers.product([file]).each do |watcher, file|
-          if matches = file.match(watcher.pattern)
-            if matches[1]
-              folder = File.join(options[:output], File.dirname(matches[1])).gsub(/\/\.$/, '')
-              break
-            end
-          end
-        end
-      end
-
-      FileUtils.mkdir_p folder
-      r = File.join folder, File.basename(file).split('.')[0]
-      r << '.css'
-    end
-
-    def ignored?(path)
-      File.basename(path)[0,1] == "_"
+      options = DEFAULTS.merge(options)
+      @runner = Runner.new(watchers, options)
+      super(watchers, options)
     end
 
     # ================
@@ -82,46 +55,35 @@ module Guard
     # ================
 
     # Build all files being watched
+    #
+    # @return [Boolean] No errors?
     def run_all
-      run_on_change(Watcher.match_files(self, Dir.glob(File.join('**', '[^_]*.*'))))
+      run_on_change(Watcher.match_files(self, Dir.glob(File.join('**', '*.*'))))
     end
     
-    # Build the files given
-    def run_on_change(paths)
-      partials = paths.select { |f| ignored?(f) }
+    # 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.
+    # 
+    # @param paths [Array<String>]
+    # @return [Boolean] No errors?
+    def run_on_change(paths)   
+      partials = paths.select {|f| File.basename(f)[0,1] == "_" }
       return run_all unless partials.empty?
-
-      changed_files = paths.reject{ |f| ignored?(f) }.map do |file|
-        css_file = get_output(file)
-        begin
-          contents = build_sass(file)
-          if contents
-            message = options[:noop] ? "verified #{file}" : "compiled #{file} to #{css_file}"
-            
-            File.open(css_file, 'w') {|f| f.write(contents) } unless options[:noop]
-            ::Guard::UI.info "-> #{message}", :reset => true
-            if options[:notification] && !options[:hide_success]
-              ::Guard::Notifier.notify(message, :title => "Guard::Sass", :image => :success)
-            end
-          end
-          css_file
-        rescue ::Sass::SyntaxError => e
-          ::Guard::UI.error "Sass > #{e.sass_backtrace_str(file)}"
-          ::Guard::Notifier.notify(
-            (options[:noop] ? 'validation' : 'rebuild') + " failed > #{e.sass_backtrace_str(file)}",
-             :title => "Guard::Sass",
-             :image => :error
-           ) if options[:notification]
-          nil
-        end
-      end.compact
+      
+      changed_files, success = @runner.run(paths)
+      
       notify changed_files
+      success
     end
-
+    
+    # Notify other guards about files that have been changed so that other guards can
+    # work on the changed files.
+    #
+    # @param changed_files [Array<String>]
     def notify(changed_files)
-      ::Guard.guards.reject{ |guard| guard == self }.each do |guard|
+      ::Guard.guards.each do |guard|
         paths = Watcher.match_files(guard, changed_files)
-        guard.run_on_change paths unless paths.empty?
+        guard.run_on_change(paths) unless paths.empty?
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: guard-sass
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-09-26 00:00:00.000000000Z
+date: 2011-10-01 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &2160420520 !ruby/object:Gem::Requirement
+  requirement: &2156617400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 0.4.0
   type: :runtime
   prerelease: false
-  version_requirements: *2160420520
+  version_requirements: *2156617400
 - !ruby/object:Gem::Dependency
   name: sass
-  requirement: &2160419700 !ruby/object:Gem::Requirement
+  requirement: &2156616940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '3.1'
   type: :runtime
   prerelease: false
-  version_requirements: *2160419700
+  version_requirements: *2156616940
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2160418160 !ruby/object:Gem::Requirement
+  requirement: &2156616480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.0.2
   type: :development
   prerelease: false
-  version_requirements: *2160418160
+  version_requirements: *2156616480
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2160417240 !ruby/object:Gem::Requirement
+  requirement: &2156616020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>'
@@ -54,7 +54,7 @@ dependencies:
         version: 2.0.0.rc
   type: :development
   prerelease: false
-  version_requirements: *2160417240
+  version_requirements: *2156616020
 description: Guard::Sass automatically rebuilds sass (like sass --watch)
 email:
 - m@hawx.me
@@ -62,6 +62,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/guard/sass/formatter.rb
+- lib/guard/sass/runner.rb
 - lib/guard/sass/templates/Guardfile
 - lib/guard/sass/version.rb
 - lib/guard/sass.rb