joosy 0.1.0.RC1

data/app/assets/javascripts/joosy/core/layout.js.coffee

@@ -0,0 +1,47 @@
+#= require joosy/core/joosy
+#= require joosy/core/modules/module
+#= require joosy/core/modules/log
+#= require joosy/core/modules/events
+#= require joosy/core/modules/container
+#= require joosy/core/modules/renderer
+#= require joosy/core/modules/time_manager
+#= require joosy/core/modules/widgets_manager
+#= require joosy/core/modules/filters
+
+class Joosy.Layout extends Joosy.Module
+  @include Joosy.Modules.Log
+  @include Joosy.Modules.Events
+  @include Joosy.Modules.Container
+  @include Joosy.Modules.Renderer
+  @include Joosy.Modules.TimeManager
+  @include Joosy.Modules.WidgetsManager
+  @include Joosy.Modules.Filters
+
+  @view 'layouts/default'
+
+  @beforePaint: (callback) -> @::__beforePaint = callback
+  @paint: (callback) -> @::__paint = callback
+  @erase: (callback) -> @::__erase = callback
+
+  navigate: (args...) ->
+    Joosy.Router.navigate(args...)
+
+  __renderSection: ->
+    'layouts'
+
+  __load: (@container) ->
+    @refreshElements()
+    @__delegateEvents()
+    @__setupWidgets()
+    @__runAfterLoads()
+
+  __unload: ->
+    @clearTime()
+    @__unloadWidgets()
+    @__runAfterUnloads()
+
+  yield: ->
+    @uuid = Joosy.uuid()
+
+  content: ->
+    $("##{@uuid}")

data/app/assets/javascripts/joosy/core/modules/container.js.coffee

@@ -0,0 +1,59 @@
+Joosy.Modules.Container =
+  events: false
+  elements: false
+
+  eventSplitter: /^(\S+)\s*(.*)$/
+
+  $: (selector) -> $(selector, @container)
+
+  refreshElements: ->
+    @__collectElements().each (key, value) =>
+      @[key] = @$(value)
+
+  swapContainer: (container, data) ->
+    realContainer = container.clone().html(data)
+    container.replaceWith realContainer
+    realContainer
+
+  __collectElements: ->
+    elements = Object.extended(@elements || {})
+
+    klass = this
+    while klass = klass.constructor.__super__
+      elements.merge(klass.elements, false)
+
+    elements
+
+  __collectEvents: ->
+    events = Object.extended(@events || {})
+
+    klass = this
+    while klass = klass.constructor.__super__
+      events.merge(klass.events, false)
+
+    events
+
+  __extractSelector: (selector) ->
+    if r = selector.match(/\$([A-z]+)/)
+      selector = @__collectElements()[r[1]]
+
+    selector
+
+  __delegateEvents: ->
+    module = this
+    events = @__collectEvents()
+
+    events.each (key, method) =>
+      method   = @[method] unless typeof(method) == 'function'
+      callback = (event) -> method.call(module, this, event)
+
+      match      = key.match(@eventSplitter)
+      eventName  = match[1]
+      selector   = @__extractSelector(match[2])
+
+      if selector == ""
+        @container.bind(eventName, callback)
+        Joosy.Modules.Log.debugAs @, "#{eventName} binded on container"
+      else
+        @container.on(eventName, selector, callback)
+        Joosy.Modules.Log.debugAs @, "#{eventName} binded on #{selector}"

data/app/assets/javascripts/joosy/core/modules/events.js.coffee

@@ -0,0 +1,35 @@
+Joosy.Modules.Events =
+  wait: (events, callback) ->
+    events = events.split(/\s+/)
+
+    @__oneShotEvents ||= []
+    @__oneShotEvents.push [events, callback]
+
+  bind: (events, callback) ->
+    events = events.split(/\s+/)
+
+    @__boundEvents ||= []
+    @__boundEvents.push [events, callback]
+
+  unbind: (target) ->
+    for [events, callback], index in @__boundEvents
+      if callback == target
+        @__boundEvents.splice(index, 1)
+        return
+
+  trigger: (event) ->
+    Joosy.Modules.Log.debugAs @, "Event #{event} triggered"
+    if @__oneShotEvents
+      for [events, callback], index in @__oneShotEvents
+        position = events.indexOf(event)
+        events.splice(position, 1) if position >= 0
+
+        if events.length == 0
+          @__oneShotEvents.splice(index, 1)
+
+          callback()
+
+    if @__boundEvents
+      for [ events, callback ] in @__boundEvents
+        if events.has(event)
+          callback()

data/app/assets/javascripts/joosy/core/modules/filters.js.coffee

@@ -0,0 +1,39 @@
+Joosy.Modules.Filters =
+  included: ->
+    @beforeLoad = (callback) ->
+      unless @::hasOwnProperty('__beforeLoads')
+        @::__beforeLoads = [].concat @.__super__.__beforeLoads || []
+      @::__beforeLoads.push callback
+
+    @afterLoad = (callback) ->
+      unless @::hasOwnProperty('__afterLoads')
+        @::__afterLoads = [].concat @.__super__.__afterLoads || []
+      @::__afterLoads.push callback
+
+    @afterUnload = (callback) ->
+      unless @::hasOwnProperty('__afterUnloads')
+        @::__afterUnloads = [].concat @.__super__.__afterUnloads || []
+      @::__afterUnloads.push callback
+
+  __runBeforeLoads: (opts...) ->
+    return true unless @__beforeLoads?.length > 0
+
+    flag = true
+
+    for filter in @__beforeLoads
+      filter = @[filter] unless typeof(filter) is 'function'
+      flag = flag && filter.apply(@, opts)
+
+    return flag
+
+  __runAfterLoads: (opts...) ->
+    if @__afterLoads?
+      for filter in @__afterLoads
+        filter = @[filter] unless typeof(filter) is 'function'
+        filter.apply(@, opts)
+
+  __runAfterUnloads: (opts...) ->
+    if @__afterUnloads?
+      for filter in @__afterUnloads
+        filter = @[filter] unless typeof(filter) is 'function'
+        filter.apply(@, opts)

data/app/assets/javascripts/joosy/core/modules/log.js.coffee

@@ -0,0 +1,15 @@
+Joosy.Modules.Log =
+  log: (args...) ->
+    return if typeof console is 'undefined'
+
+    if console.log.apply?
+      args.unshift "Joosy>"
+      console.log(args...)
+    else
+      console.log(args.first())
+
+  debug: (args...) ->
+    @log(args...) if Joosy.debug
+
+  debugAs: (context, string, args...) ->
+    @debug "#{Joosy.Module.__className__(context) || 'unknown context'}> #{string}", args...

data/app/assets/javascripts/joosy/core/modules/module.js.coffee

@@ -0,0 +1,43 @@
+moduleKeywords = ['included', 'extended']
+
+class Joosy.Module
+  @__namespace__: []
+
+  @__className__ = (klass) ->
+    klass = klass.constructor unless Object.isFunction(klass)
+
+    if klass.name?
+      klass.name
+    else
+      klass.toString().replace(/^function ([a-zA-Z]+)\([\s\S]+/, '$1')
+
+  @hasAncestor = (what, klass) ->
+    return false unless what?
+
+    [ what, klass ] = [ what.prototype, klass.prototype ]
+
+    while what
+      return true if what == klass
+      what = what.constructor?.__super__
+
+    false
+
+  @include: (obj) ->
+    throw new Error 'include(obj) requires obj' unless obj
+
+    Object.extended(obj).each (key, value) =>
+      if key not in moduleKeywords
+        this::[key] = value
+
+    obj.included?.apply(this)
+    this
+
+  @extend: (obj) ->
+    throw new Error 'extend(obj) requires obj' unless obj
+
+    Object.extended(obj).each (key, value) =>
+      if key not in moduleKeywords
+        this[key] = value
+
+    obj.extended?.apply(this)
+    this

data/app/assets/javascripts/joosy/core/modules/renderer.js.coffee

@@ -0,0 +1,116 @@
+#= require_tree ../templaters
+#= require metamorph
+
+Joosy.Modules.Renderer =
+
+  __renderer: ->
+    throw new Error "#{@constructor.name} does not have an attached template"
+
+  __helpers: null
+
+  included: ->
+    @view = (template) ->
+      if Object.isFunction(template)
+        @::__renderer = template
+      else
+        @::__renderer = (locals={}) ->
+          @render(template, locals)
+
+    @helpers = (helpers...) ->
+      @::__helpers ||= []
+      helpers.map (helper) =>
+        module = Joosy.Helpers[helper]
+        unless module
+          throw new Error "Cannot find helper module #{helper}"
+
+        @::__helpers.push module
+
+      @::__helpers = @::__helpers.unique()
+
+  __instantiateHelpers: ->
+    unless @__helpersInstance
+      @__helpersInstance = Object.extended Joosy.Helpers.Application
+
+      @__helpersInstance.render = =>
+        @render(arguments...)
+        
+      @__helpersInstance.widget = (element, widget) =>
+        @widgets ||= {}
+        
+        uuid    = Joosy.uuid()
+        element = document.createElement(element)
+        temp    = document.createElement("div")
+        
+        element.id     = uuid
+        @widgets['#'+uuid] = widget
+
+        temp.appendChild(element)
+        temp.innerHTML
+
+      if @__helpers
+        for helper in @__helpers
+          @__helpersInstance.merge helper
+
+    @__helpersInstance
+
+  # If we do not have __proto__ available...
+  __proxifyHelpers: (locals) ->
+    if locals.hasOwnProperty '__proto__'
+      locals.__proto__ = @__instantiateHelpers()
+
+      locals
+    else
+      unless @__helpersProxyInstance
+        @__helpersProxyInstance = (locals) ->
+          Object.merge(this, locals)
+
+        @__helpersProxyInstance.prototype = @__instantiateHelpers()
+
+      new @__helpersProxyInstance(locals)
+
+  render: (template, locals={}) ->
+    isResource = Joosy.Module.hasAncestor(locals.constructor, Joosy.Resource.Generic)
+    
+    if Object.isString template
+      if @__renderSection?
+        template = Joosy.Application.templater.resolveTemplate @__renderSection(), template, this
+
+      template = Joosy.Application.templater.buildView template
+    else if !Object.isFunction(template)
+      throw new Error "#{Joosy.Module.__className__ @}> template (maybe @view) does not look like a string or lambda"
+
+    if !Object.isObject(locals) && !isResource
+      throw new Error "#{Joosy.Module.__className__ @}> locals (maybe @data?) can only be dumb hash or Resource"
+
+    # Small code dup due to the fact we sometimes 
+    # actually CLONE object when proxying helpers
+    if !isResource
+      locals = @__proxifyHelpers(locals)
+      morph  = Metamorph template(locals)
+      update = => morph.html template(locals)
+    else
+      locals.e = @__proxifyHelpers(locals.e)
+      morph    = Metamorph template(locals.e)
+      update   = => morph.html template(locals.e)
+      
+    # This is here to break stack tree and save from 
+    # repeating DOM handling
+    update = update.debounce(0)
+
+    @__metamorphs ||= []
+
+    if isResource
+      locals.bind 'changed', update
+    else
+      for key, object of locals
+        if locals.hasOwnProperty key
+          if object?.bind? && object?.unbind?
+            object.bind 'changed', update
+            @__metamorphs.push [object, update]
+
+    morph.outerHTML()
+
+  __removeMetamorphs: ->
+    if @__metamorphs
+      for [object, callback] in @__metamorphs
+        object.unbind callback

data/app/assets/javascripts/joosy/core/modules/time_manager.js.coffee

@@ -0,0 +1,25 @@
+Joosy.Modules.TimeManager =
+  setTimeout: (timeout, action) ->
+    @__timeouts ||= []
+
+    timer = window.setTimeout (=> action()), timeout
+    @__timeouts.push timer
+
+    timer
+
+  setInterval: (delay, action) ->
+    @__intervals ||= []
+
+    timer = window.setInterval (=> action()), delay
+    @__intervals.push timer
+
+    timer
+
+  clearTime: ->
+    if @__intervals
+      for entry in @__intervals
+        window.clearInterval entry
+
+    if @__timeouts
+      for entry in @__timeouts
+        window.clearTimeout entry

data/app/assets/javascripts/joosy/core/modules/widgets_manager.js.coffee

@@ -0,0 +1,58 @@
+Joosy.Modules.WidgetsManager =
+  registerWidget: (container, widget) ->
+    if Joosy.Module.hasAncestor(widget, Joosy.Widget)
+      widget = new widget()
+
+    @__activeWidgets ||= []
+    @__activeWidgets.push widget.__load(this, $(container))
+
+    widget
+
+  unregisterWidget: (widget) ->
+    widget.__unload()
+
+    @__activeWidgets.splice(@__activeWidgets.indexOf(widget), 1)
+
+  __collectWidgets: ->
+    widgets = Object.extended(@widgets || {})
+
+    klass = this
+    while klass = klass.constructor.__super__
+      widgets.merge(klass.widgets, false)
+
+    widgets
+
+  __setupWidgets: ->
+    widgets    = @__collectWidgets()
+    registered = Object.extended()
+
+    widgets.each (selector, widget) =>
+      if selector == '$container'
+        activeSelector = @container
+      else
+        if r = selector.match(/\$([A-z_]+)/)
+          selector = @elements[r[1]]
+
+        activeSelector = $(selector, @container)
+
+      registered[selector] = Object.extended()
+
+      activeSelector.each (index, elem) =>
+        if Joosy.Module.hasAncestor(widget, Joosy.Widget)
+          instance = new widget
+        else
+          instance = widget.call this, index
+
+        registered[selector][Joosy.Module.__className__ instance] ||= 0
+        registered[selector][Joosy.Module.__className__ instance]  += 1
+
+        @registerWidget($(elem), instance)
+
+    registered.each (selector, value) =>
+      value.each (widget, count) =>
+        Joosy.Modules.Log.debugAs @, "Widget #{widget} registered at '#{selector}'. Elements: #{count}"
+
+  __unloadWidgets: ->
+    if @__activeWidgets
+      for widget in @__activeWidgets
+        widget.__unload()