joosy 1.2.0.alpha.38 → 1.2.0.alpha.41

data/src/joosy/core/joosy.coffee

@@ -91,29 +91,6 @@
       v.toString 16
     .toUpperCase()
 
-  #
-  # Preloads sets of images then runs callback
-  #
-  # @param [Array<String>] images             Images paths
-  # @param [Function] callback                Action to run when every picture was loaded (or triggered an error)
-  #
-  preloadImages: (images, callback) ->
-    unless Object.isArray(images)
-      images = [images]
-    if images.length == 0
-      callback()
-
-    ticks   = images.length
-    result  = []
-    checker = ->
-      if (ticks -= 1) == 0
-        callback?()
-
-    for p in images
-      result.push $('<img/>').load(checker).error(checker).attr('src', p)
-
-    result
-
   #
   # Basic URI builder. Joins base path with params hash
   #

data/src/joosy/core/layout.coffee

@@ -33,6 +33,7 @@ class Joosy.Layout extends Joosy.Module
   @include Joosy.Modules.Filters
 
   @view 'default'
+  @helper 'page'
 
   #
   # Sets the method which will controll the painting preparation proccess.
@@ -116,6 +117,7 @@ class Joosy.Layout extends Joosy.Module
   # @param [Hash] params              List of route params
   #
   constructor: (@params) ->
+    @uid = Joosy.uid()
 
   #
   # @see Joosy.Router.navigate
@@ -157,11 +159,11 @@ class Joosy.Layout extends Joosy.Module
     @__runAfterUnloads()
 
   #
-  # @todo Rename this shit already. We are not going to release having function that marks
-  #   element with UUID called `yield`.
+  # Helpers that outputs container for the page
   #
-  yield: ->
-    @uuid = Joosy.uuid()
+  page: (tag, options={}) ->
+    options.id = @uid
+    Joosy.Helpers.Application.tag tag, options
 
   #
   # Gets layout element.
@@ -169,4 +171,4 @@ class Joosy.Layout extends Joosy.Module
   # @return [jQuery]
   #
   content: ->
-    $("##{@uuid}")
+    $("##{@uid}")

data/src/joosy/core/module.coffee

@@ -52,14 +52,34 @@ class @Joosy.Module
 
     false
 
-  @alias: (method, feature, action) ->
-    chained = "#{method}Without#{feature.camelize()}"
+  #
+  # Allows to override method keeping the previous implementation accessible
+  #
+  # @param [String] method        Name of the method to override
+  # @param [String] feature       Shortcut to use as previous implementation suffix
+  # @param [String] action        Name of new method to use
+  # @param [Function] action      New implementation
+  #
+  @aliasMethodChain: (method, feature, action) ->
+    camelized = feature.charAt(0).toUpperCase() + feature.slice(1)
+    chained = "#{method}Without#{camelized}"
+
+    action = @::[action] unless Object.isFunction(action)
 
     @::[chained] = @::[method]
     @::[method] = action
 
-  @aliasStatic: (method, feature, action) ->
-    chained = "#{method}Without#{feature.camelize()}"
+  #
+  # Allows to override class-level method keeping the previous implementation accessible
+  #
+  # @param [String] method        Name of the method to override
+  # @param [String] feature       Shortcut to use as previous implementation suffix
+  # @param [String] action        Name of new method to use
+  # @param [Function] action      New implementation
+  #
+  @aliasStaticMethodChain: (method, feature, action) ->
+    camelized = feature.charAt(0).toUpperCase() + feature.slice(1)
+    chained = "#{method}Without#{camelized}"
 
     @[chained] = @[method]
     @[method] = action

data/src/joosy/core/modules/container.coffee

@@ -11,41 +11,38 @@ Joosy.Modules.Container =
   eventSplitter: /^(\S+)\s*(.*)$/
 
   included: ->
+    #
+    # Extends elements mapping scheme
+    #
+    # @example
+    #   @mapElements
+    #     'name':       '.selector'
+    #     'name2':      '$name .selector'
+    #     'category':
+    #       'name3':    '.selector'
+    #
     @mapElements = (map) ->
       unless @::hasOwnProperty "__elements"
         @::__elements = Object.clone(@.__super__.__elements) || {}
       Object.merge @::__elements, map
 
+    #
+    # Extends events mapping scheme
+    #
+    # @example
+    #   @mapEvents
+    #     'click':            ($container, event) -> #fires on container
+    #     'click .selector':  ($element, event) -> #fires on .selector
+    #     'click $name':      ($element, event) -> #fires on selector assigned to 'name' element
+    #
     @mapEvents = (map) ->
       unless @::hasOwnProperty "__events"
         @::__events = Object.clone(@.__super__.__events) || {}
       Object.merge @::__events, map
 
-  onRefresh: (callback) ->
-    @__onRefreshes = [] unless @hasOwnProperty "__onRefreshes"
-    @__onRefreshes.push callback
-
   $: (selector) ->
     $(selector, @container)
 
-  #
-  # Rebinds selectors defined in 'elements' hash to object properties
-  #
-  refreshElements: ->
-    if @hasOwnProperty "__onRefreshes"
-      @__onRefreshes.each (callback) => callback.apply @
-      @__onRefreshes = []
-
-  #
-  # Clears old HTML links, set the new HTML from the callback and refreshes elements
-  #
-  # @param [Function] htmlCallback       `() -> String` callback that will generate new HTML
-  #
-  reloadContainer: (htmlCallback) ->
-    @__removeMetamorphs?()
-    @container.html htmlCallback()
-    @refreshElements()
-
   #
   # Fills container with given data removing all events
   #
@@ -88,18 +85,22 @@ Joosy.Modules.Container =
 
     return unless entries
 
-    Object.each entries, (key, value) =>
+    for key,value of entries
       if Object.isObject(value)
         @__assignElements root['$'+key]={}, value
       else
         value = @__extractSelector value
-
-        root['$'+key] = (filter) =>
-          return @$(value) unless filter
-          return @$(value).filter(filter)
-
+        root['$'+key] = @__wrapElement(value)
         root['$'+key].selector = value
 
+  #
+  # Wraps actual element closures. Required to clear context to avoid circular reference
+  #
+  __wrapElement: (value) ->
+    (filter) =>
+      return @$(value) unless filter
+      return @$(value).filter(filter)
+
   #
   # Binds events defined in 'events' to container
   #

data/src/joosy/core/modules/events.coffee

@@ -23,12 +23,17 @@ Joosy.Modules.Events =
       events   = name
       name     = Object.keys(@__oneShotEvents).length.toString()
 
-    events = @__splitEvents events
-    @__validateEvents events
-
-    @__oneShotEvents[name] = [events, callback]
+    @__oneShotEvents[name] = [@__splitEvents(events), callback]
     name
 
+  #
+  # Removes waiter action
+  #
+  # @param [Function] target            Name of waiter to unbind
+  #
+  unwait: (target) ->
+    delete @__oneShotEvents[target]
+
   #
   # Binds action to run each time any of given event was triggered
   #
@@ -45,26 +50,16 @@ Joosy.Modules.Events =
       events   = name
       name     = Object.keys(@__boundEvents).length.toString()
 
-    events = @__splitEvents events
-    @__validateEvents events
-
-    @__boundEvents[name] = [events, callback]
+    @__boundEvents[name] = [@__splitEvents(events), callback]
     name
 
   #
   # Unbinds action from runing on trigger
   #
-  # @param [Function] target            Action to unbind
+  # @param [Function] target            Name of bind to unbind
   #
   unbind: (target) ->
-    needle = undefined
-
-    for name, [events, callback] of @__boundEvents
-      if (Object.isFunction(target) && callback == target) || name == target
-        needle = name
-        break
-
-    delete @__boundEvents[needle] if needle?
+    delete @__boundEvents[target]
 
   #
   # Triggers event for {bind} and {wait}
@@ -73,6 +68,7 @@ Joosy.Modules.Events =
   #
   trigger: (event, data...) ->
     Joosy.Modules.Log.debugAs @, "Event #{event} triggered"
+
     if @__oneShotEvents
       fire = []
       for name, [events, callback] of @__oneShotEvents
@@ -83,6 +79,7 @@ Joosy.Modules.Events =
         callback = @__oneShotEvents[name][1]
         delete @__oneShotEvents[name]
         callback data...
+
     if @__boundEvents
       for name, [events, callback] of @__boundEvents
         if events.any event
@@ -101,75 +98,91 @@ Joosy.Modules.Events =
   # @param [Function] block           Configuration block (see example)
   #
   synchronize: (block) ->
-    context = new Joosy.Events.SynchronizationContext(this)
-    block.call(this, context)
+    context = new Joosy.Events.SynchronizationContext(@)
+    block.call(@, context)
 
     if context.expectations.length == 0
-      context.after.call(this)
+      context.after.call(@)
     else
-      @wait context.expectations, => context.after.call(this)
+      @wait context.expectations, => context.after.call(@)
       context.actions.each (data) =>
-        data[0].call this, =>
+        data[0].call @, =>
           @trigger data[1]
 
   __splitEvents: (events) ->
     if Object.isString events
       if events.isBlank()
-        []
+        events = []
       else
-        events.trim().split /\s+/
-    else
-      events
+        events = events.trim().split /\s+/
 
-  __validateEvents: (events) ->
     unless Object.isArray(events) && events.length > 0
       throw new Error "#{Joosy.Module.__className @}> bind invalid events: #{events}"
 
-
-Joosy.Events = {}
-
-class Joosy.Events.Namespace
-  constructor: (@parent) ->
-    @bindings = []
-
-  bind: (args...) -> @bindings.push @parent.bind(args...)
-  unbind: ->
-    @parent.unbind b for b in @bindings
-    @bindings = []
+    events
 
 #
-# Internal representation of {Joosy.Modules.Events.synchronize} context
+# Additional events helpers and tools
 #
-# @see Joosy.Modules.Events.synchronize
-#
-class Joosy.Events.SynchronizationContext
-  @uid = 0
-
-  constructor: (@parent) ->
-    @expectations = []
-    @actions = []
-
-  #
-  # Internal simple counter to separate given synchronization actions
-  #
-  uid: ->
-    @constructor.uid += 1
-
-  #
-  # Registeres another async function that should be synchronized
-  #
-  # @param [Function] action        `(Function) -> null` to call.
-  #   Should call given function to mark itself complete.
-  #
-  do: (action) ->
-    event = "synchro-#{@uid()}"
-    @expectations.push event
-    @actions.push [action, event]
-
-  #
-  # Registers finalizer: the action that will be called when all do-functions
-  #   marked themselves as complete.
-  #
-  # @param [Function] after       Function to call.
-  #
-  after: (@after) ->
+Joosy.namespace 'Joosy.Events', ->
+  #
+  # Events namespace
+  #
+  # Creates unified collection of bindings to a particular instance
+  # that can be unbinded alltogether
+  #
+  # @example
+  #   namespace = Joosy.Events.Namespace(something)
+  #
+  #   namespace.bind 'event1', ->
+  #   namespace.bind 'event2', ->
+  #   namespace.unbind() # unbinds both bindings
+  #
+  class @Namespace
+    #
+    # @param [Object] @parent         Any instance that can trigger events
+    #
+    constructor: (@parent) ->
+      @bindings = []
+
+    bind: (args...) -> @bindings.push @parent.bind(args...)
+    unbind: ->
+      @parent.unbind b for b in @bindings
+      @bindings = []
+
+  #
+  # Internal representation of {Joosy.Modules.Events.synchronize} context
+  #
+  # @see Joosy.Modules.Events.synchronize
+  #
+  class @SynchronizationContext
+    @uid = 0
+
+    constructor: (@parent) ->
+      @expectations = []
+      @actions = []
+
+    #
+    # Internal simple counter to separate given synchronization actions
+    #
+    uid: ->
+      @constructor.uid += 1
+
+    #
+    # Registeres another async function that should be synchronized
+    #
+    # @param [Function] action        `(Function) -> null` to call.
+    #   Should call given function to mark itself complete.
+    #
+    do: (action) ->
+      event = "synchro-#{@uid()}"
+      @expectations.push event
+      @actions.push [action, event]
+
+    #
+    # Registers finalizer: the action that will be called when all do-functions
+    #   marked themselves as complete.
+    #
+    # @param [Function] after       Function to call.
+    #
+    after: (@after) ->

data/src/joosy/core/modules/filters.coffee

@@ -31,7 +31,9 @@ Joosy.Modules.Filters =
 
 
 ['beforeLoad', 'afterLoad', 'afterUnload'].each (filter) =>
-  Joosy.Modules.Filters["__run#{filter.camelize(true)}s"] = (opts...) ->
+  camelized = filter.charAt(0).toUpperCase() + filter.slice(1);
+
+  Joosy.Modules.Filters["__run#{camelized}s"] = (opts...) ->
     return true unless @["__#{filter}s"]
 
     @["__#{filter}s"].reduce (flag, func) =>

data/src/joosy/core/modules/renderer.coffee

@@ -6,18 +6,15 @@
 # Core DOM rendering mechanics
 #
 # @mixin
-# @todo           Describe this scary thing o_O
 #
 Joosy.Modules.Renderer =
 
   #
-  # Default behavior for non-set renderer (empty template?)
+  # Default behavior for non-set view (empty template?)
   #
-  __renderer: ->
+  __renderDefault: ->
     throw new Error "#{Joosy.Module.__className @constructor} does not have an attached template"
 
-  __helpers: null
-
   #
   # Defines class-level helpers: @view and @helpers
   #
@@ -26,33 +23,69 @@ Joosy.Modules.Renderer =
   #
   included: ->
     @view = (template, options={}) ->
-      if Object.isFunction template
-        @::__renderer = template
-      else
-        @::__renderer = (locals={}) ->
-          if options.dynamic
-            @renderDynamic template, locals
-          else
-            @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
+      @::__renderDefault = (locals={}) ->
+        if options.dynamic
+          @renderDynamic template, locals
+        else
+          @render template, locals
 
+    @helper = (helpers...) ->
+      unless @::hasOwnProperty "__helpers"
+        @::__helpers = @.__super__.__helpers?.clone() || []
+
+      @::__helpers = @::__helpers.add(helpers).unique()
       @::__helpers = @::__helpers.unique()
 
+  #
+  # Renders given template with given locals
+  #
+  # @param [String] template              Name of the template to render using templater
+  # @param [Function] template            `(locals) ->` lambda to use as template
+  # @param [Object] locals                Locals to assign
+  # @param [Object] parentStackPointer    Internal rendering stack pointer
+  #
+  render: (template, locals={}, parentStackPointer=false) ->
+    @__render false, template, locals, parentStackPointer
+
+  #
+  # Dynamically renders given template with given locals
+  #
+  # Whenever any of assigned locals triggers `changed` event, DOM will automatically be refreshed
+  #
+  # @param [String] template              Name of the template to render using templater
+  # @param [Function] template            `(locals) ->` lambda to use as template
+  # @param [Object] locals                Locals to assign
+  # @param [Object] parentStackPointer    Internal rendering stack pointer
+  #
+  renderDynamic: (template, locals={}, parentStackPointer=false) ->
+    @__render true, template, locals, parentStackPointer
+
+  #
+  # Converts all possible `@helper` arguments to the objects available for merge
+  #
+  __assignHelpers: ->
+    return unless @__helpers?
+  
+    unless @hasOwnProperty "__helpers"
+      @__helpers = @__helpers.clone()
+
+    @__helpers.each (helper, i) =>
+      unless Object.isObject(helper)
+        unless @[helper]?
+          throw new Error "Cannot find method '#{helper}' to use as helper"
+
+        @__helpers[i] = {}
+        @__helpers[i][helper] = => @[helper] arguments...
+
+  #
+  # Collects and merges all requested helpers including global scope to one cached object
+  #
   __instantiateHelpers: ->
     unless @__helpersInstance
-      @__helpersInstance = Object.extended Joosy.Helpers.Application
+      @__assignHelpers()
 
-      if @onRefresh
-        @__helpersInstance.onRefresh = (callback) =>
-          @onRefresh callback
+      @__helpersInstance = Object.extended Joosy.Helpers.Application
+      @__helpersInstance.__renderer = @
 
       if @__helpers
         for helper in @__helpers
@@ -60,102 +93,80 @@ Joosy.Modules.Renderer =
 
     @__helpersInstance
 
-  # If we do not have __proto__ available...
-  __proxifyHelpers: (locals) ->
-    if locals.hasOwnProperty '__proto__'
-      locals.__proto__ = @__instantiateHelpers()
-      locals
-    else
-      unless @__helpersProxyInstance
-        @__helpersProxyInstance = (locals) ->
-          Joosy.Module.merge this, locals
-
-        @__helpersProxyInstance.prototype = @__instantiateHelpers()
-
-      new @__helpersProxyInstance locals
-
-  render: (template, locals={}, parentStackPointer=false) ->
-    @__render false, template, locals, parentStackPointer
-
-  renderDynamic: (template, locals={}, parentStackPointer=false) ->
-    @__render true, template, locals, parentStackPointer
+  #
+  # Defines local `@render*` methods with proper stack pointer set
+  #
+  # @param [Object] parentStackPointer        Internal rendering stack pointer
+  #
+  __instantiateRenderers: (parentStackPointer) ->
+    render: (template, locals={}) =>
+      @render template, locals, parentStackPointer
+    renderDynamic: (template, locals={}) =>
+      @renderDynamic template, locals, parentStackPointer
+    renderInline: (locals={}, template) =>
+      @renderDynamic template, locals, parentStackPointer
 
+  #
+  # Actual rendering implementation
+  #
   __render: (dynamic, template, locals={}, parentStackPointer=false) ->
     stack = @__renderingStackChildFor parentStackPointer
 
     stack.template = template
     stack.locals   = locals
 
-    # If template was given as a lambda, parameters should
-    # be passed as a context, not as a argument
-    assignContext = false
-
     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
-      assignContext = true
     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) && Object.extended().constructor != locals.constructor
       throw new Error "#{Joosy.Module.__className @}> locals (maybe @data?) is not a hash"
 
-    renderers =
-      render: (template, locals={}) =>
-        @render template, locals, stack
-      renderDynamic: (template, locals={}) =>
-        @renderDynamic template, locals, stack
-      renderInline: (locals={}, template) =>
-        @renderDynamic template, locals, stack
-
     context = =>
       data = {}
 
       Joosy.Module.merge data, stack.locals
       Joosy.Module.merge data, @__instantiateHelpers(), false
-      Joosy.Module.merge data, renderers
+      Joosy.Module.merge data, @__instantiateRenderers(stack)
       data
 
     result = ->
-      if assignContext
-        template.call(context())
-      else
-        template(context())
+      template(context())
 
     if dynamic
       morph  = Metamorph result()
       update = =>
         if morph.isRemoved()
-          for [object, callback] in morph.__bindings
-            object.unbind callback
+          for [object, binding] in morph.__bindings
+            object.unbind binding
         else
           for child in stack.children
             @__removeMetamorphs child
           stack.children = []
           morph.html result()
-          @refreshElements?()
 
       # This is here to break stack tree and save from
-      # repeating DOM handling
+      # repeating DOM modification
       update = update.debounce 0
 
-      morph.__bindings = []
-
       for key, object of locals
         if locals.hasOwnProperty key
           if object?.bind? && object?.unbind?
-            binding = [object, update]
-            object.bind 'changed', update
+            binding = [object, object.bind('changed', update)]
             stack.metamorphBindings.push binding
-            morph.__bindings.push binding
+
+      morph.__bindings = stack.metamorphBindings
 
       morph.outerHTML()
     else
       result()
 
+  #
+  # Template for the rendering stack node
+  #
   __renderingStackElement: (parent=null) ->
     metamorphBindings: []
     locals: null
@@ -163,6 +174,9 @@ Joosy.Modules.Renderer =
     children: []
     parent: parent
 
+  #
+  # Creates new rendering stack node using given pointer as the parent
+  #
   __renderingStackChildFor: (parentPointer) ->
     if !@__renderingStack
       @__renderingStack = []
@@ -176,6 +190,9 @@ Joosy.Modules.Renderer =
       parentPointer.children.push element
       element
 
+  #
+  # Disables and unbinds all dynamic bindings for the whole rendering stack
+  #
   __removeMetamorphs: (stackPointer=false) ->
     remove = (stackPointer) =>
       if stackPointer?.children