guard-jasmine 0.6.2 → 0.7.0

data/README.md

@@ -154,10 +154,34 @@ be shown in the console:
     :specdoc => :always                           # Specdoc output options, either :always, :never or :failure
                                                   # default: :failure
 
+    :focus => false                               # Specdoc focus to hide successful specs when at least one spec fails.
+                                                  # default: true
+
+    :console => :always                           # Console.log 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.
 
+When `:focus` is enabled, only the failing specs are shown in the specdoc when at least one spec is failing.
+
+The `:console` options adds captured console logs from the spec runner and adds them to the specdoc. Please note
+that PhantomJS only support capturing of `console.log`, so the other log functions like `debug`, `warn`, `info` and
+`error` are missing. Please vote on [Issue 232](http://code.google.com/p/phantomjs/issues/detail?id=232) if you like
+to see support for more console methods coming to PhantomJS.
+
+Another restriction on console logging is that currently only the first log parameter is passed. So instead of writing
+
+    console.log('Debug of %o with %s', object, string)
+
+your should write
+
+    console.log('Debug of ' + object.toString() + ' width ' + string)
+
+You can also give your vote on [Issue 36](http://code.google.com/p/phantomjs/issues/detail?id=36) to see support for
+multiple console arguments.
+
 ### System notifications options
 
 These options affects what system notifications (growl, libnotify or notifu) are shown after a spec run:

data/bin/guard-jasmine

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-url = ARGV[1] || 'http://127.0.0.1:3000/jasmine'
+url = ARGV[0] || '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 }"

data/lib/guard/jasmine.rb

@@ -2,6 +2,7 @@ require 'guard'
 require 'guard/guard'
 require 'guard/watcher'
 require 'net/http'
+require 'version'
 
 module Guard
 
@@ -25,7 +26,9 @@ module Guard
         :keep_failed      => true,
         :all_after_pass   => true,
         :max_error_notify => 3,
-        :specdoc          => :failure
+        :specdoc          => :failure,
+        :console          => :failure,
+        :focus            => true
     }
 
     # Initialize Guard::Jasmine.
@@ -41,6 +44,8 @@ module Guard
     # @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
+    # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
+    # @option options [Symbol] :focus options for focus on failures in the specdoc
     #
     def initialize(watchers = [], options = { })
       options = DEFAULT_OPTIONS.merge(options)
@@ -57,8 +62,12 @@ module Guard
     # @raise [:task_has_failed] when run_on_change has failed
     #
     def start
-      if jasmine_runner_available?(options[:jasmine_url])
-        run_all if options[:all_on_start]
+      if phantomjs_bin_valid?(options[:phantomjs_bin])
+        if jasmine_runner_available?(options[:jasmine_url])
+          run_all if options[:all_on_start]
+        end
+      else
+        throw :task_has_failed
       end
     end
 
@@ -126,30 +135,49 @@ module Guard
           if response.code.to_i == 200
             Formatter.info("Jasmine test runner is available at #{ url }")
           else
-            notify_jasmine_runner_failure(url) if options[:notification]
+            notify_failure("Jasmine test runner isn't available", "Jasmine test runner isn't available at #{ url }")
           end
 
           response.code.to_i == 200
         end
 
       rescue Errno::ECONNREFUSED => e
-        notify_jasmine_runner_failure(url)
+        notify_failure("Jasmine test runner isn't available", "Jasmine test runner isn't available at #{ url }")
 
         false
       end
     end
 
-    # Notify that the Jasmine runner is not available.
+    # Verifies that the phantomjs bin is available and the
+    # right version is installed.
+    #
+    # @param [String] bin the location of the phantomjs bin
+    # @return [Boolean] when the runner is available
+    #
+    def phantomjs_bin_valid?(bin)
+      version = `#{ bin } --version`
+
+      if !version
+        notify_failure('PhantomJS binary missing', "PhantomJS binary doesn't exist at #{ bin }")
+      elsif version.to_version < '1.3.0'.to_version
+        notify_failure('Wrong PhantomJS version', "PhantomJS binary at #{ bin } must be at least version 1.3.0")
+      else
+        true
+      end
+    end
+
+    # Notify a failure.
     #
-    # @param [String] url the url of the Jasmine runner
+    # @param title [String] the failure title
+    # @param message [String] the failure message
     #
-    def notify_jasmine_runner_failure(url)
-      message = "Jasmine test runner not available at #{ url }"
+    def notify_failure(title, message)
       Formatter.error(message)
       Formatter.notify(message,
-                       :title    => 'Jasmine test runner not available',
+                       :title    => title,
                        :image    => :failed,
-                       :priority => 2)
+                       :priority => 2) if options[:notification]
+      false
     end
 
   end

data/lib/guard/jasmine/phantomjs/run-jasmine.coffee

@@ -1,13 +1,5 @@
-# This file is the script that runs within PhantomJS and requests the Jasmine specs,
-# waits until they are ready, extracts the result form the dom and outputs a JSON
-# structure that is the parsed by Guard::Jasmine.
-#
-# This scripts needs the TrivialReporter to report the results.
-#
-# This file is inspired by the Jasmine runner that comes with the PhantomJS examples:
-# https://github.com/ariya/phantomjs/blob/master/examples/run-jasmine.coffee, by https://github.com/Roejames12
-#
-# This file is licensed under the BSD license.
+# This file is the script that runs within PhantomJS, requests the Jasmine specs
+# and waits until they are ready.
 
 # Wait until the test condition is true or a timeout occurs.
 #
@@ -15,11 +7,11 @@
 # @param [Function] ready the action when the condition is fulfilled
 # @param [Number] timeout the max amount of time to wait
 #
-waitFor = (condition, ready, timeout = 3000) ->
+waitFor = (condition, ready, timeout = 5000) ->
   start = new Date().getTime()
   wait = ->
     if new Date().getTime() - start > timeout
-      console.log JSON.stringify({ error: "Timeout requesting Jasmine test runner!" })
+      console.log JSON.stringify({ error: 'Timeout requesting Jasmine test runner!' })
       phantom.exit(1)
     else
       if condition()
@@ -33,71 +25,201 @@ waitFor = (condition, ready, timeout = 3000) ->
 specsReady = ->
   page.evaluate -> if document.body.querySelector('.finished-at') then true else false
 
-# Extract the data from a Jasmine TrivialReporter generated DOM
+# Check arguments of the script.
+#
+if phantom.args.length isnt 1
+  console.log JSON.stringify({ error: 'Wrong usage of PhantomJS script!' })
+  phantom.exit()
+else
+  url = phantom.args[0]
+
+# Create the web page.
+#
+page = require('webpage').create()
+
+# Used to collect log messages for later assignment to the spec
+#
+currentSpecId = 0
+logs = {}
+
+# Add logs to the given suite
 #
-extractResult = ->
+# @param suite [Object} the suite result
+#
+page.addLogs = (suite) ->
+  for s in suite.suites
+    arguments.callee(s) if s
+
+  for spec in suite.specs
+    id = Number(spec['id'])
+    spec['logs'] = logs[id] if logs[id] && logs[id].length isnt 0
+    delete spec['id']
+
+  delete suite['id']
+  delete suite['parent']
+
+# Capture console.log output to add it to
+# the result when specs have finished.
+#
+page.onConsoleMessage = (msg, line, source) ->
+  if /^RUNNER_RESULT: ([\s\S]*)$/.test(msg)
+    result = JSON.parse(RegExp.$1)
+
+    for suite in result.suites
+      page.addLogs(suite)
+
+    console.log JSON.stringify(result, undefined, 2)
+
+  else if /^SPEC_START: (\d+)$/.test(msg)
+    currentSpecId = Number(RegExp.$1)
+    logs[currentSpecId] = []
+
+  else
+    logs[currentSpecId].push "#{ msg } in #{ source } (line #{ line })"
+
+# Initialize the page before the JavaScript is run.
+#
+page.onInitialized = ->
   page.evaluate ->
-    stats = /(\d+) specs?, (\d+) failures? in (\d+.\d+)s/.exec(document.body.querySelector('.description').innerText)
-    specs = parseInt stats[1]
-    failures = parseInt stats[2]
-    time = parseFloat stats[3]
-    passed = failures is 0
-
-    result = {
-      passed: passed
-      stats: {
-        specs: specs
-        failures: failures
-        time: time
-      }
-      suites: []
-    }
-
-    for suite in document.body.querySelectorAll('div.jasmine_reporter > div.suite')
-      description = suite.querySelector('a.description')
-      suite_ = {
-        description: description.innerText
-        specs: []
+
+    # Jasmine Reporter that logs reporter steps
+    # and results to the console.
+    #
+    class ConsoleReporter
+
+      runnerResult: {
+        passed: false
+        stats: {
+          specs: 0
+          failures: 0
+          time: 0.0
+        }
+        suites: []
       }
 
-      for spec in suite.querySelectorAll('div.spec')
-        status = spec.getAttribute('class').substring(5)
-        if status isnt 'skipped'
-          passed = status is 'passed'
-          spec_ = {
-            description: spec.querySelector('a.description').getAttribute 'title'
-            passed: passed
+      currentSpecs: []
+      nestedSuiteResults: {}
+
+      # Report the start of a spec.
+      #
+      # @param spec [jasmine.Spec] the spec
+      #
+      reportSpecStarting: (spec) ->
+        console.log "SPEC_START: #{ spec.id }"
+
+      # Report results from a spec.
+      #
+      # @param spec [jasmine.Spec] the spec
+      #
+      reportSpecResults: (spec) ->
+        unless spec.results().skipped
+          specResult = {
+            id: spec.id
+            description: spec.description
+            passed: spec.results().failedCount is 0
           }
-          spec_['error_message'] = spec.querySelector('div.resultMessage').innerText if not passed
-          suite_['specs'].push spec_
 
-      result['suites'].push suite_
+          if spec.results().failedCount isnt 0
+            messages = []
+            messages.push result.message for result in spec.results().getItems()
+            specResult['messages'] = messages if messages.length isnt 0
 
-    console.log "JSON_RESULT: #{ JSON.stringify(result, undefined, 2) }"
+          @currentSpecs.push specResult
 
-  phantom.exit()
+      # Report results from a suite.
+      #
+      # @param suite [jasmine.Suite] the suite
+      #
+      reportSuiteResults: (suite) ->
+        unless suite.results().skipped
+          suiteResult = {
+            id: suite.id
+            parent: suite.parentSuite?.id
+            description: suite.description
+            passed: suite.results().failedCount is 0
+            specs: @currentSpecs
+            suites: []
+          }
 
-# Check arguments of the script.
-#
-if phantom.args.length isnt 1
-  console.log JSON.stringify({ error: "Wrong usage of PhantomJS script!" })
-  phantom.exit()
-else
-  url = phantom.args[0]
+          if suite.parentSuite?
+            parent = suite.parentSuite.id
+            @nestedSuiteResults[parent] = [] unless @nestedSuiteResults[parent]
+            @nestedSuiteResults[parent].push suiteResult
+          else
+            @addNestedSuites suiteResult
+            @removeEmptySuites suiteResult
 
-page = new WebPage()
+            if suiteResult.specs.length isnt 0 || suiteResult.suites.length isnt 0
+              @runnerResult.suites.push suiteResult
 
-# Output the Jasmine test runner result as JSON object.
-# Ignore all other calls to console.log that may come from the specs.
-#
-page.onConsoleMessage = (msg) ->
-  console.log(RegExp.$1) if /^JSON_RESULT: ([\s\S]*)$/.test(msg)
+        @currentSpecs = []
+
+      # Report results from the runner.
+      #
+      # @param runner [jasmine.Runner] the runner
+      #
+      reportRunnerResults: (runner) ->
+        runtime = (new Date().getTime() - @startTime) / 1000
+
+        @runnerResult['passed'] = runner.results().failedCount is 0
+
+        @runnerResult['stats'] = {
+          specs: runner.results().totalCount
+          failures: runner.results().failedCount
+          time: runtime
+        }
+
+        console.log "RUNNER_RESULT: #{ JSON.stringify(@runnerResult) }"
+
+      # Report the start of the runner
+      #
+      # @param runner [jasmine.Runner] the runner
+      #
+      reportRunnerStarting: (runner) ->
+        @startTime = new Date().getTime()
+
+      # Add all nested suites that have previously
+      # been processed.
+      #
+      # @param suiteResult [Object] the suite result
+      #
+      addNestedSuites: (suiteResult) ->
+        if @nestedSuiteResults[suiteResult.id]
+          for suite in @nestedSuiteResults[suiteResult.id]
+            @addNestedSuites suite
+            suiteResult.suites.push suite
+
+      # Removes suites without child suites or specs.
+      #
+      # @param suiteResult [Object] the suite result
+      #
+      removeEmptySuites: (suiteResult) ->
+        suites = []
+
+        for suite in suiteResult.suites
+          @removeEmptySuites suite
+
+          suites.push suite if suite.suites.length isnt 0 || suite.specs.length isnt 0
+
+        suiteResult.suites = suites
+
+      # Log a message
+      #
+      # @param message [String] the log message
+      #
+      log: (message) ->
+
+    # Attach the console reporter when the document is ready.
+    #
+    window.onload = ->
+      jasmine.getEnv().addReporter(new ConsoleReporter())
 
 # Open web page and run the Jasmine test runner
 #
 page.open url, (status) ->
   if status isnt 'success'
-    console.log "JSON_RESULT: #{ JSON.stringify({ error: "Unable to access Jasmine specs at #{ url }" }) }"
+    console.log JSON.stringify({ error: "Unable to access Jasmine specs at #{ url }" })
     phantom.exit()
   else
-    waitFor specsReady, extractResult
+    waitFor specsReady, -> phantom.exit()
+

data/lib/guard/jasmine/runner.rb

@@ -22,6 +22,7 @@ module Guard
         # @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
+        # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
         # @return [Boolean, Array<String>] the status of the run and the failed files
         #
         def run(paths, options = { })
@@ -144,25 +145,26 @@ module Guard
         #
         def evaluate_response(output, file, options)
           json = output.read
+          result = {}
 
           begin
             result = MultiJson.decode(json)
-            output.close
-
-            if result['error']
-              notify_runtime_error(result, options)
-            else
-              result['file'] = file
-              notify_spec_result(result, options)
-            end
-
-            result
-
           rescue Exception => e
             Formatter.error("Cannot decode JSON from PhantomJS runner: #{ e.message }")
             Formatter.error('Please report an issue at: https://github.com/netzpirat/guard-jasmine/issues')
             Formatter.error(json)
+          ensure
+            output.close
           end
+
+          if result['error']
+            notify_runtime_error(result, options)
+          else
+            result['file'] = file
+            notify_spec_result(result, options)
+          end
+
+          result
         end
 
         # Notification when a system error happens that
@@ -193,58 +195,129 @@ module Guard
           plural   = failures == 1 ? '' : 's'
 
           message = "#{ specs } specs, #{ failures } failure#{ plural }\nin #{ time } seconds"
+          passed  = failures == 0
 
-          if failures != 0
-            show_specdoc(result) if options[:specdoc] != :never
+          if passed
+            report_specdoc(result, passed, options) if options[:specdoc] == :always
+            Formatter.success(message)
+            Formatter.notify(message, :title => 'Jasmine suite passed') if options[:notification] && !options[:hide_success]
+          else
+            report_specdoc(result, passed, options) 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
         end
 
         # Specdoc like formatting of the result.
         #
         # @param [Hash] result the suite result
+        # @param [Boolean] passed status
+        # @param [Hash] options the options
+        # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
         #
-        def show_specdoc(result)
+        def report_specdoc(result, passed, options)
           result['suites'].each do |suite|
-            Formatter.suite_name("➥ #{ suite['description'] }")
-
-            suite['specs'].each do |spec|
-              if spec['passed']
-                Formatter.success(" ✔ #{ spec['description'] }")
-              else
-                Formatter.spec_failed(" ✘ #{ spec['description'] }")
-                Formatter.spec_failed("   ➤ #{ format_error_message(spec['error_message'], false) }")
+            report_specdoc_suite(suite, passed, options)
+          end
+        end
+
+        # Show the suite result.
+        #
+        # @param [Hash] suite the suite
+        # @param [Boolean] passed status
+        # @param [Hash] options the options
+        # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
+        # @option options [Symbol] :focus options for focus on failures in the specdoc
+        # @param [Number] level the indention level
+        #
+        def report_specdoc_suite(suite, passed, options, level = 0)
+          Formatter.suite_name((' ' * level) + suite['description']) if passed || options[:focus] && contains_failed_spec?(suite)
+
+          suite['specs'].each do |spec|
+            if spec['passed']
+              if passed || !options[:focus]
+                Formatter.success(indent("  ✔ #{ spec['description'] }", level))
+                report_specdoc_logs(spec, options, level)
+              end
+            else
+              Formatter.spec_failed(indent("  ✘ #{ spec['description'] }", level))
+              spec['messages'].each do |message|
+                Formatter.spec_failed(indent("    ➤ #{ format_message(message, false) }", level))
               end
+              report_specdoc_logs(spec, options, level)
             end
           end
+
+          suite['suites'].each { |suite| report_specdoc_suite(suite, passed, options, level + 2) } if suite['suites']
         end
 
-        # Specdoc like formatting of the result.
+        # Shows the logs for a given spec.
+        #
+        # @param [Hash] spec the spec result
+        # @param [Hash] options the options
+        # @option options [Symbol] :console options for the console.log output, either :always, :never or :failure
+        # @param [Number] level the indention level
+        #
+        def report_specdoc_logs(spec, options, level)
+          if spec['logs'] && (options[:console] == :always || (options[:console] == :failure && !spec['passed']))
+            spec['logs'].each do |log|
+              Formatter.info(indent("    • #{ format_message(log, true) }", level))
+            end
+          end
+        end
+
+        # Indent a message.
+        #
+        # @param [String] message the message
+        # @param [Number] level the indention level
+        #
+        def indent(message, level)
+          (' ' * level) + message
+        end
+
+        # Show system notifications about the occurred errors.
         #
         # @param [Hash] result the suite result
+        # @param [Hash] options the options
         # @option options [Integer] :max_error_notify maximum error notifications to show
-        # @option options [Boolean] :hide_success hide success message notification
+        # @option options [Boolean] :notification show notifications
         #
         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
+          collect_specs(result['suites']).each_with_index do |spec, index|
+            if !spec['passed'] && options[:max_error_notify] > index
+              msg = spec['messages'].map { |message| format_message(message, true) }.join(', ')
+              Formatter.notify("#{ spec['description'] }: #{ msg }",
+                               :title    => 'Jasmine spec failed',
+                               :image    => :failed,
+                               :priority => 2) if options[:notification]
             end
           end
         end
 
-        # Formats the error message.
+        # Tests if the given suite has a failing spec underneath.
+        #
+        # @param [Hash] suite the suite result
+        # @return [Boolean] the search result
+        #
+        def contains_failed_spec?(suite)
+          collect_specs([suite]).any? { |spec| !spec['passed'] }
+        end
+
+        # Get all specs from the suites and its nested suites.
+        #
+        # @param suites [Array<Hash>] the suites results
+        # @param [Array<Hash>] all specs
+        #
+        def collect_specs(suites)
+          suites.inject([]) do |specs, suite|
+            specs = (specs | suite['specs']) if suite['specs']
+            specs = (specs | collect_specs(suite['suites'])) if suite['suites']
+            specs
+          end
+        end
+
+        # Formats a message.
         #
         # Known message styles:
         #
@@ -254,7 +327,7 @@ module Guard
         # @param [Boolean] short show a short version of the message
         # @return [String] the cleaned error message
         #
-        def format_error_message(message, short)
+        def format_message(message, short)
           if message =~ /(.*?) in http.+?assets\/(.*)\?body=\d+\s\((line\s\d+)/
             short ? $1 : "#{ $1 } in #{ $2 } on #{ $3 }"
           else

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.6.2'
+    VERSION = '0.7.0'
   end
 end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: 
   segments: 
   - 0
-  - 6
-  - 2
-  version: 0.6.2
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Michael Kessler
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-01 00:00:00 Z
+date: 2011-10-10 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: guard
@@ -50,9 +50,25 @@ dependencies:
   type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: bundler
+  name: version
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -63,11 +79,11 @@ dependencies:
         - 0
         version: "1.0"
   type: :development
-  version_requirements: *id003
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: guard-rspec
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -78,11 +94,11 @@ dependencies:
         - 4
         version: "0.4"
   type: :development
-  version_requirements: *id004
+  version_requirements: *id005
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -93,11 +109,11 @@ dependencies:
         - 6
         version: "2.6"
   type: :development
-  version_requirements: *id005
+  version_requirements: *id006
 - !ruby/object:Gem::Dependency 
   name: yard
   prerelease: false
-  requirement: &id006 !ruby/object:Gem::Requirement 
+  requirement: &id007 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -109,11 +125,11 @@ dependencies:
         - 2
         version: 0.7.2
   type: :development
-  version_requirements: *id006
+  version_requirements: *id007
 - !ruby/object:Gem::Dependency 
   name: kramdown
   prerelease: false
-  requirement: &id007 !ruby/object:Gem::Requirement 
+  requirement: &id008 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -125,7 +141,24 @@ dependencies:
         - 3
         version: 0.13.3
   type: :development
-  version_requirements: *id007
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: pry
+  prerelease: false
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 9
+        - 6
+        - 2
+        version: 0.9.6.2
+  type: :development
+  version_requirements: *id009
 description: Guard::Jasmine automatically tests your Jasmine specs on PhantomJS
 email: 
 - michi@netzpiraten.ch
@@ -149,8 +182,7 @@ files:
 - lib/guard/jasmine/version.rbc
 - lib/guard/jasmine.rb
 - lib/guard/jasmine.rbc
-- LICENSE.MIT
-- LICENSE.BSD
+- LICENSE
 - README.md
 homepage: http://github.com/netzpirat/guard-jasmine
 licenses: []

data/LICENSE.BSD

@@ -1,22 +0,0 @@
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-  * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-  * Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-  * Neither the name of the <organization> nor the
-    names of its contributors may be used to endorse or promote products
-    derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.