oojs 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.gitmodules

@@ -0,0 +1,9 @@
+[submodule "resources/js-modules"]
+	path = resources/js-modules
+	url = git://github.com/rosenfeld/js-modules.git
+[submodule "resources/jquery-bbq"]
+	path = resources/jquery-bbq
+	url = git://github.com/cowboy/jquery-bbq.git
+[submodule "resources/jasmine-jquery"]
+	path = resources/jasmine-jquery
+	url = git://github.com/velesin/jasmine-jquery.git

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in oojs.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Rodrigo Rosenfeld Rosas
+
+MIT License
+
+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,62 @@
+# Object-oriented JavaScript (or CoffeeScript)
+
+This is a bundle of tools for helping you to create well organized client-side
+code to be run in browsers covered by tests (or specs) in an easy way.
+
+It uses:
+
+- [Jasmine](http://pivotal.github.com/jasmine/) for writing specs;
+- [jQuery](http://jquery.com/), the excelent DOM manipulation library;
+- [FakeAjaxServer](https://github.com/rosenfeld/fake-ajax-server) for
+simulating AJAX requests made with jQuery. It uses
+[Sinon.js](http://sinonjs.org/) for stubbing _jQuery.ajax()_ calls;
+- [js-modules](https://github.com/rosenfeld/js-modules) for splitting
+your spec "classes" in multiple files for better maintainance;
+- [Jasmine-jQuery](https://github.com/velesin/jasmine-jquery) for
+adding some useful matchers to Jasmine;
+- [jQuery BBQ](https://github.com/cowboy/jquery-bbq/):
+don't count on that. Currently it is there only to provide $.deparam,
+for helping testing params processed by plugins, like
+[jQuery form](http://jquery.malsup.com/form/). If you don't need
+it, just don't include it;
+- The [Rails Asset Pipeline](http://guides.rubyonrails.org/asset_pipeline.html).
+Yeah, sorry if you don't use Rails, but
+(this can still be helpful)[https://github.com/rosenfeld/jasmine_assets_enabler]
+for non-Rails applications. Just append this gem to that Gemfile (or replace
+rails\_sandbox\_jasmine by oojs).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'oojs'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+I intend to write an article about it soon.
+
+For now, you'll need to create your spec helper first:
+
+    rails g oojs:spec_helper
+
+Then, create some spec:
+
+    rails g oojs:spec shopping_cart
+
+Finally, run your specs:
+
+    rake sandbox_assets:serve
+
+And navigate to http://localhost:5000/ to see them passing.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/generators/oojs/spec/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Create a sample spec.
+
+Example:
+    rails generate oojs:spec shopping_cart
+
+    This will create:
+        spec/javascripts/shopping_cart_spec.js.coffee
+        spec/javascripts/shopping_cart/fake_server.js.coffee

data/lib/generators/oojs/spec/spec_generator.rb

@@ -0,0 +1,26 @@
+module Oojs
+  module Generators
+    class SpecGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+      argument :spec_name, :type => :string
+
+      def create_spec
+        template 'spec.js.coffee.erb', "spec/javascripts/#{file_name}_spec.js.coffee"
+      end
+
+      def create_fake_ajax_server
+        template 'fake_ajax_server.js.coffee.erb', "spec/javascripts/#{file_name}/fake_server.js.coffee"
+      end
+
+      private
+
+      def file_name
+        @file_name ||= spec_name.underscore
+      end
+
+      def class_name
+        @class_name ||= spec_name.camelize
+      end
+    end
+  end
+end

data/lib/generators/oojs/spec/templates/fake_ajax_server.js.coffee.erb

@@ -0,0 +1,26 @@
+# =require fake_ajax_server
+
+createProducts = -> [
+  {id: 1, name: 'One'}
+  {id: 2, name: 'Two'}
+]
+
+extendClass 'specs.<%= class_name %>Spec', ->
+  createFakeServer: ->
+    @fakeServer = new FakeAjaxServer (url, settings)->
+      if settings then settings.url = url else settings = url
+      handled = false
+      switch settings.dataType
+        when 'json' then switch settings.type
+          when 'get' then switch settings.url
+            when '/products' then handled = true; settings.success createProducts()
+#         when 'post' then switch settings.url
+#           when ...
+#       when undefined then switch settings.type
+#         when 'get' then switch settings.url
+#           when ...
+#         when 'post' then switch settings.url
+#           when ...
+      return if handled
+      console.log arguments
+      throw "Unexpected AJAX call: #{settings.url}"

data/lib/generators/oojs/spec/templates/spec.js.coffee.erb

@@ -0,0 +1,28 @@
+# =require spec_helper
+# =require_tree ./<%= file_name %>
+
+$ -> new specs.<%= class_name %>Spec
+extendClass 'specs.<%= class_name %>Spec', (spec)->
+  initialize: ->
+    @createFakeServer()
+    @describe()
+
+  describe: ->
+    describe '<%= class_name %>', =>
+      @beforeAll()
+      beforeEach @beforeEach
+      @runSpecs()
+      @afterAll()
+
+  beforeAll: ->
+    @fakeServer.start()
+
+  afterAll: ->
+    @fakeServer.stop()
+
+  beforeEach: =>
+    @fakeServer.ignoreAllRequests()
+
+  runSpecs: =>
+    it 'passes', =>
+      expect(@fakeServer).not.toBeUndefined()

data/lib/generators/oojs/spec_helper/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Create a sample spec helper.
+
+Example:
+    rails generate oojs:spec_helper
+
+    This will create:
+        spec/javascripts/spec_helper.js.coffee

data/lib/generators/oojs/spec_helper/spec_helper_generator.rb

@@ -0,0 +1,11 @@
+module Oojs
+  module Generators
+    class SpecHelperGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def create_spec_helper
+        copy_file 'spec_helper.js.coffee', 'spec/javascripts/spec_helper.js.coffee'
+      end
+    end
+  end
+end

data/lib/generators/oojs/spec_helper/templates/spec_helper.js.coffee

@@ -0,0 +1,8 @@
+# =require application
+# =require modules
+# =require jquery
+# =require jasmine-jquery
+# #require jquery.ba-bbq # uncomment for enabling $.deparam()
+#
+# Put your common spec code here.
+# Then put "# =require spec_helper" in your specs headers.

data/lib/oojs.rb

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

data/lib/oojs/version.rb

@@ -0,0 +1,3 @@
+module Oojs
+  VERSION = "0.0.1"
+end

data/oojs.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/oojs/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Rodrigo Rosenfeld Rosas"]
+  gem.email         = ["rr.rosas@gmail.com"]
+  gem.summary       = %q{Object-oriented JavaScript (or CoffeeScript) for Rails}
+  gem.description   = %q{This is a bundle of tools for helping you
+    to create well organized client-side
+    code to be run in browsers covered by tests (or specs) in an easy way.}
+  gem.homepage      = "http://github.com/rosenfeld/oojs"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "oojs"
+  gem.require_paths = ["lib"]
+  gem.version       = Oojs::VERSION
+
+  gem.add_dependency 'rails_sandbox_jasmine'
+  gem.add_dependency 'fake-ajax-server'
+end

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

@@ -0,0 +1,315 @@
+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();
+});