Concur

:target: http://travis-ci.org/insin/concur

function inherits(child, parent) {
  function F() {}
  F.prototype = parent.prototype
  child.prototype = new F()
  child.prototype.constructor = child
}

function Widget(attrs) {
  this.attrs = attrs || {}
}

Widget.prototype.isHidden = false

function Input(attrs) {
  Widget.call(this, attrs)
}
inherits(Input, Widget)

Input.prototype.inputType = null

Input.prototype.render = function(name, value) {
  return DOMBuilder.build([
    'input', {type: this.inputType, name: name, value: value}
  ])
}

function TextInput(attrs) {
  Input.call(this, attrs)
}
inherits(TextInput, Input)

TextInput.prototype.inputType = 'text'

var Widget = Concur.extend({
  constructor: function(attrs) {
    this.attrs = attrs || {}
  }
})

Widget.prototype.isHidden = false

var Input = Widget.extend()

Input.prototype.inputType = null

Input.prototype.render = function(name, value) {
  return DOMBuilder.build([
    'input', {type: this.inputType, name: name, value: value}
  ])
}

var TextInput = Input.extend()

TextInput.prototype.inputType = 'text'

var Widget = Concur.extend({
  isHidden: false
, constructor: function(attrs) {
    this.attrs = attrs || {}
  }
})

var Input = Widget.extend({
  inputType: null
, render: function(name, value) {
    return DOMBuilder.build([
      'input', {type: this.inputType, name: name, value: value}
    ])
  }
})

var TextInput = Input.extend({
  inputType: 'text'
)}

Manipulating Prototypes

If a constructor's prototype properties include a dunder-meta property,
then when ``extend()`` is used on that constructor, dunder-meta will be
called with all property-defining objects which were passed in.

This enables you to declare constructors which can modify the prototypes of
constructors inheriting from them, at inheritance time.

Contrived example::

   function NutAllergyProtectionMeta(prototypeProps) {
      var nutIndex = prototypeProps.ingredients.indexOf('nuts')
      if (nutIndex != -1) {
         prototypeProps.ingredients.splice(nutIndex, 1)
      }
   }

   var Bar = Concur.extend({
     __meta__: NutAllergyProtectionMeta
   , eat: function() {
       if (this.ingredients.indexOf('nuts') != -1) {
         console.log('You eat nuts. You die.')
       }
       else {
         console.log('You feel a bit dunder-meta.')
       }
     }
   })

   var NougatBar = Bar.extend({
      ingredients: ['sugar', 'egg whites', 'nuts']
   })

   >>> var snack = new NougatBar()
   >>> snack.eat()
   You feel a bit dunder-meta.

Actual examples:

* Implementing basic Django-style declarative models: `./examples/models.js`_.
* Implementing inheritance of fields from ancestor constructors and mixing in
  fields from other constructors at the same time: `newforms/lib/forms.js`_

.. _`./examples/models.js`: https://github.com/insin/concur/blob/master/examples/models.js
.. _`newforms/lib/forms.js`: https://github.com/insin/newforms/blob/master/lib/forms.js#L891-943

Array, each of its contents will be mixed into that properties object in the
given order.

`Concur.extend([prototypeProps[, constructorProps]])`

• Calling `Concur.extend()` creates a "base" constructor, which inherits

• Calling `extend()` in the context of any other constructor creates a

If provided, this function will be used as the child constructor, otherwise a
new child constructor function will be created for you.

If provided, this function will not be used immediately, but will be called
when further extension is done based on the constructor returned by this call
to ``extend()``.

At that point, ``__meta__`` will be called with the property arguments passed
to ``extend()`` so it can customise them before they're used to set up the
inheriting constructor's prototype.

If provided, the contents of this Array will be mixed in to the properties
object it's set on, in the given order.