sproutcore 1.11.0.rc2 → 1.11.0.rc3

data/lib/frameworks/sproutcore/frameworks/foundation/tests/transitions/view_transitions_test.js

@@ -109,7 +109,6 @@ test("Reversing SHOWING to HIDING: FADE_IN & FADE_OUT", function () {
     equals(view.get('isVisible'), false, "The isVisible property of the view is");
     ok(!jqEl.hasClass('sc-hidden'), "The view doesn't have sc-hidden class name.");
     ok(jqEl.css('opacity') > 0, "The view's opacity is not 0 still.");
-    equals(view.$().css('opacity'), '1', "The view's opacity is");
   }, 200);
 
   setTimeout(function () {
@@ -208,8 +207,8 @@ test("Reversing HIDING to SHOWING: FADE_IN & FADE_OUT", function () {
     // Test assumption.
     equals(view.get('isVisible'), false, "The isVisible property of the view is");
     ok(!jqEl.hasClass('sc-hidden'), "The view doesn't have sc-hidden class name.");
-    ok(jqEl.css('opacity') > 0, "The view's opacity is not 0.");
-    ok(jqEl.css('opacity') < 1, "The view's opacity is not 1.");
+    ok(jqEl.css('opacity') > 0, "The view's current opacity is not 0.");
+    ok(jqEl.css('opacity') < 1, "The view's current opacity is not 1.");
 
     // Cancel fading out.
     SC.run(function () {
@@ -219,7 +218,8 @@ test("Reversing HIDING to SHOWING: FADE_IN & FADE_OUT", function () {
     jqEl = view.$();
     equals(view.get('isVisible'), true, "The isVisible property of the view is");
     ok(!jqEl.hasClass('sc-hidden'), "The view doesn't have sc-hidden class name.");
-    equals(view.$().css('opacity'), '0', "The view's opacity is");
+    ok(jqEl.css('opacity') > 0, "The view's current opacity is not 0 still.");
+    ok(jqEl.css('opacity') < 1, "The view's current opacity is not 1 still.");
   }, 200);
 
   setTimeout(function () {
@@ -228,7 +228,7 @@ test("Reversing HIDING to SHOWING: FADE_IN & FADE_OUT", function () {
     // Test assumption.
     equals(view.get('isVisible'), true, "The isVisible property of the view is");
     ok(!jqEl.hasClass('sc-hidden'), "The view doesn't have sc-hidden class name.");
-    equals(jqEl.css('opacity'), '1', "The view's opacity is now");
+    equals(jqEl.css('opacity'), '1', "The view's current opacity is now");
 
     start();
   }, 1000);

data/lib/frameworks/sproutcore/frameworks/foundation/tests/views/container/methods.js

@@ -21,10 +21,6 @@ module("SC.ContainerView Methods", {
         childViews: [containerView]
       }).append();
     });
-
-    SC.run(function () {
-      containerView.awake();
-    });
   },
 
   teardown: function () {

data/lib/frameworks/sproutcore/frameworks/foundation/tests/views/container/transition_test.js

@@ -30,10 +30,6 @@ module("SC.ContainerView Transitions", {
         childViews: [containerView]
       }).append();
     });
-
-    SC.run(function () {
-      containerView.awake();
-    });
   },
 
   teardown: function () {

data/lib/frameworks/sproutcore/frameworks/foundation/tests/views/container/ui.js

@@ -144,7 +144,6 @@
 
   test("default nowShowing", function(){
     var view = pane.view("nowShowingDefault");
-    view.awake();
 
     var contentView = view.get('contentView');
 
@@ -164,7 +163,6 @@
 
   test("Cleans up instantiated views", function() {
     var view = pane.view("cleans-up-views");
-    view.awake();
 
     var contentView = view.get('contentView');
     SC.run(function() { view.set('nowShowing', SC.View.create()); });

data/lib/frameworks/sproutcore/frameworks/foundation/views/text_field.js

@@ -1259,10 +1259,12 @@ SC.TextFieldView = SC.FieldView.extend(SC.Editable,
     if (SC.browser.isMozilla &&
         evt.keyCode === SC.Event.KEY_RETURN) { this.fieldValueDidChange(); }
 
-    // The caret/selection could have moved.  In some browsers, though, the
-    // element's values won't be updated until after this event is finished
-    // processing.
-    this.notifyPropertyChange('selection');
+    // The caret/selection may have changed.
+    // This cannot notify immediately, because in some browsers (tested Chrome 39.0 on OS X), the
+    // value of `selectionStart` and `selectionEnd` won't have updated yet. Thus if we notified
+    // immediately, observers of this view's `selection` property would get the old value.
+    this.invokeNext(this._textField_selectionDidChange);
+
     evt.allowDefault();
     return true;
   },
@@ -1287,10 +1289,12 @@ SC.TextFieldView = SC.FieldView.extend(SC.Editable,
       return true;
     }
 
-    // The caret/selection could have moved.  In some browsers, though, the
-    // element's values won't be updated until after this event is finished
-    // processing.
-    this.notifyPropertyChange('selection');
+    // The caret/selection may have changed.
+    // This cannot notify immediately, because in some browsers (tested Chrome 39.0 on OS X), the
+    // value of `selectionStart` and `selectionEnd` won't have updated yet. Thus if we notified
+    // immediately, observers of this view's `selection` property would get the old value.
+    this.invokeNext(this._textField_selectionDidChange);
+
     return sc_super();
   },
 

data/lib/frameworks/sproutcore/frameworks/media/tests/audio.js

@@ -0,0 +1,69 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+var
+  INITIAL_VOL = 0.8,
+  TIMEOUT = 1000,
+  TESTFILE = static_url("silence.mp3"), // the real sound of silence
+  isPhantom = !!window.callPhantom,
+  pane, audioView;
+
+module("SC.AudioView", {
+
+  setup: function () {
+    SC.RunLoop.begin();
+
+    audioView = SC.AudioView.create({
+      volume: INITIAL_VOL
+    });
+
+    pane = SC.MainPane.create();
+    pane.appendChild(audioView);
+    pane.append();
+
+    SC.RunLoop.end();
+
+    SC.Timer.schedule({
+      action: function () { audioView.set("value", TESTFILE); },
+      interval: 100
+    });
+  },
+
+  teardown: function () {
+    pane.remove();
+    pane = audioView = null;
+  }
+});
+
+function checkAudioSupport() {
+  if (isPhantom) {
+    warn("Audio cannot be tested in PhantomJS (see http://phantomjs.org/supported-web-standards.html)");
+    return false;
+  }
+  return true;
+}
+
+test("Test MP3 file", function () {
+  if (!checkAudioSupport()) return;
+  stop(TIMEOUT);
+
+  // assume audio has been loaded when the duration changes
+  audioView.addObserver("duration", function (sender, key) {
+    ok(sender.get(key), "MP3 file did load");
+    start();
+  });
+});
+
+test("Test initial volume", function () {
+  if (!checkAudioSupport()) return;
+  stop(TIMEOUT);
+
+  // assume audio has been loaded when the duration changes
+  audioView.addObserver("duration", function (sender, key) {
+    equals(audioView.get("volume"), INITIAL_VOL, "Initial volume is still set after audio has been loaded");
+    start();
+  });
+});

data/lib/frameworks/sproutcore/frameworks/media/views/audio.js

@@ -298,6 +298,7 @@ SC.AudioView = SC.View.extend(
   addAudioDOMEvents: function() {
     var audioElem, view=this;
     audioElem = this.$('audio')[0];
+    audioElem.volume = this.get('volume');
     this.set('audioObject', audioElem);
     SC.Event.add(audioElem, 'durationchange', this, function () {
       SC.run(function() {

data/lib/frameworks/sproutcore/frameworks/runtime/core.js

@@ -39,7 +39,7 @@ window.SproutCore = window.SproutCore || SC;
 // rest of the methods go into the mixin defined below.
 
 /**
-  @version 1.11.0.rc2
+  @version 1.11.0.rc3
   @namespace
 
   All SproutCore methods and functions are defined
@@ -56,7 +56,7 @@ window.SproutCore = window.SproutCore || SC;
 */
 SC = window.SC; // This is dumb but necessary for jsdoc to get it right
 
-SC.VERSION = '1.11.0.rc2';
+SC.VERSION = '1.11.0.rc3';
 
 /**
   @private

data/lib/frameworks/sproutcore/frameworks/runtime/mixins/observable.js

@@ -561,7 +561,9 @@ SC.Observable = /** @scope SC.Observable.prototype */ {
       }
 
     // otherwise notify property observers immediately
-    } else this._notifyPropertyObservers(key);
+    } else {
+      this._notifyPropertyObservers(key);
+    }
 
     return this;
   },
@@ -1162,9 +1164,12 @@ SC.Observable = /** @scope SC.Observable.prototype */ {
     return observers ? observers.getMembers() : [];
   },
 
-  // this private method actually notifies the observers for any keys in the
-  // observer queue.  If you pass a key it will be added to the queue.
+  /** @private
+    This private method actually notifies the observers for any keys in the observer queue.  If you
+    pass a key it will be added to the queue.
+  */
   _notifyPropertyObservers: function (key) {
+    // Ensure that this object has been initialized.
     if (!this._observableInited) this.initObservable();
 
     SC.Observers.flush(this); // hookup as many observers as possible.
@@ -1182,7 +1187,7 @@ SC.Observable = /** @scope SC.Observable.prototype */ {
     //@endif
 
     // Get any starObservers -- they will be notified of all changes.
-    starObservers =  this['_kvo_observers_*'];
+    starObservers = this['_kvo_observers_*'];
 
     // prevent notifications from being sent until complete
     this._kvo_changeLevel = this._kvo_changeLevel + 1;
@@ -1259,6 +1264,7 @@ SC.Observable = /** @scope SC.Observable.prototype */ {
           // observer, you will not be notified until the next time.)
           members = observers.getMembers();
           membersLength = members.length;
+
           for (memberLoc = 0; memberLoc < membersLength; memberLoc++) {
             member = members[memberLoc];
 
@@ -1297,6 +1303,7 @@ SC.Observable = /** @scope SC.Observable.prototype */ {
               //@if(debug)
               if (log) console.log('%@...firing local observer %@.%@ for key "%@"'.fmt(spaces, this, member, key));
               //@endif
+
               method.call(this, this, key, null, rev);
             }
           }

data/lib/frameworks/sproutcore/frameworks/runtime/protocols/mixin_protocol.js

@@ -0,0 +1,150 @@
+// ==========================================================================
+// Project:   SproutCore Costello - Property Observing Library
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/** @namespace
+  The `SC.ObjectMixinProtocol` protocol defines the properties and methods that you may implement
+  in your mixin objects (i.e. JavaScript Objects passed to SC.Object's `extend` or `create`) in
+  order to access additional functionality when used. They will be used if defined but are not
+  required.
+
+  # What is a Mixin?
+
+  A mixin, in this context, is a simple JavaScript Object that can be used to provide extra
+  functionality to SC.Object subclasses. While you can mix JavaScript Objects into "classes" (i.e.
+  using `SC.mixin(SomeClass)`), this particular protocol only refers to mixins in the context of
+  use with an SC.Object "instance" (i.e. SC.Object.create({ ... })).
+
+  For example, in order to share a method between two different classes of object, we can use a
+  mixin object that both will consume,
+
+      // Common default properties and shared methods which our different classes may consume.
+      MyApp.MyMixin = {
+        a: true,
+
+        aFunc: function () {
+          this.set('a', false);
+        },
+
+        b: [], // SHARED OBJECT!
+
+        c: {} // SHARED OBJECT!
+      };
+
+      // Two different object types, which both need the functionality provided by MyApp.MyMixin.
+      MyApp.ObjectType1 = SC.Object.extend(MyApp.MyMixin);
+      MyApp.ObjectType2 = SC.Object.extend();
+
+      obj1 = MyApp.ObjectType1.create();
+      obj2 = MyApp.ObjectType2.create(MyApp.MyMixin);
+
+      // Some proofs.
+      // 1. The default properties are copied over to the new objects.
+      obj1.get('a'); // true <--
+      obj2.get('a'); // true <--
+
+      // 2. The primitive properties are unique to each object.
+      obj1.set('a', false);
+      obj1.get('a'); // false <--
+      obj2.get('a'); // true <--
+
+      // 3. The methods are copied over to the new objects.
+      obj1.aFunc; // function () { ... } <--
+      obj2.aFunc; // function () { ... } <--
+
+      // 4. The functions/objects are shared between objects.
+      obj1.aFunc === MyApp.MyMixin.aFunc; // true <--
+      obj1.aFunc === obj2.aFunc; // true <--
+      obj1.b === obj2.b; // true <-- !! Beware of modifying this object !!
+      obj1.c === obj2.c; // true <-- !! Beware of modifying this object !!
+
+  In this example, we used a mixin to share functionality between two classes, which is very easily
+  achieved. There is one issue, that has been known to trip up developers, which should be
+  highlighted. If you set default *Objects* (e.g. [] or {}) in a mixin, these same Objects will be
+  shared between all of the mixin's consumers.
+
+  If you want to set a default Object that is unique to each consumer of the mixin, a better
+  practice is to set it in `initMixin()` or to check for its existence the first time it is used
+  and only create it then.
+
+  *Note: Do not mix `SC.ObjectMixinProtocol` into your classes. As a protocol, it exists only for
+  reference sake. You only need define any of the properties or methods listed below in order to use
+  this protocol.*
+*/
+SC.ObjectMixinProtocol = {
+
+  /**
+    This *optional* method is called to further initialize the consumer of the mixin when it is
+    created. When a mixin (i.e. JavaScript Object) is used to extend an `SC.Object` subclass, we may
+    want to perform additional set up of the `SC.Object` instance when it is created according to
+    the needs of the mixin. In order to support this, `SC.Object` will call this method,
+    `initMixin`, *if implemented*, on each mixin in the order that they were added.
+
+    For example, if we use two mixins that both initialize the same value, the last mixin added
+    would win,
+
+        myObject = SC.Object.create(
+          // First mixin.
+          {
+            initMixin: function () {
+              this.set('a', true);
+            }
+          },
+
+          // Second mixin.
+          {
+            initMixin: function () {
+              this.set('a', false);
+            }
+          });
+
+        myObject.get('a'); // false <--
+
+    This was just an example to illustrate the order in which `initMixin` is called. It is rare
+    that mixins will collide with each other, but it is something to bear in mind when making heavy
+    use of mixins.
+
+    Note, that unlike the similar `init()` method of `SC.Object`, you do *not* need to call
+    `sc_super` in `initMixin`.
+  */
+  initMixin: function () {},
+
+  /**
+    This *optional* method is called to further de-initialize the consumer of the mixin when it is
+    destroyed. When a mixin (i.e. JavaScript Object) is used to extend an `SC.Object` subclass, we
+    may want to perform additional teardown of the `SC.Object` instance when it is destroyed
+    according to the needs of the mixin (e.g. to clean up objects that the mixin code initialized
+    and that may otherwise lead to memory leaks). In order to support this, `SC.Object` will call
+    this method, `destroyMixin`, *if implemented*, on each mixin in the order that they were
+    initially added.
+
+    For example, if we use two mixins that both de-initialize the same value, the last mixin added
+    would win,
+
+        myObject = SC.Object.create(
+          // Mixin.
+          {
+            initMixin: function () {
+              // Created extra object for some purpose.
+              this.set('anObject', SC.Object.create());
+            },
+
+            destroyMixin: function () {
+              // Clean up extra object that the mixin is responsible for.
+              var anObject = this.get('anObject');
+              anObject.destroy();
+              this.set('anObject', null);
+            }
+          });
+
+        myObject.get('a'); // false <--
+
+    Note, that unlike the similar `destroy()` method of `SC.Object`, you do *not* need to call
+    `sc_super` in `destroyMixin`.
+  */
+  destroyMixin: function () {}
+
+};

data/lib/frameworks/sproutcore/frameworks/runtime/system/binding.js

@@ -279,11 +279,13 @@ SC.Binding = /** @scope SC.Binding.prototype */{
   beget: function (fromPath) {
     var ret = SC.beget(this);
     ret.parentBinding = this;
-    // Logic gates must be recreated on beget.
-    if (ret._LogicGate) {
-      ret._logicGate = ret._LogicGate.create(ret._logicGateHash);
-      ret = ret.from('logicProperty', ret._logicGate).oneWay();
+
+    // Mix adapters must be recreated on beget.
+    if (ret._MixAdapter) {
+      ret._mixAdapter = ret._MixAdapter.create(ret._mixAdapterHash);
+      ret = ret.from('aggregateProperty', ret._mixAdapter).oneWay();
     }
+
     // Enables duplicate API calls for SC.Binding.beget and SC.Binding.from
     if (fromPath !== undefined) ret = ret.from(fromPath);
     return ret;
@@ -443,7 +445,7 @@ SC.Binding = /** @scope SC.Binding.prototype */{
     }
   },
 
-  /** 
+  /**
     Disconnects the binding instance.  Changes will no longer be relayed.  You
     will not usually need to call this method.
 
@@ -493,12 +495,12 @@ SC.Binding = /** @scope SC.Binding.prototype */{
     // Mark it destroyed.
     this.isDestroyed = YES;
 
-    // Clean up the logic gate, if any. (See logic gate methods.)
-    if (this._logicGate) {
-      this._logicGate.destroy();
-      this._logicGate = null;
-      this._LogicGate = null;
-      this._logicGateHash = null;
+    // Clean up the mix adapter, if any. (See adapter methods.)
+    if (this._mixAdapter) {
+      this._mixAdapter.destroy();
+      this._mixAdapter = null;
+      this._MixAdapter = null;
+      this._mixAdapterHash = null;
     }
 
     // Disconnect the binding.
@@ -861,9 +863,9 @@ SC.Binding = /** @scope SC.Binding.prototype */{
       if (tuple) {
         this._toTarget = tuple[0];
         this._toPropertyKey = tuple[1];
-        // Hook up _logicGate if needed (see logic gate methods).
-        if (this._logicGate) {
-          this._logicGate.set('localObject', this._toTarget);
+        // Hook up _mixAdapter if needed (see adapter methods).
+        if (this._mixAdapter) {
+          this._mixAdapter.set('localObject', this._toTarget);
         }
       }
     }
@@ -949,6 +951,112 @@ SC.Binding = /** @scope SC.Binding.prototype */{
     return binding;
   },
 
+  /**
+    Adds a transform to convert the value to a bool value.  If the value is
+    an array it will return YES if array is not empty.  If the value is a string
+    it will return YES if the string is not empty.
+
+    @param {String} [fromPath]
+    @returns {SC.Binding} this
+  */
+  bool: function (fromPath) {
+    return this.from(fromPath).transform(function (v) {
+      var t = SC.typeOf(v);
+      if (t === SC.T_ERROR) return v;
+      return (t == SC.T_ARRAY) ? (v.length > 0) : (v === '') ? NO : !!v;
+    });
+  },
+
+  /**
+    Adds a transform that will return YES if the value is equal to equalValue, NO otherwise.
+
+      isVisibleBinding: SC.Binding.oneWay("MyApp.someController.title").equalTo(comparisonValue)
+
+    Or:
+
+      isVisibleBinding: SC.Binding.equalTo("MyApp.someController.title", comparisonValue)
+
+    @param {String} fromPath from path or null
+    @param {Object} equalValue the value to compare with
+    @returns {SC.Binding} this
+  */
+  equalTo: function(fromPath, equalValue) {
+    // Normalize arguments.
+    if (equalValue === undefined) {
+      equalValue = fromPath;
+      fromPath = null;
+    }
+
+    return this.from(fromPath).transform(function(value, binding) {
+       return value === equalValue;
+     });
+  },
+
+  /**
+    Adds a transform that will *always* return an integer Number value. Null and undefined values will
+    return 0 while String values will be transformed using the parseInt method (according to the
+    radix) and Boolean values will be 1 or 0 if true or false accordingly. Other edge cases like NaN
+    or other non-Numbers will also return 0.
+
+    Example results:
+
+      * null => 0
+      * undefined => 0
+      * '123' => 123
+      * true => 1
+      * {} => 0
+
+    @param {String} fromPathOrRadix from path or the radix for the parsing or null for 10
+    @param {String} radix the radix for the parsing or null for 10
+    @returns {SC.Binding} this
+  */
+  integer: function (fromPathOrRadix, radix) {
+    // Normalize arguments.
+    if (radix === undefined) {
+      radix = fromPathOrRadix;
+      fromPathOrRadix = null;
+    }
+
+    // Use base 10 by default.
+    if (radix === undefined) radix = 10;
+
+    return this.from(fromPathOrRadix).transform(function (value) {
+
+      // Null or undefined will be converted to 0.
+      if (SC.none(value)) {
+        value = 0;
+
+      // String values will be converted to integer Numbers using parseInt with the given radix.
+      } else if (typeof value === SC.T_STRING) {
+        value = window.parseInt(value, radix);
+
+      // Boolean values will be converted to 0 or 1 accordingly.
+      } else if (typeof value === SC.T_BOOL) {
+        value = value ? 1 : 0;
+      }
+
+      // All other non-Number values will be converted to 0 (this includes bad String parses above).
+      if (typeof value !== SC.T_NUMBER || isNaN(value)) {
+        value = 0;
+      }
+
+      return value;
+    });
+  },
+
+  /**
+    Adds a transform that will return YES if the value is null or undefined, NO otherwise.
+
+    @param {String} [fromPath]
+    @returns {SC.Binding} this
+  */
+  isNull: function (fromPath) {
+    return this.from(fromPath).transform(function (v) {
+      var t = SC.typeOf(v);
+      return (t === SC.T_ERROR) ? v : SC.none(v);
+    });
+  },
+
   /**
     Specifies that the binding should not return error objects.  If the value
     of a binding is an Error object, it will be transformed to a null value
@@ -977,33 +1085,31 @@ SC.Binding = /** @scope SC.Binding.prototype */{
   },
 
   /**
-    Adds a transform to the chain that will allow only single values to pass.
-    This will allow single values, nulls, and error values to pass through.  If
-    you pass an array, it will be mapped as so:
-
-          [] => null
-          [a] => a
-          [a,b,c] => Multiple Placeholder
+    Adds a transform to convert the value to the inverse of a bool value.  This
+    uses the same transform as bool() but inverts it.
 
-    You can pass in an optional multiple placeholder or it will use the
-    default.
+    @param {String} [fromPath]
+    @returns {SC.Binding} this
+  */
+  not: function (fromPath) {
+    return this.from(fromPath).transform(function (v) {
+      var t = SC.typeOf(v);
+      if (t === SC.T_ERROR) return v;
+      return !((t == SC.T_ARRAY) ? (v.length > 0) : (v === '') ? NO : !!v);
+    });
+  },
 
-    Note that this transform will only happen on forwarded valued.  Reverse
-    values are send unchanged.
+  /**
+    Adds a transform that will convert the passed value to an array.  If
+    the value is null or undefined, it will be converted to an empty array.
 
-    @param {String} fromPath from path or null
-    @param {Object} [placeholder] placeholder value.
+    @param {String} [fromPath]
     @returns {SC.Binding} this
   */
-  single: function (fromPath, placeholder) {
-    if (placeholder === undefined) {
-      placeholder = SC.MULTIPLE_PLACEHOLDER;
-    }
-    return this.from(fromPath).transform(function (value, isForward) {
-      if (value && value.isEnumerable) {
-        var len = value.get('length');
-        value = (len > 1) ? placeholder : (len <= 0) ? null : value.firstObject();
-      }
+  multiple: function (fromPath) {
+    return this.from(fromPath).transform(function (value) {
+      /*jshint eqnull:true*/
+      if (!SC.isArray(value)) value = (value == null) ? [] : [value];
       return value;
     });
   },
@@ -1043,150 +1149,355 @@ SC.Binding = /** @scope SC.Binding.prototype */{
   },
 
   /**
-    Adds a transform that will convert the passed value to an array.  If
-    the value is null or undefined, it will be converted to an empty array.
+    Adds a transform to the chain that will allow only single values to pass.
+    This will allow single values, nulls, and error values to pass through.  If
+    you pass an array, it will be mapped as so:
 
-    @param {String} [fromPath]
+          [] => null
+          [a] => a
+          [a,b,c] => Multiple Placeholder
+
+    You can pass in an optional multiple placeholder or it will use the
+    default.
+
+    Note that this transform will only happen on forwarded valued.  Reverse
+    values are send unchanged.
+
+    @param {String} fromPath from path or null
+    @param {Object} [placeholder] placeholder value.
     @returns {SC.Binding} this
   */
-  multiple: function (fromPath) {
-    return this.from(fromPath).transform(function (value) {
-      /*jshint eqnull:true*/
-      if (!SC.isArray(value)) value = (value == null) ? [] : [value];
+  single: function (fromPath, placeholder) {
+    if (placeholder === undefined) {
+      placeholder = SC.MULTIPLE_PLACEHOLDER;
+    }
+    return this.from(fromPath).transform(function (value, isForward) {
+      if (value && value.isEnumerable) {
+        var len = value.get('length');
+        value = (len > 1) ? placeholder : (len <= 0) ? null : value.firstObject();
+      }
       return value;
     });
   },
 
   /**
-    Adds a transform to convert the value to a bool value.  If the value is
-    an array it will return YES if array is not empty.  If the value is a string
-    it will return YES if the string is not empty.
+    Adds a transform that will *always* return a String value. Null and undefined values will return
+    an empty string while all other non-String values will be transformed using the toString method.
 
-    @param {String} [fromPath]
-    @returns {SC.Binding} this
-  */
-  bool: function (fromPath) {
-    return this.from(fromPath).transform(function (v) {
-      var t = SC.typeOf(v);
-      if (t === SC.T_ERROR) return v;
-      return (t == SC.T_ARRAY) ? (v.length > 0) : (v === '') ? NO : !!v;
-    });
-  },
+    Example results:
 
-  /**
-    Adds a transform to convert the value to the inverse of a bool value.  This
-    uses the same transform as bool() but inverts it.
+      * null => ''
+      * undefined => ''
+      * 123 => '123'
+      * true => 'true'
+      * {} => '[object Object]' (i.e. x = {}; return x.toString())
 
-    @param {String} [fromPath]
+    @param {String} fromPath from path or null
     @returns {SC.Binding} this
   */
-  not: function (fromPath) {
-    return this.from(fromPath).transform(function (v) {
-      var t = SC.typeOf(v);
-      if (t === SC.T_ERROR) return v;
-      return !((t == SC.T_ARRAY) ? (v.length > 0) : (v === '') ? NO : !!v);
-    });
-  },
+  string: function (fromPath) {
+    return this.from(fromPath).transform(function (value) {
 
-  /**
-    Adds a transform that will return YES if the value is null or undefined, NO otherwise.
+      // Null or undefined will be converted to an empty string.
+      if (SC.none(value)) {
+        value = '';
 
-    @param {String} [fromPath]
-    @returns {SC.Binding} this
-  */
-  isNull: function (fromPath) {
-    return this.from(fromPath).transform(function (v) {
-      var t = SC.typeOf(v);
-      return (t === SC.T_ERROR) ? v : SC.none(v);
+      // Non-string values will be converted to strings using `toString`.
+      } else if (typeof value !== SC.T_STRING && value.toString) {
+        value = value.toString();
+      }
+
+      return value;
     });
   },
 
-  /* @private Used with the logic gate bindings. */
-  _LogicGateAnd: SC.Object.extend({
-    logicProperty: function () {
-      return (this.get('valueA') && this.get('valueB'));
-    }.property('valueA', 'valueB').cacheable()
-  }),
-
-  /* @private Used with the logic gate bindings. */
-  _LogicGateOr: SC.Object.extend({
-    logicProperty: function () {
-      return (this.get('valueA') || this.get('valueB'));
-    }.property('valueA', 'valueB').cacheable()
-  }),
-
-  /* @private Used by logic gate bindings. */
-  _logicGateBinding: function (gateClass, pathA, pathB) {
+  /* @private Used by mix adapter bindings. */
+  _sc_mixAdapterBinding: function (adapterClass) {
+    var paths = [];
+
+    //@if(debug)
+    // Add some developer support to prevent improper use.
+    if (arguments.length < 3 ) {
+      SC.Logger.warn('Developer Warning: Invalid mix binding, it should have at least two target paths');
+    }
+    //@endif
+
     // If either path is local, remove any * chains and append the localObject path to it.
-    if (pathA.indexOf('*') === 0 || pathA.indexOf('.') === 0) {
-      pathA = pathA.slice(1).replace(/\*/g, '.');
-      pathA = '*localObject.' + pathA;
+    for (var i = 1; i < arguments.length; i++) {
+      var path = arguments[i];
+
+      if (path.indexOf('*') === 0 || path.indexOf('.') === 0) {
+        path = path.slice(1).replace(/\*/g, '.');
+        path = '*localObject.' + path;
+      }
+      paths.push( path );
     }
-    if (pathB.indexOf('*') === 0 || pathB.indexOf('.') === 0) {
-      pathB = pathB.slice(1).replace(/\*/g, '.');
-      pathB = '*localObject.' + pathB;
+
+    // Gets the adapter class and instantiates a nice copy.
+    var adapterHash = {
+      localObject: null,
+    };
+
+    // create the oneWay bindings pointing to the real data sources.
+    // for naming use a hardcoded convention 'value' + index of the property/path.
+    // of course, these properties are internal so we are not concerned by the naming convention
+    for (i = 0; i < paths.length; ++i) {
+      var key = 'value' + i;
+      adapterHash[key + 'Binding'] = SC.Binding.oneWay(paths[i]);
     }
 
-    // Gets the gate class and instantiates a nice copy.
-    var gateHash = {
-        localObject: null,
-        valueABinding: SC.Binding.oneWay(pathA),
-        valueBBinding: SC.Binding.oneWay(pathB)
-      },
-      gate = gateClass.create(gateHash);
+    var adapter = adapterClass.create(adapterHash);
 
     // Creates and populates the return binding.
-    var ret = this.from('logicProperty', gate).oneWay();
-    // This is all needed later on by beget, which must create a new logic gate instance
+    var ret = this.from('aggregateProperty', adapter).oneWay();
+
+    // This is all needed later on by beget, which must create a new adapter instance
     // or risk bad behavior.
-    ret._LogicGate = gateClass;
-    ret._logicGateHash = gateHash;
-    ret._logicGate = gate;
+    ret._MixAdapter = adapterClass;
+    ret._mixAdapterHash = adapterHash;
+    ret._mixAdapter = adapter;
 
     // On our way.
     return ret;
   },
 
+  /** @private */
+  _sc_mixImpl: function(paths, mixFunction) {
+    var len = paths.length,
+        properties = [];
+
+    //@if(debug)
+    // Add some developer support to prevent improper use.
+    if (SC.none(mixFunction) || SC.typeOf(mixFunction) !== SC.T_FUNCTION ) {
+      SC.Logger.error('Developer Error: Invalid mix binding, the last argument must be a function.');
+    }
+    //@endif
+
+    // Create the adapter class that eventually will contain bindings pointing to all values that will be processed
+    // by mixFunction. The effective aggregation is done by another property that depends on all these local properties
+    // and is invalidated whenever they change.
+    // First of all, create the list of the property names that the aggregate property depends on.
+    // The names of these dynamically created properties are matching the pattern
+    // mentioned above (into _sc_mixAdapterBinding): 'value' + index of the property/path
+    for (var i = 0; i < len; ++i) {
+      properties.push('value' + i);
+    }
+
+    // Create a proxy SC.Object which will be bound to the each of the paths and contain a computed
+    // property that will be dependent on all of the bound properties. The computed property will
+    // return the result of the mix function.
+    var adapter = SC.Object.extend({
+      // Use SC.Function.property to be able to pass an array as arguments to .property
+      aggregateProperty: SC.Function.property(function() {
+        // Get an array of current values that will be passed to the mix function.
+        var values = properties.map(function (name) {
+                                      return this.get(name);
+                                    }, this);
+
+        // Call the mixFunction providing an array containing all current source property values.
+        return mixFunction.apply(null, values);
+      }, properties).cacheable()
+    });
+
+    return this._sc_mixAdapterBinding.apply(this, [adapter].concat(paths));
+  },
+
   /**
-    Adds a transform that forwards the logical 'AND' of values at 'pathA' and
-    'pathB' whenever either source changes.  Note that the transform acts strictly
-    as a one-way binding, working only in the direction
+    Adds a transform that returns the logical 'AND' of all the values at the provided paths. This is
+    a quick and useful way to bind a `Boolean` property to two or more other `Boolean` properties.
+
+    For example, imagine that we wanted to only enable a deletion button when an item in a list
+    is selected *and* the current user is allowed to delete items. If these two values are set
+    on controllers respectively at `MyApp.itemsController.hasSelection` and
+    `MyApp.userController.canDelete`. We could do the following,
+
+        deleteButton: SC.ButtonView.design({
+
+          // Action & target for the button.
+          action: 'deleteSelectedItem',
+          target: MyApp.statechart,
 
-      'pathA' AND 'pathB' --> value  (value returned is the result of ('pathA' && 'pathB'))
+          // Whether the list has a selection or not.
+          listHasSelectionBinding: SC.Binding.oneWay('MyApp.itemsController.hasSelection'),
 
-    Usage example where a delete button's 'isEnabled' value is determined by whether
-    something is selected in a list and whether the current user is allowed to delete:
+          // Whether the user can delete items or not.
+          userCanDeleteBinding: SC.Binding.oneWay('MyApp.userController.canDelete'),
 
-      deleteButton: SC.ButtonView.design({
-        isEnabledBinding: SC.Binding.and('MyApp.itemsController.hasSelection', 'MyApp.userController.canDelete')
-      })
+          // Note: Only enable when the list has a selection and the user is allowed!
+          isEnabled: function () {
+            return this.get('listHasSelection') && this.get('userCanDelete');
+          }.property('listHasSelection', 'userCanDelete').cacheable()
 
-    @param {String} pathA The first part of the conditional
-    @param {String} pathB The second part of the conditional
+        })
+
+    However, this would be much simpler to write by using the `and` binding transform like so,
+
+        deleteButton: SC.ButtonView.design({
+
+          // Action & target for the button.
+          action: 'deleteSelectedItem',
+          target: MyApp.statechart,
+
+          // Note: Only enable when the list has a selection and the user is allowed!
+          isEnabledBinding: SC.Binding.and('MyApp.itemsController.hasSelection', 'MyApp.userController.canDelete')
+
+        })
+
+    *Note:* the transform acts strictly as a one-way binding, working only in the one direction.
+
+    @param {String...} the property paths of source values that will be provided to the AND transform.
   */
-  and: function (pathA, pathB) {
-    return this._logicGateBinding(this._LogicGateAnd, pathA, pathB);
+  and: function () {
+    // Fast copy.
+    var len = arguments.length,
+        paths = new Array(len);
+    for (var i = 0; i < len; i++) { paths[i] = arguments[i]; }
+
+    // Create a new mix implementation for the AND function.
+    return this._sc_mixImpl(paths, function() {
+      var result = true;
+
+      for (i = 0; result && (i < arguments.length); i++) { // Bails early if any value is false.
+        result = result && arguments[i];
+      }
+
+      return result;
+    });
   },
 
   /**
-    Adds a transform that forwards the 'OR' of values at 'pathA' and
-    'pathB' whenever either source changes.  Note that the transform acts strictly
-    as a one-way binding, working only in the direction
+    Adds a transform that returns the logical 'OR' of all the values at the provided paths. This is
+    a quick and useful way to bind a `Boolean` property to two or more other `Boolean` properties.
+
+    For example, imagine that we wanted to show a button when one or both of two values are present.
+    If these two values are set on controllers respectively at `MyApp.profileController.hasDisplayName` and
+    `MyApp.profileController.hasFullName`. We could do the following,
+
+        saveButton: SC.ButtonView.design({
+
+          // Action & target for the button.
+          action: 'saveProfile',
+          target: MyApp.statechart,
+
+          // Whether the profile has a displayName or not.
+          profileHasDisplayNameBinding: SC.Binding.oneWay('MyApp.profileController.hasDisplayName'),
+
+          // Whether the profile has a fullName or not.
+          profileHasFullNameBinding: SC.Binding.oneWay('MyApp.profileController.hasFullName'),
 
-      'pathA' OR 'pathB' --> value  (value returned is the result of ('pathA' || 'pathB'))
+          // Note: Only show when the profile has a displayName or a fullName or both!
+          isVisible: function () {
+            return this.get('profileHasDisplayName') || this.get('profileHasFullName');
+          }.property('profileHasDisplayName', 'profileHasFullName').cacheable()
 
-    Usage example where a delete button's 'isEnabled' value is determined by if the
-    content is editable, or if the user has admin rights:
+        })
 
-      deleteButton: SC.ButtonView.design({
-        isEnabledBinding: SC.Binding.or('*content.isEditable', 'MyApp.userController.isAdmin')
-      })
+    However, this would be much simpler to write by using the `or` binding transform like so,
 
-    @param {String} pathA The first part of the conditional
-    @param {String} pathB The second part of the conditional
+        saveButton: SC.ButtonView.design({
+
+          // Action & target for the button.
+          action: 'saveProfile',
+          target: MyApp.statechart,
+
+          // Note: Only show when the profile has a displayName or a fullName or both!
+          isVisibleBinding: SC.Binding.or('MyApp.profileController.hasDisplayName', 'MyApp.profileController.hasFullName')
+
+        })
+
+    *Note:* the transform acts strictly as a one-way binding, working only in the one direction.
+
+    @param {String...} the paths of source values that will be provided to the OR sequence.
   */
-  or: function (pathA, pathB) {
-    return this._logicGateBinding(this._LogicGateOr, pathA, pathB);
+  or: function () {
+    // Fast copy.
+    var len = arguments.length,
+        paths = new Array(len);
+    for (var i = 0; i < len; i++) { paths[i] = arguments[i]; }
+
+    // Create a new mix implementation for the OR function.
+    return this._sc_mixImpl( paths, function() {
+      var result = false;
+      for (i = 0; !result && (i < arguments.length); i++) { // Bails early if any value is true.
+        result = result || arguments[i];
+      }
+
+      return result;
+    });
+  },
+
+  /**
+    Adds a transform that aggregates through a given function the values at the provided paths. The
+    given function is called whenever any of the values are updated. This is a quick way to
+    aggregate multiple properties into a single property value.
+
+    For example, to concatenate two properties 'MyApp.groupController.name' and
+    'MyApp.userController.fullName', we could do the following,
+
+        currentGroupUserLabel: SC.LabelView.extend({
+
+          // The group name (may be null).
+          groupNameBinding: SC.Binding.oneWay('MyApp.groupController.name'),
+
+          // The user full name (may be null).
+          userFullNameBinding: SC.Binding.oneWay('MyApp.userController.fullName'),
+
+          // Ex. Returns one of "", "Selected Group", or "Selected Group: Selected User"
+          value: function () {
+            var groupName = this.get('groupName'),
+                userFullName = this.get('userFullName');
+
+            if (SC.none(userFullName)) {
+              if (SC.none(groupName)) {
+                return ''; // No group and no user.
+              } else {
+                return groupName; // Just a group.
+              }
+            } else {
+              return '%@: %@'.fmt(groupName, userFullName); // Group and user.
+            }
+          }.property('groupName', 'userFullName').cacheable()
+
+        })
+
+    However, this is simpler (ex. 86 fewer characters) to write by using the `mix` binding transform like so,
+
+        currentGroupUserLabel: SC.LabelView.extend({
+
+          // Ex. Returns one of "", "Selected Group", or "Selected Group: Selected User"
+          valueBinding: SC.Binding.mix(
+            'MyApp.groupController.name', // The group name (may be null).
+            'MyApp.userController.fullName', // The user full name (may be null).
+
+            // Aggregate function. The arguments match the bound property values above.
+            function (groupName, userFullName) {
+              if (SC.none(userFullName)) {
+                if (SC.none(groupName)) {
+                  return ''; // No group and no user.
+                } else {
+                  return groupName; // Just a group.
+                }
+              } else {
+                return '%@: %@'.fmt(groupName, userFullName); // Group and user.
+              }
+            })
+
+        })
+
+    *Note:* the number of parameters of `mixFunction` should match the number of paths provided.
+    *Note:* the transform acts strictly as a one-way binding, working only in the one direction.
+
+    @param {String...} the paths of source values that will be provided to the aggregate function.
+    @param {Function} mixFunction the function that aggregates the values
+  */
+  mix: function() {
+    var len = arguments.length - 1,
+        paths = new Array(len);
+
+    // Fast copy. The function is the last argument.
+    for (var i = 0; i < len; i++) { paths[i] = arguments[i]; }
+
+    return this._sc_mixImpl(paths, arguments[len]);
   },
 
   /**
@@ -1231,4 +1542,3 @@ SC.Binding = /** @scope SC.Binding.prototype */{
         SC.binding(path) = SC.Binding.from(path)
 */
 SC.binding = function (path, root) { return SC.Binding.from(path, root); };
-