cartilage 0.1.1

data/test/dummy/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/test/framework/cartilage/application_test.js.coffee

@@ -0,0 +1,14 @@
+
+module "Cartilage.Application"
+
+test "should initialize and launch application", ->
+  class TestApplication extends Cartilage.Application
+    initialize: ->
+      new Backbone.Router
+        routes:
+          "": "showMainView"
+        showMainView: ->
+          "mainView"
+      Backbone.history.start({ pushState: true })
+  TestApplication.launch()
+  ok not _.isNull(TestApplication.sharedInstance), "sharedInstance should not be null"

data/test/framework/cartilage/views/bar_segment_view_test.js.coffee

@@ -0,0 +1,5 @@
+
+module "Cartilage.Views.BarSegmentView"
+
+test "Should Implement Tests", ->
+  ok(false, "No Tests!")

data/test/framework/cartilage/views/bar_view_test.js.coffee

@@ -0,0 +1,30 @@
+
+module "Cartilage.Views.BarView"
+
+  setup: ->
+    @testView = new Cartilage.Views.BarView
+      segments: new Cartilage.Collections.Segments([
+        new Cartilage.Models.Segment({ maximum: 20  }),
+        new Cartilage.Models.Segment({ maximum: 40  }),
+        new Cartilage.Models.Segment({ maximum: 60  }),
+        new Cartilage.Models.Segment({ maximum: 80  }),
+        new Cartilage.Models.Segment({ maximum: 100 })
+      ])
+      value: 54
+
+    @testView.prepare()
+
+test "should calculate correct widths", 5, ->
+
+  _.each(@testView.subviews, (subview) ->
+    # treat 0.19999999999999996 as 0.20
+    equal subview.width.toFixed(2), 0.20, "correct width"
+  )
+
+test "should calculate correct fillWidths", 5, ->
+
+  equal @testView.subviews[0].fillWidth, 1,  "correct fillWidth"
+  equal @testView.subviews[1].fillWidth, 1,  "correct fillWidth"
+  equal @testView.subviews[2].fillWidth, 0.7,"correct fillWidth" # 70% (14/20)of 3rd segment
+  equal @testView.subviews[3].fillWidth, 0,  "correct fillWidth"
+  equal @testView.subviews[4].fillWidth, 0,  "correct fillWidth"

data/test/framework/cartilage/views/image_view_test.js.coffee

@@ -0,0 +1,27 @@
+module "Cartilage.Views.ImageView"
+  setup: ->
+    @imageView = new Cartilage.Views.ImageView
+
+test "isLoaded property should be read-only", 1, ->
+  @imageView.isLoaded = true
+  ok @imageView.isLoaded == false, "isLoaded should be false"
+
+test "isError property should be read-only", 1, ->
+  @imageView.isError = true
+  ok @imageView.isError == false, "isError should be false"
+  
+asyncTest "should fire load event upon successful load", 1, ->
+  @imageView.on "load", ->
+    ok true, 'load called'
+    start()
+
+  @imageView.imageAddress = "http://www.placehold.it/500x500"
+  $('#testElement').html @imageView.render().el 
+
+asyncTest "should fire error event upon unsuccessful load attempt", 1, ->
+  @imageView.on "error", ->
+    ok true, 'error called'
+    start()
+
+  @imageView.imageAddress = '404'
+  $('#testElement').html @imageView.render().el 

data/test/framework/cartilage/views/list_view_item_test.js.coffee

@@ -0,0 +1,17 @@
+
+module "Cartilage.Views.ListViewItem"
+
+  setup: ->
+    @testCollection = new Backbone.Collection([ {id: 1, name: "one"}, 
+                                              {id: 2, name: "two"}, 
+                                              {id: 3, name: "three"} ],
+                                              model: Backbone.Model)
+
+    @testListView = new Cartilage.Views.ListView
+      collection: @testCollection
+      allowsDragToReorder: yes
+
+test "should contain data-model-id on list items", 3, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el 
+  _.each([1,2,3], (itemId) => ok $("*[data-model-id='" + itemId + "']").length > 0)

data/test/framework/cartilage/views/list_view_test.js.coffee

@@ -0,0 +1,190 @@
+module "Cartilage.Views.BasicListView"
+  setup: ->
+    @testCollection = new Backbone.Collection([ {id: 1, name: "one"}, 
+                                              {id: 2, name: "two"}, 
+                                              {id: 3, name: "three"} ],
+                                              model: Backbone.Model)
+
+    @testListView = new Cartilage.Views.ListView
+      collection: @testCollection
+
+test "should render collection correctly", 3, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el 
+  ok $('.list-view').length, "ListView container was created."
+  equal $('.list-view-items-container > li').length, 3, "testListView should have 3 items."
+  equal @testListView.selected.length, 0, "testListView should have 0 selected items."
+
+test "should add an item to the list view", 3, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el
+  ok $('.list-view').length, "ListView container was created."
+  equal $('.list-view-items-container > li').length, 3, "testListView should have 3 items."
+  @testCollection.add({id: 4, name: "four"})
+  equal $('.list-view-items-container > li').length, 4, "testListView should now have 4 items."
+
+test "should remove an item from the list view", 3, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el
+  ok $('.list-view').length, "ListView container was created."
+  equal $('.list-view-items-container > li').length, 3, "testListView should have 3 items."
+  @testCollection.remove(@testCollection.get(3))
+  equal $('.list-view-items-container > li').length, 2, "testListView should now have 2 items."
+
+asyncTest "should trigger select event for single-select ListView", 1, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el 
+  
+  @testListView.on "select", ->
+    ok true, "Select event should have been triggered."
+    start()
+  @testListView.selectFirst()
+
+asyncTest "should trigger deselect event for single-select ListView", 1, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el 
+  
+  @testListView.on "deselect", ->
+    ok true, "Deselect event should have been triggered."
+    start()
+  @testListView.selectFirst()
+  @testListView.deselect($('.list-view > ul.list-view-items-container > li').first())
+
+module "Cartilage.Views.ListView.AllowsMultipleSelection"
+  setup: ->
+    @testListView = null
+    testCollection = new Backbone.Collection([ {id: 1, name: "one"}, 
+                                              {id: 2, name: "two"}, 
+                                              {id: 3, name: "three"} ],
+                                              model: Backbone.Model)
+
+    @testListView = new Cartilage.Views.ListView
+      collection: testCollection
+      allowsMultipleSelection: yes
+
+asyncTest "should trigger add event on @selected collection for multi-select ListView", 2, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el 
+  
+  @testListView.selected.on "add", ->
+    ok true, "add was called on multi-select"
+    start()
+
+  @testListView.selectFirst() #select($('.list-view > ul.list-view-items-container > li').first())
+  equal @testListView.selected.length, 1, "One element should have been selected"
+
+asyncTest "should trigger remove event on @selected collection for multi-select ListView", 3, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el 
+  
+  @testListView.selected.on "remove", ->
+    ok true, "remove was called on multi-select"
+    start()
+
+  @testListView.select($('.list-view > ul.list-view-items-container > li').first())
+  @testListView.selectAnother($('.list-view > ul.list-view-items-container > li').last())
+  equal @testListView.selected.length, 2, "Two elements should have been selected"
+  @testListView.deselect($('.list-view > ul.list-view-items-container > li').first())
+  equal @testListView.selected.length, 1, "Only one element should have been selected after deselect"
+
+asyncTest "should trigger reset event on @selected collection for multi-select ListView", 3, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el 
+  
+  @testListView.selected.on "reset", =>
+    ok true, "reset was called"
+    start()
+
+  @testListView.select($('.list-view > ul.list-view-items-container > li').first())
+  @testListView.selectAnother($('.list-view > ul.list-view-items-container > li').last())
+  equal @testListView.selected.length, 2, "Two elements should have been selected"
+  @testListView.clearSelection()
+  equal @testListView.selected.length, 0, "No elements should have been selected"
+
+test "should keep selected items collection in the same order as collection passed to the view", 5, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el
+  
+  @testListView.select($('.list-view > ul.list-view-items-container > li').first())
+  @testListView.selectAnother($('.list-view > ul.list-view-items-container > li').last())
+
+  equal @testListView.collection.at(0), @testListView.selected.at(0)
+  equal @testListView.collection.at(2), @testListView.selected.at(1)
+
+  @testListView.selectAnother($('.list-view > ul.list-view-items-container > li')[1])
+
+  equal @testListView.collection.at(0), @testListView.selected.at(0)
+  equal @testListView.collection.at(1), @testListView.selected.at(1)
+  equal @testListView.collection.at(2), @testListView.selected.at(2)
+
+module "Cartilage.Views.ListView.Ordered"
+  setup: ->
+    @testListView = null
+    @testCollection = new Backbone.Collection(  [], 
+                                                model: Backbone.Model,
+                                                comparator: (item) -> item.get("name")
+                                            )
+    @testListView = new Cartilage.Views.ListView
+      collection: @testCollection
+      ordered: yes
+
+test "should render items inserted into the collection in the proper order on the screen", 9, ->
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el
+  equal $('#testElement li').length, 0, "No elements should have been rendered"
+  @testCollection.add({id: "charlie", name: "charlie"})
+  equal $('#testElement li').length, 1, "One element should have been rendered"
+  @testCollection.add({id: "alpha", name: "alpha"})
+  equal $('#testElement li').length, 2, "Two elements should have been rendered"
+  equal $('#testElement li').first().data('model'), @testCollection.get("alpha"), "alpha should have been rendered first"
+  equal $('#testElement li').last().data('model'), @testCollection.get("charlie"), "charlie should have been rendered last"
+  @testCollection.add({id: "bravo", name: "bravo"})
+  equal $('#testElement li').length, 3, "Three elements should have been rendered"
+  equal $('#testElement li').first().data('model'), @testCollection.get("alpha"), "alpha should have been rendered first"
+  equal $('#testElement li').eq(1).data('model'), @testCollection.get("bravo"), "bravo should have been rendered second"
+  equal $('#testElement li').last().data('model'), @testCollection.get("charlie"), "charlie should have been rendered last"
+
+test "should render removed items back into the proper position", 4, ->
+  @testCollection.add([{id: "alpha", name: "alpha"}, {id: "bravo", name: "bravo"}, {id: "charlie", name: "charlie"}])
+  @testListView.prepare()
+  $('#testElement').html @testListView.render().el
+  equal $('#testElement li').length, 3, "Three elements should have been rendered"
+  @bravo = @testCollection.get("bravo")
+  @testCollection.remove(@bravo)
+  equal $('#testElement li').length, 2, "Two elements should have been rendered"
+  @testCollection.add(@bravo)
+  equal $('#testElement li').length, 3, "Three elements should have been rendered"
+  equal $('#testElement li').eq(1).data('model'), @testCollection.get("bravo"), "bravo should have been reinserted second"
+
+
+# This is how I'd like to test to make sure clicks get passed through to links contained
+# in the ListViewItem, but there's no way to simulate a click at coordinates in pure JS.
+#
+# module "Cartilage.Views.ListView.SelectionDisabled"
+#   setup: ->
+#     @testListView = null
+
+#     class window.TestModel extends Backbone.Model
+#     @testCollection = new Backbone.Collection([ {id: 1, name: "one"}, 
+#                                               {id: 2, name: "two"}, 
+#                                               {id: 3, name: "three"} ],
+#                                               model: TestModel)
+
+#     class window.TestListViewItem extends Cartilage.Views.ListViewItem
+#     window.JST = { "test_list_view_item": _.template('<a href="<%= testModel.get(\'name\') %>" id="link-<%= testModel.get(\'id\') %>">Link</a>')}
+
+#     @testListView = new Cartilage.Views.ListView
+#       collection: @testCollection
+#       allowsSelection: no
+#       allowsDeselction: no
+#       itemView: TestListViewItem
+
+# asyncTest "should pass a click in the listview through to the underlying element", 1, ->
+#   @testListView.prepare() 
+#   $('#testElement').html @testListView.render().el
+#   $('#testElement a#link-1').click (e) -> 
+#     ok true, "Click was received"
+#     start()
+#     e.preventDefault();
+#   offset = $('#testElement a#link-1').offset();
+#   $("#testElement a#link-1").simulate("click", {screenX: offset.left + 5, screenY: offset.top + 5}) 

data/test/framework/cartilage/views/loading_indicator_view_test.js.coffee

@@ -0,0 +1,5 @@
+
+module "Cartilage.Views.LoadingIndicatorView"
+
+test "Should Implement Tests", ->
+  ok(false, "No Tests!")

data/test/framework/cartilage/views/matrix_view_item_test.js.coffee

@@ -0,0 +1,5 @@
+
+module "Cartilage.Views.MatrixViewItem"
+
+test "Should Implement Tests", ->
+  ok(false, "No Tests!")

data/test/framework/cartilage/views/matrix_view_test.js.coffee

@@ -0,0 +1,5 @@
+
+module "Cartilage.Views.MatrixView"
+
+test "Should Implement Tests", ->
+  ok(false, "No Tests!")

data/test/framework/cartilage/views/popover_view_test.js.coffee

@@ -0,0 +1,5 @@
+
+module "Cartilage.Views.PopoverView"
+
+test "Should Implement Tests", ->
+  ok(false, "No Tests!")

data/test/framework/cartilage/views/source_list_view_item_test.js.coffee

@@ -0,0 +1,5 @@
+
+module "Cartilage.Views.SourceListViewItem"
+
+test "Should Implement Tests", ->
+  ok(false, "No Tests!")

data/test/framework/cartilage/views/source_list_view_test.js.coffee

@@ -0,0 +1,5 @@
+
+module "Cartilage.Views.SourceListView"
+
+test "Should Implement Tests", ->
+  ok(false, "No Tests!")

data/test/framework/cartilage/views/split_view_test.js.coffee

@@ -0,0 +1,5 @@
+
+module "Cartilage.Views.SplitView"
+
+test "Should Implement Tests", ->
+  ok(false, "No Tests!")

data/test/framework/cartilage/views/usage_bar_view_test.js.coffee

@@ -0,0 +1,5 @@
+
+module "Cartilage.Views.UsageBarView"
+
+test "Should Implement Tests", ->
+  ok(false, "No Tests!")

data/test/framework/cartilage/views/view_test.js.coffee

@@ -0,0 +1,85 @@
+
+module "Cartilage.View"
+
+  setup: ->
+    window.TestView = null
+
+test "superview property should be read-only", ->
+  testView = new Cartilage.View
+  testView.superview = "foobar"
+  ok _.isNull(testView.superview), "superview should be null"
+
+test "subviews property should be read-only", ->
+  testView = new Cartilage.View
+  testView.subviews = "foobar"
+  deepEqual testView.subviews, [], "subviews should be an empty array"
+
+test "observers property should be read-only", ->
+  testView = new Cartilage.View
+  testView.observers = "foobar"
+  deepEqual testView.observers, [], "observers should be an empty array"
+
+test "addSubview method should add the view to subviews array", ->
+  class TestView extends Cartilage.View
+  class TestSubview extends Cartilage.View
+  testView = new TestView
+  testSubview = new TestSubview
+  testView.addSubview(testSubview)
+  deepEqual testView.subviews, [ testSubview ], "testSubview should be in the subviews array"
+
+test "addSubview should add subview's element to its element", ->
+  class TestView extends Cartilage.View
+  class TestSubview extends Cartilage.View
+  testView = new TestView
+  testSubview = new TestSubview
+  testView.addSubview(testSubview)
+  equal testSubview.outerHTML, testView.innerHTML, "innerHTML of testView's element should match testSubview's outerHTML"
+
+test "addSubview should set the superview of the added subview to itself", ->
+  class TestView extends Cartilage.View
+  class TestSubview extends Cartilage.View
+  testView = new TestView
+  testSubview = new TestSubview
+  testView.addSubview(testSubview)
+  equal testSubview.superview, testView, "testSubview's superview should be equal to testView"
+
+test "removeFromSuperview method remove the view from its parent view's subviews array", ->
+  class TestView extends Cartilage.View
+  class TestSubview extends Cartilage.View
+  testView = new TestView
+  testSubview = new TestSubview
+  testView.addSubview(testSubview)
+  deepEqual testView.subviews, [ testSubview ], "testSubview should be in the subviews array"
+  testSubview.removeFromSuperview()
+  deepEqual testView.subviews, [], "testView.subviews should be an empty array"
+
+test "removeFromSuperview should clear the superview property", ->
+  class TestView extends Cartilage.View
+  class TestSubview extends Cartilage.View
+  testView = new TestView
+  testSubview = new TestSubview
+  testView.addSubview(testSubview)
+  equal testSubview.superview, testView, "testSubview's superview should be equal to testView"
+  testSubview.removeFromSuperview()
+  equal testSubview.superview, null, "testSubview's superview should be null"
+
+test "should determine template name automatically", ->
+  window.JST = { "test_view": -> "TestView Template" }
+  class TestView extends Cartilage.View
+  testView = new TestView
+  equal testView.template(), "TestView Template", "template() should return 'TestView Template'"
+
+test "should determine CSS class names from the inheritance chain", ->
+  class TestViewOne extends Cartilage.View
+  class TestViewTwo extends TestViewOne
+  class TestViewThree extends TestViewTwo
+  testView = new TestViewThree
+  className = testView.determineClassName()
+  equal className, "view test-view-one test-view-two test-view-three", "Class names array should include names for each parent in the inheritance chain"
+
+test "should append custom CSS class names to the view's class names", ->
+  class TestView extends Cartilage.View
+    className: "extra-class-one extra-class-two"
+  testView = new TestView
+  className = testView.determineClassName()
+  equal className, "view test-view extra-class-one extra-class-two", "Class names should include both automatically determined names and custom names"

data/test/framework/extensions/properties_test.js.coffee

@@ -0,0 +1,82 @@
+
+module "Extensions.Properties"
+
+  setup: ->
+
+test "should initialize property", ->
+
+  class TestView extends Cartilage.View
+    @property "testProperty"
+  testView = new TestView
+
+  ok not _.isUndefined(testView._testProperty), "_testProperty should not be undefined"
+  ok _.isNull(testView._testProperty), "_testProperty should be null"
+
+test "should initialize property with default value", ->
+
+  class TestView extends Cartilage.View
+    @property "testProperty", default: "foo"
+  testView = new TestView
+
+  equal testView.testProperty, "foo", "testProperty should equal 'foo'"
+
+test "should disallow changes to read-only properties", ->
+
+  class TestView extends Cartilage.View
+    @property "testProperty", access: READONLY
+  testView = new TestView
+
+  testView.testProperty = "foobar"
+  ok _.isNull(testView.testProperty), "testProperty should be null"
+
+test "should initialize read-only property with default value", ->
+
+  class TestView extends Cartilage.View
+    @property "testProperty", access: READONLY, default: "foobar"
+  testView = new TestView
+
+  equal testView.testProperty, "foobar", "testProperty should equal 'foobar'"
+
+test "should initialize property with custom getter", ->
+
+  class TestView extends Cartilage.View
+    @property "testProperty",
+      get: -> "customGetter"
+  testView = new TestView
+
+  equal testView.testProperty, "customGetter", "testProperty should equal 'customGetter'"
+
+test "should initialize property with custom setter", ->
+
+  class TestView extends Cartilage.View
+    @property "testProperty",
+      set: (value) -> @__testProperty = "customSetter"
+  testView = new TestView
+  testView.testProperty = "foo"
+
+  equal testView.testProperty, "customSetter", "testProperty should equal 'customSetter'"
+
+test "should initialize property via super()", ->
+
+  class TestView extends Cartilage.View
+    @property "testProperty"
+
+    initialize: (options = {}) ->
+      options.testProperty = "bar"
+      super(options)
+      
+  testView = new TestView
+  equal testView.testProperty, "bar"
+
+test "should clone default instead of returning directly when it is an object", ->
+
+  class TestView extends Cartilage.View
+    @property "testProperty", default: {foo: "bar"}
+
+  testView1 = new TestView
+  testView2 = new TestView
+
+  testView1.testProperty.foo = "baz"
+
+  equal testView1.testProperty.foo, "baz"
+  equal testView2.testProperty.foo, "bar"

data/test/framework/extensions/underscore_test.js.coffee

@@ -0,0 +1,73 @@
+
+module "Extensions.Underscore"
+
+# _.sum ----------------------------------------------------------------------
+
+test "_.sum should sum arrays of numbers", ->
+  testArray = [ 1, 2, 3 ]
+  equal _.sum(testArray), 6, "Value expected to be 6 (1 + 2 + 3)"
+
+test "_.sum should return NaN for non-numeric array entries", ->
+  testArray = [ 1, 2, "Foo" ]
+  ok _.isNaN(_.sum(testArray)), "Value expected to be NaN"
+
+# _.dasherize ----------------------------------------------------------------
+
+test "_.dasherize should convert title-cased string to dasherized string", ->
+  testString = "FooBarView"
+  equal _.dasherize(testString), "foo-bar-view", "Value for '#{testString}' expected to be 'foo-bar-view'"
+
+test "_.dasherize should convert camel-cased string to dasherized string", ->
+  testString = "fooBarView"
+  equal _.dasherize(testString), "foo-bar-view", "Value for '#{testString}' expected to be 'foo-bar-view'"
+
+test "_.dasherize should convert underscored string to dasherized string", ->
+  testString = "foo_bar_view"
+  equal _.dasherize(testString), "foo-bar-view", "Value for '#{testString}' expected to be 'foo-bar-view'"
+
+test "_.dasherize should leave dashed strings alone", ->
+  testString = "foo-bar-view"
+  equal _.dasherize(testString), "foo-bar-view", "Value for '#{testString}' expected to be 'foo-bar-view'"
+
+# _.camelize -----------------------------------------------------------------
+
+test "_.camelize should convert title-cased string to camel-cased string", ->
+  testString = "FooBarView"
+  equal _.camelize(testString), "fooBarView", "Value for '#{testString}' expected to be 'fooBarView'"
+
+test "_.camelize should convert dashed string to camel-cased string", ->
+  testString = "foo-bar-view"
+  equal _.camelize(testString), "fooBarView", "Value for '#{testString}' expected to be 'fooBarView'"
+
+test "_.camelize should convert underscored string to camel-cased string", ->
+  testString = "foo_bar_view"
+  equal _.camelize(testString), "fooBarView", "Value for '#{testString}' expected to be 'fooBarView'"
+
+test "_.camelize should leave camel-cased strings alone", ->
+  testString = "fooBarView"
+  equal _.camelize(testString), "fooBarView", "Value for '#{testString}' expected to be 'fooBarView'"
+
+# _.underscore ---------------------------------------------------------------
+
+test "_.underscore should convert title-cased string to underscored string", ->
+  testString = "FooBarView"
+  equal _.underscore(testString), "foo_bar_view", "Value for '#{testString}' expected to be 'foo_bar_view'"
+
+test "_.underscore should convert camel-cased string to underscored string", ->
+  testString = "fooBarView"
+  equal _.underscore(testString), "foo_bar_view", "Value for '#{testString}' expected to be 'foo_bar_view'"
+
+test "_.underscore should convert dashed string to underscored string", ->
+  testString = "foo-bar-view"
+  equal _.underscore(testString), "foo_bar_view", "Value for '#{testString}' expected to be 'foo_bar_view'"
+
+test "_.underscore should leave underscored strings alone", ->
+  testString = "foo_bar_view"
+  equal _.underscore(testString), "foo_bar_view", "Value for '#{testString}' expected to be 'foo_bar_view'"
+
+# _.remove -------------------------------------------------------------------
+
+test "_.remove should remove value from array", ->
+  testArray = [ "A", "B", "C" ]
+  _.remove(testArray, "B")
+  deepEqual testArray, [ "A", "C" ], "foo"