opal-cj 0.7.0.beta1

data/stdlib/racc/parser.rb

@@ -0,0 +1,215 @@
+# Opal port of racc/parser.rb.
+#
+# Original license:
+#
+# $originalId: parser.rb,v 1.8 2006/07/06 11:42:07 aamine Exp $
+#
+# Copyright (c) 1999-2006 Minero Aoki
+#
+# This program is free software.
+# You can distribute/modify this program under the same terms of ruby.
+#
+# As a special exception, when this code is copied by Racc
+# into a Racc output file, you may use that output file
+# without restriction.
+module Racc
+
+  class Parser
+
+    def _racc_setup
+      self.class::Racc_arg
+    end
+
+    def do_parse
+      _racc_do_parse_rb _racc_setup, false
+    end
+
+    def _racc_do_parse_rb(arg, in_debug)
+      action_table   = arg[0]
+      action_check   = arg[1]
+      action_default = arg[2]
+      action_pointer = arg[3]
+
+      goto_table     = arg[4]
+      goto_check     = arg[5]
+      goto_default   = arg[6]
+      goto_pointer   = arg[7]
+
+      nt_base        = arg[8]
+      reduce_table   = arg[9]
+      token_table    = arg[10]
+      shift_n        = arg[11]
+      reduce_n       = arg[12]
+
+      use_result     = arg[13]
+
+      # racc sys vars
+      racc_state     = [0]
+      racc_tstack    = []
+      racc_vstack    = []
+
+      racc_t         = nil
+      racc_tok       = nil
+      racc_val       = nil
+      racc_read_next = true
+
+      racc_user_yyerror = false
+      racc_error_status = 0
+
+      token = nil; act = nil; i = nil; nerr = nil; custate = nil
+
+      while true
+        i = action_pointer[racc_state[-1]]
+
+        if i
+          if racc_read_next
+            if racc_t != 0 # not EOF
+              token = next_token
+
+              racc_tok = token[0]
+              racc_val = token[1]
+
+              if racc_tok == false # EOF
+                racc_t = 0
+              else
+                racc_t = token_table[racc_tok]
+                racc_t = 1 unless racc_t
+                # racc_t ||= 1
+              end
+
+              racc_read_token(racc_t, racc_tok, racc_val) if @yydebug
+              racc_read_next = false
+            end
+          end
+
+          i += racc_t
+
+          if (i < 0) || (act = action_table[i]).nil? || (action_check[i] != racc_state[-1])
+            act = action_default[racc_state[-1]]
+          end
+
+        else
+          act = action_default[racc_state[-1]]
+        end
+
+        puts "(act: #{act}, shift_n: #{shift_n}, reduce_n: #{reduce_n})" if @yydebug
+        if act > 0 && act < shift_n
+          if racc_error_status > 0
+            if racc_t != 1
+              racc_error_status -= 1
+            end
+          end
+
+          racc_vstack.push racc_val
+          curstate = act
+          racc_state << act
+          racc_read_next = true
+
+          if @yydebug
+            racc_tstack.push racc_t
+            racc_shift racc_t, racc_tstack, racc_vstack
+          end
+
+        elsif act < 0 && act > -reduce_n
+          reduce_i   = act * -3
+          reduce_len = reduce_table[reduce_i]
+          reduce_to  = reduce_table[reduce_i + 1]
+          method_id  = reduce_table[reduce_i + 2]
+
+          tmp_t = racc_tstack.last reduce_len
+          tmp_v = racc_vstack.last reduce_len
+
+          racc_state.pop reduce_len
+          racc_vstack.pop reduce_len
+          racc_tstack.pop reduce_len
+
+          if use_result
+            reduce_call_result = self.__send__ method_id, tmp_v, nil, tmp_v[0]
+            racc_vstack.push reduce_call_result
+          else
+            raise "not using result??"
+          end
+
+          racc_tstack.push reduce_to
+
+          if @yydebug
+            racc_reduce tmp_t, reduce_to, racc_tstack, racc_vstack
+          end
+
+          k1 = reduce_to - nt_base
+
+          if (reduce_i = goto_pointer[k1]) != nil
+            reduce_i += racc_state[-1]
+
+            if (reduce_i >= 0) && ((curstate = goto_table[reduce_i]) != nil) && (goto_check[reduce_i] == k1)
+              racc_state.push curstate
+            else
+              racc_state.push goto_default[k1]
+            end
+
+          else
+            racc_state.push goto_default[k1]
+          end
+
+        elsif act == shift_n
+          # action
+          return racc_vstack[0]
+
+        elsif act == -reduce_n
+          # reduce
+          raise SyntaxError, "unexpected '#{racc_tok.inspect}'"
+
+        else
+          raise "Rac: unknown action: #{act}"
+        end
+
+        if @yydebug
+          racc_next_state racc_state[-1], racc_state
+        end
+        # raise "and finished loop"
+      end
+
+    end # _racc_do_parse_rb
+
+    def racc_read_token(t, tok, val)
+      puts "read    #{tok}(#{racc_token2str(t)}) #{val.inspect}"
+      puts "\n"
+    end
+
+    def racc_shift(tok, tstack, vstack)
+      puts "shift  #{racc_token2str tok}"
+      racc_print_stacks tstack, vstack
+      puts "\n"
+    end
+
+    def racc_reduce(toks, sim, tstack, vstack)
+      puts "reduce #{toks.empty? ? '<none>' : toks.map { |t| racc_token2str(t) }}"
+      puts "  --> #{racc_token2str(sim)}"
+      racc_print_stacks tstack, vstack
+    end
+
+    def racc_next_state(curstate, state)
+      puts "goto  #{curstate}"
+      racc_print_states state
+      puts "\n"
+    end
+
+    def racc_token2str(tok)
+      self.class::Racc_token_to_s_table[tok]
+    end
+
+    def racc_print_stacks(t, v)
+      puts '  ['
+      t.each_index do |i|
+        puts "    (#{racc_token2str(t[i])} #{v[i].inspect})"
+      end
+      puts '  ]'
+    end
+
+    def racc_print_states(s)
+      puts '  ['
+      s.each { |st| puts "   #{st}" }
+      puts '  ]'
+    end
+  end
+end

data/stdlib/rbconfig.rb

@@ -0,0 +1,20 @@
+module RbConfig
+  versions = RUBY_VERSION.split('.')
+  CONFIG = {
+    'ruby_version' => RUBY_VERSION,
+    'MAJOR'        => versions[0],
+    'MINOR'        => versions[1],
+    'TEENY'        => versions[2],
+    'RUBY'         => RUBY_ENGINE,
+    'RUBY_INSTALL_NAME' => RUBY_ENGINE,
+    'RUBY_SO_NAME'      => RUBY_ENGINE,
+    'target_os'         => 'ECMA-262',
+    'host_os'           => 'ECMA-262',
+    'PATH_SEPARATOR'    => ':'
+  }
+end
+
+# required for mspec it would appear
+RUBY_NAME = 'opal'
+RUBY_EXE = 'opal'
+RUBY_PATCHLEVEL = "327"

data/stdlib/securerandom.rb

@@ -0,0 +1,12 @@
+module SecureRandom
+  def self.uuid
+    "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".gsub /[xy]/ do |ch,|
+      %x{
+        var r = Math.random() * 16 | 0,
+            v = ch == "x" ? r : (r & 3 | 8);
+
+        return v.toString(16);
+      }
+    end
+  end
+end

data/stdlib/set.rb

@@ -0,0 +1,116 @@
+class Set
+  include Enumerable
+
+  def self.[](*ary)
+    new(ary)
+  end
+
+  def initialize(enum = nil, &block)
+    @hash = Hash.new
+
+    return if enum.nil?
+    raise ArgumentError, 'value must be enumerable' unless Enumerable === enum
+
+    if block
+      do_with_enum(enum) { |o| add(block[o]) }
+    else
+      merge(enum)
+    end
+  end
+
+  def inspect
+    "#<Set: {#{to_a.join(',')}}>"
+  end
+
+  def ==(other)
+    if self.equal?(other)
+      true
+    elsif other.instance_of?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    elsif other.is_a?(Set) && self.size == other.size
+      other.all? { |o| @hash.include?(o) }
+    else
+      false
+    end
+  end
+
+  def add(o)
+    @hash[o] = true
+    self
+  end
+  alias << add
+
+  def delete(o)
+    @hash.delete(o)
+    self
+  end
+
+  def delete?(o)
+    if include?(o)
+      delete(o)
+      self
+    else
+      nil
+    end
+  end
+
+  def delete_if
+    block_given? or return enum_for(__method__)
+    # @hash.delete_if should be faster, but using it breaks the order
+    # of enumeration in subclasses.
+    select { |o| yield o }.each { |o| @hash.delete(o) }
+    self
+  end
+
+  def add?(o)
+    if include?(o)
+      nil
+    else
+      add(o)
+    end
+  end
+
+  def each(&block)
+    return enum_for :each unless block_given?
+    @hash.each_key(&block)
+    self
+  end
+
+  def empty?
+    @hash.empty?
+  end
+
+  def clear
+    @hash.clear
+    self
+  end
+
+  def include?(o)
+    @hash.include?(o)
+  end
+  alias member? include?
+
+  def merge(enum)
+    do_with_enum(enum) { |o| add o }
+    self
+  end
+
+  def do_with_enum(enum, &block)
+    enum.each(&block)
+  end
+
+  def size
+    @hash.size
+  end
+  alias length size
+
+  def to_a
+    @hash.keys
+  end
+end
+
+module Enumerable
+  def to_set(klass = Set, *args, &block)
+    klass.new(self, *args, &block)
+  end
+end

data/stdlib/singleton.rb

@@ -0,0 +1,40 @@
+module Singleton
+  def clone
+    raise TypeError, "can't clone instance of singleton #{self.class}"
+  end
+
+  def dup
+    raise TypeError, "can't dup instance of singleton #{self.class}"
+  end
+
+  module SingletonClassMethods
+
+    def clone
+      Singleton.__init__(super)
+    end
+
+    def inherited(sub_klass)
+      super
+      Singleton.__init__(sub_klass)
+    end
+  end
+
+  class << Singleton
+    def __init__(klass)
+      klass.instance_eval {
+        @singleton__instance__ = nil
+      }
+      def klass.instance
+        return @singleton__instance__ if @singleton__instance__
+        @singleton__instance__ = new()
+      end
+      klass
+    end
+
+    def included(klass)
+      super
+      klass.extend SingletonClassMethods
+      Singleton.__init__(klass)
+    end
+  end
+end

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