opal 0.6.3 → 0.7.0.beta1

data/stdlib/nodejs/rubygems.rb

@@ -0,0 +1,68 @@
+require 'json'
+
+module Gem
+  class Install
+    def initialize(name, version)
+      @name = name
+      @version = version
+    end
+
+    def version
+      @version ||= latest_version(name)
+    end
+
+    def latest_version(name)
+      command = curl("https://rubygems.org/api/v1/versions/#{name}.json")
+      versions = JSON.parse system(command)
+      versions.first['number']
+    end
+
+    def full_name
+      "#{name}-#{version}"
+    end
+
+    def gem_home
+      ENV['HOME']+'/.opal-node/opal-gems/#{RUBY_ENGINE_VERSION}'
+    end
+
+    def gems_dir
+      File.join(gem_home, :gems)
+    end
+
+    def specs_dir
+      File.join(gem_home, :specs)
+    end
+
+    def perform
+      gem_dir = File.join(gems_dir, full_name)
+      spec_dir = File.join(specs_dir, full_name+'.yml')
+      system "mkdir -p #{gem_dir} #{spec_dir}"
+
+      Dir.chdir gem_dir do
+        system curl("https://rubygems.org/downloads/#{name}-#{version}.gem") + '| tar -xv'
+        system "gunzip metadata.gz --stdout > #{specs_dir}/#{full_name}.yml"
+        system "gunzip data.tar.gz"
+        system "tar -xvf data.tar"
+      end
+    end
+
+    def curl url
+      "curl -L #{url}"
+    end
+  end
+end
+
+command = ARGV.shift
+case command
+when 'install'
+  name = ARGV.shift
+  if ARGV.include? '-v'
+    version = ARGV[ ARGV.index('-v')+1 ]
+  else
+    version = nil
+  end
+  install = Gem::Install.new(name, version)
+  install.perform
+else
+  raise NotImplementedError, "sorry, the #{command.inspect} is not implemented."
+end

data/stdlib/nodejs/runtime.rb

@@ -0,0 +1,25 @@
+%x{
+// Generated by CoffeeScript 1.6.3
+(function() {
+  var OpalNode, extensions, fs, parser, parserFile, source, sourceFile, vm, __path__;
+  fs = require('fs');
+  __path__ = require('path');
+  vm = require('vm');
+  // vm.runInThisContext(parser, parserFile);
+  OpalNode = (function() {
+    function OpalNode() {}
+    OpalNode.node_require = require;
+    return OpalNode;
+  })();
+
+  global.OpalNode = OpalNode;
+
+}).call(this);
+}
+
+module NodeJS
+  def self.require name
+    `OpalNode.node_require(#{name})`
+  end
+end
+

data/stdlib/nodejs/yaml.rb

@@ -0,0 +1,11 @@
+require 'native'
+
+module YAML
+  `var __yaml__ = OpalNode.node_require('js-yaml')`
+
+  def self.load_path path
+    loaded = `__yaml__.yaml.safeLoad(#{File.__fs__}.readFileSync(#{path}, 'utf8'))`
+    loaded = Hash.new(loaded) if native?(loaded)
+    loaded
+  end
+end

data/stdlib/opal-parser.rb

@@ -1,11 +1,10 @@
 require 'opal/compiler'
-require 'opal/builder'
 require 'opal/erb'
 require 'opal/version'
 
 module Kernel
   def eval(str)
-    code = Opal.compile str
+    code = Opal.compile str, file: '(eval)'
     `eval(#{code})`
   end
 

data/stdlib/opal-source-maps.rb

@@ -0,0 +1,2 @@
+require 'source_map'
+require 'opal/source_map'

data/stdlib/phantomjs.rb

@@ -0,0 +1,8 @@
+module Kernel
+  def exit status = 0
+    `callPhantom(['exit', status]);`
+  end
+end
+
+STDOUT.write_proc = `function(str){callPhantom(['stdout', str])}`
+STDERR.write_proc = `function(str){callPhantom(['stderr', str])}`

data/stdlib/process.rb

@@ -0,0 +1,10 @@
+class Process
+  def self.pid
+    0
+  end
+end
+
+class Signal
+  def self.trap(*)
+  end
+end

data/stdlib/promise.rb

@@ -174,8 +174,8 @@ class Promise
   alias finally always
   alias ensure always
 
-  def trace(&block)
-    self ^ Trace.new(block)
+  def trace(depth = nil, &block)
+    self ^ Trace.new(depth, block)
   end
 
   def inspect
@@ -209,9 +209,17 @@ class Promise
       end
     end
 
-    def initialize(block)
+    def initialize(depth, block)
+      @depth = depth
+
       super -> {
-        block.call(*Trace.it(self).reverse)
+        trace = Trace.it(self).reverse
+
+        if depth && depth <= trace.length
+          trace.shift(trace.length - depth)
+        end
+
+        block.call(*trace)
       }
     end
   end

data/stdlib/set.rb

@@ -9,6 +9,7 @@ class Set
     @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]) }
@@ -17,6 +18,10 @@ class Set
     end
   end
 
+  def inspect
+    "#<Set: {#{to_a.join(',')}}>"
+  end
+
   def ==(other)
     if self.equal?(other)
       true
@@ -35,6 +40,28 @@ class Set
   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

data/stdlib/source_map.rb

@@ -1,63 +1,5 @@
-require 'json'
-
-require 'source_map/vlq.rb'
-require 'source_map/generator.rb'
-require 'source_map/parser.rb'
-
-class SourceMap
-  include SourceMap::Generator
-  include SourceMap::Parser
-
-  # Create a new blank SourceMap
-  #
-  # Options may include:
-  #
-  # :file => String           # See {#file}
-  # :source_root => String    # See {#source_root}
-  # :generated_output => IO   # See {#generated_output}
-  #
-  # :sources => Array[String] # See {#sources}
-  # :names => Array[String]   # See {#names}
-  #
-  # :version => 3             # Which version of SourceMap to use (only 3 is allowed)
-  #
-  def initialize(opts={})
-    unless (remain = opts.keys - [:generated_output, :file, :source_root, :sources, :names, :version]).empty?
-      raise ArgumentError, "Unsupported options to SourceMap.new: #{remain.inspect}"
-    end
-    self.generated_output = opts[:generated_output]
-    self.file = opts[:file] || ''
-    self.source_root = opts[:source_root] || ''
-    self.version = opts[:version] || 3
-    self.sources = opts[:sources] || []
-    self.names = opts[:names] || []
-    self.mappings = []
-    raise "version #{opts[:version]} not supported" if version != 3
-  end
-
-  # The name of the file containing the code that this SourceMap describes.
-  # (default "")
-  attr_accessor :file
-
-  # The URL/directory that contains the original source files.
-  #
-  # This is prefixed to the entries in ['sources']
-  # (default "")
-  attr_accessor :source_root
-
-  # The version of the SourceMap spec we're using.
-  # (default 3)
-  attr_accessor :version
-
-  # The list of sources (used during parsing/generating)
-  # These are relative to the source_root.
-  # (default [])
-  attr_accessor :sources
-
-  # A list of names (used during parsing/generating)
-  # (default [])
-  attr_accessor :names
-
-  # A list of mapping objects.
-  attr_accessor :mappings
-end
+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