opal-cj 0.7.0.beta1

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'

data/stdlib/stringio.rb

@@ -0,0 +1,181 @@
+class StringIO < IO
+  include IO::Readable
+  include IO::Writable
+
+  def self.open(string = "", mode = nil, &block)
+    io  = new(string, mode)
+    res = block.call(io)
+    io.close
+
+    res
+  end
+
+  attr_accessor :string
+
+  def initialize(string = "", mode = 'rw')
+    @string   = string
+    @position = string.length
+
+    if mode.include?('r') and not mode.include?('w')
+      @closed = :write
+    elsif mode.include?('w') and not mode.include?('r')
+      @closed = :read
+    end
+  end
+
+  def eof?
+    check_readable
+
+    @position == @string.length
+  end
+
+  alias eof eof?
+
+  def seek(pos, whence = IO::SEEK_SET)
+    case whence
+    when IO::SEEK_SET
+      raise Errno::EINVAL unless pos >= 0
+
+      @position = pos
+
+    when IO::SEEK_CUR
+      if @position + pos > @string.length
+        @position = @string.length
+      else
+        @position += pos
+      end
+
+    when IO::SEEK_END
+      if pos > @string.length
+        @position = 0
+      else
+        @position -= pos
+      end
+    end
+
+    0
+  end
+
+  def tell
+    @position
+  end
+
+  alias pos tell
+
+  alias pos= seek
+
+  def rewind
+    seek 0
+  end
+
+  def each_byte(&block)
+    return enum_for :each_byte unless block
+
+    check_readable
+
+    i = @position
+    until eof?
+      block.call(@string[i].ord)
+      i += 1
+    end
+
+    self
+  end
+
+  def each_char(&block)
+    return enum_for :each_char unless block
+
+    check_readable
+
+    i = @position
+    until eof?
+      block.call(@string[i])
+      i += 1
+    end
+
+    self
+  end
+
+  def write(string)
+    check_writable
+
+    string = String(string)
+
+    if @string.length == @position
+      @string   += string
+      @position += string.length
+    else
+      before = @string[0 .. @position - 1]
+      after  = @string[@position + string.length .. -1]
+
+      @string   = before + string + after
+      @position += string.length
+    end
+  end
+
+  def read(length = nil, outbuf = nil)
+    check_readable
+
+    return if eof?
+
+    string = if length
+      str = @string[@position, length]
+      @position += length
+      str
+    else
+      str = @string[@position .. -1]
+      @position = @string.length
+      str
+    end
+
+    if outbuf
+      outbuf.write(string)
+    else
+      string
+    end
+  end
+
+  def close
+    @closed = :both
+  end
+
+  def close_read
+    if @closed == :write
+      @closed = :both
+    else
+      @closed = :read
+    end
+  end
+
+  def close_write
+    if @closed == :read
+      @closed = :both
+    else
+      @closed = :write
+    end
+  end
+
+  def closed?
+    @closed == :both
+  end
+
+  def closed_read?
+    @closed == :read || @closed == :both
+  end
+
+  def closed_write?
+    @closed == :write || @closed == :both
+  end
+
+  def check_writable
+    if closed_write?
+      raise IOError, "not opened for writing"
+    end
+  end
+
+  def check_readable
+    if closed_read?
+      raise IOError, "not opened for reading"
+    end
+  end
+end

data/stdlib/strscan.rb

@@ -0,0 +1,155 @@
+class StringScanner
+  attr_reader :pos
+  attr_reader :matched
+
+  def initialize(string)
+    @string  = string
+    @pos     = 0
+    @matched = nil
+    @working = string
+    @match = []
+  end
+
+  attr_reader :string
+
+  def bol?
+    `#@pos === 0 || #@string.charAt(#@pos - 1) === "\n"`
+  end
+
+  def scan(regex)
+    %x{
+      var regex  = new RegExp('^' + regex.toString().substring(1, regex.toString().length - 1)),
+          result = regex.exec(#@working);
+
+      if (result == null) {
+        return #{self}.matched = nil;
+      }
+      else if (typeof(result) === 'object') {
+        #@prev_pos = #@pos;
+        #@pos     += result[0].length;
+        #@working  = #@working.substring(result[0].length);
+        #@matched  = result[0];
+        #@match    = result;
+
+        return result[0];
+      }
+      else if (typeof(result) === 'string') {
+        #@pos     += result.length;
+        #@working  = #@working.substring(result.length);
+
+        return result;
+      }
+      else {
+        return nil;
+      }
+    }
+  end
+
+  def [](idx)
+    %x{
+      var match = #@match;
+
+      if (idx < 0) {
+        idx += match.length;
+      }
+
+      if (idx < 0 || idx >= match.length) {
+        return nil;
+      }
+
+      if (match[idx] == null) {
+        return nil;
+      }
+
+      return match[idx];
+    }
+  end
+
+  def check(regex)
+    %x{
+      var regexp = new RegExp('^' + regex.toString().substring(1, regex.toString().length - 1)),
+          result = regexp.exec(#@working);
+
+      if (result == null) {
+        return #{self}.matched = nil;
+      }
+
+      return #{self}.matched = result[0];
+    }
+  end
+
+  def peek(length)
+    `#@working.substring(0, length)`
+  end
+
+  def eos?
+    `#@working.length === 0`
+  end
+
+  def skip(re)
+    %x{
+      re = new RegExp('^' + re.source)
+      var result = re.exec(#@working);
+
+      if (result == null) {
+        return #{self}.matched = nil;
+      }
+      else {
+        var match_str = result[0];
+        var match_len = match_str.length;
+        #{self}.matched = match_str;
+        self.prev_pos = self.pos;
+        #{self}.pos += match_len;
+        #{self}.working = #{self}.working.substring(match_len);
+        return match_len;
+      }
+    }
+  end
+
+  def get_byte()
+    %x{
+      var result = nil;
+      if (#{self}.pos < #{self}.string.length) {
+        self.prev_pos = self.pos;
+        #{self}.pos += 1;
+        result = #{self}.matched = #{self}.working.substring(0, 1);
+        #{self}.working = #{self}.working.substring(1);
+      }
+      else {
+        #{self}.matched = nil;
+      }
+
+      return result;
+    }
+  end
+
+  # not exactly, but for now...
+  alias getch get_byte
+
+  def pos=(pos)
+    %x{
+      if (pos < 0) {
+        pos += #{@string.length};
+      }
+    }
+
+    @pos = pos
+    @working = `#{@string}.slice(pos)`
+  end
+
+  def rest
+    @working
+  end
+
+  def terminate
+    @match = nil
+    self.pos = @string.length
+  end
+
+  def unscan
+    @pos = @prev_pos
+    @prev_pos = nil
+    @match = nil
+    self
+  end
+end