ende 0.4.24 → 0.4.25

data/lib/assets/javascripts/aura/extensions/stamps.js.coffee

@@ -0,0 +1,35 @@
+'use strict'
+
+define 'aura/extensions/stamps', ->
+
+
+  name: 'stamps'
+
+  version: '0.1.0'
+
+  require:
+    paths:
+      stampit: 'aura/extensions/stamps/stampit'
+
+  initialize: (application) ->
+    {sandbox, core} = application
+    stampit = require 'stampit'
+
+    core.stamps = {}
+
+    # TODO store stamps on a sandbox basis too
+    sandbox.stamp = core.stamp = stampit.mixIn (name, params...) ->
+      unless typeof name == 'string'
+        params.unshift name
+        name = null
+
+      stamp = stampit.apply stampit, params
+
+      if name then core.stamps[name] = stamp else stamp
+
+    , stampit
+
+
+
+
+

data/lib/assets/javascripts/aura/extensions/states.js.coffee

@@ -136,31 +136,33 @@ define 'aura/extensions/states', ['states'], (states) ->
 
         get: -> state.current
 
-    afterAppStart: (application) ->
-      # TODO Change the application to default state in flows extension
-      if (application.startOptions.widgets)
+      # TODO clearer startup sequence
+      application.core.metabolize = (root) ->
+        # If any initialized flow changed the application state
+        # before the widgets initialization, store its state pass
+        # through the default state and go back to the old state
+        # created by the flows
+        #
+        # TODO initialize the first flow in flows extension
+        current_state = application.state if application.state != 'initialization'
+        application.startOptions.widgets ||= root
         application.state = "default"
-      else
-        application.core.metabolize = ->
-          # If any initialized flow changed the application state
-          # before the widgets initialization, store its state pass
-          # through the default state and go back to the old state
-          # created by the flows
-          #
-          # TODO initialize the first flow in flows extension
-          current_state = application.state if application.state != 'initialization'
-          application.state = "default"
-
-          startup = application.core.start.apply @, arguments
-
-          # TODO move to domain extension
-          # TODO let this code more legible
-          domain_flow = application.domain.default
-          domain_flow?.ready ||= injection.then((widgets...) ->
-            # TODO use es6-shim promises
-            $.Deferred().resolveWith domain_flow, widgets
-          ).done
 
-          application.state = current_state if current_state?
+        startup = application.core.start arguments...
 
-          startup
+        # TODO move to domain extension
+        # TODO let this code more legible
+        domain_flow = application.domain.default
+        domain_flow?.ready ||= injection.then((widgets...) ->
+          # TODO use es6-shim promises
+          $.Deferred().resolveWith domain_flow, widgets
+        ).done
+
+        application.state = current_state if current_state?
+
+        startup
+
+
+    afterAppStart: (application) ->
+      # TODO Change the application to default state in flows extension
+      application.state = "default" if application.startOptions.widgets

data/lib/assets/javascripts/aura/extensions/widget/composable.js.coffee

@@ -0,0 +1,152 @@
+'use strict';
+
+define 'aura/extensions/widget/composable', ->
+  stamp = extend = null
+
+  advisorable = (advisor) ->
+    # TODO merge advices in the composition chain
+    advice_names = ['before', 'after', 'around']
+
+    extract_advices = (object) ->
+      found = []
+      for key of object when key.indexOf('_') isnt -1
+        [name, adviced] = key.split '_'
+
+        if advice_names.indexOf(name) != -1
+          callbacks = if object[key].length then object[key] else [object[key]]
+
+          delete object[key]
+
+          found.push
+            key: key
+            name: name
+            adviced: adviced
+            callbacks: callbacks
+
+      found
+
+    advisor.advice = (widget) ->
+
+      advices = extract_advices widget
+
+      for advice in advices
+
+        # in order to preserve declaration order, we must reverse the callbacks order
+        # TODO rename advice.name to advice.type
+        advice.callbacks.reverse() if advice.name == 'before'
+
+        # Advice with all callbacks
+        widget[advice.name] advice.adviced, callback for callback in advice.callbacks
+
+      widget
+
+    advisor.advisable = (factory) ->
+      original = factory.compose
+
+      compose_advices = (advices, composed_advices = {}) ->
+        for advice in advices
+          composed_advices[advice.key] ||= []
+          composed_advices[advice.key] = composed_advices[advice.key].concat advice.callbacks
+
+        composed_advices
+
+      composable_advices  = (stamps...) ->
+        advices = []
+        for stamped in stamps
+          {fixed: {methods: stamp_methods}} = stamped
+          advices = advices.concat extract_advices stamp_methods
+
+        # Create a ultimate stamp with all advices arrays or functions
+        # merged, that will ultimatly override the prototype chain
+        # definitions
+        #
+        # TODO do not store advices definitions in the prototype chain
+        stamps.push stamp compose_advices advices
+
+        stamps
+
+      # Move current factory composition advices to a composable form
+      # {fixed: {methods: composition_methods}} = factory.composition
+      # compose_advices extract_advices(composition_methods), composition_methods
+
+      stamp.mixIn factory,
+        compose: (stamps...) ->
+          stamps.unshift factory.composition
+          original.apply factory, composable_advices stamps...
+
+        advice: advisor.advice
+
+
+    composable = advisor.composable
+    advisor.composable = ->
+      advisor.advisable composable.apply advisor, arguments
+
+    advisor
+
+  composerable = (compositor) ->
+    compositor.composable  = (methods, state, enclose) ->
+      factory = (options) ->
+
+        # Inherit defaults from widget
+        options = _.defaults options, factory.composition.fixed.methods.options
+
+        # Composition only will compose methods and state!
+        instance = factory.composition options: options
+        enclose.call instance, options
+
+      # TODO check if it is needed to inherit compositions
+      # if methods.composition
+      #   composition = methods.composition
+      #   delete methods.composition
+      #   composition = stamp.compose composition, stamp methods, state
+      # else
+      #   composition = stamp methods, state
+
+      stamp.mixIn factory,
+        composition: stamp methods, state
+        # Suport an extension with multiple compositions
+        compose: -> @composition = stamp.compose @composition, arguments...
+
+        extend: ->
+          `var methods, state`
+          {fixed}      = @composition
+          initializers = [enclose]
+          methods      = {}
+          state        = {}
+
+          for definition in arguments
+            {methods: definition_methods, state: definition_state} = definition
+
+            methods = extend methods, fixed.methods, definition_methods or definition
+            state   = extend state  , fixed.state  , definition_state
+
+            initializers = initializers.concat fixed.enclose      if fixed.enclose
+            initializers = initializers.concat definition.enclose if definition.enclose
+
+          enclosed = (properties) ->
+            initializers.forEach (initializer) => initializer.call @, properties
+            @
+
+          compositor.composable methods, state, enclosed or enclose
+
+    compositor
+
+  version: '0.1.2'
+
+  initialize: (application) ->
+    advisable = require 'advisable'
+
+    {core: {Widgets, util: {extend}, stamp}} = application
+
+    Widgets = advisorable composerable Widgets
+
+    # THINK how to at the same time respect aura ways of instantiating
+    # widgets and preserve widget logic composability
+    Widgets.Default = Widgets.Base
+    delete Widgets.Default.extend
+
+    Widgets.Base    = Widgets.advisable Widgets.composable advisable(Widgets.Default.prototype), null, (options) ->
+      Object.defineProperty @, 'constructor', value: Widgets.Default, enumerable: false, configurable: false, writable: false
+      Widgets.Default.call Widgets.advice(@), options
+
+

data/lib/assets/javascripts/aura/extensions/widget/eventable.js.coffee

@@ -1,6 +1,6 @@
 'use strict';
 
-define 'aura/extensions/widget/eventable', ['es6-map-shim'], ->
+define 'aura/extensions/widget/eventable', ['stampit', 'es6-map-shim'], (stampit) ->
 
   extractor = /.*?\$(.*?)@(.*?)\+(.*?)/
 
@@ -24,44 +24,39 @@ define 'aura/extensions/widget/eventable', ['es6-map-shim'], ->
       event.preventDefault()
       false
 
-  eventable =
-    # TODO pass this extensions to the identifiable extension
-    # TODO use widget.extend with the constructor property
-    constructor: (options) ->
-      matches     = extractor.exec options._ref
-      @name       = matches[1]
-      @identifier = options.identifier or options.resource or matches[2]
+  eventable = stampit
+    # TODO implement rivets compatibility, instead of generic
+    # binding events, alter html
+    handles: (event_name, widget_event_name = event_name, selector = @$el) ->
+      unless @name
+        message  = "Widget name must be provided in order to use handlers, but this.name is '#{@name}' \n"
+        message += "Also you may have forgotten to set the type of your widget to 'Base'"
+        throw new TypeError message
 
-      eventable.super.constructor.call @, options
+      context = @$el unless selector == @$el
 
-      @sandbox.identifier = @identifier
+      event_name = translations.get(event_name) ? event_name
 
-      @
+      @sandbox.dom.find(selector, context).on event_name, create_handler(@, widget_event_name || event_name)
 
+    before_initialize: ->
+      matches     = extractor.exec @options._ref
+      @name       = matches[1]
+      @identifier = @options.identifier or @options.resource or matches[2]
+      @sandbox.identifier = @identifier
 
   version: '0.1.0'
 
   initialize: (application) ->
-    with_component = 'segmentio-extend'
-    extend  = require with_component
+    application.core.Widgets.Base.compose eventable
 
-    Widgets = application.core.Widgets
+    {core: {mediator}} = application
+    application.sandbox.startListening = ->
+      # TODO @listening = true
+      mediator.on event.name, event.callback for event in @_events
 
-    extend Widgets.Base.prototype,
-    # TODO implement rivets compatibility, instead of generic
-    # binding events, alter html
-      handles: (event_name, widget_event_name = event_name, selector = @$el) ->
-        unless @name
-          message = "Widget name must be provided in order to use handlers, but this.name is '#{@name}' \n"
-          message = "Also you may have forgotten to set the type of your widget to 'Base'"
-          throw message
+      true
 
-        context = @$el unless selector == @$el
 
-        event_name = translations.get(event_name) ? event_name
 
-        @sandbox.dom.find(selector, context).on event_name, create_handler(@, widget_event_name || event_name)
 
-    # TODO replace Base.extend inheritance to stampit composition
-    Widgets.Base = Widgets.Base.extend eventable
-    eventable.super = Widgets.Base.__super__

data/lib/assets/javascripts/aura/extensions/widget/flowable.js.coffee

@@ -0,0 +1,65 @@
+'use strict'
+
+define 'aura/extensions/widget/flowable', ->
+
+  # The purpose of this extension is have a formalized widget type to
+  # put domain comunication logic between other widgets
+  (application) ->
+
+    instantiation =
+      composite_with: ->
+
+        stampit  = require 'stampit/stampit'
+
+        # TODO Move each composable to its file
+        eventable  = stampit().enclose ->
+          @on       = @sandbox.on
+          @off      = @sandbox.off
+          @once     = @sandbox.once
+          @many     = @sandbox.many
+          @emit     = @sandbox.emit
+          @unlisten = @sandbox.removeAllListeners
+
+          @
+
+        filterable = stampit()
+
+        routeable  = stampit()
+
+        stateable  = stampit(transit: (state) -> application.state = state).enclose ->
+          Object.defineProperty @, 'state',
+            set: @transit
+            get: -> application.state
+            configurable: false
+
+          @stateless()
+
+        elementless = stampit ->
+          marker  = " #{@name}.#{@identifier} flow "
+          node    = document.createComment marker
+          @$el.replaceWith node
+          @$el    = $ node
+
+        stampit.compose filterable, routeable, eventable, stateable, elementless
+
+      create_widget_type: (flowable, application) ->
+        {core: {Widgets}}   = application
+
+        Widgets.Flow  = Widgets.composable Widgets.Default.prototype, null, (options) -> Widgets.Default.call @, options
+        Widgets.Flow.compose flowable
+
+    version: '0.1.0'
+
+    initialize: (application) ->
+      flowable = instantiation.composite_with application
+      instantiation.create_widget_type flowable, application
+
+    afterAppStart: (application) ->
+      application.components.addSource 'flow', 'flows'
+
+
+
+
+
+
+

data/lib/assets/javascripts/aura/extensions/widget/lifecycleable.js.coffee

@@ -6,8 +6,12 @@ define 'aura/extensions/widget/lifecycleable', ->
   with_component = 'jquery'
   jQuery         = require with_component
 
+  with_component = 'stampit/stampit'
+  stampit        = require with_component
+
   core           = null
 
+  # TODO transform into a composable
   lifecycleable =
     injection: (definition) ->
       options           = definition.options
@@ -50,7 +54,7 @@ define 'aura/extensions/widget/lifecycleable', ->
       options.require.packages.push name: options.ref, location: widgetsPath + "/" + widgetName
       options.name  = widgetName
 
-      unless options.el
+      unless options.el?
         options.el  = jQuery '<div class="widget"></div>'
         @root.append options.el
 
@@ -58,24 +62,27 @@ define 'aura/extensions/widget/lifecycleable', ->
 
       definition
 
-  recyclable =
-    constructor: (options) ->
+  recyclable = stampit(
+    inject: (name, options) ->
+      core.inject name, options
+
+    injection: -> lifecycleable.injection arguments...
 
+    before_initialize: ->
       # TODO only listen to this specific sandbox stop
-      @sandbox.on 'aura.sandbox.stop', (sandbox) =>
+      # TODO stop listening when sandbox starts or stops
+      @sandbox.on 'aura.sandbox.stop', (sandbox) ->
         @stopped() if @sandbox.ref == sandbox.ref
+      , @
 
-      @sandbox.on 'aura.sandbox.start', (sandbox) =>
+      @sandbox.on 'aura.sandbox.start', (sandbox) ->
         @started() if @sandbox.ref == sandbox.ref
-
-      recyclable.super.constructor.call @, options
-
-      @initialized()
-
-    inject: (name, options) ->
-      core.inject name, options
+      , @
 
     initialized: ->
+      # TODO think how to access parent widget in children ones
+      @sandbox._widget ||= @
+
       @sandbox.emit "#{@name}.#{@identifier}.initialized", @
 
     started: ->
@@ -85,6 +92,8 @@ define 'aura/extensions/widget/lifecycleable', ->
     stopped: ->
       @$el.remove()
 
+  ).enclose -> @initialized()
+
   (application) ->
 
     version: '0.2.0'
@@ -100,12 +109,19 @@ define 'aura/extensions/widget/lifecycleable', ->
       lifecycleable.sources    = application.config.widgets.sources
       lifecycleable.find       = core.dom.find
 
-      # TODO Keep searching for root until found, and only throw
-      # exception if someone tries to initialize widgets in root
-      # without a valid root selector
-      lifecycleable.root       = core.dom.find app.startOptions.widgets || 'body'
+      Object.defineProperty lifecycleable, 'root',
+        get: ->
+          root = core.dom.find app.startOptions.widgets
+          throw new TypeError "No root node found for selector '#{app.startOptions.widgets}'." unless root.length != 0
+
+          # TODO Cache and override root when found
+          # TODO check how this will integrate with mocha specs
+          # Object.defineProperty lifecycleable, 'root', value: root
+
+          root
+
+        configurable: true
 
-      throw new TypeError "No root node found for selector '#{app.startOptions.widgets}'." unless lifecycleable.root.length != 0
 
       lifecycleable.decamelize = core.util.decamelize
       lifecycleable.capitalize = core.util.capitalize
@@ -141,7 +157,4 @@ define 'aura/extensions/widget/lifecycleable', ->
         params[2] = @ if params.length < 3
         core.inject params...
 
-      # Add support for element removal after stoping widget
-      # TODO replace Base.extend inheritance to stampit composition
-      core.Widgets.Base = core.Widgets.Base.extend recyclable
-      recyclable.super  = core.Widgets.Base.__super__
+      core.Widgets.Base.compose recyclable

data/lib/assets/javascripts/aura/extensions/widget/napable.js.coffee

@@ -1,33 +1,29 @@
-define 'aura/extensions/widget/napable', ->
+'use strict'
 
-  'use strict'
+define 'aura/extensions/widget/napable', ['stampit/stampit'], (stampit) ->
 
-  napable =
-    bind: ->
-      @sandbox.on "#{@name}.#{@identifier}.sleep", napable.sleep, @
-      @sandbox.on "#{@name}.#{@identifier}.wake" , napable.wake , @
+  # TODO think about adding rivets bindings to the element
+  napable = stampit
+    tired: ->
+      @sandbox.on "#{@name}.#{@identifier}.sleep", @sleep, @
+      @sandbox.on "#{@name}.#{@identifier}.wake" , @wake , @
+      @
     sleep: ->
       @$el.addClass 'asleep'
       @$el.removeClass 'awake'
     wake: ->
       @$el.addClass 'awake'
       @$el.removeClass 'asleep'
-
-  napable_extensions =
-    constructor: ->
-      napable_extensions["super"].constructor.apply @, arguments
-      napable.bind.call @
+  ,
+    naping: false
+  , -> @tired()
 
   # The purpose of this extension is allow parent widget to save
   # memory by sending a sleep command to the child widgets
   (application) ->
 
-    version: '0.1.0'
+    version: '0.1.2'
 
     initialize: (application) ->
       {core} = application
-
-      # Add support for element removal after stoping widget
-      # TODO replace Base.extend inheritance to stampit composition
-      core.Widgets.Base = core.Widgets.Base.extend napable_extensions
-      napable_extensions.super  = core.Widgets.Base.__super__
+      core.Widgets.Base.compose napable

data/lib/assets/javascripts/widgets/dialog/main.js.coffee

@@ -165,7 +165,8 @@ define ->
   extract_options: ->
     options =  _.omit @options, 'el', 'ref', '_ref', 'name', 'require', 'baseUrl', 'theme', 'resource'
 
-    dynamic_options = _.omit options, Object.keys(@constructor.__super__.options)
+    # TODO merge default options in prototype
+    dynamic_options = _.omit options, Object.keys(@__proto__.options)
 
     keys = Object.keys dynamic_options
     throw new TypeError "Too many keys on options object! #{keys.join(', ')}" unless keys.length == 1