luca 0.6.6

data/src/index.coffee

@@ -0,0 +1,255 @@
+# #### Luca.js
+# #
+# # Luca is a Backbone Helper and Container View Library
+# # which is packed with about a year worth of Backbone.js
+# # experience and best practices accumulated while I developed
+# # several large Backbone applications.  By using it, you are
+# # to a degree accepting my way of doing things.  But, I can
+# # assure you that by accepting my way of doing things you can
+# # focus a lot more on developing your UI and features and less
+# # on the boilerplate code required to get things to work properly.
+# #
+# # Luca components and stock Backbone components are completely
+# # compatible and you can ( and should ) use both in your application
+# # wherever it makes the most sense to do so
+
+# #### ExtJS Component Style
+
+# # Luca is inspired by the ExtJS style of laying out applications
+# # as composite views with components nested within components, and
+# # where the outer views or components handle communication between
+# # their children.  By properly abstracting your views it becomes
+# # possible to build large applications simply with a bunch of JSON
+# # configuration parameters
+
+# MyApplication = Luca.containers.Viewport.extend
+#   components:[
+#     ctype: 'column_view'
+#     layout: '50/50'
+#     components: [
+#       ctype: 'card_view'
+#       name: 'view1'
+#       components:[
+#         ctype: 'custom_view'
+#         name: 'custom_view_1'
+#       ,
+#         ctype: 'custom_view'
+#         name: 'custom_view_2'
+#       ]
+#     ,
+#       ctype : 'custom_view'
+#       name: 'custom_view_3'
+#     ]
+#   ]
+
+# #### View Registry
+# #
+# # if You define your views in namespaces, like you should be
+# App.views.CustomView = Luca.View.extend()
+# App.views.OtherView = Luca.View.extend()
+
+# # Then you can call Luca.registry.addNamespace 'App.views'
+# # and then have views like CustomView be accessible by
+# # a @ctype property with the value 'custom_view'
+# # in the various container views provided by luca.  This style of
+# # lazy instantiation adopted from ExtJS makes it possible to define
+# # a view and its relationships but not necessarily create it until
+# # you need it.  Or at the very least, to have the containers render
+# # these components for you and inject them into their proper place
+# # in the DOM structure
+
+# Luca.registry.addNamespace 'App.views'
+
+# #### View Helpers
+# #
+# # Luca.View is an extension of Backbone.View and provides some common
+# # patterns that I have found useful in the most generic cases when developing
+# # all different kinds of features in various kinds of apps.
+
+# #### Auto Event Binding
+# #
+# # views can define a hooks attribute which prevent you from having to
+# # bind to certain named triggers.  Hooks methods are automatically called
+# # within the context of the view itself
+#   Luca.View = Backbone.View.extend
+#     ...
+#     hooks:[
+#       "before:render"
+#       "after:render"
+#     ]
+
+#   SubClass = Luca.View.extend
+#     beforeRender: ()->
+#       @doSomething()
+#     afterRender: ()->
+#       @doSomething()
+
+# # this is accomplished by the setupHooks method
+# # which is automatically called on every Luca.View
+# # subclass.  This allows you to just define which
+# # methods on your view should be called any time an
+# # event gets triggered
+#   setupHooks: (set)->
+#     set ||= @hooks
+
+#     _(set).each (event)=>
+#       parts = event.split(':')
+#       prefix = parts.shift()
+
+#       parts = _( parts ).map (p)-> _.capitalize(p)
+#       fn = prefix + parts.join('')
+
+#       @bind event, ()=> @[fn].apply @, arguments if @[fn]
+
+# #### Collection Helpers
+# #
+# # Luca.Collection is an extenstion of Backbone.Collection which provides
+# # a bunch of commonly used patterns for doing things like:
+# #
+
+# #   - setting base parameters used on every request to your REST API
+# Luca.Collection.baseParams = (obj)->
+#   return Luca.Collection._baseParams = obj if obj
+
+#   if _.isFunction( Luca.Collection._baseParams )
+#     return Luca.Collection._baseParams.call()
+
+#   if _.isObject( Luca.Collection._baseParams )
+#     Luca.Collection._baseParams
+
+# #
+# #   - filtering with query string parameters against your API
+# #
+# #   - automatic interaction with your Luca.CollectionManager class
+
+#   register: (collectionManager="", key="", collection)->
+#     ...
+#     collection ||= this
+#     ...
+#     if _.isString( collectionManager )
+#       collectionManager = Luca.util.nestedValue( collectionManager, window )
+
+#     if _.isFunction( collectionManager.add )
+#       return collectionManager.add(key, collection)
+
+#     if _.isObject( collect)
+#       collectionManager[ key ] = collection
+
+# #   - make it easier to parse Rails style responses which include the root
+# #     by specifying a @root parameter
+# #
+# #   - use backbone-query if available
+# #
+# #   - onceLoaded: run a callback once if there are models present, otherwise wait until
+# #     the collection fetches
+#   onceLoaded: (fn)->
+#     ...
+#     wrapped = ()=> fn.apply @,[@]
+
+#     @bind "reset", ()=>
+#       wrapped()
+#       @unbind "reset", wrapped
+#     ...
+# #   - ifLoaded: run a callback any time the model gets reset, or if there are already models
+#   ifLoaded: (fn, scope=@)->
+#     ...
+#     @bind "reset", (collection)=>
+#       fn.apply scope, [collection]
+#     ...
+#     unless @fetching
+#       @fetch()
+
+
+# #   - bootstrapping a collection of objects which are
+# #     rendered in your markup on page load
+
+# #### Collections with Bootstrapped Models
+# #
+# # In order to make our Backbone Apps super fast it is a good practice
+# # to pre-populate your collections by what is referred to as bootstrapping
+# #
+# # Luca.Collections make it easier for you to do this cleanly and automatically
+# #
+# # by specifying a @cached property or method in your collection definition
+# # Luca.Collections will automatically look in this space to find models
+# # and avoid a roundtrip to your API unless explicitly told to.
+# Luca.Collection._bootstrapped_models = {}
+
+# Luca.Collection.bootstrap = (obj)->
+#   _.extend Luca.Collection._bootstrapped_models, obj
+
+# Luca.Collection.cache = (key, models)->
+#   return Luca.Collection._bootstrapped_models[ key ] = models if models
+#   Luca.Collection._bootstrapped_models[ key ] || []
+
+# Luca.Collection = Backbone.Collection.extend
+#   ...
+#   fetch: (options={})->
+#     @trigger "before:fetch", @
+
+#     return @reset(@data) if @memoryCollection is true
+
+#     # fetch will try to pull from the bootstrap if it is setup to do so
+#     # you can actually make the roundtrip to the server anyway if you pass
+#     # refresh = true in the options hash
+#     return @bootstrap() if @cached_models().length and not options.refresh
+
+
+# #### Collection Manager
+# #
+# # The purpose of the collection manager is to provide an interface
+# # for tracking the creation of collections, so that you only create
+# # one instance of a given collection class per instance of some scope.
+
+# class Luca.CollectionManager
+#   ...
+#   getOrCreate: (key,collectionOptions={},initialModels=[])->
+#     @get(key) || @create(key,collectionOptions,initialModels)
+
+#   # If you use a underscored version of your collection class name
+#   # as the key for your collection ( defined via @registerAs ) then
+#   # it will automatically be able to guess which collection you are
+#   # referring to and create it for you
+#   guessCollectionClass: (key)->
+#     classified = _( key ).chain().capitalize().camelize().value()
+#     guess = (@collectionPrefix || window)[ classified ]
+
+# # You would generally create the collection manager once as part of
+# # your global application object which, in my opinion should be a
+# # Luca Viewport container
+
+# LucaApp = Luca.containers.Viewport.extend
+#   initialize: (@options={})->
+#     @collectionManager = new Luca.CollectionManager
+#       getScope: ()=> @someParentValue()
+
+#   collection: (key,options={},models=[])->
+#     @collectionManager.getOrCreate(key,options,models)
+
+#   someParentValue: ()-> @usedToScopeTheCollections
+
+# # Now in the single global instance of LucaApp you have
+# # one central place to access a collection of models, one
+# # interface to listen to for add, remove, reset, change events
+
+# #### Collection and View Integration
+
+# # One really cool feature of Luca is the enhanced API for binding
+# # collections to views.  Using an API very similar to the
+# # DOM @events property on Backbone views.  If you are using Luca.Collection
+# # classes and a Luca.CollectionManager to track them, you can use the
+# # @collectionEvents property on your views as a cleaner interface for
+# # setting up your event bindings
+
+# App.Manager = new Luca.CollectionManager()
+
+# App.SampleCollection = new Luca.SampleCollection
+#   registerWith: "App.Manager"
+#   registerAs: "sample_collection"
+
+# App.View = Luca.View.extend
+#   collectionEvents:
+#     "sample_collection add" : "onCollectionAdd"
+
+#   onCollectionAdd: (model,collection)->
+#     @doSomethingRighteous()

data/src/managers/collection_manager.coffee

@@ -0,0 +1,168 @@
+#### Collection Manager
+#
+# The purpose of the collection manager is to provide an interface
+# for tracking the creation of collections, so that you only create
+# one instance of a given collection class per instance of some scope
+#
+# For example:
+
+# LucaApp = Luca.containers.Viewport.extend
+#  initialize: (@options={})->
+#     @collectionManager = new Luca.CollectionManager
+#       getScope: ()-> @someParentValue
+#  collection: (key,options={},models=[])->
+#    @collectionManager.getOrCreate(key,options,models)
+#
+# Now in the single global instance of LucaApp you have
+# one central place to access a collection of models, one
+# interface to listen to for add, remove, reset, change events
+#
+# If you don't want this, you can either do it the old fashioned way
+# or just use the private option to get an unregistered instance.
+#
+
+#### View Event Binding Interface
+#
+# Luca.Views can specify a @collectionEvents property very similar to
+# the DOM @events property in Backbone.Views and this provides a very
+# clean API for binding to events on the collection manager and doing
+# the necessary things on the view.  This does assume that by default
+# there is only one instance of the collection manager running, otherwise
+# a configuration directive is provided at a view level to know which
+# collection manager to pull from.
+#
+# Special Thanks to @tjbladez for this wonderful initialModelsa
+#
+
+instances = []
+
+class Luca.CollectionManager
+  __collections: {}
+
+  constructor: (@options={})->
+    _.extend @, @options
+    _.extend @, Backbone.Events
+
+    # if you are going to use more than one collection
+    # manager, then you will have to specify which
+    # collection manager your views need to interact
+    # with for their collectionEvents configuration handling
+    instances.push(@)
+
+    # model to maintain state of the collection manager
+    @state = new Backbone.Model
+
+    if @collectionNames
+
+      @state.set({loaded_collections_count: 0, collections_count: @collectionNames.length })
+      @state.bind "change:loaded_collections_count", @collectionCountDidChange
+
+      if @useProgressLoader
+        @loader = new Luca.components.CollectionLoaderView(manager: @,name:"collection_loader_view")
+
+      @loadInitialCollections()
+
+    @
+
+  add: (key, collection)->
+    @currentScope()[ key ] ||= collection
+
+  allCollections: ()->
+    _( @currentScope() ).values()
+
+  # create a collection from just a key.
+  # if you pass the private option, it will
+  # skip registering this collection
+  create: (key, collectionOptions={}, initialModels=[])->
+    CollectionClass = collectionOptions.base
+    CollectionClass ||= @guessCollectionClass(key)
+    collectionOptions.name = "" if collectionOptions.private
+
+    collection = new CollectionClass(initialModels,collectionOptions)
+
+    @add(key, collection)
+
+    return collection
+
+  #### Collection Prefix
+  #
+  # If you are doing things right, you are namespacing all of your collection
+  # definitions, for example
+  #
+  # LucaApp.collections.SomeCollection = Luca.Collection.extend
+  #   registerAs: "some_collection"
+  #   registerWith: ""
+  #
+  # You should override this attribute when you create or define your collection manager
+  #
+  #
+  collectionNamespace: Luca.Collection.namespace
+
+  #### Collection Scopes
+
+  # any time you create a collection, or use getOrCreate, the key
+  # value ( @registerAs ) for your collection will be used to retrieve it
+  #
+  # if you plan to have multiple instances per key, but with some sort of
+  # scope based on a parent attribute, you should define a
+  currentScope: ()->
+    if current_scope = @getScope()
+      @__collections[ current_scope ] ||= {}
+    else
+      @__collections
+
+  # do something to each collection in the scope
+  each: (fn)->
+    _( @all() ).each(fn)
+
+  get:(key)->
+    @currentScope()[key]
+
+  # by default, we won't use a scope, but if you wish to use one
+  # you should define this method on your collection manager
+  getScope: ()-> undefined
+
+  getOrCreate: (key,collectionOptions={},initialModels=[])->
+    @get(key) || @create(key,collectionOptions,initialModels,false)
+
+  guessCollectionClass: (key)->
+    classified = _( key ).chain().capitalize().camelize().value()
+    guess = (@collectionNamespace || (window || global) )[ classified ]
+    guess ||= (@collectionNamespace || (window || global) )[ "#{classified}Collection" ]
+    guess
+
+  # load collection, iterates over each name you have passed for the
+  # your collections in the currentScope, makes sure they exist and
+  # fetched
+  loadInitialCollections: ()->
+    collectionDidLoad = (collection) =>
+      collection.unbind "reset"
+      @trigger "collection_loaded", collection.name
+
+    _(@collectionNames).each (name) =>
+      collection = @getOrCreate(name)
+      collection.bind "reset", ()->
+        collectionDidLoad(collection)
+      collection.fetch()
+
+  collectionCountDidChange: ()->
+    @trigger "all_collections_loaded" if @totalCollectionsCount() == @loadedCollectionsCount()
+
+  totalCollectionsCount: ()->
+    @state.get("collections_count")
+
+  loadedCollectionsCount: ()->
+    @state.get("loaded_collections_count")
+  # in most cases, the collections we use can be used only once
+  # and any reset events should be respected, bound to, etc.  however
+  # if this ever isn't the case, you can create an instance
+  # of a collection which is "private" in that once it is
+  # returned from the collection manager, it isn't tracked so
+  # you can make sure any add / reset / remove / filter events
+  # don't effect other views
+  private: (key, collectionOptions={}, initialModels=[])->
+    @create(key,collectionOptions,initialModels,true)
+
+Luca.CollectionManager.destroyAll = ()-> instances = []
+Luca.CollectionManager.instances = ()-> instances
+Luca.CollectionManager.get = ()-> _( instances ).last()

data/src/managers/socket_manager.coffee

@@ -0,0 +1,54 @@
+# Luca.SocketManager is an abstraction
+# around various websocket services such as
+# faye.js, socket.io, now.js, etc.
+#
+# It provides a common interface for adding
+# push / async functionality to Collections,
+# Models, and the like, regardless of the
+# transport mechanism used.
+#
+# Simply bind to it, and any message that comes
+# across the channel you subscribe to, will be
+# bubbled up as a Backbone.Event with the message
+# contents as your argument
+class Luca.SocketManager
+  constructor: (@options={})->
+    _.extend Backbone.Events
+
+    @loadTransport()
+
+  connect: ()->
+    switch @options.provider
+      when "socket.io"
+        @socket = io.connect( @options.socket_host )
+      when "faye.js"
+        @socket = new Faye.Client( @options.socket_host )
+
+  #### Transport Loading and Configuration
+  #
+  # Luca wraps several popular client side socket abstractions
+  # such as socket.io or faye.js ( more coming soon )
+  #
+  # it provides a common interface on top of these and just
+  # treats them as Backbone.Events which you bind to like you
+  # would on any other Backbone class
+
+  transportLoaded: ()-> @connect()
+
+  transport_script: ()->
+    switch @options.provider
+      when "socket.io" then "#{ @options.transport_host }/socket.io/socket.io.js"
+      when "faye.js" then "#{ @options.transport_host }/faye.js"
+
+  loadTransport: ()->
+    script = document.createElement 'script'
+    script.setAttribute "type", "text/javascript"
+    script.setAttribute "src", @transport_script()
+    script.onload = @transportLoaded
+
+    if Luca.util.isIE()
+      script.onreadystatechange = ()=>
+        if script.readyState is "loaded"
+          @transportLoaded()
+
+    document.getElementsByTagName('head')[0].appendChild script

data/src/modules/deferrable.coffee

@@ -0,0 +1,18 @@
+# TODO THis module is going to be deprecated as it has been gradually gut over time
+Luca.modules.Deferrable = 
+  configure_collection: (setAsDeferrable=true)->
+    return unless @collection
+
+    if _.isString( @collection ) and collectionManager = Luca.CollectionManager?.get()
+      @collection = collectionManager.getOrCreate(@collection)
+
+    # if there is already an instantiated backbone collection don't do anything
+    unless @collection and _.isFunction( @collection.fetch ) and _.isFunction( @collection.reset )
+      @collection = new Luca.Collection( @collection.initial_set, @collection )
+    
+    if @collection?.deferrable_trigger
+      @deferrable_trigger = @collection.deferrable_trigger
+
+    if setAsDeferrable
+      @deferrable = @collection
+

data/src/modules/local_storage.coffee

@@ -0,0 +1,50 @@
+class Luca.LocalStore
+  
+  # think of name the way you would a table in a mysql db
+  constructor: (@name)->
+    store = localStorage.getItem(@name)
+    @data = ( store && JSON.parse(store) ) || {}
+
+  guid: ()->
+    S4 = ()-> (((1+Math.random())*0x10000)|0).toString(16).substring(1)
+    (S4()+S4()+"-"+S4()+"-"+S4()+"-"+S4()+"-"+S4()+S4()+S4())
+  
+  # serialize the store into JSON and put it in the localStorage
+  save: ()->
+    localStorage.setItem(@name, JSON.stringify(@data) )
+   
+  create: (model)->
+    model.id = model.attribtues.id = @guid() unless model.id
+    @data[ model.id ] = model
+    @save()
+    model
+
+  update: (model)->
+    @data[model.id] = model
+    @save()
+    model
+  
+  find: (model)-> @data[ model.id ]
+  
+  findAll: ()-> 
+    _.values( @data )
+
+  destroy: (model)->
+    delete @data[ model.id ]
+    @save()
+    model
+
+Backbone.LocalSync = (method, model, options)->
+  store = model.localStorage || model.collection.localStorage
+
+  resp = switch method
+    when "read" then (if model.id then store.find(model) else store.findAll())
+    when "create" then store.create(model)
+    when "update" then store.update(model)
+    when "delete" then store.destroy(model)
+  
+  if resp
+    options.success(resp)
+  else
+    options.error("Record not found")
+

data/src/stylesheets/base.scss

@@ -0,0 +1,78 @@
+html.luca-ui-fullscreen {
+  height: 100%;
+
+  body {
+    height: 100%;
+    padding: 0;
+    margin: 0;
+  }
+
+  .luca-ui-viewport {
+    height: 100%;
+    padding: 0;
+    margin: 0;
+  }
+}
+
+.luca-ui-viewport {
+  li {
+    list-style-type: none;
+  }
+
+  li.nav {
+    cursor: pointer;
+  }
+
+
+}
+
+/*http://csswizardry.com/fluid-grids/#generated-grids*/
+.wrapper{
+  max-width:1208px;
+/*  max-width:894px;*/
+  padding:0 15px;
+  margin:0 auto;
+}
+
+/*
+Column container
+*/
+.grids{
+  width:auto;
+  max-width:924px;
+  clear:both;
+  margin:0 0 0 -3.247%;
+  list-style:none; /* So we can make grids out of lists. */
+  overflow:hidden; /* Clear the floats */
+}
+
+[class*="grid-"]{
+  float:left;
+  margin:0 3.247% 0 0;
+}
+
+.grid-margin {
+  margin:0 3.247% 0 0;
+}
+.grids {
+  .grid-margin {
+    margin:0 0 0 3.247%;
+  }
+}
+
+.grids [class*="grid-"]{
+  margin:0 0 0 3.247%;
+}
+
+.grid-1{ width:5.087% }
+.grid-2{ width:13.42% }
+.grid-3{ width:21.753% }
+.grid-4{ width:30.087% }
+.grid-5{ width:38.42% }
+.grid-6{ width:46.753% }
+.grid-7{ width:55.087% }
+.grid-8{ width:63.42% }
+.grid-9{ width:71.753% }
+.grid-10{ width:80.087% }
+.grid-11{ width:88.42% }
+.grid-12{ width:96.753%; margin:0; }

data/src/stylesheets/components/form_view.scss

@@ -0,0 +1,54 @@
+.luca-ui-form-view-wrapper {
+  width: 100%;
+  float: left;
+  display: block;
+  clear: both;
+  margin: 10px 0px;
+}
+
+
+.luca-ui-form-view {
+  .luca-ui-field {
+    margin: 5px;
+    padding: 5px;
+
+    .helper-text {
+      font-size: 0.75em;
+      font-color: #ccc;
+    }
+  }
+}
+
+.luca-ui-form-view.label-align-top {
+  .luca-ui-field {
+    label, input, select, textarea {
+      margin: 5px 0px;
+      display: block;
+    }
+  }
+}
+
+.luca-ui-form-view.column-layout {
+  .luca-ui-field {
+    float: left;
+  }
+}
+
+.form-view-footer {
+  .toolbar-container {
+    float: left;
+    width: 100%;
+    clear: both;
+    display: block;
+    .luca-ui-form-toolbar, .luca-ui-toolbar {
+      width: 50%;
+      display: block;
+      margin: 0px auto;
+      .luca-ui-field {
+        float: left;
+      }
+    }
+  }
+}
+
+