guard-teaspoon 0.0.3

data/MIT.LICENSE

@@ -0,0 +1,22 @@
+Copyright 2012 Jeremy Jackson / ModeSet
+
+https://github.com/modeset/guard-teaspoon
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+Guard Teaspoon
+==============
+[![Build Status](https://travis-ci.org/modeset/guard-teaspoon.png?branch=master)](https://travis-ci.org/modeset/guard-teaspoon)
+[![Code Climate](https://codeclimate.com/github/modeset/guard-teaspoon.png)](https://codeclimate.com/github/modeset/guard-teaspoon)
+
+Guard-Teaspoon allows you to run [Teaspoon](https://github.com/modeset/teaspoon) using [Guard](https://github.com/guard/guard).
+
+Teaspoon is a Javascript test runner built on top of Rails. It can run tests in the browser, or headlessly using PhantomJS or with Selenium WebDriver. We recommend you check out the [installation steps for Teaspoon](https://github.com/modeset/teaspoon#installation), and [read about configuration](https://github.com/modeset/teaspoon#configuration).
+
+With Guard-Teaspoon you can start up Guard, make changes to your tests or implementation files, and the specs will be run automatically using Teaspoon. It behaves very similarly to guard-rspec.
+
+This project is still experimental...
+
+
+## Table of Contents
+
+1. [Installation](#installation)
+2. [Usage](#usage)
+3. [Configuring Guard](#configuring-guard)
+
+
+## Installation
+
+Add it to your Gemfile. Like Teaspoon, in most cases you'll want to restrict it to the `:asset`, or `:development, :test` groups. You may also want to include one of the filesystem gems that [Guard suggests](https://github.com/guard/guard#efficient-filesystem-handling), and in our example we included `rb-fsevent`.
+
+```ruby
+group :assets do
+  gem "teaspoon"
+  gem "guard-teaspoon"
+  gem "rb-fsevent" # used by guard
+end
+```
+
+Install Teaspoon using the install generator.
+
+```
+rails generate teaspoon:install
+```
+
+Generate the Guardfile that includes the standard Guard-Teaspoon template.
+
+```
+bundle exec guard init teaspoon
+```
+
+
+## Usage
+
+Start Guard.
+
+```
+bundle exec guard start
+```
+
+Make changes to your javascript specs or implementation files and the appropriate tests will run.
+
+
+## Configuring Guard
+
+In general this isn't very complicated, but if you have multiple suites setup in Teaspoon this can get a little complicated -- there's an expectation that you understand what you're doing in regards to using Guard.
+
+The default Guardfile will watch for any file changes within your `app/assets/javascripts` path and will attempt to resolve those file to a spec. If you're using QUnit, you can change this to be _test instead of _spec, or use js.coffee or coffee for file extensions, and you can use a more advanced regexp for other needs.
+
+Guardfile
+```ruby
+guard :teaspoon do
+  watch(%r{app/assets/javascripts/(.+).js}) { |m| "#{m[1]}_spec" }
+  watch(%r{/spec/javascripts/(.*)})
+end
+```
+
+### Specifying Teaspoon Environment
+
+Guard-Teaspoon takes several options, but worth calling out is the environment option. This option allows you to tell Teaspoon where it should look for it's environment file, and is useful if Teaspoon is unable to resolve it's environment.
+
+Guardfile
+```ruby
+guard :teaspoon, environment: "spec/dummy/spec/teaspoon_env.rb" do
+end
+```
+
+### Available Options
+
+...document when this is better hammered out...
+
+
+## License
+
+Licensed under the [MIT License](http://creativecommons.org/licenses/MIT/)
+
+Copyright 2012 [Mode Set](https://github.com/modeset)
+
+
+## Make Code Not War
+![crest](https://secure.gravatar.com/avatar/aa8ea677b07f626479fd280049b0e19f?s=75)
+

data/lib/guard/teaspoon.rb

@@ -0,0 +1,130 @@
+require "guard"
+require "guard/guard"
+
+module Guard
+  class Teaspoon < Guard
+    autoload :Runner,   "guard/teaspoon/runner"
+    autoload :Resolver, "guard/teaspoon/resolver"
+
+    attr_accessor :runner, :failed_paths, :last_failed
+
+    def initialize(watchers = [], options = {})
+      super
+      @options = {
+        focus_on_failed: false,
+        all_after_pass:  true,
+        all_on_start:    true,
+        keep_failed:     true,
+        formatters:      "clean",
+        run_all:         {},
+        run_on_changes:  {}
+      }.merge(options)
+      reload
+
+      @resolver = Resolver.new(@options)
+      @runner = Runner.new(@options)
+    end
+
+    def start
+      UI.info "Guard::Teaspoon is running"
+      run_all if @options[:all_on_start]
+    end
+
+    def run_all
+      passed = @runner.run_all(@options[:run_all])
+
+      unless @last_failed = !passed
+        @failed_paths = []
+      else
+        throw :task_has_failed
+      end
+    end
+
+    def reload
+      @last_failed = false
+      @failed_paths = []
+    end
+
+    def run_on_changes(original_paths)
+      @resolver.resolve(original_paths)
+
+      failed = false
+      @resolver.suites.each do |suite, files|
+        failed = @runner.run(files, @options[:run_on_changes].merge(suite: suite))
+      end
+
+      if failed
+        @last_failed = true
+        Notifier.notify("Failed", title: "Teaspoon Guard", image: :failed)
+      else
+        Notifier.notify("Success", title: "Teaspoon Guard", image: :success)
+      end
+
+      #original_paths = paths.dup
+      #
+      #focused = false
+      #if last_failed && @options[:focus_on_failed]
+      #  path = './tmp/teaspoon_guard_result'
+      #  if File.exist?(path)
+      #    # todo: this should ask a "resolver" to see if it's a spec or not
+      #    single_spec = paths && paths.length == 1 && paths[0].include?("_spec") ? paths[0] : nil
+      #    failed_specs = File.open(path) { |file| file.read.split("\n") }
+      #
+      #    File.delete(path)
+      #
+      #    if single_spec && @inspector.clean([single_spec]).length == 1
+      #      failed_specs = failed_specs.select{|p| p.include? single_spec}
+      #    end
+      #
+      #    if failed_specs.any?
+      #      # some sane limit, stuff will explode if all tests fail
+      #      #   ... cap at 10
+      #
+      #      paths = failed_specs[0..10]
+      #      focused = true
+      #    end
+      #
+      #    # switch focus to the single spec
+      #    focused = true if single_spec and failed_specs.length > 0
+      #  end
+      #end
+      #
+      #if focused
+      #  add_failed(original_paths)
+      #  add_failed(paths.map{|p| p.split(":")[0]})
+      #else
+      #  paths += failed_paths if @options[:keep_failed]
+      #  paths = @inspector.clean(paths)
+      #end
+      #
+      #if @runner.run(paths)
+      #  remove_failed(paths) unless focused
+      #
+      #  if last_failed && focused
+      #    run_on_changes(failed_paths)
+      #  elsif last_failed && @options[:all_after_pass]
+      #    @last_failed = false
+      #    run_all
+      #  end
+      #else
+      #  @last_failed = true
+      #  add_failed(paths) unless focused
+      #
+      #  throw :task_has_failed
+      #end
+    end
+
+    private
+
+    def remove_failed(paths)
+      @failed_paths -= paths if @options[:keep_failed]
+    end
+
+    def add_failed(paths)
+      if @options[:keep_failed]
+        @failed_paths += paths
+        @failed_paths.uniq!
+      end
+    end
+  end
+end

data/lib/guard/teaspoon/resolver.rb

@@ -0,0 +1,24 @@
+module Guard
+  class Teaspoon
+    class Resolver
+
+      attr_accessor :suites
+
+      def initialize(options = {})
+        @options = options
+        #@excluded = Dir[@options[:exclude].to_s]
+      end
+
+      def resolve(original_paths)
+        @suites = {}
+        original_paths.uniq.each do |path|
+          if result = ::Teaspoon::Suite.resolve_spec_for(path)
+            suite = @suites[result[:suite]] ||= []
+            suite << result[:path]
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/guard/teaspoon/runner.rb

@@ -0,0 +1,36 @@
+module Guard
+  class Teaspoon
+    class Runner
+
+      attr_accessor :console
+
+      def initialize(options = {})
+        @options = options
+
+        begin
+          require "teaspoon/console"
+          @console = ::Teaspoon::Console.new(@options)
+        rescue ::Teaspoon::EnvironmentNotFound => e
+          STDOUT.print "Unable to load Teaspoon environment in {#{::Teaspoon::Environment.standard_environments.join(', ')}}.\n"
+          STDOUT.print "Consider using -r path/to/teaspoon_env\n"
+          abort
+        end
+      end
+
+      def run_all(options = {})
+        @console.execute(@options.merge(options))
+      end
+
+      def run(files = [], options = {})
+        return false if files.empty?
+        @console.execute(@options.merge(options), files)
+      end
+
+      private
+
+      def abort
+        exit(1)
+      end
+    end
+  end
+end

data/lib/guard/teaspoon/templates/Guardfile

@@ -0,0 +1,7 @@
+guard :teaspoon do
+  # Implementation files
+  watch(%r{app/assets/javascripts/(.+).js}) { |m| "#{m[1]}_spec" }
+
+  # Specs / Helpers
+  watch(%r{spec/javascripts/(.*)})
+end

data/lib/guard/teaspoon/version.rb

@@ -0,0 +1,5 @@
+module Guard
+  module TeaspoonVersion
+    VERSION = "0.0.3"
+  end
+end

data/spec/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/calculator.js

@@ -0,0 +1,13 @@
+var Calculator;
+
+Calculator = (function() {
+
+  function Calculator() {}
+
+  Calculator.prototype.add = function(a, b) {
+    return a + b;
+  };
+
+  return Calculator;
+
+})();

data/spec/dummy/config.ru

@@ -0,0 +1,15 @@
+# This file is used by Rack-based servers to start the application.
+
+require 'rails/commands/server'
+
+module Rails
+  class Server
+    alias :default_options_alias :default_options
+    def default_options
+      default_options_alias.merge!(:Port => 3333)
+    end
+  end
+end
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run Dummy::Application

data/spec/dummy/config/application.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../boot', __FILE__)
+
+require "action_controller/railtie"
+require "active_resource/railtie"
+require "sprockets/railtie"
+
+Bundler.require
+
+module Dummy
+  class Application < Rails::Application
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Configure sensitive parameters which will be filtered from the log file.
+    config.filter_parameters += [:password]
+
+    # Enable escaping HTML in JSON.
+    config.active_support.escape_html_entities_in_json = true
+
+    # Moved from initializers.
+    config.session_store :cookie_store, key: '_dummy_session'
+    config.secret_token = 'bc510a13d2fb96575782e90e9f2f64afc0ba4e63e5869b6139613686f104d4d3dd92ee696468de5bcbbb74daedb702d3da97554efbc6792abe75091b9df0a2ab'
+
+    # Enable the asset pipeline
+    config.assets.enabled = true
+
+    # Version of your assets, change this if you want to expire all your assets
+    config.assets.version = '1.0'
+  end
+end

data/spec/dummy/config/boot.rb

@@ -0,0 +1,7 @@
+require "rubygems"
+
+# Set up gems listed in the Gemfile.
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../../../Gemfile", __FILE__)
+
+require "bundler/setup" if File.exists?(ENV["BUNDLE_GEMFILE"])
+require "rubygems"

data/spec/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+Dummy::Application.initialize!

data/spec/dummy/config/environments/development.rb

@@ -0,0 +1,27 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # In the development environment your application's code is reloaded on
+  # every request. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Log error messages when you accidentally call methods on nil.
+  config.whiny_nils = true
+
+  # Show full error reports and disable caching
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Print deprecation notices to the Rails logger
+  config.active_support.deprecation = :log
+
+  # Only use best-standards-support built into browsers
+  config.action_dispatch.best_standards_support = :builtin
+
+  # Do not compress assets
+  config.assets.compress = false
+
+  # Expands the lines which load the assets
+  config.assets.debug = true
+end