opal 1.0.1 → 1.1.0.rc1

data/spec/ruby_specs

@@ -0,0 +1,183 @@
+ruby/core/array
+
+ruby/core/array/pack/a_spec
+!ruby/core/array/pack/at_spec
+!ruby/core/array/pack/b_spec
+ruby/core/array/pack/c_spec
+!ruby/core/array/pack/comment_spec
+!ruby/core/array/pack/d_spec
+!ruby/core/array/pack/e_spec
+!ruby/core/array/pack/empty_spec
+!ruby/core/array/pack/f_spec
+!ruby/core/array/pack/g_spec
+!ruby/core/array/pack/h_spec
+!ruby/core/array/pack/i_spec
+!ruby/core/array/pack/j_spec
+ruby/core/array/pack/l_spec
+!ruby/core/array/pack/m_spec
+!ruby/core/array/pack/n_spec
+!ruby/core/array/pack/p_spec
+!ruby/core/array/pack/percent_spec
+!ruby/core/array/pack/q_spec
+!ruby/core/array/pack/s_spec
+ruby/core/array/pack/u_spec
+!ruby/core/array/pack/v_spec
+!ruby/core/array/pack/w_spec
+!ruby/core/array/pack/x_spec
+!ruby/core/array/pack/z_spec
+
+ruby/core/basicobject
+ruby/core/builtin_constants
+ruby/core/class
+ruby/core/comparable
+
+ruby/core/complex
+!ruby/core/complex/marshal_dump_spec
+
+ruby/core/enumerable
+ruby/core/enumerator
+
+ruby/core/exception
+!ruby/core/exception/load_error_spec
+
+ruby/core/false
+ruby/core/integer
+ruby/core/file/basename_spec
+ruby/core/file/dirname_spec
+ruby/core/file/extname_spec
+ruby/core/file/join_spec
+ruby/core/file/expand_path_spec
+ruby/core/file/absolute_path_spec
+ruby/core/float
+ruby/core/hash
+ruby/core/integer
+
+ruby/core/kernel
+!ruby/core/kernel/abort_spec
+!ruby/core/kernel/at_exit_spec
+!ruby/core/kernel/backtick_spec
+!ruby/core/kernel/binding_spec
+!ruby/core/kernel/callcc_spec
+!ruby/core/kernel/caller_locations_spec
+!ruby/core/kernel/catch_spec
+!ruby/core/kernel/chomp_spec
+!ruby/core/kernel/chop_spec
+!ruby/core/kernel/exec_spec
+!ruby/core/kernel/exit_spec
+!ruby/core/kernel/fork_spec
+!ruby/core/kernel/gets_spec
+!ruby/core/kernel/load_spec
+!ruby/core/kernel/open_spec
+!ruby/core/kernel/putc_spec
+!ruby/core/kernel/readlines_spec
+!ruby/core/kernel/readline_spec
+!ruby/core/kernel/require_relative_spec
+!ruby/core/kernel/require_spec
+!ruby/core/kernel/select_spec
+!ruby/core/kernel/set_trace_func_spec
+!ruby/core/kernel/spawn_spec
+!ruby/core/kernel/syscall_spec
+!ruby/core/kernel/system_spec
+!ruby/core/kernel/tainted_spec
+!ruby/core/kernel/taint_spec
+!ruby/core/kernel/test_spec
+!ruby/core/kernel/throw_spec
+!ruby/core/kernel/trace_var_spec
+!ruby/core/kernel/trap_spec
+!ruby/core/kernel/trust_spec
+!ruby/core/kernel/untaint_spec
+!ruby/core/kernel/untrace_var_spec
+!ruby/core/kernel/untrusted_spec
+!ruby/core/kernel/untrust_spec
+
+ruby/core/matchdata
+ruby/core/math
+
+ruby/core/method
+
+ruby/core/module
+!ruby/core/module/autoload_spec
+
+ruby/core/marshal/load_spec
+ruby/core/marshal/dump_spec
+ruby/core/marshal/major_version_spec
+ruby/core/marshal/minor_version_spec
+
+ruby/core/nil
+ruby/core/numeric
+
+ruby/core/proc
+
+ruby/core/range
+ruby/core/rational
+ruby/core/regexp
+ruby/core/random
+
+ruby/core/string
+!ruby/core/string/crypt_spec
+!ruby/core/string/scrub_spec
+
+ruby/core/string/unpack/a_spec
+!ruby/core/string/unpack/at_spec
+ruby/core/string/unpack/b_spec
+ruby/core/string/unpack/c_spec
+!ruby/core/string/unpack/comment_spec
+!ruby/core/string/unpack/d_spec
+!ruby/core/string/unpack/e_spec
+!ruby/core/string/unpack/f_spec
+!ruby/core/string/unpack/g_spec
+ruby/core/string/unpack/h_spec
+!ruby/core/string/unpack/i_spec
+!ruby/core/string/unpack/j_spec
+ruby/core/string/unpack/l_spec
+ruby/core/string/unpack/m_spec
+ruby/core/string/unpack/n_spec
+!ruby/core/string/unpack/p_spec
+!ruby/core/string/unpack/percent_spec
+ruby/core/string/unpack/q_spec
+ruby/core/string/unpack/s_spec
+ruby/core/string/unpack/u_spec
+ruby/core/string/unpack/v_spec
+ruby/core/string/unpack/w_spec
+!ruby/core/string/unpack/x_spec
+ruby/core/string/unpack/z_spec
+
+ruby/core/struct
+ruby/core/symbol/to_proc_spec
+
+ruby/core/time
+!ruby/core/time/_dump_spec
+!ruby/core/time/_load_spec
+
+ruby/core/true
+ruby/core/unboundmethod
+
+ruby/language
+!ruby/language/execution_spec
+!ruby/language/safe_spec
+
+ruby/library/base64
+ruby/library/bigdecimal
+!ruby/library/bigdecimal/util_spec
+ruby/library/date
+ruby/library/delegate/delegator/send_spec
+ruby/library/erb/util/h_spec
+ruby/library/erb/util/html_escape_spec
+ruby/library/logger/severity_spec
+ruby/library/observer
+
+ruby/library/openstruct
+!ruby/library/openstruct/frozen_spec
+!ruby/library/openstruct/marshal_load_spec
+!ruby/library/openstruct/marshal_dump_spec
+
+ruby/library/pathname
+!ruby/library/pathname/empty_spec
+!ruby/library/pathname/glob_spec
+ruby/library/pp
+ruby/library/securerandom/hex_spec
+ruby/library/set
+ruby/library/singleton
+ruby/library/stringio/each_line_spec
+ruby/library/stringio/each_spec
+ruby/library/stringscanner

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'opal'
+require 'set'
+require 'opal/platform'
+require 'opal-parser'
+require 'mspec'
+require 'mspec/version'
+require 'support/mspec_rspec_adapter'
+require 'support/guard_platform'
+require 'mspec-opal/runner'
+
+# Node v0.12 as well as Google Chrome/V8 42.0.2311.135 (64-bit)
+# showed to need more tolerance (ruby spec default is 0.00003)
+TOLERANCE = 0.00004
+
+ENV['MSPEC_RUNNER'] = true
+
+module Kernel
+  def opal_parse(str, file='(string)')
+    Opal::Parser.new.parse str, file
+  end
+
+  def eval_js(javascript)
+    `eval(javascript)`
+  end
+end
+
+# To make MSpec happy
+require 'thread'
+
+require 'mspec/utils/script' # Needed by DottedFormatter
+require 'mspec-opal/formatters'

data/spec/support/guard_platform.rb

@@ -0,0 +1,4 @@
+class PlatformGuard < SpecGuard
+  HOST_OS = ENV['OPAL_PLATFORM_NAME']
+  POINTER_SIZE = ENV['OPAL_POINTER_SIZE'] || WORD_SIZE
+end

data/spec/support/match_helpers.rb

@@ -0,0 +1,57 @@
+module MatchHelpers
+  class MatchMatcher
+    def initialize(expected)
+      fail "Expected #{expected} to be a Regexp!" unless expected.is_a?(Regexp)
+      @expected = expected
+    end
+
+    def matches?(actual)
+      @actual = actual
+      @expected.match(@actual)
+    end
+
+    def failure_message
+      ["Expected #{@actual.inspect} (#{@actual.class})",
+       "to match #{@expected}"]
+    end
+
+    def negative_failure_message
+      ["Expected #{@actual.inspect} (#{@actual.class})",
+       "not to match #{@expected}"]
+    end
+  end
+
+  class EndWithHelper
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def matches?(actual)
+      @actual = actual
+      @actual.end_with?(@expected)
+    end
+
+    def failure_message
+      ["Expected #{@actual.inspect} (#{@actual.class})",
+       "to end with #{@expected}"]
+    end
+
+    def negative_failure_message
+      ["Expected #{@actual.inspect} (#{@actual.class})",
+       "not to end with #{@expected}"]
+    end
+  end
+end
+
+if !defined? RSpec
+  class Object
+    def match(expected)
+      MatchHelpers::MatchMatcher.new(expected)
+    end
+
+    def end_with(expected)
+      MatchHelpers::EndWithHelper.new(expected)
+    end
+  end
+end
+

data/spec/support/mspec_rspec_adapter.rb

@@ -0,0 +1,33 @@
+module MSpecRSpecAdapter
+  def expect(object)
+    MSpecRSpecAdapterShould.new(object)
+  end
+
+  def eq(expected)
+    MSpecRSpecAdapterEq.new(expected)
+  end
+
+  class MSpecRSpecAdapterEq < Struct.new(:object)
+  end
+
+  class MSpecRSpecAdapterShould < Struct.new(:object)
+    def to(expectation)
+      apply_expectation(:should, expectation)
+    end
+
+    def apply_expectation(type, expectation)
+      if MSpecRSpecAdapterEq === expectation
+        object.send(type) == expectation.object
+      else
+        object.send(type, expectation)
+      end
+    end
+
+    def not_to(expectation)
+      apply_expectation(:should_not, expectation)
+    end
+    alias to_not not_to
+  end
+end
+
+include MSpecRSpecAdapter unless defined? RSpec

data/spec/support/rewriters_helper.rb

@@ -0,0 +1,54 @@
+module RewritersHelper
+  def s(type, *children)
+    ::Opal::AST::Node.new(type, children)
+  end
+
+  def rewritten(ast)
+    described_class.new.process(ast)
+  end
+
+  alias :rewrite :rewritten
+
+  def expect_rewritten(ast)
+    expect(rewritten(ast))
+  end
+
+  def expect_no_rewriting_for(ast)
+    expect_rewritten(ast).to eq(ast)
+  end
+
+  def parse(source)
+    buffer = Opal::Parser::SourceBuffer.new('(eval)')
+    buffer.source = source
+    parser = Opal::Parser.default_parser
+    parser.parse(buffer)
+  end
+
+  alias :ast_of :parse
+
+  def parse_without_rewriting(source)
+    buffer = Opal::Parser::SourceBuffer.new('(eval)')
+    buffer.source = source
+    parser = Parser::Ruby30.new
+    parser.parse(buffer)
+  end
+end
+
+RSpec.shared_examples 'it rewrites source-to-source' do |from_source, to_source|
+  it "rewrites source #{from_source} to source #{to_source}" do
+    initial = ast_of(from_source)
+    rewritten = self.rewritten(initial)
+    expected = ast_of(to_source)
+
+    expect(rewritten).to eq(expected)
+  end
+end
+
+RSpec.shared_examples 'it rewrites source-to-AST' do |from_source, to_ast|
+  it "rewrites source #{from_source} to AST #{to_ast}" do
+    initial = ast_of(from_source)
+    rewritten = self.rewritten(initial)
+
+    expect(rewritten).to eq(to_ast)
+  end
+end

data/spec/support/source_map_helper.rb

@@ -0,0 +1,190 @@
+module SourceMapHelper
+  extend self
+
+  # Just for debugging purposes
+  def inspect_source(source)
+    puts source_with_lines(source)
+  end
+
+  # Just for debugging purposes
+  def source_with_lines(source)
+    source.split("\n", -1).map.with_index { |line, index| "#{(index).to_s.rjust(3)} | #{line}" }.join("\n")
+  end
+
+  def fragment(line: nil, column: nil, source_map_name: nil, code: '', sexp_type: nil)
+    double('Fragment', line: line, column: column, source_map_name: source_map_name, code: code, sexp_type: sexp_type)
+  end
+
+  SourcePosition = Struct.new(:line, :column, :file) do
+    def inspect
+      "#<SourcePosition line:#{line} column:#{column} file:#{file.inspect}>"
+    end
+    alias_method :to_s, :inspect
+
+    def in_source(source)
+      source.split("\n", -1)[line].to_s[column..-1]
+    end
+
+    def self.absolutize_mappings(relative_mappings)
+      reference_segment = [0, 0, 0, 0, 0]
+      relative_mappings.map do |relative_mapping|
+        # Reference: [generated_column, source_index, original_line, original_column, map_name_index]
+        reference_segment[0] = 0 # reset the generated_column at each new line
+
+        relative_mapping.map do |relative_segment|
+          segment = []
+
+          segment[0] = relative_segment[0].to_int +  reference_segment[0].to_int
+          segment[1] = relative_segment[1].to_int + (reference_segment[1] || 0).to_int if relative_segment[1]
+          segment[2] = relative_segment[2].to_int + (reference_segment[2] || 0).to_int if relative_segment[2]
+          segment[3] = relative_segment[3].to_int + (reference_segment[3] || 0).to_int if relative_segment[3]
+          segment[4] = relative_segment[4].to_int + (reference_segment[4] || 0).to_int if relative_segment[4]
+
+          reference_segment = segment
+          segment
+        end
+      end
+    end
+
+    def find_section_in_map_index(index_map)
+      sections = index_map.to_h[:sections]
+      section, section_index = sections.each.with_index.find do |map, index|
+        next_map = sections[index + 1] or next true # if there's no next map the current one is good
+
+        (
+          line > map[:offset][:line] || (line == map[:offset][:line] && column >= map[:offset][:column])
+        ) && (
+          line < next_map[:offset][:line] || (line == next_map[:offset][:line] && column < map[:offset][:column])
+        )
+      end
+
+      next_section = sections[section_index + 1]
+
+      section or raise "no map found for #{inspect} among available sections: #{sections.map { |s| s[:offset] }}"
+    end
+
+    def mapped_with(map)
+      case map
+      when Opal::SourceMap::Index
+        offset_section = find_section_in_map_index(map)
+
+        offset = offset_section[:offset] || raise(offset_section.inspect)
+
+        offset_line = line - offset[:line]
+        offset_column = line.zero? ? (column - offset[:column]) : column
+        offset_position = self.class.new(offset_line, offset_column, offset_section[:map][:sources].first)
+
+        offset_position.mapped_with_file_map(offset_section[:map])
+
+      when Opal::SourceMap::File
+        mapped_with_file_map(map.to_h)
+
+      else raise "unknown map type: #{map.inspect}"
+      end
+    end
+
+    def mapped_with_file_map(map_to_h)
+      relative_mappings = Opal::SourceMap::VLQ.decode_mappings(map_to_h[:mappings])
+      absolute_mappings = SourcePosition.absolutize_mappings(relative_mappings)
+      mappings_line = absolute_mappings[line] or raise(
+        "can't find a mapping for #{inspect} in the available #{absolute_mappings.size} absolute mappings: #{absolute_mappings.inspect}"
+      )
+
+      # keep all segments with a column from the required position on
+      code_before_segment_strategy = -> segments {
+        segments.select do |segment|
+          segment[0] >= column
+        end.sort_by do |segment|
+          segment[0] - column # sort by the distance from the required position
+        end.first
+      }
+
+      code_after_segment_strategy = -> segments {
+        segments.select do |segment|
+          column >= segment[0]
+        end.sort_by do |segment|
+          column - segment[0] # sort by the distance from the required position
+        end.first
+      }
+
+      absolute_segments = absolute_mappings[line] or raise
+      matched_segment = code_before_segment_strategy[absolute_segments] || code_after_segment_strategy[absolute_segments]
+
+      raise "can't find a matching segment for #{inspect} in #{absolute_mappings[line]}" unless matched_segment
+
+      source_index    = matched_segment[1]
+      original_source = map_to_h[:sources][source_index]
+      original_line   = matched_segment[2]
+      original_column = matched_segment[3]
+
+      self.class.new(original_line, original_column, original_source)
+    end
+
+    def original_source(map)
+      map_to_h = map.to_h
+      matching_source = -> map_data { map_data[:sourcesContent].first if map_data[:sources] == [file] }
+      (map_to_h[:sections] || [{offset: {}, map: map_to_h}]).map { |section| matching_source[section[:map]] }.compact.first or
+      raise "can't find a source for #{file.inspect} in #{map_to_h.to_json}"
+    end
+
+    def self.find_code(code, source:)
+      line_contents, line = source.split("\n", -1).to_enum.with_index.find do |contents, index|
+        contents.include? code
+      end
+      return nil if line_contents.nil?
+      column = line_contents.index(code)
+      new(line, column)
+    end
+  end
+
+  RSpec::Matchers.define :be_at_line_and_column do |line, column, source:|
+    expected_position = SourcePosition.new(line, column)
+
+    match do |code|
+      actual_position = SourcePosition.find_code(code, source: source)
+      actual_position == expected_position
+    end
+
+    failure_message do |code|
+      actual_position = SourcePosition.find_code(code, source: source)
+      actual_code = expected_position.in_source(source)
+      "expected #{code.inspect} to be at #{expected_position}, " +
+      "instead #{actual_code.inspect} was found at the expected position, while code was found at #{actual_position}"
+    end
+  end
+
+  RSpec::Matchers.define :be_mapped_to_line_and_column do |line, column, source:, map:, file: nil|
+    expected_position = SourcePosition.new(line, column, file)
+
+    match do |code|
+      actual_position = SourcePosition.find_code(code, source: source).mapped_with(map)
+      actual_position == expected_position
+    end
+
+    failure_message do |code|
+      code_position = SourcePosition.find_code(code, source: source)
+      actual_position = code_position.mapped_with(map)
+
+      expected_source = expected_position.original_source(map)
+      expected_code   = expected_position.in_source(expected_source)
+
+      actual_source   = actual_position.original_source(map)
+      actual_code     = actual_position.in_source(actual_source)
+
+      if Opal::SourceMap::Index === map
+        actual_section   = actual_position.find_section_in_map_index(map)
+        expected_section = expected_position.find_section_in_map_index(map)
+        map.to_h[:sections].each { |s| p s[:offset] }
+        actual_offset   = " (offset: #{actual_section[:offset]})"
+        expected_offset = " (offset: #{expected_section[:offset]})"
+      end
+
+      "expected #{code.inspect} at #{code_position.inspect} to be mapped to #{expected_position.inspect}" +
+      "\n\nEXPECTED #{expected_code.inspect} at #{expected_position}#{expected_offset}:\n"+
+      source_with_lines(expected_source) +
+      "\n\nACTUAL #{actual_code.inspect} at #{actual_position}#{actual_offset}:\n"+
+      source_with_lines(actual_source) +
+      "\n"
+    end
+  end
+end