opal 0.8.0.beta1 → 0.8.0.rc1

data/lib/opal/regexp_anchors.rb

@@ -0,0 +1,5 @@
+module Opal
+  REGEXP_START = RUBY_ENGINE == 'opal' ? '^' : '\A'.freeze
+  REGEXP_END = RUBY_ENGINE == 'opal' ? '$' : '\z'.freeze 
+end
+

data/lib/opal/sprockets/erb.rb

@@ -11,7 +11,7 @@ module Opal
       end
 
       def evaluate(context, locals, &block)
-        compiler = Opal::ERB::Compiler.new(@data, context.logical_path.sub(/^templates\//, ''))
+        compiler = Opal::ERB::Compiler.new(@data, context.logical_path.sub(/#{REGEXP_START}templates\//, ''))
         @data = compiler.prepared_source
         super
       end

data/lib/opal/sprockets/processor.rb

@@ -27,7 +27,7 @@ module Opal
       # In Sprockets 3 logical_path has an odd behavior when the filename is "index"
       # thus we need to bake our own logical_path
       filename = context.respond_to?(:filename) ? context.filename : context.pathname.to_s
-      logical_path = filename.sub(%r{^#{context.root_path}/?(.*?)#{sprockets_extnames_regexp}}, '\1')
+      logical_path = filename.gsub(%r{^#{context.root_path}/?(.*?)#{sprockets_extnames_regexp}}, '\1')
 
       compiler_options = self.compiler_options.merge(file: logical_path)
 
@@ -54,7 +54,7 @@ module Opal
     end
 
     def self.sprockets_extnames_regexp(sprockets)
-      joined_extnames = sprockets.engines.keys.map { |ext| Regexp.escape(ext) }.join('|')
+      joined_extnames = (['.js']+sprockets.engines.keys).map { |ext| Regexp.escape(ext) }.join('|')
       Regexp.new("(#{joined_extnames})*$")
     end
 
@@ -75,7 +75,7 @@ module Opal
 
       # This is the root dir of the logical path, we need this because
       # the compiler gives us the path relative to the file's logical path.
-      dirname = File.dirname(file).gsub(/#{Regexp.escape File.dirname(context.logical_path)}$/, '')
+      dirname = File.dirname(file).gsub(/#{Regexp.escape File.dirname(context.logical_path)}#{REGEXP_END}/, '')
       dirname = Pathname(dirname)
 
       required_trees.each do |original_required_tree|
@@ -95,50 +95,36 @@ module Opal
 
         environment = context.environment
 
-        if environment.respond_to?(:each_entry)
-          # Sprockets 2
-          environment.each_entry(required_tree) do |pathname|
-            if pathname.to_s == file
-              next
-            elsif pathname.directory?
-              context.depend_on(pathname)
-            elsif context.asset_requirable?(pathname)
-              context.require_asset(pathname)
-            end
-          end
-        else
-          # Sprockets 3
-          processor = ::Sprockets::DirectiveProcessor.new
-          processor.instance_variable_set('@dirname', File.dirname(file))
-          processor.instance_variable_set('@environment', environment)
-          path = processor.__send__(:expand_relative_dirname, :require_tree, original_required_tree)
-          absolute_paths = environment.__send__(:stat_sorted_tree_with_dependencies, path).first.map(&:first)
-
-          absolute_paths.each do |path|
-            path = Pathname(path)
-            pathname = path.relative_path_from(dirname)
-
-            if name.to_s == file
-              next
-            elsif path.directory?
-              context.depend_on(path.to_s)
-            else
-              context.require_asset(pathname)
-            end
+        processor = ::Sprockets::DirectiveProcessor.new
+        processor.instance_variable_set('@dirname', File.dirname(file))
+        processor.instance_variable_set('@environment', environment)
+        path = processor.__send__(:expand_relative_dirname, :require_tree, original_required_tree)
+        absolute_paths = environment.__send__(:stat_sorted_tree_with_dependencies, path).first.map(&:first)
+
+        absolute_paths.each do |path|
+          path = Pathname(path)
+          pathname = path.relative_path_from(dirname)
+
+          if name.to_s == file
+            next
+          elsif path.directory?
+            context.depend_on(path.to_s)
+          else
+            context.require_asset(pathname)
           end
         end
       end
     end
 
     def self.load_asset_code(sprockets, name)
-      asset = sprockets[name.sub(/(\.(js|rb|opal))*$/, '.js')]
+      asset = sprockets[name.sub(/(\.(js|rb|opal))*#{REGEXP_END}/, '.js')]
       return '' if asset.nil?
 
       opal_extnames = sprockets.engines.map do |ext, engine|
         ext if engine <= ::Opal::Processor
       end.compact
 
-      module_name = -> asset { asset.logical_path.sub(/\.js$/, '') }
+      module_name = -> asset { asset.logical_path.sub(/\.js#{REGEXP_END}/, '') }
       path_extnames = -> path { File.basename(path).scan(/\.[^.]+/) }
       mark_as_loaded = -> path { "Opal.mark_as_loaded(#{path.inspect});" }
       processed_by_opal = -> asset { (path_extnames[asset.pathname] & opal_extnames).any? }

data/lib/opal/sprockets/source_map_server.rb

@@ -45,13 +45,13 @@ module Opal
     end
 
     def self.get_map_cache(sprockets, logical_path)
-      logical_path = logical_path.gsub(/\.js$/, '')
+      logical_path = logical_path.gsub(/\.js#{REGEXP_END}/, '')
       cache_key = cache_key_for_path(logical_path+'.map')
       cache(sprockets).cache_get(cache_key)
     end
 
     def self.set_map_cache(sprockets, logical_path, map_contents)
-      logical_path = logical_path.gsub(/\.js$/, '')
+      logical_path = logical_path.gsub(/\.js#{REGEXP_END}/, '')
       cache_key = cache_key_for_path(logical_path+'.map')
       cache(sprockets).cache_set(cache_key, map_contents)
     end
@@ -61,7 +61,7 @@ module Opal
     end
 
     def self.cache_key_for_path(logical_path)
-      base_name = logical_path.gsub(/\.js$/, '')
+      base_name = logical_path.gsub(/\.js#{REGEXP_END}/, '')
       File.join('opal', 'source_maps', base_name)
     end
 
@@ -82,7 +82,7 @@ module Opal
       path_info = env['PATH_INFO'].to_s.sub(prefix_regex, '')
 
       case path_info
-      when %r{^(.*)\.map$}
+      when %r{^(.*)\.self\.map$}
         path = $1
         asset  = sprockets[path]
         return not_found(path) if asset.nil?
@@ -98,7 +98,7 @@ module Opal
         return [200, {"Content-Type" => "text/json"}, [source.to_s]]
       when %r{^(.*)\.rb$}
         begin
-          asset = sprockets.resolve(path_info.sub(/\.rb$/,''))
+          asset = sprockets.resolve(path_info.sub(/\.rb#{REGEXP_END}/,''))
         rescue Sprockets::FileNotFound
           return not_found(path_info)
         end

data/lib/opal/version.rb

@@ -1,3 +1,5 @@
 module Opal
-  VERSION = '0.8.0.beta1'
+  # WHEN RELEASING:
+  # Remember to update RUBY_ENGINE_VERSION in opal/corelib/variables.rb too!
+  VERSION = '0.8.0.rc1'
 end

data/lib/tilt/opal.rb

@@ -1,5 +1,5 @@
 require 'tilt'
-require 'opal/compiler'
+require 'opal/builder'
 require 'opal/config'
 require 'opal/version'
 
@@ -32,10 +32,16 @@ module Opal
     def prepare
     end
 
-    def evaluate(context, locals, &block)
-      compiler_options = Opal::Config.compiler_options.merge(file: file)
-      compiler = Compiler.new(data, compiler_options)
-      compiler.compile.to_s
+    def evaluate(_, _, &block)
+      if builder = @options[:builder]
+        builder.dup.build(file).to_s
+      elsif @options[:build]
+        Opal::Builder.build(file).to_s
+      else
+        compiler_options = (compiler_options || {}).merge!(file: file)
+        compiler = Compiler.new(data, compiler_options)
+        compiler.compile.to_s
+      end
     end
 
     def compiler_options

data/opal.gemspec

@@ -21,9 +21,9 @@ Gem::Specification.new do |s|
   required_ruby_version = '>= 1.9.3'
 
   s.add_dependency 'sourcemap', '~> 0.1.0'
-  s.add_dependency 'sprockets', '>= 2.2.3', '< 4.0.0'
+  s.add_dependency 'sprockets', '~> 3.1'
   s.add_dependency 'hike', '~> 1.2'
-  s.add_dependency 'tilt', '~> 1.4'
+  s.add_dependency 'tilt', '>= 1.4'
 
   s.add_development_dependency 'mspec', '1.5.20'
   s.add_development_dependency 'rake'

data/opal/corelib/array.rb

@@ -472,6 +472,48 @@ class Array
     }
   end
 
+  def bsearch(&block)
+    return enum_for :bsearch unless block_given?
+
+    %x{
+      var min = 0,
+          max = self.length,
+          mid,
+          val,
+          ret,
+          smaller = false,
+          satisfied = nil;
+
+      while (min < max) {
+        mid = min + Math.floor((max - min) / 2);
+        val = self[mid];
+        ret = block(val);
+
+        if (ret === $breaker) {
+          return $breaker.$v;
+        }
+        else if (ret === true) {
+          satisfied = val;
+          smaller = true;
+        }
+        else if (ret === false || ret === nil) {
+          smaller = false;
+        }
+        else if (ret.$$is_number) {
+          if (ret === 0) { return val; }
+          smaller = (ret < 0);
+        }
+        else {
+          #{raise TypeError, "wrong argument type #{`ret`.class} (must be numeric, true, false or nil)"}
+        }
+
+        if (smaller) { max = mid; } else { min = mid + 1; }
+      }
+
+      return satisfied;
+    }
+  end
+
   def cycle(n = nil, &block)
     return if empty? || n == 0
 
@@ -574,6 +616,54 @@ class Array
     self
   end
 
+  def combination(n)
+    num = Opal.coerce_to! n, Integer, :to_int
+    return enum_for :combination, num unless block_given?
+
+    %x{
+      var i, length, stack, chosen, lev, done, next;
+
+      if (num === 0) {
+        #{yield []}
+      } else if (num === 1) {
+        for (i = 0, length = self.length; i < length; i++) {
+          #{yield `[self[i]]`}
+        }
+      }
+      else if (num === self.length) {
+        #{yield `self.slice()`}
+      }
+      else if (num >= 0 && num < self.length) {
+        stack = [];
+        for (i = 0; i <= num + 1; i++) {
+          stack.push(0);
+        }
+
+        chosen = [];
+        lev = 0;
+        done = false;
+        stack[0] = -1;
+
+        while (!done) {
+          chosen[lev] = self[stack[lev+1]];
+          while (lev < num - 1) {
+            lev++;
+            next = stack[lev+1] = stack[lev] + 1;
+            chosen[lev] = self[next];
+          }
+          #{ yield `chosen.slice()` }
+          lev++;
+          do {
+            done = (lev === 0);
+            stack[lev]++;
+            lev--;
+          } while ( stack[lev+1] + num === self.length + lev + 1 );
+        }
+      }
+    }
+    self
+  end
+
   def compact
     %x{
       var result = [];
@@ -1379,7 +1469,41 @@ class Array
       return nil;
     }
   end
+  
+  def rotate(n=1)
+    n = Opal.coerce_to n, Integer, :to_int
+    %x{
+      var ary, idx, firstPart, lastPart;
+      
+      if (self.length === 1) {
+        return self.slice();
+      }
+      if (self.length === 0) {
+        return [];
+      }
+      
+      ary = self.slice();
+      idx = n % ary.length;
+      
+      firstPart = ary.slice(idx);
+      lastPart = ary.slice(0, idx);
+      return firstPart.concat(lastPart);
+    } 
+  end
+  
+  def rotate!(cnt=1)
+    raise RuntimeError, "can't modify frozen Array" if frozen?
 
+    %x{
+      if (self.length === 0 || self.length === 1) {
+        return self;
+      }
+    }
+    cnt = Opal.coerce_to cnt, Integer, :to_int
+    ary = rotate(cnt)
+    replace ary
+  end
+  
   def sample(n = nil)
     return nil if !n && empty?
     return []  if  n && empty?
@@ -1575,6 +1699,27 @@ class Array
 
   alias to_ary to_a
 
+  def to_h
+    %x{
+      var i, len = self.length, ary, key, val, hash = #{{}};
+
+      for (i = 0; i < len; i++) {
+        ary = #{Opal.coerce_to?(`self[i]`, Array, :to_ary)};
+        if (!ary.$$is_array) {
+          #{raise TypeError, "wrong element type #{`ary`.class} at #{`i`} (expected array)"}
+        }
+        if (ary.length !== 2) {
+          #{raise ArgumentError, "wrong array length at #{`i`} (expected 2, was #{`ary`.length})"}
+        }
+        key = ary[0];
+        val = ary[1];
+        hash.$store(key, val);
+      }
+
+      return hash;
+    }
+  end
+
   alias to_s inspect
 
   def transpose
@@ -1659,14 +1804,61 @@ class Array
     self
   end
 
+  def values_at(*args)
+    out = [];
+
+    args.each do |elem|
+      if elem.kind_of? Range
+        finish = Opal.coerce_to elem.last, Integer, :to_int
+        start = Opal.coerce_to elem.first, Integer, :to_int
+        
+        %x{
+          if (start < 0) {
+            start = start + self.length;
+            #{next};
+          }
+        }
+
+        %x{
+          if (finish < 0) {
+            finish = finish + self.length;
+          }
+          if (#{elem.exclude_end?}) {
+            finish--;
+          }
+          if (finish < start) {
+            #{next};
+          }
+        }
+
+        start.upto(finish) { |i| out << at(i) }
+      else
+        i = Opal.coerce_to elem, Integer, :to_int
+        out << at(i)
+      end
+    end
+
+    out
+  end
+
   def zip(*others, &block)
     %x{
-      var result = [], size = self.length, part, o;
+      var result = [], size = self.length, part, o, i, j, jj;
 
-      for (var i = 0; i < size; i++) {
+      for (j = 0, jj = others.length; j < jj; j++) {
+        o = others[j];
+        if (!o.$$is_array) {
+          others[j] = #{(
+            Opal.coerce_to?(`o`, Array, :to_ary) ||
+            Opal.coerce_to!(`o`, Enumerator, :each)
+          ).to_a};
+        }
+      }
+
+      for (i = 0; i < size; i++) {
         part = [self[i]];
 
-        for (var j = 0, jj = others.length; j < jj; j++) {
+        for (j = 0, jj = others.length; j < jj; j++) {
           o = others[j][i];
 
           if (o == null) {
@@ -1680,7 +1872,7 @@ class Array
       }
 
       if (block !== nil) {
-        for (var i = 0; i < size; i++) {
+        for (i = 0; i < size; i++) {
           block(result[i]);
         }