opal 0.11.4 → 1.0.0.beta1

data/lib/opal/source_map/file.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+class Opal::SourceMap::File
+  include Opal::SourceMap::Map
+
+  attr_reader :fragments
+  attr_reader :file
+  attr_reader :source
+
+  def initialize(fragments, file, source)
+    @fragments = fragments
+    @file = file
+    @source = source
+    @names_map = Hash.new { |hash, name| hash[name] = hash.size }
+    @absolute_mappings = nil
+  end
+
+  def generated_code
+    @generated_code ||= @fragments.map(&:code).join
+  end
+
+  # Proposed Format
+  # 1: {
+  # 2: "version" : 3,
+  # 3: "file": "out.js",
+  # 4: "sourceRoot": "",
+  # 5: "sources": ["foo.js", "bar.js"],
+  # 6: "sourcesContent": [null, null],
+  # 7: "names": ["src", "maps", "are", "fun"],
+  # 8: "mappings": "A,AAAB;;ABCDE;"
+  # 9: }
+  #
+  # Line 1: The entire file is a single JSON object
+  # Line 2: File version (always the first entry in the object) and must be a
+  #         positive integer.
+  # Line 3: An optional name of the generated code that this source map is
+  #         associated with.
+  # Line 4: An optional source root, useful for relocating source files on a server
+  #         or removing repeated values in the “sources” entry. This value is prepended to
+  #         the individual entries in the “source” field.
+  # Line 5: A list of original sources used by the “mappings” entry.
+  # Line 6: An optional list of source content, useful when the “source” can’t be
+  #         hosted. The contents are listed in the same order as the sources in line 5.
+  #         “null” may be used if some original sources should be retrieved by name.
+  # Line 7: A list of symbol names used by the “mappings” entry.
+  # Line 8: A string with the encoded mapping data.
+  def map(source_root: '')
+    {
+      version: 3,
+      # file: "out.js", # This is optional
+      sourceRoot: source_root,
+      sources: [file],
+      sourcesContent: [source.force_encoding('UTF-8')],
+      names: names,
+      mappings: Opal::SourceMap::VLQ.encode_mappings(relative_mappings),
+      # x_com_opalrb_original_lines: source.count("\n"),
+      # x_com_opalrb_generated_lines: generated_code.count("\n"),
+    }
+  end
+
+  def names
+    @names ||= begin
+      absolute_mappings # let the processing happen
+      @names_map.to_a.sort_by { |_, index| index }.map { |name, _| name }
+    end
+  end
+
+  # The fields in each segment are:
+  #
+  # 1. The zero-based starting column of the line in the generated code that
+  #    the segment represents. If this is the first field of the first segment, or
+  #    the first segment following a new generated line (“;”), then this field
+  #    holds the whole base 64 VLQ. Otherwise, this field contains a base 64 VLQ
+  #    that is relative to the previous occurrence of this field. Note that this
+  #    is different than the fields below because the previous value is reset
+  #    after every generated line.
+  #
+  # 2. If present, an zero-based index into the “sources” list. This field is
+  #    a base 64 VLQ relative to the previous occurrence of this field, unless
+  #    this is the first occurrence of this field, in which case the whole value
+  #    is represented.
+  #
+  # 3. If present, the zero-based starting line in the original source
+  #    represented. This field is a base 64 VLQ relative to the previous
+  #    occurrence of this field, unless this is the first occurrence of this
+  #    field, in which case the whole value is represented. Always present if
+  #    there is a source field.
+  #
+  # 4. If present, the zero-based starting column of the line in the source
+  #    represented. This field is a base 64 VLQ relative to the previous
+  #    occurrence of this field, unless this is the first occurrence of this
+  #    field, in which case the whole value is represented. Always present if
+  #    there is a source field.
+  #
+  # 5. If present, the zero-based index into the “names” list associated with
+  #    this segment. This field is a base 64 VLQ relative to the previous
+  #    occurrence of this field, unless this is the first occurrence of this
+  #    field, in which case the whole value is represented.
+  def segment_from_fragment(fragment, generated_column)
+    source_index     = 0                          # always 0, we're dealing with a single file
+    original_line    = fragment.line - 1          # fragments have 1-based lines
+    original_column  = fragment.column            # fragments have 0-based columns
+
+    if fragment.source_map_name
+      map_name_index = (@names_map[fragment.source_map_name.to_s] ||= @names_map.size)
+      [
+        generated_column,
+        source_index,
+        original_line,
+        original_column,
+        map_name_index,
+      ]
+    else
+      [
+        generated_column,
+        source_index,
+        original_line,
+        original_column,
+      ]
+    end
+  end
+
+  def relative_mappings
+    @relative_mappings ||= begin
+      reference_segment = [0, 0, 0, 0, 0]
+      reference_name_index = 0
+      absolute_mappings.map do |absolute_mapping|
+        # [generated_column, source_index, original_line, original_column, map_name_index]
+        reference_segment[0] = 0 # reset the generated_column at each new line
+
+        absolute_mapping.map do |absolute_segment|
+          segment = []
+
+          segment[0] = absolute_segment[0] -  reference_segment[0]
+          segment[1] = absolute_segment[1] - (reference_segment[1] || 0)
+          segment[2] = absolute_segment[2] - (reference_segment[2] || 0)
+          segment[3] = absolute_segment[3] - (reference_segment[3] || 0)
+
+          # Since [4] can be nil we need to keep track of it in the reference_segment even if it's nil in absolute_segment
+          if absolute_segment[4]
+            segment[4] = absolute_segment[4].to_int - (reference_segment[4] || reference_name_index).to_int
+            reference_name_index = absolute_segment[4]
+          end
+
+          reference_segment = absolute_segment
+          segment
+        end
+      end
+    end
+  end
+
+  # The “mappings” data is broken down as follows:
+  #
+  # each group representing a line in the generated file is separated by a ”;”
+  # each segment is separated by a “,”
+  # each segment is made up of 1,4 or 5 variable length fields.
+  def absolute_mappings
+    @absolute_mappings ||= begin
+      mappings = []
+
+      fragments_by_line.each do |raw_segments|
+        generated_column = 0
+        segments = []
+        raw_segments.each do |(generated_code, fragment)|
+          if fragment.line && fragment.column
+            segments << segment_from_fragment(fragment, generated_column)
+          end
+          generated_column += generated_code.size
+        end
+        mappings << segments
+      end
+
+      mappings
+    end
+  end
+
+  private
+
+  def fragments_by_line
+    raw_mappings = [[]]
+    fragments.flat_map do |fragment|
+      fragment_code  = fragment.code
+      fragment_lines = fragment_code.split("\n", -1) # a negative limit won't suppress trailing null values
+      fragment_lines.each.with_index do |fragment_line, index|
+        raw_segment = [fragment_line, fragment]
+        if index.zero? && !fragment_line.size.zero?
+          raw_mappings.last << raw_segment
+        elsif index.zero? && fragment_line.size.zero?
+          # noop
+        elsif fragment_line.size.zero?
+          raw_mappings << []
+        else
+          raw_mappings << [raw_segment]
+        end
+      end
+    end
+    raw_mappings
+  end
+end

data/lib/opal/source_map/index.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+class Opal::SourceMap::Index
+  include Opal::SourceMap::Map
+
+  attr_reader :source_maps
+
+  # @param source_maps [Opal::SourceMap::File]
+  # @param join: the string used to join the sources, empty by default, Opal::Builder uses "\n"
+  def initialize(source_maps, join: nil)
+    @source_maps = source_maps
+    @join = join
+  end
+
+  # To support concatenating generated code and other common post processing, an
+  # alternate representation of a map is supported:
+  #
+  #  1: {
+  #  2: version : 3,
+  #  3: file: “app.js”,
+  #  4: sections: [
+  #  5:  { offset: {line:0, column:0}, url: “url_for_part1.map” }
+  #  6:  { offset: {line:100, column:10}, map:
+  #  7:    {
+  #  8:      version : 3,
+  #  9:      file: “section.js”,
+  # 10:      sources: ["foo.js", "bar.js"],
+  # 11:      names: ["src", "maps", "are", "fun"],
+  # 12:      mappings: "AAAA,E;;ABCDE;"
+  # 13:    }
+  # 14:  }
+  # 15: ],
+  # 16: }
+  #
+  # The index map follow the form of the standard map
+  #
+  # Line 1: The entire file is an JSON object.
+  # Line 2: The version field. See the description of the standard map.
+  # Line 3: The name field. See the description of the standard map.
+  # Line 4: The sections field.
+  #
+  # The “sections” field is an array of JSON objects that itself has two fields
+  # “offset” and a source map reference. “offset” is an object with two fields,
+  # “line” and “column”, that represent the offset into generated code that the
+  # referenced source map represents.
+  #
+  # The other field must be either “url” or “map”. A “url” entry must be a URL
+  # where a source map can be found for this section and the url is resolved in the
+  # same way as the “sources” fields in the standard map. A “map” entry must be an
+  # embedded complete source map object. An embedded map does not inherit any
+  # values from the containing index map.
+  #
+  # The sections must be sorted by starting position and the represented sections
+  # may not overlap.
+  #
+  def map
+    offset_line = 0
+    offset_column = 0
+    {
+      version: 3,
+      # file: "app.js",
+      sections: @source_maps.map do |source_map|
+        map = {
+          offset: {
+            line: offset_line,
+            column: offset_column,
+          },
+          map: source_map.to_h,
+        }
+
+        generated_code  = source_map.generated_code
+        generated_code += @join if @join
+        new_lines_count = generated_code.count("\n")
+        last_line       = generated_code[generated_code.rindex("\n") + 1..-1]
+
+        offset_line    += new_lines_count
+        offset_column  += last_line.size
+
+        map
+      end
+    }
+  end
+end

data/lib/opal/source_map/map.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'json'
+
+module Opal::SourceMap::Map
+  def to_h
+    map
+  end
+
+  def to_json
+    map.to_json
+  end
+
+  def as_json(*)
+    to_h
+  end
+
+  def to_s
+    map.to_s
+  end
+
+  def to_data_uri_comment
+    "//# sourceMappingURL=data:application/json;base64,#{Base64.encode64(to_json).delete("\n")}"
+  end
+end

data/lib/opal/source_map/vlq.rb

@@ -0,0 +1,98 @@
+# Ported from http://github.com/maccman/sourcemap
+#
+# 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 Opal::SourceMap::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
+      loop do
+        digit  = vlq & VLQ_BASE_MASK
+        vlq  >>= VLQ_BASE_SHIFT
+        digit |= VLQ_CONTINUATION_BIT if vlq > 0
+        result << BASE64_DIGITS[digit]
+
+        break unless vlq > 0
+      end
+    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

data/lib/opal/util.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'open3'
 
 module Opal
@@ -43,27 +44,28 @@ module Opal
       def which(cmd)
         exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
         ENV['PATH'].split(File::PATH_SEPARATOR).find do |path|
-          exts.find { |ext|
+          exts.find do |ext|
             exe = File.join(path, "#{cmd}#{ext}")
             exe if File.executable? exe
-          }
+          end
         end
       end
 
       INSTALLED = {}
       def command_installed?(cmd, install_comment)
         command_installed = Command::INSTALLED[cmd.to_s] ||= which(cmd)
-        $stderr.puts %Q("#{cmd}" command not found#{install_comment}) unless command_installed
+        $stderr.puts %{"#{cmd}" command not found#{install_comment}} unless command_installed
         command_installed
       end
     end
 
     class DigestSourceCommand < Command
+      ExitStatusError = Class.new(StandardError)
       def digest(source)
-        out, _, _ = Open3.capture3("#{command} #{options} #{hide_stderr}", stdin_data: source)
+        out, _, status = Open3.capture3("#{command} #{options} #{hide_stderr}", stdin_data: source)
+        raise ExitStatusError, "exited with status #{status.exitstatus}" unless status.success?
         out
       end
     end
-
   end
 end