lsd_rails 0.1

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

@@ -0,0 +1,124 @@
+/*
+---
+ 
+script: ContentEditable.js
+ 
+description: Animated ways to show/hide widget
+ 
+license: Public domain (http://unlicense.org).
+ 
+requires:
+  - LSD.Mixin
+  
+uses:
+  - CKEDITOR
+ 
+provides: 
+  - LSD.Mixin.ContentEditable
+...
+*/
+
+LSD.Mixin.ContentEditable = new Class({
+  options: {
+    ckeditor: {
+      toolbarCanCollapse: false,
+      linkShowAdvancedTab: false,
+      linkShowTargetTab: false,
+      invisibility: true,
+      skin: 'ias',
+      toolbar: [['Bold', 'Italic', 'Strike', '-', 'Link', 'Unlink', '-', 'NumberedList', 'BulletedList', '-', 'Indent', 'Outdent', '-','Styles', '-', 'PasteFromWord', 'RemoveFormat']],
+      removeFormatTags: 'dialog,img,input,textarea,b,big,code,del,dfn,em,font,i,ins,kbd,q,samp,small,span,strike,strong,sub,sup,tt,u,var,iframe',
+      removeFormatAttributes: 'id,class,style,lang,width,height,align,hspace,valign',
+      contentsCss: '/stylesheets/layout/application/iframe.css',
+      extraPlugins: 'autogrow',
+      customConfig: false,
+      language: 'en',
+      removePlugins: 'bidi,dialogadvtab,liststyle,about,elementspath,blockquote,popup,undo,colorbutton,colordialog,div,entities,filebrowser,find,flash,font,format,forms,horizontalrule,image,justify,keystrokes,maximize,newpage,pagebreak,preview,print,resize,save,scayt,smiley,showblocks,showborders,sourcearea,style,table,tabletools,specialchar,templates,wsc,a11yhelp,a11yhelp',
+      stylesSet: [
+        { name : 'Paragraph', element : 'p' },
+      	{ name : 'Heading 1', element : 'h1' },
+      	{ name : 'Heading 2', element : 'h2' }
+      ]
+    }
+  },
+  
+  getEditor: function() {
+    if (this.editor) return this.editor;
+    use('CKEDITOR', function(CKEDITOR) {
+      var value = this.getValueForEditor();
+      var editor = this.editor = new CKEDITOR.editor( this.options.ckeditor, this.getEditedElement(), 1, value);
+      CKEDITOR.add(editor);
+      editor.on('focus', function() {
+        if (this.editor) this.getEditorContainer().addClass('focused');
+        this.onFocus.apply(this, arguments);
+      }.bind(this));
+      editor.on('blur', function() {
+        if (this.editor) this.getEditorContainer().removeClass('focused');
+        this.onBlur.apply(this, arguments);
+      }.bind(this));
+      editor.on('uiReady', function() {
+        this.showEditor();
+        this.fireEvent('editorReady');
+        !function() {/*
+          if (Browser.firefox) {
+            var body = this.getEditorBody()
+            body.contentEditable = false;
+            body.contentEditable = true;
+        }*/
+        this.editor.focus();
+        this.editor.forceNextSelectionCheck();
+        this.editor.focus();
+        }.delay(100, this)
+      }.bind(this));
+    }.bind(this))
+  },
+  
+  getValueForEditor: function() {
+    var element = this.getEditedElement();
+    switch (element.get('tag')) {
+      case "input": case "textarea":
+        return element.get('value');
+      default:
+        return element.innerHTML;
+    }
+  },
+  
+  showEditor: function() {
+    this.element.setStyle('display', 'none');
+    this.getEditorContainer().setStyle('display', 'block');
+  },
+  
+  hideEditor: function() {
+    this.element.setStyle('display', '');
+    this.getEditorContainer().setStyle('display', 'none');
+  },
+  
+  openEditor: function(callback) {
+    if (this.editor && this.editor.document) {
+      if (callback) callback.call(this.editor);
+      this.showEditor();
+    } else {
+      if (callback) this.addEvent('editorReady:once', callback);
+      this.getEditor();
+    }
+  },
+  
+  closeEditor: function(callback) {
+    this.editor.updateElement();
+    this.hideEditor();
+  },
+  
+  getEditorContainer: function() {
+    return $(this.editor.container.$);
+  },
+  
+  getEditorBody: function() {
+    return this.editor.document.$.body;
+  },
+  
+  getEditedElement: function() {
+    return this.toElement();
+  }
+});
+
+LSD.Behavior.define('[contenteditable=editor]', LSD.Mixin.ContentEditable);

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

@@ -0,0 +1,113 @@
+/*
+---
+ 
+script: Draggable.js
+ 
+description: Drag widget around the screen
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Mixin
+  - More/Drag
+
+provides: 
+  - LSD.Mixin.Draggable
+ 
+...
+*/
+
+LSD.Mixin.Draggable = new Class({
+  options: {
+    dragger: {
+      modifiers: {
+        x: 'left',
+        y: 'top'
+      },
+      snap: 5,
+      style: false,
+      container: true,
+      limit: {
+        x: [0, 3000],
+        y: [0, 3000]
+      },
+      handle: []
+    },
+    actions: {
+      draggable: {
+        enable: function(handle) {
+          if (this.index++ == 0) {
+            if (this.dragger) this.dragger.attach();
+            else this.getDragger();
+            this.onStateChange('draggable', true);
+          }
+          if (!handle) return;
+          this.handles.push(handle);
+          document.id(handle).addEvent('mousedown', this.dragger.bound.start);
+        },
+        
+        disable: function(handle) {
+          if (!this.dragger) return;
+          if (--this.index == 0) {
+            this.onStateChange('draggable', false);
+            this.dragger.detach();
+          }
+          if (!handle) return;
+          this.handles.erase(handle)
+          document.id(handle).removeEvent('mousedown', this.dragger.bound.start);
+        }
+      }
+    }
+  },
+  
+  initialize: function() {
+    this.parent.apply(this, arguments);
+    this.handles = [];
+    this.index = 0;
+  },
+  
+  unitialize: function() {
+    this.handles.each(this.options.actions.draggable.disable, this);
+    this.onStateChange('draggable', false);
+    delete this.dragger;
+  },
+  
+  getDragger: function() {
+    if (this.dragger) return this.dragger;
+    var element = this.element;
+    this.addEvent('setDocument', function() {
+      var position = element.getPosition();
+      element.left = position.x - element.getStyle('margin-left').toInt();
+      element.top = position.y - element.getStyle('margin-top').toInt();
+    }.create({delay: 50}));
+    this.dragger = new Drag(element, Object.append(this.options.dragger, this.options.dragger));
+    this.dragger.addEvents(this.events.dragger);
+    this.dragger.addEvents({
+      'start': this.onDragStart.bind(this),
+      'complete': this.onDragComplete.bind(this),
+      'cancel': this.onDragComplete.bind(this),
+      'drag': this.onDrag.bind(this)
+    }, true);
+    return this.dragger;
+  },
+  
+  onDragStart: function() {
+    this.onStateChange('dragged', true);
+  },
+  
+  onDragComplete: function() {
+    this.onStateChange('dragged', false);
+  },
+  
+  onDrag: function() {
+    this.setStyles({
+      top: this.dragger.value.now.y,
+      left: this.dragger.value.now.x
+    });
+  }
+  
+});
+
+LSD.Behavior.define('[draggable]', LSD.Mixin.Draggable);

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

@@ -0,0 +1,235 @@
+/*
+---
+ 
+script: Fieldset.js
+ 
+description: Wrapper around set of form fields
+ 
+license: Public domain (http://unlicense.org).
+ 
+requires:
+  - LSD.Mixin
+ 
+provides: 
+  - LSD.Mixin.Fieldset
+ 
+...
+*/
+!function() {
+  
+LSD.Mixin.Fieldset = new Class({
+  options: {
+    has: {
+      many: {
+        elements: {
+          selector: ':form-associated',
+          scopes: {
+            submittable: {
+              filter: '[name]:valued'
+            }
+          },
+          callbacks: {
+            'add': 'addField',
+            'remove': 'removeField'
+          }
+        }
+      }
+    },
+    expects: {
+      ':form': function(widget, state) {
+        widget[state ? 'addRelation' : 'removeRelation']('elements', {as: 'form'})
+      }
+    }
+  },
+  
+  constructors: {
+    fieldset: function() {
+      this.names = {};
+      this.params = {};
+      return {
+        events: {
+          request: {
+            request: 'validateFields',
+            badRequest: 'parseFieldErrors'
+          },
+          self: {
+            beforeNodeBuild: function(query, widget) {
+              if (!widget.options.clone) return;
+              var attrs = query.attributes, attributes = widget.attributes;
+              var name = attributes.name, id = attributes.id;
+              // bump name index
+              if (name) (attrs || (attrs = {})).name = Fieldset.bumpName(name) || name;
+              // bump id index
+              if (id) (attrs || (attrs = {})).id = Fieldset.bumpId(id) || id;
+              if (widget.tagName == 'label') {
+                var four = attributes['for'];
+                if (four) (attrs || (attrs = {}))['for'] = Fieldset.bumpId(four) || four;
+              }
+              if (attrs) query.attributes = attrs;
+            }
+          }
+        }
+      }
+    }
+  },
+  
+  checkValidity: function() {
+    var valid = true;
+    for (var i = 0, element; element = this.elements[i++];) if (!element.checkValidity()) valid = false;
+    return valid;
+  },
+  
+  getData: function() {
+    var data = {}
+    for (var name in this.names) {
+      var memo = this.names[name];
+      if (memo.push) {
+        for (var i = 0, radio; radio = memo[i++];) if (radio.checked) data[name] = radio.toData(); break;
+      } else {
+        var value = memo.toData();
+        if (value != null) data[name] = value;
+      }
+    }
+    return data;
+  },
+
+  getRequestData: function() {
+    return this.getData();
+  },
+  
+  reset: function() {
+    
+  },
+  
+  addFieldErrors: function(errors) {
+    for (var name in errors) {
+      var field = this.names[name];
+      if (!field) continue;
+      field.invalidate(errors[name]);
+      this.invalid = true;
+    }
+  },
+
+  parseFieldErrors: function(response) {
+    var result = {}, errors = response.errors;
+    if (errors) { //rootless response ({errors: {}), old rails
+      for (var i = 0, error; error = errors[i++];)
+        result[Fieldset.getName(this.getModelName(error[0]), error[0])] = error[1];
+    } else { //rooted response (publication: {errors: {}}), new rails
+      var regex = Fieldset.rPrefixAppender;
+      for (var model in response) {
+        var value = response[model], errors = value.errors;
+        if (!errors) continue;
+        for (var i = 0, error; error = errors[i++];)
+          result[Fieldset.getName(model, error[0])] = error[1];
+      }
+    }
+    if (Object.getLength(result) > 0) this.addFieldErrors(result);
+  },
+  
+  addField: function(widget) {
+    var name = widget.attributes.name, radio = (widget.commandType == 'radio');
+    if (!name || !widget.toData) return;
+    if (radio) {
+      if (!this.names[name]) this.names[name] = [];
+      this.names[name].push(widget);
+    } else this.names[name] = widget;
+    for (var regex = Fieldset.rNameParser, object = this.params, match, bit;;) {
+      match = regex.exec(name)
+      if (bit != null) {
+        if (!match) {
+          if (!object[bit] && radio) object[bit] = [];
+          if (object[bit] && object[bit].push) object[bit].push(widget);
+          else object[bit] = widget;
+        } else object = object[bit] || (object[bit] = (bit ? {} : []));
+      }
+      if (!match) break;
+      else bit = match[1] ||match[2];
+    }
+    return object
+  },
+  
+  getParams: function(object) {
+    if (!object) object = this.params;
+    var result = {};
+    for (var name in object) {
+      var value = object[name];
+      if (value && !value.indexOf) value = value.nodeType ? value.getValue() : this.getParams(value);
+      result[name] = value;
+    }
+    return result;
+  },
+  
+  removeField: function(widget) {
+    var name = widget.attributes.name, radio = (widget.commandType == 'radio');
+    if (!name) return;
+    if (radio) this.names[name].erase(widget);
+    else delete this.names[name];
+    for (var regex = Fieldset.rNameParser, object = this.params, match, bit;;) {
+      match = regex.exec(name)
+      if (bit != null) {
+        if (!match) {
+          if (radio) object[bit].erase(widget)
+          else delete object[bit];
+        } else object = object[bit];
+      }
+      if (!match) break;
+      else bit = match[1] ||match[2];
+    }
+    return object
+  },
+
+  invalidateFields: function(errors) {
+    this.getFields(errors, function(field, error) {
+      field.invalidate(error);
+    });
+  },
+  
+  getFieldsByName: function(fields, callback, root) {
+    if (fields.call && (callback = fields)) fields = null;
+    if (!fields) fields = this.elements;
+    if (!callback && fields.indexOf) return root[fields]
+    if (fields.map && fields.each && (!callback || !root)) return fields.map(function(field) {
+      return this.getFieldsByName(field, callback, root)
+    }.bind(this));
+  },
+  
+  validateFields: function(fields) {
+    if (!this.invalid) return;
+    this.elements.each(function(field) {
+      if (field.invalid) field.validate(true);
+    });
+  },
+
+  getModelName: function() {
+    for (var name in this.params) if (!this.params[name].nodeType) return name;
+  }
+});
+
+var Fieldset = Object.append(LSD.Mixin.Fieldset, {
+  rNameIndexBumper: /(\[)(\d+?)(\])/,
+  rIdIndexBumper:   /(_)(\d+?)(_|$)/,
+  rNameParser:      /(^[^\[]+)|\[([^\]]*)\]/g,
+  rNameMultiplier:  /(?:\[\])?$/,
+  rPrefixAppender:  /^[^\[]+/,
+  getName: function(model, name) {
+    return model + name.replace(Fieldset.rPrefixAppender, function(match) {return '[' + match + ']'});
+  },
+  bumpName: function(string) {
+    return string.replace(Fieldset.rNameIndexBumper, function(m, a, index, b) { 
+      return a + (parseInt(index) + 1) + b;
+    })
+  },
+  bumpId: function(string) {
+    return string.replace(Fieldset.rIdIndexBumper, function(m, a, index, b) { 
+      return a + (parseInt(index) + 1) + b;
+    })
+  },
+  multiplyName: function(string) {
+    return string.replace(Fieldset.rNameMultiplier, '[]')
+  }
+});
+
+LSD.Behavior.define(':fieldset', Fieldset);
+
+}();

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

@@ -0,0 +1,122 @@
+/*
+---
+ 
+script: Focus.js
+ 
+description: A mixin to make widget take focus like a regular input (even in Safari)
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Mixin
+  - QFocuser/QFocuser
+ 
+provides:
+  - LSD.Mixin.Focusable
+  - LSD.Mixin.Focusable.Propagation
+ 
+...
+*/
+  
+LSD.Mixin.Focusable = new Class({
+  options: {
+    actions: {
+      focusable: {
+        target: false,
+        enable: function(target) {
+          if (target.tabindex != null) {
+            target.attributes.tabindex = target.tabindex
+            if (target.focuser) target.element.set('tabindex', target.tabindex)
+            delete target.tabindex;
+          }
+          if (target.attributes.tabindex == -1) return;
+          target.getFocuser();
+          target.addEvents(target.events.focus);
+          target.element.addEvents(target.bindEvents({mousedown: 'retain'}));
+        },
+        
+        disable: function(target) {
+          target.blur();
+          if (target.options.tabindex == -1) return;
+          target.tabindex = target.options.tabindex || 0;
+          target.element.set('tabindex', -1)
+          target.attributes.tabindex = -1;
+          target.removeEvents(target.events.focus);
+          target.element.removeEvents(target.bindEvents({mousedown: 'retain'}));
+        }
+      }
+    }
+  },
+  
+  getFocuser: function() {
+    if (!this.focuser) this.focuser = new QFocuser(this.toElement(), {
+      onWidgetFocus: this.onFocus.bind(this),
+      onWidgetBlur: this.onBlur.bind(this),
+      tabIndex: this.getAttribute('tabindex')
+    });
+    return this.focuser;
+  },
+  
+  focus: function(element) {
+    if (element !== false) {
+      this.getFocuser().focus(element || this.element);
+      this.document.activeElement = this;
+    }
+    if (this.focused) return;
+    this.focused = true;
+    this.fireEvent('focus', arguments);
+    this.onStateChange('focused', true);
+    LSD.Mixin.Focusable.Propagation.focus(this);
+  },
+  
+  blur: function(propagated) {
+    if (!this.focused) return;
+    this.focused = false;
+    this.fireEvent('blur', arguments);
+    this.onStateChange('focused', false);
+    if (!propagated) LSD.Mixin.Focusable.Propagation.blur.delay(10, this, this);
+  },
+  
+  retain: function(e) {
+    if (e) e.preventDefault();
+    this.focus();
+  },
+  
+  onFocus: function() {
+    this.focus(false);
+    this.document.activeElement = this;
+  },
+  
+  onBlur: function() {
+    var active = this.document.activeElement;
+    if (active == this) delete this.document.activeElement;
+    while (active && (active = active.parentNode)) if (active == this) return;
+    this.blur();
+  },
+  
+  getKeyListener: function() {
+    return this.getFocuser().getKeyListener()
+  }
+});
+
+LSD.Mixin.Focusable.Propagation = {
+  focus: function(parent) {
+    while (parent = parent.parentNode) if (parent.getFocuser) parent.focus(false);
+  },
+  
+  blur: function(parent) {
+    var active = parent.document.activeElement;
+    var hierarchy = [];
+    if (active) {
+      for (var widget = active; widget.parentNode && hierarchy.push(widget); widget = widget.parentNode);
+    }
+    while (parent = parent.parentNode) {
+      if (active && hierarchy.contains(parent)) break;
+      if (parent.options && (parent.attributes.tabindex != null) && parent.blur) parent.blur(true);
+    }
+  }
+};
+
+LSD.Behavior.define('[tabindex][tabindex!=-1], :focusable', LSD.Mixin.Focusable);

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

@@ -0,0 +1,83 @@
+/*
+---
+ 
+script: Invokable.js
+ 
+description: Makes widget submit into another widget 
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Mixin
+ 
+provides:
+  - LSD.Mixin.Invokable
+ 
+...
+*/
+
+
+LSD.Mixin.Invokable = new Class({
+  options: {
+    chain: {
+      feedback: function() {
+        return {
+          action: 'submit',
+          target: this.getSubmissionTarget,
+          arguments: this.getSubmissionData,
+          priority: -5
+        }
+      }
+    },
+    states: {
+      invoked: {
+        enabler: 'invoke',
+        disabler: 'revoke'
+      }
+    },
+    events: {
+      _invokable: {
+        submit: function() {
+          this.revoke(true);
+        },
+        cancel: 'revoke'
+      }
+    }
+  },
+  
+  constructors: {
+    invoker: function() {
+      var invoker = this.invoker || this.options.invoker;
+      if (invoker) this.invoke(invoker);
+    }
+  },
+  
+  invoke: function(invoker) {
+    this.invoker = invoker;
+    this.fireEvent('invoke', invoker);
+    this.fireEvent('register', ['invoker', invoker]);
+  },
+  
+  revoke: function(soft) {
+    var invoker = this.invoker;
+    if (soft !== true) this.invoker.uncallChain();
+    this.fireEvent('revoke', invoker);
+    this.fireEvent('unregister', ['invoker', invoker]);
+  },
+  
+  getInvoker: function() {
+    return this.invoker;
+  },
+  
+  getSubmissionTarget: function() {
+    return this.getInvoker();
+  },
+  
+  getSubmissionData: function() {
+    return this.getData ? this.getData() : null;
+  }
+});
+
+LSD.Behavior.define(':invokable', LSD.Mixin.Invokable);