marionette-modal 1.0.0.8

data/test/spec/backbone.modal.spec.js

@@ -0,0 +1,224 @@
+(function() {
+  var __hasProp = {}.hasOwnProperty,
+    __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+  describe('Backbone.Modal', function() {
+    var modal;
+    modal = {};
+    beforeEach(function() {
+      var backboneView, _ref, _ref1;
+      backboneView = (function(_super) {
+        __extends(backboneView, _super);
+
+        function backboneView() {
+          _ref = backboneView.__super__.constructor.apply(this, arguments);
+          return _ref;
+        }
+
+        return backboneView;
+
+      })(Backbone.View);
+      return modal = (function(_super) {
+        __extends(modal, _super);
+
+        function modal() {
+          _ref1 = modal.__super__.constructor.apply(this, arguments);
+          return _ref1;
+        }
+
+        modal.prototype.viewContainer = 'div';
+
+        modal.prototype.cancelEl = '.close';
+
+        modal.prototype.submitEl = '.submit';
+
+        modal.prototype.template = function() {
+          return '<a class="class"></a><a id="id"></a><div></div><a data-event="true"></a><a class="close"></a><a class="submit"></a>';
+        };
+
+        modal.prototype.views = {
+          'click .class': {
+            view: new backboneView
+          },
+          'click #id': {
+            view: function() {
+              return '<p>html</p>';
+            }
+          },
+          'click [data-event]': {
+            view: function() {
+              return new Backbone.View({
+                option: true
+              });
+            }
+          }
+        };
+
+        modal.prototype._shouldCancel = true;
+
+        modal.prototype._shouldSubmit = true;
+
+        modal.prototype.beforeCancel = function() {
+          return this._shouldCancel;
+        };
+
+        modal.prototype.beforeSubmit = function() {
+          return this._shouldSubmit;
+        };
+
+        modal.prototype.cancel = function() {};
+
+        modal.prototype.submit = function() {};
+
+        return modal;
+
+      })(Backbone.Modal);
+    });
+    afterEach(function() {
+      return modal = {};
+    });
+    it("should have Backbone defined", function() {
+      return expect(Backbone).toBeDefined();
+    });
+    it('should throw an exception if there is no template or views present', function() {
+      delete modal.prototype.views;
+      delete modal.prototype.template;
+      return expect(function() {
+        return new modal();
+      }).toThrow();
+    });
+    it('should throw an exception if a template and views are defined and no viewContainer is present', function() {
+      delete modal.prototype.viewContainer;
+      return expect(function() {
+        return new modal;
+      }).toThrow();
+    });
+    describe('views:', function() {
+      var view;
+      view = {};
+      beforeEach(function() {
+        return view = new modal();
+      });
+      it('should trigger the first view when rendered', function() {
+        spyOn(view, 'triggerView');
+        view.render();
+        return expect(view.triggerView).toHaveBeenCalled();
+      });
+      it("#buildView: checks if it's a Backbone.View or just a HTML template that is passed along", function() {
+        var key, v, _results;
+        _results = [];
+        for (key in view.views) {
+          v = view.buildView(view.views[key].view);
+          if (_.isFunction(v)) {
+            _results.push(expect(_.isString(v.render().el)));
+          } else {
+            _results.push(expect(_.isString(v)));
+          }
+        }
+        return _results;
+      });
+      return it("#length should return the length of the total views", function() {
+        return expect(view.views.length).toEqual(3);
+      });
+    });
+    describe('#openAt', function() {
+      return it('opens a view at the specified index', function() {
+        var view;
+        view = new modal();
+        view.openAt(1);
+        return expect(view.currentIndex).toBe(1);
+      });
+    });
+    describe('#next', function() {
+      return it('should open the next view', function() {
+        var view;
+        view = new modal();
+        view.render().next();
+        return expect(view.currentIndex).toBe(1);
+      });
+    });
+    describe('#previous', function() {
+      return it('should open the previous view', function() {
+        var view;
+        view = new modal();
+        view.render().openAt(2).previous();
+        return expect(view.currentIndex).toBe(1);
+      });
+    });
+    describe('#currentIndex', function() {
+      return it('should return the index of the current view', function() {
+        var view;
+        view = new modal();
+        view.render().openAt(2);
+        return expect(view.currentIndex).toBe(2);
+      });
+    });
+    describe('#render', function() {
+      return it('renders the modal and internal views', function() {
+        var view;
+        view = new modal();
+        return expect(_.isString(view.render().el));
+      });
+    });
+    describe('#beforeCancel', function() {
+      it("should call this method when it's defined", function() {
+        var view;
+        view = new modal();
+        spyOn(view, 'beforeCancel');
+        view.render().triggerCancel();
+        return expect(view.beforeCancel).toHaveBeenCalled();
+      });
+      return it('stops the cancel when it returns false', function() {
+        var view;
+        view = new modal();
+        spyOn(view, 'close');
+        view._shouldCancel = false;
+        view.render().triggerCancel();
+        return expect(view.close.calls.length).toEqual(0);
+      });
+    });
+    describe('#cancel', function() {
+      return it('should be called when cancelEl is triggered', function() {
+        var view;
+        view = new modal();
+        spyOn(view, 'cancel');
+        view.render().$(view.cancelEl).click();
+        return expect(view.cancel.calls.length).toEqual(1);
+      });
+    });
+    describe('#beforeSubmit', function() {
+      it("should call this method when it's defined", function() {
+        var view;
+        view = new modal();
+        spyOn(view, 'beforeSubmit');
+        view.render().triggerSubmit({
+          preventDefault: function() {}
+        });
+        return expect(view.beforeSubmit).toHaveBeenCalled();
+      });
+      return it('stops the submit when it returns false', function() {
+        var view;
+        view = new modal();
+        spyOn(view, 'submit');
+        view._shouldSubmit = false;
+        view.render().triggerSubmit({
+          preventDefault: function() {}
+        });
+        return expect(view.submit.calls.length).toEqual(0);
+      });
+    });
+    describe('#submit', function() {
+      return it('should be called when submitEl is triggered', function() {
+        var view;
+        view = new modal();
+        spyOn(view, 'submit');
+        view.render().$(view.submitEl).click();
+        return expect(view.submit.calls.length).toEqual(1);
+      });
+    });
+    return describe('#animate', function() {
+      return it('should do all the animation work', function() {});
+    });
+  });
+
+}).call(this);

data/test/spec.html

@@ -0,0 +1,41 @@
+<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>Jasmine Spec Runner</title>
+
+  <link rel="stylesheet" type="text/css" href=".grunt/grunt-contrib-jasmine/jasmine.css">
+
+
+  
+  <script src="./.grunt/grunt-contrib-jasmine/jasmine.js"></script>
+  
+  <script src="./.grunt/grunt-contrib-jasmine/jasmine-html.js"></script>
+  
+  <script src="./examples/vendor/jquery-1.9.1.js"></script>
+  
+  <script src="./examples/vendor/underscore.js"></script>
+  
+  <script src="./examples/vendor/backbone.js"></script>
+  
+  <script src="./examples/vendor/marionette.js"></script>
+  
+  <script src="./dist/backbone.modal.js"></script>
+  
+  <script src="./dist/marionette.modal.js"></script>
+  
+  <script src="./dist/backbone.marionette.modals.js"></script>
+  
+  <script src="./test/spec/backbone.marionette.modals.spec.js"></script>
+  
+  <script src="./test/spec/backbone.modal.spec.js"></script>
+  
+  <script src="./.grunt/grunt-contrib-jasmine/reporter.js"></script>
+  
+  <script src="./.grunt/grunt-contrib-jasmine/jasmine-helper.js"></script>
+  
+
+</head>
+<body>
+</body>
+</html>

data/test/src/backbone.marionette.modals.spec.coffee

@@ -0,0 +1,56 @@
+describe 'Backbone.Marionette.Modals', ->
+
+  myLayout  = {}
+
+  class layout extends Backbone.Marionette.Layout
+    template: -> '<div id="modals"></div>'
+    regions:
+      modals:
+        selector:     '#modals'
+        regionType:    Backbone.Marionette.Modals
+
+  class BackboneModal extends Backbone.Modal
+    viewContainer: 'div'
+    cancelEl: '.close'
+    submitEl: '.submit'
+    template: -> '<a id="id"></a><div></div><a class="close"></a><a class="submit"></a>'
+    views:
+      'click #id':
+        view: -> '<p>html</p>'
+    cancel: ->
+    submit: ->
+
+  class MarionetteModal extends Marionette.Modal
+    viewContainer: 'div'
+    cancelEl: '.close'
+    submitEl: '.submit'
+    template: -> '<a id="id"></a><div></div><a class="close"></a><a class="submit"></a>'
+    views:
+      'click #id':
+        view: -> '<p>html</p>'
+    cancel: ->
+    submit: ->
+
+  myLayout = new layout()
+
+  describe '#show', ->
+    it 'should stack a modal view', ->
+      myLayout.modals.show(new modal())
+      expect(myLayout.modals.zIndex).toBe(1)
+
+    it 'should disable modals with zIndex < modal', ->
+
+  describe '#close', ->
+    it 'should only close the last modal', ->
+      myLayout.modals.close()
+      expect(myLayout.modals.zIndex).toBe(0)
+
+    it 'should enable the last modal', ->
+
+  describe '#closeAll', ->
+    it 'should close all the modals', ->
+      myLayout.modals.show(new modal())
+      myLayout.modals.closeAll()
+      expect(myLayout.modals.modals.length).toBe(0)
+
+

data/test/src/backbone.modal.spec.coffee

@@ -0,0 +1,139 @@
+describe 'Backbone.Modal', ->
+  modal = {}
+
+  beforeEach ->
+    class backboneView extends Backbone.View
+
+    class modal extends Backbone.Modal
+      viewContainer: 'div'
+      cancelEl: '.close'
+      submitEl: '.submit'
+      template: -> '<a class="class"></a><a id="id"></a><div></div><a data-event="true"></a><a class="close"></a><a class="submit"></a>'
+      views:
+        'click .class':
+          view: new backboneView
+        'click #id':
+          view: -> '<p>html</p>'
+        'click [data-event]':
+          view: -> new Backbone.View(option: true)
+
+      _shouldCancel: true
+      _shouldSubmit: true
+      beforeCancel: -> @_shouldCancel
+      beforeSubmit: -> @_shouldSubmit
+      cancel: ->
+      submit: ->
+
+  afterEach ->
+    modal = {}
+
+  it "should have Backbone defined", ->
+    expect(Backbone).toBeDefined()
+
+  it 'should throw an exception if there is no template or views present', ->
+    delete modal::views
+    delete modal::template
+
+    expect(-> new modal()).toThrow()
+
+  it 'should throw an exception if a template and views are defined and no viewContainer is present', ->
+    delete modal::viewContainer
+
+    expect(-> new modal).toThrow()
+
+  describe 'views:', ->
+    view = {}
+
+    beforeEach ->
+      view = new modal()
+
+    it 'should trigger the first view when rendered', ->
+      spyOn(view, 'triggerView')
+      view.render()
+
+      expect(view.triggerView).toHaveBeenCalled()
+
+    it "#buildView: checks if it's a Backbone.View or just a HTML template that is passed along", ->
+      for key of view.views
+        v = view.buildView(view.views[key].view)
+        if _.isFunction(v)
+          expect(_.isString(v.render().el))
+        else
+          expect(_.isString(v))
+
+    it "#length should return the length of the total views", ->
+      expect(view.views.length).toEqual(3)
+
+  describe '#openAt', ->
+    it 'opens a view at the specified index', ->
+      view = new modal()
+      view.openAt(1)
+      expect(view.currentIndex).toBe(1)
+
+  describe '#next', ->
+    it 'should open the next view', ->
+      view = new modal()
+      view.render().next()
+      expect(view.currentIndex).toBe(1)
+
+  describe '#previous', ->
+    it 'should open the previous view', ->
+      view = new modal()
+      view.render().openAt(2).previous()
+      expect(view.currentIndex).toBe(1)
+
+  describe '#currentIndex', ->
+    it 'should return the index of the current view', ->
+      view = new modal()
+      view.render().openAt(2)
+      expect(view.currentIndex).toBe(2)
+
+  describe '#render', ->
+    it 'renders the modal and internal views', ->
+      view = new modal()
+      expect(_.isString(view.render().el))
+
+  describe '#beforeCancel', ->
+    it "should call this method when it's defined", ->
+      view = new modal()
+      spyOn(view, 'beforeCancel')
+      view.render().triggerCancel()
+      expect(view.beforeCancel).toHaveBeenCalled()
+
+    it 'stops the cancel when it returns false', ->
+      view = new modal()
+      spyOn(view, 'close')
+      view._shouldCancel = false
+      view.render().triggerCancel()
+      expect(view.close.calls.length).toEqual(0)
+
+  describe '#cancel', ->
+    it 'should be called when cancelEl is triggered', ->
+      view = new modal()
+      spyOn(view, 'cancel')
+      view.render().$(view.cancelEl).click()
+      expect(view.cancel.calls.length).toEqual(1)
+
+  describe '#beforeSubmit', ->
+    it "should call this method when it's defined", ->
+      view = new modal()
+      spyOn(view, 'beforeSubmit')
+      view.render().triggerSubmit({preventDefault: ->})
+      expect(view.beforeSubmit).toHaveBeenCalled()
+
+    it 'stops the submit when it returns false', ->
+      view = new modal()
+      spyOn(view, 'submit')
+      view._shouldSubmit = false
+      view.render().triggerSubmit({preventDefault: ->})
+      expect(view.submit.calls.length).toEqual(0)
+
+  describe '#submit', ->
+    it 'should be called when submitEl is triggered', ->
+      view = new modal()
+      spyOn(view, 'submit')
+      view.render().$(view.submitEl).click()
+      expect(view.submit.calls.length).toEqual(1)
+
+  describe '#animate', ->
+    it 'should do all the animation work', ->

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: marionette-modal
+version: !ruby/object:Gem::Version
+  version: 1.0.0.8
+platform: ruby
+authors:
+- Jared Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fork of Backbone.Modal Backbone.js plugin
+email:
+- jcsmith1859@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gruntfile.coffee
+- LICENSE
+- README.md
+- Rakefile
+- dist/backbone.marionette.modals-min.js
+- dist/backbone.marionette.modals.js
+- dist/backbone.modal-min.js
+- dist/backbone.modal.js
+- dist/marionette.modal-bundled-min.js
+- dist/marionette.modal-bundled.js
+- dist/marionette.modal-min.js
+- dist/marionette.modal.css
+- dist/marionette.modal.js
+- dist/marionette.modal.theme.css
+- examples/1_single_view.html
+- examples/2_tab_based.html
+- examples/3_stacked_modal_with_marionette.html
+- examples/4_wizard.html
+- examples/css/style.css
+- examples/img/tab-icons.png
+- examples/style.css
+- examples/vendor/backbone.js
+- examples/vendor/backbone.marionette.modals.js
+- examples/vendor/backbone.modal.css
+- examples/vendor/backbone.modal.js
+- examples/vendor/backbone.modal.theme.css
+- examples/vendor/jquery-1.9.1.js
+- examples/vendor/marionette.js
+- examples/vendor/marionette.modal.css
+- examples/vendor/marionette.modal.js
+- examples/vendor/marionette.modal.theme.css
+- examples/vendor/underscore.js
+- lib/marionette-modal.rb
+- lib/marionette-modal/version.rb
+- marionette-modal.gemspec
+- package.json
+- src/backbone.marionette.modals.coffee
+- src/backbone.modal.coffee
+- src/marionette.modal.coffee
+- src/marionette.modal.sass
+- src/marionette.modal.theme.sass
+- src/style.sass
+- test/spec.html
+- test/spec/backbone.marionette.modals.spec.js
+- test/spec/backbone.modal.spec.js
+- test/src/backbone.marionette.modals.spec.coffee
+- test/src/backbone.modal.spec.coffee
+homepage: https://github.com/Outcome-Engenuity/marionette-modal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.10
+signing_key: 
+specification_version: 4
+summary: Fork of the Backbone.Modal Backbone.js plugin that is more tightly integrated
+  with Marionette.js
+test_files:
+- test/spec.html
+- test/spec/backbone.marionette.modals.spec.js
+- test/spec/backbone.modal.spec.js
+- test/src/backbone.marionette.modals.spec.coffee
+- test/src/backbone.modal.spec.coffee
+has_rdoc: