Gecko [ gandhischool.edu.np ]

Name	Size	Permission
ParsedError.coffee	5.27 KB	-rw-rw-rw-
PrettyError.coffee	7.39 KB	-rw-rw-rw-
defaultStyle.coffee	1.25 KB	-rw-rw-rw-
nodePaths.coffee	813 B	-rw-rw-rw-

Code Editor : ParsedError.coffee

sysPath = require 'path'

module.exports = class ParsedError
  constructor: (@error) ->
    do @_parse

_parse: ->
    @_trace = []
    @_kind = 'Error'
    @_wrapper = ''

@_wrapper = String @error.wrapper if @error.wrapper?

unless typeof @error is 'object'
      @_message = String @error
    else
      @_stack = @error.stack

if @error.kind?
        @_kind = String @error.kind
      else if typeof @_stack is 'string'
        if m = @_stack.match /^([a-zA-Z0-9\_\$]+):\ /
          @_kind = m[1]

@_message = @error.message? and String(@error.message) or ''
      if typeof @_stack is 'string'
        @_parseStack()

return

_parseStack: ->
    messageLines = []
    reachedTrace = no

for line in @_stack.split '\n'
      continue if line.trim() is ''
      if reachedTrace
        @_trace.push @_parseTraceItem line
      else
        if line.match /^\s*at\s.+/
          reachedTrace = yes
          @_trace.push @_parseTraceItem line
        else if !@_message.split '\n'.indexOf line
          messageLines.push line

message = messageLines.join '\n'
    if message.substr(0, @_kind.length) is @_kind
      message =
        message
        .substr(@_kind.length, message.length)
        .replace(/^\:\s+/, '')

if message.length
      @_message = if @_message.length
      then [
        @_message
        message
      ].join '\n'
      else
        message

return

_parseTraceItem: (text) ->
    text = text.trim()

return if text is ''
    return text unless text.match /^at\ /

# remove the 'at ' part
    text = text.replace /^at /, ''

return if text in ['Error (<anonymous>)', 'Error (<anonymous>:null:null)']

original = text

# the part that comes before the address
    what = null

# address, including path to module and line/col
    addr = null

# path to module
    path = null

# module dir
    dir = null

# module basename
    file = null

# line number (if using a compiler, the line number of the module
    # in that compiler will be used)
    line = null

# column, same as above
    col = null

# if using a compiler, this will translate to the line number of
    # the js equivalent of that module
    jsLine = null

# like above
    jsCol = null

# path that doesn't include `node_module` dirs
    shortenedPath = null

# like above
    shortenedAddr = null

packageName = '[current]'

# pick out the address
    if m = text.match /$([^$]+)\)$/
      addr = m[1].trim()

if addr?
      what = text.substr 0, text.length - addr.length - 2
      what = what.trim()

# might not have a 'what' clause
    unless addr?
      addr = text.trim()

addr = @_fixPath addr
    remaining = addr

# remove the <js> clause if the file is a compiled one
    if m = remaining.match /\,\ <js>:(\d+):(\d+)$/
      jsLine = m[1]
      jsCol = m[2]
      remaining = remaining.substr 0, remaining.length - m[0].length

# the line/col part
    if m = remaining.match /:(\d+):(\d+)$/
      line = m[1]
      col = m[2]
      remaining = remaining.substr 0, remaining.length - m[0].length
      path = remaining

# file and dir
    if path?
      file = sysPath.basename path
      dir = sysPath.dirname path

if dir is '.' then dir = ''

path = @_fixPath path
      file = @_fixPath file
      dir = @_fixPath dir

if dir?
      d = dir.replace /[\\]{1,2}/g, '/'
      if m = d.match ///
          node_modules/([^/]+)(?!.*node_modules.*)
        ///

packageName = m[1]

unless jsLine?
      jsLine = line
      jsCol = col

if path?
      r = @_rectifyPath path
      shortenedPath = r.path
      shortenedAddr = shortenedPath + addr.substr(path.length, addr.length)
      packages = r.packages

original: original
    what: what
    addr: addr
    path: path
    dir: dir
    file: file
    line: parseInt line
    col: parseInt col
    jsLine: parseInt jsLine
    jsCol: parseInt jsCol
    packageName: packageName
    shortenedPath: shortenedPath
    shortenedAddr: shortenedAddr
    packages: packages || []

_getMessage: -> @_message
  _getKind: -> @_kind
  _getWrapper: -> @_wrapper
  _getStack: -> @_stack
  _getArguments: -> @error.arguments
  _getType: -> @error.type
  _getTrace: -> @_trace
  _fixPath: (path) -> path.replace(///[\\]{1,2}///g, '/')

_rectifyPath: (path, nameForCurrentPackage) ->
    path = String path
    remaining = path

return path: path, packages: [] unless m = path.match /^(.+?)\/node_modules\/(.+)$/

parts = []
    packages = []

if typeof nameForCurrentPackage is 'string'
      parts.push "[#{nameForCurrentPackage}]"
      packages.push "[#{nameForCurrentPackage}]"
    else
      parts.push "[#{m[1].match(/([^\/]+)$/)[1]}]"
      packages.push m[1].match(/([^\/]+)$/)[1]

rest = m[2]

while m = rest.match /([^\/]+)\/node_modules\/(.+)$/
      parts.push "[#{m[1]}]"
      packages.push m[1]
      rest = m[2]

if m = rest.match /([^\/]+)\/(.+)$/
      parts.push "[#{m[1]}]"
      packages.push m[1]
      rest = m[2]

parts.push rest

path: parts.join "/"
    packages: packages

for prop in ['message', 'kind', 'arguments', 'type', 'stack', 'trace', 'wrapper'] then do ->
  methodName = '_get' + prop[0].toUpperCase() + prop.substr(1, prop.length)

Object.defineProperty ParsedError::, prop,
    get: -> this[methodName]()

${this.title}

Code Editor : ParsedError.coffee