agt 0.0.1

data/app/assets/javascripts/agt/mixins/disposable.coffee

@@ -0,0 +1,7 @@
+namespace('agt.mixins')
+class agt.mixins.Disposable
+  init: ->
+    @initialized?()
+
+  dispose: ->
+    @disposed?()

data/app/assets/javascripts/agt/mixins/equatable.coffee

@@ -0,0 +1,37 @@
+namespace('agt.mixins')
+# Public: An `Equatable` object can be compared in equality with another object.
+# Objects are considered as equal if all the listed properties are equal.
+#
+# ```coffeescript
+# class Dummy
+#   @include agt.mixins.Equatable('p1', 'p2')
+#
+#   constructor: (@p1, @p2) ->
+#     # ...
+#
+# dummy = new Dummy(10, 'foo')
+# dummy.equals p1: 10, p2: 'foo'   # true
+# dummy.equals new Dummy(5, 'bar') # false
+# ```
+#
+# The `Equatable` mixin is called a parameterized mixin as
+# it's in fact a function that will generate a mixin based
+# on its arguments.
+#
+# properties - A list of {String} of the properties to compare to set equality.
+#
+# Returns a {ConcreteEquatable} mixin.
+agt.mixins.Equatable = (properties...) ->
+
+  # Public: A concrete mixin is generated and returned by the
+  # [Equatable](../files/mixins/equatable.coffee.html) generator.
+  class ConcreteEquatable
+
+    # Public: Compares the `properties` of the passed-in object with the current
+    # object and return `true` if all the values are equal.
+    #
+    # o - The {Object} to compare to this instance.
+    #
+    # Returns a {Boolean} of whether the objects are equal or not.
+    equals: (o) -> o? and properties.every (p) =>
+      if @[ p ].equals? then @[ p ].equals o[ p ] else o[p] is @[ p ]

data/app/assets/javascripts/agt/mixins/formattable.coffee

@@ -0,0 +1,52 @@
+namespace('agt.mixins')
+# Public: A `Formattable` object provides a `toString` that return
+# a string representation of the current instance.
+#
+# ```coffeescript
+# class Dummy
+#   @include agt.mixins.Formattable('Dummy', 'p1', 'p2')
+#
+#   constructor: (@p1, @p2) ->
+#     # ...
+#
+# dummy = new Dummy(10, 'foo')
+# dummy.toString()
+# # [Dummy(p1=10, p2=foo)]
+# ```
+#
+# You may wonder why the class name is passed in the `Formattable`
+# call, the reason is that javascript minification can alter the
+# naming of the functions and in that case, the constructor function
+# name can't be relied on anymore.
+# Passing the class name will ensure that the initial class name
+# is always accessible through an instance.
+#
+# classname - The {String} name of the class for which generate a mixin.
+# properties - A list of {String} of the properties to include
+#              in the formatted output.
+#
+# Returns a {ConcreteFormattable} mixin.
+agt.mixins.Formattable = (classname, properties...) ->
+  # Public: The concrete class as returned by the
+  # [Formattable](../files/mixins/formattable.coffee.html) generator.
+  class ConcreteFormattable
+    ### Public ###
+
+    # Returns the object representation as a {String}.
+    # By default the object representation looks like `[ClassName]`.
+    # If the mixin was configurated using at least on property the
+    # object representation will now looks like
+    # `[ClassName(property=value)]`
+    #
+    # Returns a {String}.
+    toString: -> "[#{ classname }]"
+
+    if properties.length > 0
+      @::toString = ->
+        formattedProperties = ("#{ p }=#{ @[ p ] }" for p in properties)
+        "[#{ classname }(#{ formattedProperties.join ', ' })]"
+
+    # Returns the class name {String} of this instance.
+    #
+    # Returns a {String}
+    classname: -> classname

data/app/assets/javascripts/agt/mixins/globalizable.coffee

@@ -0,0 +1,175 @@
+namespace('agt.mixins')
+
+# Internal: The list of properties that are unglobalizable by default.
+DEFAULT_UNGLOBALIZABLE = [
+  'globalizable'
+  'unglobalizable'
+  'globalized'
+  'globalize'
+  'unglobalize'
+  'globalizeMember'
+  'unglobalizeMember'
+  'keepContext'
+  'previousValues'
+  'previousDescriptors'
+]
+
+# Public: A `Globalizable` object can expose some methods on the
+# specified global object (`window` in a browser or `global` in nodejs
+# when using methods from the `vm` module).
+#
+# The *globalization* process is **reversible** and take care to preserve
+# the initial properties of the global that may be overriden.
+#
+# The properties exposed on the global object are defined
+# in the `globalizable` property.
+#
+# ```coffeescript
+# class Dummy
+#   @include agt.mixins.Globalizable window
+#
+#   globalizable: ['someMethod']
+#
+#   someMethod: -> console.log 'in some method'
+#
+# instance = new Dummy
+# instance.globalize()
+#
+# someMethod()
+# # output: 'in some method'
+# ```
+#
+# The process can be reversed with the `unglobalize` method.
+#
+# ```coffeescript
+# instance.unglobalize()
+# ```
+#
+# The `Globalizable` function takes the target global object as the first
+# argument. The second argument define whether the functions on
+# a globalized object are bound to this object or to the global object.
+#
+# global - The global {Object} onto which adds globalized methods
+#          and properties.
+# keepContext - A {Boolean} defining whether the initial context
+#               of the methods are preserved or not.
+#
+# Returns a {ConcreteGlobalizable} mixin to decorate a class with.
+agt.mixins.Globalizable = (global, keepContext=true) ->
+
+  # Public: The concrete globalizable mixin as returned by the
+  # [Globalizable](../files/mixins/globalizable.coffee.html) generator.
+  class ConcreteGlobalizable
+
+    # Public: An {Array} storing the {String} name of the properties that
+    # can't be globalized. This takes precedence over the `globalizable`
+    # property of the decorated class.
+    @unglobalizable: DEFAULT_UNGLOBALIZABLE.concat()
+
+    # Public: {Boolean} that defines whether the methods context
+    # are preserved or not.
+    keepContext: keepContext
+
+    # Public: The method that actually exposes the object methods on global.
+    globalize: ->
+      # But only if the object isn't already `globalized`.
+      return if @globalized
+
+      # Creates the objects that will stores the previous values
+      # and property descriptors present on `global` before the
+      # object globalization.
+      @previousValues = {}
+      @previousDescriptors = {}
+
+      # Then for each properties set for globalization the
+      # `globalizeMember` method is called.
+      @globalizable.forEach (k) =>
+        unless k in (@constructor.unglobalizable or ConcreteGlobalizable.unglobalizable)
+          @globalizeMember k
+
+      # And the object is marked as `globalized`.
+      @globalized = true
+
+    # Public: The reverse process of `globalize`.
+    unglobalize: ->
+      return unless @globalized
+
+      # For each properties set for globalization the
+      # `unglobalizeMember` method is called.
+      @globalizable.forEach (k) =>
+        unless k in (@constructor.unglobalizable or ConcreteGlobalizable.unglobalizable)
+          @unglobalizeMember k
+
+      # And then the object is cleaned of the globalization artifacts
+      # and the `globalized` mark is removed.
+      @previousValues = null
+      @previousDescriptors = null
+      @globalized = false
+
+    # Internal: Exposes a member of the current object on global.
+    #
+    # key - The {String} name of the property to globalize.
+    globalizeMember: (key) ->
+      # If possible we prefer using property descriptors rather than
+      # accessing directly the properties. It will allow to correctly
+      # expose virtual properties (get/set) created through
+      # `Object.defineProperty`.
+      oldDescriptor = Object.getPropertyDescriptor global, key
+      selfDescriptor = Object.getPropertyDescriptor this, key
+
+      # If we have a property descriptor for the previous global property
+      # we store it to restore it in the `unglobalize` process.
+      if oldDescriptor?
+        @previousDescriptors[ key ] = oldDescriptor
+      # Otherwise the property value is stored.
+      else if @[ key ]?
+        @previousValues[ key ] = global if global[ key ]?
+
+      # If we have a property descriptor for the object property, we'll
+      # use it to create the property on global with the same settings.
+      if selfDescriptor?
+        # But if we have to bind functions to the object there'll be
+        # a need for additional setup.
+        if keepContext
+          # For instance, if the descriptor contains a `get` and `set`
+          # property then we have to bind both.
+          if selfDescriptor.get? or selfDescriptor.set?
+            selfDescriptor.get = selfDescriptor.get?.bind(@)
+            selfDescriptor.set = selfDescriptor.set?.bind(@)
+          # Otherwise, if the value is a function we bind it.
+          else if typeof selfDescriptor.value is 'function'
+            selfDescriptor.value = selfDescriptor.value.bind(@)
+
+        # Finally the descriptor is used to create the new property
+        # on the global object.
+        Object.defineProperty global, key, selfDescriptor
+
+      # Without a property descriptor for the object's property
+      # the value is retreived and used to create a new property
+      # descriptor.
+      else
+        value = @[ key ]
+        value = value.bind(@) if typeof value is 'function' and keepContext
+        Object.defineProperty global, key, {
+          value
+          enumerable: true
+          writable: true
+          configurable: true
+        }
+
+    # Internal: The inverse process of `globalizeMember`.
+    #
+    # key - The {String} name of the property to unglobalize.
+    unglobalizeMember: (key) ->
+      # If we have a previous descriptor we restore ot on global.
+      if @previousDescriptors[ key ]?
+        Object.defineProperty global, key, @previousDescriptors[ key ]
+
+      # If there's no previous descriptor but a previous value,
+      # the value is affected to the global property.
+      else if @previousValues[ key ]?
+        global[ key ] = @previousValues[ key ]
+
+      # And if there's nothing the property is unset.
+      else
+        global[ key ] = undefined

data/app/assets/javascripts/agt/mixins/has_ancestors.coffee

@@ -0,0 +1,47 @@
+namespace('agt.mixins')
+
+# Public: The `HasAncestors` mixin adds several methods to instance to deal
+# with parents and ancestors.
+#
+# ```coffee
+# class Dummy
+#   @concern agt.mixins.HasAncestors through: 'parentNode'
+#
+#   @ancestorScope 'activeAncestors', (ancestor) -> ancestor.active
+# ```
+#
+# options - The option {Object}:
+#           :through - The {String} name of the property giving access
+#           to the instance parent.
+#
+# Returns a {ConcreteHasAncestors} mixin.
+agt.mixins.HasAncestors = (options={}) ->
+  through = options.through or 'parent'
+
+  # Public: The concrete mixin as returned by the
+  # [HasAncestors](../files/mixins/has_ancestors.coffee.html) generator.
+  class ConcreteHasAncestors
+
+    # Public: Returns an array of all the ancestors of the current object.
+    # The ancestors are ordered such as the first element is the direct
+    # parent of the current object.
+    #
+    # Returns an {Array}
+    @getter 'ancestors', ->
+      ancestors = []
+      parent = @[ through ]
+
+      while parent?
+        ancestors.push parent
+        parent = parent[ through ]
+
+      ancestors
+
+    # Public: Returns an object containing the current object followed by its
+    # parent and ancestors.
+    @getter 'selfAndAncestors', -> [ this ].concat @ancestors
+
+    # Public: Defines a getter property on instances named with `name` and that
+    # filter the `ancestors` array with the given `block`.
+    @ancestorsScope: (name, block) ->
+      @getter name, -> @ancestors.filter(block, this)

data/app/assets/javascripts/agt/mixins/has_collection.coffee

@@ -0,0 +1,107 @@
+namespace('agt.mixins')
+
+# Public: The `HasCollection` mixin provides methods to expose a collection
+# in a class. The mixin is created using two strings.
+#
+# ```coffeescript
+# class Dummy
+#   @concern agt.mixins.HasCollection 'children', 'child'
+#
+#   @childrenScope 'activeChildren', (child) -> child.active
+#
+#   constructor: ->
+#     @children = []
+# ```
+#
+# The `plural` string is used to access the collection in all methods
+# provided by the mixin. The `singular` string will be used to create
+# the collection managing methods.
+#
+# For instance, given that `'children'` and `'child'` was passed as arguments
+# to `HasCollection` the following methods and properties will be created:
+#
+# - `childrenSize` [getter]
+# - `childrenCount` [getter]
+# - `childrenLength` [getter]
+# - `hasChildren` [getter]
+# - `addChild`
+# - `removeChild`
+# - `hasChild`
+# - `containsChild`
+#
+# plural - The {String} name of the property where the collection can be found.
+# singular - The singularized {String} name.
+#
+# Returns a {ConcreteHasCollection} mixin.
+agt.mixins.HasCollection = (plural, singular) ->
+
+  pluralPostfix = plural.replace /^./, (s) -> s.toUpperCase()
+  singularPostfix = singular.replace /^./, (s) -> s.toUpperCase()
+
+  # Public: The concrete mixin as returned by the
+  # [HasCollection](../files/mixins/has_collection.coffee.html) generator.
+  class ConcreteHasCollection
+    # The mixin integrates `Aliasable` to create various alias to the
+    # collection methods.
+    @extend agt.mixins.Aliasable
+
+    # Public: Creates a `name` scope on instances that filter
+    # the collection using the passed-in `block`.
+    #
+    # name - The {String} name of the collection scope.
+    # block - The {Function} filter for the scope.
+    @[ "#{ plural }Scope" ] = (name, block) ->
+      @getter name, -> @[ plural ].filter block, this
+
+    # Public: A property returning the number of elements in the collection.
+    @getter "#{ plural }Size", -> @[ plural ].length
+
+    # Creates aliases for the collection size property.
+    @alias "#{ plural }Size", "#{ plural }Length", "#{ plural }Count"
+
+    # Public: Returns `true` if the passed-in `item` is present
+    # in the collection.
+    #
+    # item - The item {Object} to search in the collection.
+    #
+    # Returns a {Boolean} of whether the item is present
+    # in the collection or not.
+    @::[ "has#{ singularPostfix }" ] = (item) -> item in @[ plural ]
+
+    # Creates an alias for `has<Item>` named `contains<Item>`.
+    @alias "has#{ singularPostfix }", "contains#{ singularPostfix }"
+
+    # Public: Returns `true` if the collection has at least one item.
+    #
+    # Returns a {Boolean} of whether the collection has items or not.
+    @getter "has#{ pluralPostfix }", -> @[ plural ].length > 0
+
+    # Public: Adds `item` in the collection unless it's already present.
+    #
+    # item - The item {Object} to append to the collection.
+    #
+    # Returns the {Number} of items in the collection.
+    @::[ "add#{ singularPostfix }" ] = (item) ->
+      @[ plural ].push item unless @[ "has#{ singularPostfix }" ] item
+      @[ "#{ plural }Size" ]
+
+    # Public: Removes `item` from the collection.
+    #
+    # item - The item {Object} to remove from the collection.
+    #
+    # Returns the {Number} of items in the collection.
+    @::[ "remove#{ singularPostfix }" ] = (item) ->
+      if @[ "has#{ singularPostfix }" ] item
+        @[ plural ].splice @[ "find#{ singularPostfix }" ](item), 1
+      @[ "#{ plural }Size" ]
+
+    # Public: Returns the index at which `item` is stored
+    # in the collection. It returns `-1` if `item` can't be found.
+    #
+    # item - The item {Object} to search in the collection.
+    #
+    # Returns the index {Number} of the passed-in item or `-1`.
+    @::[ "find#{ singularPostfix }" ] = (item) -> @[ plural ].indexOf item
+
+    # Creates an alias for `find<Item>` named `indexOf<Item>`
+    @alias "find#{ singularPostfix }", "indexOf#{ singularPostfix }"

data/app/assets/javascripts/agt/mixins/has_nested_collection.coffee

@@ -0,0 +1,51 @@
+namespace('agt.mixins')
+# Public: The `HasNestedCollection` adds a property with named `name`
+# that collects and concatenates all the descendants collections
+# into a single array.
+# It operates on classes that already includes the `HasCollection` mixin.
+#
+# ```coffeescript
+# class Dummy
+#   @concern agt.mixins.HasCollection 'children', 'child'
+#   @concern agt.mixins.HasNestedCollection 'descendants', through: 'children'
+#
+#   @descendantsScope 'activeDescendants', (descendant) -> descendant.active
+#
+#   constructor: ->
+#     @children = []
+# ```
+#
+# name - The {String} name of the nested collection accessor.
+# options - The options {Object}:
+#           :through - The {String} name of the collection accessor
+#                      to collect on the collection items the nested
+#                      collections.
+#
+# Returns a {ConcreteHasNestedCollection} mixin.
+agt.mixins.HasNestedCollection = (name, options={}) ->
+
+  # The collection is accessed with the named passed in the `through`option.
+  through = options.through
+  throw new Error('missing through option') unless through?
+
+  # Public: The concrete mixin as returned by the
+  # [HasNestedCollection](../files/mixins/has_nested_collection.coffee.html)
+  # generator.
+  class ConcreteHasNestedCollection
+
+    # Public: Creates a property on instances that filters the nested
+    # collections items using the passed-in `block`.
+    #
+    # scopeName - The {String} name for the scope.
+    # block - The {Function} filter of the scope.
+    @[ "#{ name }Scope" ] = (scopeName, block) ->
+      @getter scopeName, -> @[ name ].filter block, this
+
+    # Public: Returns a flat array containing all the items contained
+    # in all the nested collections.
+    @getter name, ->
+      items = []
+      @[ through ].forEach (item) ->
+        items.push(item)
+        items = items.concat(item[ name ]) if item[ name ]?
+      items