opal 0.6.3 → 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

@@ -1,122 +1,98 @@
-class SourceMap
-  # Support for encoding/decoding the variable length quantity format
-  # described in the spec at:
+module SourceMap
+  # Public: Base64 VLQ encoding
   #
-  # https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit
+  # Adopted from ConradIrwin/ruby-source_map
+  #   https://github.com/ConradIrwin/ruby-source_map/blob/master/lib/source_map/vlq.rb
   #
-  # This implementation is heavily based on https://github.com/mozilla/source-map
-  # Copyright 2009-2011, Mozilla Foundation and contributors, BSD
+  # 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
-
-    # A single base 64 digit can contain 6 bits of data. For the base 64 variable
-    # length quantities we use in the source map spec, the first bit is the sign,
-    # the next four bits are the actual value, and the 6th bit is the
-    # continuation bit. The continuation bit tells us whether there are more
-    # digits in this value following this digit.
-    #
-    #   Continuation
-    #   |    Sign
-    #   |    |
-    #   V    V
-    #   101011
-
-    VLQ_BASE_SHIFT = 5;
-
-    # binary: 100000
-    VLQ_BASE = 1 << VLQ_BASE_SHIFT;
-
-    # binary: 011111
-    VLQ_BASE_MASK = VLQ_BASE - 1;
-
-    # binary: 100000
-    VLQ_CONTINUATION_BIT = VLQ_BASE;
+    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.update BASE64_DIGITS[i] => i }
-
-    # Returns the base 64 VLQ encoded value.
-    def self.encode(int)
+    BASE64_VALUES = (0...64).inject({}) { |h, i| h[BASE64_DIGITS[i]] = i; h }
 
-      vlq = to_vlq_signed(int)
-      encoded = []
-
-      begin
-        digit = vlq & VLQ_BASE_MASK
-        vlq >>= VLQ_BASE_SHIFT
-        digit |= VLQ_CONTINUATION_BIT if vlq > 0
-        encoded << base64_encode(digit)
-      end while vlq > 0
-
-      encoded.join
+    # 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
 
-    # Decodes the next base 64 VLQ value from the given string and returns the
-    # value and the rest of the string.
+    # Public: Decode a VLQ string.
+    #
+    # str - VLQ encoded String
+    #
+    # Returns an Array of Integers.
     def self.decode(str)
-
-      vlq = 0
-      shift = 0
-      continue = true
+      result = []
       chars = str.split('')
-
-      while continue
-        char = chars.shift or raise "Expected more digits in base 64 VLQ value."
-        digit = base64_decode(char)
-        continue = false if (digit & VLQ_CONTINUATION_BIT) == 0
-        digit &= VLQ_BASE_MASK
-        vlq += digit << shift
-        shift += VLQ_BASE_SHIFT
-      end
-
-      [from_vlq_signed(vlq), chars.join('')]
-    end
-
-    # Decode an array of variable length quantities from the given string and
-    # return them.
-    def self.decode_array(str)
-      output = []
-      while str != ''
-        int, str = decode(str)
-        output << int
+      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
-      output
-    end
-
-    protected
-
-    def self.base64_encode(int)
-      BASE64_DIGITS[int] or raise ArgumentError, "#{int} is not a valid base64 digit"
+      result
     end
 
-    def self.base64_decode(char)
-      BASE64_VALUES[char] or raise ArgumentError, "#{char} is not a valid base64 digit"
-    end
-
-    # Converts from a two's-complement integer to an integer where the
-    # sign bit is placed in the least significant bit. For example, as decimals:
-    #  1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
-    #  2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
-    def self.to_vlq_signed(int)
-      if int < 0
-        ((-int) << 1) + 1
-      else
-        int << 1
-      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
 
-    # Converts to a two's-complement value from a value where the sign bit is
-    # placed in the least significant bit. For example, as decimals:
+    # Public: Decode a VLQ string into mapping numbers.
+    #
+    # str - VLQ encoded String
     #
-    #  2 (10 binary) becomes 1, 3 (11 binary) becomes -1
-    #  4 (100 binary) becomes 2, 5 (101 binary) becomes -2
-    def self.from_vlq_signed(vlq)
-      if vlq & 1 == 1
-        -(vlq >> 1)
-      else
-        vlq >> 1
+    # 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
-    end
 
+      mappings
+    end
   end
 end

data/stdlib/sourcemap.rb

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

data/stdlib/strscan.rb

@@ -10,6 +10,8 @@ class StringScanner
     @match = []
   end
 
+  attr_reader :string
+
   def bol?
     `#@pos === 0 || #@string.charAt(#@pos - 1) === "\n"`
   end
@@ -24,7 +26,7 @@ class StringScanner
       }
       else if (typeof(result) === 'object') {
         #@prev_pos = #@pos;
-        #@pos      += result[0].length;
+        #@pos     += result[0].length;
         #@working  = #@working.substring(result[0].length);
         #@matched  = result[0];
         #@match    = result;
@@ -55,6 +57,10 @@ class StringScanner
         return nil;
       }
 
+      if (match[idx] == null) {
+        return nil;
+      }
+
       return match[idx];
     }
   end

data/stdlib/template.rb

@@ -1,7 +1,7 @@
 class Template
   @_cache = {}
   def self.[](name)
-    @_cache[name]
+    @_cache[name] || @_cache["templates/#{name}"]
   end
 
   def self.[]=(name, instance)

data/stdlib/thread.rb

@@ -1,20 +1,160 @@
+# This shim implementation of Thread is meant to only appease code that tries
+# to be safe in the presence of threads, but does not actually utilize them,
+# e.g., uses thread- or fiber-local variables.
+
+class ThreadError < StandardError
+end
+
 class Thread
   def self.current
-    @current ||= self.new
+    unless @current
+      @current = allocate
+      @current.core_initialize!
+    end
+
+    @current
   end
 
-  def initialize
-    @vars = {}
+  def self.list
+    [current]
+  end
+
+  # Do not allow creation of new instances.
+  def initialize(*args)
+    fail NotImplementedError, "Thread creation not available"
   end
 
+  # fiber-local attribute access.
   def [](key)
-    @vars[key]
+    @fiber_locals[coerce_key_name(key)]
+  end
+
+  def []=(key, value)
+    @fiber_locals[coerce_key_name(key)] = value
+  end
+
+  def key?(key)
+    @fiber_locals.key?(coerce_key_name(key))
+  end
+
+  def keys
+    @fiber_locals.keys
+  end
+
+  # thread-local attribute access.
+  def thread_variable_get(key)
+    @thread_locals[coerce_key_name(key)]
+  end
+
+  def thread_variable_set(key, value)
+    @thread_locals[coerce_key_name(key)] = value
+  end
+
+  def thread_variable?(key)
+    @thread_locals.key?(coerce_key_name(key))
+  end
+
+  def thread_variables
+    @thread_locals.keys
+  end
+
+  private
+  def core_initialize!
+    @thread_locals = {}
+    @fiber_locals  = {}
+  end
+
+  def coerce_key_name(key)
+    Opal.coerce_to!(key, String, :to_s)
   end
 
-  def []=(key, val)
-    @vars[key] = val
+  public
+  class Queue
+    def initialize
+      clear
+    end
+
+    def clear
+      @storage = []
+    end
+
+    def empty?
+      @storage.empty?
+    end
+
+    def size
+      @storage.size
+    end
+
+    alias length size
+
+    def pop(non_block = false)
+      if empty?
+        fail ThreadError, "Queue empty" if non_block
+        fail ThreadError, "Deadlock"
+      end
+
+      @storage.shift
+    end
+
+    alias shift pop
+    alias deq   pop
+
+    def push(value)
+      @storage.push(value)
+    end
+
+    alias <<  push
+    alias enq push
   end
+
 end
 
-class Queue
+Queue = Thread::Queue
+
+class Mutex
+  def initialize
+    # We still keep the @locked state so any logic based on try_lock while
+    # held yields reasonable results.
+    @locked = false
+  end
+
+  def lock
+    fail ThreadError, "Deadlock" if @locked
+    @locked = true
+    self
+  end
+
+  def locked?
+    @locked
+  end
+
+  def owned?
+    # Being the only "thread", we implicitly own any locked mutex.
+    @locked
+  end
+
+  def try_lock
+    if locked?
+      false
+    else
+      lock
+      true
+    end
+  end
+
+  def unlock
+    fail ThreadError, "Mutex not locked" unless @locked
+    @locked = false
+    self
+  end
+
+  def synchronize
+    lock
+    begin
+      yield
+    ensure
+      unlock
+    end
+  end
 end