uki 1.0.0

data/frameworks/uki/src/uki-view/view/table.js

@@ -0,0 +1,71 @@
+include('list.js');
+
+uki.view.table = {};
+
+uki.view.declare('uki.view.Table', uki.view.Container, function(Base) {
+    var propertiesToDelegate = 'rowHeight data packSize visibleRectExt render selectedIndex focusable textSelectable multiselect'.split(' ');
+    
+    this._rowHeight = 17;
+    this._headerHeight = 17;
+    this.defaultCss = Base.defaultCss + 'overflow:hidden;';
+    this._listImpl = 'uki.view.List';
+    
+    uki.each(propertiesToDelegate, function(i, name) { uki.delegateProp(this, name, '_list'); }, this);
+    
+    this.columns = uki.newProp('_columns', function(c) {
+        this._columns = uki.build(c);
+        this._totalWidth = 0;
+        for (var i = 0; i < this._columns.length; i++) {
+            this._columns[i].position(i);
+            this._columns[i].bind('beforeResize', uki.proxy(function() {
+                this._updateTotalWidth();
+                this._scrollPane.layout();
+            }, this));
+        };
+        this._updateTotalWidth();
+        this._header.columns(this._columns);
+    });
+    
+    this._updateTotalWidth = function() {
+        this._totalWidth = 0;
+        for (var i=0; i < this._columns.length; i++) {
+            this._columns[i].position(i);
+            this._totalWidth += this._columns[i].width();
+        };
+        this._list.minSize(new Size(this._totalWidth, 0));
+        this._list.rect(new Rect(this._totalWidth, this._list.height()));
+        this._header.minSize(new Size(this._totalWidth, 0));
+    };
+    
+    this._createDom = function() {
+        Base._createDom.call(this);
+        var scrollPaneRect = new Rect(0, this._headerHeight, this.rect().width, this.rect().height - this._headerHeight),
+            listRect = scrollPaneRect.clone().normalize(),
+            headerRect = new Rect(0, 0, this.rect().width, this._headerHeight),
+            listML = { view: this._listImpl, rect: listRect, anchors: 'left top bottom', render: new uki.view.table.Render(this), className: 'table-list' },
+            paneML = { view: 'ScrollPane', rect: scrollPaneRect, anchors: 'left top right bottom', scrollableH: true, childViews: [listML], className: 'table-scroll-pane'},
+            headerML = { view: 'table.Header', rect: headerRect, anchors: 'top left right', className: 'table-header' };
+            
+        uki.each(propertiesToDelegate, function(i, name) { 
+            if (this['_' + name] !== undefined) listML[name] = this['_' + name];
+        }, this);
+        this._scrollPane = uki.build(paneML)[0];
+        this._list = this._scrollPane.childViews()[0];
+        this._header = uki.build(headerML)[0];
+        this._scrollPane.resizeToContents();
+        this.appendChild(this._header);
+        this.appendChild(this._scrollPane);
+        
+        this._scrollPane.bind('scroll', uki.proxy(function() {
+            // this is kinda wrong but faster than calling rect() + layout()
+            this._header.dom().style.left = -this._scrollPane.scrollLeft() + 'px'; 
+        }, this));
+        
+    };
+});
+
+uki.Collection.addAttrs(['columns']);
+
+include('table/render.js');
+include('table/column.js');
+include('table/header.js');

data/frameworks/uki/src/uki-view/view/textField.js

@@ -0,0 +1,145 @@
+uki.view.declare('uki.view.TextField', uki.view.Base, uki.view.Focusable, function(Base, Focusable) {
+    var emptyInputHeight = {};
+
+    function getEmptyInputHeight (fontSize) {
+        if (!emptyInputHeight[fontSize]) {
+            var node = uki.createElement('input', Base.defaultCss + "border:none;padding:0;border:0;overflow:hidden;font-size:"+fontSize+";left:-999em;top:0");
+            uki.dom.probe(
+                node,
+                function(probe) {
+                    emptyInputHeight[fontSize] = probe.offsetHeight;
+                }
+            );
+        }
+        return emptyInputHeight[fontSize];
+    }
+
+    function nativePlaceholder (node) {
+        return typeof node.placeholder == 'string';
+    }
+
+    
+    this._setup = function() {
+        Base._setup.apply(this, arguments);
+        uki.extend(this, {
+            _value: '',
+            _multiline: false,
+            _placeholder: '',
+            _backgroundPrefix: '',
+            defaultCss: Base.defaultCss + "margin:0;border:none;outline:none;padding:0;font-size:11px;left:2px;top:0;z-index:100;resize:none;background: url(" + uki.theme.imageSrc('x') + ")"
+        });
+    };
+    
+    this._updateBg = function() {
+        this._input.style.color = this._disabled ? '#999' : '#000';
+    };
+    
+    this.value = function(value) {
+        if (value === undefined) return this._input.value;
+
+        this._input.value = value;
+        this._updatePlaceholderVis();
+        return this;
+    };
+    
+    this.placeholder = uki.newProp('_placeholder', function(v) {
+        this._placeholder = v;
+        if (!this._multiline && nativePlaceholder(this._input)) {
+            this._input.placeholder = v;
+        } else {
+            if (!this._placeholderDom) {
+                this._placeholderDom = uki.createElement('div', this.defaultCss + 'z-input:103;color:#999;cursor:text', v);
+                this._dom.appendChild(this._placeholderDom);
+                this._updatePlaceholderVis();
+                uki.each(['fontSize', 'fontFamily', 'fontWeight'], function(i, name) {
+                    this._placeholderDom.style[name] = this.style(name);
+                }, this);
+                
+                uki.dom.bind(this._placeholderDom, 'mousedown', uki.proxy(function(e) { 
+                    this.focus(); 
+                    e.preventDefault(); 
+                }, this));
+            } else {
+                this._placeholderDom.innerHTML = v;
+            }
+        }
+    });
+    
+
+    this._style = function(name, value) {
+        if (value === undefined) return this._input.style[name];
+        this._input.style[name] = value;
+        if (this._placeholderDom) this._placeholderDom.style[name] = value;
+        return this;
+    };
+
+    uki.addProps(this, ['backgroundPrefix']);
+    
+    this.defaultBackground = function() {
+        return uki.theme.background(this._backgroundPrefix + 'input');
+    };
+    
+    this._createDom = function() {
+        var tagName = this._multiline ? 'textarea' : 'input';
+        this._dom = uki.createElement('div', Base.defaultCss + ';cursor:text;overflow:visible');
+        this._input = uki.createElement(tagName, this.defaultCss + (this._multiline ? '' : ';overflow:hidden;'));
+        this._inputStyle = this._input.style;
+        
+        this._input.value = this._value;
+        this._dom.appendChild(this._input);
+        
+        this._input.value = this.value();
+        
+        this._initFocusable(this._input);
+        this.bind('mousedown', function(e) {
+            this.focus(); 
+            e.preventDefault();
+        })
+    };
+    
+    this._layoutDom = function(rect) {
+        Base._layoutDom.apply(this, arguments);
+        uki.dom.layout(this._input.style, {
+            width: this._rect.width - 4
+        });
+        var margin;
+        if (this._multiline) {
+            this._input.style.height = this._rect.height - 4 + PX;
+            this._input.style.top = 2 + PX;
+            margin = '2px 0';
+        } else {
+            var o = (this._rect.height - getEmptyInputHeight(this.style('fontSize'))) / 2;
+            margin = CEIL(o) + 'px 0 ' + FLOOR(o) + 'px 0';
+            this._input.style.margin = margin;
+        }
+        if (this._placeholderDom) this._placeholderDom.style.margin = margin;
+    };
+    
+    this._updatePlaceholderVis = function() {
+        if (this._placeholderDom) this._placeholderDom.style.display = this.value() ? 'none' : 'block';
+    };
+
+    this._focus = function(e) {
+        this._focusBackground = this._focusBackground || uki.theme.background(this._backgroundPrefix + 'input-focus');
+        this._focusBackground.attachTo(this);
+        if (this._placeholderDom) this._placeholderDom.style.display = 'none';
+        Focusable._focus.call(this, e);
+    };
+    
+    this._blur = function(e) {
+        this._focusBackground.detach();
+        this._updatePlaceholderVis();
+        Focusable._blur.call(this, e);
+    };
+
+    this._bindToDom = function(name) {
+        return Focusable._bindToDom.call(this, name) || Base._bindToDom.call(this, name);
+    };
+});
+
+uki.view.declare('uki.view.MultilineTextField', uki.view.TextField, function(Base) {
+    this._setup = function() {
+        Base._setup.call(this);
+        this._multiline = true;
+    };
+});

data/frameworks/uki/src/uki-view/view/toolbar.js

@@ -0,0 +1,93 @@
+include('button.js');
+include('flow.js');
+
+uki.view.toolbar = {};
+
+uki.view.declare('uki.view.Toolbar', uki.view.Container, function(Base) {
+
+    this.typeName = function() { return 'uki.view.Toolbar'; };
+    
+    this._moreWidth = 30;
+    
+    this._setup = function() {
+        Base._setup.call(this);
+        this._buttons = [];
+        this._widths = [];
+    };
+    
+    this.buttons = uki.newProp('_buttons', function(b) {
+        this._buttons = b;
+        var buttons = uki.build(uki.map(this._buttons, this._createButton, this)).resizeToContents('width');
+        this._flow.childViews(buttons);
+        this._totalWidth = uki.reduce(0, this._flow.childViews(), function(s, v) { return s + v.rect().width; });
+    });
+    
+    uki.moreWidth = uki.newProp('_moreWidth', function(v) {
+        this._moreWidth = v;
+        this._updateMoreVisible();
+    });
+    
+    this._createDom = function() {
+        Base._createDom.call(this);
+        
+        var rect = this.rect(),
+            flowRect = rect.clone().normalize(),
+            moreRect = new Rect(rect.width - this._moreWidth, 0, this._moreWidth, rect.height),
+            flowML = { view: 'HFlow', rect: flowRect, anchors: 'left top right', className: 'toolbar-flow', hidePartlyVisible: true },
+            moreML = { view: 'Button', rect: moreRect, anchors: 'right top', className: 'toolbar-button',  visible: false, backgroundPrefix: 'toolbar-more-', text: '>>', focusable: false },
+            popupML = { view: 'Popup', rect: '0 0', anchors: 'right top', className: 'toolbar-popup', background: 'theme(toolbar-popup)', 
+                childViews: { view: 'VFlow', rect: '0 0', anchors: 'right top left bottom' }
+            };
+            
+        this._flow = uki.build(flowML)[0];
+        this._more = uki.build(moreML)[0];
+        this.appendChild(this._flow);
+        this.appendChild(this._more);
+        popupML.relativeTo = this._more;
+        this._popup = uki.build(popupML)[0];
+        
+        this._more.bind('click', uki.proxy(this._showMissingButtons, this));
+    };
+    
+    this._showMissingButtons = function() {
+        var maxWith = this._flow.rect().width,
+            currentWidth = 0,
+            missing = [];
+        for (var i=0, childViews = this._flow.childViews(), l = childViews.length; i < l; i++) {
+            currentWidth += childViews[i].rect().width;
+            if (currentWidth > maxWith) missing.push(i);
+        };
+        var newButtons = uki.map(missing, function(i) {
+            var descr = { html: childViews[i].html(), backgroundPrefix: 'toolbar-popup-' };
+            uki.each(['fontSize', 'fontWeight', 'color', 'textAlign', 'inset'], function(j, name) {
+                descr[name] = uki.attr(childViews[i], name);
+            });
+            return this._createButton(descr);
+        }, this);
+        uki('VFlow', this._popup).childViews(newButtons).resizeToContents('width height');
+        this._popup.resizeToContents('width height').toggle();
+    };
+    
+    this._updateMoreVisible = function() {
+        var rect = this._rect;
+        if (this._more.visible() != rect.width < this._totalWidth) {
+            this._more.visible(rect.width < this._totalWidth);
+            var flowRect = this._flow.rect();
+            flowRect.width += (rect.width < this._totalWidth ? -1 : 1)*this._moreWidth;
+            this._flow.rect(flowRect);
+        }
+    };
+    
+    this.rect = function(rect) {
+        var result = Base.rect.call(this, rect);
+        if (rect) this._updateMoreVisible();
+        return result;
+    };
+    
+    this._createButton = function(descr) {
+        return uki.extend({ 
+                view: 'Button', rect: new Rect(100, this.rect().height), focusable: false, align: 'left',
+                anchors: 'left top', backgroundPrefix: 'toolbar-button-', autosizeToContents: 'width', focusable: false
+            }, descr);
+    };    
+});

data/frameworks/uki/src/uki-view.js

@@ -0,0 +1,15 @@
+include('uki-view/view/box.js');
+include('uki-view/view/image.js');
+include('uki-view/view/button.js');
+include('uki-view/view/checkbox.js');
+include('uki-view/view/radio.js');
+include('uki-view/view/textField.js');
+include('uki-view/view/label.js');
+include('uki-view/view/list.js');
+include('uki-view/view/table.js');
+include('uki-view/view/slider.js');
+include('uki-view/view/splitPane.js');
+include('uki-view/view/scrollPane.js');
+include('uki-view/view/popup.js');
+include('uki-view/view/flow.js');
+include('uki-view/view/toolbar.js');

data/frameworks/uki/src/uki.js

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

data/frameworks/uki/thin.yaml

@@ -0,0 +1,11 @@
+---
+  environment: development
+  # address: 127.0.0.1
+  port: 21119 # 21 u 11 k 9 i
+  pid: thin.pid
+  rackup: uki.ru
+  log: thin.log
+  max_conns: 1024
+  timeout: 30
+  max_persistent_conns: 1024
+  daemonize: true

data/frameworks/uki/uki.rb

@@ -0,0 +1,38 @@
+require 'sinatra/base'
+
+class Uki < Sinatra::Base
+  def process_path(path, included = {})
+    code = File.read(path)
+    base = File.dirname(path)
+    code.gsub(%r{\n?\s*include\s*\(\s*['"]([^"']+)["']\s*\)\s*;?\s*\n?}) {
+      include_path = File.expand_path(File.join(base, $1))
+      unless included[include_path]
+        included[include_path] = true
+        process_path(include_path, included)
+      else
+        "\n"
+      end
+    }
+  end
+  
+  get %r{^/(src)/.*\.cjs$} do
+    path = request.path.sub(/\.cjs$/, '.js')
+    response.header['Content-type'] = 'application/x-javascript; charset=UTF-8'
+    process_path(File.join(File.dirname(__FILE__), path))
+  end
+  
+  get %r{^/(src|tmp|spec)/.*} do
+    path = request.path
+    response.header['Content-type'] = 'image/png' if path.match(/\.png$/)
+    response.header['Content-type'] = 'text/css' if path.match(/\.css$/)
+    response.header['Content-type'] = 'image/jpeg' if path.match(/\.jpg$/)
+    response.header['Content-type'] = 'text/javascript;charset=utf-8' if path.match(/\.js$/)
+    response.header['Content-Encoding'] = 'gzip' if path.match(/\.gz/)
+    if path.match(/.zip$/)
+      response.header['Content-Type'] = 'application/x-zip-compressed'
+      response.header['Content-Disposition'] = 'attachment; filename=tmp.zip'
+    end
+    
+    File.read File.join(File.dirname(__FILE__), path)
+  end
+end

data/frameworks/uki/uki.ru

@@ -0,0 +1,2 @@
+require 'uki'
+run Uki

data/lib/uki/include_js.rb

@@ -0,0 +1,50 @@
+module Uki
+  
+  INCLUDE_REGEXP = %r{((?:^|\n)[^\n]\W|^|\n)include\s*\(\s*['"]([^"']+)["']\s*\)(?:\s*;)?(.*?\r?\n|$)}
+  
+  #
+  # Preprocesses include() calls in js files
+  def self.include_js path, included = {}, stack = []
+    raise Exception.new("File #{path} not found.\nStack: #{stack.join(' -> ')}") unless File.exists?(path)
+    path = File.expand_path path
+    code, base = File.read(path), File.dirname(path)
+    
+    included[path] = true
+    code.gsub(INCLUDE_REGEXP) do |match|
+      if $1.include? '//' # include commented out 
+        match
+      else
+        include_path = File.expand_path File.join(base, $2)
+        unless included[include_path]
+          $1 + include_js(include_path, included, stack + [include_path]) + $3
+        else
+          $1 + $3
+        end
+      end
+    end
+  end
+  
+  def self.extract_includes path
+    result = []
+    File.read(path).scan(INCLUDE_REGEXP) do |match|
+      result << $2 unless $1.include? '//' 
+    end
+    result
+  end
+  
+  def self.append_include path, include_path
+    count = extract_includes(path).size
+    code = File.read(path)
+    line_break = code.match(/\r\n/) ? "\r\n" : "\n"
+    code = code.gsub(INCLUDE_REGEXP) do |match|
+      next if $1.include? '//' 
+      if (count -= 1) > 0
+        match
+      else
+        ($3.length ? '' : line_break) + match + "include('#{include_path}');" + line_break
+      end
+    end
+    File.open(path, 'w') { |f| f.write(code) }
+  end
+  
+end

data/lib/uki/project.rb

@@ -0,0 +1,207 @@
+require 'fileutils'
+require 'commander/import'
+require 'erb'
+require 'pathname'
+require 'uki/include_js'
+
+class Uki::Project
+  attr_accessor :dest
+  
+  def initialize dest
+    @dest = dest
+  end
+  
+  def name
+    File.basename File.expand_path(dest)
+  end
+  
+  def create options
+    verify_empty
+    init_dest
+    copy_frameworks
+    copy_templates
+    copy_images
+    init_jspec if options[:jspec]
+  end
+  
+  def build target, options = {}
+    target = File.join(dest, target) unless Pathname.new(target).absolute?
+    init_target target
+    containers = find_containers
+    cjs = extract_cjs(containers)
+    build_containers containers, target, options
+    build_js cjs, target, options
+    build_images target, options
+  end
+  
+  def create_class template, fullName
+    path = fullName.split('.')
+    create_packages path[0..-2]
+    write_class template, path
+  end
+
+  protected
+    def write_class template, path
+      package_name = path[0..-2].join('.')
+      class_name = path[-1]
+      class_name = class_name[0,1].upcase + class_name[1..-1]
+      file_name = class_name[0,1].downcase + class_name[1..-1]
+      target = File.join *(path[0..-2] + [file_name])
+      target += '.js'
+      File.open(File.join(dest, target), 'w') do |f|
+        f.write template(template).result(binding)
+      end
+      add_include(target)
+    end
+  
+    def add_include path
+      target = File.join(dest, "#{name}.js")
+      includes = Uki.extract_includes target
+      unless includes.include? path
+        Uki.append_include(target, path)
+      end
+    end
+    
+    def create_packages path
+      current = []
+      path.each do |dir|
+        current << dir
+        package_name = current.join('.')
+        target = File.join(dest, *current)
+        FileUtils.mkdir_p target unless File.exists?(target)
+        unless File.exists?("#{target}.js")
+          File.open("#{target}.js", 'w') do |f|
+            f.write template('package.js').result(binding)
+          end
+        end
+      end
+    end
+  
+    def build_js cjs, target, options
+      cjs.each do |c|
+        c = c.sub('.cjs', '.js')
+        code = Uki.include_js File.join(dest, c)
+        FileUtils.mkdir_p File.dirname(c)
+        filename = File.join(target, c)
+        File.open(filename, 'w') do |f|
+          f.write code
+        end
+        compile_js filename if options[:compile]
+      end
+    end
+    
+    def compile_js file
+      system "java -jar #{path_to_google_compiler} --js #{file} > #{file}.tmp" 
+      FileUtils.rm file
+      FileUtils.mv "#{file}.tmp", file
+    end
+  
+    def build_containers containers, target, options
+      containers.each do |c|
+        code = File.read(c).gsub(%r{=\s*["']?([^"' ]+.cjs)}) do |match|
+          match.sub('.cjs', '.js')
+        end
+        File.open(File.join(target, File.basename(c)), 'w') do |f|
+          f.write code
+        end
+      end
+    end
+    
+    def build_images target, options
+      FileUtils.cp_r File.join(dest, 'i'), File.join(target, 'i')
+    end
+  
+    def extract_cjs containers
+      containers.map do |c|
+        File.read(c).scan(%r{=\s*["']?([^"' ]+.cjs)})
+      end.flatten.uniq
+    end
+    
+    def find_containers
+      Dir.glob File.join(dest, '*.html')
+    end
+    
+    def init_target target
+      FileUtils.rm_rf target
+      FileUtils.mkdir_p target
+    end
+  
+    def init_dest
+      FileUtils.mkdir_p File.join(dest, project_name)
+      ['view', 'model'].each do |name| 
+        FileUtils.mkdir_p File.join(dest, project_name, name)
+      end
+    end
+    
+    def copy_templates
+      File.open(File.join(dest, 'index.html'), 'w') do |f|
+        f.write template('index.html').result(binding)
+      end
+      File.open(File.join(dest, "#{project_name}.js"), 'w') do |f|
+        f.write template('myapp.js').result(binding)
+      end
+      File.open(File.join(dest, project_name, 'view.js'), 'w') do |f|
+        package_name = "#{project_name}.view"
+        f.write template('package.js').result(binding)
+      end
+      File.open(File.join(dest, project_name, 'model.js'), 'w') do |f|
+        package_name = "#{project_name}.model"
+        f.write template('package.js').result(binding)
+      end
+    end
+    
+    def project_name
+      File.basename dest
+    end
+  
+    def copy_frameworks
+      FileUtils.mkdir_p File.join(dest, 'frameworks')
+      frameworks_dest = File.join(dest, 'frameworks', 'uki')
+      FileUtils.mkdir_p frameworks_dest
+      FileUtils.cp_r File.join(path_to_uki_src, '.'), frameworks_dest
+    end
+    
+    def init_jspec
+      FileUtils.mkdir_p File.join(dest, 'spec')
+      FileUtils.cp_r path_to_jspec_lib, File.join(dest, 'frameworks', 'jspec')
+      
+      File.open(File.join(dest, 'spec.html'), 'w') do |f|
+        f.write template('spec.html').result(binding)
+      end
+      File.open(File.join(dest, 'spec', 'spec.js'), 'w') do |f|
+        f.write template('spec.js').result(binding)
+      end
+    end
+    
+    def template name
+      path = File.join(UKI_ROOT, 'templates', "#{name}.erb")
+      ERB.new File.read(path)
+    end
+    
+    def path_to_jspec_lib
+      File.join(UKI_ROOT, 'frameworks', 'jspec', 'lib')
+    end
+    
+    def path_to_uki_src
+      File.join(UKI_ROOT, 'frameworks', 'uki', 'src')
+    end
+    
+    def images_path
+      File.join(path_to_uki_src, 'uki-theme', 'airport', 'i')
+    end
+  
+    def verify_empty
+      unless Dir[dest + '/*'].empty?
+        abort unless agree "`#{dest}' is not empty; continue? "
+      end
+    end
+    
+    def copy_images
+      FileUtils.cp_r images_path, File.join(dest, 'i')
+    end
+    
+    def path_to_google_compiler
+      File.join(UKI_ROOT, 'frameworks', 'uki', 'compiler.jar')
+    end
+  
+end

data/lib/uki/routes.rb

@@ -0,0 +1,20 @@
+get %r{\.cjs$} do
+  path = request.path.sub(/\.cjs$/, '.js').sub(%r{^/}, './')
+  pass unless File.exists? path
+  
+  response.header['Content-type'] = 'application/x-javascript; charset=UTF-8'
+  begin
+    Uki.include_js(path)
+  rescue Exception => e
+    message = e.message.sub(/\n/, '\\n')
+    "alert('#{message}')"
+  end
+end
+
+get %r{.*} do
+  path = request.path.sub(%r{^/}, './')
+  path = File.join(path, 'index.html') if File.exists?(path) && File.directory?(path)
+  p path
+  pass unless File.exists?(path)
+  send_file path
+end