luca 0.8.06 → 0.8.59

data/src/core/container.coffee

@@ -5,7 +5,8 @@
 # it contains, assigning them to a DOM container, and
 # automatically instantiating and rendering the components
 # in their proper place.
-Luca.core.Container = Luca.View.extend
+_.component('Luca.core.Container').extends('Luca.View').with
+
   className: 'luca-ui-container'
 
   componentClass: 'luca-ui-panel'
@@ -182,6 +183,7 @@ Luca.core.Container = Luca.View.extend
         console.log "Error Rendering Component #{ component.name || component.cid }", component
         console.log e.message
         console.log e.stack
+        throw e unless Luca.silenceRenderErrors? is true
 
   #### Container Activation
   #
@@ -261,6 +263,4 @@ Luca.core.Container = Luca.View.extend
     !@getParent?
 
   getRootComponent: ()->
-    if @rootComponent() then @ else @getParent().getRootComponent()
-
-Luca.register "container", "Luca.core.Container"
+    if @rootComponent() then @ else @getParent().getRootComponent()

data/src/core/field.coffee

@@ -1,10 +1,11 @@
-Luca.core.Field = Luca.View.extend
+_.component('Luca.core.Field').extends('Luca.View').with
+
   className: 'luca-ui-text-field luca-ui-field'
-  
+
   isField: true
 
   template: 'fields/text_field'
-   
+
   labelAlign: 'top'
 
   hooks:[
@@ -24,8 +25,8 @@ Luca.core.Field = Luca.View.extend
     _.extend @, @options
     Luca.View::initialize.apply(@, arguments)
 
-    @input_id ||= _.uniqueId('field') 
-    @input_name ||= @name 
+    @input_id ||= _.uniqueId('field')
+    @input_name ||= @name
     @helperText ||= ""
     @label ||= "*#{ @label }" if @required and not @label?.match(/^\*/)
     @inputStyles ||= ""
@@ -43,26 +44,26 @@ Luca.core.Field = Luca.View.extend
 
     @$el.html Luca.templates[ @template ]( @ )
     @input = $('input', @el)
-  
+
   change_handler: (e)->
-    @trigger "on:change", @, e 
+    @trigger "on:change", @, e
 
   disable: ()->
     $("input",@el).attr('disabled', true)
-  
+
   enable: ()->
-    $("input", @el).attr('disabled', false)  
+    $("input", @el).attr('disabled', false)
 
-  getValue: ()-> 
+  getValue: ()->
     @input.attr('value')
 
   render: ()->
     $( @container ).append( @$el )
 
-  setValue: (value)-> 
+  setValue: (value)->
     @input.attr('value', value)
-  
+
   updateState: (state)->
-    _( @statuses ).each (cls)=> 
+    _( @statuses ).each (cls)=>
       @$el.removeClass(cls)
       @$el.addClass(state)

data/src/core/model.coffee

@@ -4,7 +4,7 @@
 # few useful patterns:
 #
 #   - computed properties support
-Luca.Model = Backbone.Model.extend
+_.component('Luca.Model').extends('Backbone.Model').with
   initialize: ()->
     Backbone.Model::initialize @, arguments
 

data/src/core/view.coffee

@@ -35,6 +35,9 @@ Luca.View.extend = (definition)->
     return @
 
   definition.render = ()->
+    if @layoutTemplate?
+      @$el.html()
+
     if @deferrable
       @trigger "before:render", @
 
@@ -64,15 +67,21 @@ Luca.View.extend = (definition)->
 
       return @
 
-  Luca.View.originalExtend.apply @, [definition]
+  Luca.View.originalExtend.call(@, definition)
 
 _.extend Luca.View.prototype,
+  applyStyles: (styles={})->
+    for setting, value  of styles
+      @$el.css(setting,value)
+
+    @
+
   debug: ()->
     return unless @debugMode or window.LucaDebugMode?
     console.log [(@name || @cid),message] for message in arguments
 
   trigger: ()->
-    if Luca.enableGlobalObserver
+    if Luca.enableGlobalObserver and @observeEvents is true
       Luca.ViewObserver ||= new Luca.Observer(type:"view")
       Luca.ViewObserver.relay @, arguments
 
@@ -141,7 +150,7 @@ _.extend Luca.View.prototype,
       parts = eventId.split(':')
       prefix = parts.shift()
 
-      parts = _( parts ).map (p)-> _.capitalize(p)
+      parts = _( parts ).map (p)-> _.string.capitalize(p)
       fn = prefix + parts.join('')
 
       @bind eventId, ()=> @[fn].apply @, arguments if @[fn]

data/src/framework.coffee

@@ -1,20 +1,24 @@
-_.mixin( _.string )
-
 window.Luca =
-  VERSION: "0.8.06"
+  VERSION: "0.8.59"
   core: {}
   containers: {}
   components: {}
   modules: {}
-  fields: {}
   util: {}
-  registry:
-    classes: {}
-    namespaces:["Luca.containers","Luca.components"]
+  fields: {}
   component_cache:
     cid_index: {}
     name_index: {}
+  registry:
+    classes: {}
+    namespaces:["Luca.containers","Luca.components"]
+
 
+# 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 = false
 
 # let's use the Twitter 2.0 Bootstrap Framework
 # for what it is best at, and not try to solve this
@@ -58,12 +62,21 @@ Luca.cache = (needle, component)->
   Luca.component_cache.cid_index[ lookup_id ]
 
 # Takes an string like "deep.nested.value" and an object like window
-# and returns the value of window.deep.nested.value
-Luca.util.nestedValue = (accessor, source_object)->
+# and returns the value of window.deep.nested.value.  useful for defining
+# references on objects which don't yet exist, as strings, which get
+# evaluated at runtime when such references will be available
+Luca.util.resolve = (accessor, source_object)->
   _( accessor.split(/\./) ).inject (obj,key)->
     obj = obj?[key]
   , source_object
 
+# A better name for Luca.util.nestedValue
+Luca.util.nestedValue = Luca.util.resolve
+
+# turns a word like form_view into FormView
+Luca.util.classify = (string="")->
+  _.string.camelize( _.string.capitalize( string ) )
+
 # Lookup a component in the Luca component registry
 # by it's ctype identifier.  If it doesn't exist,
 # check any other registered namespace
@@ -72,16 +85,18 @@ Luca.registry.lookup = (ctype)->
 
   return c if c?
 
-  className = _.camelize _.capitalize( ctype )
+  className = Luca.util.classify(ctype)
 
   parents = _( Luca.registry.namespaces ).map (namespace)-> Luca.util.nestedValue(namespace, (window || global))
 
-  _.first _.compact _( parents ).map (parent)-> parent[className]
+  _( parents ).chain().map((parent)-> parent[className]).compact().value()?[0]
 
-# creates a new object from a hash with a ctype property
-# matching something in the Luca registry
+# one of the main benefits of Luca is the ability to structure your app as
+# large blocks of JSON configuration.  In order to convert an object into
+# a Luca component, we lookup the object's class by converting its ctype / type
+# property into a class that has been registered in the component registry
 Luca.util.lazyComponent = (config)->
-  ctype = config.ctype
+  ctype = config.ctype || config.type
 
   componentClass = Luca.registry.lookup( ctype )
 
@@ -95,8 +110,8 @@ Luca.util.lazyComponent = (config)->
 Luca.register = (component, constructor_class)->
   exists = Luca.registry.classes[component]
 
-  if exists?
-    throw "Can not register component with the signature #{ component }. Already exists"
+  if exists? and !window.TestRun?
+    console.log "Attempting to register component with the signature #{ component }. Already exists"
   else
     Luca.registry.classes[component] = constructor_class
 
@@ -115,5 +130,107 @@ Luca.util.isIE = ()->
   catch e
     return true
 
+# 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 ||= {}
+
+  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 with #{ template_name }" unless luca || jst
+
+  template = luca || jst
+
+  return template(variables) if variables?
+
+  template
+
+#### Component Definition And Inheritance
+#
+# this is a nice way of extending / inheriting
+# this allows for syntactic sugar such as:
+#
+# Luca.define("TestClass").extends("Luca.View").with
+#   property: "value"
+#   name: "whatever"
+#
+# All instances of TestClass defined this way, will have
+# _className properties of 'TestClass' as well as a reference
+# to the extended class 'Luca.View' so that you can inspect
+# an instance of TestClass and know that it inherits from 'Luca.View'
+class DefineProxy
+  constructor:(componentName)->
+    @namespace = (window || global)
+    @componentId = @componentName = componentName
+
+    if componentName.match(/\./)
+      @namespaced = true
+      parts = componentName.split('.')
+      @componentId = parts.pop()
+      @namespace = parts.join('.')
+
+      # automatically add the namespace to the namespace registry
+      Luca.registry.addNamespace( parts.join('.') )
+
+  in: (@namespace)-> @
+  from: (@superClassName)-> @
+  extends: (@superClassName)-> @
+  extend: (@superClassName)-> @
+  with: (properties)->
+    at = if @namespaced then Luca.util.resolve(@namespace, (window || global)) else (window||global)
+
+    if @namespaced and _.isUndefined(at)
+      eval("window.#{ @namespace } = {}")
+      at = Luca.util.resolve(@namespace,(window || global))
+
+    at[@componentId] = Luca.extend(@superClassName,@componentName, properties)
+
+    # automatically register this with the component registry
+    Luca.register( _.string.underscored(@componentId), @componentName)
+
+    at[@componentId]
+
+Luca.define = (componentName)->
+  new DefineProxy(componentName)
+
+# An alias for Luca.define
+# which I think reads better:
+#
+# Luca.component('Whatever').extends('Something').with(enhancements)
+Luca.component = Luca.define
+
+Luca.extend = (superClassName, childName, properties={})->
+  superClass = Luca.util.resolve( superClassName, (window || global) )
+
+  unless _.isFunction(superClass?.extend)
+    throw "#{ superClassName } is not a valid component to extend from"
+
+  properties._className = childName
+
+  properties._superClass = ()->
+    superClass._className ||= superClassName
+    superClass
+
+  superClass.extend(properties)
+
+_.mixin
+  component: Luca.define
+
+#### Once We Are Ready To go....
 $ do ->
-  $('body').addClass('luca-ui-enabled')
+  $('body').addClass('luca-ui-enabled')

data/src/managers/collection_manager.coffee

@@ -125,7 +125,7 @@ class Luca.CollectionManager
     @get(key) || @create(key,collectionOptions,initialModels,false)
 
   guessCollectionClass: (key)->
-    classified = _( key ).chain().capitalize().camelize().value()
+    classified = Luca.util.classify( key )
     guess = (@collectionNamespace || (window || global) )[ classified ]
     guess ||= (@collectionNamespace || (window || global) )[ "#{classified}Collection" ]
     guess

data/src/stylesheets/components/development_console.scss

@@ -29,6 +29,10 @@
       background: rgba(255,255,255,0.2);
    }
 
+   .jquery-console-message {
+    margin:10px 0px;
+   }
+
    .jquery-console-message-error {
       font-weight: bold;
       color: #ef0505;
@@ -37,6 +41,7 @@
 
    .jquery-console-prompt-label {
       font-weight: bold;
+      color: yellow;
    }
  }
 }

data/src/templates/fields/checkbox_array.luca

@@ -0,0 +1,5 @@
+.form-horizontal
+  .control-group
+    %label{:for=>"<%= input_id %>"}
+      <%= label %>
+    .controls

data/src/templates/fields/checkbox_array_item.luca

@@ -0,0 +1,4 @@
+%label{:for => "<%= input_id %>"}
+  %input{:id => "<%= input_id %>", :type => "checkbox", :name => "<%= input_name %>", :value => "<%= value %>"}
+  <%= label %>
+