ende 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95b8f0102eaf6c3d5fdf84a364afa9f01495d633
+  data.tar.gz: 44a73feca7b3353f4a51831292dc96b8f83d51dc
+SHA512:
+  metadata.gz: 98cda4fb64e3911896acb8fdb3029c5a734a6f2ea7d99f174c439a292858596097b3d61fde980dfd93d89a799dc8f103392aa0f40063d9353d8829342b3b4dec
+  data.tar.gz: 08ac320f4d91562324f8a70261859e749b212fa7f0a1be9d42a13e52dfbf9cc5a780349ad9a276722045abbc9c822212144a4dde6ed90a20f0473cc55aed889b

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ende.gemspec
+gemspec

data/README.md

@@ -0,0 +1,29 @@
+# Ende
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ende'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ende
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/WTFP-LICENSE

@@ -0,0 +1,13 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.

data/component.json

@@ -0,0 +1,31 @@
+{
+  "name": "ened",
+  "repo": "indefinido/ened",
+  "description": "Core web application functionality",
+  "version": "0.0.1",
+  "keywords": [],
+  "dependencies": {
+    "mikeric/rivets": "*",
+    "bestiejs/lodash": "*",
+    "KapIT/observe-utils": "*",
+    "segmentio/extend": "*",
+    "pluma/assimilate": "*",
+    "paulmillr/es6-shim": "*",
+    "component/type": "*",
+    "component/bind": "*",
+    "component/jquery": "*",
+    "indefinido/indemma": "*",
+    "indefinido/observable": "*",
+    "indefinido/advisable": "*"
+  },
+  "scripts": [
+    "vendor/assets/javascripts/stampit/stampit.js"
+  ],
+  "development": {},
+  "paths": [
+    "lib/components",
+    "vendor/components",
+    "vendor/assets/javascripts"
+  ],
+  "license": "MIT"
+}

data/ende.gemspec

@@ -0,0 +1,23 @@
+# cofding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ende/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ende"
+  spec.version       = Ende::VERSION
+  spec.authors       = ["Heitor Salazar"]
+  spec.email         = ["heitorsalazar@gmail.com"]
+  spec.description   = %q{A modular web application engine for rails. Using aurajs and indemma by default. the goal is to provideseamlessly integrstion with rails and popular rails engines,  such as devise.}
+  spec.summary       = %q{Endë (core,  middle) a web application engine for rails with aurajs.}
+  spec.homepage      = ""
+  spec.license       = "WTFPL"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

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

@@ -0,0 +1,110 @@
+root = exports ? this
+
+define 'aura/extensions/devise', () ->
+
+  'use strict'
+
+  sandbox  = null
+  mediator = null
+  core     = null
+
+  # TODO create an indemma model
+  session  =
+    build: (user = {}) ->
+
+      core.models.record.call
+        resource: 'user'
+        route   : '/users/sessions'
+        email   : user.email
+        password: user.password
+
+    # TODO better and more formal way to restore
+    restore: ->
+      # We make a dummy request to the new session path and if user is
+      # logged in, devise redirects us to the users/show.json path for
+      # the current loged in user
+
+
+      session.restoring = true
+
+      # Also find a better way to publish events after all widgets are
+      # loaded
+      setTimeout (( ) -> session.create()), 3000
+      # session.create()
+
+    create: (user) ->
+
+      user_session     = session.build user
+      session.instance = user_session
+
+      user_session.dirty = true
+
+      user_session
+        .save ->
+          sandbox.current_user = @
+          sandbox.signed_in = true
+          mediator.emit 'user.signed_in', @
+
+        .fail ->
+          sandbox.current_user = null
+          mediator.emit 'user.unauthorized', @ unless session.restoring
+          sandbox.signed_in ||= false
+        .always ->
+          mediator.emit 'session.restore.tried', @ if session.restoring
+          session.restoring  = false
+
+  #      user_password POST   /users/password(.:format)                 devise/passwords#create
+  #  new_user_password GET    /users/password/new(.:format)             devise/passwords#new
+  # edit_user_password GET    /users/password/edit(.:format)            devise/passwords#edit
+  #                    PATCH  /users/password(.:format)                 devise/passwords#update
+  #                    PUT    /users/password(.:format)                 devise/passwords#updaet
+  password =
+    build: (user = {}) ->
+      core.models.record.call
+        resource: 'user'
+        route   : '/users/password'
+        email   : user.email
+        password: user.password
+
+    create: (user) ->
+
+      user_password     = password.build user
+      password.instance = user_password
+
+      user_password.dirty = true
+
+      user_password
+        .save ->
+          mediator.emit 'user.password_recovered', @
+        .fail ->
+          mediator.emit 'user.unauthorized', @
+
+
+
+  # Extension definition
+  name: 'devise'
+  initialize: (application) ->
+
+    core     = application.core
+    sandbox  = application.sandbox
+    mediator = core.mediator
+
+    # Define callbacks
+    # TODO get json with features info from devise
+    # gem and only use apropriated listeners
+    mediator.on 'user.sign_in', session.create
+    mediator.on 'user.recover_password', password.create
+
+    # Define api
+    Object.defineProperty sandbox, 'current_user',
+      set: (user) -> session.current_user = user
+      get: -> session.current_user
+
+    sandbox.session = session
+
+
+
+  afterAppStart: () ->
+    # Restore session if not already
+    # TODO Restore only when application is ready
+    session.restore()

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

@@ -0,0 +1,48 @@
+define 'aura/extensions/loader', ->
+
+  'use strict';
+
+  try
+    Spinner = require 'seminovos/vendor/assets/javascripts/spin/spin'
+  catch e
+    Spinner = require 'modacad/vendor/assets/javascripts/spin/spin'
+
+
+  (application) ->
+    core     = application.core
+    mediator = core.mediator
+
+    loader =
+
+      options:
+        lines: 5             # The number of lines to draw
+        length: 0            # The length of each line
+        width: 12            # The line thickness
+        radius: 0            # The radius of the inner circle
+        corners: 0           # Corner roundness (0..1)
+        rotate: 90           # The rotation offset
+        direction: 1         # 1: clockwise -1: counterclockwise
+        color: '#FFF'        # #rgb or #rrggbb
+        speed: 1.6           # Rounds per second
+        trail: 75            # Afterglow percentage
+        shadow: false        # Whether to render a shadow
+        hwaccel: false       # Whether to use hardware acceleration
+        className: 'loader'  # The CSS class to assign to the spinner
+        zIndex: 2e9          # The z-index (defaults to 2000000000)
+        top: 'auto'          # Top position relative to parent in px
+        left: 'auto'         # Left position relative to parent in px
+
+      # Returns a new spinner (http://fgnass.github.io/spin.js)
+      # Hiding the spinner
+      #  To hide the spinner, invoke the stop() method, which removes the UI elements from the DOM
+      #  and stops the animation. Stopped spinners may be reused by calling spin() again.
+      create: (selector, options) ->
+        target = core.dom.find selector
+        new Spinner(core.util.extend {}, @options, options).spin target[0]
+
+    name: 'loader'
+    initialize: (application) ->
+      core.ui ||= {}
+      application.sandbox.ui = core.ui
+      core.ui.loader = ->
+        loader.create arguments...

data/lib/assets/javascripts/aura/extensions/mediator.js

@@ -0,0 +1,98 @@
+define('aura/extensions/mediator', function () {
+  'use strict';
+
+  return {
+    name: 'mediator',
+
+    require: {
+      paths: {
+        eventemitter: 'components/eventemitter2/lib/eventemitter2',
+        underscore: 'components/underscore/underscore'
+      },
+      shim: {
+        underscore: {
+          exports: '_'
+        }
+      }
+    },
+
+    initialize: function (app) {
+      var EventEmitter = require('eventemitter');
+      var _ = require('underscore');
+
+      app.config.mediator = _.defaults(app.config.mediator || {}, {
+        wildcard: true,
+        delimiter: '.',
+        newListener: true,
+        maxListeners: 20
+      });
+
+      var mediator = new EventEmitter(app.config.mediator);
+
+      app.core.mediator = mediator;
+
+      var attachListener = function(listenerType) {
+        return function (name, listener, context) {
+          if (!_.isFunction(listener) || !_.isString(name)) {
+            throw new Error('Invalid arguments passed to sandbox.' + listenerType);
+          }
+          context = context || this;
+          var callback = function() {
+            var args = Array.prototype.slice.call(arguments);
+            try {
+              listener.apply(context, args);
+            } catch(e) {
+              var message  = "Event emission error on context: " + (context._ref || context) + "\n";
+              message += "With message " + (e.message || e) + "\n";
+              message += "Trying to emit event " + name + "\n";
+              message += "Failed on listener: \n " + (listener.name || listener) + "\n";
+              e.stack && (message += e.stack);
+
+              mediator.emit("emission.error", context);
+              app.logger.error("emission.error", message, 'Context:', context, 'Exception:', e);
+            }
+          };
+
+          this._events = this._events || [];
+          this._events.push({ name: name, listener: listener, callback: callback });
+
+          mediator[listenerType](name, callback);
+        };
+      };
+
+      app.sandbox.on    = attachListener('on');
+      app.sandbox.once  = attachListener('once');
+
+      app.sandbox.off = function (name, listener) {
+        if(!this._events) { return; }
+        this._events = _.reject(this._events, function (evt) {
+          var ret = (evt.name === name && evt.listener === listener);
+          if (ret) { mediator.off(name, evt.callback); }
+          return ret;
+        });
+      };
+
+      app.sandbox.emit = function () {
+        var debug = app.config.debug;
+        if(debug.enable && (debug.components.length === 0 || debug.components.indexOf("aura:mediator") !== -1)){
+          var eventData = Array.prototype.slice.call(arguments);
+          eventData.unshift('Event emitted');
+          app.logger.log.apply(app.logger, eventData);
+        }
+        mediator.emit.apply(mediator, arguments);
+      };
+
+      app.sandbox.stopListening = function () {
+        if (!this._events) { return; }
+        _.each(this._events, function (evt) {
+          mediator.off(evt.name, evt.callback);
+        });
+      };
+
+      var eventName = ['aura', 'sandbox', 'stop'].join(app.config.mediator.delimiter);
+      app.core.mediator.on(eventName, function (sandbox) {
+        sandbox.stopListening();
+      });
+    }
+  };
+});

data/lib/assets/javascripts/aura/extensions/models.js.coffee.erb

@@ -0,0 +1,56 @@
+<% # TODO mover para helper %>
+<% base_path        = Rails.root.join('app', 'assets', 'javascripts', 'models') %>
+<% models_list      = Dir.glob(Rails.root.join(base_path, '**', '*.js*')) %>
+<% models_list.map! do |file|
+   file.sub! base_path.to_s + '/', ''
+
+   # Ignore Emacs temporary files
+   next nil if file =~ /~/
+
+   entries         = file.split /\// || []
+   entries.unshift 'models'
+   entries.push    File.basename entries.pop, '.js.coffee'
+   File.join *entries
+
+end.compact!
+%>
+
+root = exports ? this
+
+define 'aura/extensions/models', <%= models_list.to_json  %>, (models...) ->
+
+  'use strict'
+
+  # TODO better require api for indemma
+  indemma = require 'indemma'
+  require 'indefinido-indemma/lib/extensions/rivets'
+  require 'indefinido-indemma/lib/record/rest'
+  require 'indefinido-indemma/lib/record/associable'
+  require 'indefinido-indemma/lib/record/scopable'
+  require 'indefinido-indemma/lib/record/restfulable'
+  require 'indefinido-indemma/lib/record/resource'
+  require 'indefinido-indemma/lib/record/maid'
+  require 'indefinido-indemma/lib/record/validatable'
+
+
+  # Extension definition
+  initialize: (application) ->
+    core                = application.core
+    sandbox             = application.sandbox
+    core.util.inflector =
+      cssify: (sentence) ->  sentence.replace /\//, '-'
+
+    # TODO rename core.models to core.domain, completely
+    core.domain = core.models   = sandbox.models = indemma.model
+
+    core.model  = sandbox.model = (name) ->
+      # TODO use a Map internally in indemma
+      model = indemma.model[name]
+      throw new Error "Model '#{name}' not found!" unless model?
+      model
+
+    # TODO rename core.models to core.domain, completely
+    core.domain.record = core.models.record = sandbox.models.record = indemma.record
+
+    # build all model definitions
+    core.util._.map models, (model) -> indemma.model.call model