Dynamic computed alias - ember.js

Question

I'm trying to update a component value dynamically from the controller, without explicitly passing the value through the template. The following hard-coded solution works:
foo: Em.computed.oneWay('bar')
however, I'm looking to have something like this:
slab: 'bar',
foo: Em.computed.oneWay(slab)
Its important that the values are bound together, and not just the initial value when the component starts up. Is there a way to do this?

Answer 1

Update January 2015: Coincidentally, I wrote a small addon for this a few days ago in response to an issue in the Ember Github. This addon allows you to have dynamic computed properties. So this would now be your solution:
slab: 'bar',
foo: Ember.computed.indirect('slab')
That will keep the two bound together, so the foo property will always point at whichever property the slab value refers to.
Maybe something like this (taking from your example):
slab: function() {
return mysteryString;
}.property(),
foo: undefined,
_slabObserver: null,
_slabObserverKey: null,
_slabDidChange: function() {
// Remove the old observer
if (this.get('_slabObserverKey')) {
this.removeObserver(this, this.get('_slabObserverKey'), this.get('_slabObserver'));
}
// Create the new one
this.set('_slabObserver', function() {
// Update foo when the value whose key is held by 'slab' changes
this.set('foo', this.get(this.get('slab')));
});
// Watch the property whose key is held by 'slab' and call the method we just created
this.addObserver(this, this.get('slab'), this.get('_slabObserver'));
// Hold the last key so we can remove the observer properly after it changes
this.set('_slabObserverKey', this.get('slab'));
}.property('slab')
To walk through it:
The controller is created and slab is undefined. Something causes slab to change, triggering the _slabDidChange observer. (Note that we use property and not observes on _slabDidChange because the former would cause the function to get called too soon. Source)
_slabDidChange fires. It skips removing the old observer because we haven't created one yet. It then adds a new observer that watches the property held by the slab property. It then stores the key and observer so we can remove them later.
foo is updated whenever the property we observed changes. In your example, anytime bar updates, foo updates.
If slab changes, step 2 repeats, only it removes the old observer first, as to not have conflicting updates to foo.
The idea is that you have to add the observer to the bar property manually. I haven't tested this, but the idea should be clear.

Answer 2

try this:
slab: 'bar',
foo: Em.computed.oneWay(this.slab);

Answer 3

As far as I know, you can only do this with a computed property:
foo: function(key, value) {
var slab = this.get('slab');
if (arguments.length > 1) {
this.set(slab, value);
}
return this.get(slab);
}.property('slab')
For oneWay, you will have to change this.set(slab, value); or just remove the whole if.