squash_javascript 1.0.0

data/lib/squash/javascript/source_map.rb

@@ -0,0 +1,181 @@
+# Copyright 2012 Square Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+require 'json'
+
+# An in-memory representation of a JavaScript source map.
+
+class Squash::Javascript::SourceMap
+  # @private
+  VLQ_CONTINUATION_BIT = 1 << 5
+
+  # @return [Array<Squash::Javascript::SourceMap::Mapping>] The individual
+  #   mappings in this source map.
+  attr_reader :mappings
+
+  # @private
+  def initialize(entries=[])
+    @mappings = entries
+    sort!
+  end
+
+  # Parses a JSON version-3 source map file and generates a SourceMap from it.
+  #
+  # @param [String] source_file A path to a source map file.
+  # @param [String] route The URL where the compiled JavaScript asset is
+  #   accessed.
+  # @param [Hash] options Additional options.
+  # @option options [String] :root If set, overrides the project root specified
+  #   in the `sourceRoot` field with this root. Absolute paths will be converted
+  #   into project-local paths (suitable for Git-blaming) using this root.
+
+  def self.from_sourcemap(source_file, route, options={})
+    fields = JSON.parse(File.read(source_file))
+    raise "Only version 3 source maps are supported" unless fields['version'] == 3
+
+    project_root = options[:root] || fields['sourceRoot'] or raise("Must specify a project root in the source map or method options")
+    project_root << '/' unless project_root[-2..-1] == '/'
+
+    route   = route
+    sources = fields['sources'].map { |source| source.sub(/^#{Regexp.escape project_root}/, '') }
+    names   = fields['names']
+
+    mappings = fields['mappings'].split(';').map { |group| group.split ',' }
+    entries  = Array.new
+
+    source_file_counter   = 0
+    source_line_counter   = 0
+    source_column_counter = 0
+    symbol_counter        = 0
+    mappings.each_with_index do |group, compiled_line_number|
+      compiled_column_counter = 0
+      group.each do |segment|
+        values                  = decode64vlq(segment)
+        compiled_column_counter += values[0]
+        source_file_counter += values[1] if values[1]
+        source_line_counter += values[2] if values[2]
+        source_column_counter += values[3] if values[3]
+        symbol_counter += values[4] if values[4]
+        entries << Mapping.new(
+            route, compiled_line_number, compiled_column_counter,
+            sources[source_file_counter], source_line_counter, source_column_counter,
+            names[symbol_counter]
+        )
+      end
+    end
+
+    return new(entries)
+  end
+
+  # @private
+  def <<(obj)
+    @mappings << obj
+    sort!
+  end
+
+  # Given the URL of a minified JavaScript asset, and a line and column number,
+  # attempts to locate the original source file and line number.
+  #
+  # @param [String] route The URL of the JavaScript file.
+  # @param [Fixnum] line The line number.
+  # @param [Fixnum] column The character number within the line.
+
+  def resolve(route, line, column)
+    index   = 0
+    mapping = nil
+    while index < mappings.length
+      entry = mappings[index]
+      mapping = entry if entry.route == route && entry.compiled_line == line && entry.compiled_column <= column
+      break if entry.route > route || entry.compiled_line > line
+      index += 1
+    end
+
+    return mapping
+  end
+
+  private
+
+  def sort!
+    @mappings.sort_by! { |m| [m.route, m.compiled_line, m.compiled_column] }
+  end
+
+  def self.decode64vlq(string)
+    bytes      = string.bytes.to_a
+    byte_index = 0
+    result     = []
+
+    begin
+      raise "Base-64 VLQ-encoded string unexpectedly terminated" if byte_index >= string.bytesize
+
+      number       = 0
+      continuation = false
+      shift        = 0
+      begin
+        # each character corresponds to a 6-bit word
+        digit        = decode64(bytes[byte_index])
+        byte_index   += 1
+        # the most significant bit is the continuation bit
+        continuation = (digit & VLQ_CONTINUATION_BIT) != 0
+        # the remaining bits are the number
+        digit        = digit & (VLQ_CONTINUATION_BIT - 1)
+        # continuations are little-endian
+        number       += (digit << shift)
+        shift        += 5
+      end while continuation
+
+      # the LSB is the sign bit
+      number = (number & 1 > 0) ? -(number >> 1) : (number >> 1)
+      result << number
+    end while byte_index < string.bytesize
+
+    return result
+  end
+
+  def self.decode64(byte)
+    case byte
+      when 65..90  then byte - 65 # A..Z => 0..25
+      when 97..122 then byte - 71 # a..z => 26..51
+      when 48..57  then byte + 4  # 0..9 => 52..61
+      when 43      then 62        # + => 62
+      when 47      then 63        # / => 63
+      else raise "Invalid byte #{byte} in base-64 VLQ string"
+    end
+  end
+
+  class Mapping
+    attr_accessor :route, :compiled_line, :compiled_column, :source_file, :source_line, :source_column, :symbol
+
+    def self.from_json(obj)
+      new *obj
+    end
+
+    def initialize(route, compiled_line, compiled_column, source_file, source_line, source_column, symbol)
+      @route           = route
+      @compiled_line   = compiled_line
+      @compiled_column = compiled_column
+      @source_file     = source_file
+      @source_line     = source_line
+      @source_column   = source_column
+      @symbol          = symbol
+    end
+
+    def as_json(options=nil)
+      [route, compiled_line, compiled_column, source_file, source_line, source_column, symbol]
+    end
+
+    def to_json(options=nil)
+      as_json.to_json
+    end
+  end
+end

data/lib/squash/javascript.rb

@@ -0,0 +1,26 @@
+# Copyright 2012 Square Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+# Container module for classes relating to Squash.
+
+module Squash
+
+  # Container module for classes relating to the JavaScript client library.
+
+  module Javascript
+  end
+end
+
+require 'squash/javascript/source_map'
+require 'squash/javascript/engine'

data/vendor/assets/javascripts/squash_javascript/client.coffee

@@ -0,0 +1,219 @@
+# Copyright 2012 Square Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+root = exports ? this
+
+# Singleton class for the client library. See the README file for usage
+# examples. The singleton instance is accessed using the {.instance} method.
+#
+class root.SquashJavascript
+  _instance = undefined
+
+  # @return [_SquashJavascript] The singleton instance.
+  #
+  @instance: -> _instance ?= new _SquashJavascript()
+
+# See {root.SquashJavascript}.
+#
+class _SquashJavascript
+  # @private
+  constructor: ->
+    TraceKit.report.subscribe (error) -> SquashJavascript.instance().report(error)
+
+  # Sets configuration options. See the README file for a list of accepted
+  # configuration options. Multiple calls will merge new options in.
+  #
+  # @param [Object] options New options to apply.
+  #
+  configure: (options) ->
+    @options ||= {
+        disabled: false
+        notifyPath: '/api/1.0/notify'
+        transmitTimeout: 15000
+        ignoredExceptionClasses: []
+        ignoredExceptionMessages: {}
+    }
+    for own key, value of options
+      @options[key] = value
+
+  # Notify Squash of an error. The client must be configured first. The error
+  # must have a valid stack trace (i.e., it must have been thrown). Does not
+  # re-throw the error; that's your responsibility.
+  #
+  # You shouldn't normally need to call this method. Squash automatically
+  # installs a listener that notifies the server for thrown exceptions.
+  #
+  # @param [Error] error The error to record.
+  #
+  notify: (error) ->
+    if error instanceof Error
+      TraceKit.report(error)
+    else
+      throw error
+
+  # @private
+  report: (error) ->
+    try
+      return false if @options?.disabled
+      if !@options?.APIKey || !@options?.environment ||
+          !@options?.revision || !@options?.APIHost
+        console.error "Missing required Squash configuration keys"
+        return false
+
+      return false if this.shouldIgnoreError(error)
+      return false unless error.stack
+
+      fields = arguments[1] || new Object()
+      fields.api_key = @options.APIKey
+      fields.environment = @options.environment
+      fields.client = "javascript"
+      fields.revision = @options.revision
+
+      fields.class_name = error.type || error.name
+      # errors that make it up to window.onerror get stupidly rewritten: their
+      # class is set to "Error" and the ACTUAL class is integrated into the
+      # message (e.g., "Uncaught TypeError: [message]")
+      if !error.name && (matches = error.message.match(/^(Uncaught )?(\w+): (.+)/))
+        fields.class_name = matches[2]
+        fields.message = matches[3]
+      else
+        fields.message = error.message
+      fields.class_name ?= 'Error' # when all else fails
+
+      fields.backtraces = buildBacktrace(error.stack)
+      fields.capture_method = error.mode
+      fields.occurred_at = ISODateString(new Date())
+
+      fields.schema = window.location.protocol.replace(/:$/, '')
+      fields.host = window.location.hostname
+      fields.port = window.location.port if window.location.port.length > 0
+      fields.path = window.location.pathname
+      fields.query = window.location.search
+      fields.fragment = window.location.hash if window.location.hash != ''
+
+      fields.user_agent = navigator.userAgent
+
+      fields.screen_width = screen.width
+      fields.screen_height = screen.height
+      fields.window_width = window.innerWidth
+      fields.window_height = window.innerHeight
+      fields.color_depth = screen.colorDepth
+
+      body = JSON.stringify(fields)
+      this.HTTPTransmit (@options.APIHost + @options.notifyPath),
+          [ ['Content-Type', 'application/json'] ],
+          body
+
+      return true
+    catch internal_error
+      console.error "Error while trying to notify Squash:", internal_error.stack
+      console.error "-- original error:", error
+
+  # Runs the given `block`. If an exception is thrown within the function, adds
+  # the given user data to the exception and re-throws it.
+  #
+  # @param [Object] data The user data to add to any error.
+  # @param [function] block The code to run.
+  # @return [Object] The return value of `block`.
+  # @see #addingUserData
+  #
+  addUserData: (data, block) ->
+    try
+      block()
+    catch err
+      err._squash_user_data ?= {}
+      mergeBang err._squash_user_data, data
+      throw err
+
+  # Wraps `block` in a call to {#addUserData} and returns it. Any arguments are
+  # passed through.
+  #
+  # @see #addUserData
+  #
+  addingUserData: (data, block) ->
+    (args...) -> SquashJavascript.instance().addUserData(data, -> block(args...))
+
+  # Runs the given `block`. If an exception is thrown within the function of one
+  # of the types given, does not report the exception to Squash. Re-throws _all_
+  # exceptions.
+  #
+  # @param [class..., String...] exceptions A list of error types to ignore.
+  # @param [function] block The code to run.
+  # @return [Object] The return value of `block`.
+  # @see #ignoringExceptions
+  #
+  ignoreExceptions: (exceptions..., block) ->
+    try
+      block()
+    catch err
+      err._squash_ignored_exceptions = (err._squash_ignored_exceptions || []).concat(exceptions)
+      throw err
+
+  # Wraps `block` in a call to {#ignoreExceptions} and returns it. Any arguments
+  # are passed through.
+  #
+  # @see #ignoreExceptions
+  #
+  ignoringExceptions: (exceptions..., block) ->
+    (args...) -> SquashJavascript.instance().ignoreExceptions(exceptions..., -> block(args...))
+
+  ################################## PRIVATES ##################################
+
+  # @private
+  HTTPTransmit: (url, headers, body) ->
+    request = new XMLHttpRequest()
+    request.timeout = @options.transmitTimeout
+    request.open "POST", url, true
+    for header in headers
+      request.setRequestHeader header[0], header[1]
+    request.send body
+    request
+
+  # @private
+  shouldIgnoreError: (error) ->
+    ignored_classes = @options.ignoredExceptionClasses.concat(error._squash_ignored_exceptions || [])
+
+    return true if any(ignored_classes, (klass) -> error.name == klass)
+
+    return any(@options.ignoredExceptionMessages, (class_name, messages) ->
+      if error.name == class_name
+        return any(messages, (message) -> error.message.match(message))
+      else
+        return false
+    )
+
+  buildBacktrace = (stack) ->
+    backtraces = []
+    for line in stack
+      context = line.context
+      context = null if context && any(context, (cline) -> cline.length > 200)
+      backtraces.push ['_JS_ASSET_', line.url, line.line, line.column, line.func, context]
+    return [ ["Active Thread", true, backtraces] ]
+
+  ISODateString = (d) ->
+    pad = (n) -> if n < 10 then '0' + n else n
+    "#{d.getUTCFullYear()}-#{pad(d.getUTCMonth() + 1)}-#{pad d.getUTCDate()}T#{pad d.getUTCHours()}:#{pad d.getUTCMinutes()}:#{pad d.getUTCSeconds()}Z"
+
+  any = (obj, condition) ->
+    if obj instanceof Array
+      for element in obj
+        return true if condition(element)
+    else
+      for own key, value of obj
+        return true if condition(key, value)
+    return false
+
+  mergeBang = (modified, constant) ->
+    for own key, value of constant
+      modified[key] = value

data/vendor/assets/javascripts/squash_javascript/index.js

@@ -0,0 +1,16 @@
+// Copyright 2012 Square Inc.
+//
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+
+//= require ./tracekit
+//= require ./client