lanes 0.1.9.5 → 0.3.0

data/client/lanes/models/query/CollectionResult.coffee

@@ -0,0 +1,71 @@
+class Lanes.Models.Query.CollectionResult extends Lanes.Models.Query.Result
+
+    constructor: (@query) ->
+        @collection.on('add remove reset', =>
+            @query.trigger('change', @query)
+        )
+        @collection.on('sort', =>
+            @query.changeCount += 1
+        )
+
+        this
+
+    rowAt: (index, options = {}) ->
+        model = @collection.at(index)
+        for field, i in @query.fields.models
+            model[field.id]
+
+    allRows: (options) ->
+        rows = (@rowAt(i, options) for i in [0...@length])
+        _.Promise.resolve(rows)
+
+    modelAt: (index) ->
+        @collection.at(index)
+
+    saveModelChanges: (model, index) ->
+        old = @collection.at(index)
+        @collection.remove(old)
+        @collection.add(model, at:index)
+        @query.changeCount++
+
+    addBlankRow: (index) ->
+        @collection.add({}, at: index)
+
+    removeRow: (index = 0) ->
+        @collection.remove(
+            @collection.at(index)
+        )
+
+    reload: ->
+        @collection.reload().then(@)
+
+    ensureLoaded: ->
+        @collection.ensureLoaded().then(@)
+
+    reset: Lanes.emptyFn
+
+    rowRepresentation: (rowNum) ->
+        @modelAt(rowNum)
+
+    valueForField: (rowNum, field) ->
+        @modelAt(rowNum)[field.id]
+
+    fieldToSortValue:
+        any:    (v) -> v
+        bigdec: (v) -> parseFloat(v)
+
+    _updateSort: ->
+        field = @query.sortField
+        asc = @query.sortAscending
+        f2v = @fieldToSortValue[field.type] || @fieldToSortValue.any
+        @collection.comparator = field.sortBy or (a, b) ->
+            a = f2v(a[field.id]); b = f2v(b[field.id])
+            result = if a < b then -1 else if a > b then 1 else 0
+            if asc then result else result * -1
+        @collection.sort()
+
+Object.defineProperties Lanes.Models.Query.CollectionResult.prototype,
+    length:
+        get: -> @query.src.length
+    collection:
+        get: -> @query.src

data/client/lanes/models/query/Result.coffee

@@ -0,0 +1,9 @@
+class Lanes.Models.Query.Result
+
+    @extend: (other) ->
+        _.extend(other.prototype, this.prototype)
+
+    sortingFunction: ->
+        field = @query.sortField
+        return false unless field
+        if _.isFunction field.sortBy then field.sortBy else false

data/client/lanes/react/Component.coffee

@@ -1,7 +1,7 @@
 createHelper = (component, name) ->
     unless component.prototype[name]
         Object.defineProperty(component.prototype, name,
-            configurable: true, enumerable: false
+            configurable: true, enumerable: true
             get: -> @data?.states[name]
             set: (val) ->
                 @data?.rebind("#{name}": val)
@@ -25,7 +25,11 @@ Lanes.React.Component = {
         klass::mixins = _.unique(klass::mixins.concat(mixins))
         comp = React.createClass(klass.prototype)
         extendComponent(comp)
-        Lanes.lib.HotReload?.rememberReact(comp)
-        comp
+        return Lanes.lib.HotReload.remember(comp)
+}
 
+Lanes.React.BaseComponent = {
+    extend: (klass, mixins = @defaultMixins) ->
+        comp = React.createClass(klass.prototype)
+        return Lanes.lib.HotReload.remember(comp)
 }

data/client/lanes/react/PubSub.coffee

@@ -4,23 +4,23 @@ class Lanes.Views.PubSub extends Lanes.Views.ModelObserver
     modelEvents:
         'remote-update': 'onChange'
 
-    hideUpdate: (field)->
-        Lanes.dom.removeClass(field,"updated")
+    hideUpdate: (field) ->
+        Lanes.dom.removeClass(field, "updated")
 
-    showUpdate: (field)->
-        Lanes.dom.addClass(field,"updated")
+    showUpdate: (field) ->
+        Lanes.dom.addClass(field, "updated")
         _.delay(@hideUpdate, 3000, field )
 
-    onChange: (model,change)->
+    onChange: (model, change) ->
         return unless change.record == this.getModel()
         for field in change.fields
             this.showUpdate(field) if field = @view.query("[name=#{field}]")
 
-    bindModel: (model)->
+    bindModel: (model) ->
         Lanes.Models.PubSub.add(model)
         super
 
-    unBindModel: (model)->
+    unBindModel: (model) ->
         Lanes.Models.PubSub.remove(model)
         super
 

data/client/lanes/react/Root.cjsx

@@ -5,10 +5,7 @@ Lanes.React.Root = React.createClass
     getChildContext: ->
         viewport: @props.viewport
 
-    propTypes:
-        viewport: Lanes.PropTypes.State.isRequired
-
     render: ->
         <div classNames="root">
-            <Lanes.React.Router.RouteHandler/>
+            {this.props.children}
         </div>

data/client/lanes/react/Screen.coffee

@@ -4,6 +4,7 @@ Lanes.React.Screen = {
         Lanes.React.Mixins.Data
         Lanes.React.Mixins.Viewport
         Lanes.React.Mixins.Screen
+        Lanes.React.Mixins.Access
         Lanes.React.Mixins.RelayEditingState
     ]
 

data/client/lanes/react/TypeValidators.coffee

@@ -7,15 +7,15 @@ checkerFor = (name, checker, isRequired) ->
 
 checkerFor 'Model', (props, propName, componentName) ->
     val = props[propName]
-    if val and (!_.isObject(val) or !val.isModel)
+    if val and (!_.isObject(val) or not Lanes.u.isModel(val))
         return new Error("#{propName} is not a Lanes Model")
 
 checkerFor 'State', (props, propName, componentName) ->
     val = props[propName]
-    if val and (!_.isObject(val) or !val.isState)
+    if val and (!_.isObject(val) or not Lanes.u.isState(val))
         return new Error("#{propName} is not a state object")
 
 checkerFor 'Collection', (props, propName, componentName) ->
     val = props[propName]
-    if val and (!_.isObject(val) or !val.isCollection)
+    if val and (!_.isObject(val) or not Lanes.u.isCollection(val))
         return new Error("#{propName} is not a Lanes Collection")

data/client/lanes/react/Viewport.coffee

@@ -3,28 +3,62 @@ ALL_INSTANCES = []
 class Lanes.React.Viewport extends Lanes.Models.State
 
     @all: -> ALL_INSTANCES
+    @displayError: (msg) -> _.first(ALL_INSTANCES)?.displayError(msg)
 
     session:
         width:      'number'
         height:     'number'
         el:         'element'
         selector:   'string'
-        root:       'element'
+        domRoot:    'element'
+        reactRoot:  'object'
+        lanes:      'element'
+        modalProps: 'object'
 
     constructor: ->
         super
         ALL_INSTANCES.push(this)
-        root = document.body.querySelector(@selector)
+        return unless @selector
+        @domRoot = document.body.querySelector(@selector)
+        _.dom(@domRoot).addClass('lanes-root')
         Lanes.fatal("Root selector #{@selector} not found") unless root
-        _.dom(root).html = "<div class='lanes'/>"
-        Lanes.lib.ResizeSensor(root, _.debounce( =>
+        _.dom(@domRoot).html = "<div class='lanes'/>"
+        this.lanes = @domRoot.querySelector('.lanes')
+        Lanes.lib.ResizeSensor(@domRoot, _.debounce( =>
             @_updateDimensions()
         , 250))
-        this.root = root.querySelector('.lanes')
         this._updateDimensions()
 
+    onBoot: ->
+        prev = _.dom(this.domRoot.previousElementSibling)
+        prev.addClass('complete') if prev.hasClass('loading')
+        _.delay(->
+            prev.remove()
+        , 100)
 
     _updateDimensions: ->
         this.set
-            width:  this.root.clientWidth
-            height: this.root.clientHeight
+            width:  @lanes.clientWidth
+            height: @lanes.clientHeight
+
+
+    displayError: (msg) ->
+        @modalProps = {
+            show: true, buttons: ['OK'], title: 'Error',
+            body: -> React.createElement('h3', {}, msg)
+        }
+
+    hideModal: ->
+        @modalProps = {show: false}
+
+    displayModal: (props) ->
+        @modalProps = _.extend(props, show: true)
+
+    renderRoot: ->
+        cntrl = Lanes.Extensions.controlling()
+        component = cntrl?.rootComponent?(this) ||
+            Lanes.React.Root.DefaultComponentNotFound
+        root = React.createElement(Lanes.React.Root, {viewport: @},
+            React.createElement(component)
+        )
+        @reactRoot = Lanes.Vendor.ReactDOM.render(root, @lanes)

data/client/lanes/react/index.js

@@ -5,4 +5,3 @@
 //= require ./Screen
 //= require ./Root
 //= require ./DefaultComponentNotFound
-//= require ./Router

data/client/lanes/react/mixins/Access.coffee

@@ -1,5 +1,8 @@
 calculateAccess = (comp, props) ->
-    model = comp[comp.modelForAccess || 'model']
+
+    model = _.result(comp, 'modelForAccess') ||
+        comp.commands?.getModel()?.modelForAccess() ||
+        comp.model?.modelForAccess()
 
     accessRight = if props.readonly or comp.context?.readonly
         'r'

data/client/lanes/react/mixins/Data.coffee

@@ -12,32 +12,39 @@ class DataWrapper
         @rebind(_.clone(initialState), silent: true)
 
     rebind: (objects, options = {}) ->
-        customEvents = _.result(@component, 'bindDataEvents') || {}
+        customEvents = _.result(@component, 'bindDataEvents', {})
         for name, state of objects
+            if false == state
+                continue
             unless state
                 Lanes.warn "#{name} is not set on #{@componentName()}"
                 continue
             prevState = @states[name]
+            # onto next if the object is the same
+            continue if prevState == state
+
             @states[name] = state
             this.stopListening(prevState) if prevState
 
             this.bindEvents(name, state, customEvents[name]) if state
 
-            if state.isModel and not ( false == @component.pubsub or false == @component?.pubsub?[name] )
-
-                Lanes.Models.PubSub.remove(prevState) if prevState
-                Lanes.Models.PubSub.add(state)
-
-                @listenTo(state, 'remote-update', @onPubSubChangeSet)
-                @listenToNetworkEvents() if state.listenNetworkEvents
-
-
+            if Lanes.u.isModel(state)
+                @listenToNetworkEvents(state) if @component.listenNetworkEvents
+                unless false == @component.pubsub or false == @component?.pubsub?[name]
+                    if !prevState? or prevState.getId() != state.getId()
+                        Lanes.Models.PubSub.remove(prevState) if prevState
+                        unless false == state.pubsub
+                            if state.isNew()
+                                state.once "change:#{state.idAttribute}", -> Lanes.Models.PubSub.add(state)
+                            else
+                                Lanes.Models.PubSub.add(state)
+                    @listenTo(state, 'remote-update', @onPubSubChangeSet)
         this.setComponentState({}) unless _.isEmpty(objects) or options.silent
 
-    listenToNetworkEvents: ->
-        @listenTo(collection,     'error',   @onError)
-            .listenTo(collection, 'request', @onRequest)
-            .listenTo(collection, 'sync',    @onSync)
+    listenToNetworkEvents: (state) ->
+        @listenTo(state,     'error',     @onError)
+            .listenTo(state, 'request',   @onRequest)
+            .listenTo(state, 'load sync', @onSync)
 
     onPubSubChangeSet: (model, cs) ->
         screen = @component.context?.screen || @component.getChildContext?()?.screen
@@ -46,14 +53,21 @@ class DataWrapper
     componentName: ->
         @component.constructor.displayName
 
+    onProxyReplace: (name, model) ->
+        @states[name] = model
+        @setComponentState(name, model)
+
     bindEvents: (name, state, events) ->
+        if state.isProxy
+            @listenTo(state, 'proxyreplace', _.partial(@onProxyReplace, name))
         if !events
-            if state.isState
+            if state.isState or state.isProxy
                 events ||= 'change'
-            else if state.isCollection
+            else if Lanes.u.isCollection(state)
                 events ||= 'add remove change sort reset'
             else
                 Lanes.warn "Unable to listen to unknown type #{name}"
+
         @listenTo(state, events, _.partial(@setComponentState, name, state))
 
     onError: (modelOrCollection, options) ->
@@ -61,21 +75,21 @@ class DataWrapper
         unless options.silent
             @setComponentState
                 isRequesting: false
-                hasError: true
+                hasError: modelOrCollection?.errorMessage or true
                 error: modelOrCollection.errors
 
     onInvalid: (model, res, options) ->
         @setComponentState(isInvalid: true) unless options.silent
 
-    onRequest: (modelOrCollection, options) ->
+    onRequest: (modelOrCollection, type, options) ->
         # Set `state` only if there's no silent option
         unless options.silent
             @setComponentState
-                isRequesting: true
+                isRequesting: type
                 hasError: false
                 isInvalid: false
 
-    onSync: (modelOrCollection, res, options) ->
+    onSync: (modelOrCollection, res, options = {}) ->
         # Calls `setReactState` only if there's no silent option
         this.setComponentState(isRequesting: false) unless options.silent
 
@@ -90,7 +104,7 @@ class DataWrapper
 
     destroy: (state, events, fn) ->
         for name, state of @states
-            Lanes.Models.PubSub.remove(state) if state?.isModel
+            Lanes.Models.PubSub.remove(state) if Lanes.u.isModel(state)
         this.stopListening()
         delete @component.data
 
@@ -98,11 +112,12 @@ class DataWrapper
 _.extend(DataWrapper.prototype, Lanes.Vendor.BBEvents)
 
 readDataObjects = (comp, newProps) ->
-    bound = _.result(comp, 'dataObjects') || {}
-    bound.model = 'props' if comp.props.model
-    bound.collection = 'props' if comp.props.collection
+    bound = _.clone _.result(comp, 'dataObjects') || {}
+    bound.model ||= 'props' if comp.props.model
+    bound.collection ||= 'props' if comp.props.collection
     _.mapValues(bound, (value, name) ->
-        if _.isFunction(value) then value.call(comp)
+        if _.isFunction(value)
+            if _.isEmpty(comp.data?.states[name]) then value.call(comp) else false
         else if 'props' == value then newProps?[name] or @props[name]
         else value
     , comp)

data/client/lanes/react/mixins/FieldErrors.coffee

@@ -0,0 +1,27 @@
+Lanes.React.Mixins.FieldErrors = {
+
+    mixins: [
+        Lanes.React.Mixins.ReadEditingState
+    ]
+
+    componentWillMount: ->
+        @getInvalidModel()?.maskInvalidFields()
+
+    getInvalidFieldName: ->
+        @props.validity_attribute || @props.name
+
+    getInvalidModel: ->
+        @props.model || _.first _.values @data?.states
+
+    isFieldValueInvalid: ->
+        !!@fieldInvalidValueMessage()
+
+    fieldInvalidValueMessage: ->
+        return '' unless @isEditingRecord()
+        @getInvalidModel()?.invalidMessageFor(
+            @getInvalidFieldName()
+        )
+
+    onFieldInteraction: ->
+        @getInvalidModel()?.unmaskInvalidField( @getInvalidFieldName() )
+}

data/client/lanes/react/mixins/RelayEditingState.coffee

@@ -14,4 +14,8 @@ Lanes.React.Mixins.RelayEditingState = {
         if @props.writable?
             context.writable = @props.writable
         context
+
+    setModelUrl: (model) ->
+        @props.screen.model = model
+
 }

data/client/lanes/react/mixins/Screen.coffee

@@ -1,7 +1,21 @@
 Lanes.React.Mixins.Screen = {
+
     childContextTypes:
         screen: React.PropTypes.object
 
     listenNetworkEvents: true
 
+    loadOrCreateModel: (options) ->
+        if options.prop and @props[options.prop]
+            if options.syncOptions?.include
+                @props[options.prop].withAssociations(options.syncOptions.include, options.syncOptions)
+            @props[options.prop]
+        else
+            model = new options.klass
+            if options.attribute and @props.args?.length
+                model.fetch(_.extend( {}, options.syncOptions, {
+                    query: {"#{options.attribute}": @props.args[0]}
+                })).then => @state?.commands?.setModel(model)
+            model
+
 }