Makes it super easy to convert `foo.bar` and `foo.bar = baz` into method calls instead of property lookups!

add_property.js

function add_property(prop_name, default_value) {
  var getter = this['get_' + prop_name] || default_getter(prop_name);
  var setter = this['set_' + prop_name] || default_setter(prop_name);

  Object.defineProperty(this, prop_name, {
    get: getter.bind(this),
    set: setter.bind(this),
    enumerable: true
  });

  this['_' + prop_name] = default_value;
}


function default_getter(prop_name) {
  return function() {
    return this['_' + prop_name];
  }
}


function default_setter(prop_name) {
  return function(val) {
    this['_' + prop_name] = val;
  }
}


exports.add_property = add_property;

add_property_spec.js

var expect = require('chai').expect;

var add_property = require('./property_patch').add_property;


describe("add_property", function() {
  beforeEach(function() {
    this.Foo = function() {
      add_property.call(this, 'bar');
    }
  });


  it("makes it much cleaner to add computed properties to a JS class", function() {
    this.Foo.prototype.get_bar = function() {
      return 'the value is ' + this._bar;
    }

    this.Foo.prototype.set_bar = function(val) {
      this._bar = val > 10 ? 10 : val;
    }

    var f = new this.Foo();
    f.bar = 5;
    expect(f.bar).to.equal('the value is 5');
    f.bar = 20;
    expect(f.bar).to.equal('the value is 10');
  });


  it("provides default getter and setter behavior if you don't supply your own", function() {
    var f = new this.Foo();
    f.bar = 5;
    expect(f.bar).to.equal(5);
  });


  it("accepts an optional default value for a property", function() {
    function Bar() {
      add_property.call(this, 'hey', 3);
    }

    var b = new Bar();
    expect(b.hey).to.equal(3);
  });
});

HEY

Don't use this. This is old. Look over here instead.