opal 1.2.0 → 1.3.0.alpha1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f13610ebfa130a3b3379a2d23f3fc077de87e4fd69c33248a87bdf23e144686a
-  data.tar.gz: 275fa37ed3f201f2c716bcf8f05cc5fcd5ff42dec5aaae1b4753c126a629d5c1
+  metadata.gz: cf895e8ef63c69f90e6e099aa2f4c671649411893b980bdb03b55268da2e0a34
+  data.tar.gz: 5fc847637cea4a857bcc78ad1a491d5c898fdc051d779644f39e282e6c2aba66
 SHA512:
-  metadata.gz: b5a9d1f1494542fd5d1669bb16548b5a335777398a3d84945dbabb8477cedd79f1fd1fc251f663e9f22a518a9a7c3d361f83fb14c860bc3cb36b79c7cd6c40b8
-  data.tar.gz: 90f237673bc19937ee643fbe5562cd348476f975a90348c95138785457a6da342b4df98a48d14b223a938e9c91ac603fde0d2c5cbe18982ec1bcc3c1e6d4c375
+  metadata.gz: 0eb66e6cb09d52075f7afd1ab8d10b67fdab302a503269f95b152440991b8d1f9bc3fc759e0265503350e6c4cd3c1453afca9d7d971bbdae46a367f15f5f8230
+  data.tar.gz: e0ce987c98345a13101dc3d9311ce1bb41435777edf41ab14aac96cf5821c1e6076236de25216c443fa806567af6f1a32de2f8d7d9e1e67e4ba165547c938e95

data/.eslintrc.await.js

@@ -0,0 +1,6 @@
+module.exports = {
+  "extends": "./.eslintrc.js",
+  "parserOptions": {
+    "ecmaVersion": 8
+  },
+};

data/.eslintrc.js

@@ -0,0 +1,34 @@
+module.exports = {
+  "env": {
+    "browser": true,
+    "node": true
+  },
+  "extends": "eslint:recommended",
+  "parserOptions": {
+    "ecmaVersion": 3
+  },
+  "rules": {
+    "no-unused-vars": ["error", {
+      "varsIgnorePattern": "(\$(\$|\$\$|yield|post_args|[a-z])|self)",
+      "argsIgnorePattern": "(\$(\$|\$\$|yield|post_args|[a-z])|self)",
+    }],
+    "no-extra-semi": "off",
+    "no-empty": "off",
+    "no-unreachable": "off",
+    "no-cond-assign": "off",
+    "no-prototype-builtins": "off",
+    "no-constant-condition": ["error", { "checkLoops": false }],
+    "no-useless-escape": "off",
+    "no-fallthrough": ["error", { "commentPattern": "raise|no-break" }],
+    "no-regex-spaces": "off",
+    "no-control-regex": "off",
+  },
+  "globals": {
+    "Opal": "readonly",
+    "DataView": "readonly",
+    "ArrayBuffer": "readonly",
+    "globalThis": "readonly",
+    "Uint8Array": "readonly",
+    "Promise": "readonly",
+  }
+};

data/.github/workflows/build.yml

@@ -49,6 +49,11 @@ jobs:
             ruby: 3.0
           - name: timezone
             ruby: 3.0
+          - name: performance
+            ruby: 3.0
+            permissive: true
+            fetchdepth: '0'
+            command: bin/rake performance:compare
 
           # Currently failing:
           # - ruby: truffleruby
@@ -56,8 +61,11 @@ jobs:
           # - ruby: ruby-head
 
     runs-on: ${{ matrix.combo.os || 'ubuntu-latest' }}
+    continue-on-error: ${{ matrix.combo.permissive || false }}
     steps:
       - uses: actions/checkout@v2
+        with:
+          fetch-depth: ${{ fromJSON(matrix.combo.fetchdepth || '1') }}
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.combo.ruby }}

data/.rubocop.yml

@@ -71,6 +71,7 @@ Layout/CommentIndentation:
   Exclude:
     - 'lib/opal/rewriters/binary_operator_assignment.rb'
     - 'lib/opal/rewriters/logical_operator_assignment.rb'
+    - 'lib/opal/source_map/file.rb'
 
 # We need to support older rubies
 Layout/IndentHeredoc:
@@ -92,6 +93,7 @@ Style/GlobalVars:
     - 'stdlib/nodejs/irb.rb'
     - 'stdlib/console.rb'
     - 'stdlib/native.rb'
+    - 'stdlib/await.rb'
 
 Layout/ExtraSpacing:
   Exclude:
@@ -124,6 +126,11 @@ Lint/LiteralAsCondition:
     - 'opal/**/*.rb'
     - 'stdlib/**/*.rb'
 
+Lint/Loop:
+  Exclude:
+    # This is for optimization purposes mostly
+    - 'opal/corelib/io.rb'
+
 # Allow the use of if/unless inside blocks
 Style/Next:
   Enabled: false
@@ -134,6 +141,7 @@ Lint/RescueException:
     - 'opal/corelib/enumerator.rb'
     # Promises must care about all exceptions
     - 'stdlib/promise.rb'
+    - 'opal/corelib/binding.rb'
 
 Lint/StringConversionInInterpolation:
   Exclude:
@@ -412,6 +420,7 @@ Style/ConditionalAssignment:
 Naming/MemoizedInstanceVariableName:
   Exclude:
     - lib/opal/parser/patch.rb # it's a monkey-patch on the parser gem
+    - lib/opal/nodes/rescue.rb # we know what we are doing here and no, it's not memoization
 
 Style/AccessModifierDeclarations:
   Enabled: false

data/CHANGELOG.md

@@ -30,6 +30,9 @@ Changes are grouped as follows:
 - Support for `"\x80"` syntax in String literals ([#2235](https://github.com/opal/opal/pull/2235))
 - Added `String#+@`, `String#-@` ([#2235](https://github.com/opal/opal/pull/2235))
 - Support for `begin <CODE> end while <CONDITION>` ([#2255](https://github.com/opal/opal/pull/2255))
+- Added Hash#except and `Hash#except!` ([#2243](https://github.com/opal/opal/pull/2243))
+- Parser 3.0: Implement pattern matching (as part of this `{Array,Hash,Struct}#{deconstruct,deconstruct_keys} methods were added)` ([#2243](https://github.com/opal/opal/pull/2243))
+- [experimental] Reimplement Promise to make it bridged with JS native Promise, this new implementation can be used by requiring `promise/v2` ([#2220](https://github.com/opal/opal/pull/2220))
 
 ### Fixed
 
@@ -48,6 +51,7 @@ Changes are grouped as follows:
 - Rework class variables to support inheritance correctly ([#2251](https://github.com/opal/opal/pull/2251))
 - ISO-8859-1 and US-ASCII encodings are now separated as in MRI ([#2235](https://github.com/opal/opal/pull/2235))
 - `String#b` no longer modifies object strings in-place ([#2235](https://github.com/opal/opal/pull/2235))
+- Parser::Builder::Default.check_lvar_name patch ([#2195](https://github.com/opal/opal/pull/2195))
 
 ### Changed
 

data/README.md

@@ -116,7 +116,7 @@ your web applications.
 <html>
   <head>
     <meta charset="utf-8">
-    <script src="https://cdn.opalrb.com/opal/current/opal.js" onload="Opal.load('opal')"></script>
+    <script src="https://cdn.opalrb.com/opal/current/opal.js"></script>
     <script src="https://cdn.opalrb.com/opal/current/opal-parser.js" onload="Opal.load('opal-parser')"></script>
 
     <script type="text/ruby">

data/Rakefile

@@ -7,5 +7,6 @@ import 'tasks/building.rake'
 import 'tasks/linting.rake'
 import 'tasks/benchmarking.rake'
 import 'tasks/releasing.rake'
+import 'tasks/performance.rake'
 
 task :default => [:rspec, :mspec, :minitest]

data/UNRELEASED.md

@@ -1,50 +1,76 @@
+### Added
 
-- Support for multiple arguments in Hash#{merge, merge!, update} (#2187)
-- Support for Ruby 3.0 forward arguments: `def a(...) puts(...) end` (#2153)
-- Support for beginless and endless ranges: `(1..)`, `(..1)` (#2150)
-- Preliminary support for `**nil` argument - see #2240 to note limitations (#2152)
-- Support for `Random::Formatters` which add methods `#{hex,base64,urlsafe_base64,uuid,random_float,random_number,alphanumeric}` to `Random` and `SecureRandom` (#2218)
-- Basic support for ObjectSpace finalizers and ObjectSpace::WeakMap (#2247)
-- A more robust support for encodings (especially binary strings) (#2235)
-- Support for `"\x80"` syntax in String literals (#2235)
-- Added `String#+@`, `String#-@` (#2235)
-- Support for `begin <CODE> end while <CONDITION>` (#2255)
-- Added Hash#except and `Hash#except!` (#2243)
-- Parser 3.0: Implement pattern matching (as part of this `{Array,Hash,Struct}#{deconstruct,deconstruct_keys} methods were added)` (#2243)
-- [experimental] Reimplement Promise to make it bridged with JS native Promise, this new implementation can be used by requiring `promise/v2` (#2220)
-
+- Add support for `retry` (#2264)
+- Modernize Exceptions (#2264)
+  - Add `#cause`, `#backtrace_locations`, `#full_message` to `Exception`
+  - Normalize backtraces across platforms
+  - Add `Thread::Backtrace::Location`
+  - Output Exception#full_message on uncaught exceptions (#2269)
+- TracePoint `:class` support (#2049)
+- Implement the Flip-Flop operators (#2261)
+- Add `JS[]` to access properties on the global object (#2259)
+- Add `ENV.fetch` to the Nodejs implementation of `ENV` (#2259)
+- Opal::Cache, an optional compiler cache (enabled by default) (#2242, #2278)
+- Alias for gvars, alias on main (#2270)
+- Support for GJS (GNOME's JavaScript runtime) runner (#2280)
+- Scope variables support for `eval()` (#2256)
+- Add support for `Kernel#binding` (#2256)
+- A (mostly) correct support for refinements (#2256)
+- [CI] Performance regression check (#2276, #2282)
+- Add support for ECMAScript modules with an `--esm` CLI option (#2286)
+- Implement `Regexp#names` and add named captures support (#2272)
+- REPL improvements: (#2285)
+  - Colored output & history support
+  - `ls` to show available constants and variable
+- Add `Method#===` as an alias to `Method#call`, works the same as `Proc#===` (#2305)
+- Add `IO#gets` and `IO#read_proc` along with other supporting methods (#2309)
+  - Support `#gets` on most platforms, including browsers (via `prompt`)
+  - Move the REPL to a `--repl` CLI option of the main executable
+  - Completely refactor IO, now supporting 
+  - Add a runner for MiniRacer (as `miniracer`)
+  - Support Windows on the Chrome runner 
+  - Support Windows on the REPL
+  - Platforms an IO implementations should either set `IO#read_proc` or overwrite `IO#sysread`
+- [experimental] Add support for JavaScript async/await (#2221)
+  - Enable the feature by adding a magic comment: `# await: true`
+  - The magic comment can be also used to mark specific method patterns to be awaited
+    (e.g. `# await: *_await, sleep` will make any method ending in `_await` or named `sleep` to be awaited) 
+  - Add `Kernel#__await__` as a bridge to the `await` keyword (inspired by CoffeeScript await support)
+  - Require `opal/await` to get additional support
+  - Read more on the newly added documentation page
+- Better interoperability between legacy Promise (v1) and native Promise (v2) (#2221)
+  - Add `PromiseV1` as an alias to the original (legacy) Promise class
+  - Add `#to_v1` and `#to_v2` to both classes
+  - `Promise#to_n` will convert it to a native Promise (v2)
 
 ### Fixed
 
-- Encoding lookup was working only with uppercase names, not giving any errors for wrong ones (#2181, #2183, #2190)
-- Fix `Number#to_i` with huge number (#2191)
-- Add regexp support to `String#start_with` (#2198)
-- `String#bytes` now works in strict mode (#2194)
-- Fix nested module inclusion (#2053)
-- SecureRandom is now cryptographically secure on most platforms (#2218, #2170)
-- Fix performance regression for `Array#unshift` on v8 > 7.1 (#2116)
-- String subclasses now call `#initialize` with multiple arguments correctly (with a limitation caused by the String immutability issue, that a source string must be the first argument and `#initialize` can't change its value) (#2238, #2185)
-- Number#step is moved to Numeric (#2100)
-- Fix class Class < superclass for invalid superclasses (#2123)
-- Fix `String#unpack("U*")` on binary strings with latin1 high characters, fix performance regression on that call (#2235, #2189, #2129, #2099, #2094, #2000, #2128)
-- Fix `String#to_json` output on some edge cases (#2235)
-- Rework class variables to support inheritance correctly (#2251)
-- ISO-8859-1 and US-ASCII encodings are now separated as in MRI (#2235)
-- `String#b` no longer modifies object strings in-place (#2235)
-- Parser::Builder::Default.check_lvar_name patch (#2195)
+- Fixed multiple line `Regexp` literal to not generate invalid syntax as JavaScript (#1616)
+- Fix `Kernel#{try,catch}` along with `UncaughtThrowError` (#2264)
+- Update source-map-support to fix an off-by-one error (#2264)
+- Source map: lines should start from 1, not 0 (#2273)
+- Allow for multiple underscored args with the same name in strict mode (#2292)
+- Show instance variables in `Kernel#inspect` (#2285)
+- `0.digits` was returning an empty array in strict mode (#2301)
+- Non Integer numbers were responding to `#digits` (#2301)
+- Correctly delete hash members when dealing with boxed strings (#2306)
+- Escape string components in interpolated strings (`dstrs`) correctly (#2308)
+- Don't try to return the JS `debugger` statement, just return `nil` (#2307)
+- Retain the `-` while stringifying `-0.0` (#2304)
+- Fix super support for rest args and re-assignments with implicit arguments (#2315)
 
 ### Changed
 
-- `String#unpack`, `Array#pack`, `String#chars`, `String#length`, `Number#chr`, and (only partially) `String#+` are now encoding aware (#2235)
-- `String#inspect` now uses `\x` for binary stirngs (#2235)
-- `if RUBY_ENGINE == "opal"` and friends are now outputing less JS code (#2159, #1965)
-- `Array`: `to_a`, `slice`/`[]`, `uniq`, `*`, `difference`/`-`, `intersection`/`&`, `union`/`|`, flatten now return Array, not a subclass, as Ruby 3.0 does (#2237)
-- `Array`: `difference`, `intersection`, `union` now accept multiple arguments (#2237)
+- Fast-track bad constant names passed to `Struct.new` (#2259)
+- Renamed internal `super` related helpers,
+  `find_super_dispatcher` is now `find_super`, `find_iter_super_dispatcher` is now `find_block_super` (#2090)
+- The `opal-repl` CLI now requires files to be passed with `--require` (or `-r`) instead of the bare filename (#2309)
 
-### Deprecated
 
-- Stopped testing Opal on Ruby 2.5 since it reached EOL.
+### Deprecated
 
 ### Removed
 
-- Removed support for the outdated `c_lexer`, it was optional and didn't work for the last few releases of parser (#2235)
+### Internal
+
+- Switch from jshint to ESLint (#2289)

data/docs/async.md

@@ -0,0 +1,109 @@
+# Asynchronous code (PromiseV2 / async / await)
+
+Please be aware that this functionality is marked as experimental and may change
+in the future.
+
+In order to disable the warnings that will be shown if you use those experimental
+features, add the following line before requiring `promise/v2` or `await` and after
+requiring `opal`.
+
+```ruby
+`Opal.config.experimental_features_severity = 'ignore'`
+```
+
+## PromiseV2
+
+In Opal 1.2 we introduced PromiseV2 which is to replace the default Promise in Opal 2.0
+(which will become PromiseV1). Right now it's experimental, but the interface of PromiseV1
+stay unchanged and will continue to be supported.
+
+It is imperative that during the transition period you either `require 'promise/v1'` or
+`require 'promise/v2'` and then use either `PromiseV1` or `PromiseV2`.
+
+If you write library code it's imperative that you don't require the promise itself, but
+detect if `PromiseV2` is defined and use the newer implementation, for instance using the
+following code:
+
+```ruby
+module MyLibrary
+  Promise = defined?(PromiseV2) ? PromiseV2 : ::Promise
+end
+```
+
+The difference between `PromiseV1` and `PromiseV2` is that `PromiseV1` is a pure-Ruby
+implementation of a Promise, while `PromiseV2` is reusing the JavaScript `Promise`. Both are
+incompatible with each other, but `PromiseV2` can be awaited (see below) and they translate
+1 to 1 to the JavaScript native `Promise` (they are bridged; you can directly return a
+`Promise` from JavaScript API without a need to translate it). The other difference is that
+`PromiseV2` always runs a `#then` block a tick later, while `PromiseV1` would could run it
+instantaneously.
+
+## Async/await
+
+In Opal 1.3 we implemented the CoffeeScript pattern of async/await. As of now, it's hidden
+behind a magic comment, but this behavior may change in the future.
+
+Example:
+
+```ruby
+# await: true
+
+require "await"
+
+def wait_5_seconds
+  puts "Let's wait 5 seconds..."
+  sleep(5).await
+  puts "Done!"
+end
+
+wait_5_seconds.__await__
+```
+
+It's important to understand what happens under the hood: every scope in which `#__await__` is
+encountered will become async, which means that it will return a Promise that will resolve
+to a value. This includes methods, blocks and the top scope. This means, that `#__await__` is
+infectious and you need to remember to `#__await__` everything along the way, otherwise
+a program will finish too early and the values may be incorrect.
+
+[You can take a look at how we ported Minitest to support asynchronous tests.](https://github.com/opal/opal/pull/2221/commits/8383c7b45a94fe4628778f429508b9c08c8948b0) Take note, that
+it was ported to use `#await` while the finally accepted version uses `#__await__`.
+
+It is certainly correct to `#__await__` any value, including non-Promises, for instance
+`5.__await__` will correctly resolve to `5` (except that it will make the scope an async
+function, with all the limitations described above).
+
+The `await` stdlib module includes a few useful functions, like async-aware `each_await`
+function and `sleep` that doesn't block the thread. It also includes a method `#await`
+which is an alias of `#itself` - it makes sense to auto-await that method.
+
+This approach is certainly incompatible with what Ruby does, but due to a dynamic nature
+of Ruby and a different model of JavaScript this was the least invasive way to catch up
+with the latest JavaScript trends and support `Promise` heavy APIs and asynchronous code.
+
+## Auto-await
+
+The magic comment also accepts a comma-separated list of methods to be automatically
+awaited. An individual value can contain a wildcard character `*`. For instance,
+those two blocks of code are equivalent:
+
+```ruby
+# await: true
+
+require "await"
+
+[1,2,3].each_await do |i|
+  p i
+  sleep(i).__await__
+end.__await__
+```
+
+```ruby
+# await: sleep, *await*
+
+require "await"
+
+[1,2,3].each_await do |i|
+  p i
+  sleep i
+end
+```

data/docs/roda-sprockets.md

@@ -22,8 +22,6 @@ require 'roda'
 class App < Roda
    plugin :sprockets, precompile: %w(application.js),
                       prefix: %w(app/),
-                      root: __dir__,
-                      public_path: 'public/',
                       opal: true,
                       debug: ENV['RACK_ENV'] != 'production'
    plugin :public

data/exe/opal

@@ -2,6 +2,8 @@
 
 # Error codes are taken from /usr/include/sysexits.h
 
+OriginalARGV = ARGV.dup
+
 require 'opal/cli_options'
 options = Opal::CLIOptions.new
 begin

data/exe/opal-repl

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'opal/repl'
+ARGV << "--repl"
 
-repl = Opal::REPL.new.run ARGV.first
+load __dir__+"/opal"

data/lib/opal/builder.rb

@@ -3,6 +3,7 @@
 require 'opal/path_reader'
 require 'opal/paths'
 require 'opal/config'
+require 'opal/cache'
 require 'set'
 
 module Opal
@@ -70,6 +71,7 @@ module Opal
       @prerequired              ||= []
       @compiler_options         ||= Opal::Config.compiler_options
       @missing_require_severity ||= Opal::Config.missing_require_severity
+      @cache                    ||= Opal.cache
 
       @processed = []
     end
@@ -133,7 +135,7 @@ module Opal
     attr_reader :processed
 
     attr_accessor :processors, :path_reader, :stubs, :prerequired, :preload,
-      :compiler_options, :missing_require_severity
+      :compiler_options, :missing_require_severity, :cache
 
     private
 
@@ -165,6 +167,8 @@ module Opal
                                            "processors: #{processors.inspect}"
                   )
 
+      options = options.merge(cache: cache)
+
       processor.new(source, rel_path, @compiler_options.merge(options))
     end
 

data/lib/opal/builder_processors.rb

@@ -8,7 +8,8 @@ module Opal
     class Processor
       def initialize(source, filename, options = {})
         source += "\n" unless source.end_with?("\n")
-        @source, @filename, @options = source, filename, options
+        @source, @filename, @options = source, filename, options.dup
+        @cache = @options.delete(:cache) { Opal.cache }
         @requires = []
         @required_trees = []
       end
@@ -79,13 +80,17 @@ module Opal
       end
 
       def compiled
-        @compiled ||= begin
+        @compiled ||= Opal::Cache.fetch(@cache, cache_key) do
           compiler = compiler_for(@source, file: @filename)
           compiler.compile
           compiler
         end
       end
 
+      def cache_key
+        [self.class, @filename, @source, @options]
+      end
+
       def compiler_for(source, options = {})
         ::Opal::Compiler.new(source, @options.merge(options))
       end

data/lib/opal/cache/file_cache.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'zlib'
+
+module Opal
+  module Cache
+    class FileCache
+      def initialize(dir: nil, max_size: nil)
+        @dir = dir || self.class.find_dir
+        # Store at most 32MB of cache - de facto this 32MB is larger,
+        # as we don't account for inode size for instance. In fact, it's
+        # about 50M. Also we run this check before anything runs, so things
+        # may go up to 64M or even larger.
+        @max_size = max_size || 32 * 1024 * 1024
+
+        tidy_up_cache
+      end
+
+      def set(key, data)
+        file = cache_filename_for(key)
+
+        out = Marshal.dump(data)
+        out = Zlib.gzip(out, level: 9)
+        File.binwrite(file, out)
+      end
+
+      def get(key)
+        file = cache_filename_for(key)
+
+        if File.exist?(file)
+          FileUtils.touch(file)
+          out = File.binread(file)
+          out = Zlib.gunzip(out)
+          Marshal.load(out) # rubocop:disable Security/MarshalLoad
+        end
+      rescue Zlib::GzipFile::Error
+        nil
+      end
+
+      # Remove cache entries that overflow our cache limit... and which
+      # were used least recently.
+      private def tidy_up_cache
+        entries = Dir[@dir + '/*.rbm.gz']
+
+        size_sum = entries.map { |i| File.size(i) }.sum
+        return unless size_sum > @max_size
+
+        # First, we try to get the oldest files first.
+        # Then, what's more important, is that we try to get the least
+        # recently used files first. Filesystems with relatime or noatime
+        # will get this wrong, but it doesn't matter that much, because
+        # the previous sort got things "maybe right".
+        entries = entries.sort_by { |i| [File.mtime(i), File.atime(i)] }
+
+        entries.each do |i|
+          size_sum -= File.size(i)
+          File.unlink(i)
+
+          # We don't need to work this out anymore - we reached out goal.
+          break unless size_sum > @max_size
+        end
+      rescue Errno::ENOENT
+        # Do nothing, this comes from multithreading. We will tidy up at
+        # the next chance.
+        nil
+      end
+
+      # This complex piece of code tries to check if we can robustly mkdir_p a directory.
+      def self.dir_writable?(*paths)
+        dir = nil
+        paths = paths.reduce([]) do |a, b|
+          [*a, dir = a.last ? File.expand_path(b, a.last) : b]
+        end
+
+        File.exist?(paths.first) &&
+          paths.reverse.all? do |i|
+            !File.exist?(i) || (File.directory?(i) && File.writable?(i))
+          end
+
+        dir
+      end
+
+      def self.find_dir
+        @find_dir ||= case
+                      # Try to write cache into a directory pointed by an environment variable if present
+                      when dir = ENV['OPAL_CACHE_DIR']
+                        FileUtils.mkdir_p(dir)
+                        dir
+                      # Otherwise, we write to the place where Opal is installed...
+                      # I don't think it's a good location to store cache, so many things can go wrong.
+                      # when dir = dir_writable?(Opal.gem_dir, '..', 'tmp', 'cache')
+                      #   FileUtils.mkdir_p(dir)
+                      #   FileUtils.chmod(0o700, dir)
+                      #   dir
+                      # Otherwise, ~/.cache/opal...
+                      when dir = dir_writable?(Dir.home, '.cache', 'opal')
+                        FileUtils.mkdir_p(dir)
+                        FileUtils.chmod(0o700, dir)
+                        dir
+                      # Only /tmp is writable... or isn't it?
+                      when (dir = dir_writable?('/tmp', "opal-cache-#{ENV['USER']}")) && File.sticky?('/tmp')
+                        FileUtils.mkdir_p(dir)
+                        FileUtils.chmod(0o700, dir)
+                        dir
+                      # No way... we can't write anywhere...
+                      else
+                        warn "Couldn't find a writable path to store Opal cache. " \
+                             'Try setting OPAL_CACHE_DIR environment variable'
+                        nil
+                      end
+      end
+
+      private def cache_filename_for(key)
+        "#{@dir}/#{key}.rbm.gz"
+      end
+    end
+  end
+end