class Variable(object):
	def __init__(self, name):
		self.name = name
	def __lshift__(self, value):
		return Assignment(self, value)
	def __str__(self):
		result = self.name
		return result
	def __repr__(self):
		return 'Variable: %s' % self
	def __getattr__(self, name):
		if name.startswith('__') or name.endswith('__'): raise AttributeError
		return Variable('.'.join([self.name, name]))
	def __call__(self, *args):
		return FuncCall(self, *args)

class FuncCall(object):
	def __init__(self, name, *args):
		self.name = str(name)
		self.args = ', '.join(str(x) for x in args)
	def __repr__(self):
		return 'FuncCall: %s(%s)' % (self.name, self.args)
	def __str__(self):
		return '%s(%s)' % (self.name, self.args)


class Expression(object):
	def __init__(self, expr):
		self.expr = expr
	def __repr__(self):
		return 'Expression: %s' % self.expr
	def __rshift__(self, args):
		if not hasattr(args, '__iter__'): args = (args,)
		return self.apply(*args)
	def apply(self, *args):
		return self.expr % args

class Assignment(object):
	template = 'var %s = %s'
	def __init__(self, name, value):
		self.name = name
		self.value = value
	def __repr__(self):
		return 'Assignment: %s, %s' % (self.name, self.value)
	def __str__(self):
		return self.template % (self.name, self.value)

class Return(object):
	template = 'return %s'
	def __init__(self, var):
		self.var = var
	def __str__(self):
		return self.template % self.var
	def __repr__(self):
		return 'Return: %s' % self

class Block(object):
	template = '{\n%s\n}'
	def __init__(self, *lines):
		self.lines = lines
	def __repr__(self): return 'Block: %d lines' % len(self.lines)
	def __str__(self):
		return self.template % ';\n'.join(str(x) for x in self.lines)

class Closure(object):
	template = '''function(%s)'''
	def __init__(self, args, *code):
		self.args = ', '.join(str(x) for x in args)
		self.code = Block(*code)
	def __str__(self):
		out = ['(',
				self.template % self.args,
				str(self.code),
				')'
			]
		return '\n'.join(out)
	def __repr__(self):
		return 'Closure: %s' % (self.template % self.args)
	def __call__(self, *args):
		return FuncCall(self, *args)

class Field(object):
	template = '''%s: %s'''
	def __init__(self, name, closure):
		self.name = name
		self.closure = closure
	def __repr__(self):
		return 'Method: %s' % self.name
	def __str__(self):
		return self.template % (self.name, self.closure)

class Object(object):
	template = '''{\n%s\n}'''
	def __init__(self, *methods):
		self.methods = methods
	def __repr__(self):
		return 'Object at %x: %d methods' % (id(self), len(self.methods))
	def __str__(self):
		methods = ',\n'.join(str(x) for x in self.methods)
		return self.template % methods

widg = Variable('widg')
jq = Variable('$')
this = Variable('this')
arguments = Variable('arguments')
print Closure((jq,),
	widg << jq.widget('"ui.captionator"', Object(
		Field('options', Object()),
		Field('_create', Closure(())),
		Field('destroy', Closure(())),
		Field('_setOption', Closure(('option', 'value'),
			jq.Widget.prototype._setOption.apply( this, arguments )
		))
	)),
	Return(widg)
)('jQuery')