lanes 0.1.9 → 0.1.9.5

data/client/lanes/models/Sync.coffee

@@ -8,12 +8,10 @@ methodMap = {
     'read':   'GET'
 }
 
-getValue = (object, prop)->
+getValue = (object, prop) ->
     if !(object && object[prop])
-        return null;
-    return if _.isFunction(object[prop]) then object[prop]() else object[prop];
-
-
+        return null
+    return if _.isFunction(object[prop]) then object[prop]() else object[prop]
 
 Lanes.Models.Sync = {
     paramsMap:
@@ -29,63 +27,68 @@ Lanes.Models.Sync = {
     urlError: ->
         throw new Error('A "url" property or function must be specified')
 
-    copyServerReply: (record, reply)->
-        record.errors = reply?.errors
-        record.lastServerMessage = reply?.message
-        { record: record, reply: reply }
+    state: (method, model, options = {}) ->
+        options.url ||= _.result(model, "url")
+        if _.contains(['create', 'update', 'patch'], method)
+            options.data ||= model.dataForSave(options)
+        model.requestInProgress = true
+        model.trigger("request", model, options)
+        return new _.Promise (resolve, reject) ->
+            handler = (reply) ->
+                delete model.requestInProgress
+                model.errors = reply?.errors
+                model.trigger("error", model, options) if reply.errors
+                model.lastServerMessage = reply?.message
+
+                model.setFromServer(reply.data, options, method)
+                model.trigger("sync", model, reply, options)
+                resolve(model)
+
+            Lanes.Models.Sync.perform(method, options).then (reply) ->
+                handler(reply)
+            , (err) ->
+                reply = { errors: { http: err.error.message } }
+                try
+                    reply = JSON.parse(err.body) unless _.isEmpty(err?.body)
+                finally
+                    handler(reply)
 
-    # Wraps a sync request's error and success functions
-    # Copies any errors onto the model and sets it's data on success
-    wrapRequest: (record, options)->
-        error   = options.error
-        success = options.success
-        options.promise = new _.Promise( (resolve,reject)->
-            options.resolvePromise = resolve
-            options.rejectPromise  = reject
-        )
-        options.error = (reply, status, req)->
-            options.rejectPromise(
-                Lanes.Models.Sync.copyServerReply( record,
-                    reply.responseJSON || {error: reply.responseText}
-                )
-            )
-            delete record.requestInProgress
-            error?.apply(options.scope, arguments)
 
-        options.success = (reply, status, req)->
-            record.setFromServer( reply.data, options ) if reply?.data?
-            record.trigger("sync", record, reply, status)
-            options.resolvePromise( Lanes.Models.Sync.copyServerReply(record,reply) )
-            delete record.requestInProgress
-            success?.apply(options.scope, arguments)
-        options
 
-    perform: (method, model, options={})->
+    perform: (method, options = {}) ->
         query = {}
         for key, value of options
             query[ this.paramsMap[key] ] = value if this.paramsMap[key]
 
         # Default JSON-request options.
-        params = {
-            type: methodMap[method]
+        _.defaults(options, {
+            method: methodMap[method]
             dataType: "json"
             data: query
-        }
+        })
 
         # Ensure that we have a URL.
-        params.url = _.result(model, "url") or Lanes.Models.Sync.urlError() unless options.url
-        params.url += '.json'
-
-        params.headers = _.extend({}, _.result(options,'headers'))
-        params.headers['X_CSRF_TOKEN'] = Lanes.config.csrf_token
-        params.contentType = "application/json"
-        if options.data || _.contains(['create','update','patch'], method)
-            params.data = JSON.stringify( options.data || model.dataForSave(options) )
-            delete options.data
+        url = options.url or Lanes.Models.Sync.urlError()
+        options.url += '.json'
+        unless _.isEmpty(query)
+            options.url += '?' + Lanes.lib.objToParam(query)
+        if options.data and !_.isString(options.data)
+            options.originalData = options.data
+            options.data = JSON.stringify( options.data )
+        options.headers ||= {}
+        options.headers['X_CSRF_TOKEN'] = Lanes.config.csrf_token
+        options.contentType = "application/json"
 
         # Make the request, allowing the user to override any Ajax options.
-        xhr = options.xhr = Lanes.$.ajax(_.extend(params, options))
-        model.requestInProgress = true
-        model.trigger("request", model, xhr, options)
-        xhr
+        # xhr = options.xhr = Lanes.$.ajax(_.extend(params, options))
+        new _.Promise( (resolve, reject) ->
+            options.xhr = Lanes.Vendor.xhr(options, (err, resp, body) ->
+                if err
+                    reject(error:err, body:options.xhr.responseText)
+                else
+                    resolve(JSON.parse(body))
+            )
+        )
+
+
 }

data/client/lanes/models/User.coffee

@@ -1,36 +1,31 @@
-unless Lanes.Models.Roles
+unless Lanes.Models.Role
 
-    class Lanes.Models.Role extends Lanes.Models.BasicModel
+    class Lanes.Models.Role extends Lanes.Models.Base
         props:
             id:     'string'
             name:   'string'
             member: { type: 'boolean', default: false }
 
-    class Lanes.Models.Roles extends Lanes.Models.BasicCollection
-        model: Lanes.Models.Role
-
-
 unless Lanes.Models.User
     class Lanes.Models.User extends Lanes.Models.Base
 
-        constructor: (attributes,access)->
+        constructor: (attributes, access) ->
             super
             this.access_data = access
 
-        api_path: 'users'
+        api_path: -> 'users'
+
         derived:
             roles:
                 fn: -> []
             isLoggedIn:
                 fn: -> false
             allRoles:
-                fn: -> new Lanes.Models.Roles
+                fn: -> new Lanes.Models.Role.Collection
 
         session:
             access_data: 'object'
-
-        session:
-            id:          "integer"
+            id:          'integer'
             login:       'string'
             name:        'string'
             email:       'string'
@@ -38,9 +33,28 @@ unless Lanes.Models.User
             options:     'object'
             password:    'string'
 
-        canRead: (model,field)  -> true
-        canWrite: (model,field) -> true
-        canDelete: (model)      -> true
+        canRead:   (model, field) -> true
+        canWrite:  (model, field) -> true
+        canDelete: (model)        -> true
+
+CURRENT_USER = null
+
+Object.defineProperty(Lanes, 'current_user', {
+
+    set: (user) ->
+        events = null
+        if CURRENT_USER
+            events = CURRENT_USER._events
+        if _.any(events)
+            for key, callbacks of events
+                if user._events[key]
+                    user._events[key] = user._events[key].concat(callbacks)
+                else
+                    user._events[key] = callbacks
+        CURRENT_USER = user
+
+    get: ->
+        CURRENT_USER
+})
 
-unless Lanes.current_user
-    Lanes.current_user = new Lanes.Models.User
+Lanes.current_user = new Lanes.Models.User

data/client/lanes/react/Component.coffee

@@ -0,0 +1,31 @@
+createHelper = (component, name) ->
+    unless component.prototype[name]
+        Object.defineProperty(component.prototype, name,
+            configurable: true, enumerable: false
+            get: -> @data?.states[name]
+            set: (val) ->
+                @data?.rebind("#{name}": val)
+        )
+
+extendComponent = (component) ->
+    names = _.keys(component.prototype.dataObjects).concat(['collection', 'model'])
+    for name in _.unique(names)
+        createHelper(component, name)
+
+Lanes.React.Component = {
+
+    defaultMixins: [
+        Lanes.React.Mixins.Data
+        Lanes.React.Mixins.Viewport
+        Lanes.React.Mixins.Component
+    ]
+
+    extend: (klass, mixins = @defaultMixins) ->
+        klass::mixins ||= []
+        klass::mixins = _.unique(klass::mixins.concat(mixins))
+        comp = React.createClass(klass.prototype)
+        extendComponent(comp)
+        Lanes.lib.HotReload?.rememberReact(comp)
+        comp
+
+}

data/client/lanes/react/DefaultComponentNotFound.cjsx

@@ -0,0 +1,9 @@
+class Lanes.React.Root.DefaultComponentNotFOund extends Lanes.React.Component
+    propTypes:
+        extension: React.PropTypes.object
+
+    render: ->
+        identifier = @props.extension?.identifier || "UnknownExtension"
+        <div className="fancy-header">
+            <h1>{_.classify(identifier)}.rootElement() did not return an element!</h1>
+        </div>

data/client/lanes/react/Root.cjsx

@@ -0,0 +1,14 @@
+Lanes.React.Root = React.createClass
+    childContextTypes:
+        viewport: Lanes.PropTypes.State.isRequired
+
+    getChildContext: ->
+        viewport: @props.viewport
+
+    propTypes:
+        viewport: Lanes.PropTypes.State.isRequired
+
+    render: ->
+        <div classNames="root">
+            <Lanes.React.Router.RouteHandler/>
+        </div>

data/client/lanes/react/Router.cjsx

@@ -0,0 +1,18 @@
+Lanes.React.Router = Lanes.Vendor.ReactRouter
+Route = Lanes.React.Router.Route
+Lanes.React.runRouter = (viewport) ->
+
+    cntrl = Lanes.Extensions.controlling()
+
+    defaultComponent = cntrl?.rootComponent?(viewport) ||
+        Lanes.React.Root.DefaultComponentNotFound
+
+    routes =
+        <Route handler={Lanes.React.Root}>
+            <Lanes.React.Router.DefaultRoute handler={defaultComponent}/>
+            {Lanes.Extensions.routes()}
+        </Route>
+
+    Lanes.React.Router.run(routes, Lanes.React.Router.HistoryLocation, (Handler) ->
+        React.render(<Handler viewport=viewport />, viewport.root)
+    )

data/client/lanes/react/Screen.coffee

@@ -0,0 +1,15 @@
+Lanes.React.Screen = {
+
+    defaultMixins: [
+        Lanes.React.Mixins.Data
+        Lanes.React.Mixins.Viewport
+        Lanes.React.Mixins.Screen
+        Lanes.React.Mixins.RelayEditingState
+    ]
+
+    extend: (klass) ->
+        comp = Lanes.React.Component.extend(klass, @defaultMixins)
+        klass::mixins.push _.unique(klass::mixins.concat(this.defaultMixins))
+        comp
+
+}

data/client/lanes/react/TypeValidators.coffee

@@ -0,0 +1,21 @@
+Lanes.PropTypes ||= {}
+
+checkerFor = (name, checker, isRequired) ->
+    Lanes.PropTypes[name] = checker
+    Lanes.PropTypes[name].isRequired = isRequired || (props, propName, componentName) ->
+        return new Error("#{propName} must be given") unless props[propName]
+
+checkerFor 'Model', (props, propName, componentName) ->
+    val = props[propName]
+    if val and (!_.isObject(val) or !val.isModel)
+        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)
+        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)
+        return new Error("#{propName} is not a Lanes Collection")

data/client/lanes/react/Viewport.coffee

@@ -0,0 +1,30 @@
+ALL_INSTANCES = []
+
+class Lanes.React.Viewport extends Lanes.Models.State
+
+    @all: -> ALL_INSTANCES
+
+    session:
+        width:      'number'
+        height:     'number'
+        el:         'element'
+        selector:   'string'
+        root:       'element'
+
+    constructor: ->
+        super
+        ALL_INSTANCES.push(this)
+        root = document.body.querySelector(@selector)
+        Lanes.fatal("Root selector #{@selector} not found") unless root
+        _.dom(root).html = "<div class='lanes'/>"
+        Lanes.lib.ResizeSensor(root, _.debounce( =>
+            @_updateDimensions()
+        , 250))
+        this.root = root.querySelector('.lanes')
+        this._updateDimensions()
+
+
+    _updateDimensions: ->
+        this.set
+            width:  this.root.clientWidth
+            height: this.root.clientHeight

data/client/lanes/react/index.js

@@ -0,0 +1,8 @@
+//= require ./TypeValidators
+//= require ./Viewport
+//= require_tree ./mixins
+//= require ./Component
+//= require ./Screen
+//= require ./Root
+//= require ./DefaultComponentNotFound
+//= require ./Router

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

@@ -0,0 +1,27 @@
+calculateAccess = (comp, props) ->
+    model = comp[comp.modelForAccess || 'model']
+
+    accessRight = if props.readonly or comp.context?.readonly
+        'r'
+    else if props.writable or comp.context?.writable or Lanes.current_user.canWrite(model, props.name)
+        'w'
+    else if props.readable or Lanes.current_user.canRead(model, props.name)
+        'r'
+    comp.setState({accessRight}) if accessRight
+
+Lanes.React.Mixins.Access = {
+
+    componentDidMount: ->
+        calculateAccess(this, @props)
+
+    componentWillReceiveProps: (newProps) ->
+        calculateAccess(this, newProps)
+
+    hasReadAccess: ->
+        !!@state.accessRight
+
+    hasWriteAccess: ->
+        _.include(['w', 'd'], @state.accessRight)
+
+
+}

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

@@ -0,0 +1,4 @@
+Lanes.React.Mixins.Component = {
+    contextTypes:
+        screen:  React.PropTypes.object
+}

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

@@ -0,0 +1,136 @@
+# Patterned loosely after Backbone React
+# https://github.com/magalhas/backbone-react-component/blob/master/lib/component.js
+
+# Mixing `Backbone.Events` into `Wrapper.prototype`
+# Binds models and collections to a `React.Component`. It mixes `Backbone.Events`.
+
+class DataWrapper
+
+    constructor: (@component, initialState = {}) ->
+        # Object to store data state (not the component state)
+        @states = {}
+        @rebind(_.clone(initialState), silent: true)
+
+    rebind: (objects, options = {}) ->
+        customEvents = _.result(@component, 'bindDataEvents') || {}
+        for name, state of objects
+            unless state
+                Lanes.warn "#{name} is not set on #{@componentName()}"
+                continue
+            prevState = @states[name]
+            @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
+
+
+        this.setComponentState({}) unless _.isEmpty(objects) or options.silent
+
+    listenToNetworkEvents: ->
+        @listenTo(collection,     'error',   @onError)
+            .listenTo(collection, 'request', @onRequest)
+            .listenTo(collection, 'sync',    @onSync)
+
+    onPubSubChangeSet: (model, cs) ->
+        screen = @component.context?.screen || @component.getChildContext?()?.screen
+        screen?.onPubSubChangeSet?(model, cs)
+
+    componentName: ->
+        @component.constructor.displayName
+
+    bindEvents: (name, state, events) ->
+        if !events
+            if state.isState
+                events ||= 'change'
+            else if state.isCollection
+                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) ->
+        # Set state only if there's no silent option
+        unless options.silent
+            @setComponentState
+                isRequesting: false
+                hasError: true
+                error: modelOrCollection.errors
+
+    onInvalid: (model, res, options) ->
+        @setComponentState(isInvalid: true) unless options.silent
+
+    onRequest: (modelOrCollection, options) ->
+        # Set `state` only if there's no silent option
+        unless options.silent
+            @setComponentState
+                isRequesting: true
+                hasError: false
+                isInvalid: false
+
+    onSync: (modelOrCollection, res, options) ->
+        # Calls `setReactState` only if there's no silent option
+        this.setComponentState(isRequesting: false) unless options.silent
+
+    setComponentState: (key, value, args...) ->
+        return unless @component.isMounted()
+        state = if _.isObject(key) then key else {"#{key}": value}
+        if _.isFunction(@component.setDataState)
+            @component.setDataState(state, args...)
+        else
+            @component.setState(state)
+        true
+
+    destroy: (state, events, fn) ->
+        for name, state of @states
+            Lanes.Models.PubSub.remove(state) if state?.isModel
+        this.stopListening()
+        delete @component.data
+
+
+_.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
+    _.mapValues(bound, (value, name) ->
+        if _.isFunction(value) then value.call(comp)
+        else if 'props' == value then newProps?[name] or @props[name]
+        else value
+    , comp)
+
+Lanes.React.Mixins.Data = {
+    # When the component gets the initial state, instance a `DataWrapper` to take
+    # care of models and collections binding
+    getInitialState: ->
+        defaults = readDataObjects(this)
+        @data = new DataWrapper(this, defaults) unless _.isEmpty(defaults)
+        {}
+
+    # When the component unmounts, dispose listeners and delete @data reference.
+    componentWillUnmount: ->
+        @data.destroy() if @data
+
+    componentWillReceiveProps: (newProps) ->
+        newState = readDataObjects(this, newProps)
+        return if _.isEmpty(newState)
+        if @data
+            @data.rebind(newState, silent:true)
+        else
+            @data = new DataWrapper(this, newState)
+
+    listenTo: (state, events, fn) ->
+        @data.listenTo(state, events, fn)
+
+    stopListening: (state, events, fn) ->
+        @data.stopListening(state, events, fn)
+
+}