lsd_rails 0.1

data/Packages/lsd-specs/lsd/Module/Accessories/Chain.js

@@ -0,0 +1,385 @@
+describe("LSD.Module.Chain", function() {
+  var getAction = function(name, async, failing) {
+    var action = LSD.Action[LSD.capitalize(name)] = LSD.Action.build({
+      enable: function(target) {
+        action.count++;
+        action.args = Array.prototype.slice.call(arguments, 1);
+        if (async) {
+          if (this.retrieve(target)) return;
+          var callback = function() {
+            this.removeEvents(events);
+            self.eliminate(target);
+          };
+          var self = this, events = {
+            complete: callback,
+            cancel: callback
+          };
+          this.store(target, action.xhr)
+          action.xhr.addEvents(events);
+          action.xhr.fireEvent('start');
+          return action.xhr;
+        } else this.store(target, true)
+      },
+      disable: function(target) {
+        if (async) action.xhr.fireEvent('cancel');
+        this.eliminate(target);
+        action.count--;
+      },
+      getState: function(target) {
+        var submission = this.retrieve(target);
+        return !submission || !(submission !== true || submission.running);
+      }
+    });
+    if (async) {
+      var xhr = new Events;
+      xhr.callChain = true;
+      xhr.addEvents({
+        cancel: function() {
+          xhr.running = false;
+        },
+        complete: function() {
+          xhr.running = false;
+        },
+        start: function() {
+          xhr.running = true;
+        }
+      })
+      if (failing) xhr.onFailure = true;
+      action.xhr = xhr;
+    }
+    action.count = 0;
+    return action;
+  }
+  
+  it ("should read chain links off options and walk them both ways", function() {
+    var kiss = getAction('kiss'), slap = getAction('slap');
+    var widget = new LSD.Widget({
+      chain: {
+        kiss: function() {
+          return {action: 'kiss'}
+        },
+        slap: function() {
+          return {action: 'slap'}
+        }
+      }
+    });
+    expect(kiss.count).toEqual(0);
+    expect(slap.count).toEqual(0);
+    expect(widget.chainPhase).toEqual(-1);
+    widget.callChain();
+    expect(kiss.count).toEqual(1);
+    expect(slap.count).toEqual(1);
+    expect(widget.chainPhase).toEqual(1);
+    widget.uncallChain();
+    expect(kiss.count).toEqual(0);
+    expect(slap.count).toEqual(0);
+    expect(widget.chainPhase).toEqual(-1);
+    widget.callChain();
+    expect(kiss.count).toEqual(1);
+    expect(slap.count).toEqual(1);
+    expect(widget.chainPhase).toEqual(1);
+    widget.uncallChain();
+    expect(kiss.count).toEqual(0);
+    expect(slap.count).toEqual(0);
+    expect(widget.chainPhase).toEqual(-1);
+  });
+  
+  it ("waits for asynchrponous tasks to finish", function() {
+    var kiss = getAction('kiss', true), slap = getAction('slap');
+    var widget = new LSD.Widget({
+      chain: {
+        kiss: function() {
+          return {action: 'kiss'}
+        },
+        slap: function() {
+          return {action: 'slap'}
+        }
+      }
+    });
+    widget.callChain();
+    expect(widget.chainPhase).toEqual(0);
+    expect(kiss.count).toEqual(1);
+    expect(slap.count).toEqual(0);
+    expect(kiss.xhr.fireEvent('complete', [888]));
+    expect(widget.chainPhase).toEqual(1);
+    expect(kiss.count).toEqual(1);
+    expect(slap.args).toEqual([888]);
+    expect(slap.count).toEqual(1);
+    expect(kiss.xhr.fireEvent('complete', 777));
+    expect(widget.chainPhase).toEqual(1);
+    expect(kiss.count).toEqual(1);
+    expect(slap.count).toEqual(1);
+  })
+  
+  it ("handles asynchronous multiple asynchronous actions and reveses them right", function() {
+    var kiss = getAction('kiss'), slap = getAction('slap', true, true);
+    var widget = new LSD.Widget({
+      chain: {
+        ordinarySlap: function() {
+          return {action: 'slap', arguments: [3, 4]}
+        },
+        highPriorityKiss: function() {
+          return {action: 'kiss', priority: 10, target: girl}
+        },
+        doubleKissFirst: function() {
+          return {action: 'kiss', arguments: [1, 2], target: mom}
+        },
+        doubleKissSecond: function() {
+          return {action: 'kiss', arguments: [1, 2], target: boy}
+        },
+        lastSlap: function() {
+          return {action: 'slap', arguments: [3, 4], target: mom}
+        },
+        goodbyeSelfKiss: function() {
+          return {action: 'kiss', arguments: [1, 2]}
+        }
+      }
+    });
+    var boy = new LSD.Widget, girl = new LSD.Widget, mom = new LSD.Widget;
+    widget.callChain();
+    var chain = widget.getActionChain().map(function(e) { return e.action});
+    expect(chain).toEqual(['kiss', 'slap', 'kiss', 'kiss', 'slap', 'kiss'])
+    expect(widget.chainPhase).toEqual(1);
+    expect(kiss.count).toEqual(1);
+    expect(slap.count).toEqual(1);
+    expect(widget.chainPhasing.map(function(e) { return e.action})).toEqual(['kiss', 'slap']);
+    slap.xhr.fireEvent('success').fireEvent('complete');
+    expect(widget.chainPhase).toEqual(4);
+    expect(widget.chainPhasing.map(function(e) { return e.action})).toEqual(['kiss', 'slap', 'kiss', 'kiss', 'slap']);
+    expect(kiss.count).toEqual(3);
+    expect(slap.count).toEqual(2);
+    slap.xhr.fireEvent('success').fireEvent('complete');
+    expect(widget.chainPhasing.map(function(e) { return e.action})).toEqual(['kiss', 'slap', 'kiss', 'kiss', 'slap', 'kiss']);
+    expect(widget.chainPhase).toEqual(5);
+    expect(kiss.count).toEqual(4);
+    expect(slap.count).toEqual(2);
+    widget.callChain();
+    expect(widget.chainPhasing.map(function(e) { return e.action})).toEqual(['kiss', 'slap']);
+    expect(widget.chainPhase).toEqual(1);
+    expect(kiss.count).toEqual(5);
+    expect(slap.count).toEqual(3);
+    slap.xhr.fireEvent('success').fireEvent('complete');
+    expect(widget.chainPhase).toEqual(4);
+    expect(widget.chainPhasing.map(function(e) { return e.action})).toEqual(['kiss', 'slap', 'kiss', 'kiss', 'slap']);
+    expect(kiss.count).toEqual(7);
+    expect(slap.count).toEqual(4);
+    slap.xhr.fireEvent('success').fireEvent('complete');
+    expect(widget.chainPhase).toEqual(5);
+    expect(widget.chainPhasing.map(function(e) { return e.action})).toEqual(['kiss', 'slap', 'kiss', 'kiss', 'slap', 'kiss']);
+    expect(kiss.count).toEqual(8);
+    expect(slap.count).toEqual(4);
+    widget.uncallChain();
+    expect(kiss.count).toEqual(7);
+    expect(slap.count).toEqual(4);
+    expect(widget.chainPhasing.map(function(e) { return e.action})).toEqual(['kiss', 'slap', 'kiss', 'kiss', 'slap']);
+    expect(widget.chainPhase).toEqual(4);
+    expect(widget.chainPhasing.getLast().action).toEqual('slap')
+    widget.uncallChain();
+    expect(widget.chainPhasing.map(function(e) { return e.action})).toEqual(['kiss', 'slap']);
+    expect(kiss.count).toEqual(5);
+    expect(slap.count).toEqual(3);
+    expect(widget.chainPhase).toEqual(1)
+    widget.uncallChain();
+    expect(widget.chainPhasing.map(function(e) { return e.action})).toEqual([]);
+    expect(kiss.count).toEqual(4);
+    expect(slap.count).toEqual(2);
+    expect(widget.chainPhase).toEqual(-1)
+  });
+  
+  it ("handles asynchronous multiple asynchronous actions and their failures  ", function() {
+    var kiss = getAction('kiss'), slap = getAction('slap', true, true);
+    var widget = new LSD.Widget({
+      chain: {
+        goodbyeSelfKiss: function() {
+          return {action: 'kiss', arguments: [1, 2], priority: -1}
+        },
+        ordinarySlap: function() {
+          return {action: 'slap', arguments: [3, 4]}
+        },
+        highPriorityKiss: function() {
+          return {action: 'kiss', priority: 10, target: girl}
+        },
+        doubleKissFirst: function() {
+          return {action: 'kiss', arguments: [1, 2], target: mom}
+        },
+        doubleKissSecond: function() {
+          return {action: 'kiss', arguments: [1, 2], target: boy}
+        },
+        lastSlap: function() {
+          return {action: 'slap', arguments: [3, 4], target: mom}
+        }
+      }
+    });
+    var boy = new LSD.Widget, girl = new LSD.Widget, mom = new LSD.Widget;
+    widget.callChain();
+    var chain = widget.getActionChain().map(function(e) { return e.action});
+    expect(chain).toEqual(['kiss', 'slap', 'kiss', 'kiss', 'slap', 'kiss']);
+    expect(widget.chainPhase).toEqual(1);
+    expect(kiss.count).toEqual(1);
+    expect(slap.count).toEqual(1);
+    slap.xhr.fireEvent('failure');
+    slap.xhr.fireEvent('complete');
+    expect(widget.chainPhase).toEqual(1);
+    expect(kiss.count).toEqual(1);
+    expect(slap.count).toEqual(1);
+    slap.xhr.fireEvent('failure');
+    slap.xhr.fireEvent('complete');
+    /*
+    expect(widget.chainPhase).toEqual(4);
+    expect(kiss.count).toEqual(3);
+    expect(slap.count).toEqual(2);
+    slap.xhr.fireEvent('success');
+    slap.xhr.fireEvent('complete');
+    expect(widget.chainPhase).toEqual(5);
+    expect(kiss.count).toEqual(4);
+    expect(slap.count).toEqual(2);
+    widget.callChain();
+    expect(widget.chainPhase).toEqual(1);
+    expect(kiss.count).toEqual(5);
+    expect(slap.count).toEqual(3);
+    slap.xhr.fireEvent('success');
+    slap.xhr.fireEvent('complete');
+    expect(widget.chainPhase).toEqual(4);
+    expect(kiss.count).toEqual(7);
+    expect(slap.count).toEqual(4);
+    slap.xhr.fireEvent('success');
+    slap.xhr.fireEvent('complete');
+    expect(widget.chainPhase).toEqual(5);
+    expect(kiss.count).toEqual(8);
+    expect(slap.count).toEqual(4);
+    widget.uncallChain();
+    expect(kiss.count).toEqual(7);
+    expect(slap.count).toEqual(4);
+    expect(widget.chainPhase).toEqual(4)
+    widget.uncallChain();
+    expect(kiss.count).toEqual(5);
+    expect(slap.count).toEqual(3);
+    expect(widget.chainPhase).toEqual(1)
+    widget.uncallChain();
+    expect(kiss.count).toEqual(4);
+    expect(slap.count).toEqual(2);
+    expect(widget.chainPhase).toEqual(-1)
+    */
+  })
+  
+  it ("should obey keywords and do walkaheads and alternative branches", function() {
+    var kiss = getAction('kiss'), lick = getAction('lick'), slap = getAction('slap', true, true);
+    var widget = new LSD.Widget({
+      chain: {
+        conditionalSlap: function() {
+          return {action: 'slap'}
+        },
+        onSuccessKissInstant: function() {
+          return {keyword: 'and', action: 'kiss', arguments: [555]}
+        },
+        onFailureKiss: function() {
+          return {keyword: 'or', action: 'lick', arguments: [666]}
+        }
+      }
+    });
+    widget.callChain()
+    expect(widget.chainPhase).toEqual(0);
+    expect(kiss.args[0]).toEqual(555);
+    expect(kiss.count).toEqual(1);
+    slap.xhr.fireEvent('failure').fireEvent('complete');
+    expect(kiss.count).toEqual(0);
+    expect(lick.count).toEqual(1);
+  });
+  
+  it ("should greedely capture and execute actions combined with and", function() {
+    var kiss = getAction('kiss'), lick = getAction('lick'), slap = getAction('slap', true, true);
+    var widget = new LSD.Widget({
+      chain: {
+        conditionalSlap: function() {
+          return {action: 'slap'}
+        },
+        onSuccessKissInstant: function() {
+          return {keyword: 'and', action: 'kiss', arguments: [555]}
+        },
+        onSuccessParazyticKissInstant: function() {
+          return {keyword: 'and', action: 'kiss', arguments: [333], target: boy}
+        },
+        onFailureKiss: function() {
+          return {keyword: 'or', action: 'lick', arguments: [666]}
+        },
+        onFailureParazyticKiss: function() {
+          return {keyword: 'or', action: 'lick', arguments: [444], target: boy}
+        },
+        finalStep: function() {
+          return {action: 'lick', target: dog}
+        }
+      }
+    });
+    var boy = new LSD.Widget, dog = new LSD.Widget
+    widget.callChain()
+    expect(widget.chainPhase).toEqual(0);
+    expect(kiss.args[0]).toEqual(333);
+    expect(kiss.count).toEqual(2);
+    expect(slap.count).toEqual(1);
+    slap.xhr.fireEvent('failure').fireEvent('complete');
+    expect(kiss.count).toEqual(0);
+    expect(lick.count).toEqual(2);
+    expect(widget.chainPhase).toEqual(0);
+    widget.callChain();
+    expect(widget.chainPhase).toEqual(5);
+    expect(kiss.count).toEqual(0);
+    expect(lick.count).toEqual(3);
+    widget.callChain();
+    expect(widget.chainPhase).toEqual(0);
+    expect(kiss.count).toEqual(2);
+    expect(lick.count).toEqual(3);
+    expect(slap.count).toEqual(2);
+    slap.xhr.fireEvent('success').fireEvent('complete');
+    expect(widget.chainPhase).toEqual(5);
+    expect(kiss.count).toEqual(2);
+    expect(lick.count).toEqual(4);
+    expect(slap.count).toEqual(2);
+    widget.uncallChain();
+    expect(widget.chainPhase).toEqual(0);
+    expect(kiss.count).toEqual(2);
+    expect(lick.count).toEqual(3);
+    expect(slap.count).toEqual(2);
+    widget.uncallChain();
+    expect(widget.chainPhase).toEqual(-1);
+    expect(kiss.count).toEqual(2);
+    expect(lick.count).toEqual(3);
+    expect(slap.count).toEqual(1);
+    widget.callChain();
+    expect(widget.chainPhase).toEqual(0);
+    expect(kiss.count).toEqual(4);
+    expect(lick.count).toEqual(3);
+    expect(slap.count).toEqual(2);
+    slap.xhr.fireEvent('failure').fireEvent('complete');
+    expect(widget.chainPhase).toEqual(0);
+    expect(kiss.count).toEqual(2);
+    expect(lick.count).toEqual(5);
+    expect(slap.count).toEqual(2);
+  });
+  
+  it ("should wait for multiple asynchronous objects", function() {
+    
+    var kiss = getAction('kiss'), lick = getAction('lick'), slap = getAction('slap', true, true);
+    var cat = new LSD.Widget({
+      chain: {
+        slap: function() {
+          return {action: 'slap', target: dog, fork: true}
+        }
+      }
+    });
+    var dog = new LSD.Widget({
+      chain: {
+        kiss: function() {
+          return {action: 'kiss', target: cat}
+        }
+      }
+    });
+    cat.callChain();
+    expect(cat.chainPhase).toEqual(0);
+    expect(kiss.count).toEqual(0);
+    slap.xhr.fireEvent('complete').fireEvent('success');
+    expect(cat.chainPhase).toEqual(0);
+    expect(kiss.count).toEqual(1);
+    //slap.xhr.fireEvent('complete').fireEvent('success');
+    //expect(kiss.count).toEqual(1);
+  });
+})

data/Packages/lsd-specs/lsd/Module/Accessories/Dimensions.js

@@ -0,0 +1,53 @@
+describe("LSD.Module.Dimensions", function() {
+  describe("#size", function() {
+    it ("should set size", function() {
+      var instance = new LSD.Widget;
+      instance.setSize({width:400, height:300});
+      expect(instance.size.width).toEqual(400);
+      expect(instance.size.height).toEqual(300);
+    });
+  });
+
+  describe("#height", function() {
+
+    it ("should set height", function() {
+      var instance = new LSD.Widget;
+      instance.setSize({height:500});
+      expect(instance.size.height).toEqual(500);
+    });
+
+    it ("should set height according to minHeight & maxHeight", function() {
+      var instance = new LSD.Widget;
+      instance.setStyle("minHeight", 100);
+      instance.setStyle("maxHeight", 200);
+      instance.setHeight(250);
+      expect(instance.size.height).toEqual(200);
+      instance.setHeight(150);
+      expect(instance.size.height).toEqual(150);
+      instance.setHeight(50);
+      expect(instance.size.height).toEqual(100);
+    });
+  });
+
+  describe("#width", function() {
+
+    it ("should set width", function() {
+      var instance = new LSD.Widget;
+      instance.setSize({width:500});
+      expect(instance.size.width).toEqual(500);
+    });
+
+    it ("should set width according to minWidth & maxWidth", function() {
+      var instance = new LSD.Widget;
+      instance.setStyle("minWidth", 100);
+      instance.setStyle("maxWidth", 200);
+      instance.setWidth(250);
+      expect(instance.size.width).toEqual(200);
+      instance.setWidth(150);
+      expect(instance.size.width).toEqual(150);
+      instance.setWidth(50);
+      expect(instance.size.width).toEqual(100);
+    });
+
+  });
+});

data/Packages/lsd-specs/lsd/Module/Accessories/Element.js

@@ -0,0 +1,112 @@
+describe("LSD.Module.Element", function() {
+  describe("#attach", function() {
+    it ("should attach element from constructor", function() {
+      var element = new Element('div');
+      var instance = new LSD.Widget(element);
+      expect(instance.attached).toBeTruthy();
+      expect(instance.element).toBeTruthy();
+      expect(element.retrieve('widget')).toEqual(instance);
+    });
+    
+    it ("should not attach if no element is given to constructor", function() {
+      var instance = new LSD.Widget();
+      expect(instance.attached).toBeFalsy();
+      expect(instance.element).toBeFalsy();
+    });
+    
+    it ("should let attach element after construction", function() {
+      var element = new Element('div');
+      var instance = new LSD.Widget();
+      
+      instance.attach(element);
+      expect(instance.attached).toBeTruthy();
+      expect(instance.element).toBeTruthy();
+    });
+    
+    it ("should let change element storage key through options", function() {
+      var element = new Element('div');
+      var instance = new LSD.Widget(element, {key: 'jesus'});
+      expect(element.retrieve('jesus')).toEqual(instance)
+    });
+  });
+  
+  describe("#detach", function() {
+    it ("should clean element on detach", function() {
+      var element = new Element('div');
+      var instance = new LSD.Widget(element);
+      instance.detach();
+      expect(instance.element).toBeFalsy();
+      expect(element.retrieve('widget')).toBeFalsy();
+    });
+    
+    it ("should let attach another element after", function() {
+      var element = new Element('div'), another = new Element('a');
+      var instance = new LSD.Widget(element);
+      expect(instance.element == element).toEqual(true);
+      instance.detach();
+      expect(instance.element).toEqual(null);
+      instance.attach(another);
+      expect(instance.element).toEqual(another);
+      expect(another.retrieve('widget')).toEqual(instance);
+      expect(element.retrieve('widget')).toBeFalsy();
+      instance.detach();
+      instance.attach(element);
+      expect(instance.element).toNotEqual(another);
+      expect(instance.element).toEqual(element);
+      expect(element.retrieve('widget')).toEqual(instance);
+      expect(another.retrieve('widget')).toBeFalsy();
+    });
+  });
+  
+  describe("#build", function() {
+    it ('should build the attached element', function() {
+      var element = new Element('div');
+      var instance = new LSD.Widget(element);
+      expect(instance.built).toBeTruthy();
+    });
+    
+    it ("should attach the built element", function() {
+      var instance = new LSD.Widget({tag: 'h2'});
+      instance.build();
+      expect(instance.element).toBeTruthy();
+      expect(instance.attached).toBeTruthy();    
+    });
+  });
+  
+  describe("#destroy", function() {
+    it ('should detach the destroyed element', function() {
+      var element = new Element('div');
+      var instance = new LSD.Widget(element);
+      expect(element.retrieve('widget') == instance).toBeTruthy();
+      instance.destroy();
+      expect(instance.attached).toBeFalsy();
+    });
+    
+    it ('should destroy element', function() {
+      var element = new Element('div');
+      var child = new Element('a').inject(element);
+      var instance = new LSD.Widget(child);
+      instance.destroy();
+      expect(element.getChildren().length).toEqual(0)
+    });
+  });
+  
+  describe("#toElement", function() {
+    it ('should pick up attached element', function() {
+      var element = new Element('div');
+      var instance = new LSD.Widget(element);
+      expect(instance.toElement()).toEqual(element);
+    });
+    
+    it ('should build element when there\'s no attached element', function() {
+      var instance = new LSD.Widget({inline: false});
+      expect(instance.toElement().nodeName).toEqual('DIV');
+    });
+    
+    it ('should be used in document.id (aka $ function)', function() {
+      var instance = new LSD.Widget({inline: true});
+      expect($(instance).nodeName).toEqual('SPAN');
+    });
+  });
+
+});

data/Packages/lsd-specs/lsd/Module/Accessories/Events.js

@@ -0,0 +1,151 @@
+describe("LSD.Module.Accessories.Events", function() {
+  describe("#simple", function() {
+
+    it ("self", function() {
+      var clicked = false;
+      LSD.Widget.Test = new Class({
+        options: {
+          events: {
+            self: {
+              'touch': 'onTouch'
+            }
+          }
+        },
+
+        onTouch: function(event) {
+          clicked = true;
+        }
+      });
+
+      var element = new Element('test');
+      var widget = new LSD.Widget(element, {context:'widget'});
+      widget.fireEvent('touch');
+      expect(clicked).toBeTruthy();
+    });
+
+    it ("element", function() {
+      var clicked = false;
+      LSD.Widget.Test = new Class({
+        options: {
+          events: {
+            element: {
+              'click': 'onClick'
+            }
+          }
+        },
+
+        onClick: function(event) {
+          clicked = true;
+        }
+      });
+
+      var element = new Element('test');
+      new LSD.Widget(element, {context:'widget'});
+      element.fireEvent("click");
+      expect(clicked).toBeTruthy();
+    });
+
+    it ("parent", function() {
+      var clicked = false;
+      LSD.Widget.Test = new Class({
+        options: {
+          events: {
+            parent: {
+              'click': 'onClick'
+            }
+          }
+        },
+
+        onClick: function(event) {
+          clicked = true;
+        }
+      });
+
+      var parent = new LSD.Widget(new Element('button'), {context:'widget'});
+      var widget = new LSD.Widget(new Element('test'), {context:'widget'});
+
+      parent.appendChild(widget);
+      parent.fireEvent('click');
+
+      expect(clicked).toBeTruthy();
+    });
+
+    it ("document", function() {
+      var clicked = false;
+
+      LSD.Widget.Test = new Class({
+        options: {
+          events: {
+            document: {
+              'click': 'onClick'
+            }
+          }
+        },
+
+        onClick: function(event) {
+          clicked = true;
+        }
+      });
+
+      var doc = new LSD.Document;
+      var widget = new LSD.Widget(new Element('test'), {context:'widget', document: doc});
+      doc.fireEvent("click");
+      expect(clicked).toBeTruthy();
+    });
+
+    it ("window", function() {
+      var resized = false;
+
+      LSD.Widget.Test = new Class({
+        options: {
+          events: {
+            window: {
+              resize: 'onWindowResize'
+            }
+          }
+        },
+
+        onWindowResize: function(event) {
+          resized = true;
+        }
+      });
+
+      new LSD.Widget(new Element('test'), {context:'widget'});
+
+      window.fireEvent("resize");
+      expect(resized).toBeTruthy();
+    });
+
+  });
+
+  describe("#complex", function() {
+
+    it ("click:relay", function() {
+      var clicked = false;
+      LSD.Widget.Test = new Class({
+        options: {
+          events: {
+            element: {
+              'click:relay(buttog)': 'onClick'
+            }
+          }
+        },
+
+        onClick: function(event) {
+          clicked = true;
+        }
+      });
+
+
+      var widget = new LSD.Widget(new Element('test'), {context:'widget'});
+      var button = new LSD.Widget({tag: 'buttog', inline: null});
+      button.inject(widget);
+      widget.element.fireEvent('click', {target: button.element});
+
+      expect(clicked).toBeTruthy();
+    });
+
+  });
+
+
+});