lanes 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 38a1fcc3512ac9a78d8c2016485012fb4a2bb5bf
+  data.tar.gz: e61f1035204fea72416015f3a1ffa931e650b467
+SHA512:
+  metadata.gz: b840ac96f4bc763324dc3f9a80b15b91d720e81115a1dc21ba25cc2696fc2e24dd9be382ca124f9687994c7dba8fdb5125241c34ebbcecaf57ff81e0473ae92d
+  data.tar.gz: 410fabf525eee6f51f1e185bc6a40ad4276062b8058f918495de898be6ab279cc1ed11de635ea0b299f2a7338710b9ddf77bb2683922ff60f8b7859c48e39e9a

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+coverage
+doc/
+log/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+npm-build/node_modules
+tmp
+db/schema*

data/.jshintrc

@@ -0,0 +1,3 @@
+{
+  "esnext": true
+}

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gem "yard-activerecord",   github: 'nathanstitt/yard-activerecord', branch: 'develop'
+gem "active_record_mocks", github: 'envygeeks/active_record_mocks', branch: 'master'
+gem "guard-jasmine",       github: "guard/guard-jasmine",           branch: 'jasmine-2'
+
+gem 'puma'
+
+gemspec

data/Guardfile

@@ -0,0 +1,15 @@
+notification :growl
+
+require "lanes/guard_tasks"
+
+Lanes::GuardTasks.run(self, name: 'lanes') do | tests |
+
+    tests.client do
+
+    end
+
+    tests.server do
+
+    end
+
+end

data/LICENSE-MIT.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Argosity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,15 @@
+# Lanes web framework
+
+Lanes is a web framework that aims to make writing single page apps as simple as traditional Rails apps.
+
+It's extracted from the Stockor ERP application and is still very much a work in progress.
+
+## Contributing
+
+The standard instructions are always good:
+
+ 1. Fork it ( http://github.com/argosity/stockor-core/fork )
+ 2. Create your feature branch (`git checkout -b my-new-feature`)
+ 3. Commit your changes (`git commit -am 'Add some feature'`)
+ 4. Push to the branch (`git push origin my-new-feature`)
+ 5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,74 @@
+require 'bundler/setup'
+require "bundler/gem_tasks"
+require 'rake/testtask'
+require 'yard'
+require 'yard-activerecord'
+require_relative 'yard_ext/all'
+require 'guard'
+
+Dir.glob('tasks/*.rake').each { |r| load r}
+
+Rake::TestTask.new do |t|
+    t.libs << 'test'
+    t.pattern = "test/*_test.rb"
+end
+
+
+YARD::Rake::YardocTask.new do |t|
+    t.files   = ['lib/skr/concerns/*.rb','lib/**/*.rb','db/schema.rb']
+    t.options = ["--title=Stockor Core Documentation",
+                 "--markup=markdown",
+                 "--template-path=yard_ext/templates",
+                 "--readme=README.md"]
+end
+
+
+desc "Open an irb session preloaded with skr-core"
+task :console do
+    require 'irb'
+    require 'irb/completion'
+    require 'pp'
+    require 'lanes'
+    include Lanes
+    Lanes::DB.establish_connection
+    ActiveRecord::Base.logger = Logger.new STDOUT
+    ARGV.clear
+    IRB.start
+end
+
+
+task :doc => 'db:environment' do
+    env = ENV['RAILS_ENV'] || 'development'
+    ENV['SCHEMA']       = 'db/schema.rb'
+    ENV['DB_STRUCTURE'] = 'db/schema.rb'
+    Rake::Task["db:schema:dump"].invoke
+    Rake::Task["yard"].invoke
+end
+
+
+task :guard => [ 'db:migrate', 'db:test:clone_structure' ] do
+    # NAS: I've never figured out how to run Guard from a rake task
+    # Guard.setup
+    # Guard.run_all
+    # ^ this will work but only runs the task once
+    # and doesn't listen for changes.  Which kinda defeats the purpose
+    # For now just shell out until I can figure it out
+    sh "bundle exec guard"
+end
+
+args = ['-F','config/puma.rb']
+
+task :dev do
+    args.push('start')
+    Puma::ControlCLI.new(args).run
+end
+
+# require 'jasmine'
+# load 'jasmine/tasks/jasmine.rake'
+
+
+task :testj do
+    require 'lanes/api'
+    Lanes.config.specs_root = Pathname.getwd
+
+end

data/bin/lanes

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'lanes/cli'
+
+Lanes::CLI.start(ARGV)

data/client/javascripts/component/Base.coffee

@@ -0,0 +1,39 @@
+class BaseComponent
+
+    constructor: (options={})->
+        super
+        @access ||= this.calculate_access()
+
+    namespace: "Component"
+
+    session:
+        access:
+            type: 'string',
+            values: ['read','write','none']
+
+    derived:
+        readOnly:  { deps: ['access'], fn:-> @access=='read' }
+        writeAble: { deps: ['access'], fn:-> @access=='write' }
+
+    readTemplate:  -> @renderTemplateMethod('template')
+    writeTemplate: -> @renderTemplateMethod('template')
+    emptyTemplate: -> '<span></span>'
+
+    template: (scope)->
+        if scope.writeAble
+            scope.writeTemplate()
+        else if scope.readOnly
+            scope.readTemplate()
+        else
+            scope.emptyTemplate()
+
+    calculate_access:->
+        if ! @field_name || Lanes.View.RenderContext.canWrite(@field_name)
+            'write'
+        else if Lanes.View.RenderContext.canRead(@field_name)
+            'read'
+        else
+            'none'
+
+
+Lanes.Component.Base = Lanes.View.Base.extend(BaseComponent)

data/client/javascripts/component/ChoicesInput.coffee

@@ -0,0 +1,47 @@
+class Lanes.Component.ChoicesInput extends Lanes.Component.Base
+
+    session:
+        selections: 'collection'
+
+    subViewOptions: ->
+        { field_name: @field_name, mappings: @mappings }
+
+    constructor: (options={})->
+        if options.has_many
+            @association = options.model.associations[options.has_many]
+            @field_name  = @association.fk
+        else
+            @field_name = options.field_name || options.subViewId
+
+        @mappings = _.extend({
+            id: 'id', title: 'title', selected: 'selected'
+        },options.mappings||{})
+        super
+
+
+    initialize: (options={})->
+        if @association
+            collection = Lanes.Data[@association.model].sharedCollection()
+            collection.fetch().then (m)=>
+                @selections = m
+                this.on('change:model', this.onModelChange )
+        else if options.data
+            @selections = options.data
+
+    selectionForID: (id)->
+        q={}; q[@mappings.id]=id
+        @selections.findWhere( q )
+
+    onAttributeChange: (model,fkid)->
+        this.select( this.selectionForID( fkid ) )
+
+    onModelChange: ->
+        if (old_model = this.previousAttributes()['model'])
+            this.stopListening(old_model,"change:#{@association.fk}", this.onAttributeChange )
+        this.listenTo(@model,"change:#{@association.fk}", this.onAttributeChange )
+        fk_id = @model.get( @association.fk )
+        record = if fk_id
+            this.selectionForID( fk_id )
+        else
+            @model[@association.name]
+        this.select(record)

data/client/javascripts/component/Grid.coffee

@@ -0,0 +1,199 @@
+# DataTables class modifications
+_.extend( Lanes.$.fn.dataTableExt.oStdClasses,{
+    sTable: "table table-striped"
+	sWrapper: "dataTables_wrapper form-inline"
+	sFilterInput: "form-control input-sm"
+	sLengthSelect: "form-control input-sm"
+})
+
+
+class Lanes.Component.Grid extends Lanes.Component.Base
+
+    events:
+        'click button.refresh': 'reload'
+        'click button.delete':  'deleteRow'
+        'click button.create':  'addRow'
+        'click tr': 'onRowClick'
+        'cancel-edit': 'onCancelEdit'
+        'order.dt table': 'onSort'
+
+    templateName: 'grid'
+    templateData: ->
+        data = { grid: this, buttons: ['refresh'] }
+        data['buttons'].push('create') if @add_records
+        data['buttons'].push('delete') if @delete_records
+        data
+
+    derived:
+        column_definitions:
+            deps:['record_query'], fn: ->
+                @record_query.fields.map(this._make_field, this)
+
+        model_class:
+             deps:['record_query'], fn:-> @record_query.model_class
+
+        single_select_mode:
+             deps:['selection_mode'], fn:-> @selection_mode == 'single'
+
+    session:
+        edit_records:   ['boolean',true,false]
+        add_records:    ['boolean',true,false]
+        delete_records: ['boolean',true,false]
+        record_query:   'state'
+        editor:         'state'
+        selection_mode: ['string', true, 'single']
+        editor_config:  { type: 'object' }
+        editing_controller:  'any' # either string or constructor fn
+
+    initialize: (options)->
+        this.listenTo(this.ui,'change:screen_menu_size', this.delayedWidthReset)
+
+        unless Lanes.current_user.canWrite(this.model_class)
+            this.edit_records = false
+            this.add_records  = false
+        unless Lanes.current_user.canDelete(this.model_class)
+            this.delete_records = false
+
+    onSort: ->
+        return unless @editor
+        @editor.remove()
+        this.unset('editor')
+
+    onSelect: (ev)->
+        [record,row] = ev.detail
+        this.grid.unselect(row)
+
+    removeRow: (row)->
+        this.dt_api.row(row).remove().draw()
+
+    onCancelEdit: (ev)->
+        model = this.modelForRow(ev.detail)
+        this.removeRow(ev.detail) if model.isNew()
+
+    reload: ->
+        @dt_api.ajax.reload()
+
+    unselect: (row)->
+        @fireEvent('unselect-row', @modelForRow(row), {row:row} )
+        row.removeClass('active')
+
+    beginEdit: (row,ev)->
+        return false unless model = this.modelForRow(row)
+        this.createEditor(row) unless @editor
+        @editor.move(row,ev)
+
+
+    createEditor: (row)->
+        config = _.extend({ parent: this }, this.editor_config)
+        @editor = switch this.editing_controller
+            when 'row' then new Grid.RowEditor(config)
+            when 'popover' then new Grid.PopOverEditor(config)
+            else new this.editing_controller(config)
+
+    deleteRow: ->
+        @editor.deleteCurrent()
+
+
+    addRow: (record)->
+        # create a record if record argument wasn't given or it's an event
+        record = new this.model_class() if !record || record.type == "click"
+        row = this.dt_api.row.add( this._dataFromModel(record) )
+        this.api_settings().oFeatures.bServerSide=false
+        row.draw(false)
+        this.api_settings().oFeatures.bServerSide=true
+        this.$( row.nodes() ).click()
+
+
+    api_settings: ->
+        this.dt_api.settings()[0]
+
+    onRowClick: (ev)->
+        row = this.$(ev.target).closest('tr')
+        if this.edit_records
+            this.beginEdit(row,ev)
+        else if @single_select_mode
+            this.unselect(row) for row in this.$('tr .active')
+        else
+            if row.hasClass('active')
+                this.unselect(row)
+            else
+                row.addClass('active')
+                @fireEvent('select-row', {model:model, row:row} ) if model = this.modelForRow(row)
+
+    updateRow: (row, model)->
+        row.attr('id', model.id)
+        this.dt_api.row(row).data(this._dataFromModel(model)).draw()
+
+
+    modelForRow: (row)->
+        data = this.dt_api.row(row).data()
+        return null unless data
+        return data.model if data.model?.isModel
+        attrs = if row.attr('id') then { id: parseInt(row.attr('id')) } else {}
+        for field,i in @column_definitions
+            attrs[field.field] = data[i]
+        data.model = new @record_query.model_class(attrs,ignoreUnsaved:true)
+
+
+    delayedGridConfiguration: ->
+        _.delay( =>
+            @dt_api.columns.adjust()
+        ,500 )
+
+
+    render: ->
+        super
+        responsiveHelper = undefined;
+        breakpointDefinition = {
+            tablet: 1024,
+            phone : 480
+        };
+
+        this.dataTable=this.$('table').dataTable(
+            deferRender: true
+            scrollY: "300px"
+            scrollX: true
+            serverSide: true
+            oClasses: ['table', 'table-stiped', 'table-hover', 'table-condensed']
+            bProcessing: true
+            bDeferRender: true
+            oScroller: { loadingIndicator: true }
+#            columnDefs: @column_definitions
+            ajax:
+                url: @record_query.url
+                data: (d)=>@buildData(d)
+                dataSrc: (d)->
+                    d.recordsFiltered = d.recordsTotal = d.total
+                    row.DT_RowId = row.shift() for row in d.data
+                    d['data']
+            dom: "rtiS"
+            oScroller:
+                rowHeight: 40
+            columns: @column_definitions
+        )
+        this.dt_api = this.dataTable.api()
+
+        this.delayedGridConfiguration()
+        this
+
+    buildData: (d)->
+        params = { o: {}, s: d.start, l: d.length||100, df:'array', f: ['id'].concat(_.pluck(@column_definitions, 'field')) }
+        if ! _.isEmpty( query = @record_query.asParams() )
+            params['q']=query
+        for order in d.order
+            column = @record_query.fields.at(order.column)
+            params['o'][column.field] = order.dir
+        params
+
+
+    _make_field: (query_field,index)->
+        align = switch query_field.type
+            when 'integer','bigdec' then 'r'
+            else 'l'
+        { title: query_field.title, field: query_field.field, className: align, "targets": [ index ] }
+
+    _dataFromModel: (model)->
+        data = []
+        for field,i in @column_definitions
+            data.push( model.get(field.field) || '' )
+        data

data/client/javascripts/component/ModalDialog.coffee

@@ -0,0 +1,44 @@
+class Lanes.Component.ModalDialog extends Lanes.Component.Base
+
+    events:
+        'hide.bs.modal': '_onHide'
+
+    bindings:
+        'ui.layout_size': { type:'class',selector:'.modal-dialog'}
+
+    buttons:
+        close: { label: 'Close', type: 'default', dismiss: true }
+
+    session:
+        dialog_title: 'string'
+
+    initialize: (options)->
+        super
+
+    toggleShown: (show)->
+        if show then this.show() else this.hide()
+
+    template: (context)->
+        tmpl = Lanes.Templates.find('modal', context.namespace)
+        tmpl({
+            size    : context.size  || 'lg'
+            title   : context.title || context.dialog_title
+            body    : context.renderTemplateMethod('bodyTemplate')
+            buttons : context.buttons
+        })
+
+    hide:->
+        this.$el.modal('hide')
+        Lanes.Promise.resolve( this )
+
+    show: ->
+        this.render()
+        this.$el.modal({ body: this.ui.viewport })
+        this.notification = new Lanes.Deferred
+        return this.notification.promise
+
+    destroy: ->
+        this.detach()
+
+    _onHide: (ev)->
+        this.notification.resolve(this)

data/client/javascripts/component/PopOver.coffee

@@ -0,0 +1,52 @@
+class Lanes.Component.PopOver extends Lanes.Component.Base
+
+    events:
+        'hide.bs.popover': '_onHide'
+
+    session:
+        target: 'el'
+        title: 'string'
+        content: 'any'
+        template: 'string'
+        templateData: 'object'
+        placement: { type: 'string', default: "right" }
+        destroyAfterHide: [ 'boolean', true, false ]
+
+    derived:
+        options:
+            deps: ['title','content','template','templateData'], fn:->
+                content = if this.template then this.renderTemplate() else this.content
+                { title: @title, content: content, html: true, placement: "auto #{@placement}" }
+
+    renderTemplate: ->
+        template = Lanes.Templates.find(this.template)
+        if template
+            template(this.templateData)
+        else
+            Lanes.warn "PopOver Template #{this.template} was not found"
+
+    initialize: (options)->
+        template = Lanes.Templates.find('component/popover')({ className: options.className||'' })
+        _.extend(options, this.options, {template: template, container: this.ui?.viewport})
+        this.target.popover(options).on("hide.bs.popover", _.bind(this._onHide, this) )
+        this.show() if options.autoShow
+
+    toggleShown: (show)->
+        if show then this.show() else this.hide()
+
+    show: ->
+        this.target.popover('show')
+        this.notification = new Lanes.Deferred
+        return this.notification.promise
+
+    destroy: ->
+        this.target.popover('destroy')
+
+    hide:->
+        this.target.popover('hide')
+        Lanes.Promise.resolve( this )
+        this.destroy()
+
+    _onHide: (ev)->
+        this.notification.resolve(this)
+        this.destroy() if this.destroyAfterHide

data/client/javascripts/component/RadioGroup.coffee

@@ -0,0 +1,59 @@
+class RadioInput
+    template: (scope)->
+        '<label><input type="radio" name="' + scope.field_name + '"/> <span></span></label>'
+
+    #bindings: {}
+
+    constructor: (options)->
+        @field_name=options.field_name
+        m = options.mappings
+        @bindings = {}
+        @bindings["model.#{m.id}"]       = { type: 'value', selector: 'input' }
+        @bindings["model.#{m.selected}"] = { type: 'booleanAttribute', selector: 'input', name:'checked' }
+        @bindings["model.#{m.title}"]    = 'span'
+        @bindings["model.#{m.visible}"]  = { type: 'toggle' } if m.visible
+        super
+
+
+Lanes.View.Base.extend(RadioInput)
+
+
+class RadioGroup
+    constructor: -> super
+
+    events:
+        'change input': 'onInputChange'
+
+    writeTemplate: ->
+        "<span data-hook='choices-input'></span>"
+
+    subviews:
+        fields:
+            hook: 'choices-input'
+            collection: 'selections'
+            options: 'subViewOptions'
+            view: RadioInput
+
+
+    initialize: ->
+        super
+        this.listenTo(@selections, "change", this.onSelectionChange) if @selections
+
+    onSelectionChange: (option)->
+        return unless option[@mappings.selected]
+        @selections.each( (other_option)->
+            other_option[@mappings.selected] = other_option[@mappings.id] == option[@mappings.id]
+        ,this)
+
+    onInputChange: (ev)->
+        @selections.each( (option)->
+            option[@mappings.selected] = option[@mappings.id] == ev.target.value
+        ,this)
+
+    getSelected: ->
+        q={}
+        q[@mappings.selected]=true
+        @selections.findWhere(q)
+
+
+Lanes.Component.RadioGroup = Lanes.Component.ChoicesInput.extend(RadioGroup)