uki 1.0.0

data/frameworks/uki/spec/unit/selector.spec.js

@@ -0,0 +1,140 @@
+describe 'uki.Selector'
+    it 'should tokenize expression'
+        tokens = uki.Selector.tokenize('label > * > project.views.CustomView Label[name^="wow"]')[0];
+        tokens.should_eql ['label', '>', '*', '>', 'project.views.CustomView', 'Label[name^="wow"]']
+    end
+    
+    it 'should copy find to uki'
+        uki.find.should.not.be_undefined
+    end
+    
+    describe 'filtering'
+        before_each
+            tree = uki.build([
+                { view: 'Box', rect: '0 0 1000 1000', name: 'top', childViews: [
+                    { view: 'Box', rect: '0 0 1000 1000', name: 'second', childViews: [
+                        { view: 'Box', rect: '10 10 100 100', name: 'third', someAttribute: true, childViews: [
+                            { view: 'Label', rect: '10 10 100 100', name: 'label1', someAttribute: false }
+                        ]},
+                        { view: 'Label', rect: '200 10 100 100', name: 'label2' }
+                    ]}
+                ]}
+            ]);
+        
+        end
+
+        it 'by *'
+            elements = uki.Selector.find('*', tree);
+            elements.length.should.be 4
+            uki.attr(elements[0], 'name').should.be 'second'
+            uki.attr(elements[1], 'name').should.be 'third'
+            uki.attr(elements[2], 'name').should.be 'label1'
+            uki.attr(elements[3], 'name').should.be 'label2'
+        end
+    
+        it 'by * *'
+            elements = uki.Selector.find('* *', tree);
+            elements.length.should.be 3
+            uki.attr(elements[0], 'name').should.be 'third'
+            uki.attr(elements[1], 'name').should.be 'label1'
+            uki.attr(elements[2], 'name').should.be 'label2'
+        end
+    
+        it 'by full typeName()'
+            elements = uki.Selector.find('uki.view.Label', tree);
+            elements.length.should.be 2
+            uki.attr(elements[0], 'name').should.be 'label1'
+            uki.attr(elements[1], 'name').should.be 'label2'
+        end
+    
+        it 'by contracted typeName()'
+            elements = uki.Selector.find('Box', tree);
+            elements.length.should.be 2
+            uki.attr(elements[0], 'name').should.be 'second'
+            uki.attr(elements[1], 'name').should.be 'third'
+        end
+    
+        it 'by attribute'
+            elements = uki.Selector.find('[name=second]', tree);
+            elements.length.should.be 1
+            uki.attr(elements[0], 'name').should.be 'second'
+        end
+        
+        it 'by attribute in brackets'
+            elements = uki.Selector.find('[name="second"]', tree);
+            elements.length.should.be 1
+            uki.attr(elements[0], 'name').should.be 'second'
+        end
+    
+        it 'by attribute and typeName()'
+            elements = uki.Selector.find('Box[name=second]', tree);
+            elements.length.should.be 1
+            uki.attr(elements[0], 'name').should.be 'second'
+        end
+        
+        it 'by ^= attribute'
+            elements = uki.Selector.find('[name^="label"]', tree);
+            elements.length.should.be 2
+            uki.attr(elements[0], 'name').should.be 'label1'
+            uki.attr(elements[1], 'name').should.be 'label2'
+        end
+        
+        it 'by $= attribute'
+            elements = uki.Selector.find('*[name$="bel1"]', tree);
+            elements.length.should.be 1
+            uki.attr(elements[0], 'name').should.be 'label1'
+        end
+        
+        it 'by ~= attribute'
+            elements = uki.Selector.find('*[name~="abe"]', tree);
+            elements.length.should.be 2
+            uki.attr(elements[0], 'name').should.be 'label1'
+            uki.attr(elements[1], 'name').should.be 'label2'
+        end
+        
+        it 'by attribute presence'
+            elements = uki.Selector.find('*[someAttribute]', tree);
+            elements.length.should.be 1
+            uki.attr(elements[0], 'name').should.be 'third'
+        end
+        
+        it 'direct children with >'
+            elements = uki.Selector.find('>', [tree[0].childViews()[0]]);
+            elements.length.should.be 2
+            uki.attr(elements[0], 'name').should.be 'third'
+            uki.attr(elements[1], 'name').should.be 'label2'
+        end
+        
+        it 'direct children with > *'
+            elements = uki.Selector.find('> *', [tree[0].childViews()[0]]);
+            elements.length.should.be 2
+            uki.attr(elements[0], 'name').should.be 'third'
+            uki.attr(elements[1], 'name').should.be 'label2'
+        end
+        
+        it 'right after with +'
+            elements = uki.Selector.find('Box + Label', tree);
+            elements.length.should.be 1
+            uki.attr(elements[0], 'name').should.be 'label2'
+        end
+        
+        it 'direct children within container >'
+            elements = uki.Selector.find('Box > Label', tree);
+            elements.length.should.be 2
+            uki.attr(elements[0], 'name').should.be 'label2'
+            uki.attr(elements[1], 'name').should.be 'label1'
+        end
+        
+        it 'by :eq modifier'
+            elements = uki.Selector.find('Box:eq(0) > Label:eq(0)', tree);
+            elements.length.should.be 1
+            uki.attr(elements[0], 'name').should.be 'label2'
+        end
+        
+        it 'by :gt modifier'
+            elements = uki.Selector.find('Box:gt(0)', tree);
+            elements.length.should.be 1
+            uki.attr(elements[0], 'name').should.be 'third'
+        end
+    end
+end

data/frameworks/uki/spec/unit/theme/template.spec.js

@@ -0,0 +1,31 @@
+describe 'uki.theme.Template'
+    it 'should replace single value'
+        var t = new uki.theme.Template('<code>${value}</code>')
+        t.render({value: '111'}).should.be '<code>111</code>'
+    end
+    
+    it 'should replace at the beggining of a string'
+        var t = new uki.theme.Template('${before}<code>${value}</code>')
+        t.render({before: '000', value: '111'}).should.be '000<code>111</code>'
+    end
+    
+    it 'should replace at the end of a string'
+        var t = new uki.theme.Template('<code>${value}</code>${after}')
+        t.render({value: '111', after: '222'}).should.be '<code>111</code>222'
+    end
+    
+    it 'should replace several same values'
+        var t = new uki.theme.Template('<code>${value} ${value}</code>');
+        t.render({value: '111'}).should.be '<code>111 111</code>'
+    end
+    
+    it 'should replace adjacent values'
+        var t = new uki.theme.Template('<code>${a}${b}</code>');
+        t.render({a: '111', b: '222'}).should.be '<code>111222</code>'
+    end
+    
+    it 'should work with brackets'
+        var t = new uki.theme.Template('<code>${a} {something} ${b} .css { some code }</code>');
+        t.render({a: '111', b: '222'}).should.be '<code>111 {something} 222 .css { some code }</code>'
+    end
+end

data/frameworks/uki/spec/unit/utils.spec.js

@@ -0,0 +1,176 @@
+describe 'uki.utils'
+    utils = uki.utils;
+    
+    it 'should test isFunction'
+        var f1 = function() {};
+        function f2 () {};
+        utils.isFunction(function() {}).should.be_true('anonimous function')
+        utils.isFunction(f1).should.be_true('var f = function')
+        utils.isFunction(f2).should.be_true('function f')
+        utils.isFunction({}).should.not.be_true('object')
+    end
+    
+    it 'should test isArray'
+        var x = [1, 2]
+        utils.isArray([]).should.be_true('anonimous array')
+        utils.isArray(x).should.be_true('x = []')
+        utils.isArray({}).should.not.be_true('object')
+    end
+    
+    describe '.each()'
+        it 'should iterate over array'
+            var count = 0;
+            utils.each([1, 1, 1], function() {
+                count ++;
+            });
+            count.should.be 3
+        end
+    
+        it 'should set this to current element'
+            utils.each([1, 1, 1], function() {
+                this.valueOf().should.eql 1
+            });
+        end
+    
+        it 'should iterate with given context'
+            var context = {};
+            utils.each([1, 1, 1], function() {
+                this.should.be context
+            }, context);
+        end
+        
+        it 'should iterave over hash'
+            utils.each({a: 1, b: 1, c: 1}, function() {
+                this.valueOf().should.be 1
+            });
+        end
+        
+        it 'should iterate over hash with given context'
+            var context = {};
+            utils.each({a: 1, b: 1, c: 1}, function() {
+                this.should.be context
+            }, context);
+        end
+    end
+    
+    it 'should trim text'
+        utils.trim('  TEST TEST ').should.be 'TEST TEST'
+    end
+    
+    it 'should escape html'
+        utils.escapeHTML('<span class="a">1</span>').should.be '&lt;span class=&quot;a&quot;&gt;1&lt;/span&gt;'
+    end
+    
+    it 'should test if is inArray'
+        utils.inArray(1, [0, 1, 2]).should.be 1
+        utils.inArray(3, [0, 1, 2]).should.be -1
+    end
+    
+    it 'should make uniq array'
+        utils.unique([1, 1, 2, 3]).should.eql [1, 2, 3]
+    end
+    
+    it 'should grep array for items'
+        var result = utils.grep([1, 2, 3, 4], function(v) {
+            return v > 2;
+        });
+        result.should.eql [3, 4]
+    end
+    
+    it 'should map array'
+        var result = utils.map([1, 2, 3, 4], function(v) {
+            return -v;
+        });
+        result.should.eql [-1, -2, -3, -4]
+    end
+    
+    it 'should reduce array'
+        var result = utils.reduce(1, [1,2,3,4], function(x, e) { return e*x; });
+        result.should.be 2*3*4
+    end
+    
+    it 'should map in given context'
+        var context = {};
+        var result = utils.map([1, 2, 3, 4], function(v) {
+            this.should.be context
+        }, context);
+    end
+    
+    it 'should map by field name (shortcut)'
+        var result = utils.map([{a: 1}, {a: 2}, {a: 3}], 'a');
+        result.should.eql [1, 2, 3]
+    end
+    
+    it 'should map extend objects'
+        var e = utils.extend({a: 1}, {b: 2}, {c: 3, d: undefined});
+        e.should.eql {a: 1, b: 2, c: 3}
+    end
+    
+    it 'should extend uki with utils'
+        var functions = ['isFunction', 'isArray', 'trim', 'escapeHTML', 'each', 'inArray', 'unique', 'grep', 'map', 'extend'];
+        utils.each(functions, function() {
+            uki[this].should.not.be_null
+        });
+    end
+    
+    it 'should extend new class with base class'
+        base = function() {};
+        called = {};
+        base.prototype = {
+            a: function() {
+                called.a = true;
+            }
+        }
+        var sub = uki.newClass(base, { init: uki.F });
+        (new sub()).a();
+        called.a.should.be_true
+    end
+    
+    it 'should extend new class with mixins'
+        base = function() {};
+        called = {};
+        base.prototype = {
+            a: function() {
+                called.a = true;
+            }
+        }
+        var sub = uki.newClass(base, { b: function() { called.b = true} }, { init: uki.F });
+        (new sub()).a();
+        (new sub()).b();
+        called.a.should.be_true
+        called.b.should.be_true
+    end
+    
+    it 'should use function as a last parameter passing base classes to it'
+        base = function() {};
+        called = false;
+        base.prototype = {
+            a: function() {
+                called.a = true;
+            }
+        }
+        var sub = uki.newClass(base, { b: function() { called.b = true} }, function(b, mixin) {
+            called = true;
+            b.should.be base.prototype
+            mixin.b.should.not.be_null
+            this.init = uki.F;
+            this.b = uki.F;
+        });
+        (new sub()).b.should.not.be_null
+        called.should.be_true
+    end
+    
+    it 'should filter unique elements in array'
+        a = [1, 2, 3, 1, 4]
+        uki.unique(a).should.eql [1, 2, 3, 4]
+    end
+    
+    it 'should filter unique elements in array of objects'
+        x = {a: 1}
+        y = {b: 1}
+        z = {c: 1}
+        a = [x, y, x, y, z]
+        uki.unique(a).should.eql [x, y, z]
+    end
+    
+end

data/frameworks/uki/spec/unit/view/base.spec.js

@@ -0,0 +1,86 @@
+describe 'uki.view.Base'
+
+    before_each
+        v = new uki.view.Base('100 100');
+    end
+    
+    it 'should create a dom node upon construction'
+        v.dom().should.not.be_null
+    end
+    
+    it 'should delegate className to dom'
+        v.className('test')
+        v.className().should.be 'test'
+        v.dom().className.should.be 'test'
+    end
+    
+    it 'should delegate id to dom'
+        v.id('test')
+        v.id().should.be 'test'
+        v.dom().id.should.be 'test'
+    end
+    
+    it 'should register id in a hash'
+        called = false
+        stub(uki, 'registerId').and_return(function(view) {
+            view.id().should.be 'test1'
+            called = true
+        });
+        v.id('test1')
+        called.should.be_true
+    end
+    
+    it 'should unregister id from hash on change'
+        called = false
+        stub(uki, 'unregisterId').and_return(function(view) {
+            view.id().should.be 'test2'
+            called = true
+        });
+        v.id('test2')
+        v.id('test3')
+        called.should.be_true
+    end
+    
+    it 'should attach background'
+        var bg = new uki.background.Null()
+        called = false
+        stub(bg, 'attachTo').and_return(function(view) {
+            view.should.be v
+            called = true
+        })
+        v.background(bg)
+        called.should.be_true
+    end
+    
+    it 'should return default background if none specified'
+        v._defaultBackground = '#CCC'
+        v.background().should.be_an_instance_of uki.background.Css
+    end
+    
+    it 'should set rect property'
+        v.rect('0 10 20 30')
+        v.rect().should.be_an_instance_of uki.geometry.Rect
+    end
+    
+    it 'should set minSize and maxSize properties'
+        v.minSize('10 20').maxSize('100 200')
+        v.dom().style.minWidth.should.be '10px'
+        v.dom().style.minHeight.should.be '20px'
+        v.dom().style.maxWidth.should.be '100px'
+        v.dom().style.maxHeight.should.be '200px'
+        v.minSize().should.eql new uki.geometry.Size(10, 20)
+        v.maxSize().should.eql new uki.geometry.Size(100, 200)
+    end
+    
+    it 'should normailze rect according to min and max sizes'
+        v.minSize('110 10')
+        v.rect().width.should.be 110
+        v.maxSize('200 50')
+        v.rect().height.should.be 50
+    end
+    
+    it 'should return null for next/prev views'
+        v.nextView().should.be_null
+        v.prevView().should.be_null
+    end
+end

data/frameworks/uki/spec/unit/view/container.spec.js

@@ -0,0 +1,73 @@
+describe 'uki.view.Container'
+    before_each
+        parentView = new uki.view.Container('100 200')
+    end
+    
+    it 'should append child views'
+        child = new uki.view.Base('10 10')
+        parentView.appendChild(child)
+        parentView.childViews().length.should.be 1
+        parentView.childViews().should.eql [child]
+    end
+    
+    it 'should insert child before'
+        firstChild = new uki.view.Base('10 10')
+        secondChild = new uki.view.Base('10 10')
+        parentView.appendChild(secondChild)
+        parentView.insertBefore(firstChild, secondChild)
+        parentView.childViews().should.eql [firstChild, secondChild]
+    end
+    
+    it 'should set correct parent'
+        child = new uki.view.Base('10 10')
+        parentView.appendChild(child)
+        child.parent().should.be parentView
+    end
+    
+    it 'should remove children'
+        child = new uki.view.Base('10 10')
+        parentView.appendChild(child)
+        parentView.removeChild(child)
+        child.parent().should.be_null
+    end
+    
+    it 'should allow childViews() writing'
+        child = new uki.view.Base('10 10')
+        parentView.childViews([child])
+        parentView.childViews().should.eql [child]
+    end
+    
+    it 'should remove children on childViews() write'
+        firstChild = new uki.view.Base('10 10')
+        secondChild = new uki.view.Base('10 10')
+        thirdChild = new uki.view.Base('10 10')
+        parentView.childViews([firstChild, secondChild])
+        parentView.childViews([secondChild, thirdChild])
+        firstChild.parent().should.be_null
+        secondChild.parent().should.be parentView
+        thirdChild.parent().should.be parentView
+    end
+    
+    it 'should allow nextView, prevView accessors for children'
+        secondChild = new uki.view.Base('10 10')
+        firstChild = new uki.view.Base('10 10')
+        parentView.appendChild(firstChild)
+        parentView.appendChild(secondChild)
+        firstChild.nextView().should.be secondChild
+        secondChild.prevView().should.be firstChild
+        firstChild.prevView().should.be_null
+        secondChild.nextView().should.be_null
+    end
+        
+    it 'should resize children on rect resize'
+        child = new uki.view.Base('10 10')
+        called = 0
+        stub(child, 'parentResized').and_return(function() {
+            called++;
+        });
+        parentView.appendChild(child)
+        parentView.rect('200 200')
+        called.should.be 1
+    end
+  
+end

data/frameworks/uki/spec/unit/view.spec.js

@@ -0,0 +1,13 @@
+describe 'uki.view'
+    it 'should declare new views'
+        called = false
+        uki.view.declare('tmp.view.TestView', uki.view.Base, function(base) {
+            base.should.be uki.view.Base.prototype
+            called = true
+        });
+        tmp.view.TestView.should.not.be_null
+        called.should.be_true
+        (new tmp.view.TestView()).typeName().should.be 'tmp.view.TestView'
+    end
+  
+end

data/frameworks/uki/src/airport.js

@@ -0,0 +1 @@
+include('uki-theme/airport.js');

data/frameworks/uki/src/uki-core/attachment.js

@@ -0,0 +1,175 @@
+include('const.js');
+include('utils.js');
+include('dom.js');
+include('geometry.js');
+include('view/observable.js');
+
+(function() {
+    var self = uki.Attachment = uki.newClass(uki.view.Observable, /** @lends uki.Attachment.prototype */ {
+        /**
+         * Attachment serves as a connection between a uki view and a dom container.
+         * It notifies its view with parentResized on window resize. 
+         * Attachment supports part of uki.view.Base API like #domForChild or #rectForChild
+         *
+         * @param {Element} dom Container element
+         * @param {uki.view.Base} view Attached view
+         * @param {uki.geometry.Rect} rect Initial size
+         *
+         * @see uki.view.Base#parentResized
+         * @name uki.Attachment
+         * @augments uki.view.Observable
+         * @constructor
+         */
+        init: function( dom, view, rect ) {
+            uki.initNativeLayout();
+            
+            this._dom     = dom = dom || root;
+            this._view    = view;
+            this._rect = Rect.create(rect) || this.rect();
+            
+            uki.dom.offset.initialize();
+            
+            view.parent(this);
+            this.domForChild().appendChild(view.dom());
+            
+            if (dom != root && dom.tagName != 'BODY') {
+                var computedStyle = dom.runtimeStyle || dom.ownerDocument.defaultView.getComputedStyle(dom, null);
+                if (!computedStyle.position || computedStyle.position == 'static') dom.style.position = 'relative';
+            }
+            self.register(this);
+
+            this.layout();
+        },
+        
+        /**
+         * Returns document.body if attached to window. Otherwise returns dom
+         * uki.view.Base api
+         *
+         * @type Element
+         */
+        domForChild: function() {
+            return this._dom === root ? doc.body : this._dom;
+        },
+        
+        /**
+         * uki.view.Base api
+         *
+         * @type uki.geometry.Rect
+         */
+        rectForChild: function(child) {
+            return this.rect();
+        },
+        
+        /**
+         * uki.view.Base api
+         */
+        scroll: function() {
+            // TODO: support window scrolling
+        },  
+        
+        /**
+         * uki.view.Base api
+         */
+        scrollTop: function() {
+            // TODO: support window scrolling
+            return this._dom.scrollTop || 0;
+        },
+        
+        /**
+         * uki.view.Base api
+         */
+        scrollLeft: function() {
+            // TODO: support window scrolling
+            return this._dom.scrollLeft || 0;
+        },
+        
+        /**
+         * uki.view.Base api
+         */
+        parent: function() {
+            return null;
+        },
+        
+        /**
+         * On window resize resizes and layout its child view
+         * @fires event:layout
+         */
+        layout: function() {
+            var oldRect = this._rect;
+                
+            // if (rect.eq(this._rect)) return;
+            var newRect = this._rect = this.rect();
+            this._view.parentResized(oldRect, newRect);
+            if (this._view._needsLayout) this._view.layout();
+            this.trigger('layout', {source: this, rect: newRect});
+        },
+        
+        /**
+         * @return {Element} Container dom
+         */
+        dom: function() {
+            return this._dom;
+        },
+        
+        /**
+         * @return {Element} Child view
+         */
+        view: function() {
+            return this._view;
+        },
+        
+        /**
+         * @private
+         * @return {uki.geometry.Rect} Size of the container
+         */
+        rect: function() {
+            var width = this._dom === root || this._dom === doc.body ? 
+                    MAX(getRootElement().clientWidth, this._dom.offsetWidth || 0) : 
+                    this._dom.offsetWidth,
+                height = this._dom === root || this._dom === doc.body ? 
+                    MAX(getRootElement().clientHeight, this._dom.offsetHeight || 0) : 
+                    this._dom.offsetHeight;
+            
+            return new Rect(width, height);
+        }
+    });
+    
+    function getRootElement() {
+        return doc.compatMode == "CSS1Compat" && doc.documentElement || doc.body;
+    }
+    
+    self.instances = [];
+    
+    /**
+     * @memberOf uki.Attachment
+     */
+    self.register = function(a) {
+        if (self.instances.length == 0) {
+            var timeout = false;
+            uki.dom.bind(root, 'resize', function() {
+                if (!timeout) {
+                    timeout = true;
+                    setTimeout(function() {
+                        timeout = false;
+                        uki.each(self.instances, function() { this.layout(); });
+                    }, 1)
+                }
+            });
+        }
+        self.instances.push(a);
+    };
+    
+    /**
+     * @memberOf uki.Attachment
+     */
+    self.childViews = function() {
+        return uki.map(self.instances, 'view');
+    };
+    
+    /**
+     * @memberOf uki.Attachment
+     */
+    uki.top = function() {
+        return [self];
+    };
+})();