guard-jasmine 0.4.0 → 0.5.0

data/README.md

@@ -112,8 +112,11 @@ Guard::Jasmine can be adapted to all kind of projects. Please read the
 
 ## Options
 
-There following options can be passed to Guard::Jasmine:
+There are many options that can customize Guard::Jasmine to your needs.
 
+### General options
+
+The general options configures the environment that is needed to run Guard::Jasmine:
 
     :jasmine_url => 'http://192.168.1.5/jasmine'  # URL where Jasmine is served.
                                                   # default: http://127.0.0.1/jasmine
@@ -121,6 +124,10 @@ There following options can be passed to Guard::Jasmine:
     :phantomjs_bin => '~/bin/phantomjs'           # Path to phantomjs.
                                                   # default: '/usr/local/bin/phantomjs'
 
+### Spec runner options
+
+The spec runner options configures the behavior driven development (or BDD) cycle:
+
     :all_on_start => false                        # Run all suites on start.
                                                   # default: true
 
@@ -130,20 +137,36 @@ There following options can be passed to Guard::Jasmine:
     :all_after_pass => false                      # Run all suites after a suite has passed again after failing.
                                                   # default: true
 
-    :notifications => false                       # Show success and error messages.
+The `:keep_failed` failed option remembers failed suites and not failed specs. The reason for this decision is to
+avoid additional round trip time to request the Jasmine test runner for each single spec, which is mostly more expensive
+than running a whole suite.
+
+### Specdoc options
+
+Guard::Jasmine can generate an RSpec like specdoc in the console after running the specs and you can set when it will
+be shown in the console:
+
+    :specdoc => :always                           # Specdoc output options, either :always, :never or :failure
+                                                  # default: :failure
+
+With the option set to :always, the specdoc is shown with and without errors in your spec, whereas on with the option
+set to :never, there is no output at all, instead just a summary of the spec run is shown. The default option :failure
+shows the specdoc when at least one spec failed.
+
+### System notifications options
+
+These options affects what system notifications (growl, libnotify or notifu) are shown after a spec run:
+
+    :notifications => false                       # Show success and error notifications.
                                                   # default: true
 
-    :hide_success => true                         # Disable successful compilation messages.
+    :hide_success => true                         # Disable successful spec run notification.
                                                   # default: false
 
     :max_error_notify => 5                        # Maximum error notifications to show.
                                                   # default: 3
 
-The `:keep_failed` failed option remembers failed suites and not failed specs. The reason for this decision is to
-avoid to much round trip time to request the Jasmine test runner for each single spec, which is mostly more expensive
-than running a whole suite.
-
-### A note on Rails 2 and 3
+## A note on Rails 2 and 3
 
 This readme describes the use of Guard::Jasmine with Jasminerice through the asset pipeline, but it is not really
 a requirement for Guard::Jasmine. As long as you serve the Jasmine test runner under a certain url,

data/bin/guard-jasmine

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+url = ARGV[1] || 'http://127.0.0.1:3000/jasmine'
+script = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'guard', 'jasmine', 'phantomjs', 'run-jasmine.coffee'))
+
+puts "Run Jasmine at #{ url }"
+puts `phantomjs #{ script } #{ url }`

data/lib/guard/jasmine.rb

@@ -16,6 +16,18 @@ module Guard
 
     attr_accessor :last_run_failed, :last_failed_paths
 
+    DEFAULT_OPTIONS = {
+        :jasmine_url      => 'http://localhost:3000/jasmine',
+        :phantomjs_bin    => '/usr/local/bin/phantomjs',
+        :notification     => true,
+        :hide_success     => false,
+        :all_on_start     => true,
+        :keep_failed      => true,
+        :all_after_pass   => true,
+        :max_error_notify => 3,
+        :specdoc          => :failure
+    }
+
     # Initialize Guard::Jasmine.
     #
     # @param [Array<Guard::Watcher>] watchers the watchers in the Guard block
@@ -28,20 +40,13 @@ module Guard
     # @option options [Boolean] :all_on_start run all suites on start
     # @option options [Boolean] :keep_failed keep failed suites and add them to the next run again
     # @option options [Boolean] :all_after_pass run all suites after a suite has passed again after failing
+    # @option options [Symbol] :specdoc options for the specdoc output, either :always, :never or :failure
     #
     def initialize(watchers = [], options = { })
-      defaults = {
-          :jasmine_url      => 'http://localhost:3000/jasmine',
-          :phantomjs_bin    => '/usr/local/bin/phantomjs',
-          :notification     => true,
-          :hide_success     => false,
-          :all_on_start     => true,
-          :keep_failed      => true,
-          :all_after_pass   => true,
-          :max_error_notify => 3
-      }
-
-      super(watchers, defaults.merge(options))
+      options = DEFAULT_OPTIONS.merge(options)
+      options[:specdoc] = :failure if ![:always, :never, :failure].include? options[:specdoc]
+
+      super(watchers, options)
 
       self.last_run_failed   = false
       self.last_failed_paths = []
@@ -89,9 +94,12 @@ module Guard
     # @return [Boolean] when running the changed specs was successful
     #
     def run_on_change(paths)
+      return false if Inspector.clean(paths).empty?
+
       paths += self.last_failed_paths if options[:keep_failed]
 
       passed, failed_specs = Runner.run(Inspector.clean(paths), options)
+      Inspector.clear
 
       if passed
         self.last_failed_paths = self.last_failed_paths - paths

data/lib/guard/jasmine/inspector.rb

@@ -16,11 +16,22 @@ module Guard
         def clean(paths)
           paths.uniq!
           paths.compact!
-          paths = paths.select { |p| jasmine_spec?(p) }
-          clear_jasmine_specs
+
+          if paths.include?('spec/javascripts')
+            paths = ['spec/javascripts']
+          else
+            paths = paths.select { |p| jasmine_spec?(p) }
+          end
+
           paths
         end
 
+        # Clears the list of Jasmine specs in this project.
+        #
+        def clear
+          @jasmine_specs = nil
+        end
+
         private
 
         # Tests if the file is valid.
@@ -43,12 +54,6 @@ module Guard
           @jasmine_specs ||= Dir.glob('spec/**/*_spec.{js,js.coffee}')
         end
 
-        # Clears the list of Jasmine specs in this project.
-        #
-        def clear_jasmine_specs
-          @jasmine_specs = nil
-        end
-
       end
     end
   end

data/lib/guard/jasmine/runner.rb

@@ -21,6 +21,7 @@ module Guard
         # @option options [Boolean] :notification show notifications
         # @option options [Boolean] :hide_success hide success message notification
         # @option options [Integer] :max_error_notify maximum error notifications to show
+        # @option options [Symbol] :specdoc options for the specdoc output, either :always, :never
         # @return [Boolean, Array<String>] the status of the run and the failed files
         #
         def run(paths, options = { })
@@ -194,9 +195,12 @@ module Guard
           message = "#{ specs } specs, #{ failures } failure#{ plural }\nin #{ time } seconds"
 
           if failures != 0
-            notify_specdoc(result, message, options)
+            show_specdoc(result) if options[:specdoc] != :never
+            Formatter.error(message)
+            notify_errors(result, options)
             Formatter.notify(message, :title => 'Jasmine suite failed', :image => :failed, :priority => 2) if options[:notification]
           else
+            show_specdoc(result) if options[:specdoc] == :always
             Formatter.success(message)
             Formatter.notify(message, :title => 'Jasmine suite passed') if options[:notification] && !options[:hide_success]
           end
@@ -205,31 +209,39 @@ module Guard
         # Specdoc like formatting of the result.
         #
         # @param [Hash] result the suite result
-        # @param [String] stats the status information
-        # @option options [Integer] :max_error_notify maximum error notifications to show
-        # @option options [Boolean] :hide_success hide success message notification
         #
-        def notify_specdoc(result, stats, options)
+        def show_specdoc(result)
           result['suites'].each do |suite|
             Formatter.suite_name("➥ #{ suite['description'] }")
 
             suite['specs'].each_with_index do |spec, index|
               if spec['passed']
-                Formatter.success(" ✔ #{ spec['description'] }") if !options[:hide_success]
+                Formatter.success(" ✔ #{ spec['description'] }")
               else
                 Formatter.spec_failed(" ✘ #{ spec['description'] }")
                 Formatter.spec_failed("   ➤ #{ format_error_message(spec['error_message'], false) }")
-                if options[:max_error_notify] > index
-                  Formatter.notify("#{ spec['description'] }: #{ format_error_message(spec['error_message'], true) }",
-                                   :title    => 'Jasmine spec failed',
-                                   :image    => :failed,
-                                   :priority => 2) if options[:notification]
-                end
               end
             end
           end
+        end
 
-          Formatter.info(stats)
+        # Specdoc like formatting of the result.
+        #
+        # @param [Hash] result the suite result
+        # @option options [Integer] :max_error_notify maximum error notifications to show
+        # @option options [Boolean] :hide_success hide success message notification
+        #
+        def notify_errors(result, options)
+          result['suites'].each do |suite|
+            suite['specs'].each_with_index do |spec, index|
+              if !spec['passed'] && options[:max_error_notify] > index
+                Formatter.notify("#{ spec['description'] }: #{ format_error_message(spec['error_message'], true) }",
+                                 :title    => 'Jasmine spec failed',
+                                 :image    => :failed,
+                                 :priority => 2) if options[:notification]
+              end
+            end
+          end
         end
 
         # Formats the error message.

data/lib/guard/jasmine/version.rb

@@ -1,6 +1,6 @@
 module Guard
   module JasmineVersion
     # Guard::Jasmine version that is used for the Gem specification
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: guard-jasmine
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 11
   prerelease: 
   segments: 
   - 0
-  - 4
+  - 5
   - 0
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors: 
 - Michael Kessler
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-12 00:00:00 Z
+date: 2011-09-14 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: guard
@@ -128,13 +128,14 @@ dependencies:
 description: Guard::Jasmine automatically tests your Jasmine specs on PhantomJS
 email: 
 - michi@netzpiraten.ch
-executables: []
-
+executables: 
+- guard-jasmine
 extensions: []
 
 extra_rdoc_files: []
 
 files: 
+- bin/guard-jasmine
 - lib/guard/jasmine/formatter.rb
 - lib/guard/jasmine/inspector.rb
 - lib/guard/jasmine/phantomjs/run-jasmine.coffee