opal-wedge 0.9.0.dev

data/stdlib/source_map.rb

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

data/stdlib/source_map/map.rb

@@ -0,0 +1,220 @@
+require 'json'
+
+require 'source_map/offset'
+require 'source_map/mapping'
+require 'source_map/vlq'
+
+module SourceMap
+  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 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)
+      eql?(other)
+    end
+
+    def eql?(other)
+      other.is_a?(self.class) &&
+        self.mappings == other.mappings &&
+        self.filename == other.filename
+    end
+
+    def +(other)
+      mappings = @mappings.dup
+      offset   = @mappings.any? ? @mappings.last.generated.line+1 : 0
+      other.each do |m|
+        mappings << Mapping.new(
+          m.source, m.generated + offset,
+          m.original, m.name
+        )
+      end
+      self.class.new(mappings, other.filename)
+    end
+
+    def |(other)
+      return other.dup if self.mappings.empty?
+
+      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,
+        "mappings"  => to_s,
+        "sources"   => sources,
+        "names"     => names
+      }
+    end
+
+    # Public: Get a pretty inspect output for debugging purposes.
+    #
+    # Returns a String.
+    def inspect
+      str = "#<#{self.class}"
+      str << " filename=#{filename.inspect}" if filename
+      str << " mappings=#{mappings.map(&:to_s).inspect}" if mappings.any?
+      str << ">"
+      str
+    end
+
+    protected
+      attr_reader :mappings
+
+      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 }
+
+        sources_index = Hash[sources.each_with_index.to_a]
+        names_index   = Hash[names.each_with_index.to_a]
+
+        ary = (1..(by_lines.keys.max || 1)).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
+  end
+end

data/stdlib/source_map/mapping.rb

@@ -0,0 +1,26 @@
+require 'source_map/offset'
+
+module SourceMap
+  class Mapping < Struct.new(:source, :generated, :original, :name)
+    # Public: Get a simple string representation of the mapping.
+    #
+    # Returns a String.
+    def to_s
+      str = "#{generated.line}:#{generated.column}"
+      str << "->#{source}@#{original.line}:#{original.column}"
+      str << "##{name}" if name
+      str
+    end
+
+    # Public: Get a pretty inspect output for debugging purposes.
+    #
+    # Returns a String.
+    def inspect
+      str = "#<#{self.class} source=#{source.inspect}"
+      str << " generated=#{generated}, original=#{original}"
+      str << " name=#{name.inspect}" if name
+      str << ">"
+      str
+    end
+  end
+end

data/stdlib/source_map/offset.rb

@@ -0,0 +1,88 @@
+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
+      if column == 0
+        "#{line}"
+      else
+        "#{line}:#{column}"
+      end
+    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/stdlib/source_map/version.rb

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

data/stdlib/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.join
+    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/stdlib/sourcemap.rb

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