joosy 0.1.0.alpha → 1.0.0.RC1

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

@@ -0,0 +1,168 @@
+#= 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
+
+#
+# Base class for all of your Joosy Layouts.
+# @see http://guides.joosy.ws/guides/layouts-pages-and-routing.html
+#
+# @example Sample application layout
+#   class @ApplicationLayout extends Joosy.Layout
+#     @view 'application'
+#
+# @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
+#
+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 'default'
+
+  #
+  # Sets the method which will controll the painting preparation proccess.
+  #
+  # This method will be called right ater previous layout {Joosy.Layout.erase} and in parallel with
+  #   layout data fetching so you can use it to initiate preloader.
+  #
+  # @note Given method will be called with `complete` function as parameter. As soon as your
+  #   preparations are done you should call that function.
+  #
+  # @example Sample before painter
+  #   @beforePaint (complete) ->
+  #     if !@data # checks if parallel fetching finished
+  #       $('preloader').slideDown -> complete()
+  # 
+  #
+  @beforePaint: (callback) ->
+    @::__beforePaint = callback
+    
+  #
+  # Sets the method which will controll the painting proccess.
+  #
+  # This method will be called after fetching, erasing and beforePaint is complete.
+  # It should be used to setup appearance effects of layout.
+  #
+  # @note Given method will be called with `complete` function as parameter. As soon as your
+  #   preparations are done you should call that function.
+  #
+  # @example Sample painter
+  #   @paint (complete) ->
+  #     @container.fadeIn -> complete()
+  #
+  @paint: (callback) ->
+    @::__paint = callback
+
+  #
+  # Sets the method which will controll the erasing proccess.
+  #
+  # Use this method to setup hiding effect.
+  #
+  # @note Given method will be called with `complete` function as parameter. As soon as your
+  #   preparations are done you should call that function.
+  #
+  # @note This method will be caled _before_ unload routines so in theory you can
+  #   access layout data from that. Think twice if you are doing it right though.
+  #
+  # @example Sample eraser
+  #   @erase (complete) ->
+  #     @container.fadeOut -> complete()
+  #
+  @erase: (callback) ->
+    @::__erase = callback
+  
+  #
+  # Sets the method which will controll the data fetching proccess.
+  #
+  # @note Given method will be called with `complete` function as parameter. As soon as your
+  #   preparations are done you should call that function.
+  #
+  # @note You are strongly encouraged to NOT fetch anything with Layout!
+  #   Use {Joosy.Page.fetch}
+  #
+  # @example Basic usage
+  #   @fetch (complete) ->
+  #     $.get '/rumbas', (@data) => complete()
+  #
+  @fetch: (callback) ->
+    @::__fetch = callback
+
+  #
+  # Defaults to `false` to ease beforePaint state check.
+  #
+  data: false
+  
+  #
+  # @param [Hash] params              List of route params
+  #
+  constructor: (@params) ->
+
+  #
+  # @see Joosy.Router.navigate
+  #
+  navigate: (args...) ->
+    Joosy.Router.navigate(args...)
+
+  #
+  # This is required by {Joosy.Modules.Renderer}
+  # Sets the base template dir to app_name/templates/layouts
+  #
+  __renderSection: ->
+    'layouts'
+
+  #
+  # Layout bootstrap proccess.
+  #
+  #   * {Joosy.Modules.Container.refreshElements}
+  #   * {Joosy.Modules.Container.__delegateEvents}
+  #   * {Joosy.Modules.WidgetsManager.__setupWidgets}
+  #
+  __load: (@container) ->
+    @refreshElements()
+    @__delegateEvents()
+    @__setupWidgets()
+    @__runAfterLoads()
+
+  #
+  # Layout destruction proccess.
+  #
+  #   * {Joosy.Modules.TimeManager.__clearTime}
+  #   * {Joosy.Modules.WidgetsManager.__unloadWidgets}
+  #   * {Joosy.Modules.Renderer.__removeMetamorphs}
+  #
+  __unload: ->
+    @__clearTime()
+    @__unloadWidgets()
+    @__removeMetamorphs()
+    @__runAfterUnloads()
+
+  #
+  # @todo Rename this shit already. We are not going to release having function that marks
+  #   element with UUID called `yield`.
+  #
+  yield: ->
+    @uuid = Joosy.uuid()
+
+  #
+  # Gets layout element.
+  #
+  # @return [jQuery]
+  #
+  content: ->
+    $("##{@uuid}")

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

@@ -0,0 +1,124 @@
+#
+# DOM container handling, DOM elements and DOM events bindings
+#
+# @note Requires implementor to contain DOM node at @container propert
+#
+# @mixin
+#
+Joosy.Modules.Container =
+  events: false
+  elements: false
+
+  eventSplitter: /^(\S+)\s*(.*)$/
+
+  onRefresh: (callback) ->
+    @__onRefreshes = [] unless @hasOwnProperty "__onRefreshes"
+    @__onRefreshes.push callback
+
+  $: (selector) ->
+    $(selector, @container)
+
+  #
+  # Rebinds selectors defined in 'elements' hash to object properties
+  #
+  # @example Sample elements
+  #   elements:
+  #     foo: '.foo'
+  #     bar: '.bar'
+  #
+  refreshElements: ->
+    @__collectElements().each (key, value) =>
+      # TODO: Check for possible collisions?
+      @[key] = @$(value)
+
+    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
+  #
+  # @param [jQuery] container       jQuery entity of container to update
+  # @param [String] data            HTML to inject
+  #
+  swapContainer: (container, data) ->
+    container.unbind().off()
+    container.html data
+    container
+
+  #
+  # Gathers 'elements' from current and super classes
+  #
+  __collectElements: ->
+    elements = Object.extended @elements || {}
+
+    klass = this
+    while klass = klass.constructor.__super__
+      Joosy.Module.merge elements, klass.elements, false
+
+    elements
+
+  #
+  # Gathers 'events' from current and super classes
+  #
+  __collectEvents: ->
+    events = Object.extended @events || {}
+
+    klass = this
+    while klass = klass.constructor.__super__
+      Joosy.Module.merge events, klass.events, false
+
+    events
+
+  #
+  # Converts '$...' notation to selector from 'elements'
+  #
+  # @param [String] selector            Selector to convert
+  #
+  __extractSelector: (selector) ->
+    if r = selector.match /\$([A-z]+)/
+      selector = @__collectElements()[r[1]]
+
+    selector
+
+  #
+  # Bings events defined in 'events' to container
+  #
+  # @example Sample events
+  #   events:
+  #     'click': -> # this will raise on container click
+  #     'click .foo': -> # this will raise on .foo click
+  #     'click $foo': -> #this will search for selector of foo element
+  #
+  __delegateEvents: ->
+    module = this
+    events = @__collectEvents()
+
+    events.each (key, method) =>
+      unless Object.isFunction method
+        method = @[method]
+      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 if selector == undefined
+        throw new Error "Unknown element #{match[2]} in #{Joosy.Module.__className @constructor} (maybe typo?)"
+      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,122 @@
+#
+# Basic events implementation
+#
+# @mixin
+#
+Joosy.Modules.Events =
+
+  #
+  # Waits for the list of given events to happen at least once. Then runs callback.
+  #
+  # @param [String] events              List of events to wait for separated by space
+  # @param [Function] callback          Action to run when all events were triggered at least once
+  #
+  wait: (events, callback) ->
+    events = events.split /\s+/ if Object.isString events
+
+    @__oneShotEvents ||= []
+    @__oneShotEvents.push [events, callback]
+
+  #
+  # Binds action to run each time any of given even was triggered
+  #
+  # @param [String] events              List of events separated by space
+  # @param [Function] callback          Action to run on trigger
+  #
+  bind: (events, callback) ->
+    events = events.split /\s+/
+
+    @__boundEvents ||= []
+    @__boundEvents.push [events, callback]
+
+  #
+  # Unbinds action from runing on trigger
+  #
+  # @param [Function] target            Action to unbind
+  #
+  unbind: (target) ->
+    for [events, callback], index in @__boundEvents
+      if callback == target
+        @__boundEvents.splice index, 1
+        return
+
+  #
+  # Triggers event for {bind} and {wait}
+  #
+  # @param [String]           Name of event to trigger
+  #
+  trigger: (event, data...) ->
+    Joosy.Modules.Log.debugAs @, "Event #{event} triggered"
+    if @__oneShotEvents
+      fire = []
+      for [events, callback], index in @__oneShotEvents
+        events.remove event
+        if events.length == 0
+          fire.push index
+      fire.each (index) =>
+        callback = @__oneShotEvents[index][1]
+        @__oneShotEvents.removeAt index
+        callback data...
+    if @__boundEvents
+      for [events, callback] in @__boundEvents
+        if events.has event
+          callback data...
+  
+  #
+  # Runs set of callbacks finializing with result callback
+  #
+  # @example Basic usage
+  #   Joosy.synchronize (context) ->
+  #     contet.do (done) -> done()
+  #     contet.do (done) -> done()
+  #     content.after ->
+  #       console.log 'Success!'
+  #
+  # @param [Function] block           Configuration block (see example)
+  #
+  synchronize: (block) ->
+    context = new Joosy.Modules.Events.SynchronizationContext(this)
+    block.call(this, context)
+    
+    @wait context.expectations, => context.after.call(this)
+
+    context.actions.each (data) =>
+      data[0].call this, =>
+        @trigger data[1]
+        
+#
+# Internal representation of {Joosy.Modules.Events.synchronize} context
+#
+# @see Joosy.Modules.Events.synchronize
+#
+class Joosy.Modules.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) ->

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

@@ -0,0 +1,39 @@
+#
+# Filters registration routines
+#
+# @mixin
+#
+Joosy.Modules.Filters =
+
+  #
+  # Defines static registration routines
+  #
+  # @example Set of methods
+  #   class Test
+  #     @beforeLoad ->  # supposed to run before load and control loading queue
+  #     @afterLoad ->   # supposed to run after load to finalize loading
+  #     @afterUnload -> # supposed to run after unload to collect garbage
+  #
+  #     # private
+  #
+  #     @__runBeforeLoads() # Runs filters registered as beforeLoad
+  #     @__runAfterLoads() # Runs filters registered as afterLoad
+  #     @__runAfterUnloads() # Runs filters registered as afterUnload
+  #
+  included: ->
+    ['beforeLoad', 'afterLoad', 'afterUnload'].each (filter) =>
+      @[filter] = (callback) ->
+        unless @::hasOwnProperty "__#{filter}s"
+          @::["__#{filter}s"] = [].concat @.__super__["__#{filter}s"] || []
+        @::["__#{filter}s"].push callback
+
+
+['beforeLoad', 'afterLoad', 'afterUnload'].each (filter) =>
+  Joosy.Modules.Filters["__run#{filter.camelize(true)}s"] = (opts...) ->
+    return true unless @["__#{filter}s"]
+
+    @["__#{filter}s"].reduce (flag, func) =>
+      unless Object.isFunction func
+        func = @[func]
+      flag && func.apply(@, opts) != false
+    , true

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

@@ -0,0 +1,36 @@
+#
+# Wrappers for console.log
+#
+# @mixin
+#
+Joosy.Modules.Log =
+  
+  #
+  # Checks if console is available and proxies given arguments directly to `console.log`
+  #
+  log: (args...) ->
+    return unless console?
+
+    if console.log.apply?
+      args.unshift "Joosy>"
+      console.log args...
+    else
+      console.log args.first()
+
+  #
+  # Runs `log` if debug is active
+  #
+  debug: (args...) ->
+    return unless Joosy.debug
+    @log args...
+
+  #
+  # Logs given message wrapping it with description of given object (class name)
+  #
+  # @param [Object] context           The class required to be described in log message
+  # @param [String] string            Message to log
+  #
+  debugAs: (context, string, args...) ->
+    return unless Joosy.debug
+    context = Joosy.Module.__className(context) || 'unknown context'
+    @debug "#{context}> #{string}", args...

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

@@ -0,0 +1,117 @@
+moduleKeywords = ['included', 'extended']
+
+#
+# Base Joosy class extending Coffee class with module-like injections 
+#   and other tiny stuff.
+#
+class Joosy.Module
+  #
+  # Sets the default namespace for all Joosy descendants.
+  # This is used in {Joosy.namespace} magic.
+  #
+  @__namespace__: []
+
+  #
+  # Gets Object/Class class name.
+  #
+  # @note Never use this to make some magical auto-suggestions!!!
+  #   Remember: minifcation will rename your classes. Therefore it
+  #   is only intended for development debugging purposes.
+  #
+  # @note Go @jashkenas Go! Give us https://github.com/jashkenas/coffee-script/issues/2052.
+  #   Please go vote for this feature if you are reading this. It will
+  #   give us ability to eleminate a lot of boilerplate for you.
+  #
+  # @return [String]
+  #
+  @__className: (klass) ->
+    unless Object.isFunction(klass)
+      klass = klass.constructor
+
+    if klass.name?
+      klass.name
+    else
+      klass.toString().replace /^function ([a-zA-Z]+)\([\s\S]+/, '$1'
+
+  #
+  # Determines if class A has class B in its ancestors.
+  #
+  # @param [Class] what       Class to check againt
+  # @param [Class] klass      Possible ancestor to search for
+  #
+  # @return [Boolean]
+  #
+  @hasAncestor: (what, klass) ->
+    unless what? && klass?
+      return false
+
+    [what, klass] = [what.prototype, klass.prototype]
+
+    while what
+      if what == klass
+        return true
+      what = what.constructor?.__super__
+
+    false
+
+  @alias: (method, feature, action) ->
+    chained = "#{method}Without#{feature.camelize()}"
+
+    @::[chained] = @::[method]
+    @::[method] = action
+
+  @aliasStatic: (method, feature, action) ->
+    chained = "#{method}Without#{feature.camelize()}"
+
+    @[chained] = @[method]
+    @[method] = action
+    
+  #
+  # Simple and fast shallow merge implementation.
+  #
+  # This is here due to: https://github.com/andrewplummer/Sugar/issues/100.
+  # This bug was closed and we got some performance but this implementation is
+  # still like 10x fater for basic tasks.
+  #
+  # @param [Object] destination       Object to extend
+  # @param [Object] source            Source of new properties
+  # @param [Boolean] unsafe           Determines if we should rewrite destination properties
+  #
+  # @return [Object]                  The new and mighty destination Object
+  #
+  @merge: (destination, source, unsafe=true) ->
+    for key, value of source
+      if source.hasOwnProperty(key)
+        if unsafe || !destination.hasOwnProperty(key)
+          destination[key] = value
+    destination
+
+  #
+  # Mixes given object as dynamic methods
+  #
+  # @param [Object] object          Module object
+  #
+  @include: (object) ->
+    unless object
+      throw new Error 'include(object) requires obj'
+
+    Object.each object, (key, value) =>
+      if key not in moduleKeywords
+        this::[key] = value
+
+    object.included?.apply this
+    null
+
+  #
+  # Mixes given object as static methods
+  #
+  # @param [Object] object          Module object
+  #
+  @extend: (object) ->
+    unless object
+      throw new Error 'extend(object) requires object'
+
+    @merge this, object
+
+    object.extended?.apply this
+    null