squash_javascript 1.0.3 → 2.0.5

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    Yzg2ZTI5ZWVkNzI4NmQ4NzQ3MzA5OTc4ZGJlNGE0OGNjZDdlMGY4Yw==
-  data.tar.gz: !binary |-
-    NWVkMTA3NTMzYTQyZDExYjlmMDdiNzNmNDJhM2IzMTgxNjYzMmM4NA==
+SHA1:
+  metadata.gz: f8d9f1fd8dff2720d5a08a2842c3d47b7432f43f
+  data.tar.gz: 39c29285f2daca8d0caf179d33fd99d0dd7504c9
 SHA512:
-  metadata.gz: !binary |-
-    NGU0MmQ1MDc5MjNjNTYzNDlkZmY2Mzk0NmRhNWQwNGEwMDRkOWQ5ZTBmNGVl
-    OWI3ZTkyZDgyMmMzNjg1OTdjMGI0NTc5OWIwMzdlMGNmMzQ1OGMwMGZjZjI1
-    ODc0MjE1NzA0NjkwMmU2ZGM5YjAzZjAyNmI0ZDAxYTRjMzEwYmI=
-  data.tar.gz: !binary |-
-    MzhkODM0MzVmNjM0YmI4NTE2NmRmNzcxODZmOTVhODU1NmUzZmI1NjkwNmRj
-    NDA0ZjQxOWE0NmM0NmVlZDBmNzZlM2EwMGEwMzJhZDk2ODk1YTIwOWI0ZDgz
-    ODNlNzkzNzNiMWZkOTk2MDNkNjU5Y2ZhYjBlZWU1NmE5NWQ3OTk=
+  metadata.gz: d6a8223c1f281122cb38da8c24cd68bd2574bd21372dd3a1541181375835f9cb84d510d525327bcae127388f0e2c24e1302ce3eaeaac36bfee189f51c8e01033
+  data.tar.gz: 4938f74e4e02ed2afa346bc5463a0e2f93edf9b1cea24a95ac74ad452edc1ad1ec4b70eeac6c972b116eef32888a086e33efb9139efb8f6b7af48ecb8a92fe48

data/README.md

@@ -42,11 +42,15 @@ The library is included in this project. For Rails projects, a Sprockets include
 file is provided. For non-Rails projects, the output of `rake minify` rolls in
 the library.
 
-Unfortunately, TraceKit was causing unexpected behavior on Chrome and Firefox,
-and parts of it are commented out. (The jQuery hooks were disabled.)
+**The included version of TraceKit has been modified somewhat:**
+
+* `window.onerror` support was expanded to include changes in recent versions of
+  modern browsers (namely, passing the column and error object as parameters).
+* TraceKit was causing unexpected behavior on Chrome and Firefox, and parts of
+  it are commented out. (The jQuery hooks were disabled.)
 
 Installation
------
+------------
 
 ### Rails
 
@@ -252,20 +256,57 @@ still be re-raised, but the failsafe error will be "eaten."
 Source Mapping
 --------------
 
-If you can generate a source map for your minified JavaScript files (Clojure
+### Rails and Sprockets
+
+Squash JavaScript can integrate with Sprockets to automatically generate source
+maps for each stage of the asset compilation pipeline, then integrate with
+Capistrano to upload the source maps to Squash. To use this feature, configure
+your project like so:
+
+1. Replace your JavaScript compiler gem with Closure, if you aren't already
+   using it.
+
+   ```` diff
+   -gem 'uglifier'
+   +gem 'closure-compiler'
+   ````
+
+2. Use Squash's source-mapping Tilt engines for CoffeeScript and JavaScript.
+
+   These Tilt engines wrap existing Tilt template engines, but also generate
+   source maps to `tmp/sourcemaps`.
+
+   ```` ruby
+   Sprockets.register_engine '.coffee', Squash::Javascript::SourceMappingCoffeescriptTemplate
+   config.assets.js_compressor = Squash::Javascript::SourceMappingJavascriptMinifier
+   ````
+
+3. Add the Squash Capistrano tasks to your Capfile:
+
+    ```` ruby
+    require 'squash/javascript/capistrano'
+    ````
+
+    If you do not use Capistrano 3, you can use the `rake sourcemaps:upload:all`
+    task to upload your generated source maps to Squash.
+
+### Other Projects
+
+If you can generate a source map for your minified JavaScript files (Closure
 can), you can use this gem to upload that source map to Squash, where it will
 be used to convert minified stack traces to their original format, which can
 then benefit from Git-blaming, context, and other features of Squash.
 
 To upload the source map to squash, run the `upload_source_map` binary included
-with this gem, and pass it four arguments: 1) your API key, 2) the environment
-name, 3) the path to the JSON source map, and 4) the URL where this file will be
-hosted. Example:
+with this gem, and pass it four arguments: 1) your Squash host, 2) your API key,
+3) the environment name, and 4) the path to the JSON source map. Example:
 
 ````
-upload_source_map abc-123-abc-123-abc-123 production artifacts/mapping.json https://my.application/assets/minified.js
+upload_source_map http://your.squash.host abc-123-abc-123-abc-123 production artifacts/mapping.json
 ````
 
+Use `--help` to learn about additional options.
+
 Specs
 -----
 

data/bin/upload_source_map

@@ -36,9 +36,15 @@ project_dir = Dir.getwd
 ignore_root = false
 revision    = nil
 options     = {}
+from        = 'hosted'
+to          = 'original'
 
 parser = OptionParser.new do |parser|
-  parser.banner = "Usage: upload_source_map [options] YOUR_SQUASH_HOST YOUR_API_KEY ENVIRONMENT /path/to/mapping.json https://url.for/minified/asset.js"
+  parser.banner = "Usage: upload_source_map [options] YOUR_SQUASH_HOST YOUR_API_KEY ENVIRONMENT /path/to/mapping.json"
+
+  parser.on('-f', '--from S', "The type of stack trace element this source map converts from (hosted [default], concatenated, etc.)") { |f| from = f }
+  parser.on('-t', '--to S', "The type of stack trace element this source map converts to (compiled, original [default], coffee, etc.)") { |t| to = t }
+
   parser.on('-o', '--open-timeout N', Integer, "HTTP connection open timeout") { |ot| options[:open_timeout] = ot }
   parser.on('-r', '--read-timeout N', Integer, "HTTP connection data received timeout") { |rt| options[:read_timeout] = rt }
   parser.on('-k', '--[no-]skip-verification', "Do not perform SSL peer verification") { |sv| options[:skip_verification] = sv }
@@ -62,14 +68,14 @@ host        = ARGV.shift
 api_key     = ARGV.shift
 environment = ARGV.shift
 map_file    = ARGV.shift
-route       = ARGV.shift
 revision    = revision || git_revision(project_dir)
 
-map = Squash::Javascript::SourceMap.from_sourcemap(map_file, route, root: ignore_root ? project_dir : nil)
 Squash::Uploader.new(host, options).transmit '/api/1.0/sourcemap.json',
                                              {
                                                  'api_key'     => api_key,
                                                  'environment' => environment,
                                                  'revision'    => revision,
-                                                 'sourcemap'   => Base64.encode64(Zlib::Deflate.deflate(map.to_yaml))
+                                                 'sourcemap'   => Base64.encode64(Zlib::Deflate.deflate(File.read(map_file))),
+                                                 'from'        => from,
+                                                 'to'          => to
                                              }

data/lib/squash/javascript/capistrano.rb

@@ -0,0 +1,16 @@
+# Copyright 2014 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.
+
+load(File.dirname(__FILE__) + '/../../tasks/squash.cap')
+

data/lib/squash/javascript/patches.rb

@@ -0,0 +1,33 @@
+require 'source_map'
+require 'sprockets'
+
+# @private
+class Sprockets::Asset
+  def sourcemap
+    relative_path = if pathname.to_s.include?(Rails.root.to_s)
+                      pathname.relative_path_from(Rails.root)
+                    else
+                      pathname
+                    end.to_s
+    # any extensions after the ".js" can be removed, because they will have
+    # already been processed
+    relative_path.gsub! /(?<=\.js)\..*$/, ''
+    resource_path = [Rails.application.config.assets.prefix, logical_path].join('/')
+
+    mappings = Array.new
+    to_s.lines.each_with_index do |_, index|
+      offset = SourceMap::Offset.new(index, 0)
+      mappings << SourceMap::Mapping.new(relative_path, offset, offset)
+    end
+    SourceMap::Map.new(mappings, resource_path)
+  end
+end
+
+# @private
+class Sprockets::BundledAsset < Sprockets::Asset
+  def sourcemap
+    to_a.inject(SourceMap::Map.new) do |map, asset|
+      map + asset.sourcemap
+    end
+  end
+end

data/lib/squash/javascript/railtie.rb

@@ -0,0 +1,5 @@
+class Squash::Javascript::Railtie < Rails::Railtie
+  rake_tasks do
+    Dir[File.join(File.dirname(__FILE__), 'tasks', '*.rake')].each { |f| load f }
+  end
+end

data/lib/squash/javascript/source_mapping_coffeescript_template.rb

@@ -0,0 +1,27 @@
+require 'digest/sha2'
+
+class Squash::Javascript::SourceMappingCoffeescriptTemplate < Tilt::CoffeeScriptTemplate
+  def evaluate(scope, locals, &block)
+    @output ||= begin
+      result = CoffeeScript.compile(data, options.merge(sourceMap: true))
+
+      relative_path = if file.include?(Rails.root.to_s)
+                        Pathname.new(file).relative_path_from(Rails.root)
+                      else
+                        Pathname.new(file)
+                      end
+
+      map            = JSON.parse(result['v3SourceMap'])
+      map['file']    = relative_path.to_s.sub(/\.coffee$/, '')
+      map['sources'] = [relative_path.to_s]
+
+      map_path = Rails.root.join('tmp', 'sourcemaps', 'compiled', Digest::SHA2.hexdigest(relative_path.to_s) + '.json')
+      FileUtils.mkdir_p map_path.dirname
+      Rails.root.join('tmp', 'sourcemaps', map_path).open('w') do |f|
+        f.puts map.to_json
+      end
+
+      result['js']
+    end
+  end
+end

data/lib/squash/javascript/source_mapping_javascript_minifier.rb

@@ -0,0 +1,36 @@
+require 'digest/md5'
+
+class Squash::Javascript::SourceMappingJavascriptMinifier < Tilt::Template
+  def prepare() end
+
+  def evaluate(context, locals)
+    source_map_file = Tempfile.new('sourcemap')
+    compressor      = Closure::Compiler.new(create_source_map: source_map_file.path)
+    minified        = compressor.compress(data)
+
+    minified_file = Tempfile.new('minified')
+    minified_file.write minified
+
+    map                   = JSON.parse(source_map_file.read)
+    minified_filename     = [Rails.application.config.assets.prefix, "#{context.logical_path}-#{digest(minified)}.js"].join('/')
+    concatenated_filename = [Rails.application.config.assets.prefix, "#{context.logical_path}.js"].join('/')
+    map['file']           = minified_filename
+    map['sources']        = [concatenated_filename]
+
+    path = source_map_path(digest(minified))
+    FileUtils.mkdir_p path.dirname
+    File.open(path, 'w') { |f| f.puts map.to_json }
+
+    return minified
+  end
+
+  private
+
+  def digest(io)
+    Rails.application.assets.digest.update(io).hexdigest
+  end
+
+  def source_map_path(digest)
+    Rails.root.join 'tmp', 'sourcemaps', 'minified', "#{digest}.json"
+  end
+end

data/lib/squash/javascript/tasks/sourcemaps.rake

@@ -0,0 +1,73 @@
+require 'squash/uploader'
+
+namespace :sourcemaps do
+  namespace :upload do
+    task all: [:minified, :concatenated, :compiled]
+
+    task minified: :environment do
+      manifest_path = Rails.root.join('public',
+                                      Rails.application.config.assets.prefix.sub(/^\//, ''),
+                                      'manifest-*.json')
+      manifest_path = Dir.glob(manifest_path.to_s).first
+      raise "You must precompile your static assets before running this task." unless manifest_path
+
+      manifest = JSON.parse(File.read(manifest_path))
+      manifest['files'].each do |path, metadata|
+        sourcemap_path = Rails.root.join('tmp', 'sourcemaps', 'minified', "#{metadata['digest']}.json")
+        if sourcemap_path.exist?
+          Squash::Uploader.new(Squash::Ruby.configuration(:api_host),
+                               skip_verification: Squash::Ruby.configuration(:skip_verification)
+          ).transmit '/api/1.0/sourcemap.json',
+                     {
+                         'api_key'     => Squash::Ruby.configuration(:api_key),
+                         'environment' => Rails.env,
+                         'revision'    => Squash::Ruby.current_revision,
+                         'sourcemap'   => Base64.encode64(Zlib::Deflate.deflate(File.read(sourcemap_path))),
+                         'from'        => 'hosted',
+                         'to'          => 'concatenated'
+                     }
+        end
+      end
+    end
+
+    task concatenated: :environment do
+      Rails.application.assets.each_logical_path(Rails.application.config.assets.precompile) do |path|
+        next unless path.end_with?('.js')
+        asset = Rails.application.assets.find_asset(path)
+        next unless asset.kind_of?(Sprockets::BundledAsset)
+        map = asset.sourcemap
+        Squash::Uploader.new(Squash::Ruby.configuration(:api_host),
+                             skip_verification: Squash::Ruby.configuration(:skip_verification)
+        ).transmit '/api/1.0/sourcemap.json',
+                   {
+                       'api_key'     => Squash::Ruby.configuration(:api_key),
+                       'environment' => Rails.env,
+                       'revision'    => Squash::Ruby.current_revision,
+                       'sourcemap'   => Base64.encode64(Zlib::Deflate.deflate(map.as_json.to_json)),
+                       'from'        => 'concatenated',
+                       'to'          => 'compiled',
+                   }
+      end
+    end
+
+    task compiled: :environment do
+      Dir.glob(Rails.root.join('tmp', 'sourcemaps', 'compiled', '*.json')).each do |file|
+        Squash::Uploader.new(Squash::Ruby.configuration(:api_host),
+                             skip_verification: Squash::Ruby.configuration(:skip_verification)
+        ).transmit '/api/1.0/sourcemap.json',
+                   {
+                       'api_key'     => Squash::Ruby.configuration(:api_key),
+                       'environment' => Rails.env,
+                       'revision'    => Squash::Ruby.current_revision,
+                       'sourcemap'   => Base64.encode64(Zlib::Deflate.deflate(File.read(file))),
+                       'from'        => 'compiled',
+                       'to'          => 'original'
+                   }
+      end
+    end
+  end
+
+  task :clean do
+    system 'rm', '-rf', 'tmp/sourcemaps/*'
+  end
+end

data/lib/squash/javascript.rb

@@ -22,5 +22,8 @@ module Squash
   end
 end
 
-require 'squash/javascript/source_map'
+require 'squash/javascript/patches'
+require 'squash/javascript/source_mapping_coffeescript_template'
+require 'squash/javascript/source_mapping_javascript_minifier'
 require 'squash/javascript/engine'
+require 'squash/javascript/railtie'

data/lib/tasks/squash.cap

@@ -0,0 +1,30 @@
+# Copyright 2014 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.
+
+namespace :squash do
+  namespace :sourcemaps do
+    desc "Uploads JavaScript source maps to Squash"
+    task :upload do
+      on roles(:web), limit: 1 do
+        within release_path do
+          with rails_env: fetch(:rails_env) do
+            rake 'sourcemaps:upload:all'
+          end
+        end
+      end
+    end
+  end
+end
+
+after 'deploy:finishing', 'squash:sourcemaps:upload'

data/vendor/assets/javascripts/squash_javascript/{client.coffee → client.js.coffee}

@@ -203,7 +203,7 @@ class _SquashJavascript
     for line in stack
       context = line.context
       context = null if context && any(context, (cline) -> cline && cline.length > 200)
-      backtraces.push {url: line.url, line: line.line, column: line.column, symbol: line.func, context: context, type: 'minified'}
+      backtraces.push {url: line.url, line: line.line, column: line.column, symbol: line.func, context: context, type: 'js:hosted'}
     return [ {name: "Active Thread", faulted: true, backtrace: backtraces} ]
 
   ISODateString = (d) ->