ela 1.1.0

data/app/js/lib/models/app.coffee

@@ -0,0 +1,58 @@
+ELA.Models ?= {}
+class ELA.Models.App extends Backbone.Model
+  helpText: 'about'
+
+  defaults:
+    path: null
+    params: null
+    showAbout: false
+
+  initialize: ->
+    @on('change:path', @handlePath)
+    @on('change:params', @handleParams)
+
+  # @returns BaseApp or BaseSubappContainer
+  currentAppModel: ->
+    @get('currentAppModel')
+
+  # @returns BaseApp
+  currentApp: ->
+    @currentAppModel()?.currentApp()
+
+  currentNamespace: ->
+    path = @get('path')
+    if path?
+      klass = path[0].toCapitalCamel()
+      ELA[klass]
+
+  handlePath: (model, path) ->
+    if path?
+      if path[0] is 'about'
+        @set(showAbout: true)
+      else if path[0] isnt @currentAppModel()?.name
+        AppClass = @currentNamespace().Models.App
+        @set
+          showAbout: false
+          currentAppModel: new AppClass(path: path.slice(1))
+      else
+        @currentAppModel()?.set(path: path.slice(1))
+        @set(showAbout: false)
+    else
+      @set
+        currentAppModel: null
+        showAbout: false
+
+  handleParams: (model, params) ->
+    @currentApp().deserialize(params) if params?
+
+  url: ->
+    url = location.origin
+    if json = @toJSON()
+      url += '/#app/' +
+        @get('path').join('/') +
+        '?' +
+        encodeURI(json)
+    url
+
+  toJSON: ->
+    JSON.stringify(currentApp.serialize()) if currentApp = @currentApp()

data/app/js/lib/models/base_app.coffee

@@ -0,0 +1,62 @@
+ELA.Models ?= {}
+class ELA.Models.BaseApp extends ELA.Models.BaseAppModel
+  hasHelpText: true
+
+  initialize: (options = {}) ->
+    @parentApp = options.parentApp
+
+    @on 'change:path', @handlePath
+    @set currentAside: @get('currentAside') or null
+    @handlePath()
+
+  handlePath: =>
+    path = @get('path')?[0]
+    if path is 'help'
+      @set showHelp: true
+    else
+      @set showHelp: false
+
+  helpTextName: =>
+    @path.replace('/', '_')
+
+  # Initialize the curves attribute with all necessary options.
+  #
+  # @param [Array] curves curves to add to the curves collection
+  # @param [Object] options reached through to collection initialization
+  initCurves: (curves, options = {}) ->
+    @curves = new ELA.Collections.Curves(curves, options)
+
+  currentApp: -> this
+
+  serialize: ->
+    v = parameters: _.pick(
+        @attributes
+        _.keys(@defaults())
+      )
+    if @curves?
+      v.selectedCurves = for curve in @curves.getHistory()
+        curve.get('function')
+    if @displayParams?
+      v.displayParams = @displayParams.serialize()
+    if @get('axisLabelingForCurve')?
+      v.axisLabelingForCurve = @get('axisLabelingForCurve').get('function')
+    v
+
+  deserialize: (params) ->
+    @set(params.parameters)
+
+    for curve in @curves.models
+      curve.set(selected: false)
+
+    for curve in @curves.models
+      curveFunction = curve.get('function')
+      if _.contains(params.selectedCurves, curveFunction)
+        curve.set(selected: true)
+        if curveFunction is params.axisLabelingForCurve
+          @set(axisLabelingForCurve: curve)
+
+    # Wait until graphView has been created, it's initializer resets
+    # displayParams
+    if params.displayParams?
+      _.defer =>
+        @displayParams.deserialize(params.displayParams)

data/app/js/lib/models/base_app_model.coffee

@@ -0,0 +1,61 @@
+ELA.Models ?= {}
+class ELA.Models.BaseAppModel extends Backbone.Model
+  # Returns the locale prefixes for the current app. Subapps have all
+  # levels as prefix.
+  localePrefix: (append = null) ->
+    prefixes = []
+    path = @path.split('/')
+    path.push(append) if append?
+    until path.length < 1
+      prefixes.push(path.join('.'))
+      path.pop()
+    if prefixes.length <= 0
+      null
+    else if prefixes.length is 1
+      prefixes[0]
+    else
+      prefixes
+
+  # Loads the settings for the current app. This function is subapp
+  # aware meaning it prefers the current subapps settings, then the
+  # parent apps settings.
+  #
+  # @param [String] type the settings type (e.g. curves, formFields, defaults, etc.)
+  # @param [String] key the settings key (may be undefined)
+  # @param [Object] defaults the fixed defaults (those may not be overwritten)
+  # @returns [Object] the merged settings
+  loadSettings: (type, key, defaults = {}) ->
+    @settings ||= {}
+    settings = @settings["#{type}_#{key}"] ||= do =>
+      settings = {}
+      pathComponents = @path.split('/')
+      until pathComponents.length < 1
+        step = ELA.settings
+        step = step[component] for component in pathComponents when step?
+        if type? and key?
+          settings = $.extend step?[type]?[key], settings
+        else
+          settings = $.extend step?[type], settings
+        pathComponents.pop()
+      settings
+    $.extend settings, defaults
+
+  # Loads the default parameters for the current app.
+  defaults: ->
+    @loadSettings('defaults')
+
+  # Loads the settings for a specific form field.
+  #
+  # @param [String] attribute the name of the attribute
+  # @param [Object] defaults
+  loadFormFieldSettings: (attribute, defaults = {}) ->
+    defaults.attribute = attribute
+    @loadSettings('formFields', attribute, defaults)
+
+  # Loads the curve settings for given FUN for the current app.
+  #
+  # @param [String] fun name of the curve function
+  # @param [Object] defaults default values
+  loadCurveSettings: (fun, defaults = {}) ->
+    defaults.function = fun
+    @loadSettings('curves', fun, defaults)

data/app/js/lib/models/base_calculator.coffee

@@ -0,0 +1,212 @@
+ELA.Models ?= {}
+class ELA.Models.BaseCalculator
+  _.extend @prototype, Backbone.Events
+
+  xRange: (func) -> 1.0
+  yRange: (func) ->
+    curve = func
+    group = _.find @curveGroups, (group) -> _.contains(group, curve)
+    minY = null
+    maxY = null
+    if group?
+      for func in group when _.isFunction(@[func])
+        result = @[func]()
+        maxY = Math.max(result.maxY, maxY)
+        minY = Math.min(result.minY, minY)
+    else
+      result = null
+      if _.isFunction(@[func])
+        result = @[func]()
+      else
+        throw new Error("#{func} does not specify a calculator function in #{name}")
+      minY = result.minY
+      maxY = result.maxY
+
+    range = 0
+    range += maxY if maxY > 0
+    range -= minY if minY < 0
+    range
+
+  constructor: (options) ->
+    for required in (options.required or [])
+      throw "Missing `#{required}` option" unless options[required]?
+
+    models = _.omit(options, 'required')
+
+    @_memo = {}
+
+    this[name] = model for name, model of models
+
+    @bindEvents(models)
+
+  bindEvents: (models = {}) ->
+    @stopListening()
+    for key, obj of models
+      do =>
+        if obj.on?
+          modelName = _.clone(key)
+          @listenTo obj, 'change', (model) =>
+            for attribute, value of model.changed
+              @trigger("change:#{modelName}.#{attribute}", model, value)
+
+  @_parseForDeps: (funcStr) ->
+    for dep in (funcStr.match(/this.([$_a-zA-Z][$_a-zA-Z0-9]*(\.get)?(\([^\)]*\))?)/g) or [])
+      dep = dep.slice(5)
+      continue if /^[_A-Z][_A-Z0-9]*$/.test(dep) # skip CONSTANTS
+      if (match = dep.match(/([^.]+)\.get\(['"]([^'"]+)['"]\)/))
+        "#{match[1]}.#{match[2]}"
+      else
+        ampIndex = dep.indexOf('(')
+        if ampIndex > 0
+          # Search within parentheses again
+          [dep.slice(0, ampIndex), @_parseForDeps(dep.slice(ampIndex))]
+        else
+          dep
+
+  @extractDeps: (func) ->
+    deps = @_parseForDeps(func.toString())
+    _.chain(deps).flatten().compact().uniq().value()
+
+  @memoize: (name, func) ->
+    resolveDeps = (f) ->
+      depsBefore = ''
+      until f.deps.join('') is depsBefore
+        depsBefore = f.deps.join('')
+        f.deps = for dep in f.deps
+          if /([^.]+)\.([^.]+)/.test(dep)
+            dep
+          else if this[dep]?
+            this[dep].deps or dep
+        f.deps = _.chain(f.deps).flatten().compact().uniq().value()
+      f.depsResolved = true
+
+    bindDeps = (f, callback) ->
+      for dep in f.deps
+        @on "change:#{dep}", =>
+          callback()
+          @trigger("change:#{name}")
+      @_memo[name].eventsBound = true
+
+    parameters = do ->
+      funcStr = func.toString()
+      if (match = funcStr.match(/function ?\(([^\)]+)\)/))?
+        match[1].split(',')
+      else
+        []
+
+    # TODO: Bind Events for dynamic dependencies like this[func] where
+    # func is a string parameter when calling the function.
+    f = if parameters.length > 0
+      ->
+        @_memo[name] ||= values: {}, eventsBound: false
+        key = JSON.stringify(arguments)
+
+        unless @_memo[name].values[key]?
+          @_memo[name].values[key] = func.apply(this, arguments)
+
+        resolveDeps.call(this, f) unless f.depsResolved
+
+        unless @_memo[name].eventsBound
+          bindDeps.call this, f, =>
+            @_memo[name].values = {}
+
+        @_memo[name].values[key]
+
+    else
+      ->
+        @_memo[name] ||= eventsBound: false
+
+        unless @_memo[name].value?
+          @_memo[name].value = func.apply(this, arguments)
+
+        resolveDeps.call(this, f) unless f.depsResolved
+
+        unless @_memo[name].eventsBound
+          bindDeps.call this, f, =>
+            @_memo[name].value = null
+
+        @_memo[name].value
+
+    f.depsResolved = false
+    f.memoizable = true
+    f.deps = @extractDeps(func)
+    f
+
+  @reactive: (name, func) ->
+    resolveDeps = (f) ->
+      depsBefore = ''
+      resolvedDeps = [] # required to avoid loops
+      until f.deps.join('') is depsBefore
+        depsBefore = f.deps.join('')
+        f.deps = for dep in f.deps
+          continue if dep is name
+          if /([^.]+)\.([^.]+)/.test(dep)
+            dep
+          else if this[dep]? and not _.contains(resolvedDeps, dep)
+            resolvedDeps.push(dep)
+            this[dep].deps or dep
+        f.deps = _.chain(f.deps).flatten().compact().uniq().value()
+      f.depsResolved = true
+
+    bindDeps = (f, callback) ->
+      for dep in f.deps
+        @on "change:#{dep}", =>
+          callback() if callback?
+          @trigger("change:#{name}")
+      @_memo[name].eventsBound = true
+
+    parameters = do ->
+      funcStr = func.toString()
+      if (match = funcStr.match(/function \(([^\)]+)\)/))?
+        match[1].split(',')
+      else
+        []
+
+    # TODO: Bind Events for dynamic dependencies like this[func] where
+    # func is a string parameter when calling the function.
+    f = ->
+      @_memo[name] ||= eventsBound: false
+      resolveDeps.call(this, f) unless f.depsResolved
+      bindDeps.call(this, f) unless @_memo[name].eventsBound
+      f._func.apply(this, arguments)
+
+    f.depsResolved = false
+    f.memoizable = false
+    f.deps = @extractDeps(func)
+    f._func = func
+    f
+
+  clearMemoizations: ->
+    for key, memo of @_memo
+      memo.value = null if _.has(memo, 'value')
+      memo.values = {} if _.has(memo, 'values')
+
+  pole: (func, options = {}) ->
+    precision = Math.abs(options.precision or 0.001)
+    min       = options.min or 0.0
+    max       = options.max or 1.0
+    middle    = (max + min)*0.5
+
+    minPos    = this[func](min)    > 0
+    maxPos    = this[func](max)    > 0
+    middlePos = this[func](middle) > 0
+
+    n = 0
+    if minPos is maxPos
+      return max
+    else
+      while middle - min > precision
+        y = this[func](middle)
+        return middle if y is Infinity or y is -Infinity
+
+        if minPos is middlePos
+          min = middle
+          minPos = middlePos
+        else
+          max = middle
+          maxPos = middlePos
+
+        middle = (max + min)*0.5
+        middlePos = this[func](middle) > 0
+        n += 1
+    min

data/app/js/lib/models/base_subapp_container.coffee

@@ -0,0 +1,35 @@
+ELA.Models ?= {}
+class ELA.Models.BaseSubappContainer extends ELA.Models.BaseAppModel
+  subapps: {}
+
+  initialize: (options = {}) ->
+    @subappInstances = {}
+
+    for name, app of @subapps
+      AppModel = app.model.toFunction()
+      @subappInstances[name] = new AppModel
+        parentApp: this
+
+    @on 'change:path', @handlePath
+    @handlePath()
+
+  handlePath: =>
+    path = @get('path')
+    subapp = path[0]
+    if _.isEmpty(path)
+      subappPath = @subappInfo()[0].path
+      ELA.router.navigate "app/#{subappPath}",
+        trigger: false
+        replace: true
+      [..., last] = subappPath.split('/')
+      path.push(last)
+
+    @subappInstances[subapp]?.set(path: path.slice(1))
+
+  subappInfo: ->
+    for name, app of @subappInstances
+      name: app.name
+      path: app.path
+
+  currentApp: ->
+    @subappInstances[@get('path')[0]]

data/app/js/lib/models/curve.coffee

@@ -0,0 +1,179 @@
+ELA.Models ?= {}
+class ELA.Models.Curve extends Backbone.Model
+  defaults:
+    selected: false
+    lineDash: null
+    lineWidth: 3
+    zIndex: 0
+    group: 'general'
+  parentCurve: null
+
+  # https://jsfiddle.net/wct4bctb/
+  LINE_DASHES: [
+    [],
+    [6, 4],                          # 10
+    [2, 2],                          # 4
+    [2, 4, 10, 4],                   # 20
+    [2, 4, 2, 4, 2, 4, 2, 4, 10, 4], # 38
+    [26, 6],                         # 32
+    [2, 4, 26, 4]                    # 36
+    [2, 4, 2, 4, 2, 4, 2, 4, 26, 4]  # 54
+  ]
+
+  initialize: (attributes, options = {}) ->
+    super
+
+    # We have to reinitialize the subcurves every time. Otherwise they
+    # stay as Curve objects in the Model (Beware the scope of the
+    # subcurves reference, its class wide).
+    subcurves = {}
+    for name, subcurve of (attributes.subcurves or {})
+      subcurves[name] = new ELA.Models.Curve(subcurve, parentCurve: this)
+    @set('subcurves', subcurves)
+    @parentCurve = options.parentCurve if options.parentCurve?
+
+  showInLegend: ->
+    show = @get('showInLegend')
+    if show? then show else true
+
+  strokeStyle: ->
+    if @get('strokeStyle')?
+      @get('strokeStyle')
+    else if @parentCurve?
+      @parentCurve.strokeStyle()
+    else
+      index = @collection.filter((c) -> c.attributes.strokeStyle is undefined).indexOf(this)
+      length = @collection.length
+      saturation = Math.round(65 - 40 * ((index % 20) / 20))
+      luminance = Math.round(65 - 15 * ((index % 20) / 20 + 1))
+      distance = 360 * 0.61088
+      hue = index * distance
+      'hsl(' + hue + ",#{saturation}%,#{luminance}%)"
+
+  # @return Array canvas lineDash definition
+  lineDash: (idx = 0) ->
+    @get('lineDash') or @LINE_DASHES[idx % @LINE_DASHES.length]
+
+  hasSubcurves: ->
+    _.keys(@subcurves()).length > 0
+
+  subcurves: ->
+    @get('subcurves')
+
+  subcurve: (key) ->
+    @get('subcurves')[key]
+
+  select: => @set(selected: true)
+  deselect: => @set(selected: false)
+
+  toJSON: =>
+    _.defaults super(),
+      strokeStyle: @strokeStyle()
+      hsl: @strokeStyle()
+
+  Presenter: class Presenter extends Backbone.Poised.View
+    unitValue: (value) ->
+      unitFn = @model.get('unitFn')
+      return unitFn(value) if _.isFunction(unitFn)
+
+      unitFactor = @model.get('unitFactor')
+      return unitFactor * value if unitFactor?
+
+      value
+
+    # Returns the label.
+    #
+    # @return String The label
+    label: ->
+      @_label ||= do =>
+        func = @model.get('function')
+        @loadLocale "curves.#{func}.label", "curves.#{func}.yAxisLabel", "curves.#{func}.xAxisLabel",
+          'curves.yAxisLabel', 'curves.xAxisLabel',
+          defaultValue: func.toLabel()
+
+    # Returns the x-axis label.
+    #
+    # @return String The label for the x-axis
+    xAxisLabel: ->
+      @_xAxisLabel ||= do =>
+        func = @model.get('function')
+        @loadLocale "curves.#{func}.xAxisLabel", 'curves.xAxisLabel',
+          defaultValue: func.toLabel()
+
+    # Returns the y-axis label.
+    #
+    # @return String The label for the y-axis
+    yAxisLabel: ->
+      @_yAxisLabel ||= do =>
+        func = @model.get('function')
+        @loadLocale "curves.#{func}.yAxisLabel", 'curves.yAxisLabel',
+          defaultValue: func.toLabel()
+
+    # Returns the y axis unit label.
+    #
+    # With the introduction of distinction between curve specific x
+    # and y axis labeling, this function is deprecated in favor of
+    # `#xAxisUnitLabel` and `#yAxisUnitLabel`.
+    #
+    # @deprecated
+    #
+    # @return String The unit for the y-axis
+    unitLabel: ->
+      console.log('ELA.Models.Curve.Presenter#unitLabel is deprecated.')
+      unit = @model.get('unit')
+      if unit then "[#{unit}]" else ''
+
+    # Returns the x-axis unit label.
+    #
+    # @return String The unit for the x-axis
+    xAxisUnitLabel: ->
+      @_xAxisUnitLabel ||= do =>
+        func = @model.get('function')
+        @loadLocale "curves.#{func}.xAxisUnitLabel", 'curves.xAxisUnitLabel',
+          returnNull: true
+
+    # Returns the y axis unit label.
+    #
+    # @return String The unit for the y-axis
+    yAxisUnitLabel: ->
+      @_yAxisUnitLabel ||= do =>
+        func = @model.get('function')
+        @loadLocale "curves.#{func}.yAxisUnitLabel", 'curves.yAxisUnitLabel',
+          returnNull: true
+
+    # Returns the full label as concatenation of `#label` and
+    # `#unitLabel`. Generally used for curve specific axis labling.
+    #
+    # With the introduction of distinction between curve specific x
+    # and y axis labeling, this function is deprecated in favor of
+    # `#fullXAxisLabel` and `#fullYAxisLabel`.
+    #
+    # @deprecated
+    #
+    # @return String The full curve label
+    fullLabel: ->
+      console.log('ELA.Models.Curve.Presenter#fullLabel is deprecated.')
+      "#{@label()} #{@unitLabel()}"
+
+    # Returns the full label for the x-axis as concatenation of label
+    # and unit label.
+    #
+    # @return String The full label for the x-axis
+    fullXAxisLabel: ->
+      unit = @xAxisUnitLabel()
+      unit = if unit? then " [#{unit}]" else ''
+      "#{@xAxisLabel()}#{unit}"
+
+    # Returns the full label for the y-axis as concatenation of label
+    # and unit label.
+    #
+    # @return String The full label for the y-axis
+    fullYAxisLabel: ->
+      unit = @yAxisUnitLabel()
+      unit = if unit? then " [#{unit}]" else ''
+      "#{@yAxisLabel()}#{unit}"
+
+    subcurveLabel: (subcurve) ->
+      func = @model.get('function')
+      @loadLocale "curves.#{func}.subcurves.#{subcurve}.label",
+        defaultValue: func