guard-jasmine 1.7.0 → 1.8.0

data/README.md

@@ -344,6 +344,9 @@ The server options configures the server environment that is needed to run Guard
                                               # e.g. :development or :test
                                               # default: RAILS_ENV is exists, otherwise :development
 
+:server_timeout => 30                         # The number of seconds to wait for the Jasmine spec server
+                                              # default: 15
+
 :port => 9292                                 # Jasmine server port to use.
                                               # default: 8888
 
@@ -441,7 +444,7 @@ stack trace.
 
 ### Overwrite options when running all specs
 
-You may want to have different options when the spec runner runs all specs. You can specify the `:run_all` options
+You may want to have different options when the spec runner runs all specs. You can specify the `:run_all` option
 as a Hash that contains any valid runner option and will overwrite the general options.
 
 ```ruby
@@ -525,26 +528,33 @@ Usage:
   guard-jasmine spec
 
 Options:
-  -s, [--server=SERVER]          # Server to start, either `auto`, `none`, `webrick`, `mongrel`,
-                                 # `thin`, `jasmine_gem`
+  -s, [--server=SERVER]          # Server to start, either `auto`, `webrick`, `mongrel`, `thin`,
+                                 # `unicorn`, `jasmine_gem` or `none`
                                  # Default: auto
   -p, [--port=N]                 # Server port to use
-                                 # Default: 8888
-  -u, [--url=URL]                # The url of the Jasmine test runner
-                                 # Default: http://localhost:8888/jasmine
+                                 # Default: 3001
+  -e, [--server-env=SERVER_ENV]  # The server environment to use, for example `development`, `test` etc.
+                                 # Default: test
+      [--server-timeout=N]       # The number of seconds to wait for the Jasmine spec server
+                                 # Default: 15
   -b, [--bin=BIN]                # The location of the PhantomJS binary
-                                 # Default: /usr/local/bin/phantomjs
-  -t, [--timeout=N]              # The maximum time in milliseconds to wait
-                                 # for the spec runner to finish
+  -d, [--spec-dir=SPEC_DIR]      # The directory with the Jasmine specs
+                                 # Default: spec/javascripts
+  -u, [--url=URL]                # The url of the Jasmine test runner_options
+                                 # Default: http://localhost:3001/jasmine
+  -t, [--timeout=N]              # The maximum time in milliseconds to wait for the spec
+                                 # runner to finish
                                  # Default: 10000
-  -c, [--console=CONSOLE]        # Whether to show console.log statements in the spec runner,
+      [--console=CONSOLE]        # Whether to show console.log statements in the spec runner,
                                  # either `always`, `never` or `failure`
                                  # Default: failure
-  -x, [--errors=ERRORS]          # Whether to show errors in the spec runner,
+      [--errors=ERRORS]          # Whether to show errors in the spec runner,
                                  # either `always`, `never` or `failure`
                                  # Default: failure
-  -e, [--server-env=SERVER_ENV]  # The server environment to use, for example `development`, `test`
-                                 # Default: RAILS_ENV if exists, otherwise `test`
+      [--focus]                  # Specdoc focus to hide successful tests when at least one test fails
+                                 # Default: true
+      [--specdoc=SPECDOC]        # Whether to show successes in the spec runner, either `always`, `never` or `failure`
+                                 # Default: always
 
 Run the Jasmine spec runner
 ```
@@ -695,7 +705,7 @@ $ guard-jasmine-debug
 ```
 
 The only argument that the script takes is the URL to the Jasmine runner, which defaults to
-`http://127.0.0.1:3000/Jasmine`. So you can for example just run a subset of the specs by changing the URL:
+`http://127.0.0.1:3000/jasmine`. So you can for example just run a subset of the specs by changing the URL:
 
 ```bash
 $ guard-jasmine-debug http://127.0.0.1:3000/Jasmine?spec=YourSpec

data/lib/guard/jasmine.rb

@@ -23,6 +23,7 @@ module Guard
     DEFAULT_OPTIONS = {
         :server           => :auto,
         :server_env       => ENV['RAILS_ENV'] || 'development',
+        :server_timeout   => 15,
         :port             => 8888,
         :jasmine_url      => 'http://localhost:8888/jasmine',
         :timeout          => 10000,
@@ -46,6 +47,7 @@ module Guard
     # @param [Hash] options the options for the Guard
     # @option options [String] :server the server to use, either :auto, :none, :webrick, :mongrel, :thin, :jasmine_gem, or a custom rake task
     # @option options [String] :server_env the server environment to use, for example :development, :test
+    # @option options [Integer] :server_timeout the number of seconds to wait for the Jasmine spec server
     # @option options [String] :port the port for the Jasmine test server
     # @option options [String] :jasmine_url the url of the Jasmine test runner
     # @option options [String] :phantomjs_bin the location of the PhantomJS binary
@@ -88,7 +90,7 @@ module Guard
 
         Server.start(options[:server], options[:port], options[:server_env], options[:spec_dir]) unless options[:server] == :none
 
-        if Jasmine.runner_available?(options[:jasmine_url])
+        if Jasmine.runner_available?(options)
           run_all if options[:all_on_start]
         end
       else

data/lib/guard/jasmine/cli.rb

@@ -9,7 +9,7 @@ require 'guard/jasmine/util'
 module Guard
   class Jasmine
 
-    # Small helper class to run the Jasmine runner once from the
+    # Small helper class to run the Jasmine runner_options once from the
     # command line. This can be useful to integrate guard-jasmine
     # into a continuous integration server.
     #
@@ -20,13 +20,7 @@ module Guard
 
       default_task :spec
 
-      desc 'spec', 'Run the Jasmine spec runner'
-
-      method_option :focus,
-                    :type => :boolean,
-                    :aliases => '-f',
-                    :default => true,
-                    :desc    => 'Specdoc focus to hide successful tests when at least one test fails'
+      desc 'spec', 'Run the Jasmine spec runner_options'
 
       method_option :server,
                     :type => :string,
@@ -40,17 +34,34 @@ module Guard
                     :default => 3001,
                     :desc => 'Server port to use'
 
-      method_option :url,
+      method_option :server_env,
                     :type => :string,
-                    :aliases => '-u',
-                    :default => 'http://localhost:3001/jasmine',
-                    :desc => 'The url of the Jasmine test runner'
+                    :aliases => '-e',
+                    :default => ENV['RAILS_ENV'] || 'test',
+                    :desc => 'The server environment to use, for example `development`, `test` etc.'
+
+      method_option :server_timeout,
+                    :type => :numeric,
+                    :default => 15,
+                    :desc => 'The number of seconds to wait for the Jasmine spec server'
 
       method_option :bin,
                     :type => :string,
                     :aliases => '-b',
                     :desc => 'The location of the PhantomJS binary'
 
+      method_option :spec_dir,
+                    :type => :string,
+                    :aliases => '-d',
+                    :default => 'spec/javascripts',
+                    :desc => 'The directory with the Jasmine specs'
+
+      method_option :url,
+                    :type => :string,
+                    :aliases => '-u',
+                    :default => 'http://localhost:3001/jasmine',
+                    :desc => 'The url of the Jasmine test runner'
+
       method_option :timeout,
                     :type => :numeric,
                     :aliases => '-t',
@@ -59,33 +70,25 @@ module Guard
 
       method_option :console,
                     :type => :string,
-                    :aliases => '-c',
                     :default => 'failure',
                     :desc => 'Whether to show console.log statements in the spec runner, either `always`, `never` or `failure`'
 
       method_option :errors,
                     :type => :string,
-                    :aliases => '-x',
                     :default => 'failure',
                     :desc => 'Whether to show errors in the spec runner, either `always`, `never` or `failure`'
 
+      method_option :focus,
+                    :type => :boolean,
+                    :aliases => '-f',
+                    :default => true,
+                    :desc    => 'Specdoc focus to hide successful tests when at least one test fails'
+
       method_option :specdoc,
                     :type => :string,
                     :default => :always,
                     :desc => 'Whether to show successes in the spec runner, either `always`, `never` or `failure`'
 
-      method_option :server_env,
-                    :type => :string,
-                    :aliases => '-e',
-                    :default => ENV['RAILS_ENV'] || 'test',
-                    :desc => 'The server environment to use, for example `development`, `test` etc.'
-
-      method_option :spec_dir,
-                    :type => :string,
-                    :aliases => '-d',
-                    :default => 'spec/javascripts',
-                    :desc => 'The directory with the Jasmine specs'
-
       # Run the Guard::Jasmine::Runner with options from
       # the command line.
       #
@@ -94,34 +97,36 @@ module Guard
       def spec(*paths)
         paths = [options.spec_dir] if paths.empty?
 
-        runner = {}
-        runner[:jasmine_url] = options.url
-        runner[:phantomjs_bin] = options.bin || CLI.which('phantomjs')
-        runner[:timeout] = options.timeout
-        runner[:port] = options.port
-        runner[:server_env] = options.server_env
-        runner[:spec_dir] = options.spec_dir
-        runner[:console] = [:always, :never, :failure].include?(options.console.to_sym) ? options.console.to_sym : :failure
-        runner[:errors] = [:always, :never, :failure].include?(options.errors.to_sym) ? options.errors.to_sym : :failure
-        runner[:specdoc] = [:always, :never, :failure].include?(options.specdoc.to_sym) ? options.specdoc.to_sym : :always
-        runner[:server] = options.server.to_sym
-        runner[:focus] = options.focus
+        runner_options = {}
+        runner_options[:jasmine_url] = options.url
+        runner_options[:phantomjs_bin] = options.bin || CLI.which('phantomjs')
+        runner_options[:timeout] = options.timeout
+        runner_options[:port] = options.port
+        runner_options[:server_env] = options.server_env
+        runner_options[:server_timeout] = options.server_timeout
+        runner_options[:spec_dir] = options.spec_dir
+        runner_options[:console] = [:always, :never, :failure].include?(options.console.to_sym) ? options.console.to_sym : :failure
+        runner_options[:errors] = [:always, :never, :failure].include?(options.errors.to_sym) ? options.errors.to_sym : :failure
+        runner_options[:specdoc] = [:always, :never, :failure].include?(options.specdoc.to_sym) ? options.specdoc.to_sym : :always
+        runner_options[:server] = options.server.to_sym
+        runner_options[:focus] = options.focus
 
 
-        runner[:notification] = false
-        runner[:hide_success] = true
+        runner_options[:notification] = false
+        runner_options[:hide_success] = true
 
-        runner[:max_error_notify] = 0
+        runner_options[:max_error_notify] = 0
 
-        if CLI.phantomjs_bin_valid?(runner[:phantomjs_bin])
-          ::Guard::Jasmine::Server.start(runner[:server], runner[:port], runner[:server_env], runner[:spec_dir]) unless runner[:server] == :none
+        if CLI.phantomjs_bin_valid?(runner_options[:phantomjs_bin])
+          ::Guard::Jasmine::Server.start(runner_options[:server], runner_options[:port], runner_options[:server_env], runner_options[:spec_dir]) unless runner_options[:server] == :none
 
-          if CLI.runner_available?(runner[:jasmine_url])
-            result = ::Guard::Jasmine::Runner.run(paths, runner)
+          if CLI.runner_available?(runner_options)
+            result = ::Guard::Jasmine::Runner.run(paths, runner_options)
             ::Guard::Jasmine::Server.stop
 
             Process.exit result.first ? 0 : 1
           else
+            ::Guard::Jasmine::Server.stop
             Process.exit 2
           end
 

data/lib/guard/jasmine/templates/Guardfile

@@ -1,5 +1,5 @@
 guard 'jasmine' do
   watch(%r{spec/javascripts/spec\.(js\.coffee|js|coffee)$})         { "spec/javascripts" }
   watch(%r{spec/javascripts/.+_spec\.(js\.coffee|js|coffee)$})
-  watch(%r{app/assets/javascripts/(.+?)\.(js\.coffee|js|coffee)$})  { |m| "spec/javascripts/#{m[1]}_spec.#{m[2]}" }
+  watch(%r{app/assets/javascripts/(.+?)\.(js|coffee)})  { |m| "spec/javascripts/#{m[1]}_spec.#{m[2]}" }
 end

data/lib/guard/jasmine/util.rb

@@ -13,16 +13,18 @@ module Guard
       # If the runner is not available within 15 seconds, then
       # the availability check will cancel.
       #
-      # @param [String] url the location of the test runner
+      # @param [Hash] options the options for the Guard
+      # @option options [Integer] :server_timeout the number of seconds to wait for the Jasmine spec server
+      # @option options [String] :jasmine_url the url of the Jasmine test runner
       # @return [Boolean] when the runner is available
       #
-      def runner_available?(url)
-        url = URI.parse(url)
+      def runner_available?(options)
+        url = URI.parse(options[:jasmine_url])
 
         begin
           ::Guard::Jasmine::Formatter.info "Waiting for Jasmine test runner at #{ url }"
 
-          Timeout::timeout(15) do
+          Timeout::timeout(options[:server_timeout]) do
             Net::HTTP.start(url.host, url.port) do |http|
               response = http.request(Net::HTTP::Head.new(url.path))
               available = response.code.to_i == 200

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 = '1.7.0'
+    VERSION = '1.8.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: guard-jasmine
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-10 00:00:00.000000000 Z
+date: 2012-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
@@ -138,7 +138,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 4241117556701944522
+      hash: -1717723720735593618
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: