lsd_rails 0.1

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

@@ -0,0 +1,134 @@
+/*
+---
+ 
+script: Sortable.js
+ 
+description: Reorder widgets as you please
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - More/Sortables
+  - LSD.Mixin
+ 
+provides:
+  - LSD.Mixin.Sortable
+ 
+...
+*/
+
+LSD.Mixin.Sortable = new Class({
+  options: {
+    sortables: {
+      clone: true,
+      snap: 5,
+      constrain: true,
+      revert: true
+    },
+    pseudos: Array.fast('activatable'),
+    events: {
+      self: {
+        mousedown: 'onBeforeSortStart'
+      }
+    }
+  },
+  
+  getSortables: function() {
+    if (this.sortables) return this.sortables;
+    var options = Object.append({}, this.options.sortables);
+    if (options.clone === true) options.clone = function(event, element){
+      var widget = element.uid && element.retrieve('widget');
+      var clone = element.cloneNode(true);
+      document.id(clone).addEvent('mousedown', function(event){
+        element.fireEvent('mousedown', event);
+      }).addClass('clone').store('origin', widget).setStyles({
+        margin: 0,
+        position: 'absolute',
+        visibility: 'hidden',
+        width: element.getStyle('width')
+      }).setPosition(element.getPosition(element.getOffsetParent()));
+      return clone.inject(this.list);
+    };
+    delete options.snap;
+    this.sortables = new Sortables([], options);
+    this.fireEvent('register', ['sortables', this.sortables]);
+    this.sortables.addEvents(this.bindEvents({
+      start: 'onSortStart',
+      complete: 'onSortComplete',
+      sort: 'onSort'
+    }))
+    var self = this;
+    this.sortables.insert = function(dragging, element) {
+      if (self.onBeforeSort.apply(self, arguments)) {
+        (dragging.retrieve('origin') || dragging).fireEvent('beforeMove', element);
+        var where = 'inside';
+        if (this.lists.contains(element)){
+          this.list = element;
+          this.drag.droppables = this.getDroppables();
+        } else {
+          where = this.element.getAllPrevious().contains(element) ? 'before' : 'after';
+        };
+        (this.element.uid && this.element.retrieve('widget') || this.element).inject(element, where);
+        this.fireEvent('sort', [this.element, this.clone]);
+      }
+    };
+    return this.sortables;
+  },
+  
+  onBeforeSort: function(dragging, element) {
+    return true;
+  },
+  
+  onBeforeSortStart: function(event) {
+    for (var target = event.target, widget; target && target.tagName; target = target.parentNode) {
+      if (target == this.element) break;
+      widget = target.uid && Element.retrieve(target, 'widget');
+      if (widget && widget.pseudos.reorderable) {
+        if (widget.getHandle) {
+          var handle = widget.getHandle();
+          if (!(handle == event.target || handle.contains(event.target))) return;
+        }
+        var snap = widget.options.snap || this.options.sortables.snap || 0;
+        var start = event.page, self = this;
+        if (snap > 0) {
+          var events = {
+            mousemove: function(event) {
+              var distance = Math.round(Math.sqrt(Math.pow(event.page.x - start.x, 2) + Math.pow(event.page.y - start.y, 2)));
+              if (distance > snap) self.getSortables().start(event, widget.element);
+            },
+            mouseup: function() {
+              document.body.removeEvents(events);
+            }
+          };
+          document.body.addEvents(events);
+        } else {
+          this.getSortables().start(event, widget.element)
+        }
+        break;
+      }
+    };
+  },
+
+  onSortStart: function(element) {
+    var widget = element.retrieve('widget');
+    widget.addClass('moved');
+    widget.fireEvent('moveStart');
+  },
+  
+  onSortComplete: function(element) {
+    var widget = element.retrieve('widget');
+    widget.removeClass('moved');
+    widget.fireEvent('moveComplete');
+  },
+  
+  onSort: function(element) {
+    var widget = element.retrieve('widget');
+    widget.fireEvent('move');
+    this.fireEvent('sort', [widget, element]);
+  }
+  
+});
+
+LSD.Behavior.define(':sortable', LSD.Mixin.Sortable);

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

@@ -0,0 +1,64 @@
+/*
+---
+ 
+script: Submittable.js
+ 
+description: Makes widget result in either submission or cancellation
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Mixin
+ 
+provides:
+  - LSD.Mixin.Submittable
+ 
+...
+*/
+
+
+LSD.Mixin.Submittable = new Class({
+  options: {
+    actions: {
+      autosubmission: {
+        enable: function() {
+          if (this.attributes.autosubmit) this.submit();
+        }
+      }
+    },
+    events: {
+      _form: {
+        attach: function(element) {
+          if (LSD.toLowerCase(element.tagName) == 'form') element.addEvent('submit', this.bindEvent('submit'));
+        },
+        detach: function(element) {
+          if (LSD.toLowerCase(element.tagName) == 'form') element.removeEvent('submit', this.bindEvent('submit'));
+        }
+      }
+    }
+  },
+  
+  submit: function(event) {
+    if (event && event.type == 'submit' && event.target == this.element)
+      event.preventDefault();
+    var submission = this.captureEvent('submit', arguments);
+    if (submission) return submission;
+    else if (submission !== false) this.callChain();
+    return this;
+  },
+  
+  cancel: function() {
+    var submission = this.captureEvent('cancel', arguments);
+    if (submission) return submission;
+    else if (submission !== false) {
+      var target = this.getSubmissionTarget();
+      if (target) target.uncallChain();
+      this.uncallChain();
+    };
+    return this;
+  }
+});
+
+LSD.Behavior.define(':submittable', LSD.Mixin.Submittable);

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

@@ -0,0 +1,102 @@
+/*
+---
+ 
+script: Target.js
+ 
+description: Functions to fetch and parse target into action chains
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Mixin
+
+provides: 
+  - LSD.Mixin.Target
+
+...
+*/
+
+!function() {
+  var cache = {};
+  LSD.Mixin.Target = new Class({
+    options: {
+      chain: {
+        target: function() {
+          if (!this.attributes.target) return;
+          return this.parseTargetSelector(this.attributes.target).map(function(chain) {
+            if (!chain.action) chain.action = this.getTargetAction(); 
+            if (!chain.action) return;
+            if (chain.selector) {
+              chain.target = function() {
+                return this.getElements(chain.selector);
+              }.bind(this);
+            };
+            switch (chain.keyword) {
+              case "before":
+                chain.priority = 50;
+                break;
+              case "after":
+                chain.priority = -50;
+            }
+            return chain;
+          }.bind(this));
+        }
+      }
+    },
+  
+    parseTargetSelector: function(selector) {
+      return (cache[selector] || (cache[selector] = Parser.exec.apply(Parser, arguments)))
+    },
+
+    getTargetAction: function() {
+      return this.attributes.interaction || this.captureEvent('getTargetAction', arguments);
+    }
+  });
+  
+  
+  var Parser = LSD.Mixin.Target.Parser = {
+    build: function(expression, start, end, keyword) {      
+      var last = expression[end - start - 1];
+      if (!last.classes && !last.attributes && last.tag == '*' && !last.id && last.pseudos[0].type == 'class') {
+        var actions = last.pseudos
+        end--;
+      };
+      if (keyword) start++;
+      var built = (start < end) ? {selector: Parser.slice(expression, start, end)} : {}
+      if (actions) return actions.map(function(pseudo, i) {
+        var object = Object.append({action: pseudo.key}, built);
+        var action = LSD.Action[LSD.toClassName(pseudo.key)];
+        var priority = action && action.prototype.options && action.prototype.options.priority;
+        if (priority != null) object.priority = priority;
+        if (pseudo.value) object.arguments = pseudo.value;
+        if (keyword) object.keyword = keyword;
+        return object;
+      }); else return built;
+    },
+    
+    slice: function(expressions, start, end) {
+      return {
+        Slick: true,
+        expressions: [expressions.slice(start, end)]
+      };
+    },
+    
+    exec: function(selector) {
+      var parsed = selector.Slick ? selector : Slick.parse(selector), expressions = [];
+      for (var i = 0, expression; expression = parsed.expressions[i]; i++) {
+        var started = 0;
+        var first = expression[0];
+        var keyword = Keywords[first.tag] ? first.tag : null; 
+        var exp = Parser.build(expression, started, expression.length, keyword);
+        expressions.push[exp.push ? 'apply' : 'call'](expressions, exp);
+      }
+      return expressions;
+    }
+  };
+  
+  var Keywords = Parser.Keywords = Array.fast('if', 'then', 'else', 'or', 'and', 'before');
+}();
+
+LSD.Behavior.define('[target]', LSD.Mixin.Target);

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

@@ -0,0 +1,41 @@
+/*
+---
+ 
+script: Touchable.js
+ 
+description: A mousedown event that lasts even when you move your mouse over. 
+ 
+license: Public domain (http://unlicense.org).
+
+authors: Yaroslaff Fedin
+ 
+requires:
+  - LSD.Mixin
+  - Mobile/Mouse
+  - Mobile/Click
+  - Mobile/Touch
+
+ 
+provides:   
+  - LSD.Mixin.Touchable
+ 
+...
+*/
+
+
+LSD.Mixin.Touchable = new Class({
+  options: {
+    events: {
+      enabled: {
+        element: {
+          'touchstart': 'activate',
+          'touchend': 'deactivate',
+          'touchcancel': 'deactivate'
+        }
+      }
+    },
+    states: Array.fast('active')
+  }
+});
+
+LSD.Behavior.define(':touchable', LSD.Mixin.Touchable);

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

@@ -0,0 +1,35 @@
+/*
+---
+ 
+script: Unselectable.js
+ 
+description: DisableS in browser native selection for element
+ 
+license: Public domain (http://unlicense.org).
+ 
+requires:
+  - LSD.Mixin
+  - Ext/Element.disableSelection
+ 
+provides: 
+  - LSD.Mixin.Unselectable
+ 
+...
+*/
+
+LSD.Mixin.Unselectable = new Class({
+  options: {
+    actions: {
+      selection: {
+        enable: function() {
+          this.element.disableSelection()
+        },
+        disable: function() {
+          this.element.enableSelection();
+        }
+      }
+    }
+  }
+});
+
+LSD.Behavior.define(':unselectable', LSD.Mixin.Unselectable);

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

@@ -0,0 +1,277 @@
+/*
+---
+ 
+script: Uploader.js
+ 
+description: Add your widget have a real form value.
+ 
+license: Public domain (http://unlicense.org).
+ 
+requires:
+  - LSD.Mixin
+  - Widgets/LSD.Widget.Button
+  - Widgets/LSD.Widget.Progress
+  - Uploader/*
+  - LSD.Mixin.List
+  - Core/JSON
+  
+provides: 
+  - LSD.Mixin.Uploader
+ 
+...
+*/
+
+LSD.Mixin.Uploader = new Class({
+  options: {
+    actions: {
+      uploader: {
+        enable: function() {
+          if (this.attributes.multiple) this.options.uploader.multiple = true;
+          this.fireEvent('register', ['uploader', this.getUploader()]);
+          var target = this.getUploaderTarget();
+          if (target) this.getUploader().attach(target);
+          this.getStoredBlobs().each(this.addFile, this);
+        },
+        disable: function() {
+          this.getUploader().removeEvents(this.events.uploader);
+          this.getUploader().detach(this.getUploaderTarget())
+          this.fireEvent('unregister', ['uploader', this.getUploader()]);
+        }
+      }
+    },
+    events: {
+      uploader: {
+        fileComplete: 'onFileComplete',
+        fileRemove: 'onFileRemove',
+        fileProgress: 'onFileProgress',
+        fileProgress: 'onFileProgress',
+        beforeSelect: 'onBeforeFileSelect'
+      }
+    },
+    has: {
+      many: {
+        targets: {
+          selector: ':uploading',
+          as: 'uploader',
+          relay: {
+            mouseover: function() {
+              this.uploader.getUploader().attach(this.toElement());
+            }
+          }
+        }
+      }
+    },
+    states: Array.fast('empty'),
+    filelist: false,
+    uploader: {
+      instantStart: true,
+      timeLimit: 36000,
+      queued: false,
+      multiple: false
+    }
+  },
+  
+  constructors: {
+    uploader: function() {
+      this.blobs = {};
+    }
+  },
+  
+  getUploader: function() {
+    if (this.uploader) return this.uploader;
+    var options = Object.append({}, this.options.uploader);
+    if (!options.fileClass) options.fileClass = this.getUploaderFileClass(Uploader.getAdapter());
+    this.uploader = new Uploader(options);
+    this.uploader.widget = this;
+    return this.uploader;
+  },
+  
+  onBeforeFileSelect: function() {
+    this.lastUploaderTarget =  this.getUploader().target;
+  },
+  
+  getUploaderTarget: function() {
+    var target = this.options.uploader.target;
+    if (target) {
+      return target;
+    } else if (target !== false) {
+      return this.element
+    }
+  },
+
+  getUploaderFileClass: function(adapter) {
+    if (!adapter) adapter = Uploader.getAdapter();
+    if (adapter.indexOf) adapter = Uploader[LSD.toClassName(adapter)];
+    if (!adapter.File.Widget) {
+      var Klass = new Class({
+        Implements: [adapter.File, this.getUploaderFileClassBase()]
+      });
+      adapter.File.Widget = function() {
+        return new LSD.Widget().mixin(Klass, true);
+      }
+    }
+    return adapter.File.Widget;
+  },
+  
+  getUploaderFileClassBase: function() {
+    return LSD.Widget.Filelist.File
+  },
+  
+  onFileComplete: function(file) {
+    var blob = this.processStoredBlob(file.response.text);
+    if (blob && !blob.errors) {
+      this.onFileSuccess(file, blob);
+    } else {
+      this.onFileFailure(file, blob || response);
+    }
+  },
+  
+  processValue: function(file) {
+    return file.id || file.uid;
+  },
+  
+  onFileSuccess: function(file, blob) {
+    this.addBlob(file, blob);
+    file.fireEvent('success', blob);
+  },
+  
+  onFileFailure: function(file, blob) {
+    file.fireEvent('failure', blob);
+  },
+  
+  onFileRemove: function(file) {
+    this.removeBlob(file);
+  },
+  
+  getBlob: function(file) {
+    return this.blobs[file.id];
+  },
+  
+  addBlob: function(file, blob) {
+    this.setValue(blob);
+    this.blobs[file.id] = blob;
+  },
+  
+  removeBlob: function(file) {
+    this.setValue(this.blobs[file.id], true);
+    delete this.blobs[file.id];    
+  },
+  
+  retrieveStoredBlobs: function() {
+    var attrs = this.attributes;
+    return attrs.file || attrs.files || attrs.blobs || attrs.blob;
+  },
+
+  processStoredBlob: function(response) {
+    if (response.indexOf) response = JSON.decode(response);
+    if (response && Object.getLength(response) == 1) response = response[Object.keys(response)[0]];
+    return response;
+  },
+  
+  getStoredBlobs: function() {
+    var files = this.retrieveStoredBlobs();
+    return files ? Array.from(JSON.decode(files)).map(this.processStoredBlob.bind(this)) : [];
+  },
+  
+  addFile: function(blob) {
+    var widget = new (this.getUploaderFileClass());
+    widget.widget = this;
+    widget.setState('complete');
+    widget.build();
+    widget.setBase(this.getUploader());
+    widget.setFile(blob);
+    this.addBlob(widget, blob);
+  }
+});
+
+LSD.Mixin.Upload = new Class({
+  options: {
+    has: {
+      one: {
+        progress: {
+          source: 'progress',
+          selector: 'progress'
+        }
+      }
+    },
+    events: {
+      setBase: function() {
+        if (this.target) this.targetWidget = this.target.retrieve('widget');
+        this.build();
+      },
+      build: function() {
+        this.inject(this.getWidget());
+      },
+      progress: function(progress) {
+        if (this.progress) this.progress.set(progress.percentLoaded);
+      },
+      start: function() {
+        this.setState('started');
+      },
+      complete: function() {
+        if (this.progress) this.progress.set(100);
+        this.unsetState('started');
+        this.setState('complete');
+      },
+      stop: function() {
+        this.unsetState('started');
+      },
+      remove: 'dispose'
+    }
+  },
+  
+  getParentWidget: function(widget) {
+    return widget;
+  },
+  
+  getWidget: function() {
+    return (this.widget || this.base.widget);
+  }
+});
+
+LSD.Widget.Filelist = new Class({
+  options: {
+    tag: 'filelist',
+    inline: 'ul',
+    pseudos: Array.from(':items'),
+    has: {
+      many: {
+        items: {
+          selector: 'file',
+          source: 'filelist-file'
+        }
+      }
+    }
+  }
+});
+
+LSD.Widget.Filelist.File = new Class({
+  options: {
+    tag: 'file',
+    inline: 'li',
+    layout: {
+      '::canceller': 'Cancel',
+      '::progress': true
+    },
+    pseudos: Array.fast('upload'),
+    events: {
+      setFile: function() {
+        this.write(this.name);
+      }
+    },
+    has: {
+      one: {
+        canceller: {
+          selector: 'a.cancel',
+          source: 'a.cancel',
+          events: {
+            click: 'cancel'
+          }
+        }
+      }
+    }
+  }
+});
+
+LSD.Behavior.define(':uploader', LSD.Mixin.Uploader);
+LSD.Behavior.define(':upload', LSD.Mixin.Upload);