luca 0.9.76 → 0.9.89

data/app/assets/javascripts/luca/development/component.coffee

@@ -0,0 +1,76 @@
+model = Luca.register  "Luca.models.Component"
+model.extends           "Luca.Model"
+
+model.configuration
+  defaults:
+    class_name: undefined
+    superClass: undefined
+    asset_id: undefined
+    source_file_contents: ""
+    defined_in_file: ""
+
+model.defines
+  idAttribute: "class_name"
+  
+  documentation: ()->
+    base = _( @toJSON() ).pick 'header_documentation', 'class_name', 'defined_in_file'
+
+    _.extend base, @metaData(), 
+      componentGroup: @componentGroup() 
+      componentType: @componentType() 
+      componentTypeAlias: @componentTypeAlias()
+      details:
+        publicMethods:        @documentationFor("publicMethods")
+        privateMethods:       @documentationFor("privateMethods")
+        privateProperties:    @documentationFor("privateProperties")
+        publicProperties:     @documentationFor("publicProperties")
+
+  documentationFor: (methodOrPropertyGroup="publicMethods")->
+    documentationSource = _.extend({}, @get("defines_methods"), @get("defines_properties"))
+
+    result = {}
+
+    if list = @metaData()?[ methodOrPropertyGroup ]?()
+      _(list).reduce (memo, methodOrProperty)->
+        memo[ methodOrProperty ] = documentationSource[ methodOrProperty ]
+        memo
+      , result  
+
+    result
+
+  url: ()->
+    "/project/components/#{ Luca.namespace }/#{ @classNameId() }"
+
+  metaData: ()->
+    Luca( @get("class_name") ).prototype.componentMetaData()
+
+  classNameId: ()->
+    @get("class_name").replace(/\./g,'__')
+
+  componentGroup: ()->
+    parts = @get('class_name').split('.')
+    parts.slice(0,2).join('.')
+
+  componentType: ()->
+    type  = "view"
+    parts = @get('class_name').split('.')
+
+    switch group = parts[1]
+      when "collections" then "collection"
+      when "models" then "model"
+      when ("views" || "components" || "pages") then "view"
+
+    return if group?
+
+    if componentPrototype = Luca.util.resolve( @get("class_name") )
+      return "view" if Luca.isViewPrototype( componentPrototype:: )
+      return "collection" if Luca.isCollectionPrototype( componentPrototype:: )
+      return "model" if Luca.isModelProtoype( componentPrototype:: )
+
+    # meh, but what about Router?
+    "view"
+
+  componentTypeAlias: ()->
+    parts = @get('class_name').split('.')
+    name = parts.pop()
+    _.str.underscored( name )

data/app/assets/javascripts/luca/development/components.coffee

@@ -0,0 +1,57 @@
+components = Luca.register   "Luca.collections.Components"
+components.extends            "Luca.Collection"
+
+components.configuration
+  model: Luca.models.Component
+  namespace: "components"
+
+components.classMethods
+  generate: ()->
+    @collection = new Luca.collections.Components()
+    @collection.fetch()
+    @collection
+
+components.defines
+  findByClassName: (class_name)->
+    @detect (model)->
+      model.get("class_name") is class_name
+        
+  filterByNamespace: (namespace)->
+    @query
+      class_name: $like: namespace
+
+  classNames: ()->
+    @pluck('class_name')
+
+  groupsInsideOf: (namespace)->
+    classes = @filterByNamespace(namespace)
+    unique = {}
+    
+    for component in classes when not unique[ component.componentGroup() ]?
+      if component.get("class_name")?.split('.')?.length > 2
+        unique[ component.componentGroup() ] = component.componentGroup().split('.')[1] 
+
+    _.values(unique)
+
+  namespaces: ()->
+    list = _( @classNames() ).map (className)->
+      className.split('.')[0]
+
+    _( list ).uniq()
+
+  fetch: (options={})->
+    @populateFromRegistry(options)
+
+  comparator: (model)->
+    model.get("class_name")
+      
+  populateFromRegistry: (options={})->
+    registeredClassNames = for class_name in Luca.registry.classes(true)
+      {class_name, name: class_name}
+
+    if options.namespace
+      registeredClassNames = for model in registeredClassNames when model.name.match(options.namespace)
+        model
+
+      
+    @reset(registeredClassNames, options={})

data/{src/tools → app/assets/javascripts/luca/development}/console.coffee

@@ -1,6 +1,6 @@
 developmentConsole = Luca.register    "Luca.tools.DevelopmentConsole"
 
-developmentConsole.extends            "Luca.core.Container"
+developmentConsole.extends            "Luca.Container"
 
 developmentConsole.defines
   className: "luca-ui-console"
@@ -188,11 +188,12 @@ Luca.util.launchers.developmentConsole = (name="luca-development-console")->
   @_lucaDevConsole = Luca name, ()=>
     @$el.append Backbone.View::make("div", id: "#{ name }-wrapper", class: "modal fade large")
 
-    console = new Luca.tools.DevelopmentConsole
+    dconsole = new Luca.tools.DevelopmentConsole
       name: name
       container: "##{ name }-wrapper"
 
-    console.render()
-    console.getCodeMirror().setHeight(602)
+    dconsole.render()
+    dconsole.getCodeMirror().setHeight(602)
 
-  @_lucaDevConsole.show()
+  @_lucaDevConsole.show()
+  Luca(name)

data/app/assets/javascripts/luca/development/index.coffee

@@ -0,0 +1,5 @@
+#= require ./code_mirror_field
+#= require ./console
+#= require ./code_sync_manager
+#= require ./component
+#= require ./components

data/{src → app/assets/javascripts/luca}/framework.coffee

@@ -1,8 +1,5 @@
-# the Luca() browser utility function is meant to be a smart wrapper around various
-# types of input which will return what the developer would expect given the
-# context it is used.
 lucaUtilityHelper = (payload, args...)->
-  unless payload?
+  if arguments.length is 0 
     return _( Luca.Application.instances ).values()?[0]
 
   if _.isString(payload) and result = Luca.cache(payload)
@@ -20,17 +17,14 @@ lucaUtilityHelper = (payload, args...)->
   if _.isObject(payload) and payload.ctype?
     return Luca.util.lazyComponent( payload )
 
-  if _.isObject(payload) and payload.defines and payload.extends
-    definition = payload.defines
-    inheritsFrom = payload.extends
-
   if _.isFunction( fallback = _(args).last() )
     return fallback()
 
 (window || global).Luca = ()-> lucaUtilityHelper.apply(@, arguments)
 
+Luca.VERSION = '0.9.9'
+
 _.extend Luca,
-  VERSION: "0.9.76"
   core: {}
   collections: {}
   containers: {}
@@ -42,54 +36,17 @@ _.extend Luca,
   registry:{}
   options: {}
   config: {}
+  logger: (trackerMessage)->
+    (args...)->
+      args.unshift( trackerMessage )
+      console.log(@, args)
+
   getHelper: ()->
     ()-> lucaUtilityHelper.apply(@, arguments)
 
 # for triggering / binding to component definitions
 _.extend Luca, Backbone.Events
 
-Luca.config.maintainStyleHierarchy = true
-Luca.config.maintainClassHierarchy = true
-Luca.config.autoApplyClassHierarchyAsCssClasses = true
-
-# When using Luca.define() should we automatically register
-# the component with the registry?
-Luca.autoRegister = Luca.config.autoRegister = true
-
-# if developmentMode is true, you have access to some neat development tools
-Luca.developmentMode = Luca.config.developmentMode = false
-
-# The Global Observer is very helpful in development
-# it observes every event triggered on every view, collection, model
-# and allows you to inspect / respond to them.  Use in production
-# may have performance impacts which has not been tested
-Luca.enableGlobalObserver = Luca.config.enableGlobalObserver = false
-
-# let's use the Twitter 2.0 Bootstrap Framework
-# for what it is best at, and not try to solve this
-# problem on our own!
-Luca.config.enableBoostrap = Luca.config.enableBootstrap = true
-
-Luca.config.enhancedViewProperties = true
-
-Luca.keys = Luca.config.keys =
-  ENTER: 13
-  ESCAPE: 27
-  KEYLEFT: 37
-  KEYUP: 38
-  KEYRIGHT: 39
-  KEYDOWN: 40
-  SPACEBAR: 32
-  FORWARDSLASH: 191
-
-# build a reverse map
-Luca.keyMap = Luca.config.keyMap = _( Luca.keys ).inject (memo, value, symbol)->
-  memo[value] = symbol.toLowerCase()
-  memo
-, {}
-
-Luca.config.showWarnings = true
-
 Luca.setupCollectionSpace = (options={})->
   {baseParams, modelBootstrap} = options
 
@@ -106,7 +63,10 @@ Luca.setupCollectionSpace = (options={})->
 # Creates a basic Namespace for you to begin defining
 # your application and all of its components.
 Luca.initialize = (namespace, options={})->
-  defaults = 
+  Luca.namespace = namespace.toLowerCase()
+  existing       = Luca.util.resolve(namespace, window || global) || {}
+
+  _.defaults existing,
     views: {}
     collections: {}
     models: {}
@@ -122,30 +82,29 @@ Luca.initialize = (namespace, options={})->
       Luca.getApplication?.apply(@, arguments)
     getCollectionManager: ()->
       Luca.CollectionManager.get?.apply(@, arguments)
+    route: Luca.routeHelper
 
 
   object = {}
-  object[ namespace ] = _.extend(Luca.getHelper(), defaults)
+  object[ namespace ] = _.defaults(Luca.getHelper(), existing)
 
   _.extend(Luca.config, options)
   _.extend (window || global), object
 
+  Luca.lastNamespace = namespace
   Luca.concern.namespace "#{ namespace }.concerns"
   Luca.registry.namespace "#{ namespace }.views"
   Luca.Collection.namespace "#{ namespace }.collections"
 
   Luca.on "ready", ()->
-    Luca.define.close()
     Luca.setupCollectionSpace(options)
 
 Luca.onReady = (callback)->
+  Luca.define.close()
   Luca.trigger("ready")
 
   $ -> callback.apply(@, arguments)
 
-Luca.warn = (message)->
-  console.log(message) if Luca.config.showWarnings is true
-
 Luca.find = (el)->
   Luca( $(el).data('luca-id') )
 
@@ -208,48 +167,6 @@ Luca.parentClass = (obj, resolve=true)->
   if resolve then Luca.util.resolve(parent) else parent
 
 
-# This is a convenience method for accessing the templates
-# available to the client side app, either the ones which ship with Luca
-# available in Luca.templates ( these take precedence ) or
-# the app's own templates which are usually available in JST
-
-# optionally, passing in variables will compile the template for you, instead
-# of returning a reference to the function which you would then call yourself
-Luca.template = (template_name, variables)->
-  window.JST ||= {}
-
-  if _.isFunction(template_name)
-    return template_name(variables)
-
-  luca = Luca.templates?[ template_name ]
-  jst = JST?[ template_name ]
-
-  unless luca? or jst?
-    needle = new RegExp("#{ template_name }$")
-
-    luca = _( Luca.templates ).detect (fn,template_id)->
-      needle.exec( template_id )
-
-    jst = _( JST ).detect (fn,template_id)->
-      needle.exec( template_id )
-
-  throw "Could not find template named #{ template_name }" unless luca || jst
-
-  template = luca || jst
-
-  return template(variables) if variables?
-
-  template
-
-Luca.available_templates = (filter="")->
-  available = _( Luca.templates ).keys()
-
-  if filter.length > 0
-    _( available ).select (tmpl)-> tmpl.match(filter)
-  else
-    available
-
-
 UnderscoreExtensions =
   module: (base,module)->
     _.extend base, module

data/app/assets/javascripts/luca/index.coffee

@@ -0,0 +1,8 @@
+#= require_tree ./templates
+#= require ./framework
+#= require ./config
+#= require ./util
+#= require ./core
+#= require ./managers
+#= require ./containers
+#= require ./components

data/{src → app/assets/javascripts/luca}/managers/collection_manager.coffee

@@ -3,6 +3,7 @@ class Luca.CollectionManager
 
   __collections: {}
 
+  autoStart: true
   relayEvents: true 
 
   constructor: (@options={})->
@@ -29,7 +30,9 @@ class Luca.CollectionManager
     @state = new Luca.Model()
 
     if @initialCollections
-      handleInitialCollections.call(@)
+      @on "ready", handleInitialCollections, @
+
+    @trigger "ready" if @autoStart is true
 
   add: (key, collection)->
     @currentScope()[ key ] ||= collection
@@ -85,7 +88,6 @@ class Luca.CollectionManager
 
   collectionCountDidChange: ()->
     if @allCollectionsLoaded() 
-      # for backwards compat
       @trigger "all_collections_loaded" 
       @trigger "initial:load"
 
@@ -111,10 +113,12 @@ Luca.CollectionManager.destroyAll = ()->
 
 Luca.CollectionManager.loadCollectionsByName = (set, callback)->
   for name in set 
-    collection = @getOrCreate(name)
-    collection.once "reset", ()->
-      callback(collection)
-    collection.fetch()  
+    if collection = @getOrCreate(name)
+      collection.on "reset", ()->
+        callback(collection)
+        collection.unbind("reset", @)
+
+      collection.fetch()  
 
 #### Private Methods
 guessCollectionClass = (key)->
@@ -152,12 +156,12 @@ loadInitialCollections = ()->
 
 handleInitialCollections = ()->
   @state.set({loaded_collections_count: 0, collections_count: @initialCollections.length })
-  @state.bind "change:loaded_collections_count", ()=> @collectionCountDidChange()
+  @state.bind "change:loaded_collections_count", ()=> 
+    @collectionCountDidChange()
 
   if @useProgressLoader
     @loaderView ||= new Luca.components.CollectionLoaderView(manager: @,name:"collection_loader_view")
 
   loadInitialCollections.call(@)
 
-  @initialCollectionsLoadedu
   @

data/app/assets/javascripts/luca/managers/index.coffee

@@ -0,0 +1,2 @@
+#= require ./collection_manager
+#= require ./socket_manager

data/app/assets/javascripts/luca/managers/socket_manager.coffee

@@ -0,0 +1,89 @@
+# The SocketManager provides communication between a Websocket / Pubsub
+# system and routes messages through the application to instances
+# of a specific view, model, collection, or other Backbone.Events object. 
+#
+# You will need to create the socket manager specifying your provider and host:
+#       @socket = new Luca.SocketManager(host:"//localhost:9292/faye")
+#
+socketManager = Luca.register "Luca.SocketManager"
+socketManager.extends         "Luca.Model"
+
+socketManager.defines
+  # The SocketManager can be configured with the following options:
+  #
+  # autoStart: default(true) immediately begins to load the provider
+  # script, setup the connection, etc
+  #
+  # provider: faye.js or socket.io
+  defaults:
+    autoStart: true  
+    providerAvailable: false
+    ready: false
+    provider: "faye.js"
+
+  initialize: (@attributes={})->
+    unless @providerLibraryIsAvailable()
+      @loadProviderSource() 
+
+    Luca.Model::initialize?.apply(@, arguments)
+
+    model = @
+
+    connectOnReady = ()=> 
+      @connect() if @isReady()
+
+    model.on "change:ready", ()->
+      connectOnReady()
+      model.unbind("change:ready", @)
+
+    model.on "change:providerAvailable", ()->
+      connectOnReady()
+      model.unbind("change:ready", @)
+
+    @on "ready", _.once ()=> @set('ready', true)
+
+    @trigger "change"
+
+  # The socket manager is ready once 'ready' event has been
+  # triggered on it.  ( usually by the application ). and once
+  # the provider client library as been loaded.
+  isReady: ()->
+    @get("ready") is true and @get("providerAvailable") is true
+
+  providerLibraryIsAvailable: ()->
+    providerTest = switch @get('provider')
+      when "socket.io"
+        "io"
+      when "faye.js"
+        "Faye.Client"
+
+    !!(Luca.util.resolve(providerTest)?)
+
+  connect: ()->
+    switch @get('provider')
+      when "socket.io"
+        @client = io.connect( @get('host') )
+      when "faye.js"
+        @client = new Faye.Client(@get('host'))
+        @set("client", @client)
+
+  providerSourceLoaded: ()-> 
+    @set "providerAvailable", true
+
+  providerSourceUrl: ()->
+    switch @get('provider')
+      when "socket.io" then "#{  @get('host')  }/socket.io/socket.io.js"
+      when "faye.js" then "#{  @get('host')  }/faye.js"
+
+  loadProviderSource: ()->
+    script = document.createElement 'script'
+    script.setAttribute "type", "text/javascript"
+    script.setAttribute "src", @providerSourceUrl()
+    script.onload = _.bind(@providerSourceLoaded,@)
+
+    if Luca.util.isIE()
+      script.onreadystatechange = ()=>
+        if script.readyState is "loaded"
+          @providerSourceLoaded()
+
+    document.getElementsByTagName('head')[0].appendChild script