aa-rails4 0.6.0

data/spec/javascripts/coffeescripts/jquery.aa.table-checkbox-toggler-spec.js.coffee

@@ -0,0 +1,34 @@
+describe "AA.TableCheckboxToggler", ->
+  
+  beforeEach ->
+    loadFixtures('table_checkboxes.html');
+
+    @collection = $("#collection")
+    @toggle_all = @collection.find(".toggle_all")
+
+    @checkboxes = @collection.find(":checkbox").not(@toggle_all)
+    
+    new AA.TableCheckboxToggler({}, @collection)
+
+  describe "'selected' class for table row", ->
+    it "should add the class 'selected' to rows when their checkbox is checked ", ->
+      checkbox = $("#item_1")
+      checkbox.attr("checked", "checked")      
+      checkbox.trigger("change")
+
+      expect(checkbox.parents("tr")).toHaveAttr("class", "selected")
+
+    it "should remove the class 'selected' from rows when their checkbox is unchecked ", ->
+      checkbox = $("#item_1")
+      checkbox.trigger("change")
+
+      expect(checkbox.parents("tr")).not.toHaveAttr("class", "selected")
+
+  describe "clicking a cell", ->
+    it "should toggle the checkbox when a cell is clicked", ->
+      checkbox = $("#item_1")
+      row = checkbox.parents("td")
+      $(row).trigger("click")
+
+      expect(checkbox).toHaveAttr("checked", "checked")
+

data/spec/javascripts/compiled/jquery.aa.checkbox-toggler-spec.js

@@ -0,0 +1,60 @@
+(function() {
+
+  describe("AA.CheckboxToggler", function() {
+    beforeEach(function() {
+      loadFixtures('checkboxes.html');
+      this.collection = $("#collection");
+      this.toggle_all = this.collection.find(".toggle_all");
+      this.checkboxes = this.collection.find(":checkbox").not(this.toggle_all);
+      return new AA.CheckboxToggler({}, this.collection);
+    });
+    describe("on init", function() {
+      it("should raise an error if container not found", function() {
+        var _this = this;
+        return expect(function() {
+          return new AA.CheckboxToggler({});
+        }).toThrow("Container element not found");
+      });
+      return it("should raise an error if 'toggle all' checkbox not found", function() {
+        var _this = this;
+        this.toggle_all.remove();
+        return expect(function() {
+          return new AA.CheckboxToggler({}, _this.collection);
+        }).toThrow("'toggle all' checkbox not found");
+      });
+    });
+    describe("'toggle all' checkbox", function() {
+      it("should check all checkboxes when checked", function() {
+        this.toggle_all.trigger("click");
+        return expect(this.checkboxes).toHaveAttr("checked");
+      });
+      return it("should uncheck all checkboxes when unchecked", function() {
+        this.toggle_all.trigger("click");
+        this.toggle_all.trigger("click");
+        return expect(this.checkboxes).not.toHaveAttr("checked");
+      });
+    });
+    return describe("individual checkboxes", function() {
+      describe("when all checkboxes are selected and one is unchecked", function() {
+        beforeEach(function() {
+          this.collection.find(":checkbox").attr("checked", "checked");
+          return this.collection.find("#item_1").trigger("click");
+        });
+        return it("should uncheck the 'toggle all' checkbox", function() {
+          return expect(this.toggle_all).not.toHaveAttr("checked");
+        });
+      });
+      return describe("when the last checkbox is checked", function() {
+        beforeEach(function() {
+          this.checkboxes.attr("checked", "checked");
+          this.collection.find("#item_1").removeAttr("checked");
+          return this.collection.find("#item_1").trigger("click");
+        });
+        return it("should check the 'toggle all' checkbox", function() {
+          return expect(this.toggle_all).toHaveAttr("checked");
+        });
+      });
+    });
+  });
+
+}).call(this);

data/spec/javascripts/compiled/jquery.aa.popover-spec.js

@@ -0,0 +1,106 @@
+(function() {
+
+  describe("AA.Popover", function() {
+    var $button, $popover, $wrapper, popover;
+    $wrapper = void 0;
+    $button = void 0;
+    $popover = void 0;
+    popover = void 0;
+    beforeEach(function() {
+      $wrapper = $(inject({
+        id: "wrapper"
+      }));
+      $button = $(inject({
+        el: "a",
+        id: "my_popover_button",
+        attrs: {
+          href: "#my_popover"
+        }
+      }));
+      $popover = $(inject({
+        id: "my_popover"
+      }));
+      $button.popover({
+        fadeInDuration: 0,
+        fadeOutDuration: 0
+      });
+      return popover = $button.data("popover");
+    });
+    describe("opening button / link is pressed", function() {
+      return it("should open the popover", function() {
+        $button.trigger("click");
+        return expect($("#my_popover")).toBeVisible();
+      });
+    });
+    describe("when initiated", function() {
+      it("should be hidden", function() {
+        return expect($popover).toBeHidden();
+      });
+      it("should be have class popover", function() {
+        return expect($popover).toHaveClass("popover");
+      });
+      return describe("nipple", function() {
+        return it("should exist", function() {
+          return expect($popover).toContain(".popover_nipple");
+        });
+      });
+    });
+    describe("when open is called", function() {
+      beforeEach(function() {
+        expect($popover).toBeHidden();
+        return $button.popover("open");
+      });
+      return it("should be open", function() {
+        return expect($popover).toBeVisible();
+      });
+    });
+    describe("when destroy is called", function() {
+      beforeEach(function() {
+        return $button.popover("destroy");
+      });
+      it("should not have popover stored as a data attr", function() {
+        return expect($button.data("popover")).toEqual(undefined);
+      });
+      return it("should not be bound to any event listeners", function() {
+        return expect($button.data("events")).toEqual(undefined);
+      });
+    });
+    describe("when it's already open", function() {
+      beforeEach(function() {
+        return $button.popover("open");
+      });
+      describe("when close is called", function() {
+        beforeEach(function() {
+          return $button.popover("close");
+        });
+        return it("should close", function() {
+          return expect($popover).toBeHidden();
+        });
+      });
+      return describe("when user clicks outside", function() {
+        beforeEach(function() {
+          $button.popover("open");
+          return $("#wrapper").trigger("click");
+        });
+        return it("should close", function() {
+          return expect($popover).toBeHidden();
+        });
+      });
+    });
+    return describe("options", function() {
+      return describe("autoOpen set to false", function() {
+        beforeEach(function() {
+          $button.popover("destroy");
+          return $button.popover({
+            autoOpen: false
+          });
+        });
+        return it("should not open when the link is clicked", function() {
+          $button.trigger("click");
+          return expect($("#my_popover")).toBeHidden();
+        });
+      });
+    });
+  });
+
+}).call(this);

data/spec/javascripts/compiled/jquery.aa.table-checkbox-toggler-spec.js

@@ -0,0 +1,37 @@
+(function() {
+
+  describe("AA.TableCheckboxToggler", function() {
+    beforeEach(function() {
+      loadFixtures('table_checkboxes.html');
+      this.collection = $("#collection");
+      this.toggle_all = this.collection.find(".toggle_all");
+      this.checkboxes = this.collection.find(":checkbox").not(this.toggle_all);
+      return new AA.TableCheckboxToggler({}, this.collection);
+    });
+    describe("'selected' class for table row", function() {
+      it("should add the class 'selected' to rows when their checkbox is checked ", function() {
+        var checkbox;
+        checkbox = $("#item_1");
+        checkbox.attr("checked", "checked");
+        checkbox.trigger("change");
+        return expect(checkbox.parents("tr")).toHaveAttr("class", "selected");
+      });
+      return it("should remove the class 'selected' from rows when their checkbox is unchecked ", function() {
+        var checkbox;
+        checkbox = $("#item_1");
+        checkbox.trigger("change");
+        return expect(checkbox.parents("tr")).not.toHaveAttr("class", "selected");
+      });
+    });
+    return describe("clicking a cell", function() {
+      return it("should toggle the checkbox when a cell is clicked", function() {
+        var checkbox, row;
+        checkbox = $("#item_1");
+        row = checkbox.parents("td");
+        $(row).trigger("click");
+        return expect(checkbox).toHaveAttr("checked", "checked");
+      });
+    });
+  });
+
+}).call(this);

data/spec/javascripts/fixtures/checkboxes.html

@@ -0,0 +1,9 @@
+<div id="collection">
+  <input type="checkbox" name="toggle_all" class="toggle_all" value="">
+
+  <input type="checkbox" name="item1" id="item_1" value="1">
+  <input type="checkbox" name="item2" id="item_2" value="2">
+  <input type="checkbox" name="item3" id="item_3" value="3">
+  <input type="checkbox" name="item4" id="item_4" value="4">
+</div>
+

data/spec/javascripts/fixtures/table_checkboxes.html

@@ -0,0 +1,17 @@
+<table id="collection">
+  <thead>
+    <tr>
+      <td>
+        <input type="checkbox" name="toggle_all" class="toggle_all" value="">
+      </td>
+    </tr>
+  </thead>
+  <tbody>
+    <tr><td><input type="checkbox" name="item1" id="item_1" value="1"></td></tr>
+    <tr><td><input type="checkbox" name="item2" id="item_2" value="2"></td></tr>
+    <tr><td><input type="checkbox" name="item3" id="item_3" value="3"></td></tr>
+    <tr><td><input type="checkbox" name="item4" id="item_4" value="4"></td></tr>
+  </tbody>
+</table>
+
+

data/spec/javascripts/helpers/SpecHelper.js

@@ -0,0 +1,3 @@
+beforeEach(function() {
+  window.inject = $.jasmine.inject;
+});

data/spec/javascripts/helpers/vendor/jasmine-fixture-0.0.5.js

@@ -0,0 +1,108 @@
+/* jasmine-fixture Makes injecting HTML snippets into the DOM easy & clean!
+ *  site: https://github.com/searls/jasmine-fixture   */
+(function($){
+  var originalJasmineFixture = window.jasmineFixture,
+      defaultConfiguration = {
+        el:'div',
+        cssClass:'',
+        id:'',
+        text: '',
+        html: '',
+        defaultAttribute: 'class',
+        attrs: {}
+      };
+
+  window.jasmineFixture = function($) {
+    var isReady = false,
+        rootId  = 'specContainer',
+        defaults = $.extend({},defaultConfiguration);
+
+    $.jasmine = {
+      inject: function(arg,context) {
+        if(isReady !== true) init();
+        var parent = context ? context : $('#'+rootId),
+            $toInject;
+        if(itLooksLikeHtml(arg)) {
+          $toInject = $(arg);
+        } else {
+          var config = $.extend({},defaults,arg,{ userString: arg });
+          $toInject = $('<'+config.el+'></'+config.el+'>');
+          applyAttributes($toInject,config);
+          injectContents($toInject,config);
+        }
+        return $toInject.appendTo(parent);
+      },
+      configure: function(config) {
+        $.extend(defaults,config);
+      },
+      restoreDefaults: function(){
+        defaults = $.extend({},defaultConfiguration);
+      },
+      noConflict: function() {
+        window.jasmineFixture = originalJasmineFixture;
+        return this;
+      }
+    };
+
+    $.fn.inject = function(html){
+      return $.jasmine.inject(html,$(this));
+    };
+
+    var applyAttributes = function($html,config) {
+      var attrs = $.extend({},{
+        id: config.id,
+        'class': config['class'] || config.cssClass
+      }, config.attrs);
+      if(isString(config.userString)) {
+        attrs[config.defaultAttribute] = config.userString;
+      }
+      for(var key in attrs) {
+        if(attrs[key]) {
+          $html.attr(key,attrs[key]);
+        }
+      }
+    };
+
+    var injectContents = function($el,config){
+      if(config.text && config.html) {
+        throw "Error: because they conflict, you may only configure inject() to set `html` or `text`, not both! \n\nHTML was: "+config.html+" \n\n Text was: "+config.text
+      } else if(config.text) {
+        $el.text(config.text);
+      } else if(config.html) {
+        $el.html(config.html);
+      }
+    }
+
+    var itLooksLikeHtml = function(arg) {
+      return isString(arg) && arg.indexOf('<') !== -1
+    };
+
+    var isString = function(arg) {
+      return arg && arg.constructor === String;
+    };
+
+    var init = function() {
+      $('body').append('<div id="'+rootId+'"></div>');
+      isReady = true;
+    };
+
+    var tidyUp = function() {
+      $('#'+rootId).remove();
+      isReady = false;
+    };
+
+    $(function(jQuery){
+      init();
+    });
+    afterEach(function(){
+      tidyUp();
+    });
+
+    return $.jasmine;
+  };
+
+  if(jQuery) {
+    var jasmineFixture = window.jasmineFixture(jQuery);
+    window.inject = window.inject || jasmineFixture.inject;
+  }
+})(jQuery);

data/spec/javascripts/helpers/vendor/jasmine-jquery.js

@@ -0,0 +1,288 @@
+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 self = this;
+  var url = this.fixturesPath.match('/$') ? this.fixturesPath + relativeUrl : this.fixturesPath + '/' + relativeUrl;
+  jQuery.ajax({
+    async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
+    cache: false,
+    dataType: 'html',
+    url: url,
+    success: function(data) {
+      self.fixturesCache_[relativeUrl] = data;
+    },
+    error: function(jqXHR, status, errorThrown) {
+        throw Error('Fixture could not be loaded: ' + url + ' (status: ' + status + ', message: ' + errorThrown.message + ')');
+    }
+  });
+};
+
+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) {
+  return jQuery('<div />').append(element.clone()).html();
+};
+
+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]]);
+    },
+
+    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 this.actual.size() > 0;
+    },
+
+    toHaveAttr: function(attributeName, expectedAttributeValue) {
+      return hasProperty(this.actual.attr(attributeName), expectedAttributeValue);
+    },
+
+    toHaveId: function(id) {
+      return this.actual.attr('id') == id;
+    },
+
+    toHaveHtml: function(html) {
+      return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html);
+    },
+
+    toHaveText: function(text) {
+      if (text && jQuery.isFunction(text.test)) {
+        return text.test(this.actual.text());
+      } else {
+        return this.actual.text() == 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).size() > 0;
+    },
+
+    toBeDisabled: function(selector){
+      return this.actual.is(':disabled');
+    },
+
+    // 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 instanceof jQuery) {
+        var result = jQueryMatchers[methodName].apply(this, arguments);
+        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);
+    }
+  })
+});
+
+afterEach(function() {
+  jasmine.getFixtures().cleanUp();
+  jasmine.JQuery.events.cleanUp();
+});