luca 0.9.9 → 0.9.42

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

@@ -1,2 +0,0 @@
-#= require ./container
-#= require_directory .

data/app/assets/javascripts/luca/containers/page_controller.coffee

@@ -1,25 +0,0 @@
-# The PageController container is a special type of container whose components or pages
-# will always monopolize the entire element's display and where only one page or component
-# will be visible at a time.  The PageController is typically going to be at the very root
-# of every application, and will be directly integrated with the application's router. 
-# A typical application hierarchy will be an abstract `Viewport` with a single top level
-# `PageController` named 'main_controller'. 
-#
-#       - Viewport / Application
-#         - Router. ( maps urls to named pages on the controller )
-#         - Main Page Controller
-#           - Pages
-#             - Named views / containers
-view = Luca.register    "Luca.containers.PageController"
-view.extends            "Luca.Container"
-
-view.privateMethods
-  initialize: (@options={})->
-    @components ||= @pages || @options.pages
-    for component in @components
-      component.components ||= component.pages
-
-    Luca.Container::initialize.apply(@, arguments)
-
-view.register()  
-

data/app/assets/javascripts/luca/core/events.coffee

@@ -1,114 +0,0 @@
-# Luca.Events
-#
-# These helpers will get mixed into Luca.Collection, Luca.View, and Luca.Model.
-#
-# They allow for syntactic sugar like:
-#
-# view.defer("someMethodOnTheView").until("collection","fetch")
-#
-# or
-#
-# view.defer( myCallback ).until("triggered:event")
-class Luca.DeferredBindingProxy
-  constructor: (@object, operation, wrapWithUnderscore=true)->
-    if _.isFunction(operation)
-      fn = operation
-
-    else if _.isString(operation) and _.isFunction(@object[operation])
-      fn = @object[operation]
-
-    unless _.isFunction(fn)
-      throw "Must pass a function or a string representing one"
-
-    if wrapWithUnderscore is true
-      @fn = _.bind ()->
-        _.defer(fn)
-      , @object
-    else
-      @fn = _.bind(fn,@object)
-
-    @
-
-  # until accepts an object to bind to, and a trigger to bind with
-  # if you just pass a trigger, the object getting bound to
-  # will implicitly be @object
-  until: (watch, trigger)->
-    if watch? and not trigger?
-      trigger = watch
-      watch = @object
-
-    watch.once(trigger, @fn)
-
-    @object
-
-class Luca.EventRelayer
-  constructor: (options={})->
-    {@target,@events,@prefix,@source} = options
-
-    if @events.length > 0 and @target and @source
-      @setup()
-    @
-
-  prefixedBy: (@prefix="")->
-    @
-
-  from:(@source)->
-    @
-
-  to: (@target)->
-    @
-
-  setup: (@target)->
-    prefix = @prefix
-    target = @target
-
-    for eventId in @events
-      console.log "Binding to ", eventId, prefix, @target.name, @source.name
-      @source.on eventId, (args...)->
-        trigger = _( [prefix,eventId] ).compact().join(':')
-        args.unshift(trigger)
-        @trigger.apply(@, args)
-      , target
-
-
-Luca.Events =
-  relays: (events...)->
-    new Luca.EventRelayer(relayer: @, events: events)
-
-  defer: (operation, wrapWithUnderscore=true)->
-    new Luca.DeferredBindingProxy(@, operation, wrapWithUnderscore)
-
-  once: (trigger, callback, context)->
-    context ||= @
-
-    onceFn = ()->
-      callback.apply(context, arguments)
-      @unbind(trigger, onceFn)
-
-    @bind trigger, onceFn
-
-
-Luca.EventsExt =
-  waitUntil:(trigger, context)->
-    @waitFor.call(@, trigger, context )
-
-  waitFor: (trigger, context)->
-    self = @
-    proxy =
-      on:(target)->
-        target.waitFor.call(target,trigger,context)
-      and:(runList...)->
-        for fn in runList
-          fn = if _.isFunction(fn) then fn else self[fn]
-          self.once(trigger, fn, context)
-      andThen: ()->
-        self.and.apply(self, arguments)
-
-  relayEvent: (trigger)->
-    on: (components...)=>
-      to: (targets...)=>
-        for target in targets
-          for component in components
-            component.on trigger, (args...)=>
-              args.unshift(trigger)
-              target.trigger.apply(target,args)

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

@@ -1,12 +0,0 @@
-#= require ./registry
-#= require ./observer
-#= require ./events
-#= require ./templates
-#= require_tree ../concerns
-#= require ./model
-#= require ./collection
-#= require ./view
-#= require ./panel
-#= require_self
-
-

data/app/assets/javascripts/luca/core/model.coffee

@@ -1,56 +0,0 @@
-model = Luca.register     'Luca.Model'
-
-model.extends             'Backbone.Model'
-
-model.includes            'Luca.Events'
-
-model.defines
-  initialize: ()->
-    Backbone.Model::initialize(@, arguments)
-    setupComputedProperties.call(@)
-    Luca.concern.setup.call(@)
-
-  read: (attr)->
-    if _.isFunction(@[attr])
-      @[attr].call(@)
-    else
-      @get(attr) || @[attr]
-
-  get: (attr)->
-    if @computed?.hasOwnProperty(attr)
-      @_computed[attr]
-    else
-      Backbone.Model::get.call @, attr
-
-setupComputedProperties = ()->
-  return if _.isUndefined(@computed)
-
-  @_computed = {}
-
-  for attr, dependencies of @computed
-    @on "change:#{attr}", ()=>
-      @_computed[attr] = @read(attr) 
-
-    dependencies = dependencies.split(',') if _.isString(dependencies)
-
-    _(dependencies).each (dep)=>
-      @on "change:#{dep}", ()=>
-        @trigger "change:#{attr}"
-        
-      @trigger "change:#{attr}" if @has(dep) 
-
-
-Luca.Model._originalExtend = Backbone.Model.extend
-
-Luca.Model.extend = (definition={})->
-  # for backward compatibility
-  definition.concerns ||= definition.concerns if definition.concerns?
-
-  componentClass = Luca.Model._originalExtend.call(@, definition)
-  
-  if definition.concerns? and _.isArray( definition.concerns )
-    for module in definition.concerns
-      Luca.decorate( componentClass ).with( module )
-
-  componentClass
-

data/app/assets/javascripts/luca/core/panel.coffee

@@ -1,124 +0,0 @@
-# Luca.Panel is a low level Luca.View component which is used 
-# to build components which have toolbar areas, and a body area for the main
-# contents of the view.
-panel = Luca.register           "Luca.Panel"
-
-panel.replaces                  "Luca.Panel"
-
-panel.extends                   "Luca.View"
-
-panel.configuration
-  topToolbar: undefined
-  bottomToolbar: undefined
-  #loadMask: false
-  #loadMaskTemplate: "components/load_mask"
-  #loadMaskTimeout: 3000
-
-panel.publicMethods
-  applyStyles: (styles={},body=false)->
-
-    target = if body then @$bodyEl() else @$el
-
-    for setting, value  of styles
-      target.css(setting,value)
-
-    @
-
-  $bodyEl: ()->
-    element = @bodyTagName || "div"
-    className = @bodyClassName || "view-body"
-
-    @bodyEl ||= "#{ element }.#{ className }"
-
-    bodyEl = @$(@bodyEl)
-
-    return bodyEl if bodyEl.length > 0
-
-    if bodyEl.length is 0 and (@bodyClassName? || @bodyTagName?)
-      newElement = @make(element,class:className,"data-auto-appended":true)
-      @$el.append( newElement )
-      return @$(@bodyEl)
-
-    @$el
-
-  $wrap: (wrapper)->
-    if _.isString(wrapper) and not wrapper.match(/[<>]/)
-      wrapper = @make("div",class:wrapper)
-
-    @$el.wrap( wrapper )
-
-  $template: (template, variables={})->
-    @$html( Luca.template(template,variables) )
-
-  $empty: ()->
-    @$bodyEl().empty()
-    
-  $html: (content)->
-    if content? then @$bodyEl().html( content ) else @$bodyEl().html()
-
-  $append: (content)->
-    @$bodyEl().append(content)
-
-panel.privateMethods
-  beforeRender: ()->
-    Luca.View::beforeRender?.apply(@, arguments)
-    @applyStyles( @styles ) if @styles?
-    @applyStyles( @bodyStyles, true ) if @bodyStyles?
-    @renderToolbars?()
-
-  renderToolbars: ()->
-    _( ["top","left","right","bottom"] ).each (orientation)=>
-      if config = @["#{ orientation }Toolbar"]
-        @renderToolbar( orientation, config)
-
-  renderToolbar: (orientation="top", config={})->
-    config.parent = @
-    config.orientation = orientation
-    el = Luca.util.read( config.container )
-    el ||= Luca.util.read( config.targetEl )
-
-    Luca.Panel.attachToolbar.call(@, config, el )
-
-panel.classMethods
-  attachToolbar: (config={}, targetEl)->
-    config.orientation ||= "top"
-    config.type ||= config.ctype ||= @toolbarType || "panel_toolbar"
-
-    config.additionalClassNames = "#{ Luca.config.toolbarContainerClass } #{ config.orientation }"
-  
-    toolbar = Luca.util.lazyComponent( config )
-    # TEMP
-    # Do this properly
-    if config.orientation is "bottom"
-      @getBottomToolbar ||= ()-> toolbar   
-
-    if config.orientation is "top"
-      @getTopToolbar ||= ()-> toolbar   
-
-    if config.orientation is "right"
-      @getRightToolbar ||= ()-> toolbar   
-
-    if config.orientation is "left"
-      @getLeftToolbar ||= ()-> toolbar   
-
-    hasBody = @bodyClassName or @bodyTagName
-
-    action = config.attachmentAction
-    # there will be a body panel inside of the views $el
-    # so just place the toolbar before, or after the body
-    action ||= switch config.orientation
-      when "top", "left"
-        if hasBody and not targetEl?.length > 0 then "before" else "prepend"
-
-      when "bottom", "right"
-        if hasBody and not targetEl?.length > 0 then "after" else "append"
-
-    toolbarEl = if targetEl?.length > 0
-      @$(targetEl)
-    else
-      @$bodyEl()
-
-    toolbarEl[action]( toolbar.render().el )
-
-panel.defines
-  version: 3

data/app/assets/javascripts/luca/core/registry/component_definition.coffee

@@ -1,319 +0,0 @@
-# Component Definition Helpers
-#
-# We have customized the core Backbone.extend process to use a slightly
-# different syntax, which allows us to intercept the component definition at
-# various points, and maintain information about classes being defined, and
-# the relationships between inherited classes, etc.
-#
-# Under the hood it isn't much more than Backbone.View.extend(@proto)  
-#
-# Luca provides a self-documenting component generation language which
-# allows you to build the @proto property in a way which captures the intent
-# of the interface being described.  
-#
-# Example:
-#   myForm = MyApp.register    'MyForm'
-# 
-#   myForm.extends             'Luca.components.FormView'
-#
-#   myForm.triggers            'some:custom:hook'
-#
-#   myForm.publicMethods
-#     publicMethod: ()-> ...
-#
-#   myForm.classMethods 
-#     classMethod: ()-> ...
-#
-# This gives us the ability to inspect our component registry at run time,
-# auto-generate nice documentation, build development tools, etc.
-
-class ComponentDefinition
-  constructor:(componentName, @autoRegister=true)->
-    @namespace = Luca.util.namespace()
-    @componentId = @componentName = componentName
-    @superClassName = 'Luca.View' 
-    @properties ||= {}
-    @_classProperties ||= {}
-
-    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('.') )
-
-    Luca.define.__definitions.push(@)
-
-  @create: (componentName, autoRegister=Luca.config.autoRegister)->
-    new ComponentDefinition(componentName, autoRegister)
-
-  isValid: ()->
-    return false unless _.isObject(@properties) 
-    return false unless Luca.util.resolve(@superClassName)?
-    return false unless @componentName?
-    true
-
-  isDefined: ()->
-    @defined is true
-
-  isOpen: ()->
-    !!(@isValid() and not @isDefined())
-
-  meta: (key, value)->
-    metaKey = @namespace + '.' + @componentId
-    metaKey = metaKey.replace(/^\./,'')
-    data = Luca.registry.addMetaData(metaKey, key, value)
-
-    @properties.componentMetaData = ()->
-      Luca.registry.getMetaDataFor(metaKey)
-
-  # allow for specifying the namespace
-  in: (@namespace)-> @
-
-  # allow for multiple ways of saying the same thing for readability purposes
-  from: (@superClassName)-> 
-    @
-  extends: (@superClassName)-> 
-    @
-  extend: (@superClassName)-> 
-    @
-
-  aliases: (@_aliases...)->
-    @meta("aliases", @_aliases)
-    @
-
-  replaces: (replaces...)->
-    @_aliases ||= []
-    for old in replaces
-      @_aliases.push(old)
-      Luca.util.deprecateComponent(old, @componentName)
-
-  triggers: (hooks...)->
-    _.defaults(@properties ||= {}, hooks: []) 
-    for hook in hooks
-      @properties.hooks.push(hook) 
-
-    @properties.hooks = _.uniq(@properties.hooks)
-
-    @meta("hooks", @properties.hooks)
-    @
-
-  includes: (includes...)->
-    _.defaults(@properties ||= {}, include: []) 
-    for include in includes
-      @properties.include.push(include) 
-    @properties.include = _.uniq(@properties.include)
-    @meta("includes", @properties.include)
-    @
-
-  mixesIn: (concerns...)->
-    _.defaults(@properties ||= {}, concerns: []) 
-    for concern in concerns
-      @properties.concerns.push(concern) 
-    @properties.concerns = _.uniq(@properties.concerns)
-
-    @meta("concerns", @properties.concerns)
-    @
-
-  contains: (components...)->
-    _.defaults(@properties, components: [])
-    @properties.components = components 
-    @
-
-  validatesConfigurationWith:(validationConfiguration={})->
-    @meta "configuration validations", validationConfiguration
-    @properties.validatable = true
-    @
-
-  beforeDefinition: (callback)->
-    @_classProperties.beforeDefinition = callback  
-    @
-
-  afterDefinition: (callback)->
-    @_classProperties.afterDefinition = callback  
-    @
-
-  classConfiguration: (properties={})->
-    @meta("class configuration", _.keys(properties))
-    _.defaults((@_classProperties||={}), properties)
-    @
-
-  configuration: (properties={})->
-    @meta("public configuration", _.keys(properties) )
-    _.defaults((@properties||={}), properties)
-    @
-
-  publicConfiguration: (properties={})->
-    @meta("public configuration", _.keys(properties) )
-    _.defaults((@properties||={}), properties)
-    @
-
-  privateConfiguration: (properties={})->
-    @meta("private configuration", _.keys(properties) )
-    _.defaults((@properties||={}), properties)
-    @
-
-  classInterface: (properties={})->
-    @meta("class interface", _.keys(properties))
-    _.defaults((@_classProperties||={}), properties)
-    @
-
-  methods: (properties={})->
-    @meta("public interface", _.keys(properties) )
-    _.defaults((@properties||={}), properties)
-    @
-
-  public: (properties={})->
-    @meta("public interface", _.keys(properties) )
-    _.defaults((@properties||={}), properties)
-    @
-
-  publicInterface: (properties={})->
-    @meta("public interface", _.keys(properties) )
-    _.defaults((@properties||={}), properties)
-    @
-
-  private: (properties={})->
-    @meta("private interface", _.keys(properties) )
-    _.defaults((@properties||={}), properties)
-    @
-
-  privateInterface: (properties={})->
-    @meta("private interface", _.keys(properties) )
-    _.defaults((@properties||={}), properties)
-    @
-
-  # This is the end of the chain. It MUST be called
-  # in order for the component definition to be complete. 
-  definePrototype: (properties={})->
-    _.defaults((@properties||={}), properties)
-
-    at = if @namespaced
-      Luca.util.resolve(@namespace, (window || global))
-    else
-      (window||global)
-
-    # automatically create the namespace
-    if @namespaced and not at?
-      eval("(window||global).#{ @namespace } = {}")
-      at = Luca.util.resolve(@namespace,(window || global))
-
-    @meta("super class name", @superClassName )
-    @meta("display name", @componentName)
-
-    @properties.displayName = @componentName
-    
-    @properties.componentMetaData = ()->
-      Luca.registry.getMetaDataFor(@displayName)
-
-    @_classProperties?.beforeDefinition?(@)
-
-    definition = at[@componentId] = Luca.extend(@superClassName,@componentName, @properties)
-
-    if _.isArray( @properties?.include )
-      for include in @properties.include
-        include = Luca.util.resolve(include) if _.isString(include)
-        if not include?
-          console.log "Attempt to include module failed. #{ include } not defined."
-        _.extend(definition::, include)
-
-    if @_aliases?
-      for alias in @_aliases
-        eval("#{ alias } = definition;")
-
-    if @autoRegister is true 
-      componentType = "view" if Luca.isViewPrototype( definition )
-
-      if Luca.isCollectionPrototype( definition )
-        Luca.Collection.namespaces ||= []
-        Luca.Collection.namespaces.push( @namespace )
-        componentType = "collection" 
-
-      componentType = "model" if Luca.isModelPrototype( definition )
-
-      # automatically register this with the component registry
-      type_alias = _.string.underscored(@componentId)
-      Luca.registerComponent( type_alias, @componentName, componentType)
-
-    @defined = true
-
-    unless _.isEmpty(@_classProperties)
-      _.extend(definition, @_classProperties)
-
-
-
-    definition?.afterDefinition?.call(definition, @)
-
-    definition
-
-
-# Aliases for the mixin definition
-cd = ComponentDefinition::
-
-cd.concerns = cd.behavesAs = cd.uses = cd.mixesIn 
-
-# Aliases for the final call on the define proxy
-cd.register = cd.defines = cd.defaults = cd.exports = cd.defaultProperties = cd.definePrototype
-
-cd.defaultsTo = cd.enhance = cd.with = cd.definePrototype
-
-cd.publicMethods = cd.publicInterface
-cd.privateMethods = cd.privateInterface
-cd.classProperites = cd.classMethods = cd.classInterface
-
-_.extend (Luca.define = ComponentDefinition.create),
-  __definitions: []
-  incomplete: ()->
-    _( Luca.define.__definitions ).select (definition)-> 
-      definition.isOpen()
-  close: ()->
-    for open in Luca.define.incomplete()
-      open.register() if open.isValid()
-    Luca.define.__definitions.length = 0
-  findDefinition: (componentName)->
-    _( Luca.define.__definitions ).detect (definition)->
-      definition.componentName is componentName
-
-Luca.register = (componentName)->
-  new ComponentDefinition(componentName, true)
-
-_.mixin def: Luca.define
-
-# The last method of the ComponentDefinition chain is always going to result in
-# a call to Luca.extend.  Luca.extend wraps the call to Luca.View.extend,
-# or Backbone.Collection.extend, and accepts the names of the extending,
-# and extended classes as strings.  This allows us to maintain information
-# and references to the classes and their prototypes, mainly for the purposes
-# of introspection and development tools
-Luca.extend = (superClassName, childName, properties={})->
-  superClassName  = Luca.util.checkDeprecationStatusOf(superClassName)
-  superClass      = Luca.util.resolve( superClassName, (window || global) )
-
-  unless _.isFunction(superClass?.extend)
-    throw "Error defining #{ childName }. #{ superClassName } is not a valid component to extend from"
-
-  superMetaData = Luca.registry.getMetaDataFor(superClassName)
-  superMetaData.descendants().push(childName)
-
-  properties.displayName = childName
-
-  properties._superClass = ()->
-    superClass.displayName ||= superClassName
-    superClass
-
-  properties._super = (method, context=@, args=[])->
-    # TODO: debug this better
-    # protect against a stack too deep error in weird cases
-    @_superClass().prototype[method]?.apply(context, args)
-
-  definition = superClass.extend(properties)
-
-  if _.isArray( properties?.include )
-    for include in properties.include
-      include = Luca.util.resolve(include) if _.isString(include)
-      _.extend(definition::, include)
-
-  definition
-