agt 0.0.1

data/app/assets/javascripts/agt/inheritance.coffee

@@ -0,0 +1,132 @@
+
+# Internal: For a given function on an object it will find the property
+# name and its kind (value/getter/setter).
+findCaller = (caller, proto) ->
+  keys = Object.keys proto
+
+  for k in keys
+    descriptor = Object.getPropertyDescriptor proto, k
+
+    if descriptor?
+      return {key: k, descriptor, kind: 'value'} if descriptor.value is caller
+      return {key: k, descriptor, kind: 'get'} if descriptor.get is caller
+      return {key: k, descriptor, kind: 'set'} if descriptor.set is caller
+    else
+      return {key: k} if proto[k] is caller
+
+  {}
+
+unless Object::super?
+  # Public: Gives access to the super method of any 
+  Object.defineProperty Object.prototype, 'super', {
+    enumerable: false
+    configurable: true
+    value: (args...) ->
+      # To define which function to use as super when
+      # calling the `this.super` method we need to know which
+      # function is the caller.
+      caller = arguments.caller ? @super.caller
+      if caller?
+        # When the caller has a `__super__` property, we face
+        # a mixin method, we can access the `__super__` property
+        # to retrieve its super property.
+        if caller.__super__?
+          value = caller.__super__[caller.__included__.indexOf @constructor]
+
+          # The `this.super` method can be called only if the super
+          # is a function.
+          if value?
+            if typeof value is 'function'
+              value.apply(this, args)
+            else
+              throw new Error "The super for #{caller._name} isn't a function"
+          else
+            throw new Error "No super method for #{caller._name}"
+
+        # Without the `__super__` property we face a method declared
+        # in the including class and that may redefine a method from
+        # a mixin or a parent.
+        else
+          # The name of the property that stores the caller is retrieved.
+          # The `kind` variable is either `'value'`, `'get'`, `'set'`
+          # or `'null'`. It will be needed to find the correspondant
+          # super method in the property descriptor.
+          {key, kind} = findCaller caller, @constructor.prototype
+
+          # If the key is present we'll try to get a descriptor on the
+          # `__super__` class property.
+          if key?
+            desc = Object.getPropertyDescriptor @constructor.__super__, key
+
+            # And if a descriptor is available we get the function
+            # corresponding to the `kind` and call it with the arguments.
+            if desc?
+              value = desc[kind].apply(this, args)
+
+            # Otherwise, the value of the property is simply called.
+            else
+              value = @constructor.__super__[key].apply(this, args)
+
+            return value
+
+          # And in other cases an error is raised.
+          else
+            throw new Error "No super method for #{caller.name || caller._name}"
+      else
+        throw new Error "Super called with a caller"
+
+  }
+
+  # Public:
+  Object.defineProperty Function.prototype, 'super', {
+    enumerable: false
+    configurable: true
+    value: (args...) ->
+      caller = arguments.caller or @super.caller
+      if caller?
+        if caller.__super__?
+          value = caller.__super__[caller.__included__.indexOf this]
+
+          if value?
+            if typeof value is 'function'
+              value.apply(this, args)
+            else
+              throw new Error "The super for #{caller._name} isn't a function"
+          else
+            throw new Error "No super method for #{caller._name}"
+
+        else
+          # super method in the property descriptor.
+          {key, kind} = findCaller caller, this
+
+          reverseMixins = []
+          reverseMixins.unshift m for m in @__mixins__
+
+          # If the key is present we'll try to get a descriptor on the
+          # `__super__` class property.
+          if key?
+            for m in reverseMixins
+              if m[key]?
+                mixin = m
+                break
+
+            desc = Object.getPropertyDescriptor mixin, key
+
+            # And if a descriptor is available we get the function
+            # corresponding to the `kind` and call it with the arguments.
+            if desc?
+              value = desc[kind].apply(this, args)
+
+            # Otherwise, the value of the property is simply called.
+            else
+              value = mixin[key].apply(this, args)
+
+            return value
+
+          # And in other cases an error is raised.
+          else
+            throw new Error "No super class method for #{caller.name || caller._name}"
+      else
+        throw new Error "super called without a caller"
+
+  }

data/app/assets/javascripts/agt/math.coffee

@@ -0,0 +1,45 @@
+
+Math.PI2 = Math.PI * 2
+Math.PI_2 = Math.PI / 2
+Math.PI_4 = Math.PI / 4
+Math.PI_8 = Math.PI / 8
+
+### Public ###
+
+Math.degToRad = (n) -> n * Math.PI / 180
+
+Math.radToDeg = (n) -> n * 180 / Math.PI
+
+Math.normalize = (value, minimum, maximum) ->
+  (value - minimum) / (maximum - minimum)
+
+Math.interpolate = (normValue, minimum, maximum) ->
+  minimum + (maximum - minimum) * normValue
+
+Math.deltaBelowRatio = (a, b, ratio=10000000000) -> Math.abs(a - b) < 1 / ratio
+
+Math.map = (value, min1, max1, min2, max2) ->
+  Math.interpolate Math.normalize(value, min1, max1), min2, max2
+
+# Returns true if the passed-in argument can be casted to a number.
+#
+#     Math.isFloat 0.245 # true
+#     Math.isFloat '12'  # true
+#     Math.isFloat 'foo' # false
+Math.isFloat = (floats...) ->
+  return false for float in floats when isNaN parseFloat float
+  true
+
+Math.isInt = (ints...) ->
+  return false for int in ints when isNaN parseInt int
+  true
+
+# Returns the passed-in arguments casted into floats.
+Math.asFloat = (floats...) ->
+  floats[i] = parseFloat n for n,i in floats
+  floats
+
+# Returns the passed-in arguments casted into floats.
+Math.asInt = (ints...) ->
+  ints[i] = parseInt n for n,i in ints
+  ints

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

@@ -0,0 +1,31 @@
+namespace('agt.mixins')
+# Public: The `Activable` mixin provides the basic interface for an activable
+# widget. You can hook your own activation/deactivation routines by overriding
+# the `activated` and `deactivated` methods.
+#
+# ```coffeescript
+# class Dummy
+#   @include agt.mixins.Activable
+#
+#   activated: ->
+#     # ...
+#
+#   deactivated: ->
+#     # ...
+# ```
+#
+# `Activable` instances are deactivated at creation.
+class agt.mixins.Activable
+  active: false
+
+  # Public: Activates the instance.
+  activate: ->
+    return if @active
+    @active = true
+    @activated?()
+
+  # Public: Deactivates the instance.
+  deactivate: ->
+    return unless @active
+    @active = false
+    @deactivated?()

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

@@ -0,0 +1,25 @@
+namespace('agt.mixins')
+# Public: Provides class methods to deal with aliased methods and properties.
+#
+# ```coffeescript
+# class Dummy
+#   @extend agt.mixins.Aliasable
+#
+#   someMethod: ->
+#   @alias 'someMethod', 'someMethodAlias'
+# ```
+class agt.mixins.Aliasable
+
+  # Public: Creates aliases for the given `source` property of tthe current
+  # class prototype. Any number of alias can be passed at once.
+  #
+  # source - The {String} name of the aliased property
+  # aliases - A list of {String}s to use as aliases.
+  @alias: (source, aliases...) ->
+    desc = Object.getPropertyDescriptor @prototype, source
+
+    if desc?
+      Object.defineProperty @prototype, alias, desc for alias in aliases
+    else
+      if @prototype[ source ]?
+        @prototype[ alias ] = @prototype[ source ] for alias in aliases

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

@@ -0,0 +1,72 @@
+namespace('agt.mixins')
+# Public: The `AlternateCase` mixin add methods to convert the properties
+# of a class instance to camelCase or snake_case.
+#
+# The methods are available on the class itself and should be called
+# after having declared all the class members.
+#
+# For instance, given the class below:
+#
+# ```coffeescript
+# class Dummy
+#   @extend agt.mixins.AlternateCase
+#
+#   someProperty: 'foo'
+#   someMethod: ->
+#
+#   @snakify()
+# ```
+#
+# An instance will have both `someProperty` and `someMethod` as defined
+# by the class, but also `some_property` and `some_method`.
+#
+# The alternative is also possible. Given a class that uses snake_case
+# to declare its member, the `camelize` method will provides the camelCase
+# alternative to the class.
+class agt.mixins.AlternateCase
+
+  # Public: Converts all the prototype properties to snake_case.
+  @snakify: -> @convert 'toSnakeCase'
+
+  # Public: Converts all the prototype properties to camelCase.
+  @camelize: -> @convert 'toCamelCase'
+
+  # Public: Adds the specified alternatives of each properties on the
+  # current prototype. The passed-in argument is the name of the class
+  # method to call to convert the key string.
+  #
+  # alternateCase - The {String} name of the class method to use
+  #                 to convert.
+  @convert: (alternateCase) ->
+    for key,value of @prototype
+      alternate = @[alternateCase] key
+
+      descriptor = Object.getPropertyDescriptor @prototype, key
+
+      if descriptor?
+        Object.defineProperty @prototype, alternate, descriptor
+      else
+        @prototype[alternate] = value
+
+  # Public: Converts a string to `snake_case`.
+  #
+  # str - The {String} to convert.
+  #
+  # Returns a {String} in `snake_case` .
+  @toSnakeCase: (str) ->
+    str.
+    replace(/([a-z])([A-Z])/g, "$1_$2")
+    .split(/_+/g)
+    .join('_')
+    .toLowerCase()
+
+  # Public: Converts a string to `camelCase`.
+  #
+  # str - The {String} to convert.
+  #
+  # Returns a {String} in `camelCase`.
+  @toCamelCase: (str) ->
+    a = str.toLowerCase().split(/[_\s-]/)
+    s = a.shift()
+    s = "#{ s }#{w.replace /^./, (s) -> s.toUpperCase()}" for w in a
+    s

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

@@ -0,0 +1,71 @@
+namespace('agt.mixins')
+# Internal: Contains all the function that will instanciate a class
+# with a specific number of arguments. These functions are all generated
+# at runtime with the `Function` constructor.
+build = (klass, args) ->
+  BUILDS = (
+    new Function( "return new arguments[0](#{
+      ("arguments[1][#{ j-1 }]" for j in [ 0..i ] when j isnt 0).join ","
+    });") for i in [ 0..24 ]
+  )
+
+  f = BUILDS[ if args? then args.length else 0 ]
+  f klass, args
+
+# Public: A `Cloneable` object can return a copy of itself through its `clone`
+# method.
+#
+# The `Cloneable` generator function produces a different mixin when called
+# with or without arguments.
+#
+# When called without argument, the returned mixin creates a clone using
+# a copy constructor (a constructor that initialize the current object
+# with an object).
+#
+# ```coffeescript
+# class Dummy
+#   @include agt.mixins.Cloneable()
+#
+#   constructor: (options={}) ->
+#     @property = options.property or 'foo'
+#     @otherProperty = options.otherProperty or 'bar'
+#
+# instance = new Dummy
+# otherInstance = instance.clone()
+# # otherInstance = {property: 'foo', otherProperty: 'bar'}
+# ```
+#
+# When called with arguments, the `clone` method will call the class
+# constructor with the values extracted from the given properties.
+#
+# ```coffeescript
+# class Dummy
+#   @include agt.mixins.Cloneable('property', 'otherProperty')
+#
+#   constructor: (@property='foo', @otherProperty='bar') ->
+#
+# instance = new Dummy
+# otherInstance = instance.clone()
+# # otherInstance = {property: 'foo', otherProperty: 'bar'}
+# ```
+#
+# properties - A list of {String} of the properties to pass in the constructor.
+#
+# Returns a {ConcreteCloneable} mixin configured with the passed-in arguments.
+agt.mixins.Cloneable = (properties...) ->
+
+  # Public: The concrete cloneable mixin as created by the
+  # [Cloneable](../files/mixins/cloneable.coffee.html) generator.
+  class ConcreteCloneable
+
+    # Public: Returns a copy of this instance.
+    #
+    # When the mixin is configurated without any `properties` the cloned
+    # instance is passed directly as argument at the creation of the new
+    # instance.
+    #
+    # Returns an {Object}.
+    clone: -> new @constructor this
+
+    if properties.length > 0
+      ConcreteCloneable::clone = -> build @constructor, properties.map (p) => @[ p ]

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

@@ -0,0 +1,90 @@
+namespace('agt.mixins')
+# Public: The `Delegation` mixin allow to define properties on an object that
+# proxy another property of an object stored in one of its property.
+#
+# ```coffeescript
+# class Dummy
+#   @extend agt.mixins.Delegation
+#
+#   @delegate 'someProperty', to: 'someObject'
+#
+#   constructor: ->
+#     @someObject = someProperty: 'some value'
+#
+# instance = new Dummy
+# instance.someProperty
+# # 'some value'
+# ```
+class agt.mixins.Delegation
+
+  # Public: The `delegate` class method generates a property on the current
+  # prototype that proxy the property of the given object.
+  #
+  # The `to` option specify the property of the object accessed by
+  # the delegated property.
+  #
+  # The delegated property name can be prefixed with the name of the
+  # accessed property
+  #
+  # ```coffeescript
+  # class Dummy
+  #   @extend agt.mixins.Delegation
+  #
+  #   @delegate 'someProperty', to: 'someObject', prefix: true
+  #   # delegated property is named `someObjectSomeProperty`
+  # ```
+  #
+  # By default, using a prefix generates a camelCase property name.
+  # You can use the `case` option to change that to a snake_case property
+  # name.
+  #
+  # ```coffeescript
+  # class Dummy
+  #   @extend agt.mixins.Delegation
+  #
+  #   @delegate 'some_property', to: 'some_object', prefix: true, case: 'snake'
+  #   # delegated property is named `some_object_some_property`
+  # ```
+  #
+  # The `delegate` method accept any number of properties to delegate
+  # with the same options.
+  #
+  # ```coffeescript
+  # class Dummy
+  #   @extend agt.mixins.Delegation
+  #
+  #   @delegate 'someProperty', 'someOtherProperty', to: 'someObject'
+  # ```
+  #
+  # properties - A list of {String} of the properties to delegate.
+  # options - The delegation options {Object}:
+  #           :to - The {String} name of the target property.
+  #           :prefix - A {Boolean} indicating whether to prefix the created
+  #                     delegated property name with the target property name.
+  #           :case - An optional {String} to define the case to use to generate
+  #                   a prefixed delegated property.
+  @delegate: (properties..., options={}) ->
+    delegated = options.to
+    prefixed = options.prefix
+    _case = options.case or agt.CAMEL_CASE
+
+    properties.forEach (property) =>
+      localAlias = property
+
+      # Currently, only `camel`, and `snake` cases are supported.
+      if prefixed
+        switch _case
+          when agt.SNAKE_CASE
+            localAlias = delegated + '_' + property
+          when agt.CAMEL_CASE
+            localAlias = delegated + property.replace /^./, (m) ->
+              m.toUpperCase()
+
+      # The `Delegation` mixin rely on `Object.property` and thus can't
+      # be used on IE8.
+      Object.defineProperty @prototype, localAlias, {
+        enumerable: true
+        configurable: true
+        get: -> @[ delegated ][ property ]
+        set: (value) -> @[ delegated ][ property ] = value
+      }