luca 0.8.599 → 0.9.0

data/src/tools/class_browser.coffee

@@ -0,0 +1,39 @@
+# The Class Browser takes a map of your application's source code and the
+# classes it defines and allows you to view and even edit the source code
+# for a given class in the browser.
+
+# We do this by combining the functionality of a Luca CollectionList View
+# which inspects the Luca component registry, and a CodeMirror Editor instance
+# which compiles coffeescript and evaluates it on the fly.  The Luca Framework
+# is capable of updating all of the application components with the changes
+# you make to their code.
+_.def("Luca.tools.ClassBrowser").extends("Luca.containers.SplitView").with
+
+  name: "class_browser"
+
+  className: "luca-class-browser row"
+
+  layout:["span3","span9"]
+  # Composite views can be made up by specifying a list of components
+  # either as a collection of object configurations, or as a list
+  # of names corresponding to component types.  The various types of
+  # Luca containers will handle rendering these components and arranging
+  # them visually
+  components:["class_browser_list","class_browser_detail"]
+
+  # The container is responsible for handling communication between components.
+  # We provide a nice API for this via the @componentEvents property.
+  componentEvents:
+    "class_browser_list component:loaded" : "loadSourceCode"
+
+  bottomToolbar:
+    buttons:[
+      label: "Add New"
+      icon: "plus"
+      color: "primary"
+      white: true
+      align: 'right'
+    ]
+
+  loadSourceCode: (model, response)->
+    Luca("class_browser_detail").loadComponent( model )

data/src/tools/code_editor.coffee

@@ -0,0 +1,258 @@
+BuffersModel = Luca.Model.extend
+  defaults:
+    _current: "default"
+    _namespace: "default"
+    _compiled: []
+
+  initialize: (@attributes={})->
+    Luca.Model::initialize.apply(@, arguments)
+    @fetch(silent:true)
+
+  requireCompilation: ()->
+    @get("_compiled")
+
+  bufferKeys: ()->
+    return @bufferNames if @bufferNames?
+
+    for key, value of @attributes when !key.match(/_/)
+      key
+
+  namespacedBuffer: (key)->
+    "#{ @get('_namespace') }:#{ key }"
+
+  bufferValues: ()->
+    _( @attributes ).pick( @bufferKeys() )
+
+  fetch: (options={})->
+    options.silent ||= true
+
+    _( @bufferKeys() ).each (key)=>
+      value = localStorage?.getItem( @namespacedBuffer(key) )
+      @set(key, value, silent: options.silent is true) if value?
+
+    @
+
+  persist: ()->
+    _( @bufferKeys() ).each (key)=>
+      value = @get(key)
+      localStorage?.setItem( @namespacedBuffer(key), value)
+
+    @
+
+  currentContent: ()->
+    current = @get("_current")
+    @get(current)
+
+compilers =
+  coffeescript: (code)->
+    CoffeeScript.compile code, bare: true
+  default: (code)->
+    code
+
+_.def("Luca.tools.CodeEditor").extends("Luca.components.Panel").with
+  name: "code_editor"
+
+  id: "editor_container"
+
+  autoBindEventHandlers: true
+
+  bodyClassName: "codemirror-wrapper"
+
+  defaultValue: ''
+
+  compilationEnabled: false
+
+  bufferNamespace: "luca:code"
+
+  namespace: (set, options={})->
+    if set?
+      @bufferNamespace = set
+      @buffers?.set("_namespace", set, silent: (options.silent is true) )
+
+    @bufferNamespace
+
+  initialize: (@options)->
+    @_super("initialize", @, arguments)
+
+    _.bindAll @, "onCompiledCodeChange", "onBufferChange", "onEditorChange", "stripTabs"
+
+    @mode ||= "coffeescript"
+    @theme ||= "monokai"
+    @keyMap ||= "vim"
+    @lineWrapping ||= true
+
+    @compiler = compilers[@mode] || compilers.default
+
+    @setupBuffers()
+
+  setWrap: (@lineWrapping)->
+    @editor.setOption("lineWrapping", @lineWrapping)
+
+  setMode: (@mode)->
+    @editor.setOption("mode", @mode)
+    @
+
+  setKeyMap: (@keyMap)->
+    @editor.setOption("keyMap", @keyMap)
+    @
+
+  setTheme: (@theme)->
+    @editor.setOption("theme",@theme)
+    @
+
+  setupBuffers: ()->
+    attributes = _.extend(@currentBuffers || {},_compiled:@compiledBuffers,_namespace:@namespace())
+    @buffers = new BuffersModel(attributes)
+
+    editor = @
+
+    _( @buffers.bufferKeys() ).each (key)=>
+      @buffers.bind "change:#{ key }", ()=>
+        @onBufferChange.apply(@, arguments)
+
+    _( @buffers.requireCompilation() ).each (key)=>
+      @buffers.bind "change:compiled_#{ key }", @onCompiledCodeChange
+
+    # handle switching of the buffers.  when the editor
+    # is told to switch buffers, we will get the current content
+    # in that buffer, and update the code mirror instance
+    @buffers.bind "change:_current", (model,value)=>
+      editor.trigger "buffer:change"
+      editor.editor.setValue( @buffers.currentContent() || "" )
+
+    @monitorChanges = true
+
+  currentBuffer: ()->
+    @buffers.get("_current")
+
+  loadBuffer: (bufferName, autoSave=true)->
+    @saveBuffer() if autoSave
+    @buffers.set("_current", bufferName)
+
+  saveBuffer: ()->
+    localStorage.setItem( @buffers.namespacedBuffer( @currentBuffer() ), @editor.getValue())
+    @buffers.set( @currentBuffer(), @editor.getValue() )
+
+  getBuffer: (buffer, compiled=false)->
+    buffer ||= @currentBuffer()
+    code = @buffers.get( buffer )
+
+    return code unless compiled is true
+
+    compiledCode = @buffers.get("compiled_#{ buffer }")
+
+    if _.string.isBlank(compiledCode)
+      compiledCode = @compileCode(code, buffer)
+
+    return compiledCode
+
+  editorOptions: ()->
+    mode: @mode
+    theme: @theme
+    keyMap: @keyMap
+    lineNumbers: true
+    gutter: true
+    autofocus: true
+    onChange: @onEditorChange
+    onKeyEvent: @stripTabs
+    passDelay: 50
+    autoClearEmptyLines: true
+    smartIndent: false
+    tabSize: 2
+    electricChars: false
+
+
+  beforeRender: ()->
+    Luca.components.Panel::beforeRender?.apply(@, arguments)
+
+    styles =
+      "min-height": @minHeight
+      background:'#272822'
+      color:'#f8f8f2'
+
+    @$bodyEl().css(styles)
+
+    @$html "<textarea></textarea>"
+
+  afterRender: ()->
+    _.defer ()=>
+      @editor = window.CodeMirror.fromTextArea( @$('textarea')[0], @editorOptions())
+      @restore()
+      @enableTabStripping = true
+
+  save: ()->
+    @saveBuffer()
+
+  restore: ()->
+    @editor.setValue("")
+    @editor.refresh()
+
+  replaceTabWithSpace: ()->
+
+  stripTabs: (editor, keyEvent)->
+    if keyEvent?.keyCode is 9
+      coords = @editor.cursorCoords()
+      cleansed = @getValue().replace(/\t/g,'  ')
+      @setValue(cleansed)
+      @editor.setCursor( coords )
+
+    false
+
+  onEditorChange: ()->
+    if @monitorChanges
+      @save()
+
+  onBufferChange: (model, newValue, changes)->
+    previous = model.previousAttributes()
+
+    _( @buffers.bufferKeys() ).each (key)=>
+      if previous[key] isnt @buffers.get(key)
+
+        if _( @buffers.requireCompilation() ).include(key)
+          result = @compileCode( @buffers.get(key), key )
+          if result.success is true
+            @buffers.persist(key)
+            @buffers.set("compiled_#{ key }", result.compiled, silent: true)
+        else
+          @trigger "code:change:#{ key }", @buffers.get(key)
+          @buffers.persist(key)
+
+    @buffers.change()
+
+  onCompiledCodeChange: (model, newValue, changes)->
+    changedBuffers = _( model.changedAttributes() ).keys()
+    @trigger "code:change", changedBuffers
+    for changed in changedBuffers
+      @trigger "code:change:#{ changed }", changed
+
+  compileCode: (code, buffer)->
+    buffer ||= @currentBuffer()
+    code ||= @getBuffer(buffer, false)
+
+    compiled = ""
+
+    result =
+      success: true
+      compiled: ""
+
+    try
+      compiled = @compiler.call(@, code)
+      @trigger "compile:success", code, compiled
+      result.compiled = compiled
+    catch error
+      @trigger "compile:error", error, code
+      result.success = false
+      result.compiled = @buffers.get("compiled_#{ buffer }")
+
+    result
+
+  getCompiledCode: (buffer)->
+    buffer = @getBuffer(buffer)
+    _.string.strip( @compileCode(buffer) )
+
+  getValue: ()->
+    @editor.getValue()
+
+  setValue: (value)->
+    value = value.replace(/\t/g, '  ')
+    @editor.setValue( value )

data/src/tools/code_mirror_field.coffee

@@ -0,0 +1,57 @@
+defaultOptions =
+  readOnly: false
+  lineNumbers: true
+  gutter: true
+  autofocus: false
+  passDelay: 50
+  autoClearEmptyLines: true
+  smartIndent: false
+  tabSize: 2
+  electricChars: false
+
+Luca.define("Luca.tools.CodeMirrorField").extends("Luca.components.Panel").with
+  bodyClassName: "codemirror-wrapper"
+  preProcessors: []
+  postProcessors: []
+
+  codemirrorOptions: ()->
+    options = _.clone( defaultOptions )
+
+    customOptions =
+      mode: @mode || "coffeescript"
+      theme: @theme || "monokai"
+      keyMap: @keyMap || "basic"
+      lineNumbers: if @lineNumbers? then @lineNumbers else defaultOptions.lineNumbers
+      readOnly: if @readOnly? then @readOnly else defaultOptions.readOnly
+      gutter: if @gutter? then @gutter else defaultOptions.gutter
+      lineWrapping: @lineWrapping is true
+      onChange: ()=>
+        @trigger "editor:change", @
+        @onEditorChange?.call(@)
+
+    customOptions.onKeyEvent = _.bind(@onKeyEvent,@) if @onKeyEvent?
+
+    _.extend(options, customOptions)
+
+  getCodeMirror: ()->
+    @instance
+
+  getValue: (processed=true)->
+    value = @getCodeMirror().getValue()
+
+  setValue: (value="", processed=true)->
+    @getCodeMirror().setValue( value )
+
+  afterRender: ()->
+    @instance = CodeMirror( @$bodyEl()[0], @codemirrorOptions() )
+    @setMaxHeight()
+    @setHeight()
+
+  setMaxHeight: (maxHeight=undefined, grow=true)->
+    maxHeight ||= @maxHeight
+    return unless maxHeight?
+    @$('.CodeMirror-scroll').css('max-height', maxHeight)
+    @$('.CodeMirror-scroll').css('height', maxHeight) if grow is true
+
+  setHeight: (height=undefined)->
+    @$('.CodeMirror-scroll').css('height', height) if height?

data/src/tools/coffee_script_editor.coffee

@@ -0,0 +1,60 @@
+_.def("Luca.tools.CoffeeEditor").extends("Luca.tools.CodeMirrorField").with
+  name : "coffeescript_editor"
+
+  compileOptions:
+    bare: true
+
+  hooks:[
+    "editor:change"
+  ]
+
+  initialize: (@options)->
+    Luca.tools.CodeMirrorField::initialize.apply(@, arguments)
+
+    _.bindAll(@, "editorChange")
+
+    editor = @
+
+    @state = new Luca.Model
+      currentMode: "coffeescript"
+      coffeescript:""
+      javascript:""
+
+    @state.bind "change:coffeescript", (model)->
+      editor.trigger("change:coffeescript")
+      code = model.get("coffeescript")
+
+      editor.compile code, (compiled)->
+        model.set('javascript',compiled)
+
+    @state.bind "change:javascript", (model)->
+      editor.onJavascriptChange?.call(editor, model.get('javascript') )
+
+  compile: (code, callback)->
+    response = {}
+    code ||= @getValue()
+
+    try
+      compiled = CoffeeScript.compile(code, @compileOptions)
+      callback?.call(@, compiled)
+      response =
+        success: true
+        compiled: compiled
+    catch error
+      @trigger("compile:error", error, code)
+
+      response =
+        success: false
+        compiled: ''
+        message: error.message
+
+  currentMode: ()->
+    @state.get("currentMode")
+
+  fixTabs: ()->
+    value = @getValue(false)
+    debugger
+
+  editorChange: ()->
+    @fixTabs()
+    @state.set( @currentMode(), @getValue() )

data/src/tools/collection_inspector.coffee

@@ -0,0 +1,4 @@
+_.def("Luca.tools.CollectionInspector").extends("Luca.View").with
+  name: "collection_inspector"
+
+  className: "collection-inspector"