lsd_rails 0.1

data/Packages/lsd/Source/Mixin/List.js

@@ -0,0 +1,99 @@
+/*
+---
+ 
+script: List.js
+ 
+description: Mixin that makes it simple to work with a list of item (and select one of them)
+ 
+license: Public domain (http://unlicense.org).
+ 
+requires:
+  - LSD.Mixin
+  - Core/Element
+  - Ext/Element.Properties.item
+ 
+provides: 
+  - LSD.Mixin.List
+ 
+...
+*/
+
+
+LSD.Mixin.List = new Class({  
+  options: {
+    endless: true,
+    force: false,
+    proxies: {
+      container: {
+        condition: function(widget) {
+          return !!widget.setList
+        }
+      }
+    },
+    shortcuts: {
+      previous: 'previous',
+      next: 'next'
+    },
+    has: {
+      many: {
+        items: {
+          selector: ':item',
+          traits: Array.fast('selectable'),
+          as: 'list',
+          pseudos: Array.fast('value'),
+          options: function() {
+            if (this.attributes.multiple) {
+              return {pseudos: Array.fast('checkbox')};
+            } else {
+              return {pseudos: Array.fast('radio'), radiogroup: this.lsd};
+            }
+          },
+          states: {
+            link: {
+              checked: 'selected',
+              selected: 'checked'
+            },
+            add: Array.fast('selected', 'checked')
+          },
+          callbacks: {
+            fill: 'fill',
+            empty: 'empty'
+          }
+        }
+      }
+    },
+    states: Array.fast('empty')
+  },
+  
+  findItemByValue: function(value) {
+    for (var i = 0, widget; widget = this.items[i++];) {
+      var val = widget.value == null ? (widget.getValue ? widget.getValue() : null) : widget.value;
+      if (val === value) return this.items[i - 1];
+    }
+    return null;
+  },
+  
+  sort: function(sort) {
+    return this.getItems().sort(sort)
+  },
+  
+  filter: function(filter) {
+    return this.getItems().filter(filter)
+  },
+  
+  next: function() {
+    var index = this.items.indexOf(this.selectedItems[0]);
+    var item = this.items[index + 1] || (this.options.endless && this.items[0]);
+    return item && item.check();
+  },
+  
+  previous: function() {
+    var index = this.items.indexOf(this.selectedItems[0]);
+    var item = this.items[index - 1] || (this.options.endless && this.items.getLast());
+    return item && item.check();
+  }
+  
+});
+
+
+LSD.Behavior.define(':list', LSD.Mixin.List);

data/Packages/lsd/Source/Mixin/Placeholder.js

@@ -0,0 +1,77 @@
+/*
+---
+ 
+script: Placeholder.js
+ 
+description: Placeholder for form fileds.
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Mixin
+
+ 
+provides:   
+  - LSD.Mixin.Placeholder
+ 
+...
+*/
+
+
+LSD.Mixin.Placeholder = new Class({
+  
+  options: {
+    actions: {
+      placeholder: {
+        enable: function(){
+          this.element.set('autocomplete', 'off');
+          this.onPlacehold();
+        },
+        disable: function(){
+          this.onUnplacehold();
+        }
+      }
+    },
+    events: {
+      enabled: {
+        element: {
+          'focus': 'onUnplacehold',
+          'blur': 'onPlacehold',
+          'keypress': 'onUnplacehold'
+        }
+      }
+    },
+    states: {
+      placeheld: {
+        enabler: 'placehold',
+        disabler: 'unplacehold'
+      }
+    }
+  },
+  
+  getPlaceholder: function(){
+    return this.attributes.placeholder;
+  },
+  
+  onUnplacehold: function(){
+    if (this.placeheld){
+      this.applyValue('');
+      this.unplacehold();
+      return true;
+    };
+  },
+  
+  onPlacehold: function(){
+    var value = this.getRawValue();
+    if (!value || value.match(/^\s*$/) || value == this.getPlaceholder()){
+      this.applyValue(this.getPlaceholder());
+      this.placehold();
+      return true;
+    };
+  }
+  
+});
+
+LSD.Behavior.define('[placeholder]', LSD.Mixin.Placeholder);

data/Packages/lsd/Source/Mixin/Request.js

@@ -0,0 +1,120 @@
+/*
+---
+ 
+script: Request.js
+ 
+description: Make various requests to back end
+ 
+license: Public domain (http://unlicense.org).
+ 
+requires:
+  - LSD.Mixin
+  - Core/Request
+  - Ext/Request.Form
+  - Ext/Request.Auto
+  - Ext/document.createFragment
+  
+provides: 
+  - LSD.Mixin.Request
+ 
+...
+*/
+
+LSD.Mixin.Request = new Class({
+  options: {
+    request: {
+      method: 'get'
+    },
+    states: Array.fast('working'),
+    events: {
+      self: {
+        submit: function() {
+          return this.send.apply(this, arguments);
+        },
+        
+        cancel: function() {
+          return this.stop()
+        },
+        
+        getCommandAction: function() {
+          if (!this.isRequestURLLocal()) return 'submit';
+        },
+
+        getTargetAction: function() {
+          if (this.getCommandAction() == 'submit') return 'update';
+        }
+      },
+      request: {
+        request: 'busy',
+        complete: 'idle'
+      }
+    }
+  },
+  
+  send: function() {
+    var data = this.getRequestData && this.getRequestData() || null;
+    var options = Object.merge({}, this.options.request, {data: data, url: this.getRequestURL(), method: this.getRequestMethod()});
+    for (var i = 0, j = arguments.length, arg, opts; i < j; i++) {
+      var arg = arguments[i];
+      if (!arg) continue;
+      if (typeof arg == 'object' && !arg.event && !arg.indexOf) {
+        if (("url" in arg) || ("method" in arg) || ("data" in arg)) Object.merge(options, arg)
+        else options.data = Object.merge(options.data || {}, arg);
+      } else if (arg.call) var callback = arg;
+    }
+    var request = this.getRequest(options);
+    request.addEvent('complete:once', function() {
+      if (callback) callback();
+      if (request.isSuccess() && this.getCommandAction && this.getCommandAction() == 'submit')
+        if (this.chainPhase == -1 || (this.chainPhase == this.getActionChain().length - 1))  
+          this.eachLink('optional', arguments, true);
+    }.bind(this));
+    return request.send(options);
+  },
+  
+  stop: function() {
+    if (this.request) this.request.cancel();
+    return this;
+  },
+  
+  getRequest: function(options, fresh) {
+    var type = (options && options.type) || this.getRequestType();
+    if (fresh || !this.request || this.request.type != type) {
+      this.request = this[type == 'xhr' ? 'getXHRRequest' : 'getFormRequest'](options);
+      if (!this.request.type) {
+        this.request.type = type;
+        this.fireEvent('register', ['request', this.request, type]);
+      }
+    }
+    return this.request;
+  },
+  
+  getXHRRequest: function(options) {
+    return new Request.Auto(options);
+  },
+  
+  getFormRequest: function(options) {
+    return new Request.Form(options);
+  },
+  
+  getRequestType: function() {
+    return this.attributes.transport || this.options.request.type;
+  },
+  
+  getRequestMethod: function() {
+    return this.attributes.method || this.options.request.method;
+  },
+  
+  getRequestURL: function() {
+    return this.attributes.href || this.attributes.src || this.attributes.action;
+  },
+  
+  isRequestURLLocal: function(base, host) {
+    if (!host) host = location.host;
+    if (!base) base = location.pathname;
+    var url = this.getRequestURL();
+    return !url || (url.charAt(0) == "#") || url.match(new RegExp('(?:' + host + ')?' + base + '/?#'));
+  }
+});
+
+LSD.Behavior.define(':form[action], [src], [href]', LSD.Mixin.Request);

data/Packages/lsd/Source/Mixin/Resizable.js

@@ -0,0 +1,182 @@
+/*
+---
+ 
+script: Resizable.js
+ 
+description: Resize widget with the mouse freely
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Mixin
+  - More/Drag
+
+provides: 
+  - LSD.Mixin.Resizable 
+...
+*/
+
+
+LSD.Mixin.Resizable = new Class({
+  options: {
+    resizer: {
+      modifiers: {
+        x: 'width',
+        y: 'height'
+      },
+      snap: false,
+      style: false,
+      crop: false,
+      handle: [],
+      container: true,
+      limit: {
+        x: [0, 3000],
+        y: [0, 3000]
+      },
+    },
+    actions: {
+      resizable: {
+        enable: function(handle, resizable) {
+          this.handle = handle;
+          this.resized = resizable || this;
+          this.onStateChange('resizable', true);
+          var resizer = this.resizer;
+          if (resizer == this.getResizer(document.id(this.resized))) resizer.attach();
+          if (handle) document.id(handle).addEvent('mousedown', this.resizer.bound.start);
+          if (this.options.resizer.fit) this.fit(resizable)
+        },
+
+        disable: function(handle, content) {
+          this.onStateChange('resizable', false);
+          if (this.resizer) this.resizer.detach();
+          if (handle) document.id(handle).removeEvent('mousedown', this.resizer.bound.start);
+          delete this.resized, delete this.handle;
+        },
+      }
+    }
+  },
+  
+  initialize: function() {
+    this.parent.apply(this, arguments);
+    var options = this.options.resizer;
+    var rules = (new FastArray).concat(this.getAttribute('resizable').split(/\s+/));
+    options.modifiers.x = (!rules.x && rules.y) ? false : 'width';
+    options.modifiers.y = (!rules.y && rules.x) ? false : 'height';
+    options.fit = !!rules.fit;
+  },
+  
+  uninitialize: function() {
+    if (this.handle) this.options.actions.resizable.disable.call(this, this.handle, this.resized);
+    delete this.resizer;
+  },
+   
+  getResizer: function(resized) {
+    var element = resized
+    if (this.resizer) {
+      if (this.resizer.element == element) return this.resizer;
+      return this.resizer.element = element;
+    }
+    var resizer = this.resizer = new Drag(element, Object.append(this.options, this.options.resizer));
+    this.fireEvent('register', ['resizer', resizer]);
+    resizer.addEvents({
+      'beforeStart': this.onBeforeResize.bind(this),
+      'start': this.onResizeStart.bind(this),
+      'complete': this.onResizeComplete.bind(this),
+      'cancel': this.onResizeComplete.bind(this),
+      'drag': this.onResize.bind(this)
+    }, true);
+    return resizer;
+  },
+  
+  check: function(size) {
+    if (!this.resizer) return;
+    var width = this.element.offsetWidth - this.offset.inner.left - this.offset.inner.right;
+    if (!size) size = {width: this.resized.toElement().width}
+    if (size.width < width) {
+      if (!$chk(this.limit)) this.limit = this.resized.getStyle('minWidth') || 1
+      this.resized.setStyle('minWidth', width);
+      $clear(this.delay);
+      this.delay = (function() { //reset limit options in one second
+        this.resized.setStyle('minWidth', this.limit);
+      }).delay(1000, this); 
+      size.width = width;
+    }
+    return size;
+  },
+  
+  onBeforeResize: function() {
+    Object.append(this.resized.toElement(), this.resized.size)
+  },
+  
+  onResizeStart: function() {
+    this.onStateChange('resized', true);
+    var getLiquid = function(child, prop) {
+      var value = child.style.current[prop];
+      return ((value == 'inherit') || (value == 'auto') || child.style.expressed[prop]) ? value : null
+    }
+    if (!this.liquid) {
+      this.liquid = LSD.Module.DOM.walk(this, function(child) { 
+        return getLiquid(c, 'width')
+      }) || []
+      this.liquid.include(this.resized);
+      if (this.resized != this) {
+        var style = this.resized.style.liquid = {};
+        var width = getLiquid(this.resized, 'width');
+        if (width) style.width = width;
+        var height = getLiquid(this.resized, 'height');
+        if (height) style.height = height;
+      }
+    }
+  },
+  
+  onResizeComplete: function() {
+    if (this.resized.style.liquid) this.resized.setStyles(this.resized.style.liquid);
+    this.onStateChange('resized', false);
+    delete this.liquid
+  },
+  
+  onResize: function() {
+    var now = this.resizer.value.now;
+    var resized = this.resized;
+    if (!resized.style.dimensions) {
+      resized.style.dimensions = {};
+      var width = resized.style.current.width
+      if (width == 'auto') resized.style.dimensions.width = 'auto';
+      var height = resized.toElement().getStyle('height');
+      if (height == 'auto') resized.style.dimensions.height = 'auto';
+    }
+    if (!now.x) now.x = resized.size.width;
+    if (!now.y) now.y = resized.size.height;
+    var size = this.check({width: resized.setWidth(now.x) || now.x, height: resized.setHeight(now.y) || now.y});
+    resized.setStyles(size);
+    if (this.liquid) {
+      this.liquid.each(function(child) {
+        child.update();
+      })
+    }
+    this.refresh();
+  },
+  
+  fit: function(content) {
+    if (!content) content = this.resized;
+    var element = content.getWrapper();
+    var display = element.getStyle('display');
+    if (display != 'inline-block') element.setStyle('display', 'inline-block');
+    var width = element.offsetWidth;
+    var height = element.offsetHeight;
+    element.setStyle('display', display)
+    content.setHeight(height);
+    content.setWidth(width);
+    this.refresh({
+      maxWidth: width, maxHeight: height
+    });
+  },
+  
+  getScrolled: function() {
+    return this.resized.getWrapper();
+  }
+});
+
+LSD.Behavior.define('[resizable][resizable!=false]', LSD.Mixin.Resizable);

data/Packages/lsd/Source/Mixin/Resource.js

@@ -0,0 +1,81 @@
+/*
+---
+ 
+script: Resource.js
+ 
+description: Make various requests to back end
+ 
+license: Public domain (http://unlicense.org).
+ 
+requires:
+  - LSD.Mixin
+  - Resource/*
+  - More/URI
+  
+provides: 
+  - LSD.Mixin.Resource
+ 
+...
+*/
+
+LSD.Mixin.Resource = new Class({
+  options: {
+    resource: {
+      prefix: null,
+      name: null
+    },
+    request: {
+      type: 'xhr'
+    }
+  },
+  
+  getResource: function(options) {
+    if (!options) options = this.options.resource
+    if (!this.resource) {
+      var name = options.name;
+      var prefix = options.prefix;
+      if (!name || !prefix) {
+        var uri = this.attributes.itemtype.split(/\s+/).getLast();
+        if (uri) {
+          if (uri.toURI) uri = uri.toURI();
+          prefix = uri.get('directory');
+          name = uri.get('file');
+          /*
+            Parses the last URL bit that can be singularized 
+          */
+          while (!name || !(name = name.singularize())) {
+            var dirs = prefix.split('/');
+            name = dirs.pop();
+            prefix = dirs.join('/')
+          }
+        }
+      }
+      var options = Object.clone(this.options.resource);
+      if (prefix) options.prefix = prefix;
+      options.getRequest = this.bindEvent('getRequest');
+      this.resource = new Resource(name, options);
+      if (!this.getRequest) this.setAttribute('href', this.resource.getFormattedURL('plural'));
+    }
+    return this.resource;
+  },
+  
+  getResourceID: function() {
+    return this.attributes.itemid;
+  },
+  
+  getModel: function() {
+    return this.getResource().init(this.getResourceID() || this.element);
+  },
+  
+  submit: function() {
+    var model = this.getModel();
+    return model.save.apply(model, arguments);
+  },
+  
+  'delete': function() {
+    this.dispose()
+    return this.getModel().destroy();
+  }
+});
+
+LSD.Behavior.define(':resource, [itemscope]', LSD.Mixin.Resource);

data/Packages/lsd/Source/Mixin/Root.js

@@ -0,0 +1,41 @@
+/*
+---
+ 
+script: Root.js
+ 
+description: The topmost widget easily accessible.
+ 
+license: Public domain (http://unlicense.org).
+ 
+requires:
+  - LSD.Mixin
+  - LSD.Behavior
+ 
+provides: 
+  - LSD.Mixin.Root
+ 
+...
+*/
+
+LSD.Mixin.Root = new Class({
+  options: {
+    events: {
+      _root: {
+        nodeInserted: function(node) {
+          node.root = this;
+          node.fireEvent('setRoot', this);
+          node.fireEvent('register', ['root', this]);
+        },
+        nodeRemoved: function(node) {
+          if (node.root == this) {
+            node.fireEvent('unsetRoot', this);
+            node.fireEvent('unregister', ['root', this]);
+            delete node.root;
+          }
+        }
+      }
+    }
+  }
+});
+
+LSD.Behavior.define(':root', LSD.Mixin.Root);

data/Packages/lsd/Source/Mixin/Scrollable.js

@@ -0,0 +1,69 @@
+/*
+---
+ 
+script: Scrollable.js
+ 
+description: For all the scrollbars you always wanted
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Mixin
+  - LSD.Behavior
+  - Widgets/LSD.Widget.Scrollbar
+
+provides: 
+  - LSD.Mixin.Scrollable
+ 
+...
+*/
+
+LSD.Mixin.Scrollable = new Class({
+  options: {
+    events: {
+      self: {
+        resize: 'showScrollbars'
+      },
+      element: {
+        mousewheel: 'onMousewheel'
+      }
+    }
+  },
+  
+  onMousewheel: function(event) {
+    var scrollbar = this.vertical || this.horizontal;
+    if (scrollbar) scrollbar.track.element.fireEvent('mousewheel', event  );
+  },
+  
+  showScrollbars: function(size) {
+    if (!size) size = this.size;
+    var scrolled = document.id(this.getScrolled());
+    scrolled.setStyles(size)
+    scrolled.setStyle('overflow', 'hidden');
+    if (size.width < scrolled.scrollWidth) {
+      if (this.getHorizontalScrollbar().parentNode != this) this.horizontal.inject(this);
+      this.horizontal.slider.set(this.horizontal.now)
+    } else if (this.horizontal) this.horizontal.dispose();
+    
+    if (size.height < scrolled.scrollHeight) {
+      if (this.getVerticalScrollbar().parentNode != this) this.vertical.inject(this);
+        this.vertical.slider.set(this.vertical.now)
+    } else if (this.vertical) this.vertical.dispose();
+  },
+  
+  getVerticalScrollbar: function() {
+    return (this.vertical || (this.vertical = this.buildLayout('scrollbar[mode=vertical]')))
+  },
+  
+  getHorizontalScrollbar: function() {
+    return (this.horizontal || (this.horizontal = this.buildLayout('scrollbar[mode=horizontal]')))
+  },
+  
+  getScrolled: Macro.defaults(function() {
+    return this.getWrapper();
+  })
+});
+
+LSD.Behavior.define('[scrollable]', LSD.Mixin.Scrollable);