agt 0.0.1

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

@@ -0,0 +1,64 @@
+namespace('agt.mixins')
+# Public: A `Memoizable` object can store data resulting of heavy methods
+# in order to speed up further call to that method.
+#
+# The invalidation of the memoized data is defined using a `memoizationKey`.
+# That key should be generated based on the data that may induce changes
+# in the functions's results.
+#
+# ```coffeescript
+# class Dummy
+#   @include agt.mixins.Memoizable
+#
+#   constructor: (@p1, @p2) ->
+#     # ...
+#
+#   heavyMethod: (arg) ->
+#     key = "heavyMethod-#{arg}"
+#     return @memoFor key if @memoized key
+#
+#     # do costly computation
+#     @memoize key, result
+#
+#   memoizationKey: -> "#{p1};#{p2}"
+# ```
+class agt.mixins.Memoizable
+  # Public: Returns `true` if data are available for the given `prop`.
+  #
+  # When the current state of the object don't match the stored
+  # memoization key, the whole data stored in the memo are cleared.
+  #
+  # prop - The {String} name of a property.
+  #
+  # Retuns a {Boolean} of whether the value of the propery is memoized or not.
+  memoized: (prop) ->
+    if @memoizationKey() is @__memoizationKey__
+      @__memo__?[ prop ]?
+    else
+      @__memo__ = {}
+      false
+
+  # Public: Returns the memoized data for the given `prop`.
+  #
+  # prop - The {String} name of a property.
+  #
+  # Returns the memoized data for the given prop
+  memoFor: (prop) -> @__memo__[ prop ]
+
+  # Public: Register a memo in the current object for the given `prop`.
+  # The memoization key is updated with the current state of the
+  # object.
+  memoize: (prop, value) ->
+    @__memo__ ||= {}
+    @__memoizationKey__ = @memoizationKey()
+    @__memo__[ prop ] = value
+
+  # Public Abstract: Generates the memoization key for this
+  # instance's state.
+  #
+  # By default the memoization key of an object is the return of its `toString`
+  # method. **You SHOULD redefine the memoization key generation in the class
+  # including the `Memoizable` mixin.**
+  #
+  # Returns a {String} that identify the state of the current instance.
+  memoizationKey: -> @toString()

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

@@ -0,0 +1,101 @@
+namespace('agt.mixins')
+# Public: A `Parameterizable` object provides a class and an instance
+# method to convert an arbitrary {Object} or a series of values into
+# an instance of the class receiving the mixin.
+#
+# ```coffeescript
+# class Dummy
+#   @include agt.mixins.Parameterizable('dummyFrom', {
+#     x: 0
+#     y: 0
+#     name: 'Untitled'
+#   })
+#
+#   constructor: (@x, @y, @name) ->
+#
+# instance = new Dummy
+#
+# Dummy.instanceFrom(1,2,'foo')
+# instance.instanceFrom(1,2,'foo')
+# ```
+#
+# The methods can be used either with an object or with a list
+# of values whose order is the order of the `parameters` object keys:
+#
+# ``` coffeescript
+# Dummy.instanceFrom(1,2,'Foo') # [Dummy(x=1,y=2,name='Foo')]
+# Dummy.instanceFrom(x: 1, y: 2, name: 'Foo') # [Dummy(x=1,y=2,name='Foo')]
+# ```
+#
+# The last `instanceFrom` argument controls can be a {Boolean} of whether
+# the method raises an exception when the creation arguments types mismatch:
+#
+# ``` coffeescript
+# Dummy.instanceFrom(1,'foo','bar' true) # value for y doesn't match type number
+# Dummy.instanceFrom(x: 1, y: 'foo', name: 'bar', true) # value for y doesn't match type number
+# ```
+#
+# The only edge case is that if you have yourself defined a {Boolean} as last
+# argument you'll always have to pass the `strict` argument when calling the
+# methods.
+#
+# The `allowPartial` argument, when set to `true`, will prevent the method
+# to fallback on the default values provided in the `parameters` object
+# leaving the class constructor to deal with it.
+#
+# method - The {String} name of the method to create.
+# parameters - An {Object} describing the arguments name, type and order.
+# allowPartial - A {Boolean} of
+agt.mixins.Parameterizable = (method, parameters, allowPartial=false) ->
+
+  # Public: The concrete mixin as returned by the
+  # [Parameterizable](../files/mixins/parameterizable.coffee.html) generator.
+  class ConcreteParameterizable
+
+    # Internal:
+    @included: (klass) ->
+      f = (args..., strict)->
+        (args.push(strict); strict = false) if typeof strict isnt 'boolean'
+        output = {}
+
+        o = arguments[ 0 ]
+        n = 0
+        firstArgumentIsObject = o? and typeof o is 'object'
+
+        for k,v of parameters
+          value = if firstArgumentIsObject then o[ k ] else arguments[ n++ ]
+          parameterType = typeof v
+
+          if strict
+            if typeof value is parameterType
+              output[ k ] = value
+            else
+              if parameterType is 'number'
+                value = parseFloat value
+
+                if isNaN value
+                  throw new Error "value for #{ k } doesn't match type #{ parameterType}"
+                else
+                  output[k] = value
+              else
+                throw new Error "value for #{ k } doesn't match type #{ parameterType}"
+
+          else
+            if value?
+              if parameterType is 'number'
+                value = parseFloat value
+
+                if isNaN value
+                  output[ k ] = v unless allowPartial
+                else
+                  output[ k ] = value
+              else
+                output[ k ] = value
+            else
+              output[ k ] = v unless allowPartial
+
+
+        output
+
+      klass[method] = f
+      klass::[method] = f

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

@@ -0,0 +1,62 @@
+namespace('agt.mixins')
+# Public: A `Poolable` class has the ability to manage a pool of instances
+# and prevent the further creation of instances as long as unused ones
+# are still present.
+class agt.mixins.Poolable
+
+  # Internal: The two objects stores are created in the extended hook to avoid
+  # that all the class extending `Poolable` shares the same instances.
+  @extended: (klass) ->
+    klass.usedInstances = []
+    klass.unusedInstances = []
+
+  # Public: Resets all the instances pools.
+  @resetPools: ->
+    @usedInstances = []
+    @unusedInstances = []
+
+  # Public: The `get` method returns an instance of the class.
+  # If the class defines an `init` method, it will be called with the
+  # passed-in `options` {Object}.
+  #
+  # options - The option {Object} to use to setup the created instance.
+  #
+  # Returns an instance of the current class.
+  @get: (options={}) ->
+    # Either retrieve or create the instance.
+    if @unusedInstances.length > 0
+      instance = @unusedInstances.shift()
+    else
+      instance = new this
+
+    # Stores the instance in the used pool.
+    @usedInstances.push instance
+
+    # Init the instance and return it.
+    instance.init(options)
+    instance
+
+  # Public: The `release` method takes an instance and move
+  # it from the the used pool to the unused pool.
+  #
+  # instance - The instance of the current class.
+  @release: (instance) ->
+    return unless instance in @usedInstances
+
+    # The instance is removed from the used instances pool.
+    index = @usedInstances.indexOf(instance)
+    @usedInstances.splice(index, 1)
+
+    # And then moved to the unused instances one.
+    @unusedInstances.push instance
+
+  # Public: Default `init` implementation, just copy all the options
+  # in the instance.
+  #
+  # options - The setup {Object} for this instance.
+  init: (options={}) -> @[ k ] = v for k,v of options
+
+  # Public: Default `dispose` implementation, call the `release` method
+  # on the instance constructor. A proper implementation should
+  # take care of removing/cleaning all the instance properties.
+  dispose: -> @constructor.release(this)

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

@@ -0,0 +1,45 @@
+namespace('agt.mixins')
+# Public: A `Sourcable` object is an object that can return the source code
+# to re-create it by code.
+#
+# ```coffeescript
+# class Dummy
+#   @include agt.mixins.Sourcable('agt.geom.Dummy', 'p1', 'p2')
+#
+#   constructor: (@p1, @p2) ->
+#
+# dummy = new Dummy(10,'foo')
+# dummy.toSource() # "new agt.geom.Dummy(10,'foo')"
+# ```
+#
+# name - The {String} path to the current class.
+# signature - A list of {String} name of properties
+agt.mixins.Sourcable = (name, signature...) ->
+
+  # Public: A concrete class is generated and returned by
+  # [Sourcable](../files/mixins/sourcable.coffee.html).
+  class ConcreteSourcable
+
+    # Internal: Generates the source for a property's value.
+    sourceFor = (value) ->
+      switch typeof value
+        when 'object'
+          isArray = Object::toString.call(value).indexOf('Array') isnt -1
+          if isArray
+            "[#{ value.map (el) -> sourceFor el }]"
+          else
+            if value.toSource?
+              value.toSource()
+            else
+              value
+        when 'string'
+          "'#{ value.replace "'", "\\'" }'"
+        else value
+
+    # Public: Returns the source code corresponding to the current instance.
+    #
+    # Returns a {String} with the source of the instance.
+    toSource: ->
+      args = (@[ arg ] for arg in signature).map (o) -> sourceFor o
+
+      "new #{ name }(#{ args.join ',' })"

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

@@ -0,0 +1,47 @@
+namespace('agt.mixins')
+class agt.mixins.StateMachine
+  @initial: (state) -> @initialState = state
+
+  @event: (name, block) ->
+    @::[name] = block
+
+  @state: (name, defines) ->
+    @states ?= {}
+    @stateProperties ?= []
+
+    @states[name] = defines
+    @::[name] = -> @state is name
+    @stateProperties.push(k) for k,v of defines when k not in @stateProperties
+
+    this
+
+  initializeStateMachine: -> @setState(@constructor.initialState)
+
+  transition: (options) ->
+    throw new Error("From option is mandatory") unless options.from?
+    throw new Error("To option is mandatory") unless options.to?
+
+    {from, to} = options
+    if from is 'all'
+      from = Object.keys(@constructor.states)
+    else
+      from = from.split(' ')
+
+    to = options.to
+
+    for f in from
+      unless @constructor.states[f]
+        throw new Error("From state '#{f}' does not match any defined state")
+
+    unless @constructor.states[to]
+      throw new Error("To state '#{to}' does not match any defined state")
+
+    if @state in from
+      @setState(to)
+    else
+      throw new Error "Can't transition from #{@state} to #{to}"
+
+  setState: (state) ->
+    @state = state
+    state = @constructor.states[@state]
+    @[key] = state[key] for key in @constructor.stateProperties

data/app/assets/javascripts/agt/net/router.coffee

@@ -0,0 +1,165 @@
+namespace('agt.net')
+# Public: The router class allow to trigger view changes on url changes.
+# Typically the url changes may be handled by the history API or a url hash
+# handler.
+# The routes the router will support are defined in the callback passed to
+# the router constructor as in the example below:
+#
+# ```coffee
+# router = new Router ->
+#   @match '/posts', ->
+#     # render the post index
+#
+#   @match '/posts/:id', ({id}) ->
+#     # render a single post identified with an :id
+# ```
+class agt.net.Router
+  @extend agt.mixins.Aliasable
+
+  ### Public ###
+
+  # Creates a new router instance. The constructor takes a {Function}
+  # and call it in the constructor this the router as the context object
+  # of the call. This is generally inside the block {Function} that you'll
+  # define the route to support.
+  #
+  # block - The initialization {Function}.
+  constructor: (block) ->
+    @routes = {}
+    @beforeFilters = []
+    @afterFilters = []
+
+    block.call(this)
+    @buildRoutesHandlers()
+
+  # Registers a route on this router.
+  #
+  # A route is defined with a `path` {String}, starting with a `/` and that
+  # can contains variables patterns for dynamic routes.
+  #
+  # For instance, the following path `'/posts/:post_id/comments/:id'` sets
+  # that the route defines two variables `post_id` and `id` that can contains
+  # any value. It means that this route will match both `'/posts/1/comments/2'`
+  # or `'/posts/foo/comments/bar'`.
+  #
+  # To limit the legal values for a variable, you can pass a string
+  # in the option object with the name of the variable as key, such as in:
+  #
+  # ```coffee
+  # @match '/posts/:id', id: '(\d+)', ({id}) ->
+  # ```
+  #
+  # In the example above the route can only be matched if the content for the
+  # `id` variable in the path contains only numbers. It means that
+  # `'/posts/1/comments/2'` will be matched by the route but
+  # `'/posts/foo/comments/bar'` won't.
+  #
+  # path - The path {String} to support.
+  # options - An option {Object} that can contain properties matching the
+  #           path variables and containing strings that will be used to
+  #           construct the regexp String to test paths.
+  match: (path, options={}, handle) ->
+    [options, handle] = [{}, options] if typeof options is 'function'
+    path = path.replace /^\/|\/$/g, ''
+    @routes[path] = {handle, options}
+
+  @alias 'match', 'get'
+
+  # Registers a filter to be called before the route handler.
+  #
+  # ```coffee
+  # @beforeFilter (path, router) ->
+  #   # ...
+  # ```
+  #
+  # filter - The {Function} to invoke before the route handler.
+  beforeFilter: (filter) -> @beforeFilters.push filter
+
+  # Registers a filter to be called after the route handler.
+  #
+  # ```coffee
+  # @afterFilter (path, router) ->
+  #   # ...
+  # ```
+  #
+  # filter - The {Function} to invoke after the route handler.
+  afterFilter: (filter) -> @afterFilters.push filter
+
+  # Defines a handler for paths that doesn't match any routes.
+  #
+  # notFoundHandle - The {Function} to call for route not found.
+  notFound: (@notFoundHandle) ->
+
+  # Triggers a change of route with the passed-in path.
+  #
+  # A `route:changed` event is dispatched after all the filters and the
+  # handler was called.
+  #
+  # path - The path {String} to match.
+  goto: (path) ->
+    path = '/' if path is '.'
+    path = path.replace(/^\./, '')
+    path = path.replace(/\/$/, '') unless path is '/'
+    path = "/#{path}" if path.indexOf('/') isnt 0
+
+    handler = @findRoute(path)
+
+    @beforeFilters.forEach (filter) => filter(path, this)
+
+    if handler?
+      handler(path)
+    else
+      @notFoundHandle?({path})
+
+    @afterFilters.forEach (filter) => filter(path, this)
+
+    document.dispatchEvent agt.domEvent('route:changed', {path}) if document?
+
+  # Internal: Returns the {Function} to handle the passed-in `path`.
+  #
+  # path - The path {String} to match.
+  #
+  # Returns a {Function}.
+  findRoute: (path) ->
+    for k, {test, handle} of @routes
+      return handle if test(path)
+
+  # Internal: Builds the route handlers.
+  buildRoutesHandlers: ->
+    for path, data of @routes
+      @routes[path] = @buildRouteHandler(path, data)
+
+  # Internal: Build a single route handler using the information provided.
+  #
+  # path - A {String} of the route path pattern.
+  # options - An object with the following properties:
+  #           :handle - The {Function} that will handle the route.
+  #           :options - An {Object} that contains the path variables patterns.
+  buildRouteHandler: (path, {handle, options}) ->
+    pathArray = path.split '/'
+    pathRe = []
+    pathParams = []
+
+    for part in pathArray
+      params_re = /^:(.+)$/
+      if res = params_re.exec(part)
+        param_name = res[1]
+        pathRe.push options[param_name] ? '([^/]+)'
+        pathParams.push param_name
+      else
+        pathRe.push part
+
+    re = new RegExp('^/' + pathRe.join('/') + '$')
+
+    {
+      options
+      test: (path) -> re.test(path)
+      handle: (path) ->
+        params = {path: path}
+        res = re.exec(path)
+        if res? and res.length > 1
+          for pname,i in pathParams
+            params[pname] = decodeURI(res[i+1])
+
+        handle(params)
+    }