lanes 0.0.1

data/client/javascripts/view/Assets.coffee

@@ -0,0 +1,9 @@
+Lanes.View.Assets = {
+    path: (asset)->
+        path = @paths[ asset ]
+        Lanes.log( "Path for #{asset} was not found" ) unless path
+        path
+
+    setPaths: (paths={})->
+        @paths = paths;
+}

data/client/javascripts/view/Base.coffee

@@ -0,0 +1,231 @@
+class ViewBase
+
+    model_events: {}
+
+    extended_properties: [
+        'subviews', 'events', 'model_events'
+    ]
+
+    derived:
+        '$el':
+            deps: ['el'], fn: -> this.$()
+
+        root_view:
+            deps: ['parent'], fn: ->
+                view = this
+                while view.parent
+                    view = view.parent
+                view
+
+    session:
+        ui:     'state'
+        parent: 'object'
+        pubSub: 'boolean'
+
+    template: (context)->
+        context.renderTemplateMethod('template')
+
+    constructor: (options={})->
+        if !options.ui && options.parent
+            view = options.parent
+            while view.parent
+                view = view.parent
+            options.ui = view.ui
+
+        Lanes.Vendor.Ampersand.View.apply(this, arguments)
+        if !this.pubSub? # if it's unset, not true/false; default to parent or true
+            this.pubSub = if this.parent?.pubSub? then this.parent.pubSub else true
+        this.on('change:parent', this._onParentSet)
+        this.on('change:model', this._onModelChange)
+        this.subViewId = options.subViewId;
+        this.initializeFormBindings() if @form_bindings
+
+        if @keyBindings
+            Lanes.View.Keys.add(this, @keyBindings, @keyScope)
+
+        if @pubSub
+            this._pubSub = new Lanes.View.PubSub(this)
+
+    _onParentSet: ->
+        if this.root_view.ui
+            this.ui = this.root_view.ui
+
+    unBindModel: (model)->
+        for event, fn of @model_events
+            model.off(event, this[fn], this )
+
+    bindModel: (model)->
+        for event, fn of @model_events
+            model.on(event, this[fn], this )
+
+    remove: ->
+        this.unBindModel( @model ) if @model
+        Lanes.View.Keys.remove(this, @key_bindings, @key_scope) if @key_bindings
+        super
+
+    initializeKeyBindings: ->
+
+
+
+    initializeFormBindings: ->
+        @_form_bindings = {}
+        for data, selector of @form_bindings
+            @_form_bindings[data] = new Lanes.View.FormBindings(this, data, selector)
+
+    setFieldsFromBindings: ->
+        binding.setAllFields() for name, binding of @_form_bindings
+
+    fireEvent: (name, args)->
+        evt = document.createEvent('CustomEvent')
+        evt.initCustomEvent(name, true, true, args )
+        this.el.dispatchEvent(evt)
+
+    prepareSubview: (el, options, identifier)->
+        options.view = this._subviewClass(options) unless _.isFunction(options.view)
+        args = { parent: this, el: el, subViewId: identifier }
+        view_arguments = if options.options
+            @resultsFor(options.options, identifier, options)
+        else
+            {}
+        for access in ['model','data']
+            args[access] = Lanes.getPath(options[access], this) if options[access]
+        if options.collection
+            args.view = options.view
+            args.viewOptions = view_arguments
+            args.collection  = Lanes.getPath(options.collection, this)
+            new Lanes.Vendor.Ampersand.CollectionView(args)
+        else
+            new options.view( _.extend(args,view_arguments) )
+
+    viewpath: ''
+
+    detach: ->
+        this.el.parentNode.removeChild(this.el) if this.el.parentNode
+
+    renderTemplate:(name,data={})->
+        template = Lanes.Templates.find(name, @namespace)
+        if template
+            template(data)
+        else
+            Lanes.fatal( "Template #{name} doesn't exist!" )
+
+    renderTemplateMethod: (method)->
+        return '<span></span>' unless name = _.result(this, "#{method}Name")
+        this.renderTemplate(name, _.result(this, "#{method}Data") || @model)
+
+    subViewDefinition: ->
+        if ( definition = this.parent?.subviews?[ @subViewId ] )
+            definition
+        else
+            null
+
+    renderAllSubviews: ->
+        for name, options of this.subviews
+            selector = options.container || '[data-hook="' + options.hook + '"]'
+            this.renderSubview(this[name], selector) unless options.collection
+
+    withRenderContext: (fn)->
+        Lanes.View.RenderContext.push( @subViewId, @model )
+        try
+            returned = fn.apply(this,arguments)
+        catch e
+            Lanes.warn e
+        finally
+            Lanes.View.RenderContext.pop()
+        returned
+
+    renderContextFree: ->
+        previousClass = this.el?.className
+        Lanes.View.Base.__super__.render.apply(this, arguments)
+        if previousClass
+            this.$el.addClass( previousClass )
+        this.onRender?()
+        this
+
+    render: (options={})->
+        this.withRenderContext( this.renderContextFree )
+
+    $: (selector)->
+        if selector then Lanes.$(selector,this.el) else Lanes.$(this.el)
+
+    _onModelChange: (model)->
+        for name, definition of this.subviews
+            continue unless ( view = this[name] )
+            view.model = Lanes.getPath(definition.model, this) if definition.model
+            view.collection = Lanes.getPath(definition.collection, this) if definition.collection
+        old_model = this.previous(@keypath)
+        return if old_model == @model
+        this.unBindModel( old_model ) if old_model
+        this.bindModel( @model ) if @model
+
+    belongsToScreen: ->
+        view = this
+        while view and ! ( view instanceof Lanes.View.Screen )
+            view = view.parent
+        view
+
+    _subviewClass: (subview)->
+        klass = if subview.component
+            Lanes.getPath("Lanes.Component.#{subview.component}")
+        else if subview.view
+            if _.isString(subview.view)
+                Lanes.getPath(subview.view, "Lanes.View")# || Lanes.getPath("Lanes.View.#{subview.view}")
+            else
+                subview.view
+        Lanes.warn( "Unable to obtain view for %o", subview) if ! klass
+        klass
+
+    bindingWriteDefinition: (keypath, options)->
+        switch options.type
+            when 'booleanAttribute'
+                {
+                    selector: "change #{options.selector}",
+                    handler: (ev)->
+                        [model, field] = Lanes.getModelPath(this,keypath)
+                        model.set(field,ev.target.checked)
+                }
+            else
+                {}
+
+    cacheElements: (config)->
+        super
+        this
+
+    cacheJqElements: (config)->
+        this.cacheElements(config)
+        for key, _ of config
+            this[key] = Lanes.$(this[key])
+        this
+
+    @configureSubview: (name, subview)->
+        fn = if subview.prepareView
+            subview.prepareView
+        else
+            _.partial(this.prototype.prepareSubview, _, subview, name)
+        subview.hook=name if !subview.hook && !subview.container
+        subview.waitFor=(subview.model || subview.collection ) if ! subview.waitFor
+        subview.prepareView = (el)->
+            this.subViewIntances ||= {}
+            this.subViewIntances[name]=fn.call(this,el)
+
+    @extended: (klass)->
+        if views = klass.prototype.subviews
+            @configureSubview(name, definition) for name, definition of views
+        setupWritableBindings(klass.prototype) if klass.prototype.bindings
+
+    Lanes.lib.ModuleSupport.includeInto(@)
+    @include Lanes.lib.defer
+    @include Lanes.lib.debounce
+    @include Lanes.lib.results
+
+
+
+setupWritableBindings=(klass)->
+    klass.events ||= {}
+    for keypath, options of klass.bindings
+        continue unless options.write
+        writeFn = ( klass.bindingWriteDefinition || ViewBase.prototype.bindingWriteDefinition )
+        definition = writeFn.call(klass, keypath, options)
+        klass.events[ definition.selector ] = definition.handler
+
+Lanes.View.Base = Lanes.lib.MakeBaseClass( Lanes.Vendor.Ampersand.View, ViewBase )

data/client/javascripts/view/FormBindings.coffee

@@ -0,0 +1,98 @@
+class Lanes.View.FormBindings
+
+    constructor: (@view, @keypath, @selector)->
+        _.bindAll(this,'onFieldChange')
+        @selector = "#{@selector} " if @selector
+        @view.on( "change:el",          this.rebindForm,    this )
+        @view.on( "change:#{@keypath}", this.rebindModel,   this )
+        @view.on( "remove",             this.teardown,      this )
+        this.rebindModel( @view, @model() )
+
+    onFieldChange: (ev)->
+        el = Lanes.$(ev.target);
+        name = el.attr('name');
+        m = this.model();
+        return unless m.hasAttribute(name)
+        val = el.val()
+
+        el[0]._is_setting=true; m.set( name, val ); delete el[0]._is_setting
+        msg = m.validateFieldChange(name,val)
+        this.setError( el, msg )
+
+    onAttributeUpdate: (model, opts={})->
+        attributes = if opts.all then this.attributesFor(model) else model.changedAttributes()
+        if attributes['errors'] && ! _.isEmpty(attributes['errors'])
+            for name, message of attributes['errors']
+                this.setError(Lanes.$(el),message) if el = this.getElement(name)
+        for name, _ of attributes
+            el = this.getElement(name)
+            this.setElValue(Lanes.$(el),model.get(name)) if el && ! el._is_setting
+
+    setElValue:  (el, value)->
+        if el.attr('type')
+            switch el.attr('type')
+                when 'radio'
+                    for input in Lanes.$(this.view.el).find("#{@selector}input[type=radio][name=#{el.attr('name')}]")
+                        input.checked = input.value == value
+                when 'checkbox'
+                     el.prop('checked', !!value)
+                when 'break'
+                    file
+                else
+                    el.val(value)
+
+        else if el.is('input') || el.is('select') || el.is('textarea')
+            el.val(value ||  ( if value == 0 then '0' else '') )
+        else
+            el.text(value || ( if value == 0 then '0' else '') )
+
+    clearErrors: ->
+        Lanes.$(this.view.el).find(
+            this.selector + "input ~ .feedback.error, " +
+            this.selector + ".ro-input.update ~ .feedback.error"
+        ).removeClass('error')
+
+    setError: (el, message)->
+        return unless placeholder = el.siblings('.feedback')
+        if message
+            placeholder.addClass('error')
+            placeholder.attr('data-tooltip-message', message)
+        else
+            placeholder.removeClass('error')
+
+    attributesFor: (model)->
+        attrs = {}
+        for name,val of model._definition
+            attrs[name]=val #if ! val.session
+        attrs
+
+    fields: ->
+        @cached_fields ||= Lanes.$(@view.el).find("#{@selector}input, #{@selector}.ro-input.update")
+
+    getElement: (name)->
+        _.find( this.fields(), (i)->i.getAttribute('name') == name )
+
+    setAllFields: ->
+        this.onAttributeUpdate(this.model(), all: true)
+
+    model: ->
+        @cached_model ||= Lanes.getPath(@keypath, @view)
+
+    rebindForm: (view, el)->
+        input_selector = "#{@selector}input, #{@selector}select"
+        if old_el = @view.changedAttributes()['el']
+            Lanes.$(el).off("change", input_selector, this.onFieldChange )
+        @cached_fields = null
+        Lanes.$(el).on("change",input_selector, this.onFieldChange )
+
+    rebindModel: (view, model)->
+        this.clearErrors()
+        if old_model = @view.changedAttributes()[@keypath]
+            old_model.off( "change", this.onAttributeUpdate )
+        if model
+            this.onAttributeUpdate(model, { all: true } )
+            @cached_model = null
+            model.on('change', this.onAttributeUpdate, this )
+
+    teardown: ->
+        this.model().off( "change", this.onAttributeUpdate )

data/client/javascripts/view/Functions.coffee

@@ -0,0 +1,13 @@
+
+Lanes.View.fn = {
+
+    toggleClass: (class_name, selector='')->
+        {
+            selector: '', elAttribute: 'class', converter:
+                (dir,value)-> if value then class_name else ''
+        }
+
+    onEnter: (method)->
+        (ev)->
+            this[method](ev) if 13 == ev.keyCode
+}

data/client/javascripts/view/Helpers.coffee

@@ -0,0 +1,77 @@
+# "private" methods for the helpers
+impl = {
+    field: (name, options, writeable_input, readonly_input)->
+        readonly_input = writeable_input if ! readonly_input
+        o = this.field_options(name, options)
+        if options.writable || Lanes.View.RenderContext.canRead(name)
+            contents  = if options.unwrapped then "" else "<label class='skr #{o.widths}'><b>#{o.title}:</b>"
+            contents += if options.writable || Lanes.View.RenderContext.canWrite(name)
+                writeable_input
+            else
+                readonly_input
+            contents += "</label>" unless options.unwrapped
+        else
+            contents = "<div class='#{o.widths}'></div>"
+        this.markSafe(contents)
+
+    template: (template,data)->
+        this.markSafe( Lanes.Templates.find('view/_'+template)(data) )
+
+    markSafe: (str)->
+        result = new String(str)
+        result.HTMLSafe = true
+        result
+
+
+    field_options: (name, options)->
+        options.widths=[options.width] if options.width # convert singular widths into an array if present
+        {
+            widths: this.grid_widths(options.widths...)
+            title:  _.escape( options.label || _.titleize(name) )
+        }
+
+    grid_width:(widths, type='')->
+        last = widths[widths.length-1]
+        widths.push(last) for i in [widths.length-1..4]
+        ( "col-#{width}#{type}-#{widths[index]}" for index,width of ['xs','sm','md','lg'] ).join(' ')
+}
+
+Lanes.View.Helpers = {
+
+    elid: -> 'id="' + _.uniqueId('v') + '"'
+
+    toolbar: (options)->
+        return impl.template( 'toolbar', options )
+
+    button: (options)->
+        if _.isString(options)
+            options={ name: options, text: _.titleize(options) }
+        _.defaults(options, { css: options.name, icon: "icon-#{options.name}" })
+        if options.name == 'save' && !Lanes.View.RenderContext.canWrite(name)
+            ""
+        else
+            impl.template('button', options )
+
+    grid_offsets: (widths...)->
+        impl.grid_width(widths,'-offset')
+
+    grid_widths: (widths...)->
+        impl.grid_width(widths);
+
+    text_field: (name,options={})->
+        impl.field(name, options,
+            "<input type='text' name='#{name}'><span class='feedback'></span>"
+            "<div class='ro-input update' name='#{name}'></div>"
+        )
+
+    subview: (name,options={})->
+        definition = Lanes.View.RenderContext.view().subviews[name]
+        selector = if definition.hook
+            "data-hook='#{definition.hook}'"
+        else
+            "class='#{definition.selector}'"
+        impl.field( name, options, "<div #{selector}></div>" )
+
+
+
+}

data/client/javascripts/view/InterfaceState.coffee

@@ -0,0 +1,88 @@
+
+
+MENU_NARROW_WIDTH = 60
+MENU_WIDE_WIDTH   = 250
+NAVBAR_HEIGHT     = 50
+BREAKPOINTS = {
+    sm: 750
+    md: 970
+    lg: 1170
+}
+
+ALL_INSTANCES = []
+
+class Lanes.View.InterfaceState extends Lanes.Data.BasicModel
+
+    constructor: ->
+        super
+        ALL_INSTANCES.push(this)
+
+        this.on('change:root', =>
+            @viewport_width = @root.width()
+            @root.data()['ui']=@
+        )
+        this.on('change:menu_view', =>
+            @trigger('change:screen_menu_position', @, @screen_menu_position )
+        )
+        this.on('change:menu_view', =>
+            @trigger('change:screen_menu_position', @, @screen_menu_position )
+        )
+        this.screen_menu_shown = false if this.tiny_screen
+
+    session:
+        screen_menu_preference: {
+            type: 'string',
+            values: [ 'menu-wide', 'menu-narrow', 'menu-hidden' ]
+        }
+        root:              'element'
+        menu_view:         'any'
+        viewport:          'element'
+        viewport_width:    'number'
+        viewport_height:   'number'
+        screen_menu_shown: 'boolean'
+        http_error:        'string'
+        selector:          'string'
+        instance:          'object'
+
+    derived:
+        menu_width:
+            deps: ['screen_menu_size'], fn: ->
+                switch this.screen_menu_size
+                    when 'menu-wide' then 240
+                    when 'menu-narrow' then 60
+                    else 0
+        layout_size:
+            deps: ['screens_width'], fn:->
+                switch
+                    when @screens_width < BREAKPOINTS.sm then 'tiny'
+                    when @screens_width < BREAKPOINTS.md then 'sm'
+                    when @screens_width < BREAKPOINTS.lg then 'md'
+                    else 'lg'
+        tiny_screen:
+            deps: ['layout_size'], fn:->
+                @layout_size == 'tiny'
+
+        screen_menu_position:
+            deps: ['viewport_width'], fn: ->
+                if this.viewport_width < BREAKPOINTS.sm + MENU_NARROW_WIDTH then 'top' else 'side'
+
+        screen_menu_size:
+            deps: ['viewport_width','screen_menu_preference'], fn: ->
+                return @screen_menu_preference if @screen_menu_preference
+                width = this.viewport_width
+                switch
+                    when width < BREAKPOINTS.sm + MENU_NARROW_WIDTH then 'menu-hidden'
+                    when width < BREAKPOINTS.lg + MENU_WIDE_WIDTH   then 'menu-narrow'
+                    else 'menu-wide'
+        screens_width:
+            deps: ['viewport_width','screen_menu_size'], fn: ->
+                @viewport_width - @menu_width
+
+        screens_height:
+            deps: ['viewport_height'], fn: ->
+                @viewport_height - NAVBAR_HEIGHT
+
+    nextSidebarState: ->
+        if ! @screen_menu_preference
+            @screen_menu_preference = @screen_menu_size
+        this.toggle('screen_menu_preference')

data/client/javascripts/view/Keys.coffee

@@ -0,0 +1,59 @@
+km = Lanes.Vendor.KeyMaster
+
+Lanes.View.Keys = {
+
+    scopes:{}
+    defaultTime: 5000
+
+    setScopeTimer: (scope)->
+        @timeout = _.delay( =>
+            km.setScope('none')
+        ,@defaultTime)
+
+    rescheduleTimeout: (scope)->
+        return unless @timeout
+        clearTimeout(@timeout)
+        this.setScopeTimer(scope)
+        Lanes.View.TimedHighlight.reset(scope.time || @defaultTime)
+
+    addScope:(scope)->
+        km(scope.shortcut, (ev)=>
+            km.setScope(scope.name)
+            for view in scope.views
+                Lanes.View.TimedHighlight.on(view, scope.time || @defaultTime)
+
+            @setScopeTimer() unless scope.permanent
+
+            return false
+        )
+        scope.views = []
+        @scopes[scope.name] = scope
+
+    addEvent: (keys, handler, view, scope)->
+        km(keys, scope.name, (ev)=>
+            view[handler].call(view, ev)
+            @rescheduleTimeout(scope)
+
+        )
+
+    add: (view, events, scope)->
+        scope = @scopes[scope.name] || this.addScope(scope)
+        scope.views.push(view)
+        for keys, handler of events
+            this.addEvent(keys, handler, view, scope)
+
+    remove: (view, events, scope)->
+        scope = @scopes[scope.name]
+        scope.views.remove(view)
+        for keys, handler of events
+            km.unbind(keys,scope.name)
+
+        if 0==scopes.views.length
+            km.unbind(scope.shortcut,'all')
+            delete @scopes[scope.name]
+
+
+    initialize: ->
+        km.filter = -> true
+
+}

data/client/javascripts/view/ModelObserver.coffee

@@ -0,0 +1,31 @@
+class Lanes.View.ModelObserver extends Lanes.Data.State
+
+    model_events: {}
+
+    constructor: (@view, @keypath='model')->
+        super
+        @view.on( "change:#{@keypath}", this.rebindModel,   this )
+        @view.on( "remove",             this.teardown,      this )
+        this.rebindModel()
+
+    getModel: ->
+        @cached_model ||= Lanes.getPath(@keypath, @view)
+
+    unBindModel: (model)->
+        for event, fn of @model_events
+            model.off(event, this[fn], this )
+
+    bindModel: (model)->
+        for event, fn of @model_events
+            model.on(event, this[fn], this )
+
+    rebindModel: ->
+        @cached_model=null
+        old_model = @view.previous(@keypath)
+        new_model = this.getModel()
+        return if old_model == new_model
+        this.unBindModel( old_model ) if old_model
+        this.bindModel(   new_model ) if new_model
+
+    teardown: ->
+        this.unBindModel( model ) if model = this.getModel()

data/client/javascripts/view/ModelUpdate.coffee

@@ -0,0 +1,8 @@
+class Lanes.View.ModelUpdate extends Lanes.View.Base
+
+    templateName: 'view/model-update'
+
+    bindings:
+        'model.name':{ selector: 'a', type: 'text' }
+        'model.icon': { selector: 'i', type: 'class' }
+        'model.time_ago': '.ago'

data/client/javascripts/view/PubSub.coffee

@@ -0,0 +1,29 @@
+# Responsible for adding and removing a view's model(s) from Data.PubSub
+class Lanes.View.PubSub extends Lanes.View.ModelObserver
+
+    model_events:
+        'remote-update': 'onChange'
+
+    hideUpdate: (field)->
+        _.dom.removeClass(field,"updated")
+
+    showUpdate: (field)->
+        _.dom.addClass(field,"updated")
+        _.delay(@hideUpdate, 3000, field )
+
+    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)->
+        Lanes.Data.PubSub.add(model)
+        super
+
+    unBindModel: (model)->
+        Lanes.Data.PubSub.remove(model)
+        super
+
+    teardown: ->
+        super
+        Lanes.Data.PubSub.remove(model) if model = this.getModel()

data/client/javascripts/view/RenderContext.coffee

@@ -0,0 +1,32 @@
+Lanes.View.RenderContext = {
+
+    stack: []
+
+    reset: ()->
+        @stack  = []
+
+    start: (@parent, model=@parent.model)->
+        @stack = [[@parent,model]]
+
+    push: (identifier, model)->
+        @stack.push([identifier,model])
+        @_grants = null
+
+    model: ->
+        @stack[ @stack.length-1 ][1]?.modelForAccess()
+
+    view: ->
+        @stack[ @stack.length-1 ][0]
+
+    canRead: (field)->
+        Lanes.current_user.canRead( this.model(), field )
+
+    canWrite: (field)->
+        Lanes.current_user.canWrite( this.model(), field )
+
+    pop: ->
+        @stack.pop()
+
+
+
+}