opal 0.9.4 → 0.10.0.beta1

data/stdlib/nodejs/dir.rb

@@ -2,12 +2,14 @@ class Dir
   @__glob__ = node_require :glob
   `var __glob__ = #{@__glob__}`
 
-  def self.[] glob
-    `__glob__.sync(#{glob})`
-  end
+  class << self
+    def [] glob
+      `__glob__.sync(#{glob})`
+    end
 
-  def pwd
-    `process.cwd()`
+    def pwd
+      `process.cwd()`
+    end
+    alias getwd pwd
   end
-  alias getwd pwd
 end

data/stdlib/nodejs/file.rb

@@ -17,6 +17,7 @@ class File < IO
   end
 
   def self.exist? path
+    path = path.path if path.respond_to? :path
     `__fs__.existsSync(#{path})`
   end
 
@@ -74,13 +75,22 @@ class File < IO
     end
   end
 
-
-
+  def self.stat path
+    path = path.path if path.respond_to? :path
+    File::Stat.new(path)
+  end
 
   # Instance Methods
 
   def initialize(path, flags)
-    flags = flags.gsub(/b/, '')
+    binary_flag_regexp = /b/
+    encoding_flag_regexp = /:(.*)/
+    # binary flag is unsupported
+    warn "Binary flag (b) is unsupported by Node.js openSync method, removing flag." if flags.match(binary_flag_regexp)
+    flags = flags.gsub(binary_flag_regexp, '')
+    # encoding flag is unsupported
+    warn "Encoding flag (:encoding) is unsupported by Node.js openSync method, removing flag." if flags.match(encoding_flag_regexp)
+    flags = flags.gsub(encoding_flag_regexp, '')
     @path = path
     @flags = flags
     @fd = `__fs__.openSync(path, flags)`
@@ -101,3 +111,18 @@ class File < IO
   end
 end
 
+class File::Stat
+
+  @__fs__ = node_require :fs
+  `var __fs__ = #{@__fs__}`
+
+  def initialize(path)
+    @path = path
+  end
+
+
+  def file?
+    `__fs__.statSync(#{@path}).isFile()`
+  end
+
+end

data/stdlib/nodejs/node_modules/.bin/js-yaml

@@ -0,0 +1 @@
+../js-yaml/bin/js-yaml.js

data/stdlib/nodejs/node_modules/js-yaml/node_modules/.bin/esparse

@@ -0,0 +1 @@
+../esprima/bin/esparse.js

data/stdlib/nodejs/node_modules/js-yaml/node_modules/.bin/esvalidate

@@ -0,0 +1 @@
+../esprima/bin/esvalidate.js

data/stdlib/nodejs/require.rb

@@ -2,7 +2,7 @@ require 'opal-parser'
 
 module Kernel
   def __prepare_require__(path)
-    name = `Opal.normalize_loadable_path(#{path})`
+    name = `Opal.normalize(#{path})`
     full_path = name.end_with?('.rb') ? name : name+'.rb'
 
     if `!Opal.modules[#{name}]`

data/stdlib/nodejs/yaml.rb

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

data/stdlib/opal-parser.rb

@@ -4,8 +4,13 @@ require 'opal/version'
 
 module Kernel
   def eval(str)
-    code = Opal.compile str, file: '(eval)'
-    `eval(#{code})`
+    str = Opal.coerce_to!(str, String, :to_str)
+    code = Opal.compile str, file: '(eval)', eval: true
+    %x{
+      return (function(self) {
+        return eval(#{code});
+      })(self)
+    }
   end
 
   def require_remote url

data/stdlib/pathname.rb

@@ -33,7 +33,7 @@ class Pathname
   end
 
   def cleanpath
-    `return Opal.normalize_loadable_path(#@path)`
+    `return Opal.normalize(#@path)`
   end
 
   def to_path
@@ -44,6 +44,28 @@ class Pathname
     @path
   end
 
+  def expand_path
+    File.expand_path @path
+  end
+
+  def +(other)
+    other = Pathname.new(other) unless Pathname === other
+    Pathname.new(File.join(@path, other.to_path))
+  end
+
+  def join(*args)
+    args.unshift self
+    result = args.pop
+    result = Pathname.new(result) unless Pathname === result
+    return result if result.absolute?
+    args.reverse_each {|arg|
+      arg = Pathname.new(arg) unless Pathname === arg
+      result = arg + result
+      return result if result.absolute?
+    }
+    result
+  end
+
   alias :to_str :to_path
   alias :to_s :to_path
 end

data/stdlib/phantomjs.rb

@@ -5,3 +5,13 @@ STDERR.write_proc = `function(str){callPhantom(['stderr', str])}`
 
 STDOUT.tty = true
 STDERR.tty = true
+
+ARGV += `JSON.parse(callPhantom(['argv']))`
+
+%x{
+  var env = JSON.parse(callPhantom(['env']));
+
+  Object.keys(env).forEach(function(key) {
+    #{ENV[`key`] = `env[key]`}
+  });
+}

data/stdlib/promise.rb

@@ -122,7 +122,7 @@ class Promise
     @delayed   = false
 
     @prev = nil
-    @next = nil
+    @next = []
   end
 
   def value
@@ -171,7 +171,7 @@ class Promise
   end
 
   def >>(promise)
-    @next = promise
+    @next << promise
 
     if exception?
       promise.reject(@delayed[0])
@@ -214,8 +214,8 @@ class Promise
     @realized = :resolve
     @value    = value
 
-    if @next
-      @next.resolve(value)
+    if @next.any?
+      @next.each { |p| p.resolve(value) }
     else
       @delayed = [value]
     end
@@ -251,8 +251,8 @@ class Promise
     @realized = :reject
     @error    = value
 
-    if @next
-      @next.reject(value)
+    if @next.any?
+      @next.each { |p| p.reject(value) }
     else
       @delayed = [value]
     end
@@ -265,49 +265,64 @@ class Promise
   end
 
   def then(&block)
-    if @next
-      raise ArgumentError, 'a promise has already been chained'
-    end
-
     self ^ Promise.new(success: block)
   end
 
+  def then!(&block)
+    there_can_be_only_one!
+    self.then(&block)
+  end
+
   alias do then
+  alias do! then!
 
   def fail(&block)
-    if @next
-      raise ArgumentError, 'a promise has already been chained'
-    end
-
     self ^ Promise.new(failure: block)
   end
 
+  def fail!(&block)
+    there_can_be_only_one!
+    fail(&block)
+  end
+
   alias rescue fail
   alias catch fail
+  alias rescue! fail!
+  alias catch! fail!
 
   def always(&block)
-    if @next
-      raise ArgumentError, 'a promise has already been chained'
-    end
-
     self ^ Promise.new(always: block)
   end
 
+  def always!(&block)
+    there_can_be_only_one!
+    always(&block)
+  end
+
   alias finally always
   alias ensure always
+  alias finally! always!
+  alias ensure! always!
 
   def trace(depth = nil, &block)
-    if @next
+    self ^ Trace.new(depth, block)
+  end
+
+  def trace!(*args, &block)
+    there_can_be_only_one!
+    trace(*args, &block)
+  end
+
+  def there_can_be_only_one!
+    if @next.any?
       raise ArgumentError, 'a promise has already been chained'
     end
-
-    self ^ Trace.new(depth, block)
   end
 
   def inspect
     result = "#<#{self.class}(#{object_id})"
 
-    if @next
+    if @next.any?
       result += " >> #{@next.inspect}"
     end
 
@@ -400,7 +415,7 @@ class Promise
       @wait << promise
 
       promise.always {
-        try if @next
+        try if @next.any?
       }
 
       self

data/tasks/building.rake

@@ -14,9 +14,9 @@ task :dist do
   require 'opal/util'
   require 'opal/sprockets/environment'
 
-  Opal::Processor.arity_check_enabled = false
-  Opal::Processor.const_missing_enabled = false
-  Opal::Processor.dynamic_require_severity = :warning
+  Opal::Config.arity_check_enabled = false
+  Opal::Config.const_missing_enabled = false
+  Opal::Config.dynamic_require_severity = :warning
   env = Opal::Environment.new
 
   build_dir = ENV['DIR'] || 'build'

data/tasks/testing.rake

@@ -1,4 +1,7 @@
-require_relative './testing/mspec_special_calls'
+# Remove when we drop support for 1.9.3
+__dir__ = defined?(Kernel.__dir__) ? Kernel.__dir__ : File.dirname(File.realpath(__FILE__))
+
+require "#{__dir__}/testing/mspec_special_calls"
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:rspec) do |t|
@@ -24,7 +27,7 @@ module Testing
     whitelist_pattern = !!env['RUBYSPECS']
 
     excepting = []
-    rubyspecs = File.read('spec/rubyspecs').lines.reject do |l|
+    rubyspecs = File.read('spec/ruby_specs').lines.reject do |l|
       l.strip!
       l.start_with?('#') || l.empty? || (l.start_with?('!') && excepting.push(l.sub('!', 'spec/') + '.rb'))
     end.flat_map do |path|
@@ -37,7 +40,14 @@ module Testing
     userspecs &= rubyspecs if whitelist_pattern
 
     opalspec_filters = Dir['spec/filters/**/*_opal.rb']
-    rubyspec_filters = Dir['spec/filters/**/*.rb'] - opalspec_filters
+
+    if ENV['INVERT_RUNNING_MODE']
+      # When we run an inverted test suite we should run only 'bugs'.
+      # Unsupported features are not supported anyway
+      rubyspec_filters = Dir['spec/filters/bugs/*.rb'] - opalspec_filters
+    else
+      rubyspec_filters = Dir['spec/filters/**/*.rb'] - opalspec_filters
+    end
 
     specs = []
     add_specs = ->(name, new_specs) do
@@ -53,12 +63,12 @@ module Testing
       add_specs["PATTERN=#{pattern}", userspecs]
     elsif suite == 'opal'
       add_specs['spec/opal', opalspecs]
-    elsif suite == 'rubyspec'
-      add_specs['spec/rubyspec', rubyspecs]
+    elsif suite == 'ruby'
+      add_specs['spec/ruby', rubyspecs]
     else
       warn 'Please provide at lease one of the following environment variables:'
-      warn 'PATTERN # e.g. PATTERN=spec/rubyspec/core/numeric/**_spec.rb'
-      warn 'SUITE   # can be either SUITE=opal or SUITE=rubyspec'
+      warn 'PATTERN # e.g. PATTERN=spec/ruby/core/numeric/**_spec.rb'
+      warn 'SUITE   # can be either SUITE=opal or SUITE=ruby'
       exit 1
     end
 
@@ -75,6 +85,7 @@ module Testing
     File.write filename, <<-RUBY
       require 'spec_helper'
       require 'opal/platform'
+      OSpecRunner.main.will_start
       #{enter_benchmarking_mode}
       #{requires.join("\n    ")}
       OSpecFilter.main.unused_filters_message(list: #{!!ENV['LIST_UNUSED_FILTERS']})
@@ -98,12 +109,12 @@ pattern_usage = <<-DESC
 Use PATTERN environment variable to manually set the glob for specs:
 
   # Will run all specs matching the specified pattern.
-  # (Note: the rubyspecs filters will still apply)
-  bundle exec rake mspec_node PATTERN=spec/rubyspec/core/module/class_variable*_spec.rb
-  bundle exec rake mspec_node PATTERN=spec/rubyspec/core/numeric/**_spec.rb
+  # (Note: the ruby_specs filters will still apply)
+  bundle exec rake mspec_node PATTERN=spec/ruby/core/module/class_variable*_spec.rb
+  bundle exec rake mspec_node PATTERN=spec/ruby/core/numeric/**_spec.rb
 DESC
 
-%w[rubyspec opal].each do |suite|
+%w[ruby opal].each do |suite|
   desc "Run the MSpec/#{suite} test suite on Opal::Sprockets/phantomjs" + pattern_usage
   task :"mspec_#{suite}_sprockets_phantomjs" do
     filename = File.expand_path('tmp/mspec_sprockets_phantomjs.rb')
@@ -160,9 +171,9 @@ DESC
   end
 end
 
-task :mspec_phantomjs           => [:mspec_opal_phantomjs,           :mspec_rubyspec_phantomjs]
-task :mspec_nodejs              => [:mspec_opal_nodejs,              :mspec_rubyspec_nodejs]
-task :mspec_sprockets_phantomjs => [:mspec_opal_sprockets_phantomjs, :mspec_rubyspec_sprockets_phantomjs]
+task :mspec_phantomjs           => [:mspec_opal_phantomjs,           :mspec_ruby_phantomjs]
+task :mspec_nodejs              => [:mspec_opal_nodejs,              :mspec_ruby_nodejs]
+task :mspec_sprockets_phantomjs => [:mspec_opal_sprockets_phantomjs, :mspec_ruby_sprockets_phantomjs]
 
 task :jshint do
   js_filename = 'tmp/jshint.js'
@@ -197,6 +208,8 @@ task :cruby_tests do
       benchmark/test_benchmark.rb
       ruby/test_call.rb
       opal/test_keyword.rb
+      base64/test_base64.rb
+      opal/unsupported_and_bugs.rb
     ].flat_map do |path|
       if path.end_with?('.rb')
         path

data/tasks/testing/mspec_special_calls.rb

@@ -6,7 +6,7 @@ class Opal::Nodes::CallNode
   add_special :language_version do
     if scope.top?
       lang_type = arglist[2][1]
-      target = "rubyspec/language/versions/#{lang_type}_1.9"
+      target = "ruby/language/versions/#{lang_type}_1.9"
 
       if File.exist?(target)
         compiler.requires << target

data/tasks/testing/sprockets-phantomjs.js

@@ -37,6 +37,10 @@ page.onCallback = function(data) {
   case 'stderr':
     system.stderr.write(data[1] || '');
     break;
+  case 'env':
+    return JSON.stringify(system.env);
+  case 'argv':
+    return JSON.stringify(system.args.slice(1));
   default:
     console.error('Unknown callback data: ', data);
   }

data/test/opal/test_keyword.rb

@@ -51,17 +51,17 @@ class TestKeywordArguments < Test::Unit::TestCase
   #   assert_raise(ArgumentError) { f4(str: "bar", check: true) }
   #   assert_raise(ArgumentError) { f4("string") }
   # end
-  #
-  # define_method(:f5) {|str: "foo", num: 424242, **h| [str, num, h] }
-  #
-  # def test_f5
-  #   assert_equal(["foo", 424242, {}], f5)
-  #   assert_equal(["bar", 424242, {}], f5(str: "bar"))
-  #   assert_equal(["foo", 111111, {}], f5(num: 111111))
-  #   assert_equal(["bar", 111111, {}], f5(str: "bar", num: 111111))
-  #   assert_equal(["bar", 424242, {:check=>true}], f5(str: "bar", check: true))
-  #   assert_raise(ArgumentError) { f5("string") }
-  # end
+
+  define_method(:f5) {|str: "foo", num: 424242, **h| [str, num, h] }
+
+  def test_f5
+    assert_equal(["foo", 424242, {}], f5)
+    assert_equal(["bar", 424242, {}], f5(str: "bar"))
+    assert_equal(["foo", 111111, {}], f5(num: 111111))
+    assert_equal(["bar", 111111, {}], f5(str: "bar", num: 111111))
+    assert_equal(["bar", 424242, {:check=>true}], f5(str: "bar", check: true))
+    assert_raise(ArgumentError) { f5("string") }
+  end
 
 
   def f6(str: "foo", num: 424242, **h, &blk)
@@ -96,16 +96,16 @@ class TestKeywordArguments < Test::Unit::TestCase
     assert_equal([[1, 2, 3], "bar", 424242, {}], f7(1, 2, 3, str: "bar"))
   end
 
-  # define_method(:f8) { |opt = :ion, *rest, key: :word|
-  #   [opt, rest, key]
-  # }
-  #
-  # def test_f8
-  #   assert_equal([:ion, [], :word], f8)
-  #   assert_equal([1, [], :word], f8(1))
-  #   assert_equal([1, [2], :word], f8(1, 2))
-  # end
-  #
+  define_method(:f8) { |opt = :ion, *rest, key: :word|
+    [opt, rest, key]
+  }
+
+  def test_f8
+    assert_equal([:ion, [], :word], f8)
+    assert_equal([1, [], :word], f8(1))
+    assert_equal([1, [2], :word], f8(1, 2))
+  end
+
   # def f9(r, o=42, *args, p, k: :key, **kw, &b)
   #   [r, o, args, p, k, kw, b]
   # end
@@ -141,15 +141,15 @@ class TestKeywordArguments < Test::Unit::TestCase
                   [:keyrest, :kw], [:block, :b]], method(:f9).parameters)
   end
 
-  # def test_lambda
-  #   f = ->(str: "foo", num: 424242) { [str, num] }
-  #   assert_equal(["foo", 424242], f[])
-  #   assert_equal(["bar", 424242], f[str: "bar"])
-  #   assert_equal(["foo", 111111], f[num: 111111])
-  #   assert_equal(["bar", 111111], f[str: "bar", num: 111111])
-  # end
-  #
-  #
+  def test_lambda
+    f = ->(str: "foo", num: 424242) { [str, num] }
+    assert_equal(["foo", 424242], f[])
+    assert_equal(["bar", 424242], f[str: "bar"])
+    assert_equal(["foo", 111111], f[num: 111111])
+    assert_equal(["bar", 111111], f[str: "bar", num: 111111])
+  end
+
+
   # def p1
   #   Proc.new do |str: "foo", num: 424242|
   #     [str, num]
@@ -164,20 +164,20 @@ class TestKeywordArguments < Test::Unit::TestCase
   #   assert_raise(ArgumentError) { p1[str: "bar", check: true] }
   #   assert_equal(["foo", 424242], p1["string"] )
   # end
-  #
-  #
-  # def p2
-  #   Proc.new do |x, str: "foo", num: 424242|
-  #     [x, str, num]
-  #   end
-  # end
-  #
-  # def test_p2
-  #   assert_equal([nil, "foo", 424242], p2[])
-  #   assert_equal([:xyz, "foo", 424242], p2[:xyz])
-  # end
-  #
-  #
+
+
+  def p2
+    Proc.new do |x, str: "foo", num: 424242|
+      [x, str, num]
+    end
+  end
+
+  def test_p2
+    assert_equal([nil, "foo", 424242], p2[])
+    assert_equal([:xyz, "foo", 424242], p2[:xyz])
+  end
+
+
   # def p3
   #   Proc.new do |str: "foo", num: 424242, **h|
   #     [str, num, h]
@@ -192,46 +192,46 @@ class TestKeywordArguments < Test::Unit::TestCase
   #   assert_equal(["bar", 424242, {:check=>true}], p3[str: "bar", check: true])
   #   assert_equal(["foo", 424242, {}], p3["string"])
   # end
-  #
-  #
-  # def p4
-  #   Proc.new do |str: "foo", num: 424242, **h, &blk|
-  #     [str, num, h, blk]
-  #   end
-  # end
-  #
-  # def test_p4
-  #   assert_equal(["foo", 424242, {}, nil], p4[])
-  #   assert_equal(["bar", 424242, {}, nil], p4[str: "bar"])
-  #   assert_equal(["foo", 111111, {}, nil], p4[num: 111111])
-  #   assert_equal(["bar", 111111, {}, nil], p4[str: "bar", num: 111111])
-  #   assert_equal(["bar", 424242, {:check=>true}, nil], p4[str: "bar", check: true])
-  #   a = p4.call {|x| x + 42 }
-  #   assert_equal(["foo", 424242, {}], a[0, 3])
-  #   assert_equal(43, a.last.call(1))
-  # end
-  #
-  #
-  # def p5
-  #   Proc.new do |*r, str: "foo", num: 424242, **h|
-  #     [r, str, num, h]
-  #   end
-  # end
-  #
-  # def test_p5
-  #   assert_equal([[], "foo", 424242, {}], p5[])
-  #   assert_equal([[], "bar", 424242, {}], p5[str: "bar"])
-  #   assert_equal([[], "foo", 111111, {}], p5[num: 111111])
-  #   assert_equal([[], "bar", 111111, {}], p5[str: "bar", num: 111111])
-  #   assert_equal([[1], "foo", 424242, {}], p5[1])
-  #   assert_equal([[1, 2], "foo", 424242, {}], p5[1, 2])
-  #   assert_equal([[1, 2, 3], "foo", 424242, {}], p5[1, 2, 3])
-  #   assert_equal([[1], "bar", 424242, {}], p5[1, str: "bar"])
-  #   assert_equal([[1, 2], "bar", 424242, {}], p5[1, 2, str: "bar"])
-  #   assert_equal([[1, 2, 3], "bar", 424242, {}], p5[1, 2, 3, str: "bar"])
-  # end
-  #
-  #
+
+
+  def p4
+    Proc.new do |str: "foo", num: 424242, **h, &blk|
+      [str, num, h, blk]
+    end
+  end
+
+  def test_p4
+    assert_equal(["foo", 424242, {}, nil], p4[])
+    assert_equal(["bar", 424242, {}, nil], p4[str: "bar"])
+    assert_equal(["foo", 111111, {}, nil], p4[num: 111111])
+    assert_equal(["bar", 111111, {}, nil], p4[str: "bar", num: 111111])
+    assert_equal(["bar", 424242, {:check=>true}, nil], p4[str: "bar", check: true])
+    a = p4.call {|x| x + 42 }
+    assert_equal(["foo", 424242, {}], a[0, 3])
+    assert_equal(43, a.last.call(1))
+  end
+
+
+  def p5
+    Proc.new do |*r, str: "foo", num: 424242, **h|
+      [r, str, num, h]
+    end
+  end
+
+  def test_p5
+    assert_equal([[], "foo", 424242, {}], p5[])
+    assert_equal([[], "bar", 424242, {}], p5[str: "bar"])
+    assert_equal([[], "foo", 111111, {}], p5[num: 111111])
+    assert_equal([[], "bar", 111111, {}], p5[str: "bar", num: 111111])
+    assert_equal([[1], "foo", 424242, {}], p5[1])
+    assert_equal([[1, 2], "foo", 424242, {}], p5[1, 2])
+    assert_equal([[1, 2, 3], "foo", 424242, {}], p5[1, 2, 3])
+    assert_equal([[1], "bar", 424242, {}], p5[1, str: "bar"])
+    assert_equal([[1, 2], "bar", 424242, {}], p5[1, 2, str: "bar"])
+    assert_equal([[1, 2, 3], "bar", 424242, {}], p5[1, 2, 3, str: "bar"])
+  end
+
+
   # def p6
   #   Proc.new do |o1, o2=42, *args, p, k: :key, **kw, &b|
   #     [o1, o2, args, p, k, kw, b]
@@ -255,19 +255,19 @@ class TestKeywordArguments < Test::Unit::TestCase
   #   assert_equal([[:opt, :o1], [:opt, :o2], [:rest, :args], [:opt, :p], [:key, :k],
   #                 [:keyrest, :kw], [:block, :b]], p6.parameters)
   # end
-  #
-  # def m1(*args)
-  #   yield(*args)
-  # end
-  #
-  # def test_block
-  #   blk = Proc.new {|str: "foo", num: 424242| [str, num] }
-  #   assert_equal(["foo", 424242], m1(&blk))
-  #   assert_equal(["bar", 424242], m1(str: "bar", &blk))
-  #   assert_equal(["foo", 111111], m1(num: 111111, &blk))
-  #   assert_equal(["bar", 111111], m1(str: "bar", num: 111111, &blk))
-  # end
-  #
+
+  def m1(*args)
+    yield(*args)
+  end
+
+  def test_block
+    blk = Proc.new {|str: "foo", num: 424242| [str, num] }
+    assert_equal(["foo", 424242], m1(&blk))
+    assert_equal(["bar", 424242], m1(str: "bar", &blk))
+    assert_equal(["foo", 111111], m1(num: 111111, &blk))
+    assert_equal(["bar", 111111], m1(str: "bar", num: 111111, &blk))
+  end
+
   # def rest_keyrest(*args, **opt)
   #   return *args, opt
   # end
@@ -570,21 +570,21 @@ class TestKeywordArguments < Test::Unit::TestCase
   #     assert_equal({:bar => "bar"}, obj.foo, bug10659)
   #   }
   # end
-  #
-  # def m(a) yield a end
-  #
+
+  def m(a) yield a end
+
   # def test_nonsymbol_key
   #   result = m(["a" => 10]) { |a = nil, **b| [a, b] }
   #   assert_equal([{"a" => 10}, {}], result)
   # end
-  #
-  # def method_for_test_to_hash_call_during_setup_complex_parameters k1:, k2:, **rest_kw
-  #   [k1, k2, rest_kw]
-  # end
-  #
-  # def test_to_hash_call_during_setup_complex_parameters
-  #   sym = "sym_#{Time.now}".to_sym
-  #   h = method_for_test_to_hash_call_during_setup_complex_parameters k1: "foo", k2: "bar", sym => "baz"
-  #   assert_equal ["foo", "bar", {sym => "baz"}], h, '[Bug #11027]'
-  # end
+
+  def method_for_test_to_hash_call_during_setup_complex_parameters k1:, k2:, **rest_kw
+    [k1, k2, rest_kw]
+  end
+
+  def test_to_hash_call_during_setup_complex_parameters
+    sym = "sym_#{Time.now}".to_sym
+    h = method_for_test_to_hash_call_during_setup_complex_parameters k1: "foo", k2: "bar", sym => "baz"
+    assert_equal ["foo", "bar", {sym => "baz"}], h, '[Bug #11027]'
+  end
 end