oojs 0.0.4 → 0.1.0

data/lib/assets/javascripts/oojspec_helpers.js.coffee

@@ -0,0 +1,7 @@
+# =require_tree ./oojspec_helpers
+
+oojspec.assertions.add 'undefined', # simetric to 'toBeDefined'
+  assert: (@actual)-> @actual is undefined
+  assertMessage: 'Expected ${actual} to be undefined.'
+  refuteMessage: 'Expected ${actual} not to be undefined.'
+  expectation: 'toBeUndefined'

data/lib/assets/javascripts/oojspec_helpers/ajax_spec_helpers.js.coffee

@@ -0,0 +1,26 @@
+# =require modules
+
+TIMEOUT = 500 # ms - Used to be 300, but FF was too slow
+extendClass 'specs.oojspec.AjaxHelpers', ->
+  ajaxServer = null
+  initialize: (fakeAjaxServer, options = {})->
+    ajaxServer = fakeAjaxServer
+  ajaxSettings: -> ajaxServer.ajaxSettings()
+  waitsForAjaxRequest: (message = "An AJAX call was expected", \
+                        timeout = @timeout or TIMEOUT, extraCondition)->
+    @waitsFor message, timeout, ->
+      ajaxServer.ajaxCallbacksQueue.length and (not extraCondition or extraCondition.call this)
+  waitsForAjaxRequestAnd: (condition, message, timeout)->
+    @waitsForAjaxRequest(message, timeout, condition)
+  nextRequest: (url, method, format)->
+    @checkRequestSettings(url, method, format)
+    ajaxServer.processNextRequest()
+  checkRequestSettings: (url, method, format)->
+    s = @ajaxSettings()
+    @expect(s.url).toBe url unless url is undefined
+    @expect(s.type).toBe method unless method is undefined
+    @expect(s.dataType).toBe format unless format is undefined
+  ignoreRequest: (url, method, format)->
+    @checkRequestSettings(url, method, format)
+    ajaxServer.ignoreNextRequest()
+  ignoreAllRequest: -> ajaxServer.ignoreAllRequest()

data/lib/assets/javascripts/oojspec_helpers/oojspec-jquery.js.coffee

@@ -0,0 +1,165 @@
+$ = jQuery # just to make sure
+
+assertions = oojspec.assertions
+
+addAssertion = (name, assertion)->
+  assert = assertion.assert
+  assertion.assert = ->
+    if arguments.length < assert.length
+      msg = "[#{name}] Expected to receive at least #{assert.length} argument"
+      msg += 's' if assert.length > 1
+      assertions.fail msg
+      return
+    result = assert.apply this, arguments
+    @actual = $toString(@actual) if @actual instanceof jQuery
+    result
+  assertions.add name, assertion
+
+@oojs or= {}
+
+$toString = ($element)->
+  return toHtml($element) if oojs.debugJQuery
+  $element.map((i, el)-> el.toString()).toArray().join '; '
+
+toHtml = ($element)->
+  $element.map((i, el)-> $('<div/>').append($(el).clone()).html()).toArray().join ';\n\n'
+
+browserTagCaseIndependentHtml = (html)-> $('<div/>').append(html).html()
+
+addAssertion 'hasClass',
+  assert: (@actual, @className)-> $(actual).hasClass className
+  assertMessage: 'Expected ${actual} to have class ${className}.'
+  refuteMessage: 'Expected ${actual} not to have class ${className}.'
+  expectation: 'toHaveClass'
+
+addAssertion 'isVisible',
+  assert: (@actual)-> $(actual).is(':visible')
+  assertMessage: 'Expected ${actual} to be visible.'
+  refuteMessage: 'Expected ${actual} not to be visible.'
+  expectation: 'toBeVisible'
+
+addAssertion 'isHidden',
+  assert: (@actual)-> $(actual).is(':hidden')
+  assertMessage: 'Expected ${actual} to be hidden.'
+  refuteMessage: 'Expected ${actual} not to be hidden.'
+  expectation: 'toBeHidden'
+
+addAssertion 'isSelected',
+  assert: (@actual)-> $(actual).is(':selected')
+  assertMessage: 'Expected ${actual} to be selected.'
+  refuteMessage: 'Expected ${actual} not to be selected.'
+  expectation: 'toBeSelected'
+
+addAssertion 'isChecked',
+  assert: (@actual)-> $(actual).is(':checked')
+  assertMessage: 'Expected ${actual} to be checked.'
+  refuteMessage: 'Expected ${actual} not to be checked.'
+  expectation: 'toBeChecked'
+
+addAssertion 'isEmpty',
+  assert: (@actual)-> $(actual).is(':empty')
+  assertMessage: 'Expected ${actual} to be empty.'
+  refuteMessage: 'Expected ${actual} not to be empty.'
+  expectation: 'toBeEmpty'
+
+addAssertion 'exists',
+  assert: (@actual)-> $(actual).length
+  assertMessage: 'Expected ${actual} to exist.'
+  refuteMessage: 'Expected ${actual} not to exist.'
+  expectation: 'toExist'
+
+addAssertion 'hasAttr',
+  assert: (@actual, @attribute, @expected)-> hasProperty actual.attr(attribute), expected
+  assertMessage: 'Expected attribute ${attribute} to be ${expected} for ${actual}.'
+  refuteMessage: 'Expected attribute ${attribute} not to be ${expected} for ${actual}.'
+  expectation: 'toHaveAttr'
+
+addAssertion 'hasProp',
+  assert: (@actual, @property, @expected)-> hasProperty actual.prop(attribute), expected
+  assertMessage: 'Expected property ${property} to be ${expected} for ${actual}.'
+  refuteMessage: 'Expected property ${property} not to be ${expected} for ${actual}.'
+  expectation: 'toHaveProp'
+
+addAssertion 'hasCss',
+  assert: (@actual, @css)->
+    return false for prop, value of css when @actual.css(prop) isnt value
+    true
+  assertMessage: 'Expected ${actual} to have css ${css}.'
+  refuteMessage: 'Expected ${actual} not to have css ${css}.'
+  expectation: 'toHaveCss'
+
+addAssertion 'hasId',
+  assert: (@actual, @id)-> hasProperty actual.attr('id') is id
+  assertMessage: 'Expected ${actual} to have id ${id}.'
+  refuteMessage: 'Expected ${actual} not to have id ${id}.'
+  expectation: 'toHaveId'
+
+addAssertion 'hasHtml',
+  assert: (@actual, @html)-> actual.html() is browserTagCaseIndependentHtml html
+  assertMessage: 'Expected ${actual} to have html ${html}.'
+  refuteMessage: 'Expected ${actual} not to have html ${html}.'
+  expectation: 'toHaveHtml'
+
+addAssertion 'hasText',
+  assert: (@actual, @text)->
+    trimmedText = $.trim actual.text()
+    return text.test trimmedText if text?.test
+    trimmedText is text
+  assertMessage: 'Expected ${actual} to have text ${text}.'
+  refuteMessage: 'Expected ${actual} not to have text ${text}.'
+  expectation: 'toHaveText'
+
+addAssertion 'hasValue',
+  assert: (@actual, @value)-> actual.val() is value
+  assertMessage: 'Expected ${actual} to have value ${value}.'
+  refuteMessage: 'Expected ${actual} not to have value ${value}.'
+  expectation: 'toHaveValue'
+
+addAssertion 'hasData',
+  assert: (@actual, @key, @value)-> actual.data(key) is value
+  assertMessage: 'Expected ${key} data to be ${value} for ${actual}.'
+  refuteMessage: 'Expected ${key} data not to be ${value} for ${actual}.'
+  expectation: 'toHaveData'
+
+addAssertion 'isSelector', # TODO: override toBe?
+  assert: (@actual, @selector)-> actual.is selector
+  assertMessage: 'Expected ${actual} to be ${selector}.'
+  refuteMessage: 'Expected ${actual} not to be ${selector}.'
+  expectation: 'toBeSelector'
+
+addAssertion 'containsSelector', # TODO: override contains?
+  assert: (@actual, @selector)-> actual.find(selector).length
+  assertMessage: 'Expected ${actual} to contain ${selector}.'
+  refuteMessage: 'Expected ${actual} not to contain ${selector}.'
+  expectation: 'toContainSelector'
+
+addAssertion 'isDisabled',
+  assert: (@actual)-> actual.is ':disabled'
+  assertMessage: 'Expected ${actual} to be disabled.'
+  refuteMessage: 'Expected ${actual} not to be disabled.'
+  expectation: 'toBeDisabled'
+
+addAssertion 'isFocused',
+  assert: (@actual)-> actual.is ':focus'
+  assertMessage: 'Expected ${actual} to be focused.'
+  refuteMessage: 'Expected ${actual} not to be focused.'
+  expectation: 'toBeFocused'
+
+addAssertion 'handle',
+  assert: (@actual, @event)-> actual.data('events')?[event].length
+  assertMessage: 'Expected ${actual} to handle ${event}.'
+  refuteMessage: 'Expected ${actual} not to handle ${event}.'
+  expectation: 'toHandle'
+
+addAssertion 'handleWith',
+  assert: (@actual, @event, @handler)->
+    stack = actual.data('events')[event]
+    return true for ev in stack when ev.handler is handler
+    false
+  assertMessage: 'Expected ${actual} to handle ${event} with ${handler}.'
+  refuteMessage: 'Expected ${actual} not to handle ${event} with ${handler}.'
+  expectation: 'toHandle'
+
+hasProperty = (actualValue, expectedValue)->
+  return actualValue isnt undefined if expectedValue is undefined
+  actualValue is expectedValue

data/lib/oojs.rb

@@ -1,11 +1,11 @@
 require "oojs/version"
-require 'rails_sandbox_jasmine'
+require 'oojspec'
 require 'fake-ajax-server'
 require 'jquery-rails'
 require 'sinon-rails'
 
 module Oojs
   class Engine < Rails::Engine
-    config.sandbox_assets.template ||= 'jasmine/runner'
+    config.sandbox_assets.template ||= 'oojspec/runner'
   end
 end

data/lib/oojs/version.rb

@@ -1,3 +1,3 @@
 module Oojs
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/oojs.gemspec

@@ -17,6 +17,6 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = Oojs::VERSION
 
-  gem.add_dependency 'rails_sandbox_jasmine'
+  gem.add_dependency 'oojspec'
   gem.add_dependency 'fake-ajax-server', '>= 0.0.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oojs
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,10 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-04 00:00:00.000000000 Z
+date: 2012-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rails_sandbox_jasmine
+  name: oojspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -58,9 +58,9 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- lib/assets/javascripts/jasmine_helpers.js.coffee
-- lib/assets/javascripts/jasmine_helpers/ajax_spec_helpers.js.coffee
-- lib/assets/javascripts/jasmine_helpers/extra_matchers.js.coffee
+- lib/assets/javascripts/oojspec_helpers.js.coffee
+- lib/assets/javascripts/oojspec_helpers/ajax_spec_helpers.js.coffee
+- lib/assets/javascripts/oojspec_helpers/oojspec-jquery.js.coffee
 - lib/generators/oojs/spec/USAGE
 - lib/generators/oojs/spec/spec_generator.rb
 - lib/generators/oojs/spec/templates/fake_ajax_server.js.coffee.erb
@@ -71,7 +71,6 @@ files:
 - lib/oojs.rb
 - lib/oojs/version.rb
 - oojs.gemspec
-- vendor/assets/javascripts/jasmine-jquery.js
 - vendor/assets/javascripts/jquery.ba-bbq.js
 - vendor/assets/javascripts/modules.js.coffee
 homepage: http://github.com/rosenfeld/oojs
@@ -88,7 +87,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3524376735705668499
+      hash: -1256028454248046243
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -97,10 +96,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3524376735705668499
+      hash: -1256028454248046243
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Object-oriented JavaScript (or CoffeeScript) for Rails

data/lib/assets/javascripts/jasmine_helpers.js.coffee

@@ -1 +0,0 @@
-# =require_tree ./jasmine_helpers

data/lib/assets/javascripts/jasmine_helpers/ajax_spec_helpers.js.coffee

@@ -1,28 +0,0 @@
-# =require modules
-
-TIMEOUT = 500 # ms - Used to be 300, but FF was too slow
-extendClass 'specs.jasmine.AjaxHelpers', (self)->
-  ajaxServer = null
-  initialize: (fakeAjaxServer, options={})->
-    ajaxServer = fakeAjaxServer
-    TIMEOUT = options.timeout if options.timeout
-  ajaxSettings: -> ajaxServer.ajaxSettings()
-  waitsFor: (condition, message="waited event didn't happen", timeout=TIMEOUT)->
-    waitsFor (-> condition.call self), message, timeout
-  waitsForAjaxRequest: (message = "An AJAX call was expected", timeout=TIMEOUT, extraCondition)->
-    @waitsFor (-> ajaxServer.ajaxCallbacksQueue.length and
-      (not extraCondition or extraCondition.call self)), message, timeout
-  waitsForAjaxRequestAnd: (condition, message, timeout)->
-    @waitsForAjaxRequest(message, timeout, condition)
-  nextRequest: (url, method, format)->
-    @checkRequestSettings(url, method, format)
-    ajaxServer.processNextRequest()
-  checkRequestSettings: (url, method, format)->
-    s = @ajaxSettings()
-    expect(s.url).toBe url unless url is undefined
-    expect(s.type).toBe method unless method is undefined
-    expect(s.dataType).toBe format unless format is undefined
-  ignoreRequest: (url, method, format)->
-    @checkRequestSettings(url, method, format)
-    ajaxServer.ignoreNextRequest()
-  ignoreAllRequest: -> ajaxServer.ignoreAllRequest()

data/lib/assets/javascripts/jasmine_helpers/extra_matchers.js.coffee

@@ -1,6 +0,0 @@
-# =require jasmine-jquery
-
-jasmine.JQuery.matchersClass.toHaveCss = (css)->
-  (return false unless @actual.css(prop) is value) for prop, value of css
-  true
-

data/vendor/assets/javascripts/jasmine-jquery.js

@@ -1,315 +0,0 @@
-var readFixtures = function() {
-  return jasmine.getFixtures().proxyCallTo_('read', arguments);
-};
-
-var preloadFixtures = function() {
-  jasmine.getFixtures().proxyCallTo_('preload', arguments);
-};
-
-var loadFixtures = function() {
-  jasmine.getFixtures().proxyCallTo_('load', arguments);
-};
-
-var setFixtures = function(html) {
-  jasmine.getFixtures().set(html);
-};
-
-var sandbox = function(attributes) {
-  return jasmine.getFixtures().sandbox(attributes);
-};
-
-var spyOnEvent = function(selector, eventName) {
-  jasmine.JQuery.events.spyOn(selector, eventName);
-};
-
-jasmine.getFixtures = function() {
-  return jasmine.currentFixtures_ = jasmine.currentFixtures_ || new jasmine.Fixtures();
-};
-
-jasmine.Fixtures = function() {
-  this.containerId = 'jasmine-fixtures';
-  this.fixturesCache_ = {};
-  this.fixturesPath = 'spec/javascripts/fixtures';
-};
-
-jasmine.Fixtures.prototype.set = function(html) {
-  this.cleanUp();
-  this.createContainer_(html);
-};
-
-jasmine.Fixtures.prototype.preload = function() {
-  this.read.apply(this, arguments);
-};
-
-jasmine.Fixtures.prototype.load = function() {
-  this.cleanUp();
-  this.createContainer_(this.read.apply(this, arguments));
-};
-
-jasmine.Fixtures.prototype.read = function() {
-  var htmlChunks = [];
-
-  var fixtureUrls = arguments;
-  for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) {
-    htmlChunks.push(this.getFixtureHtml_(fixtureUrls[urlIndex]));
-  }
-
-  return htmlChunks.join('');
-};
-
-jasmine.Fixtures.prototype.clearCache = function() {
-  this.fixturesCache_ = {};
-};
-
-jasmine.Fixtures.prototype.cleanUp = function() {
-  jQuery('#' + this.containerId).remove();
-};
-
-jasmine.Fixtures.prototype.sandbox = function(attributes) {
-  var attributesToSet = attributes || {};
-  return jQuery('<div id="sandbox" />').attr(attributesToSet);
-};
-
-jasmine.Fixtures.prototype.createContainer_ = function(html) {
-  var container;
-  if(html instanceof jQuery) {
-    container = jQuery('<div id="' + this.containerId + '" />');
-    container.html(html);
-  } else {
-    container = '<div id="' + this.containerId + '">' + html + '</div>'
-  }
-  jQuery('body').append(container);
-};
-
-jasmine.Fixtures.prototype.getFixtureHtml_ = function(url) {
-  if (typeof this.fixturesCache_[url] == 'undefined') {
-    this.loadFixtureIntoCache_(url);
-  }
-  return this.fixturesCache_[url];
-};
-
-jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function(relativeUrl) {
-  var url = this.makeFixtureUrl_(relativeUrl);
-  var request = new XMLHttpRequest();
-  request.open("GET", url + "?" + new Date().getTime(), false);
-  request.send(null);
-  this.fixturesCache_[relativeUrl] = request.responseText;
-};
-
-jasmine.Fixtures.prototype.makeFixtureUrl_ = function(relativeUrl){
-  return this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl;
-};
-
-jasmine.Fixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) {
-  return this[methodName].apply(this, passedArguments);
-};
-
-
-jasmine.JQuery = function() {};
-
-jasmine.JQuery.browserTagCaseIndependentHtml = function(html) {
-  return jQuery('<div/>').append(html).html();
-};
-
-jasmine.JQuery.elementToString = function(element) {
-  var domEl = $(element).get(0)
-  if (domEl == undefined || domEl.cloneNode)
-    return jQuery('<div />').append($(element).clone()).html();
-  else
-    return element.toString();
-};
-
-jasmine.JQuery.matchersClass = {};
-
-(function(namespace) {
-  var data = {
-    spiedEvents: {},
-    handlers:    []
-  };
-
-  namespace.events = {
-    spyOn: function(selector, eventName) {
-      var handler = function(e) {
-        data.spiedEvents[[selector, eventName]] = e;
-      };
-      jQuery(selector).bind(eventName, handler);
-      data.handlers.push(handler);
-    },
-
-    wasTriggered: function(selector, eventName) {
-      return !!(data.spiedEvents[[selector, eventName]]);
-    },
-
-    wasPrevented: function(selector, eventName) {
-      return data.spiedEvents[[selector, eventName]].isDefaultPrevented();
-    },
-
-    cleanUp: function() {
-      data.spiedEvents = {};
-      data.handlers    = [];
-    }
-  }
-})(jasmine.JQuery);
-
-(function(){
-  var jQueryMatchers = {
-    toHaveClass: function(className) {
-      return this.actual.hasClass(className);
-    },
-
-    toBeVisible: function() {
-      return this.actual.is(':visible');
-    },
-
-    toBeHidden: function() {
-      return this.actual.is(':hidden');
-    },
-
-    toBeSelected: function() {
-      return this.actual.is(':selected');
-    },
-
-    toBeChecked: function() {
-      return this.actual.is(':checked');
-    },
-
-    toBeEmpty: function() {
-      return this.actual.is(':empty');
-    },
-
-    toExist: function() {
-      return $(document).find(this.actual).length;
-    },
-
-    toHaveAttr: function(attributeName, expectedAttributeValue) {
-      return hasProperty(this.actual.attr(attributeName), expectedAttributeValue);
-    },
-
-    toHaveProp: function(propertyName, expectedPropertyValue) {
-      return hasProperty(this.actual.prop(propertyName), expectedPropertyValue);
-    },
-
-    toHaveId: function(id) {
-      return this.actual.attr('id') == id;
-    },
-
-    toHaveHtml: function(html) {
-      return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html);
-    },
-
-    toHaveText: function(text) {
-      var trimmedText = $.trim(this.actual.text());
-      if (text && jQuery.isFunction(text.test)) {
-        return text.test(trimmedText);
-      } else {
-        return trimmedText == text;
-      }
-    },
-
-    toHaveValue: function(value) {
-      return this.actual.val() == value;
-    },
-
-    toHaveData: function(key, expectedValue) {
-      return hasProperty(this.actual.data(key), expectedValue);
-    },
-
-    toBe: function(selector) {
-      return this.actual.is(selector);
-    },
-
-    toContain: function(selector) {
-      return this.actual.find(selector).length;
-    },
-
-    toBeDisabled: function(selector){
-      return this.actual.is(':disabled');
-    },
-
-    toBeFocused: function(selector) {
-      return this.actual.is(':focus');
-    },
-
-    // tests the existence of a specific event binding
-    toHandle: function(eventName) {
-      var events = this.actual.data("events");
-      return events && events[eventName].length > 0;
-    },
-
-    // tests the existence of a specific event binding + handler
-    toHandleWith: function(eventName, eventHandler) {
-      var stack = this.actual.data("events")[eventName];
-      var i;
-      for (i = 0; i < stack.length; i++) {
-        if (stack[i].handler == eventHandler) {
-          return true;
-        }
-      }
-      return false;
-    }
-  };
-
-  var hasProperty = function(actualValue, expectedValue) {
-    if (expectedValue === undefined) {
-      return actualValue !== undefined;
-    }
-    return actualValue == expectedValue;
-  };
-
-  var bindMatcher = function(methodName) {
-    var builtInMatcher = jasmine.Matchers.prototype[methodName];
-
-    jasmine.JQuery.matchersClass[methodName] = function() {
-      if (this.actual
-          && (this.actual instanceof jQuery
-             || jasmine.isDomNode(this.actual))) {
-          this.actual = $(this.actual);
-          var result = jQueryMatchers[methodName].apply(this, arguments)
-          if (this.actual.get && !$.isWindow(this.actual.get()[0])) 
-            this.actual = jasmine.JQuery.elementToString(this.actual)
-        return result;
-      }
-
-      if (builtInMatcher) {
-        return builtInMatcher.apply(this, arguments);
-      }
-
-      return false;
-    };
-  };
-
-  for(var methodName in jQueryMatchers) {
-    bindMatcher(methodName);
-  }
-})();
-
-beforeEach(function() {
-  this.addMatchers(jasmine.JQuery.matchersClass);
-  this.addMatchers({
-    toHaveBeenTriggeredOn: function(selector) {
-      this.message = function() {
-        return [
-          "Expected event " + this.actual + " to have been triggered on " + selector,
-          "Expected event " + this.actual + " not to have been triggered on " + selector
-        ];
-      };
-      return jasmine.JQuery.events.wasTriggered($(selector), this.actual);
-    }
-  });
-  this.addMatchers({
-    toHaveBeenPreventedOn: function(selector) {
-      this.message = function() {
-        return [
-          "Expected event " + this.actual + " to have been prevented on " + selector,
-          "Expected event " + this.actual + " not to have been prevented on " + selector
-        ];
-      };
-      return jasmine.JQuery.events.wasPrevented(selector, this.actual);
-    }
-  });
-});
-
-afterEach(function() {
-  jasmine.getFixtures().cleanUp();
-  jasmine.JQuery.events.cleanUp();
-});