lanes 0.0.1

data/client/javascripts/data/Screens.coffee

@@ -0,0 +1,157 @@
+class ScreenView extends Lanes.Data.BasicModel
+
+    session:
+        screen: 'object'
+
+    session:
+        active: ['boolean', true, false]
+        ui: 'state'
+
+    derived:
+        view:
+            deps: ['screen'], fn: ->
+                new @screen.viewModel( screen: this.screen, ui: @ui )
+
+    initialize: (options)->
+        super
+        @screen=options.screen
+        Lanes.Data.Screens.displaying.add( this )
+        this.active=true
+
+    renderScreen: ->
+        this.view.render()
+
+    remove: ->
+        Lanes.Data.Screens.displaying.remove( this )
+
+
+
+class Screen extends Lanes.Data.BasicModel
+
+    session:
+        id:          'string'
+        title:       'string'
+        description: 'string'
+        view:        'string'
+        icon:        'string'
+        group_id:    'string'
+        files:       'array'
+        loading:     'boolean'
+        model:       'string'
+
+    derived:
+        model_type:
+            deps: ['model'], fn: ->
+                Lanes.Data[this.model]
+
+    initialize: ->
+        @views = []
+
+    _setDisplaying: (ui)->
+        @views.push( new ScreenView( screen: this, ui: ui ) )
+
+    display: (ui)->
+        @viewModel ||= Lanes.Screens[this.view]
+        if @viewModel?
+           this._setDisplaying(ui)
+        else
+            this.loading=true
+            Lanes.lib.Loader(this.files)
+                .then =>
+                    @viewModel = Lanes.Screens[this.view]
+                    @_setDisplaying(ui)
+                    @loading=false
+                .catch (failures)=>
+                    @loading=false
+                    Lanes.warn(failures)
+
+
+class ScreenViewSet extends Lanes.Data.BasicCollection
+
+    model: ScreenView
+
+    active: ->
+        @findWhere( active: true )
+
+    initialize: (models, options={})->
+        this.on( 'change:active', this.onActiveChange )
+
+    remove: (model)->
+        index = this.indexOf(model)
+        super
+        if model.active && this.length
+            this.at(_.min([index,this.length-1])).active = true
+        model.active = false
+        this
+
+    onActiveChange: (changed,active)->
+        return unless active
+        this.each (screen)->
+            screen.set( active: false ) unless screen == changed
+
+    activateNext: -> this._moveActive(+1)
+    activatePrev: -> this._moveActive(-1)
+
+    _moveActive: (inc)->
+        return if this.length == 1
+        current = this.findIndexWhere( active: true )
+        return if current == -1
+        if inc>0 && current == this.length-1
+            current = -1
+        if inc<0 && current == 0
+            current = this.length
+        this.at(current+inc).active = true
+
+
+
+class ScreenSet extends Lanes.Data.BasicCollection
+
+    model: Screen
+
+    register: (spec)->
+
+    addScreen: (screen)->
+        screen = this.add( screen )
+        screen.set(active:true)
+
+
+
+class MenuGroup extends Lanes.Data.BasicModel
+
+    session:
+        id:          'string'
+        title:       'string'
+        description: 'string'
+        icon:        'string'
+        active:      ['boolean', true, false]
+
+    screens: ->
+        @avail ||= new Lanes.Data.SubCollection( Lanes.Data.Screens.all, {
+            filter: (screen)=>
+                screen.group_id == @id && Lanes.current_user.canRead(screen.model_type)
+            watched: ['group_id']
+        })
+
+class MenuGroupSet extends Lanes.Data.BasicCollection
+    constructor: -> super
+    model: MenuGroup
+
+    available: ->
+        @avail ||= new Lanes.Data.SubCollection(this, {
+            filter: (mgs)=>
+                mgs.screens().filter()
+                mgs.screens().length > 0
+        })
+
+
+
+Lanes.Data.Screens = {
+    all: new ScreenSet
+    displaying: new ScreenViewSet([],{ single_active_only: true })
+    groups:  new MenuGroupSet
+    available_groups: ->
+        MenuGroupSet.where({ id:  available.groupBy (screen)-> screen.group_id.keys })
+
+    register: (spec)->
+        this.all.add( spec )
+}

data/client/javascripts/data/Sync.coffee

@@ -0,0 +1,62 @@
+
+# a simple reimplentation
+# to use traffic cop
+methodMap = {
+    'create': 'POST',
+    'update': 'PUT',
+    'patch':  'PATCH',
+    'delete': 'DELETE',
+    'read':   'GET'
+}
+
+getValue = (object, prop)->
+    if !(object && object[prop])
+        return null;
+    return if _.isFunction(object[prop]) then object[prop]() else object[prop];
+
+
+urlError = ->
+    throw new Error('A "url" property or function must be specified')
+
+
+paramsMap = {
+    fields  : 'f'
+    with    : 'w'
+    query   : 'q'
+    include : 'i'
+    order   : 'o'
+    limit   : 'l'
+    start   : 's'
+}
+
+Lanes.Data.Sync = (method, model, options)->
+
+    query = {}
+    for key, value of options
+        query[ paramsMap[key] ] = value if paramsMap[key]
+
+    # Default JSON-request options.
+    params = {
+        type: methodMap[method]
+        dataType: "json"
+        data: query
+    }
+
+    # Ensure that we have a URL.
+    params.url = _.result(model, "url") or urlError() unless options.url
+    params.url += '.json'
+    params.headers = {
+        X_CSRF_TOKEN: Lanes.Data.Config.csrf_token
+    }
+    # Ensure that we have the appropriate request data.
+    if !options.data? && model && _.contains([ "create", "update", "patch" ], method )
+        params.contentType = "application/json"
+        params.data = JSON.stringify( model.dataForSave(options) )
+
+    # Don't process data on a non-GET request.
+    #params.processData = false if params.type isnt "GET"
+
+    # Make the request, allowing the user to override any Ajax options.
+    xhr = options.xhr = Lanes.$.ajax(_.extend(params, options))
+    model.trigger "request", model, xhr, options
+    xhr

data/client/javascripts/data/User.coffee

@@ -0,0 +1,70 @@
+class Lanes.Data.User extends Lanes.Data.Model
+
+    constructor: (attributes,access)->
+        super
+        this.access_data = access
+
+    api_path: 'users'
+    derived:
+        roles:
+            deps: ['role_names', 'access_data']
+            fn: -> new Lanes.Data.UserRoleSet( @access_data )
+        isLoggedIn:
+            deps:['id'], fn: -> !!this.id
+        allRoles:
+            deps: ['role_names', 'access_data']
+            fn: ->
+                role_data = Lanes.Data.Roles.all?.toJSON() || []
+                roles = new Lanes.Data.Roles( role_data )
+                _.each( this.role_names, (name)->
+                    console.log name, roles
+                    roles.get(name)?.member = true
+                )
+                roles
+
+    session:
+        access_data: 'object'
+
+    props:
+        id:         { type: "integer", required:true }
+        login:       'string'
+        name:        'string'
+        email:       'string'
+        role_names:  'array'
+        options:     'object'
+        password:    'string'
+
+    canRead: (model,field)  -> this.roles.canRead(model,field)
+    canWrite: (model,field) -> this.roles.canWrite(model,field)
+    canDelete: (model)      -> this.roles.canDelete(model)
+
+    logout: ->
+        _.each(this.attributes, (value,key)=> @set(key, null) )
+
+    setLoginData: (attrs, access)->
+        this.access_data = access
+        this.set(attrs)
+
+    @attemptLogin: (login,password, options)->
+        session = new Session( login: login, password: password )
+        success = options.success
+        session.save(_.extend(options,{
+            success: (session)->
+                Lanes.current_user.setLoginData(session.user, session.access)
+                success.apply(options.scope, arguments)
+        }))
+
+Lanes.current_user = new Lanes.Data.User
+
+class Lanes.Data.User.Collection extends Lanes.Data.Collection
+    model: Lanes.Data.User
+
+
+class Session extends Lanes.Data.Model
+    api_path: 'user-session'
+    props:
+        id:         'integer'
+        login:      'string'
+        password:   'string'
+        access:     'object'
+        user:       'object'

data/client/javascripts/data/index.js

@@ -0,0 +1,7 @@
+//= require_self
+//= require ./Model
+//= require ./Collection
+//= require_tree ./mixins
+//= require_tree .
+
+Lanes.namespace( 'Data.mixins' );

data/client/javascripts/data/mixins/HasCodeField.coffee

@@ -0,0 +1,13 @@
+Lanes.Data.mixins.HasCodeField = {
+
+    INVALID: /[^A-Z0-9a-z]/
+
+    included: ->
+        this.prototype.INVALID_CODE_CLanes.RS ||= Lanes.Data.mixins.Lanes.sCodeField.INVALID
+
+    initialize: ->
+        this.on('change:code', this.upcaseCode )
+
+    upcaseCode: ->
+        this.set('code', this.get('code').toUpperCase())
+}

data/client/javascripts/extension/Base.coffee

@@ -0,0 +1,9 @@
+class BaseExtension
+
+    setBootstrapData: (data)->
+
+    @extended:(klass)->
+        Lanes.Extensions.register(klass)
+
+
+Lanes.Extension.Base = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.State, BaseExtension )

data/client/javascripts/extension/Extensions.coffee

@@ -0,0 +1,17 @@
+Lanes.Extensions = {
+
+    instances: {}
+
+    register: (klass)->
+        instance = new klass
+        this.instances[klass.prototype.identifier] = instance
+        instance.onRegistered?()
+
+    fireOnAvailable: (application)->
+        instance.onAvailable?(application) for identifier, instance of @instances
+
+    setBootstrapData: (bootstrap_data)->
+        for identifier,data of bootstrap_data
+            instance.setBootstrapData(data) if instance = this.instances[identifier]
+
+}

data/client/javascripts/extension/GlAccounts.coffee

@@ -0,0 +1,9 @@
+class GlAccounts
+
+    identifier: 'gl_accounts'
+
+    setBootstrapData: (data)->
+        Lanes.Data.GlAccount.sharedCollection().reset(data)
+
+
+Lanes.Extension.Base.extend(GlAccounts)

data/client/javascripts/extension/index.js

@@ -0,0 +1,6 @@
+//= require_self
+//= require ./Base
+//= require ./Extensions
+//= require ./load
+
+Lanes.namespace('Extension');

data/client/javascripts/extension/load.js.erb

@@ -0,0 +1,3 @@
+<% Lanes::Extension.each(self) do | ext | %>
+<% require_asset ext.logical_path %>
+<% end %>

data/client/javascripts/lanes-complete.js

@@ -0,0 +1,3 @@
+//=require ./vendor/modern-stack
+//=require ./lib
+//=require_self

data/client/javascripts/lanes-workspace.js

@@ -0,0 +1 @@
+//=require ./workspace

data/client/javascripts/lib/MakeBaseClass.coffee

@@ -0,0 +1,55 @@
+FUNC_NAME_REGEX = /function\s+([^\s\(]+)/
+
+addMissingFunctionName = (klass)->
+    return if klass.name
+    Object.defineProperty( klass, 'name', {
+        get: ->
+            this._name_cache_ ||= (
+                results = FUNC_NAME_REGEX.exec((this).toString())
+                if (results && results.length) then results[1] else ""
+            )
+        set: (value)->
+            return {}
+    })
+
+mixinModules = (klass)->
+    Lanes.lib.ModuleSupport.includeInto(klass)
+    if klass::mixins
+        klass.include(Lanes.getPath(mixin)) for mixin in klass::mixins
+
+extendClass = (ampersand_base, parent, child)->
+    child.__super__ = parent.prototype
+    child.Derived = []
+    parent.Derived.push(child)
+    for prop in parent::extended_properties || []
+        if parent::[prop] && child::[prop]
+            _.extend( child::[prop], parent::[prop] )
+
+    mixinModules(child)
+
+    parent.extended(child) if _.isFunction(parent.extended)
+
+    child = ampersand_base.extend.call(parent, child.prototype )
+
+    child.extend = (klass)->
+        extendClass( ampersand_base, child, klass )
+
+    parent.after_extended(child) if _.isFunction(parent.after_extended)
+    addMissingFunctionName(child)
+    child
+
+
+createExtendsChain = ( ampersand_base, base )->
+    return (klass)->
+        extendClass( ampersand_base, this, klass )
+    base.__super__ = ampersand_base.prototype
+    base
+
+
+
+Lanes.lib.MakeBaseClass = ( ampersand_base, base )->
+    base = ampersand_base.extend( base.prototype )
+    mixinModules(base)
+    base.extend = createExtendsChain( ampersand_base, base )
+    base.Derived = []
+    base

data/client/javascripts/lib/ModuleSupport.coffee

@@ -0,0 +1,22 @@
+moduleKeywords = ['extended', 'included', 'initialize']
+
+class Lanes.lib.ModuleSupport
+    @includeInto: (klass)->
+        _.extend(klass,this)
+
+    @include: (obj) ->
+        special = this::extended_properties || []
+        if obj.initialize
+            fn = @::initialize
+            @::initialize = ->
+                obj.initialize.apply(this, arguments)
+                fn?.apply(this,arguments)
+
+        for key, value of obj when key not in moduleKeywords
+            # Assign properties to the prototype
+            if key in special && @::[key]
+                _.extend(@::[key], value)
+            else
+                @::[key] = value
+        obj.included?.apply(@)
+        this

data/client/javascripts/lib/Templates.coffee

@@ -0,0 +1,47 @@
+Lanes.namespace "Templates"
+
+
+ns2path = (ns)->
+    ns.replace(".","/").toLowerCase()
+
+Lanes.Templates.find = (name, namespace) ->
+    return Lanes.Templates[name] if Lanes.Templates[name]
+    if namespace?
+        Lanes.Templates[ ns2path(namespace) + "/" + name]
+    else
+        null
+
+# scribbed from eco's compiler.coffee
+# we include the functions here rather than on every single template
+Lanes.TemplateWrapper = {
+
+    sanitize: (value) ->
+        if value and value.HTMLSafe
+            value
+        else if typeof value isnt "undefined" and value?
+            Lanes.TemplateWrapper.escape value
+        else
+            ""
+
+    capture: (__out) ->
+        (callback) ->
+            out = __out
+            result = undefined
+            __out = []
+            callback.call this
+            result = __out.join("")
+            __out = out
+            __safe result
+
+    escape: _.escape
+
+    safe: (value) ->
+        if value and value.HTMLSafe
+            value
+        else
+            value = ""  unless typeof value isnt "undefined" and value?
+            result = new String(value)
+            result.HTMLSafe = true
+            result
+
+}

data/client/javascripts/lib/debounce.coffee

@@ -0,0 +1,15 @@
+
+Lanes.lib.debounce = {
+    debounce: (fn, options={})->
+        options.scope ||= this
+        options.delay ||= 250
+        _.debounce( ->
+            fn.apply(options.scope, (options.arguments||[]).concat(arguments...))
+        , options.delay )
+
+    debounceMethod: (method,options)->
+        original = this[method]
+        this[method] = @debounce( ->
+            original.apply(this, arguments)
+        ,options)
+}

data/client/javascripts/lib/defer.coffee

@@ -0,0 +1,7 @@
+Lanes.lib.defer = {
+    defer: (fn, options={})->
+        scope = options.scope || this
+        _.delay( ->
+            fn.apply(scope,options.arguments)
+        ,options.delay||1)
+}

data/client/javascripts/lib/el.js

@@ -0,0 +1,115 @@
+/**
+* el.js v0.3 - A JavaScript Node Creation Tool
+*
+* https://github.com/markgandolfo/el.js
+*
+* Copyright 2013 Mark Gandolfo and other contributors
+* Released under the MIT license.
+* http://en.wikipedia.org/wiki/MIT_License
+*/
+_.el = (function () {
+  var el = function(tagName, attrs, child) {
+    // Pattern to match id & class names
+    var pattern = /([a-z]+|#[\w-\d]+|\.[\w\d-]+)/g;
+
+    if(arguments.length === 2) {
+      if(attrs instanceof Array || typeof attrs === 'function' || typeof attrs === 'string' || attrs.constructor !== Object) {
+        child = attrs;
+        attrs = undefined;
+      }
+    }
+
+    // does the user pass attributes in, if not set an empty object up
+    attrs = typeof attrs !== 'undefined' ? attrs : {};
+    child = typeof child !== 'undefined' ? child : [];
+    child = child instanceof Array ? child : [child];
+
+    // run the pattern over the tagname in an attempt to pull out class & id attributes
+    // shift the first record out as it's the element name
+    matched = tagName.match(pattern);
+    tagName = matched[0];
+    matched.shift();
+
+    // Iterate over the matches and concat the attrs to either class or id keys in attrs json object
+    for (var m in matched) {
+      if(matched[m][0] == '.') {
+        if(attrs['class'] === undefined) {
+          attrs['class'] = matched[m].substring(1, matched[m].length);
+        } else {
+          attrs['class'] = attrs['class'] + ' ' + matched[m].substring(1, matched[m].length);
+        }
+      } else if(matched[m][0] == '#') {
+        if(attrs['id'] === undefined) {
+          attrs['id'] = matched[m].substring(1, matched[m].length);
+        } else {
+          // Feels dirty having multiple id's, but it's allowed: http://www.w3.org/TR/selectors/#id-selectors
+          attrs['id'] = attrs['id'] + ' ' + matched[m].substring(1, matched[m].length);
+        }
+      }
+    }
+
+    // create the element
+    var el = document.createElement(tagName);
+    for(var i = 0; i < child.length; i += 1) {
+      (function(child){
+        switch(typeof child) {
+          case 'object':
+            el.appendChild(child);
+            break;
+          case 'function':
+            var discardDoneCallbackResult = false;
+            var doneCallback = function doneCallback(content) {
+              if (!discardDoneCallbackResult) {
+                el.appendChild(content);
+              }
+            };
+            var result = child.apply(null, [doneCallback]);
+            if(typeof result != 'undefined') {
+              discardDoneCallbackResult = true;
+              el.appendChild(result);
+            }
+            break;
+          case 'string':
+            el.appendChild(document.createTextNode(child));
+            break;
+          default:
+            //???
+        }
+      }(child[i]));
+    }
+
+    for (var key in attrs) {
+      if (attrs.hasOwnProperty(key)) {
+        el.setAttribute(key, attrs[key]);
+      }
+    }
+
+    return el;
+  };
+
+  // alias
+  el.create = el.c = el;
+
+  // vanity methods
+  el.img = function(attrs) {
+    return this.create('img', attrs);
+  };
+
+  el.a = function(attrs, child) {
+    return this.create('a', attrs, child);
+  };
+
+  el.div = function(attrs, child) {
+    return this.create('div', attrs, child);
+  };
+
+  el.p = function(attrs, child) {
+    return this.create('p', attrs, child);
+  };
+
+  el.input = function(attrs, child) {
+    return this.create('input', attrs);
+  };
+
+  return el;
+}());

data/client/javascripts/lib/index.js

@@ -0,0 +1,9 @@
+//= require ./noConflict
+//= require ./namespace
+//= require ./utilFunctions
+//= require ./underscore.inflection
+//= require ./ModuleSupport
+//= require_tree .
+
+
+Lanes.namespace('lib');