puffer 0.0.32 → 0.1.0

data/app/assets/javascripts/puffer/right-in-edit-src.js

@@ -0,0 +1,373 @@
+/**
+ * RightJS-UI InEdit v2.2.0
+ * http://rightjs.org/ui/in-edit
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+var InEdit = RightJS.InEdit = (function(document, RightJS) {
+/**
+ * This module defines the basic widgets constructor
+ * it creates an abstract proxy with the common functionality
+ * which then we reuse and override in the actual widgets
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+
+/**
+ * The widget units constructor
+ *
+ * @param String tag-name or Object methods
+ * @param Object methods
+ * @return Widget wrapper
+ */
+function Widget(tag_name, methods) {
+  if (!methods) {
+    methods = tag_name;
+    tag_name = 'DIV';
+  }
+
+  /**
+   * An Abstract Widget Unit
+   *
+   * Copyright (C) 2010 Nikolay Nemshilov
+   */
+  var AbstractWidget = new RightJS.Class(RightJS.Element.Wrappers[tag_name] || RightJS.Element, {
+    /**
+     * The common constructor
+     *
+     * @param Object options
+     * @param String optional tag name
+     * @return void
+     */
+    initialize: function(key, options) {
+      this.key = key;
+      var args = [{'class': 'rui-' + key}];
+
+      // those two have different constructors
+      if (!(this instanceof RightJS.Input || this instanceof RightJS.Form)) {
+        args.unshift(tag_name);
+      }
+      this.$super.apply(this, args);
+
+      if (RightJS.isString(options)) {
+        options = RightJS.$(options);
+      }
+
+      // if the options is another element then
+      // try to dynamically rewrap it with our widget
+      if (options instanceof RightJS.Element) {
+        this._ = options._;
+        if ('$listeners' in options) {
+          options.$listeners = options.$listeners;
+        }
+        options = {};
+      }
+      this.setOptions(options, this);
+
+      return (RightJS.Wrapper.Cache[RightJS.$uid(this._)] = this);
+    },
+
+  // protected
+
+    /**
+     * Catches the options
+     *
+     * @param Object user-options
+     * @param Element element with contextual options
+     * @return void
+     */
+    setOptions: function(options, element) {
+      if (element) {
+        options = RightJS.Object.merge(options, new Function("return "+(
+          element.get('data-'+ this.key) || '{}'
+        ))());
+      }
+
+      if (options) {
+        RightJS.Options.setOptions.call(this, RightJS.Object.merge(this.options, options));
+      }
+
+      return this;
+    }
+  });
+
+  /**
+   * Creating the actual widget class
+   *
+   */
+  var Klass = new RightJS.Class(AbstractWidget, methods);
+
+  // creating the widget related shortcuts
+  RightJS.Observer.createShortcuts(Klass.prototype, Klass.EVENTS || RightJS([]));
+
+  return Klass;
+}
+
+
+/**
+ * A shared module to create textual spinners
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+var Spinner = new RightJS.Class(RightJS.Element, {
+  /**
+   * Constructor
+   *
+   * @param Number optional spinner size (4 by default)
+   * @return void
+   */
+  initialize: function(size) {
+    this.$super('div', {'class': 'rui-spinner'});
+    this.dots = [];
+
+    for (var i=0; i < (size || 4); i++) {
+      this.dots.push(new RightJS.Element('div'));
+    }
+
+    this.dots[0].addClass('glowing');
+    this.insert(this.dots);
+    RightJS(this.shift).bind(this).periodical(300);
+  },
+
+  /**
+   * Shifts the spinner elements
+   *
+   * @return void
+   */
+  shift: function() {
+    if (this.visible()) {
+      var dot = this.dots.pop();
+      this.dots.unshift(dot);
+      this.insert(dot, 'top');
+    }
+  }
+});
+
+
+/**
+ * In-Edit plugin initalization
+ *
+ * Copyright (C) 2010 Nikolay Nemshilov
+ */
+var R = RightJS,
+    $ = RightJS.$,
+    $w = RightJS.$w,
+    Xhr     = RightJS.Xhr,
+    Object  = RightJS.Object,
+    Element = RightJS.Element,
+    Input   = RightJS.Input;
+
+
+
+
+
+
+
+
+
+/**
+ * An inline editor feature
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+var InEdit = new Widget('FORM', {
+  extend: {
+    version: '2.2.0',
+
+    EVENTS: $w('show hide send update'),
+
+    Options: {
+      url:    null,    // the url address where to send the stuff
+      name:   'text',  // the field name
+      method: 'put',   // the method
+
+      type:   'text',  // the input type, 'text', 'file', 'password' or 'textarea'
+
+      toggle:  null,   // a reference to an element that should get hidden when the editor is active
+
+      update:  true,   // a marker if the element should be updated with the response-text
+
+      Xhr: {}          // additional Xhr options
+    },
+
+    i18n: {
+      Save:   'Save',
+      Cancel: 'Cancel'
+    },
+
+    current: null      // currently opened editor
+  },
+
+  /**
+   * Constructor
+   *
+   * @param mixed an element reference
+   * @param Object options
+   * @return void
+   */
+  initialize: function(element, options) {
+    this.element = $(element);
+
+    this
+      .$super('in-edit', options)
+      .set('action', this.options.url)
+      .insert([
+        this.field   = new Input({type: this.options.type, name: this.options.name, 'class': 'field'}),
+        this.spinner = new Spinner(4),
+        this.submit  = new Input({type: 'submit', 'class': 'submit', value: InEdit.i18n.Save}),
+        this.cancel  = new Element('a', {'class': 'cancel', href: '#', html: InEdit.i18n.Cancel})
+      ])
+      .onClick(this.clicked)
+      .onSubmit(this.send);
+  },
+
+  /**
+   * Shows the inline-editor form
+   *
+   * @return InEdit this
+   */
+  show: function() {
+    if (InEdit.current !== this) {
+      if (InEdit.current) { InEdit.current.hide(); }
+
+      this.oldContent = this.element.html();
+
+      if (!R(['file', 'password']).include(this.options.type)) {
+        this.field.setValue(this.oldContent);
+      }
+
+      this.element.update(this);
+
+      this.spinner.hide();
+      this.submit.show();
+
+      if (this.options.toggle) {
+        $(this.options.toggle).hide();
+      }
+    }
+
+    if (this.options.type !== 'file') {
+      this.field.focus();
+    }
+
+    InEdit.current = this;
+    return this.fire('show');
+  },
+
+  /**
+   * Hides the form and brings the content back
+   *
+   * @param String optional new content
+   * @return InEdit this
+   */
+  hide: function() {
+    this.element._.innerHTML = this.oldContent;
+
+    if (this.xhr) {
+      this.xhr.cancel();
+    }
+
+    return this.finish();
+  },
+
+  /**
+   * Triggers the form remote submit
+   *
+   * @return InEdit this
+   */
+  send: function(event) {
+    if (event) { event.stop(); }
+
+    this.spinner.show().resize(this.submit.size());
+    this.submit.hide();
+
+    this.xhr = new Xhr(this.options.url, Object.merge(this.options.Xhr, {
+      method:     this.options.method,
+      spinner:    this.spinner,
+      onComplete: R(this.receive).bind(this)
+    })).send(this);
+
+    return this.fire('send');
+  },
+
+// protected
+
+  // finishes up with the form
+  finish: function() {
+    if (this.options.toggle) {
+      $(this.options.toggle).show();
+    }
+
+    InEdit.current = null;
+    return this.fire('hide');
+  },
+
+  // the xhr callback
+  receive: function() {
+    if (this.options.update) {
+      this.element.update(this.xhr.text);
+      this.fire('update');
+    }
+
+    this.xhr = null;
+
+    this.finish();
+  },
+
+  // catches clicks on the element
+  clicked: function(event) {
+    if (event.target === this.cancel) {
+      event.stop();
+      this.hide();
+    }
+  }
+
+});
+
+
+/**
+ * The document hooks for in-edit form
+ *
+ * Copyright (C) 2010 Nikolay Nemshilov
+ */
+$(document).onKeydown(function(event) {
+  // processing the `ESC` button
+  if (event.keyCode === 27 && InEdit.current) {
+    InEdit.current.hide();
+  }
+});
+
+
+/**
+ * The element level inline editor extension
+ *
+ * Copyright (C) 2009-2010 Nikolay Nemshilov
+ */
+Element.include({
+  /**
+   * Triggers an inline-editor feature on the element
+   *
+   * @param Object options for the InEdit class
+   * @return InEdit object
+   */
+  inEdit: function(options) {
+    return new InEdit(this, options).show();
+  }
+});
+
+
+var embed_style = document.createElement('style'),                 
+    embed_rules = document.createTextNode("div.rui-spinner,div.rui-spinner div{margin:0;padding:0;border:none;background:none;list-style:none;font-weight:normal;float:none;display:inline-block; *display:inline; *zoom:1;border-radius:.12em;-moz-border-radius:.12em;-webkit-border-radius:.12em}div.rui-spinner{text-align:center;white-space:nowrap;background:#EEE;border:1px solid #DDD;height:1.2em;padding:0 .2em}div.rui-spinner div{width:.4em;height:70%;background:#BBB;margin-left:1px}div.rui-spinner div:first-child{margin-left:0}div.rui-spinner div.glowing{background:#777}form.rui-in-edit,form.rui-in-edit .cancel{margin:0;padding:0;float:none;position:static}form.rui-in-edit{display:inline-block; *display:inline; *zoom:1;border:none;background:none}form.rui-in-edit div.rui-spinner{margin-right:.2em}form.rui-in-edit div.rui-spinner div{margin-top:.2em}form.rui-in-edit textarea.field{width:100%;margin-bottom:.5em}form.rui-in-edit .field,form.rui-in-edit .submit{margin-right:.2em}form.rui-in-edit,form.rui-in-edit .field,form.rui-in-edit .submit,form.rui-in-edit div.rui-spinner,form.rui-in-edit .cancel{vertical-align:middle}");      
+                                                                   
+embed_style.type = 'text/css';                                     
+document.getElementsByTagName('head')[0].appendChild(embed_style); 
+                                                                   
+if(embed_style.styleSheet) {                                       
+  embed_style.styleSheet.cssText = embed_rules.nodeValue;          
+} else {                                                           
+  embed_style.appendChild(embed_rules);                            
+}                                                                  
+
+
+return InEdit;
+})(document, RightJS);

data/app/assets/javascripts/puffer/right-keys-src.js

@@ -0,0 +1,87 @@
+/**
+ * Pretty Keyboard Events v2.2.1
+ * http://rightjs.org/plugins/keys
+ *
+ * Copyright (C) 2009-2011 Nikolay Nemshilov
+ */
+(function(RightJS) {
+/**
+ * The keys plugin initialization
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+RightJS.Keys = {
+  version: '2.2.1'
+};
+
+
+
+/**
+ * The Event level keyboard keycodes and stuff
+ *
+ * Copyright (C) 2010 Nikolay Nemshilov
+ */
+RightJS.Event.Keys = {
+  BACKSPACE:  8,
+  TAB:        9,
+  ENTER:     13,
+  ESC:       27,
+  SPACE:     32,
+  PAGEUP:    33,
+  PAGEDOWN:  34,
+  END:       35,
+  HOME:      36,
+  LEFT:      37,
+  UP:        38,
+  RIGHT:     39,
+  DOWN:      40,
+  INSERT:    45,
+  DELETE:    46
+};
+
+
+/**
+ * Overloading the Element#on method to handle those fancy names
+ *
+ * Copyright (C) 2010-2011 Nikolay Nemshilov
+ */
+[RightJS.Document, RightJS.Element, RightJS.Window].each('include', {
+  on: function() {
+    var args = RightJS.$A(arguments), name = args[0];
+
+    if (typeof(name) === 'string') {
+      var key = name.split(/[\+\-\_ ]+/);
+      key = (key[key.length - 1] || '').toUpperCase();
+
+      if (key in RightJS.Event.Keys || /^[A-Z0-9]$/.test(key)) {
+        var meta   = /(^|\+|\-| )(meta|alt)(\+|\-| )/i.test(name),
+            ctrl   = /(^|\+|\-| )(ctl|ctrl)(\+|\-| )/i.test(name),
+            shift  = /(^|\+|\-| )(shift)(\+|\-| )/i.test(name),
+            code   = RightJS.Event.Keys[key] || key.charCodeAt(0),
+            orig   = args.slice(1),
+            method = orig.shift();
+
+        if (typeof(method) === 'string') {
+          method = this[method] || function() {};
+        }
+
+        // replacing the arguments
+        args = ['keydown', function(event) {
+          var raw = event._;
+          if (
+            (raw.keyCode === code) &&
+            (!meta  || raw.metaKey || raw.altKey) &&
+            (!ctrl  || raw.ctrlKey) &&
+            (!shift || raw.shiftKey)
+          ) {
+            return method.call(this, [event].concat(orig));
+          }
+        }];
+      }
+    }
+
+    return this.$super.apply(this, args);
+  }
+});
+
+})(RightJS);

data/app/assets/javascripts/puffer/right-slider-src.js

@@ -1,5 +1,5 @@
 /**
- * RightJS-UI Slider v2.2.3
+ * RightJS-UI Slider v2.3.0
  * http://rightjs.org/ui/slider
  *
  * Copyright (C) 2009-2011 Nikolay Nemshilov
@@ -177,7 +177,7 @@ var Slider = new Widget({
   include: Updater,
 
   extend: {
-    version: '2.2.3',
+    version: '2.3.0',
 
     EVENTS: $w('change'),
 
@@ -224,9 +224,9 @@ var Slider = new Widget({
 
     if (options.range === true) {
       this.handles = new Array();
-      this.handles[0] = this.first('.handle.from') || $E('div', {'class': 'handle.from'}).insertTo(this);
-      this.handles[1] = this.first('.handle.to') || $E('div', {'class': 'handle.to'}).insertTo(this);
-      
+      this.handles[0] = this.first('.handle.from') || $E('div', {'class': 'handle from'}).insertTo(this);
+      this.handles[1] = this.first('.handle.to') || $E('div', {'class': 'handle to'}).insertTo(this);
+
       this.values = [0, 0];
       this.values[0] = options.values === null ? options.min : options.values[0];
       this.values[1] = options.values === null ? options.max : options.values[1];
@@ -234,8 +234,6 @@ var Slider = new Widget({
       this.setValue(this.values[0], 'from');
       this.setValue(this.values[1], 'to');
 
-      //this.offsets = [0, 0];
-
     } else {
       this.handle = this.first('.handle') || $E('div', {'class': 'handle'}).insertTo(this);
       this.setValue(this.value);
@@ -273,7 +271,7 @@ var Slider = new Widget({
   },
 
   /**
-   * Returns the values that used to store the range 
+   * Returns the values that used to store the range
    *
    * @return An array storing the from/to float numbers
    */
@@ -307,9 +305,9 @@ var Slider = new Widget({
       this.offset = horizontal ? handle_f.left - dims.left : dims.top + dims.height - handle_f.top - handle_size;
       this.space  = (horizontal ? dims.width : dims.height) - handle_size - (this.offset * 2);
 
-      var handle_t = this.handles[1].setStyle(horizontal ? {left: this.space + 'px'} : 
+      var handle_t = this.handles[1].setStyle(horizontal ? {left: this.space + 'px'} :
                                                            {bottom: this.space + 'px'}).dimensions();
-     
+
     } else {
       var handle      = this.handle.setStyle(horizontal ? {left: 0} : {bottom: 0}).dimensions(),
           handle_size = this.hSize = horizontal ? handle.width : handle.height;
@@ -322,13 +320,22 @@ var Slider = new Widget({
   },
 
   // initializes the slider drag
-  start: function(event, type) {
-    return this.precalc().e2val(event, type);
+  start: function(event) {
+    this._type = null
+    if (event.target.hasClass('handle')) {
+      if (event.target.hasClass('from')) {
+        this._type = "from";
+      } else if (event.target.hasClass('to')) {
+        this._type = "to";
+      }
+    }
+
+    return this.precalc().e2val(event);
   },
 
   // processes the slider-drag
-  move: function(event, type) {
-    return this.e2val(event, type);
+  move: function(event) {
+    return this.e2val(event);
   },
 
   // shifts the slider to the value
@@ -391,7 +398,7 @@ var Slider = new Widget({
       if (fireEvent) {
         this.fire('change', {value: value, values: this.values});
       }
-      
+
     } else {
       // calculating and setting the actual position
       var position = this.space / (options.max - options.min) * (value - options.min);
@@ -410,16 +417,17 @@ var Slider = new Widget({
   },
 
   // converts the event position into the actual value in terms of the slider measures
-  e2val: function(event, type) {
+  e2val: function(event) {
     var options = this.options, horizontal = options.direction === 'x',
         dims    = this.dims, offset = this.offset, space = this.space,
         cur_pos = event.position()[horizontal ? 'x' : 'y'] - offset - this.hSize/2,
         min_pos = horizontal ? dims.left + offset : dims.top + offset,
-        value   = (options.max - options.min) / space * (cur_pos - min_pos);
+        value   = (options.max - options.min) / space * (cur_pos - min_pos),
+        type    = this._type;
 
-    if (!type) {
+    if (type == null) {
       return this.shiftTo(horizontal ? options.min + value : options.max - value);
-    } else if (type === "to") { 
+    } else if (type === "to") {
       this.shiftTo(this.values[0], "from");
       return this.shiftTo(horizontal ? options.min + value : options.max - value, "to");
     } else {
@@ -453,23 +461,14 @@ $(document).on({
       if (!(slider instanceof Slider)) {
         slider = new Slider(slider);
       }
-      var type = null;
-      if (event.target.hasClass('handle')) {
-        if (event.target.hasClass('from')) {
-          type = "from";
-        } else if (event.target.hasClass('to')) {
-          type = "to";
-        }
-      }
-      Slider.current = slider.start(event, type);
-      Slider.handleType = type;
+      Slider.current = slider.start(event);
     }
   },
 
   // handles the slider move
   mousemove: function(event) {
     if (Slider.current) {
-      Slider.current.move(event, Slider.handleType);
+      Slider.current.move(event);
     }
   },
 
@@ -477,7 +476,6 @@ $(document).on({
   mouseup: function(event) {
     if (Slider.current) {
       Slider.current = false;
-      Slider.handleType = null;
     }
   }
 });
@@ -485,7 +483,6 @@ $(document).on({
 $(window).onBlur(function() {
   if (Slider.current) {
     Slider.current = false;
-    Slider.handleType = null;
   }
 });