guard-jasmine-node 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+/.rvmrc

data/.travis.yml

@@ -0,0 +1 @@
+# travis-ci ftw

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in guard-jasmine-node.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,6 @@
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/guard-jasmine-node.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "guard/jasmine_node/version"
+
+Gem::Specification.new do |s|
+  s.name        = "guard-jasmine-node"
+  s.version     = Guard::JasmineNodeVersion::VERSION
+  s.authors     = ["dave@kapoq.com"]
+  s.email       = ["dave@kapoq.com"]
+  s.homepage    = "https://github.com/kapoq/guard-jasmine-node"
+  s.summary     = %q{Guard::JasmineNode automatically runs your Jasmine Node specs when files are modified}
+  s.description = %q{}
+
+  s.rubyforge_project = "guard-jasmine-node"
+
+  s.add_dependency "guard", ">= 0.4"
+  
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "guard-rspec"
+  if RUBY_PLATFORM =~ /linux/
+    s.add_development_dependency "rb-inotify"
+    s.add_development_dependency "libnotify"
+  end
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/guard/jasmine-node.rb

@@ -0,0 +1,26 @@
+require 'guard/jasmine_node'
+
+Guard::Jasminenode = Guard::JasmineNode
+
+module Guard
+  class Jasminenode < Guard
+    GEM_NAME = "jasmine-node"
+
+    # Guardfile template needed inside guard gem
+    def self.init(name)
+      if ::Guard::Dsl.guardfile_include?(GEM_NAME)
+        ::Guard::UI.info "Guardfile already includes #{GEM_NAME} guard"
+      else
+        content = File.read('Guardfile')
+        guard   = File.read("#{::Guard.locate_guard(GEM_NAME)}/lib/guard/jasmine_node/templates/Guardfile")
+        File.open('Guardfile', 'wb') do |f|
+          f.puts(content)
+          f.puts("")
+          f.puts(guard)
+        end
+        ::Guard::UI.info "#{name} guard added to Guardfile, feel free to edit it"
+      end
+    end
+  end
+end
+    

data/lib/guard/jasmine_node.rb

@@ -0,0 +1,70 @@
+require 'guard'
+require 'guard/guard'
+
+module Guard
+  class JasmineNode < Guard
+    DEFAULT_OPTIONS = {
+      :jasmine_node_bin => "jasmine-node",
+      :all_after_pass   => true,
+      :all_on_start     => true,
+      :keep_failed      => true
+    }
+
+    autoload :Runner, "guard/jasmine_node/runner"
+    
+    def initialize(watchers = [], options = {})
+      super(watchers, DEFAULT_OPTIONS.merge(options))
+      clear_pass_state
+    end
+
+    def start
+      run_all if options[:all_on_start]
+    end
+
+    def run_all
+      outcome = Runner.run(["spec"], options.merge(:message => "Running all specs"))
+      set_pass_state(outcome)
+    end
+
+    def run_on_change(changed_paths = [])
+      run_paths = if options[:keep_failed]
+                    failing_paths + changed_paths
+                  else
+                    changed_paths
+                  end
+
+      outcome = Runner.run(run_paths, options)
+      set_pass_state(outcome, run_paths)
+      
+      if passing?
+        run_all if options[:all_after_pass]
+      end
+    end
+
+    def passing?
+      @passing
+    end
+
+    def failing_paths
+      @failing_paths
+    end
+
+    private
+
+    def clear_pass_state
+      @passing       = true
+      @failing_paths = []
+    end
+    
+    def set_pass_state(passed, run_paths = [])
+      @passing = passed
+      if run_paths.any?
+        @failing_paths = if passing?
+                           @failing_paths - run_paths
+                         else
+                           @failing_paths && run_paths
+                         end
+      end
+    end
+  end
+end

data/lib/guard/jasmine_node/runner.rb

@@ -0,0 +1,22 @@
+require 'guard/ui'
+
+module Guard
+  class JasmineNode
+    module Runner
+      def self.run(paths = [], options = {})
+        return false if paths.empty?
+        
+        message = options.fetch(:message, "Running: #{paths.join(' ')}")
+        ::Guard::UI.info(message, :reset => true)
+
+        system(jasmine_node_command(paths, options))
+      end
+
+      private
+
+      def self.jasmine_node_command(paths = [], options = {})
+        "#{options[:jasmine_node_bin]} #{paths.join(' ')}"
+      end
+    end
+  end
+end

data/lib/guard/jasmine_node/templates/Guardfile

@@ -0,0 +1,5 @@
+guard "jasmine-node", :jasmine_node_bin => File.expand_path(File.dirname(__FILE__) + "/node_modules/jasmine-node/bin/jasmine-node")  do
+  watch(%r{^spec/.+_spec\.js$})
+  watch(%r{^lib/(.+)\.js$})     { |m| "spec/lib/#{m[1]}_spec.js" }
+  watch('spec/spec_helper.js')
+end

data/lib/guard/jasmine_node/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  module JasmineNodeVersion
+    VERSION = "0.0.1"
+  end
+end

data/spec/spec/jasmine_node_spec.rb

@@ -0,0 +1,222 @@
+require 'spec_helper'
+
+describe Guard::JasmineNode do
+  let(:guard)  { Guard::JasmineNode.new }
+  let(:runner) { Guard::JasmineNode::Runner }
+  
+  describe "#initialize" do
+    context "when no options are given" do
+      it "sets a default path to jasmine-node bin" do
+        guard.options[:jasmine_node_bin].should eql "jasmine-node"
+      end
+
+      it "sets a default :all_after_pass option" do
+        guard.options[:all_after_pass].should be_true
+      end
+
+      it "sets a default :all_on_start option" do
+        guard.options[:all_on_start].should be_true
+      end
+      
+      it "sets a default :keep_failed option" do
+        guard.options[:keep_failed].should be_true
+      end
+
+      it "is passing" do
+        guard.should be_passing
+      end
+
+      it "has no failing paths" do
+        guard.failing_paths.should be_empty
+      end
+    end
+
+    context "when options are given" do
+      let(:a_path) { "/foo/bar/jasmine-node" }
+      let(:guard)  { Guard::JasmineNode.new([], {
+                                              :jasmine_node_bin => a_path,
+                                              :all_on_start     => false,
+                                              :all_after_pass   => false,
+                                              :keep_failed      => false
+                                            }) }
+
+      it "sets the path to jasmine-node bin" do
+        guard.options[:jasmine_node_bin].should eql a_path        
+      end
+      
+      it "sets the :all_after_pass option" do
+        guard.options[:all_after_pass].should be_false
+      end
+
+      it "sets the :all_on_start option" do
+        guard.options[:all_on_start].should be_false
+      end
+      
+      it "sets the :keep_failed option" do
+        guard.options[:keep_failed].should be_false
+      end
+    end
+  end
+
+  describe "#start" do
+    context "when :all_on_start is true" do
+      it "runs all" do
+        guard.should_receive(:run_all)
+        guard.start
+      end
+    end
+    
+    context "when :all_on_start is false" do
+      let(:guard) { Guard::JasmineNode.new([], { :all_on_start => false }) }
+        
+      it "does not run all" do
+        guard.should_not_receive(:run_all)
+        guard.start
+      end
+    end
+  end
+
+  describe "#run_all" do
+    it "runs the runner with the spec dir" do
+      runner.should_receive(:run).with(["spec"], anything)
+      guard.run_all
+    end
+
+    it "tells the message to the runner" do
+      runner.should_receive(:run).with(anything, hash_including(:message => "Running all specs"))
+      guard.run_all
+    end
+
+    it "passes the options on to the runner" do
+      an_option = { :option => "value" }
+      guard.options.update(an_option)
+      runner.should_receive(:run).with(anything, hash_including(an_option))
+      guard.run_all
+    end
+
+    context "when specs pass" do
+      before do
+        runner.stub(:run => true)
+        guard.run_all
+      end
+
+      it "is passing" do
+        guard.should be_passing
+      end
+
+      it "has no failed paths" do
+        guard.failing_paths.should be_empty
+      end
+    end
+
+    context "when specs fail" do
+      before do
+        runner.stub(:run => false)
+      end
+
+      it "is not passing" do
+        guard.run_all
+        guard.should_not be_passing
+      end
+
+      it "keeps previously failing specs" do
+        failing_paths = %w(foo bar)
+        guard.run_on_change(failing_paths)
+        guard.run_all
+        guard.failing_paths.should eql failing_paths
+      end
+    end
+  end
+
+  describe "#run_on_change" do
+    it "runs the runner with paths" do
+      runner.should_receive(:run).with(["/a/path"], anything)
+      guard.run_on_change(["/a/path"])
+    end
+
+    it "passes options through to the runner" do
+      an_option = { :option => "value" }
+      guard.options.update(an_option)
+      runner.should_receive(:run).with(anything, hash_including(an_option))
+      guard.run_on_change
+    end
+
+    context "when specs pass" do
+      before do
+        runner.stub(:run => true)
+      end
+
+      it "is passing" do
+        guard.run_on_change
+        guard.should be_passing
+      end
+      
+      context "and :all_after_pass is true" do
+        before do
+          guard.options[:all_after_pass] = true
+        end
+
+        it "runs all" do
+          guard.should_receive(:run_all)
+          guard.run_on_change
+        end
+      end
+      
+      context "and :all_after_pass is false" do
+        before do
+          guard.options[:all_after_pass] = false
+        end
+
+        context "if :all_after_pass is true" do
+          it "does not run all" do
+            guard.should_not_receive(:run_all)
+            guard.run_on_change
+          end
+        end
+      end
+    end
+
+    context "when specs fail" do
+      before do
+        runner.stub(:run => false)
+      end
+
+      it "is not passing" do
+        guard.run_on_change
+        guard.should_not be_passing
+      end
+    end
+
+    context "when there are failing paths" do
+      let(:failing_paths) { %w(foo/bar zip/zap) }
+      let(:changed_paths) { %w(aaa/bbb ccc/ddd) }
+      let(:all_paths)     { failing_paths + changed_paths }
+      
+      before do
+        guard.stub(:failing_paths => failing_paths)
+      end
+      
+      context "and :keep_failed is true" do
+        before do
+          guard.options[:keep_failed] = true
+        end
+
+        it "runs the runner failing paths and the changed paths" do
+          runner.should_receive(:run).with(all_paths, anything)
+          guard.run_on_change(changed_paths)
+        end
+      end
+      
+      context "and :keep_failed is false" do
+        before do
+          guard.options[:keep_failed] = false
+        end
+
+        it "runs the runner with only the changed paths" do
+          runner.should_receive(:run).with(changed_paths, anything)
+          guard.run_on_change(changed_paths)
+        end
+      end
+    end
+  end
+end

data/spec/spec/runner_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Guard::JasmineNode::Runner do
+  let(:runner) { Guard::JasmineNode::Runner }
+  
+  describe ".run" do
+    context "when passed no paths" do
+      it "returns false" do
+        runner.run.should be_false
+      end
+    end
+
+    context "when passed paths" do
+      let(:some_paths) { %w(/foo/bar /zip/zap) }
+
+      it "executes jasmine node" do
+        runner.should_receive(:system).with(/__EXECUTABLE__/)
+        runner.run(some_paths, :jasmine_node_bin => "__EXECUTABLE__")
+      end
+      
+      context "when message option is given" do
+        it "outputs message" do
+          Guard::UI.should_receive(:info).with("hello", anything)
+          runner.run(some_paths, :message => "hello")
+        end
+      end
+
+      context "when no message option is given" do
+        it "outputs default message" do
+          Guard::UI.should_receive(:info).with("Running: /foo/bar /zip/zap", anything)
+          runner.run(some_paths)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'rspec'
+require 'guard/jasmine_node'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+
+  config.before do
+    ENV["GUARD_ENV"] = "test"
+    @project_path = Pathname.new(File.expand_path("../../", __FILE__))
+  end
+
+  config.after do
+    ENV["GUARD_ENV"] = nil
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: guard-jasmine-node
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- dave@kapoq.com
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-22 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &21459700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: *21459700
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &21459280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21459280
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &21458820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21458820
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: &21458360 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21458360
+- !ruby/object:Gem::Dependency
+  name: libnotify
+  requirement: &21457940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *21457940
+description: ''
+email:
+- dave@kapoq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- guard-jasmine-node.gemspec
+- lib/guard/jasmine-node.rb
+- lib/guard/jasmine_node.rb
+- lib/guard/jasmine_node/runner.rb
+- lib/guard/jasmine_node/templates/Guardfile
+- lib/guard/jasmine_node/version.rb
+- spec/spec/jasmine_node_spec.rb
+- spec/spec/runner_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kapoq/guard-jasmine-node
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: guard-jasmine-node
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Guard::JasmineNode automatically runs your Jasmine Node specs when files
+  are modified
+test_files: []