ende 0.0.1

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

@@ -0,0 +1,251 @@
+define 'aura/extensions/rivets', ->
+
+  'use strict';
+
+  extend = require 'segmentio-extend'
+
+  rivets = require 'mikeric-rivets/dist/rivets'
+
+  Rivets = rivets._
+
+  observable_configuration = require 'indefinido-observable/lib/adapters/rivets'
+
+  rivets.configure observable_configuration
+  rivets.configure
+    templateDelimiters: ['{{', '}}']
+
+  # Custom rivets view because we don't want to prefix attributes
+  # Rivets.View
+  # -----------
+  # A collection of bindings built from a set of parent nodes.
+  class Rivets.View
+    # The DOM elements and the model objects for binding are passed into the
+    # constructor along with any local options that should be used throughout the
+    # context of the view and it's bindings.
+    constructor: (@els, @models, @options = {}) ->
+      @els = [@els] unless (@els.jquery || @els instanceof Array)
+
+      for option in ['config', 'binders', 'formatters']
+        @[option] = {}
+        @[option][k] = v for k, v of @options[option] if @options[option]
+        @[option][k] ?= v for k, v of Rivets[option]
+
+      @build()
+
+    # Regular expression used to match binding attributes.
+    bindingRegExp: =>
+      prefix = @config.prefix
+      if prefix then new RegExp("^data-#{prefix}-") else /^data-/
+
+    # Regular expression used to match component nodes.
+    componentRegExp: =>
+      new RegExp "^#{@config.prefix?.toUpperCase() ? 'RV'}-"
+
+    # Parses the DOM tree and builds `Rivets.Binding` instances for every matched
+    # binding declaration.
+    build: =>
+      @bindings = []
+      skipNodes = []
+      bindingRegExp = @bindingRegExp()
+      componentRegExp = @componentRegExp()
+
+
+      buildBinding = (binding, node, type, declaration) =>
+        options = {}
+
+        pipes = (pipe.trim() for pipe in declaration.split '|')
+        context = (ctx.trim() for ctx in pipes.shift().split '<')
+        path = context.shift()
+        splitPath = path.split /\.|:/
+        options.formatters = pipes
+        options.bypass = path.indexOf(':') != -1
+
+        if splitPath[0]
+          key = splitPath.shift()
+        else
+          key = null
+          splitPath.shift()
+
+        keypath = splitPath.join '.'
+
+        if dependencies = context.shift()
+          options.dependencies = dependencies.split /\s+/
+
+        if @models[key]
+          @bindings.push new Rivets[binding] @, node, type, key, keypath, options
+        else
+          console.warn "Model with key '#{key}' not found for binding of type '#{type}' on keypath '#{keypath}'.", @
+
+      parse = (node) =>
+        unless node in skipNodes
+          if node.nodeType is Node.TEXT_NODE
+            parser = Rivets.TextTemplateParser
+
+            if delimiters = @config.templateDelimiters
+              if (tokens = parser.parse(node.data, delimiters)).length
+                unless tokens.length is 1 and tokens[0].type is parser.types.text
+                  [startToken, restTokens...] = tokens
+                  node.data = startToken.value
+
+                  if startToken.type is 0
+                    node.data = startToken.value
+                  else
+                    buildBinding 'TextBinding', node, null, startToken.value
+
+                  for token in restTokens
+                    text = document.createTextNode token.value
+                    node.parentNode.appendChild text
+
+                    if token.type is 1
+                      buildBinding 'TextBinding', text, null, token.value
+          else if componentRegExp.test node.tagName
+            type = node.tagName.replace(componentRegExp, '').toLowerCase()
+            @bindings.push new Rivets.ComponentBinding @, node, type
+
+          else if node.attributes?
+            for attribute in node.attributes
+              if bindingRegExp.test attribute.name
+                type = attribute.name.replace bindingRegExp, ''
+                unless binder = @binders[type]
+                  for identifier, value of @binders
+                    if identifier isnt '*' and identifier.indexOf('*') isnt -1
+                      regexp = new RegExp "^#{identifier.replace('*', '.+')}$"
+                      if regexp.test type
+                        binder = value
+
+                binder or= @binders['*']
+
+                if binder.block
+                  skipNodes.push n for n in node.childNodes
+                  attributes = [attribute]
+
+            for attribute in attributes or node.attributes
+              if bindingRegExp.test attribute.name
+                type = attribute.name.replace bindingRegExp, ''
+                buildBinding 'Binding', node, type, attribute.value
+
+          parse childNode for childNode in node.childNodes
+
+      parse el for el in @els
+
+      return
+
+    # Returns an array of bindings where the supplied function evaluates to true.
+    select: (fn) =>
+      binding for binding in @bindings when fn binding
+
+    # Binds all of the current bindings for this view.
+    bind: =>
+      binding.bind() for binding in @bindings
+
+    # Unbinds all of the current bindings for this view.
+    unbind: =>
+      binding.unbind() for binding in @bindings
+
+    # Syncs up the view with the model by running the routines on all bindings.
+    sync: =>
+      binding.sync() for binding in @bindings
+
+    # Publishes the input values from the view back to the model (reverse sync).
+    publish: =>
+      binding.publish() for binding in @select (b) -> b.binder.publishes
+
+    # Updates the view's models along with any affected bindings.
+    update: (models = {}) =>
+      @models[key] = model for key, model of models
+      binding.update models for binding in @bindings
+
+
+  # Treat backspace, enter and other case
+  rivets.binders.spell ||=
+    publishes: true
+    bind: (el) ->
+
+      @options.publisher ||=  (event) =>
+        value  = Rivets.Util.getInputValue @el
+
+        # TODO more controllable enter handling
+        return if event.which == 13
+
+        value += String.fromCharCode event.which || event.keyCode || event.charCode
+
+        for formatter in @formatters.slice(0).reverse()
+          args = formatter.split /\s+/
+          id = args.shift()
+
+          if @view.formatters[id]?.publish
+            value = @view.formatters[id].publish value, args...
+
+        @view.config.adapter.publish @model, @keypath, value
+        event.preventDefault()
+
+      if window.jQuery?
+        # TODO Rivets.Util.bindEvent el, 'keypress change', @options.publisher
+        Rivets.Util.bindEvent el, 'keypress', @options.publisher
+        Rivets.Util.bindEvent el, 'change'  , @publish
+      else
+        Rivets.Util.bindEvent el, 'keypress', @options.publisher
+        Rivets.Util.bindEvent el, 'change'  , @publish
+
+    unbind: (el) ->
+
+      if window.jQuery?
+        # TODO Rivets.Util.unbindEvent el, 'keypress change', @options.publisher
+        Rivets.Util.unbindEvent el, 'keypress', @options.publisher
+        Rivets.Util.unbindEvent el, 'change', @publish
+      else
+        # TODO Rivets.Util.unbindEvent el, 'change'  , @options.publisher
+        Rivets.Util.unbindEvent el, 'keypress', @options.publisher
+        Rivets.Util.unbindEvent el, 'change', @publish
+
+    routine: (el, value) ->
+      if window.jQuery?
+        el = jQuery el
+
+        if value?.toString() isnt el.val()?.toString()
+          el.val if value? then value else ''
+      else
+
+        if el.type is 'select-multiple'
+          o.selected = o.value in value for o in el if value?
+        else if value?.toString() isnt el.value?.toString()
+          el.value = if value? then value else ''
+
+
+
+  rivets.formatters.float = (value) ->
+    throw new TypeError "Invalid value passed to float formatter: #{value}" unless value?
+
+    # Blank value and impossible to convert to string
+    (!value || !(value + '')) && (value = 0)
+
+    # Force getter reading on IE
+    value = parseFloat value + ''
+
+    # Handle NaN
+    (isNaN(value)) && (value = 0)
+
+    # Format value
+    value.toFixed(2).toString().replace '.', ','
+
+  rivets.formatters.currency = (value) ->
+    'R$ ' + rivets.formatters.float value
+
+
+  (application) ->
+
+    initialize: (application) ->
+
+      extend application.sandbox,
+        view: rivets
+
+      extend application.core.Widgets.Base.prototype,
+        bind: (presentation, options) ->
+          if presentation.presented
+            presented = presentation.presented
+            delete presentation.presented
+
+          @view = rivets.bind @$el, presentation, options
+
+          presented(@view) if presented?
+

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

@@ -0,0 +1,62 @@
+define 'aura/extensions/states', ['application/states'], (states) ->
+
+  'use strict'
+
+  (application) ->
+    core     = application.core
+    logger   = application.logger
+    mediator = core.mediator
+    _        = core.util._
+
+
+    state =
+      current: 'default'
+      list: []
+      previous: null
+      change: (transition) ->
+        if state.current != transition.to
+          from           = core.state
+          to             = if transition.to == 'previous' then state.previous else transition.to
+          state.previous = state.current
+          state.current  = to
+          mediator.emit 'state.changed', to: to, from: from
+        else
+          mediator.emit 'state.errored', to: transition.to, message: 'Application already in this state!'
+      changed: (transition) ->
+        core.dom.find('html').addClass(transition.to).removeClass(transition.from)
+
+    # Set default intial state
+    core.dom.find('html').addClass state.current
+
+    # Application flow control
+    flow =
+
+      changed: (transition) ->
+        widget_configurations = states[transition.to]
+        if widget_configurations
+          widgets = []
+
+          for name, options of widget_configurations
+            widgets.push
+              name: options.name || name
+              options: options
+
+            delete options.name
+
+          core.inject(widgets).fail flow.failed
+
+          delete states[transition.to]
+      failed: (exception) ->
+        logger.error "states.flow.failed: Failed autostarting widget #{@} \n Message: #{exception.message}", exception
+
+
+    initialize: (application) ->
+      mediator.on 'state.change' , state.change
+      mediator.on 'state.changed', state.changed
+
+      # TODO load widgets before state.changed, load on state.change
+      mediator.on 'state.changed', flow.changed
+
+      Object.defineProperty core, 'state',
+        set: (to) -> state.change to: to
+        get: -> state.current

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

@@ -0,0 +1,66 @@
+define 'aura/extensions/widget/eventable', ->
+
+  'use strict';
+
+  extend = require 'segmentio-extend'
+
+  extractor = /.*?\$(.*?)@(.*?)\+(.*?)/
+
+  translations = new Map()
+  translations.set 'transition.end',
+    'webkitTransitionEnd otransitionend oTransitionEnd msTransitionEnd transitionend'
+
+  translations.set 'transition.start',
+    'webkitTransitionStart otransitionstart oTransitionStart msTransitionStart transitionstart'
+
+  translations.set 'animation.end',
+    'webkitAnimationEnd oanimationend oAnimationEnd msAnimationEnd animationend'
+
+  translations.set 'animation.start',
+    'webkitAnimationStart oanimationstart oAnimationStart msAnimationStart animationstart'
+
+
+  create_handler = (widget, event_name) ->
+    (event) ->
+      widget.sandbox.emit "#{widget.name}.#{widget.identifier}.#{event_name}ed", @
+      event.preventDefault()
+      false
+
+
+  (application) ->
+
+    initialize: (application) ->
+
+      extend application.core.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
+
+          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)
+
+      parent = application.core.Widgets.Base
+
+      # TODO pass this extensions to the identifiable extension
+      eventableize = (options) ->
+        matches     = extractor.exec options._ref
+        @name       = matches[1]
+        @identifier = options.resource ? matches[2]
+
+        parent.call @, options
+
+        @sandbox.identifier = @identifier
+
+        @
+
+      eventableize.prototype        = new parent _ref: ''
+      extend eventableize, parent
+      application.core.Widgets.Base = eventableize
+
+

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

@@ -0,0 +1,75 @@
+define 'aura/extensions/widget/lifecycleable', ->
+
+  'use strict'
+
+  # TODO Remove jquery and use core dependencies
+  jQuery = require 'jquery'
+
+  lifecycleable =
+    injection: (definition) ->
+      options           = definition.options
+
+      # TODO check for existing widgets before convert options, and
+      # not only if type is object
+      for subwidget_name, suboptions of options
+        # TODO if isWidget subwidget_name
+        if $.type(suboptions) == 'object'
+
+          for name, suboption of suboptions
+            options["#{subwidget_name}#{@capitalize name}"] = suboption
+
+          # TODO delete options[subwidget_name]
+
+      ref               = definition.name.split "@"
+      widgetName        = @decamelize ref[0]
+      widgetSource      = ref[1] || "default"
+
+      requireContext    = require.s.contexts._
+      widgetsPath       = @sources[widgetSource] || "widgets"
+
+      # Register the widget a s requirejs package...
+      # TODO: packages are not supported by almond, should we find another way to do this ?
+      options.ref               = '__widget__$' + widgetName + "@" + widgetSource
+      options.baseUrl           = widgetsPath + "/" + widgetName
+      options.require           = options.require || {}
+      options.require.packages  = options.require.packages || []
+      options.require.packages.push name: options.ref, location: widgetsPath + "/" + widgetName
+      options.name  = widgetName;
+
+      unless options.el
+        options.el  = jQuery '<div class="widget"></div>'
+        @root.append options.el
+
+      @find(options.el).attr options.attributes if options.attributes?
+
+      definition
+
+  (application) ->
+
+    initialize: (application) ->
+      core = application.core
+
+      # TODO use indemma inflections module instead
+      core.util.capitalize = (string) ->
+        string.charAt(0).toUpperCase() + string.slice(1);
+
+
+      # Cache usefull methods
+      lifecycleable.sources    = application.config.widgets.sources
+      lifecycleable.find       = core.dom.find
+      lifecycleable.root       = core.dom.find app.startOptions.widgets
+      lifecycleable.decamelize = core.util.decamelize
+      lifecycleable.capitalize = core.util.capitalize
+
+
+      # Add injection functiono for widgets
+      core.inject = (name = options.name, options) ->
+        if jQuery.isArray name
+          widgets    = name
+          injections = core.util._.map widgets, lifecycleable.injection, lifecycleable
+          return core.start injections
+
+        else if not name
+          throw new TypeError "app.core.inject: No widget name provided" unless name?
+
+        core.start = lifecycleable.injection options

data/lib/assets/javascripts/config/initializers/jquery.js.coffee

@@ -0,0 +1,6 @@
+# window.$  require 'jquery'
+#
+# window.$.ajaxSetup
+#   beforeSend: (xhr) ->
+#     token = $('meta[name="csrf-token"]').attr('content')
+#     xhr.setRequestHeader 'X-CSRF-Token', token

data/lib/assets/javascripts/config/initializers/load_components.js.coffee

@@ -0,0 +1,73 @@
+#= require require/require
+#= require build
+
+root = exports ? this
+
+# Little object class to merge component require and requirejs require
+loader =
+  shim: ->
+    # Store loaders functions
+    loader.loaders.component = require
+    loader.loaders.requirejs = requirejs
+    loader.activate.define   = root.define
+
+    # Expand require fuction with requirejs configurations
+    # so we can require without great problems
+    loader.require.config  = requirejs.config
+    loader.require.s       = requirejs.s
+
+  initialize: ->
+    extend = require 'segmentio-extend'
+    extend loader.require, require
+
+    # Override global require for ower one
+    root.require = loader.require
+    root.loader = loader
+
+  # Resource loaders compatibility
+  loaders:
+    requirejs : null
+    component : null
+    discovered: null
+
+  discover: (params...) ->
+
+    if params[0] instanceof Array
+      requirer = 'requirejs'
+    else
+      requirer = 'component'
+
+    @activate (requirer) and requirer
+
+  activate: (requirer) ->
+    switch requirer
+      when 'component'
+        root.define = null
+      when 'requirejs'
+        root.define = @activate.define
+      else
+        false
+
+    @loaders.discovered = @loaders[requirer]
+
+    true
+
+  require: (params...) ->
+    using = loader.discover params...
+
+    try
+
+      module = loader.loaders.discovered.apply @, params
+
+    catch e
+      console.warn 'Failed to load \'', params[0], "' with #{using}: Error: '", e.message, '\'. Trying with requirejs.'
+      loader.activate 'requirejs'
+      module = loader.loaders.discovered.apply @, params unless module
+
+    # Always let requirjs active by default
+    loader.activate 'requirejs'
+
+    module
+
+loader.shim()
+loader.initialize()

data/lib/assets/javascripts/config/initializers/requirejs.js.coffee

@@ -0,0 +1,3 @@
+requirejs.config({
+  baseUrl: '/assets'
+});

data/lib/assets/javascripts/ende.js.coffee

@@ -0,0 +1 @@
+#= require_tree ./config/initializers

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

@@ -0,0 +1,95 @@
+define ['./states/index', './presenter'], (templates, presenter) ->
+
+  # If some extension provides you can use the type defined in there
+  # to extend your widget. Defaults to Base constructor.
+  #
+  # type: 'Base'
+
+  # Default values for the options passed to this widget
+  #
+  # Note: the options are passed thorught the html element data
+  # attributes for this widget: <div data-aura-amount="3"></div>
+  #
+  # options: {}
+
+
+  # Widget initialization method, will be called upon loading, options
+  # are already filled with defaults
+  initialize: (options) ->
+    sandbox = @sandbox
+    sandbox.logger.log "initialized!"
+
+    base =
+      status: null
+      classes: =>
+        "#{@state} #{@status} authenticator"
+      toggle_state: (event) =>
+        @state = if @state == 'default' then 'passwords' else 'default'
+        false
+
+    # Forward the models to the presenter
+    authenticator =
+      message: null
+      email: null
+      password: null
+      # TODO copiar do modacad
+      # button_label: 'Entrar'
+
+      # Authentication state
+      authenticate: (event) ->
+        base.status  = "loading" # replace all status
+        sandbox.emit 'user.sign_in', authentication
+
+      # Listeners
+      authenticated: (session) ->
+        base.status  = "success"
+
+      unauthorized: ->
+        authentication.message = "Ops... seu e-mail ou senha estão incorretos. Tente mais uma vez!<br><a href='#'>Esqueceu sua senha? Clique aqui.</a>"
+        base.status  = "error"
+
+
+    recoverer =
+      email: null
+      message: null
+
+      # TODO copiar do modacad
+      # button_label: 'Entrar'
+
+      # Recovery state
+      recover: (event, models) ->
+        base.status = 'loading'
+        sandbox.emit 'user.recover_password', recovery
+
+      recovered: (password) ->
+        base.status = 'success'
+
+
+    # Bind and unbind events depending on state
+    sandbox.on 'user.signed_in'          , authenticator.authenticated
+    sandbox.on 'user.unauthorized'       , authenticator.unauthorized
+    sandbox.on 'user.password_recovered' , recoverer.recovered
+
+
+    # Will also initialize sandbox!
+    @$el.attr 'data-class', 'base.classes < base.status'
+    @presentation  = presenter authenticator, recoverer, base
+    authentication = @presentation.authenticator
+    recovery       = @presentation.recoverer
+
+    # TODO Extract to stateable widget
+    # TODO use observable
+    @observed ||= {}
+    Object.defineProperty @, 'state',
+      get: => @observed.state
+      set: @transition
+
+    @state = 'default'
+
+
+  # TODO Extract to stateable widget
+  # TODO use observable
+  transition: (to) ->
+    @html templates[to]
+    @bind @presentation
+    @observed.state = to

data/lib/assets/javascripts/widgets/authenticator/presenter.js.coffee

@@ -0,0 +1,35 @@
+'use strict'
+define ->
+  observable = require('observable').mixin
+
+  (authenticator, recoverer, base) ->
+
+    authenticator: observable Object.create null,
+      status:
+        configurable: true
+        get: -> authenticator.status
+        set: (status) -> authenticator.status = status
+      message:
+        configurable: true
+        get: -> authenticator.message
+        set: (message) -> authenticator.message = message
+      classes:
+        configurable: true
+        value: ->
+          "widget authenticator #{authenticator.status}"
+      email:
+        configurable: true
+        set: (email) -> authenticator.email = email
+        get: -> authenticator.email
+      password:
+        configurable: true
+        set: (password) -> authenticator.password = password
+        get: -> authenticator.password
+      authenticate:
+        configurable: true
+        value: authenticator.authenticate
+
+    # TODO split into two presenters
+    recoverer: observable recoverer
+
+    base: observable base

data/lib/assets/javascripts/widgets/authenticator/states/default.html

@@ -0,0 +1,7 @@
+<div class="message" data-html="authenticator.message"> </div>
+<input type="email"    data-value="authenticator.email" placeholder="Login" />
+<input type="password" data-value="authenticator.password" placeholder="Password" />
+<button data-on-click="authenticator.authenticate">
+  Authenticate!
+</button>
+<a data-on-click="base.toggle_state">Recuperar Senha</a>

data/lib/assets/javascripts/widgets/authenticator/states/index.js.coffee

@@ -0,0 +1,3 @@
+define ['text!./default.html', 'text!./passwords.html'], (default_state, passwords_state) ->
+  default: default_state
+  passwords: passwords_state