agt 0.0.1

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

@@ -0,0 +1,105 @@
+
+# Defines a local `requestAnimationFrame` function using the snippets
+# from [Paul Irish](http://paulirish.com/2011/requestanimationframe-for-smart-animating/).
+g = global ? window
+requestAnimFrame = g.requestAnimationFrame       or
+                   g.webkitRequestAnimationFrame or
+                   g.mozRequestAnimationFrame    or
+                   g.oRequestAnimationFrame      or
+                   g.msRequestAnimationFrame     or
+                   -> g.setTimeout callback, 1000 / 60
+
+# Public: Impulse is a custom signal whose purpose is to handle
+# animations within an application.
+#
+# The `Impulse` signal has its own messages to dispatch.
+#
+# Impulse dispatch its messages on a regular basis, based
+# on the `requestAnimationFrame` function.
+class agt.Impulse extends agt.Signal
+  ### Public ###
+
+  # Returns a global unique instance to use as reference
+  # in a typical application
+  #
+  # Returns an {agt.Impulse}
+  @instance: -> @__instance__ ||= new Impulse
+
+  # Initialize the `Impulse` signal with a specific time scale.
+  # By default the `timeScale` is `1`, which means there's no scaling.
+  constructor:(@timeScale=1)->
+    super()
+
+    @running = false
+
+  # Impulse listeners are registered as any other signal listeners.
+  #
+  # ```coffeescript
+  # impulse.add (bias, biasInSeconds, time) ->
+  # ```
+  #
+  # listener - The listener {Function} to register, with the following
+  #            signature:
+  #            :bias - The duration {Number} of the last animation
+  #                    frame in milliseconds.
+  #            :biasInSeconds - The duration {Number} of the last
+  #                             animation frame in seconds.
+  #            :time - The current time {Number} at the moment of the call.
+  # context - The this {Object} for the listener.
+  # priority - The priority {Number}, the greater the priority, the sooner
+  #            the listener will be called.
+  add:(listener, context, priority=0)->
+    super listener, context, priority
+
+    # By convention, the `Impulse` signal start running when the
+    # first listener is added.
+    @start() if @hasListeners() and not @running
+
+  # Impulse listeners are unregistered as any other signal listeners.
+  #
+  # listener - The {Function} to remove from this signal.
+  # context - The `this` {Object} that was registered with the listener.
+  remove:(listener, context)->
+    super listener, context
+
+    # The `Impulse` object automatically stop itself when it doesn't
+    # have a listener anymore.
+    @stop() if @running and not @hasListeners()
+
+  # {Delegates to: agt.Signal.hasListeners}
+  hasListeners:->
+    @listeners.length > 0
+
+  # Starts, or restarts the `Impulse`.
+  start:->
+    @running = true
+    @initRun()
+
+  # Stops the `Impulse`.
+  stop:->
+    @running = false
+
+  # Internal: Initializes the run of the `Impulse`. A request
+  # is made to the `requestAnimationFrame` that will
+  # call the `run` method each time.
+  initRun:->
+    @time = @getTime()
+    requestAnimFrame =>
+      @run()
+
+  # A running `Impulse` will dispatch various informations
+  # to its listeners each time the `run` method is called.
+  #
+  # The `initRun` is called at the end of the function if the impulse
+  # is always running in order to continue the animation.
+  run:->
+    if @running
+      t = @getTime()
+      s = ( t - @time ) * @timeScale
+
+      @dispatch s, s / 1000, t
+      @initRun()
+
+  # Internal: Helper method that return the current time.
+  getTime:->
+    new Date().getTime()

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

@@ -0,0 +1,56 @@
+# The module bootstrap.
+isCommonJS = typeof module isnt "undefined"
+
+__namespaces__ = {}
+
+if isCommonJS
+  module.exports = agt = {}
+else
+  window.agt = agt = {}
+
+namespace = (path) ->
+  return if __namespaces__[path]
+
+  __namespaces__[path] = true
+
+  originalPath = path
+  path = path.split('.')
+  root = path.shift()
+
+  obj = if isCommonJS
+    module.exports
+  else
+    window[root] ||= {}
+
+  for p in path
+    obj = obj[p] = obj[p] or {}
+
+window.namespace if window?
+
+agt.deprecated = (message) ->
+  parseLine = (line) ->
+    if line.indexOf('@') > 0
+      if line.indexOf('</') > 0
+        [m, o, f] = /<\/([^@]+)@(.)+$/.exec line
+      else
+        [m, f] = /@(.)+$/.exec line
+    else
+      if line.indexOf('(') > 0
+        [m, o, f] = /at\s+([^\s]+)\s*\(([^\)])+/.exec line
+      else
+        [m, f] = /at\s+([^\s]+)/.exec line
+
+    [o,f]
+
+  e = new Error()
+  caller = ''
+  if e.stack?
+    s = e.stack.split('\n')
+    [deprecatedMethodCallerName, deprecatedMethodCallerFile] = parseLine s[3]
+
+    caller = if deprecatedMethodCallerName
+      " (called from #{deprecatedMethodCallerName} at #{deprecatedMethodCallerFile})"
+    else
+       "(called from #{deprecatedMethodCallerFile})"
+
+  console.log "DEPRECATION WARNING: #{message}#{caller}"

data/app/assets/javascripts/agt/inflector/inflection.coffee

@@ -0,0 +1,21 @@
+namespace('agt.inflector')
+
+# Public: The `Inflection` class represent a single inflection for the general
+# case of pluralization, singularization and conversion to the past tense.
+class agt.inflector.Inflection
+  ### Public ###
+
+  # Creates a new instance.
+  #
+  # match - The {RegExp} or {String} to match.
+  # replace - The replacement {String}.
+  constructor: (@match, @replace) ->
+    @match = ///^#{@match}$///i if typeof @match is 'string'
+
+  # Converts the passed-in {String} if it matches the inflection's {RegExp}.
+  #
+  # string - The {String} to convert.
+  #
+  # Returns a {String}.
+  inflect: (string) ->
+    string.replace(@match, @replace) if @match.test(string)

data/app/assets/javascripts/agt/inflector/inflections.coffee

@@ -0,0 +1,75 @@
+
+agt.inflector.config 'en', ->
+  @plural(/$/, 's')
+  @plural(/s$/i, 's')
+  @plural(/^(ax|test)is$/i, '$1es')
+  @plural(/(octop|vir)us$/i, '$1i')
+  @plural(/(octop|vir)i$/i, '$1i')
+  @plural(/(alias|status)$/i, '$1es')
+  @plural(/(bu)s$/i, '$1ses')
+  @plural(/(buffal|tomat)o$/i, '$1oes')
+  @plural(/([ti])um$/i, '$1a')
+  @plural(/([ti])a$/i, '$1a')
+  @plural(/sis$/i, 'ses')
+  @plural(/(?:([^f])fe|([lr])f)$/i, '$1$2ves')
+  @plural(/(hive)$/i, '$1s')
+  @plural(/([^aeiouy]|qu)y$/i, '$1ies')
+  @plural(/(x|ch|ss|sh)$/i, '$1es')
+  @plural(/(matr|vert|ind)(?:ix|ex)$/i, '$1ices')
+  @plural(/^(m|l)ouse$/i, '$1ice')
+  @plural(/^(m|l)ice$/i, '$1ice')
+  @plural(/^(ox)$/i, '$1en')
+  @plural(/^(oxen)$/i, '$1')
+  @plural(/(quiz)$/i, '$1zes')
+
+  @singular(/s$/i, '')
+  @singular(/(ss)$/i, '$1')
+  @singular(/(n)ews$/i, '$1ews')
+  @singular(/([ti])a$/i, '$1um')
+  @singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '$1sis')
+  @singular(/(^analy)(sis|ses)$/i, '$1sis')
+  @singular(/([^f])ves$/i, '$1fe')
+  @singular(/(hive)s$/i, '$1')
+  @singular(/(tive)s$/i, '$1')
+  @singular(/([lr])ves$/i, '$1f')
+  @singular(/([^aeiouy]|qu)ies$/i, '$1y')
+  @singular(/(s)eries$/i, '$1eries')
+  @singular(/(m)ovies$/i, '$1ovie')
+  @singular(/(x|ch|ss|sh)es$/i, '$1')
+  @singular(/^(m|l)ice$/i, '$1ouse')
+  @singular(/(bus)(es)?$/i, '$1')
+  @singular(/(o)es$/i, '$1')
+  @singular(/(shoe)s$/i, '$1')
+  @singular(/(cris|test)(is|es)$/i, '$1is')
+  @singular(/^(a)x[ie]s$/i, '$1xis')
+  @singular(/(octop|vir)(us|i)$/i, '$1us')
+  @singular(/(alias|status)(es)?$/i, '$1')
+  @singular(/^(ox)en/i, '$1')
+  @singular(/(vert|ind)ices$/i, '$1ex')
+  @singular(/(matr)ices$/i, '$1ix')
+  @singular(/(quiz)zes$/i, '$1')
+  @singular(/(database)s$/i, '$1')
+
+  @irregular('person', 'people')
+  @irregular('man', 'men')
+  @irregular('child', 'children')
+  @irregular('sex', 'sexes')
+  @irregular('move', 'moves')
+  @irregular('zombie', 'zombies')
+
+  @uncountable('equipment', 'information', 'rice', 'money', 'species', 'series', 'fish', 'sheep', 'jeans ', 'police')
+
+  @pastTense /^(.*)$/,'$1ed'
+  @pastTense /e$/,'ed'
+  @pastTense /t$/,'ted'
+  @pastTense /g$/,'gged'
+  @pastTense /ight$/,'ought'
+  @pastTense "buy",'bought'
+  @pastTense "has",'had'
+  @pastTense "sell",'sold'
+  @pastTense "is",'was'
+  @pastTense "are",'were'
+  @pastTense "teach",'taught'
+  @pastTense "feel",'felt'
+  @pastTense "light",'lit'
+  @pastTense "find",'found'

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

@@ -0,0 +1,235 @@
+namespace('agt.inflector')
+# Public: The `Inflector` transform words from singular to plural
+# and verbs from present to past. The `agt.inflector` package is an instance
+# of the `Inflector` class with default inflections for english words and verbs.
+#
+# ```coffeescript
+# agt.inflector.config 'fr', ->
+#   @plural /$/, 's'
+#   @plural /^(bij|caill|ch|gen|hib|jouj|p)ou$/i, '$1oux'
+#   @plural /^(b|cor|ém|gemm|soupir|trav|vant|vitr)ail$/i, 'aux'
+#
+#   @singular /s$/i, ''
+#   @singular /oux$/i, 'ou'
+#   @singular /aux$/i, 'ail'
+#
+#   @uncountable 'discours', 'secours', 'souris'
+#
+#   @pastTense /^a$/i, 'eu'
+#   @pastTense /^est$/i, 'fut'
+#
+# agt.inflector.pluralize('fr', 'coup') # 'coups'
+# agt.inflector.pluralize('fr', 'hibou') # 'hiboux'
+# agt.inflector.pluralize('fr', 'discours') # 'discours'
+#
+# agt.inflector.singularize('fr', 'hiboux') # 'hibou'
+# agt.inflector.singularize('fr', 'coups') # 'coup'
+# ```
+class agt.inflector.Inflector
+
+  ### Public ###
+
+  # Extends or defines the inflections for a given language.
+  #
+  # ```coffee
+  # inflector.config 'en', ->
+  #   # ...
+  #
+  # inflector.config 'fr', ->
+  #   # ...
+  #
+  # inflector.config 'de', ->
+  #   # ...
+  # ```
+  #
+  # As the language is passed to the `config` function, the methods available
+  # inside the block doesn't require the `lang` argument as the `Inflector`
+  # methods does.
+  #
+  # lang - The language {String} to configurate.
+  # block - The configuration {Function} to call. The function is called
+  #         with the inflector as the `this` object as well as the sole
+  #         argument.
+  config: (lang, block) ->
+    scope =
+      plural: (m,r) => @plural(lang,m,r)
+      singular: (m,r) => @singular(lang,m,r)
+      irregular: (p,s) => @irregular(lang,p,s)
+      uncountable: (a...) => @uncountable(lang,a)
+      pastTense: (m,r) => @pastTense(lang,m,r)
+
+    block.call(scope, scope)
+
+  # Defines a pluralization inflection for the specified language.
+  #
+  # ```coffee
+  # inflector.plural 'fr', /$/, 's'
+  #
+  # inflector.plural 'fr', /(eu|eau|au)$/i, '$1x'
+  #
+  # inflector.plural 'fr', /^(bij|caill|ch|gen|hib|jouj|p)ou$/i, '$1oux'
+  # ```
+  #
+  # lang - The language {String} to configurate. Note that when inside
+  #        a configuration block this parameter is automatically set.
+  # match - The {RegExp} or the {String} that match words. When a string
+  #         is passed, the created regex is equivalent to `///^#{word}$///`.
+  # replace - The replacement {String}. Groups defined in the regex can be
+  #           freely used.
+  plural: (lang, match, replace) ->
+    @default(lang, 'plural')
+
+    inflection = new agt.inflector.Inflection(match, replace)
+    @inflections[lang].plural.push(inflection)
+
+
+  # Defines a singularization inflection for the specified language.
+  #
+  # ```coffee
+  # inflector.singlular 'fr', /s$/, ''
+  #
+  # inflector.singlular 'fr', /^(eu|eau|au)x$/i, '$1'
+  #
+  # inflector.singlular 'fr', /oux$/i, 'ou'
+  # ```
+  #
+  # lang - The language {String} to configurate. Note that when inside
+  #        a configuration block this parameter is automatically set.
+  # match - The {RegExp} or the {String} that match words. When a string
+  #         is passed, the created regex is equivalent to `///^#{word}$///`.
+  # replace - The replacement {String}. Groups defined in the regex can be
+  #           freely used.
+  singular: (lang, match, replace) ->
+    @default(lang, 'singular')
+
+    inflection = new agt.inflector.Inflection(match, replace)
+    @inflections[lang].singular.push(inflection)
+
+  # Defines an inflection for an irregular word which pluralization doesn't
+  # follow the general rules such as person and people in english.
+  #
+  # ```coffee
+  # inflector.irregular 'fr', 'ail', 'aulx'
+  # inflector.irregular 'fr', 'œuil', 'yeux'
+  # ```
+  #
+  # lang - The language {String} to configurate. Note that when inside
+  #        a configuration block this parameter is automatically set.
+  # singular - The singular {String} for the irregular word.
+  # plural - The plural {String} for the irregular word.
+  irregular: (lang, singular, plural) ->
+    @default(lang, 'plural')
+    @default(lang, 'singular')
+
+    pluralInflection = new agt.inflector.Inflection(singular, plural)
+    singularInflection = new agt.inflector.Inflection(plural, singular)
+    @inflections[lang].singular.push(singularInflection)
+    @inflections[lang].plural.push(pluralInflection)
+
+  # Defines one or many uncountable words. Uncountable words have a single
+  # form and are always returned as is in both {::pluralize} and {::singularize}
+  # methods.
+  #
+  # ```coffee
+  # inflector.uncountable 'fr', ['discours', 'secours']
+  #
+  # inflector.config 'fr', ->
+  #   @uncountable 'discours', 'secours'
+  # ```
+  #
+  # lang - The language {String} to configurate. Note that when inside
+  #        a configuration block this parameter is automatically set.
+  # uncountables - The {Array} of uncountable {String}. When inside
+  #                a configuration block, the uncountable words must be passed
+  #                as a list of {String}.
+  uncountable: (lang, uncountables) ->
+    @default(lang, 'uncountable')
+
+    @inflections[lang].uncountable = @inflections[lang].uncountable.concat(uncountables)
+
+  # Defines an inflection to convert a verb from its present form to its past
+  # form.
+  #
+  # ```coffee
+  # inflector.pastTense 'fr', /e/i, 'é'
+  # inflector.pastTense 'fr', /est/i, 'était'
+  # ```
+  #
+  # lang - The language {String} to configurate. Note that when inside
+  #        a configuration block this parameter is automatically set.
+  # match - The {RegExp} or the {String} that match words. When a string
+  #         is passed, the created regex is equivalent to `///^#{word}$///`.
+  # replace - The replacement {String}. Groups defined in the regex can be
+  #           freely used.
+  pastTense: (lang, match, replace) ->
+    @default(lang, 'past')
+
+    inflection = new agt.inflector.Inflection(match, replace)
+    @inflections[lang].past.push(inflection)
+
+  # Conversion Methods
+
+  # Returns the passed-in {String} in its pluralized form.
+  #
+  # string - The {String} to pluralize.
+  # lang - The language {String} to use.
+  #
+  # Returns a {String}.
+  pluralize: (string, lang='en') -> @inflect('plural', string, lang)
+
+  # Returns the passed-in {String} in its singularized form.
+  #
+  # string - The {String} to singularize.
+  # lang - The language {String} to use.
+  #
+  # Returns a {String}.
+  singularize: (string, lang='en') -> @inflect('singular', string, lang)
+
+  # Returns the passed-in {String} in its past form.
+  #
+  # string - The {String} to conjugate to the past.
+  # lang - The language {String} to use.
+  #
+  # Returns a {String}.
+  toPast: (string, lang='en') -> @inflect('past', string, lang)
+
+  ### Internal ###
+
+  # Realizes the inflection for the passed-in string based on the specified
+  # conversion mode.
+  #
+  # conversion - The {String} kind of conversion to apply.
+  # string - The {String} to convert.
+  # lang - The language {String} to use.
+  #
+  # Returns a {String}.
+  inflect: (conversion, string, lang='en') ->
+    result = string
+    return result if string is '' or string in @inflections[lang].uncountable
+
+    inflections = @inflections[lang][conversion]
+
+    return result if not inflections? or inflections.length is 0
+
+    reversed = []
+    reversed.unshift(o) for o in inflections
+
+    reversed.some (inflection) ->
+      res = inflection.inflect(string)
+      result = res if res?
+      res
+
+    result
+
+  # Defines a new collection on the `inflections` object for the specified
+  # `lang`.
+  #
+  # lang - The target language {String}.
+  # collection - The {String} name of the collection to create.
+  default: (lang, collection)->
+    @inflections ||= {}
+    @inflections[lang] ||= {}
+    @inflections[lang][collection] ||= []
+
+agt.inflector = new agt.inflector.Inflector
+agt.inflector.Inflector = agt.inflector.constructor