opal 0.7.2 → 0.8.0.beta1

data/lib/opal/sprockets/server.rb

@@ -9,60 +9,12 @@ require 'opal/source_map'
 require 'sprockets'
 require 'sourcemap'
 require 'erb'
+require 'opal/sprockets/source_map_server'
+require 'opal/sprockets/source_map_header_patch'
 
 module Opal
-
-  class SourceMapServer
-    def initialize sprockets, prefix = '/'
-      @sprockets = sprockets
-      @prefix = prefix
-    end
-
-    attr_reader :sprockets, :prefix
-
-    def inspect
-      "#<#{self.class}:#{object_id}>"
-    end
-
-    def call(env)
-      prefix_regex = %r{^(?:#{prefix}/|/)}
-      path_info = env['PATH_INFO'].to_s.sub(prefix_regex, '')
-
-      case path_info
-      when %r{^(.*)\.map$}
-        path = $1
-        asset  = sprockets[path]
-        return not_found(path) if asset.nil?
-
-        # "logical_name" of a BundledAsset keeps the .js extension
-        source = register[asset.logical_path.sub(/\.js$/, '')]
-        return not_found(asset) if source.nil?
-
-        map = JSON.parse(source)
-        map['sources'] = map['sources'].map {|s| "#{prefix}/#{s}"}
-        source = map.to_json
-        return not_found(asset) if source.nil?
-
-        return [200, {"Content-Type" => "text/json"}, [source.to_s]]
-      when %r{^(.*)\.rb$}
-        source = File.read(sprockets.resolve(path_info))
-        return not_found(path_info) if source.nil?
-        return [200, {"Content-Type" => "text/ruby"}, [source]]
-      else
-        not_found(path_info)
-      end
-    end
-
-    def not_found(*messages)
-      not_found = [404, {}, [{not_found: messages, keys: register.keys}.inspect]]
-    end
-
-    def register
-      Opal::Processor.source_map_register
-    end
-  end
-
   class Server
+    SOURCE_MAPS_PREFIX_PATH = '/__OPAL_SOURCE_MAPS__'
 
     attr_accessor :debug, :use_index, :index_path, :main, :public_root,
                   :public_urls, :sprockets, :prefix
@@ -113,16 +65,29 @@ module Opal
     def create_app
       server, sprockets, prefix = self, @sprockets, self.prefix
       sprockets.logger.level ||= Logger::DEBUG
+      source_map_enabled = self.source_map_enabled
+      if source_map_enabled
+        maps_prefix = SOURCE_MAPS_PREFIX_PATH
+        maps_app = SourceMapServer.new(sprockets, maps_prefix)
+        ::Opal::Sprockets::SourceMapHeaderPatch.inject!(maps_prefix)
+      end
+
       @app = Rack::Builder.app do
         not_found = lambda { |env| [404, {}, []] }
         use Rack::Deflater
         use Rack::ShowExceptions
         use Index, server if server.use_index
-        assets = []
-        assets << SourceMapServer.new(sprockets, prefix) if server.source_map_enabled
-        assets << sprockets
-        map(prefix) { run Rack::Cascade.new(assets) }
-        run Rack::Static.new(not_found, :root => server.public_root, :urls => server.public_urls)
+        if source_map_enabled
+          map(maps_prefix) do
+            require 'rack/conditionalget'
+            require 'rack/etag'
+            use Rack::ConditionalGet
+            use Rack::ETag
+            run maps_app
+          end
+        end
+        map(prefix)      { run sprockets }
+        run Rack::Static.new(not_found, root: server.public_root, urls: server.public_urls)
       end
     end
 
@@ -152,37 +117,43 @@ module Opal
           raise "index does not exist: #{@index_path}" unless File.exist?(@index_path)
           Tilt.new(@index_path).render(self)
         else
-          ::ERB.new(SOURCE).result binding
+          source
         end
       end
 
-      def javascript_include_tag source
-        if @server.debug
-          assets = @server.sprockets[source].to_a
+      def javascript_include_tag name
+        sprockets = @server.sprockets
+        prefix = @server.prefix
+        asset = sprockets[name]
+        raise "Cannot find asset: #{name}" if asset.nil?
+        scripts = []
 
-          raise "Cannot find asset: #{source}" if assets.empty?
-
-          scripts = assets.map do |a|
-            %Q{<script src="/assets/#{ a.logical_path }?body=1"></script>}
+        if @server.debug
+          asset.to_a.map do |dependency|
+            scripts << %{<script src="#{prefix}/#{dependency.logical_path}?body=1"></script>}
           end
-
-          scripts.join "\n"
         else
-          "<script src=\"/assets/#{source}.js\"></script>"
+          scripts << %{<script src="#{prefix}/#{name}.js"></script>}
         end
+
+        scripts << %{<script>#{Opal::Processor.load_asset_code(sprockets, name)}</script>}
+
+        scripts.join "\n"
       end
 
-      SOURCE = <<-HTML
-        <!DOCTYPE html>
-        <html>
-        <head>
-          <title>Opal Server</title>
-        </head>
-        <body>
-          <%= javascript_include_tag @server.main %>
-        </body>
-        </html>
-      HTML
+      def source
+        <<-HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <title>Opal Server</title>
+          </head>
+          <body>
+            #{javascript_include_tag @server.main}
+          </body>
+          </html>
+        HTML
+      end
     end
   end
 end

data/lib/opal/sprockets/source_map_header_patch.rb

@@ -0,0 +1,41 @@
+require 'sprockets/server'
+
+module Opal
+  module Sprockets
+    module SourceMapHeaderPatch
+      # Adds the source map header to all sprocket responses for assets
+      # with a .rb or .opal extension in the extension chain.
+      def headers_with_opal_source_maps(env, asset, length)
+        headers_without_opal_source_maps(env, asset, length).tap do |current_headers|
+          if asset.pathname.to_s =~ /\.(rb|opal)\b/
+            base_path = asset.logical_path.gsub('.js', '')
+            current_headers['X-SourceMap'] = "#{::Opal::Sprockets::SourceMapHeaderPatch.prefix}/#{base_path}.map"
+          end
+        end
+      end
+
+      def self.included(base)
+        # Poor man's alias_method_chain :)
+        base.send(:alias_method, :headers_without_opal_source_maps, :headers)
+        base.send(:alias_method, :headers, :headers_with_opal_source_maps)
+      end
+
+      def self.inject!(prefix)
+        self.prefix = prefix
+        unless ::Sprockets::Server.ancestors.include?(self)
+          ::Sprockets::Server.send :include, self
+        end
+      end
+
+      def self.prefix
+        @prefix
+      end
+
+      def self.prefix= val
+        @prefix = val
+      end
+    end
+  end
+end
+
+

data/lib/opal/sprockets/source_map_server.rb

@@ -0,0 +1,115 @@
+module Opal
+  class SourceMapServer
+    # Carelessly taken from Sprockets::Caching (Sprockets v2)
+    class Cache
+      def initialize
+        @cache = {}
+      end
+
+      attr_reader :cache
+
+      def cache_get(key)
+        # `Cache#get(key)` for Memcache
+        if cache.respond_to?(:get)
+          cache.get(key)
+
+        # `Cache#[key]` so `Hash` can be used
+        elsif cache.respond_to?(:[])
+          cache[key]
+
+        # `Cache#read(key)` for `ActiveSupport::Cache` support
+        elsif cache.respond_to?(:read)
+          cache.read(key)
+
+        else
+          nil
+        end
+      end
+
+      def cache_set(key, value)
+        # `Cache#set(key, value)` for Memcache
+        if cache.respond_to?(:set)
+          cache.set(key, value)
+
+        # `Cache#[key]=value` so `Hash` can be used
+        elsif cache.respond_to?(:[]=)
+          cache[key] = value
+
+        # `Cache#write(key, value)` for `ActiveSupport::Cache` support
+        elsif cache.respond_to?(:write)
+          cache.write(key, value)
+        end
+
+        value
+      end
+    end
+
+    def self.get_map_cache(sprockets, logical_path)
+      logical_path = logical_path.gsub(/\.js$/, '')
+      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$/, '')
+      cache_key = cache_key_for_path(logical_path+'.map')
+      cache(sprockets).cache_set(cache_key, map_contents)
+    end
+
+    def self.cache(sprockets)
+      @cache ||= sprockets.cache ? sprockets : Cache.new
+    end
+
+    def self.cache_key_for_path(logical_path)
+      base_name = logical_path.gsub(/\.js$/, '')
+      File.join('opal', 'source_maps', base_name)
+    end
+
+
+    def initialize sprockets, prefix = '/'
+      @sprockets = sprockets
+      @prefix = prefix
+    end
+
+    attr_reader :sprockets, :prefix
+
+    def inspect
+      "#<#{self.class}:#{object_id}>"
+    end
+
+    def call(env)
+      prefix_regex = %r{^(?:#{prefix}/|/)}
+      path_info = env['PATH_INFO'].to_s.sub(prefix_regex, '')
+
+      case path_info
+      when %r{^(.*)\.map$}
+        path = $1
+        asset  = sprockets[path]
+        return not_found(path) if asset.nil?
+
+        # "logical_name" of a BundledAsset keeps the .js extension
+        source = SourceMapServer.get_map_cache(sprockets, asset.logical_path)
+        return not_found(asset) if source.nil?
+
+        map = JSON.parse(source)
+        map['sources'] = map['sources'].map {|s| "#{prefix}/#{s}"}
+        source = map.to_json
+
+        return [200, {"Content-Type" => "text/json"}, [source.to_s]]
+      when %r{^(.*)\.rb$}
+        begin
+          asset = sprockets.resolve(path_info.sub(/\.rb$/,''))
+        rescue Sprockets::FileNotFound
+          return not_found(path_info)
+        end
+        return [200, {"Content-Type" => "text/ruby"}, [Pathname(asset).read]]
+      else
+        not_found(path_info)
+      end
+    end
+
+    def not_found(*messages)
+      not_found = [404, {}, [{not_found: messages}.inspect]]
+    end
+  end
+end

data/lib/opal/version.rb

@@ -1,3 +1,3 @@
 module Opal
-  VERSION = '0.7.2'
+  VERSION = '0.8.0.beta1'
 end

data/lib/tilt/opal.rb

@@ -0,0 +1,48 @@
+require 'tilt'
+require 'opal/compiler'
+require 'opal/config'
+require 'opal/version'
+
+$OPAL_SOURCE_MAPS = {}
+
+module Opal
+  class TiltTemplate < Tilt::Template
+    self.default_mime_type = 'application/javascript'
+
+    def self.inherited(subclass)
+      subclass.default_mime_type = 'application/javascript'
+    end
+
+    def self.engine_initialized?
+      true
+    end
+
+    def self.version
+      ::Opal::VERSION
+    end
+
+    def self.compiler_options
+      Opal::Config.compiler_options.merge(requirable: true)
+    end
+
+    def initialize_engine
+      require_template_library 'opal'
+    end
+
+    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
+    end
+
+    def compiler_options
+      self.class.compiler_options
+    end
+  end
+end
+
+Tilt.register 'rb',   Opal::TiltTemplate
+Tilt.register 'opal', Opal::TiltTemplate

data/opal.gemspec

@@ -21,7 +21,7 @@ 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', '< 3.0.0'
+  s.add_dependency 'sprockets', '>= 2.2.3', '< 4.0.0'
   s.add_dependency 'hike', '~> 1.2'
   s.add_dependency 'tilt', '~> 1.4'
 

data/opal/corelib/array.rb

@@ -228,33 +228,52 @@ class Array
   end
 
   def ==(other)
-    return true if `self === other`
-
-    unless Array === other
-      return false unless other.respond_to? :to_ary
-      return other == self
-    end
+    %x{
+      var recursed = {};
 
-    other = other.to_a
+      function _eqeq(array, other) {
+        var i, length, a, b;
 
-    return false unless `self.length === other.length`
+        if (!other.$$is_array) {
+          if (#{Opal.respond_to? `other`, :to_ary}) {
+            return #{`other` == `array`};
+          } else {
+            return false;
+          }
+        }
 
-    %x{
-      for (var i = 0, length = self.length; i < length; i++) {
-        var a = self[i],
-            b = other[i];
+        other = #{other.to_a};
 
-        if (a.$$is_array && b.$$is_array && (a === self)) {
-          continue;
+        if (array.length !== other.length) {
+          return false;
         }
 
-        if (!#{`a` == `b`}) {
-          return false;
+        recursed[#{`array`.object_id}] = true;
+
+        for (i = 0, length = array.length; i < length; i++) {
+          a = array[i];
+          b = other[i];
+          if (a.$$is_array) {
+            if (b.$$is_array && b.length !== a.length) {
+              return false;
+            }
+            if (!recursed.hasOwnProperty(#{`a`.object_id})) {
+              if (!_eqeq(a, b)) {
+                return false;
+              }
+            }
+          } else {
+            if (!#{`a` == `b`}) {
+              return false;
+            }
+          }
         }
+
+        return true;
       }
-    }
 
-    true
+      return _eqeq(self, other);
+    }
   end
 
   def [](index, length = undefined)
@@ -615,7 +634,13 @@ class Array
         }
       }
 
-      return self.length === original ? nil : object;
+      if (self.length === original) {
+        if (#{block_given?}) {
+          return #{yield};
+        }
+        return nil;
+      }
+      return object;
     }
   end
 
@@ -709,29 +734,48 @@ class Array
   end
 
   def eql?(other)
-    return true if `self === other`
-    return false unless Array === other
+    %x{
+      var recursed = {};
 
-    other = other.to_a
+      function _eql(array, other) {
+        var i, length, a, b;
 
-    return false unless `self.length === other.length`
+        if (!other.$$is_array) {
+          return false;
+        }
 
-    %x{
-      for (var i = 0, length = self.length; i < length; i++) {
-        var a = self[i],
-            b = other[i];
+        other = #{other.to_a};
 
-        if (a.$$is_array && b.$$is_array && (a === self)) {
-          continue;
+        if (array.length !== other.length) {
+          return false;
         }
 
-        if (!#{`a`.eql? `b`}) {
-          return false;
+        recursed[#{`array`.object_id}] = true;
+
+        for (i = 0, length = array.length; i < length; i++) {
+          a = array[i];
+          b = other[i];
+          if (a.$$is_array) {
+            if (b.$$is_array && b.length !== a.length) {
+              return false;
+            }
+            if (!recursed.hasOwnProperty(#{`a`.object_id})) {
+              if (!_eql(a, b)) {
+                return false;
+              }
+            }
+          } else {
+            if (!#{`a`.eql?(`b`)}) {
+              return false;
+            }
+          }
         }
+
+        return true;
       }
-    }
 
-    true
+      return _eql(self, other);
+    }
   end
 
   def fetch(index, defaults = undefined, &block)
@@ -866,30 +910,56 @@ class Array
 
   def flatten(level = undefined)
     %x{
-      var result = [];
+      var object_id = #{`self`.object_id};
 
-      for (var i = 0, length = self.length; i < length; i++) {
-        var item = self[i];
+      function _flatten(array, level) {
+        var array = #{`array`.to_a},
+            result = [],
+            i, length,
+            item, ary;
 
-        if (#{Opal.respond_to? `item`, :to_ary}) {
-          item = #{`item`.to_ary};
+        for (i = 0, length = array.length; i < length; i++) {
+          item = array[i];
 
-          if (level == null) {
-            result.push.apply(result, #{`item`.flatten.to_a});
+          if (!#{Opal.respond_to? `item`, :to_ary}) {
+            result.push(item);
+            continue;
           }
-          else if (level == 0) {
+
+          ary = #{`item`.to_ary};
+
+          if (ary === nil) {
             result.push(item);
+            continue;
           }
-          else {
-            result.push.apply(result, #{`item`.flatten(`level - 1`).to_a});
+
+          if (!ary.$$is_array) {
+            #{raise TypeError};
+          }
+
+          if (object_id === #{`ary`.object_id}) {
+            #{raise ArgumentError};
+          }
+
+          switch (level) {
+          case undefined:
+            result.push.apply(result, _flatten(ary));
+            break;
+          case 0:
+            result.push(ary);
+            break;
+          default:
+            result.push.apply(result, _flatten(ary, level - 1));
           }
         }
-        else {
-          result.push(item);
-        }
+        return result;
       }
 
-      return result;
+      if (level !== undefined) {
+        level = #{Opal.coerce_to(`level`, Integer, :to_int)};
+      }
+
+      return _flatten(self, level);
     }
   end
 
@@ -917,12 +987,15 @@ class Array
 
   def hash
     %x{
-      var hash = ['A'], item, item_hash;
+      var hash = ['A'],
+          item;
       for (var i = 0, length = self.length; i < length; i++) {
         item = self[i];
-        // Guard against recursion
-        item_hash = self === item ? 'self' : item.$hash();
-        hash.push(item_hash);
+        if (item.$$is_array && #{`self`.eql?(`item`)}) {
+          hash.push('self');
+        } else {
+          hash.push(item.$hash());
+        }
       }
       return hash.join(',');
     }
@@ -1022,6 +1095,7 @@ class Array
 
     %x{
       var result = [];
+      var object_id = #{`self`.object_id};
 
       for (var i = 0, length = self.length; i < length; i++) {
         var item = self[i];
@@ -1039,6 +1113,10 @@ class Array
         if (#{Opal.respond_to? `item`, :to_ary}) {
           var tmp = #{`item`.to_ary};
 
+          if (object_id === #{`tmp`.object_id}) {
+            #{raise ArgumentError};
+          }
+
           if (tmp !== nil) {
             result.push(#{`tmp`.join(sep)});
 
@@ -1138,6 +1216,56 @@ class Array
     end
   end
 
+  def product(*args, &block)
+    %x{
+      var result = #{block_given?} ? null : [],
+          n = args.length + 1,
+          counters = new Array(n),
+          lengths  = new Array(n),
+          arrays   = new Array(n),
+          i, m, subarray, len, resultlen = 1;
+
+      arrays[0] = self;
+      for (i = 1; i < n; i++) {
+        arrays[i] = #{Opal.coerce_to(`args[i - 1]`, Array, :to_ary)};
+      }
+
+      for (i = 0; i < n; i++) {
+        len = arrays[i].length;
+        if (len === 0) {
+          return result || self;
+        }
+        resultlen *= len;
+        if (resultlen > 2147483647) {
+          #{raise RangeError, "too big to product"}
+        }
+        lengths[i] = len;
+        counters[i] = 0;
+      }
+
+      outer_loop: for (;;) {
+        subarray = [];
+        for (i = 0; i < n; i++) {
+          subarray.push(arrays[i][counters[i]]);
+        }
+        if (result) {
+          result.push(subarray);
+        } else {
+          #{yield `subarray`}
+        }
+        m = n - 1;
+        counters[m]++;
+        while (counters[m] === lengths[m]) {
+          counters[m] = 0;
+          if (--m < 0) break outer_loop;
+          counters[m]++;
+        }
+      }
+
+      return result || self;
+    }
+  end
+
   def push(*objects)
     %x{
       for (var i = 0, length = objects.length; i < length; i++) {