added @compile #2

jdknezek · 2012-01-27T18:37:04Z

I added a compile function that compiles a Coco template string into a function to be called with a context:

    $ coco -es
    t = '''
      <~! ul
      for v, i of @
        li "#i: #v"
    '''

    f = require \ckup .compile t

    console.log f <[a b c]>

    <ul
    ><li
    >0: a</li><li
    >1: b</li><li
    >2: c</li></ul>

ckup is included with with, and if context isn't specified then it defaults to ckup, so these should all be equivalent:

    console.log ckup.render 'doctype \\html'
    # <!DOCTYPE html>
    console.log ckup.render '@doctype \\html'
    # <!DOCTYPE html>

    console.log ckup.compile('doctype \\html')!
    # <!DOCTYPE html>
    console.log ckup.compile('@doctype \\html')!
    # <!DOCTYPE html>
    console.log ckup.compile('doctype \\html') \context
    # <!DOCTYPE html>

The only incompatibility should be if you combine @ and context:

    console.log ckup.compile('@doctype \\html') \context
    # TypeError: Object context has no method 'doctype'

satyr · 2012-01-28T00:50:14Z

Is this only for replacing this within the template function? I don't think it a good idea if so.

How about simply delegating render arguments to template, and giving the generated function a default parameter?

  render: (template, ...args) ->
    unless typeof template is \function
      template = Function \context,
        'with(this)' + (Coco ? require \coco)compile "#template"
    template.apply me = ^this, args
    me._

jdknezek · 2012-01-29T00:27:04Z

The use case was more for reusable compiled template functions. I really wanted to do something like this:

$.get 'my-template.ck', success: (text) ->
  template = ckup.compile text

  for item in items
    $ '#container' .append template item

It's really just a question of syntax though. Abstracting out the compilation and removing the magic context variable may be a good compromise?

    compile: (template) ->
      template = Function 'with(this)' + (Coco ? require \coco)compile "#template"
      ~>
        template.apply me = ^this, @@
        me._

    render: (template, ...args) ->
      unless typeof template is \function
        template = @compile template
      template.apply me = ^this, args
      me._

with

<-! ul
for v, i of @@0
  li "#i: #v"

instead of

<~! ul
for v, i of @
  li "#i: #v"

I don't consider @@0 as pretty as just @, but it would save having to bind every function. And of course you could leave the first argument as context for the common use case, but I hate introducing magic identifiers.

Edit: Sorry, forgot the binding in compile.

jdknezek · 2012-01-29T00:59:18Z

Forget that idea; @@ gets overwritten in every block, so it has to be a special variable.

    compile: (template) ->
      template = Function \arg,
        'with(this)' + (Coco ? require \coco)compile "#template"
      (arg) ~>
        template.call me = ^this, arg
        me._

    render: (template, arg) ->
      unless typeof template is \function
        template = @compile template
      template.call me = ^this, arg
      me._

Replace arg with whatever name.

jdknezek · 2012-01-29T02:17:41Z

I really don't like the arg approach either, but maybe this is beyond the scope of what you intended for ckup.

I was really looking for the same sort of usage as CoffeeKup but with Coco's beautiful extensions, but both CoffeeKup and ck keep more state and manipulate this to eliminate the need for bound calls. I might mess with it more and open another pull request, but if that's not the direction you'd like to take ckup just let me know.

satyr · 2012-01-29T02:59:33Z

The use case was more for reusable compiled template functions

You should ideally be passing a function for dynamic rendering. (The @-less style isn't very efficient due to with.)

for item of items
  $ '#container' .append ckup.render ->
    @ul ->
      for v, i of item
      @li "#i: #v"

Though I understand the need for compiling to the withed function. It's certainly nicer to omit all those @.

I really don't like the arg approach either, but maybe this is beyond the scope of what you intended for ckup.

Maybe importing the context object into the instance works?

How about:

  render: (template, context) -> @renderer(template) context

  renderer: (template) ->
    template = @compile template unless typeof template is \function
    (context) ~>
      template.call me = ^this <<< context
      me._

  # Compile a template Coco code into a renderer function,
  # enabling `@`-less style using `with`.
  compile: (code) ->
    Function 'with(this)' + (Coco ? require \coco)compile "#code"

Then you'd be able to:

f = require \ckup .renderer '''
  for v, i of list
    li "#i: #v"
'''
f list: <[a b c]>

added @compile

8b52461

jdknezek closed this Jan 29, 2012

satyr added a commit that referenced this pull request Jan 30, 2012

added @Renderer and @compile as per #2

dc9b83c

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

added @compile #2

added @compile #2

jdknezek commented Jan 27, 2012

satyr commented Jan 28, 2012

jdknezek commented Jan 29, 2012

jdknezek commented Jan 29, 2012

jdknezek commented Jan 29, 2012

satyr commented Jan 29, 2012

added @compile #2

added @compile #2

Conversation

jdknezek commented Jan 27, 2012

satyr commented Jan 28, 2012

jdknezek commented Jan 29, 2012

jdknezek commented Jan 29, 2012

jdknezek commented Jan 29, 2012

satyr commented Jan 29, 2012