sourcemap 0.0.1

data/examples/foobar.map

@@ -0,0 +1 @@
+{"version":3,"file":null,"lineCount":74,"mappings":";AACA;CAAA,KAAA,gDAAA;KAAA,aAAA;;CAAA,CAAA,CAAW,GAAX;;CAAA,CACA,CAAW,CADX,IACA;;CAGA,CAAA,EAAgB,IAAhB;AAAU,CAAV,CAAA,CAAS,CAAT,EAAA;IAJA;;CAAA,CAOA,CAAS,GAAT,GAAU;CAAM,EAAI,QAAJ;CAPhB,EAOS;;CAPT,CAUA,CAAO,CAAP;;CAVA,CAaA,CACE,CADF;CACE,CAAQ,EAAR;CAAA,CACQ,EAAR,EAAA;CADA,CAEQ,CAAA,CAAR,KAAS;CAAM,EAAI,GAAA,OAAJ;CAFf,IAEQ;CAhBV,GAAA;;CAAA,CAmBA,CAAO,CAAP,KAAO;CACL,OAAA,OAAA;CAAA,CADc,EAAR,mDACN;CAAM,CAAQ,GAAd,CAAA,CAAA,IAAA;CApBF,EAmBO;;CAIP,CAAA,EAAsB,0CAAtB;CAAA,GAAA,CAAA,OAAA;IAvBA;;CAAA,CA0BA,GAAA;;AAAS,CAAA;UAAA,iCAAA;sBAAA;CAAA,EAAA,CAAI;CAAJ;;CA1BT;CAAA;;;ACAA;CAAA,KAAA,6DAAA;;CAAA;CAAA,MAAA,oCAAA;qBAAA;CAAA,EAAA,CAAA;CAAA,EAAA;;CAAA,CAGA,CAAU,GAAA,CAAV,CAAU,EAAA;;AACV,CAAA,MAAA,iDAAA;uBAAA;CAAA,CAAY,CAAH,CAAT;CAAA,EAJA;;CAAA,CAOA,CAAQ,EAAR,IAAQ,CAAA,CAAA;;AACR,CAAA,MAAA,uCAAA;sBAAA;IAAgC,CAAU;CAA1C,EAAA,CAAA,EAAA;MAAA;CAAA,EARA;CAAA;","sources":["foo.coffee","bar.coffee"],"names":[]}

data/lib/source_map.rb

@@ -0,0 +1,4 @@
+require 'source_map/map'
+require 'source_map/offset'
+require 'source_map/version'
+require 'source_map/vlq'

data/lib/source_map/map.rb

@@ -0,0 +1,219 @@
+require 'json'
+
+require 'source_map/offset'
+require 'source_map/vlq'
+
+module SourceMap
+  Mapping = Struct.new(:source, :generated, :original, :name) do
+    def to_s
+      "#{generated.line}:#{generated.column}->#{original.line}:#{original.column}"
+    end
+
+    alias_method :inspect, :to_s
+  end
+
+  class Map
+    include Enumerable
+
+    def self.from_json(json)
+      from_hash JSON.parse(json)
+    end
+
+    def self.from_hash(hash)
+      str     = hash['mappings']
+      sources = hash['sources']
+      names   = hash['names']
+
+      mappings = decode_vlq_mappings(str, sources, names)
+      new(mappings, hash['file'])
+    end
+
+    # Internal: Decode VLQ mappings and match up sources and symbol names.
+    #
+    # str     - VLQ string from 'mappings' attribute
+    # sources - Array of Strings from 'sources' attribute
+    # names   - Array of Strings from 'names' attribute
+    #
+    # Returns an Array of Mappings.
+    def self.decode_vlq_mappings(str, sources = [], names = [])
+      mappings = []
+
+      source_id       = 0
+      original_line   = 1
+      original_column = 0
+      name_id         = 0
+
+      VLQ.decode_mappings(str).each_with_index do |group, index|
+        generated_column = 0
+        generated_line   = index + 1
+
+        group.each do |segment|
+          generated_column += segment[0]
+          generated = Offset.new(generated_line, generated_column)
+
+          if segment.size >= 4
+            source_id        += segment[1]
+            original_line    += segment[2]
+            original_column  += segment[3]
+
+            source   = sources[source_id]
+            original = Offset.new(original_line, original_column)
+          else
+            # TODO: Research this case
+            next
+          end
+
+          if segment[4]
+            name_id += segment[4]
+            name     = names[name_id]
+          end
+
+          mappings << Mapping.new(source, generated, original, name)
+        end
+      end
+
+      mappings
+    end
+
+    def initialize(mappings = [], filename = nil)
+      @mappings, @filename = mappings, filename
+    end
+
+    attr_reader :filename
+
+    def line_count
+      @line_count ||= @mappings.any? ? @mappings.last.generated.line : 0
+    end
+
+    def size
+      @mappings.size
+    end
+
+    def [](i)
+      @mappings[i]
+    end
+
+    def each(&block)
+      @mappings.each(&block)
+    end
+
+    def to_s
+      @string ||= build_vlq_string
+    end
+
+    def sources
+      @sources ||= @mappings.map(&:source).uniq.compact
+    end
+
+    def names
+      @names ||= @mappings.map(&:name).uniq.compact
+    end
+
+    def +(other)
+      mappings = @mappings.dup
+      offset   = line_count + 1
+      other.each do |m|
+        mappings << Mapping.new(
+          m.source, m.generated + offset,
+          m.original, m.name
+        )
+      end
+      self.class.new(mappings)
+    end
+
+    def |(other)
+      mappings = []
+
+      other.each do |m|
+        om = bsearch(m.original)
+        next unless om
+
+        mappings << Mapping.new(
+          om.source, m.generated,
+          om.original, om.name
+        )
+      end
+
+      self.class.new(mappings, other.filename)
+    end
+
+    def bsearch(offset, from = 0, to = size - 1)
+      mid = (from + to) / 2
+
+      # We haven't found a match
+      if from > to
+        return from < 1 ? nil : self[from-1]
+      end
+
+      # We found an exact match
+      if offset == self[mid].generated
+        self[mid]
+
+      # We need to filter more
+      elsif offset < self[mid].generated
+        bsearch(offset, from, mid - 1)
+      elsif offset > self[mid].generated
+        bsearch(offset, mid + 1, to)
+      end
+    end
+
+    def as_json
+      {
+        "version"   => 3,
+        "file"      => filename,
+        "lineCount" => line_count,
+        "mappings"  => to_s,
+        "sources"   => sources,
+        "names"     => names
+      }
+    end
+
+    protected
+      def build_vlq_string
+        source_id        = 0
+        source_line      = 1
+        source_column    = 0
+        name_id          = 0
+
+        by_lines = @mappings.group_by { |m| m.generated.line }
+
+        ary = (1..by_lines.keys.max).map do |line|
+          generated_column = 0
+
+          (by_lines[line] || []).map do |mapping|
+            group = []
+            group << mapping.generated.column - generated_column
+            group << sources_index[mapping.source] - source_id
+            group << mapping.original.line - source_line
+            group << mapping.original.column - source_column
+            group << names_index[mapping.name] - name_id if mapping.name
+
+            generated_column = mapping.generated.column
+            source_id        = sources_index[mapping.source]
+            source_line      = mapping.original.line
+            source_column    = mapping.original.column
+            name_id          = names_index[mapping.name] if mapping.name
+
+            group
+          end
+        end
+
+        VLQ.encode_mappings(ary)
+      end
+
+      def sources_index
+        @sources_index ||= build_index(sources)
+      end
+
+      def names_index
+        @names_index ||= build_index(names)
+      end
+
+    private
+      def build_index(array)
+        index = {}
+        array.each_with_index { |v, i| index[v] = i }
+        index
+      end
+  end
+end

data/lib/source_map/offset.rb

@@ -0,0 +1,84 @@
+module SourceMap
+  # Public: Offset is an immutable structure representing a position in
+  # a source file.
+  class Offset
+    include Comparable
+
+    # Public: Construct Offset value.
+    #
+    # Returns Offset instance.
+    def self.new(*args)
+      case args.first
+      when Offset
+        args.first
+      when Array
+        super(*args.first)
+      else
+        super(*args)
+      end
+    end
+
+    # Public: Initialize an Offset.
+    #
+    # line   - Integer line number
+    # column - Integer column number
+    def initialize(line, column)
+      @line, @column = line, column
+    end
+
+    # Public: Gets Integer line of offset
+    attr_reader :line
+
+    # Public: Get Integer column of offset
+    attr_reader :column
+
+    # Public: Shift the offset by some value.
+    #
+    # other - An Offset to add by its line and column
+    #         Or an Integer to add by line
+    #
+    # Returns a new Offset instance.
+    def +(other)
+      case other
+      when Offset
+        Offset.new(self.line + other.line, self.column + other.column)
+      when Integer
+        Offset.new(self.line + other, self.column)
+      else
+        raise ArgumentError, "can't convert #{other} into #{self.class}"
+      end
+    end
+
+    # Public: Compare Offset to another.
+    #
+    # Useful for determining if a position in a few is between two offsets.
+    #
+    # other - Another Offset
+    #
+    # Returns a negative number when other is smaller and a positive number
+    # when its greater. Implements the Comparable#<=> protocol.
+    def <=>(other)
+      case other
+      when Offset
+        diff = self.line - other.line
+        diff.zero? ? self.column - other.column : diff
+      else
+        raise ArgumentError, "can't convert #{other.class} into #{self.class}"
+      end
+    end
+
+    # Public: Get a simple string representation of the offset
+    #
+    # Returns a String.
+    def to_s
+      "#{line}:#{column}"
+    end
+
+    # Public: Get a pretty inspect output for debugging purposes.
+    #
+    # Returns a String.
+    def inspect
+      "#<#{self.class} line=#{line}, column=#{column}>"
+    end
+  end
+end

data/lib/source_map/version.rb

@@ -0,0 +1,3 @@
+module SourceMap
+  VERSION = "0.0.1"
+end

data/lib/source_map/vlq.rb

@@ -0,0 +1,98 @@
+module SourceMap
+  # Public: Base64 VLQ encoding
+  #
+  # Adopted from ConradIrwin/ruby-source_map
+  #   https://github.com/ConradIrwin/ruby-source_map/blob/master/lib/source_map/vlq.rb
+  #
+  # Resources
+  #
+  #   http://en.wikipedia.org/wiki/Variable-length_quantity
+  #   https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+  #   https://github.com/mozilla/source-map/blob/master/lib/source-map/base64-vlq.js
+  #
+  module VLQ
+    VLQ_BASE_SHIFT = 5
+    VLQ_BASE = 1 << VLQ_BASE_SHIFT
+    VLQ_BASE_MASK = VLQ_BASE - 1
+    VLQ_CONTINUATION_BIT = VLQ_BASE
+
+    BASE64_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.split('')
+    BASE64_VALUES = (0...64).inject({}) { |h, i| h[BASE64_DIGITS[i]] = i; h }
+
+    # Public: Encode a list of numbers into a compact VLQ string.
+    #
+    # ary - An Array of Integers
+    #
+    # Returns a VLQ String.
+    def self.encode(ary)
+      result = ""
+      ary.each do |n|
+        vlq = n < 0 ? ((-n) << 1) + 1 : n << 1
+        begin
+          digit  = vlq & VLQ_BASE_MASK
+          vlq  >>= VLQ_BASE_SHIFT
+          digit |= VLQ_CONTINUATION_BIT if vlq > 0
+          result << BASE64_DIGITS[digit]
+        end while vlq > 0
+      end
+      result
+    end
+
+    # Public: Decode a VLQ string.
+    #
+    # str - VLQ encoded String
+    #
+    # Returns an Array of Integers.
+    def self.decode(str)
+      result = []
+      chars = str.split('')
+      while chars.any?
+        vlq = 0
+        shift = 0
+        continuation = true
+        while continuation
+          char = chars.shift
+          raise ArgumentError unless char
+          digit = BASE64_VALUES[char]
+          continuation = false if (digit & VLQ_CONTINUATION_BIT) == 0
+          digit &= VLQ_BASE_MASK
+          vlq   += digit << shift
+          shift += VLQ_BASE_SHIFT
+        end
+        result << (vlq & 1 == 1 ? -(vlq >> 1) : vlq >> 1)
+      end
+      result
+    end
+
+    # Public: Encode a mapping array into a compact VLQ string.
+    #
+    # ary - Two dimensional Array of Integers.
+    #
+    # Returns a VLQ encoded String seperated by , and ;.
+    def self.encode_mappings(ary)
+      ary.map { |group|
+        group.map { |segment|
+          encode(segment)
+        }.join(',')
+      }.join(';')
+    end
+
+    # Public: Decode a VLQ string into mapping numbers.
+    #
+    # str - VLQ encoded String
+    #
+    # Returns an two dimensional Array of Integers.
+    def self.decode_mappings(str)
+      mappings = []
+
+      str.split(';').each_with_index do |group, index|
+        mappings[index] = []
+        group.split(',').each do |segment|
+          mappings[index] << decode(segment)
+        end
+      end
+
+      mappings
+    end
+  end
+end

data/lib/sourcemap.rb

@@ -0,0 +1 @@
+require 'source_map'

data/sourcemap.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'source_map/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sourcemap"
+  spec.version       = SourceMap::VERSION
+  spec.authors       = ["Josh Peek", "Alex MacCaw"]
+  spec.email         = ["alex@alexmaccaw.com"]
+  spec.description   = %q{Ruby source maps}
+  spec.summary       = %q{Ruby source maps}
+  spec.homepage      = "http://github.com/maccman/sourcemap"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+end

data/test/test_map.rb

@@ -0,0 +1,178 @@
+require 'minitest/autorun'
+require 'source_map/map'
+
+class TestMap < MiniTest::Unit::TestCase
+  include SourceMap
+
+  def setup
+    @mappings = Map.new([
+      Mapping.new('a.js', Offset.new(0, 0), Offset.new(0, 0)),
+      Mapping.new('b.js', Offset.new(1, 0), Offset.new(20, 0)),
+      Mapping.new('c.js', Offset.new(2, 0), Offset.new(30, 0))
+    ])
+  end
+
+  def test_map
+    hash = {
+      'version' => 3,
+      'file' => "script.min.js",
+      'lineCount' => 1,
+      'mappings' => "AAEAA,QAASA,MAAK,EAAG,CACfC,OAAAC,IAAA,CAAY,eAAZ,CADe",
+      'sources' => ["script.js"],
+      'names' => ["hello", "console", "log"]
+    }
+    map = Map.from_hash(hash)
+
+    assert mapping = map[0]
+    assert_equal 1, mapping.generated.line
+    assert_equal 0, mapping.generated.column
+    assert_equal 3, mapping.original.line
+    assert_equal 0, mapping.original.column
+    assert_equal 'script.js', mapping.source
+    assert_equal 'hello', mapping.name
+
+    assert mapping = map[-1]
+    assert_equal 1, mapping.generated.line
+    assert_equal 45, mapping.generated.column
+    assert_equal 3, mapping.original.line
+    assert_equal 17, mapping.original.column
+    assert_equal 'script.js', mapping.source
+    assert_equal nil, mapping.name
+
+    assert_equal hash['lineCount'], map.line_count
+    assert_equal hash['sources'],   map.sources
+    assert_equal hash['names'],     map.names
+    assert_equal hash['mappings'],  map.to_s
+
+    assert_equal hash, map.as_json
+  end
+
+  def test_map2
+    hash = {
+      'version' => 3,
+      'file' => "example.js",
+      'lineCount' => 43,
+      'mappings' => ";;;;;EACAA;;EACAC;;EAGA;IAAA;;;EAGAC;IAAS;;;EAGTC;;EAGAC;IACE;IACA;IACA;MAAQ;;;;EAGVC;;;IACE;;;EAGF;IAAA;;;EAGAC;;;IAAQ;;MAAA",
+      'sources' => ["example.coffee"],
+      'names' => ["number", "opposite", "square", "list", "math", "race", "cubes"]
+    }
+    map = Map.from_hash(hash)
+
+    assert mapping = map[0]
+    assert_equal 6, mapping.generated.line
+    assert_equal 2, mapping.generated.column
+    assert_equal 2, mapping.original.line
+    assert_equal 0, mapping.original.column
+    assert_equal 'example.coffee', mapping.source
+    assert_equal 'number', mapping.name
+
+    assert mapping = map[-1]
+    assert_equal 43, mapping.generated.line
+    assert_equal 6, mapping.generated.column
+    assert_equal 28, mapping.original.line
+    assert_equal 8, mapping.original.column
+    assert_equal 'example.coffee', mapping.source
+    assert_equal nil, mapping.name
+
+    assert_equal hash['lineCount'], map.line_count
+    assert_equal hash['sources'],   map.sources
+    assert_equal hash['names'],     map.names
+    assert_equal hash['mappings'],  map.to_s
+  end
+
+  def test_map3
+    hash = {
+      'version' => 3,
+      'file' => "example.min.js",
+      'lineCount' => 1,
+      'mappings' => "AACC,SAAQ,EAAG,CAAA,IACCA,CADD,CACOC,CADP,CACaC,CADb,CAC0CC,CAWpDA,EAAA,CAASA,QAAQ,CAACC,CAAD,CAAI,CACnB,MAAOA,EAAP,CAAWA,CADQ,CAIrBJ,EAAA,CAAO,CAAC,CAAD,CAAI,CAAJ,CAAO,CAAP,CAAU,CAAV,CAAa,CAAb,CAEPC,EAAA,CAAO,MACCI,IAAAC,KADD,QAEGH,CAFH,MAGCI,QAAQ,CAACH,CAAD,CAAI,CAChB,MAAOA,EAAP,CAAWD,CAAA,CAAOC,CAAP,CADK,CAHb,CAcc,YAArB,GAAI,MAAOI,MAAX,EAA8C,IAA9C,GAAoCA,KAApC,EACEC,KAAA,CAAM,YAAN,CAGO,UAAQ,EAAG,CAAA,IACdC,CADc,CACVC,CADU,CACJC,CACdA,EAAA,CAAW,EACNF,EAAA,CAAK,CAAV,KAAaC,CAAb,CAAoBX,CAAAa,OAApB,CAAiCH,CAAjC,CAAsCC,CAAtC,CAA4CD,CAAA,EAA5C,CACER,CACA,CADMF,CAAA,CAAKU,CAAL,CACN,CAAAE,CAAAE,KAAA,CAAcb,CAAAM,KAAA,CAAUL,CAAV,CAAd,CAEF,OAAOU,EAPW,CAAX,CAAA,EApCC,CAAX,CAAAG,KAAA,CA8CO,IA9CP",
+      'sources' => ["example.js"],
+      'names' => ["list","math","num","square","x","Math","sqrt","cube","elvis","alert","_i","_len","_results","length","push","call"]
+    }
+    map = Map.from_hash(hash)
+
+    assert mapping = map[0]
+    assert_equal 1, mapping.generated.line
+    assert_equal 0, mapping.generated.column
+    assert_equal 2, mapping.original.line
+    assert_equal 1, mapping.original.column
+    assert_equal 'example.js', mapping.source
+    assert_equal nil, mapping.name
+
+    assert mapping = map[-1]
+    assert_equal 1, mapping.generated.line
+    assert_equal 289, mapping.generated.column
+    assert_equal 2, mapping.original.line
+    assert_equal 1, mapping.original.column
+    assert_equal 'example.js', mapping.source
+    assert_equal nil, mapping.name
+
+    assert_equal hash['lineCount'], map.line_count
+    assert_equal hash['sources'],   map.sources
+    assert_equal hash['names'],     map.names
+    assert_equal hash['mappings'],  map.to_s
+  end
+
+  def test_line_count
+    # assert_equal 3, @mappings.line_count
+  end
+
+  def test_to_s
+    assert_equal "ACmBA;ACUA", @mappings.to_s
+  end
+
+  def test_sources
+    assert_equal ["a.js", "b.js", "c.js"], @mappings.sources
+  end
+
+  def test_names
+    assert_equal [], @mappings.names
+  end
+
+  def test_add
+    mappings2 = Map.new([
+      Mapping.new('d.js', Offset.new(0, 0), Offset.new(0, 0))
+    ])
+    mappings3 = @mappings + mappings2
+    assert_equal 0, mappings3[0].generated.line
+    assert_equal 1, mappings3[1].generated.line
+    assert_equal 2, mappings3[2].generated.line
+    assert_equal 3, mappings3[3].generated.line
+  end
+
+  def test_pipe
+    mappings1 = Map.from_json(%{
+      {
+        "version": 3,
+        "file": "index.js",
+        "sourceRoot": "",
+        "sources": [
+          "index.coffee"
+        ],
+        "names": [],
+        "mappings": ";AAAA;AAAA,MAAA,IAAA;;AAAA,EAAA,IAAA,GAAO,SAAA,GAAA;WACL,KAAA,CAAM,aAAN,EADK;EAAA,CAAP,CAAA;;AAGA,EAAA,IAAW,IAAX;AAAA,IAAG,IAAH,CAAA,CAAA,CAAA;GAHA;AAAA"
+      }
+    })
+
+    mappings2 = Map.from_json(%{
+      {
+        "version":3,
+        "file":"index.min.js",
+        "sources":["index.js"],
+        "names":["test","alert","call","this"],
+        "mappings":"CACA,WACE,GAAIA,KAEJA,MAAO,WACL,MAAOC,OAAM,eAGf,IAAI,KAAM,CACRD,SAGDE,KAAKC"
+      }
+    })
+
+    mappings3 = mappings1 | mappings2
+    assert_equal 'CAAA,WAAA,GAAA,KAAA,MAAO,WAAA,MACL,OAAM,eAER,IAAW,KAAX,CAAG,SAHH,KAAA', mappings3.to_s
+  end
+
+  def test_bsearch
+    assert_equal Offset.new(0, 0), @mappings.bsearch(Offset.new(0, 0)).original
+    assert_equal Offset.new(0, 0), @mappings.bsearch(Offset.new(0, 5)).original
+    assert_equal Offset.new(20, 0), @mappings.bsearch(Offset.new(1, 0)).original
+    assert_equal Offset.new(20, 0), @mappings.bsearch(Offset.new(1, 0)).original
+    assert_equal Offset.new(30, 0), @mappings.bsearch(Offset.new(2, 0)).original
+  end
+end