luca 0.6.6

data/spec/components/form_view_spec.coffee

@@ -0,0 +1,13 @@
+describe 'The Form View', ->
+  describe 'Generating a form from a model', ->
+    beforeEach ->
+      Model = Backbone.Model.extend
+        schema:
+          field0: "hidden"
+          field1: "text"
+          field3: "boolean"
+          field4: "blob"
+          field5:
+            collection: "sample"
+
+      @model = new Model(field0:1,field1:"jonathan",field3:true,field4:"what up player?")

data/spec/containers/card_view_spec.coffee

@@ -0,0 +1 @@
+describe "The Card View", ->

data/spec/core/collection_spec.coffee

@@ -0,0 +1,215 @@
+#### Luca.Collection
+
+describe "Luca.Collection", ->
+  it "should accept a name and collection manager", ->
+    mgr = new Luca.CollectionManager()
+    collection = new Luca.Collection([], name:"booya",manager:mgr)
+    expect( collection.name ).toEqual("booya")
+    expect( collection.manager ).toEqual(mgr)
+
+  it "should allow me to specify my own fetch method on a per collection basis", ->
+    spy = sinon.spy()
+    collection = new Luca.Collection([],fetch:spy)
+    collection.fetch()
+
+    expect( spy.called ).toBeTruthy()
+
+  it "should trigger before:fetch", ->
+    collection = new Luca.Collection([], url:"/models")
+    spy = sinon.spy()
+    collection.bind "before:fetch", spy
+    collection.fetch()
+    expect( spy.called ).toBeTruthy()
+
+  it "should automatically parse a response with a root in it", ->
+    collection = new Luca.Collection([], root:"root",url:"/rooted/models")
+    collection.fetch()
+    @server.respond()
+    expect( collection.length ).toEqual(2)
+
+  it "should attempt to register with a collection manager", ->
+    registerSpy = sinon.spy()
+
+    collection = new Luca.Collection [],
+      name:"registered"
+      register: registerSpy
+
+    expect( registerSpy ).toHaveBeenCalled()
+
+describe "The ifLoaded helper", ->
+  it "should fire the passed callback automatically if there are models", ->
+    spy = sinon.spy()
+    collection = new Luca.Collection([{attr:"value"}])
+    collection.ifLoaded(spy)
+    expect( spy.callCount ).toEqual(1)
+
+  it "should fire the passed callback any time the collection resets", ->
+    spy = sinon.spy()
+
+    collection = new Luca.Collection([{attr:"value"}], url:"/models")
+
+    collection.ifLoaded ()->
+      spy.call()
+
+    collection.fetch()
+    @server.respond()
+
+    expect( spy.callCount ).toEqual(2)
+
+  it "should not fire the callback if there are no models", ->
+    spy = sinon.spy()
+    collection = new Luca.Collection()
+    collection.ifLoaded(spy)
+    expect( spy.called ).toBeFalsy()
+
+  it "should automatically call fetch on the collection", ->
+    spy = sinon.spy()
+    collection = new Luca.Collection([],url:"/models",blah:true)
+    collection.ifLoaded(spy)
+    @server.respond()
+    expect( spy.called ).toBeTruthy()
+
+  it "should allow me to not automatically call fetch on the collection", ->
+    collection = new Luca.Collection([],url:"/models")
+    spy = sinon.spy( collection.fetch )
+    fn = ()-> true
+    collection.ifLoaded(fn, autoFetch:false)
+    expect( spy.called ).toBeFalsy()
+
+describe "The onceLoaded helper", ->
+  it "should fire the passed callback once if there are models", ->
+    spy = sinon.spy()
+    collection = new Luca.Collection([{attr:"value"}])
+    collection.onceLoaded(spy)
+    expect( spy.callCount ).toEqual(1)
+
+  it "should fire the passed callback only once", ->
+    spy = sinon.spy()
+    collection = new Luca.Collection([{attr:"value"}],url:"/models")
+    collection.onceLoaded(spy)
+    expect( spy.callCount ).toEqual(1)
+
+    collection.fetch()
+    @server.respond()
+    expect( spy.callCount ).toEqual(1)
+
+  it "should not fire the callback if there are no models", ->
+    spy = sinon.spy()
+    collection = new Luca.Collection()
+    collection.onceLoaded(spy)
+    expect( spy.called ).toBeFalsy()
+
+  it "should automatically call fetch on the collection", ->
+    spy = sinon.spy()
+    collection = new Luca.Collection([],url:"/models")
+    collection.onceLoaded(spy)
+    @server.respond()
+    expect( spy.called ).toBeTruthy()
+
+  it "should allow me to not automatically call fetch on the collection", ->
+    collection = new Luca.Collection([],url:"/models")
+    spy = sinon.spy( collection.fetch )
+    fn = ()-> true
+    collection.onceLoaded(fn, autoFetch:false)
+    expect( spy.called ).toBeFalsy()
+
+describe "Registering with the collection manager", ->
+
+  it "should be able to find a default collection manager", ->
+    mgr = new Luca.CollectionManager()
+    expect( Luca.CollectionManager.get() ).toEqual(mgr)
+
+  it "should automatically register with the manager if I specify a name", ->
+    mgr = new Luca.CollectionManager()
+    collection = new Luca.Collection([],name:"auto_register")
+    expect( mgr.get("auto_register") ).toEqual(collection)
+
+  it "should register with a specific manager", ->
+    window.other_manager = new Luca.CollectionManager()
+
+    collection = new Luca.Collection [],
+      name: "other_collection"
+      manager: window.other_manager
+
+    expect( window.other_manager.get("other_collection") ).toEqual(collection)
+
+  it "should find a collection manager by string", ->
+    window.find_mgr_by_string = new Luca.CollectionManager()
+
+    collection = new Luca.Collection [],
+      name: "biggie"
+      manager: "find_mgr_by_string"
+
+    expect( collection.manager ).toBeDefined()
+
+  it "should not register with a collection manager if it is marked as private", ->
+    manager = new Luca.CollectionManager()
+
+    registerSpy = sinon.spy()
+
+    private = new Luca.Collection [],
+      name: "private"
+      manager: manager
+      private: true
+      register: registerSpy
+
+    expect( registerSpy ).not.toHaveBeenCalled()
+
+
+describe "The Model Bootstrap", ->
+  window.ModelBootstrap =
+    sample: []
+
+  _(5).times (n)->
+    window.ModelBootstrap.sample.push
+      id: n
+      key: "value"
+
+  it "should add an object into the models cache", ->
+    Luca.Collection.bootstrap( window.ModelBootstrap )
+    expect( Luca.Collection.cache("sample").length ).toEqual(5)
+
+  it "should fetch the cached models from the bootstrap", ->
+    collection = new Luca.Collection [],
+      cached: ()-> "sample"
+
+    collection.fetch()
+
+    expect( collection.length ).toEqual(5)
+    expect( collection.pluck('id') ).toEqual([0,1,2,3,4])
+
+  it "should reference the cached models", ->
+    collection = new Luca.Collection [],
+      cached: ()-> "sample"
+
+    expect( collection.cached_models().length ).toEqual(5)
+
+  it "should avoid making an API call", ->
+    spy = sinon.spy( Backbone.Collection.prototype.fetch )
+    collection = new Luca.Collection [],
+        cached: ()-> "sample"
+
+    collection.fetch()
+    expect( spy.called ).toBeFalsy()
+
+  it "should make an API call if specifically asked", ->
+    spy = sinon.spy()
+
+    collection = new Luca.Collection [],
+      cached: ()-> "sample"
+      url: ()-> "/models"
+
+    collection.bind "after:response", spy
+    collection.fetch(refresh:true)
+    @server.respond()
+
+    expect( spy.called ).toBeTruthy()
+
+
+
+
+
+
+
+
+

data/spec/core/view_spec.coffee

@@ -0,0 +1,87 @@
+describe "Luca.View", ->
+  Custom = Luca.View.extend
+    clickHandler: sinon.spy()
+    autoBindEventHandlers: true
+
+  it "should be defined", ->
+    expect(Luca.View).toBeDefined()
+
+  it "should extend itself with the passed options", ->
+    view = new Luca.View(name:"custom")
+    expect(view.name).toEqual("custom")
+
+  it "should create a unique id based on the name", ->
+    view = new Luca.View(name:"boom")
+    expect( view.cid ).toContain 'boom'
+
+  it "should register the view in the cache", ->
+    view = new Luca.View(name:"cached")
+    expect( Luca.cache("cached") ).toBeDefined()
+
+  it "should trigger after initialize", ->
+    view = new Luca.View()
+    expect( view ).toHaveTriggered("after:initialize")
+
+  it "should auto-bind event handlers", ->
+    # pending
+
+
+
+describe "Hooks", ->
+  it "should have before and after render hooks", ->
+    Custom = Luca.View.extend
+      beforeRender: sinon.spy()
+      afterRender: sinon.spy()
+
+    view = new Custom()
+
+    view.render()
+
+    expect( view.beforeRender ).toHaveBeenCalled()
+    expect( view.afterRender ).toHaveBeenCalled()
+
+  it "should call custom hooks in addition to framework hooks", ->
+    Custom = Luca.View.extend
+      hooks:["custom:hook"]
+      afterRender: ()-> @trigger("custom:hook")
+      customHook: sinon.spy()
+
+    view = new Custom()
+
+    view.render()
+
+    expect( view.customHook ).toHaveBeenCalled()
+
+describe "The Collection Events API", ->
+  App =
+    collections : {}
+
+  App.collections.Sample = Luca.Collection.extend
+    name: "sample"
+
+  SampleView = Luca.View.extend
+    resetHandler: sinon.spy()
+    collectionEvents:
+      "sample reset" : "resetHandler"
+
+  class SampleManager extends Luca.CollectionManager
+    collectionNamespace: App.collections
+    name: "collectionEvents"
+
+  beforeEach ()->
+    @manager ||= new SampleManager()
+    @collection = @manager.getOrCreate("sample")
+
+  it "should know which collection manager to use", ->
+    view = new SampleView()
+    expect( view.getCollectionManager().name ).toEqual( "collectionEvents" )
+
+  it "should create a reference to the collection", ->
+    view = new SampleView()
+    expect( view.sampleCollection ).toBeDefined()
+
+  it "should call the resetHandler callback on the view", ->
+    view = new SampleView()
+    collection = @manager.get("sample")
+    collection.reset([])
+    expect( view.resetHandler ).toHaveBeenCalled()

data/spec/framework_spec.coffee

@@ -0,0 +1,48 @@
+#= require "./helper"
+
+describe "The Luca Framework", ->
+  it "should specify a version", ->
+    expect(Luca.VERSION).toBeDefined()
+
+  it "should define Luca in the global space", ->
+    expect(Luca).toBeDefined()
+
+  it "should enable bootstrap by default", ->
+    expect(Luca.enableBootstrap).toBeTruthy()
+
+  it "should have classes in the registry", ->
+    expect( Luca.registry.classes ).toBeDefined()
+
+  it "should be able to lookup classes in the registry by ctype", ->
+    expect( Luca.registry.lookup("form_view") ).toBeTruthy()
+
+  it "should allow me to add view namespaces to the registry", ->
+    Luca.registry.addNamespace("Test.namespace")
+    expect( Luca.registry.namespaces ).toContain("Test.namespace")
+
+  it "should resolve a value.string to the object", ->
+    window.nested =
+      value:
+        string: "haha"
+
+    value = Luca.util.nestedValue("nested.value.string", window)
+
+    expect(value).toEqual("haha")
+
+  it "should create an instance of a class by ctype", ->
+    object = 
+      ctype: "template"
+      template: "components/form_view"    
+
+    component = Luca.util.lazyComponent(object)
+    expect( _.isFunction(component.render) ).toBeTruthy()
+
+  it "should find a created view in the cache", ->
+    template = new Luca.components.Template
+      template: "components/form_view"    
+      name: 'test_template'
+
+    expect(Luca.cache("test_template")).toBeDefined()
+
+
+describe 

data/spec/helper.coffee

@@ -0,0 +1,120 @@
+# thanks player
+# https://github.com/thefrontside/jasmine.backbone.js
+
+json = (object) ->
+  JSON.stringify object
+
+msg = (list) ->
+  (if list.length isnt 0 then list.join(";") else "")
+
+eventBucket = (model, eventName) ->
+  spiedEvents = model.spiedEvents
+  spiedEvents = model.spiedEvents = {}  unless spiedEvents
+  bucket = spiedEvents[eventName]
+  bucket = spiedEvents[eventName] = []  unless bucket
+  bucket
+
+triggerSpy = (constructor) ->
+  trigger = constructor::trigger
+  constructor::trigger = (eventName) ->
+    bucket = eventBucket(this, eventName)
+    bucket.push Array::slice.call(arguments, 1)
+    trigger.apply this, arguments
+
+triggerSpy Backbone.Model
+triggerSpy Backbone.Collection
+triggerSpy Backbone.View
+
+EventMatchers =
+  toHaveTriggered: (eventName) ->
+    bucket = eventBucket(@actual, eventName)
+    triggeredWith = Array::slice.call(arguments, 1)
+    @message = ->
+      [ "expected model or collection to have received '" + eventName + "' with " + json(triggeredWith), "expected model not to have received event '" + eventName + "', but it did" ]
+
+    _.detect bucket, (args) ->
+      if triggeredWith.length is 0
+        true
+      else
+        jasmine.getEnv().equals_ triggeredWith, args
+
+ModelMatchers =
+  toHaveAttributes: (attributes) ->
+    keys = []
+    values = []
+    jasmine.getEnv().equals_ @actual.attributes, attributes, keys, values
+    missing = []
+    i = 0
+
+    while i < keys.length
+      message = keys[i]
+      missing.push keys[i]  if message.match(/but missing from/)
+      i++
+    @message = ->
+      [ "model should have at least these attributes(" + json(attributes) + ") " + msg(missing) + " " + msg(values), "model should have none of the following attributes(" + json(attributes) + ") " + msg(keys) + " " + msg(values) ]
+
+    missing.length is 0 and values.length is 0
+
+  toHaveExactlyTheseAttributes: (attributes) ->
+    keys = []
+    values = []
+    equal = jasmine.getEnv().equals_(@actual.attributes, attributes, keys, values)
+    @message = ->
+      [ "model should match exact attributes, but does not. " + msg(keys) + " " + msg(values), "model has exactly these attributes, but shouldn't :" + json(attributes) ]
+
+    equal
+
+createFakeServer = ->
+  server = sinon.fakeServer.create()
+  server.respondWith("GET", "/models", [
+    200,
+    {"Content-Type":"application/json"},
+    '[{"id":1,"attr1":"value1","attr2":"value2"},{"id":2,"attr1":"value1","attr2":"value2"}]'
+  ])
+  server.respondWith("GET", "/rooted/models", [
+    200,
+    {"Content-Type":"application/json"},
+    '{"root":[{"id":1,"attr1":"value1","attr2":"value2"},{"id":2,"attr1":"value1","attr2":"value2"}]}'
+  ])
+  server.respondWith("GET", "/empty", [
+    200,
+    {"Content-Type":"application/json"},
+    '[]'
+  ])
+  server
+
+spyMatchers = "called calledOnce calledTwice calledThrice calledBefore calledAfter calledOn alwaysCalledOn calledWith alwaysCalledWith calledWithExactly alwaysCalledWithExactly".split(" ")
+i = spyMatchers.length
+spyMatcherHash = {}
+unusualMatchers =
+  returned: "toHaveReturned"
+  alwaysReturned: "toHaveAlwaysReturned"
+  threw: "toHaveThrown"
+  alwaysThrew: "toHaveAlwaysThrown"
+
+getMatcherFunction = (sinonName) ->
+  ->
+    sinonProperty = @actual[sinonName]
+    (if (typeof sinonProperty is "function") then sinonProperty.apply(@actual, arguments) else sinonProperty)
+
+while i--
+  sinonName = spyMatchers[i]
+  matcherName = "toHaveBeen" + sinonName.charAt(0).toUpperCase() + sinonName.slice(1)
+  spyMatcherHash[matcherName] = getMatcherFunction(sinonName)
+for j of unusualMatchers
+  spyMatcherHash[unusualMatchers[j]] = getMatcherFunction(j)
+
+window.sinonJasmine =
+  getMatchers: ->
+    spyMatcherHash
+
+#### Loadup Jasmine
+beforeEach ->
+  @server = createFakeServer()
+
+  @addMatchers ModelMatchers
+  @addMatchers EventMatchers
+  @addMatchers sinonJasmine.getMatchers()
+
+afterEach ->
+  @server.restore()

data/spec/managers/collection_manager_spec.coffee

@@ -0,0 +1,95 @@
+describe "The Collection Manager", ->
+  App = collections: {}
+
+  App.collections.SampleCollection = Luca.Collection.extend
+    url: "/models"
+
+  beforeEach ()->
+    @manager = new Luca.CollectionManager(name:"manager",collectionNamespace: App.collections)
+
+  it "should be defined", ->
+    expect( Luca.CollectionManager ).toBeDefined()
+
+  it "should make the latest instance accessible by class function", ->
+    expect( Luca.CollectionManager.get().name ).toEqual("manager")
+
+  it "should be able to guess a collection constructor class", ->
+    base = @manager.guessCollectionClass("sample_collection")
+    expect( base ).toEqual(App.collections.SampleCollection)
+
+  it "should create a collection on demand", ->
+    collection = @manager.getOrCreate("sample_collection")
+    expect( collection.url ).toEqual "/models"
+
+describe "Adding Collections", ->
+  manager = new Luca.CollectionManager
+  first   = new Luca.Collection([],name:"added",prop:"val2")
+  second  = new Luca.Collection([],name:"added",prop:"val1")
+
+  manager.add("added", first)
+  manager.add("added", second)
+
+  expect( manager.get("added") ).toEqual( first )
+
+describe "The Scope Functionality", ->
+  scope = "one"
+
+  manager = new Luca.CollectionManager
+    getScope: ()-> scope
+
+  babyone = new Luca.Collection([{id:1},{id:2}],name:"baby")
+
+  manager.add("baby", babyone)
+
+  expect( manager.get("baby").pluck('id') ).toEqual([1,2])
+  expect( manager.get("baby") ).toBeDefined()
+  expect( manager.get("baby") ).toEqual( babyone )
+  expect( manager.allCollections().length ).toEqual(1)
+
+  scope = "two"
+
+  babytwo = new Luca.Collection([{id:3},{id:4}],name:"baby")
+
+  expect( manager.get("baby").pluck('id') ).toEqual([3,4])
+  expect( manager.get("baby") ).toBeDefined()
+  expect( manager.get("baby") ).toEqual( babytwo )
+  expect( manager.allCollections().length ).toEqual(1)
+
+  scope = "one"
+  expect( manager.get("baby").pluck('id') ).toEqual([1,2])
+
+describe "Loading collections", ->
+  App = collections: {}
+
+  exampleSpy = sinon.spy()
+  sampleSpy  = sinon.spy()
+
+  App.collections.ExampleCollection = Luca.Collection.extend
+    name: "example"
+    url: "/example_models"
+    fetch: ()->
+      exampleSpy.call()
+      @reset([{id: 1}])
+
+  App.collections.SampleCollection = Luca.Collection.extend
+    name: "sample"
+    url: "/sample_models"
+    fetch: ()->
+      sampleSpy.call()
+      @reset([{id: 4}])
+
+  manager = new Luca.CollectionManager(name:"manager",collectionNamespace: App.collections, collectionNames: ["example", "sample"])
+
+  it "should have example collection created", ->
+    collection = manager.get("example")
+    expect(collection.url).toEqual ("/example_models")
+
+  it "should have example collection fetched", ->
+    expect(exampleSpy).toHaveBeenCalled()
+
+  it "should have sample collection created", ->
+    collection = manager.get("sample")
+    expect(collection.url).toEqual ("/sample_models")
+
+  it "should have sample collection loaded", ->
+    expect(sampleSpy).toHaveBeenCalled()