opal 1.4.0.alpha1 → 1.5.0.rc1

data/spec/lib/rewriters/logical_operator_assignment_spec.rb

@@ -1,82 +1,57 @@
 require 'lib/spec_helper'
+require 'support/rewriters_helper'
 
 RSpec.describe Opal::Rewriters::LogicalOperatorAssignment do
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
-  end
-
-  let(:rewriter) { Opal::Rewriters::LogicalOperatorAssignment.new }
+  include RewritersHelper
 
-  def parse(source)
-    parser = Opal::Parser.default_parser
-    buffer = ::Opal::Parser::SourceBuffer.new('(eval)')
-    buffer.source = source
-    parser.parse(buffer)
-  end
-
-  def rewrite(ast)
-    rewriter.process(ast)
-  end
+  use_only_described_rewriter!
 
-  around(:each) do |e|
-    Opal::Rewriters::LogicalOperatorAssignment.reset_tmp_counter!
-    Opal::Rewriter.disable { e.run }
-  end
+  before(:each) { Opal::Rewriters::LogicalOperatorAssignment.reset_tmp_counter! }
   let(:cache_tmp_name) { :$logical_op_recvr_tmp_1 }
   let(:cached) { s(:js_tmp, cache_tmp_name) }
 
-  shared_examples 'it rewrites' do |from, to|
-    it "rewrites #{from.inspect} to #{to.inspect}" do
-      input = parse(from)
-      rewritten = rewrite(input)
-      expected = parse(to)
-
-      expect(rewritten).to eq(expected)
-    end
-  end
-
   context 'rewriting or_asgn and and_asgn nodes' do
     context 'local variable' do
-      include_examples 'it rewrites', 'a = local; a ||= 1', 'a = local; a = a || 1'
-      include_examples 'it rewrites', 'a = local; a &&= 1', 'a = local; a = a && 1'
+      include_examples 'it rewrites source-to-source', 'a = local; a ||= 1', 'a = local; a = a || 1'
+      include_examples 'it rewrites source-to-source', 'a = local; a &&= 1', 'a = local; a = a && 1'
     end
 
     context 'instance variable' do
-      include_examples 'it rewrites', '@a ||= 1', '@a = @a || 1'
-      include_examples 'it rewrites', '@a &&= 1', '@a = @a && 1'
+      include_examples 'it rewrites source-to-source', '@a ||= 1', '@a = @a || 1'
+      include_examples 'it rewrites source-to-source', '@a &&= 1', '@a = @a && 1'
     end
 
     context 'constant' do
-      include_examples 'it rewrites', 'CONST ||= 1', 'CONST = defined?(CONST) ? (CONST || 1) : 1'
-      include_examples 'it rewrites', 'CONST &&= 1', 'CONST = CONST && 1'
+      include_examples 'it rewrites source-to-source', 'CONST ||= 1', 'CONST = defined?(CONST) ? (CONST || 1) : 1'
+      include_examples 'it rewrites source-to-source', 'CONST &&= 1', 'CONST = CONST && 1'
     end
 
     context 'global variable' do
-      include_examples 'it rewrites', '$g ||= 1', '$g = $g || 1'
-      include_examples 'it rewrites', '$g &&= 1', '$g = $g && 1'
+      include_examples 'it rewrites source-to-source', '$g ||= 1', '$g = $g || 1'
+      include_examples 'it rewrites source-to-source', '$g &&= 1', '$g = $g && 1'
     end
 
     context 'class variable' do
-      include_examples 'it rewrites', '@@a ||= 1', '@@a = defined?(@@a) ? (@@a || 1) : 1'
-      include_examples 'it rewrites', '@@a &&= 1', '@@a = @@a && 1'
+      include_examples 'it rewrites source-to-source', '@@a ||= 1', '@@a = defined?(@@a) ? (@@a || 1) : 1'
+      include_examples 'it rewrites source-to-source', '@@a &&= 1', '@@a = @@a && 1'
     end
 
     context 'simple method call' do
-      include_examples 'it rewrites', 'recvr = 1; recvr.meth ||= rhs', 'recvr = 1; recvr.meth || recvr.meth = rhs'
-      include_examples 'it rewrites', 'recvr = 1; recvr.meth &&= rhs', 'recvr = 1; recvr.meth && recvr.meth = rhs'
+      include_examples 'it rewrites source-to-source', 'recvr = 1; recvr.meth ||= rhs', 'recvr = 1; recvr.meth || recvr.meth = rhs'
+      include_examples 'it rewrites source-to-source', 'recvr = 1; recvr.meth &&= rhs', 'recvr = 1; recvr.meth && recvr.meth = rhs'
     end
 
     context '[] / []= method call' do
-      include_examples 'it rewrites', 'recvr = 1; recvr[idx] ||= rhs', 'recvr = 1; recvr[idx] || recvr[idx] = rhs'
-      include_examples 'it rewrites', 'recvr = 1; recvr[idx] &&= rhs', 'recvr = 1; recvr[idx] && recvr[idx] = rhs'
+      include_examples 'it rewrites source-to-source', 'recvr = 1; recvr[idx] ||= rhs', 'recvr = 1; recvr[idx] || recvr[idx] = rhs'
+      include_examples 'it rewrites source-to-source', 'recvr = 1; recvr[idx] &&= rhs', 'recvr = 1; recvr[idx] && recvr[idx] = rhs'
     end
 
     context '[] / []= method call with multiple arguments' do
-      include_examples 'it rewrites',
+      include_examples 'it rewrites source-to-source',
         'recvr = 1; recvr[idx1, idx2] ||= rhs',
           'recvr = 1; recvr[idx1, idx2] || recvr[idx1, idx2] = rhs'
 
-      include_examples 'it rewrites',
+      include_examples 'it rewrites source-to-source',
         'recvr = 1; recvr[idx1, idx2] &&= rhs',
           'recvr = 1; recvr[idx1, idx2] && recvr[idx1, idx2] = rhs'
     end
@@ -84,26 +59,26 @@ RSpec.describe Opal::Rewriters::LogicalOperatorAssignment do
     context 'chain of method calls' do
       it 'rewrites ||= by caching receiver to a temporary local variable' do
         input = parse('recvr.a.b ||= rhs')
-        rewritten = rewrite(input)
+        rewritten = rewrite(input).children.first
 
         expected = s(:begin,
-          s(:lvasgn, cache_tmp_name, parse('recvr.a')), # cached = recvr.a
+          s(:lvasgn, cache_tmp_name, ast_of('recvr.a')), # cached = recvr.a
           s(:or,
-            s(:send, cached, :b),                       # cached.b
-            s(:send, cached, :b=, parse('rhs'))))       # cached.b = rhs
+            s(:send, cached, :b),                        # cached.b ||
+            s(:send, cached, :b=, ast_of('rhs'))))       # cached.b = rhs
 
         expect(rewritten).to eq(expected)
       end
 
       it 'rewrites &&= by caching receiver to a temporary local variable' do
         input = parse('recvr.a.b &&= rhs')
-        rewritten = rewrite(input)
+        rewritten = rewrite(input).children.first
 
         expected = s(:begin,
-          s(:lvasgn, cache_tmp_name, parse('recvr.a')), # cached = recvr.a
+          s(:lvasgn, cache_tmp_name, ast_of('recvr.a')), # cached = recvr.a
           s(:and,
-            s(:send, cached, :b),                       # cached.b
-            s(:send, cached, :b=, parse('rhs'))))       # cached.b = rhs
+            s(:send, cached, :b),                        # cached.b ||
+            s(:send, cached, :b=, ast_of('rhs'))))       # cached.b = rhs
 
         expect(rewritten).to eq(expected)
       end
@@ -112,17 +87,17 @@ RSpec.describe Opal::Rewriters::LogicalOperatorAssignment do
     context 'method call using safe nafigator' do
       it 'rewrites ||= by caching receiver and rewriting it to if and or_asgn' do
         input = parse('recvr&.meth ||= rhs')
-        rewritten = rewrite(input)
+        rewritten = rewrite(input).children.first
 
         expected = s(:begin,
-          s(:lvasgn, cache_tmp_name, parse('recvr')), # cached = recvr
-          s(:if, s(:send, cached, :nil?),             # if cached.nil?
-            s(:nil),                                  #   nil
-                                                      # else
+          s(:lvasgn, cache_tmp_name, ast_of('recvr')), # cached = recvr
+          s(:if, s(:send, cached, :nil?),              # if cached.nil?
+            s(:nil),                                   #   nil
+                                                       # else
             s(:or,
-              s(:send, cached, :meth),                #   cached.meth ||
-              s(:send, cached, :meth=, parse('rhs'))) #     cached.meth = rhs
-            )                                         # end
+              s(:send, cached, :meth),                 #   cached.meth ||
+              s(:send, cached, :meth=, ast_of('rhs'))) #     cached.meth = rhs
+            )                                          # end
           )
 
         expect(rewritten).to eq(expected)
@@ -130,17 +105,17 @@ RSpec.describe Opal::Rewriters::LogicalOperatorAssignment do
 
       it 'rewrites &&= by caching receiver and rewriting it to if and or_asgn' do
         input = parse('recvr&.meth &&= rhs')
-        rewritten = rewrite(input)
+        rewritten = rewrite(input).children.first
 
         expected = s(:begin,
-          s(:lvasgn, cache_tmp_name, parse('recvr')), # cached = recvr
-          s(:if, s(:send, cached, :nil?),             # if cached.nil?
-            s(:nil),                                  #   nil
-                                                      # else
+          s(:lvasgn, cache_tmp_name, ast_of('recvr')), # cached = recvr
+          s(:if, s(:send, cached, :nil?),              # if cached.nil?
+            s(:nil),                                   #   nil
+                                                       # else
             s(:and,
-              s(:send, cached, :meth),                #   cached.meth ||
-              s(:send, cached, :meth=, parse('rhs'))) #     cached.meth = rhs
-            )                                         # end
+              s(:send, cached, :meth),                 #   cached.meth &&
+              s(:send, cached, :meth=, ast_of('rhs'))) #     cached.meth = rhs
+            )                                          # end
           )
 
         expect(rewritten).to eq(expected)
@@ -150,53 +125,53 @@ RSpec.describe Opal::Rewriters::LogicalOperatorAssignment do
 
   context 'rewriting defined?(or_asgn) and defined?(and_asgn)' do
     context 'local variable' do
-      include_examples 'it rewrites', 'a = nil; defined?(a ||= 1)', 'a = nil; "assignment"'
-      include_examples 'it rewrites', 'a = nil; defined?(a &&= 1)', 'a = nil; "assignment"'
+      include_examples 'it rewrites source-to-source', 'a = nil; defined?(a ||= 1)', 'a = nil; "assignment"'
+      include_examples 'it rewrites source-to-source', 'a = nil; defined?(a &&= 1)', 'a = nil; "assignment"'
     end
 
     context 'instance variable' do
-      include_examples 'it rewrites', 'defined?(@a ||= 1)', %q("assignment")
-      include_examples 'it rewrites', 'defined?(@a &&= 1)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(@a ||= 1)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(@a &&= 1)', %q("assignment")
     end
 
     context 'constant' do
-      include_examples 'it rewrites', 'defined?(CONST ||= 1)', %q("assignment")
-      include_examples 'it rewrites', 'defined?(CONST &&= 1)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(CONST ||= 1)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(CONST &&= 1)', %q("assignment")
     end
 
     context 'global variable' do
-      include_examples 'it rewrites', 'defined?($g ||= 1)', %q("assignment")
-      include_examples 'it rewrites', 'defined?($g &&= 1)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?($g ||= 1)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?($g &&= 1)', %q("assignment")
     end
 
     context 'class variable' do
-      include_examples 'it rewrites', 'defined?(@@a ||= 1)', %q("assignment")
-      include_examples 'it rewrites', 'defined?(@@a &&= 1)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(@@a ||= 1)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(@@a &&= 1)', %q("assignment")
     end
 
     context 'simple method call' do
-      include_examples 'it rewrites', 'defined?(recvr.meth ||= rhs)', %q("assignment")
-      include_examples 'it rewrites', 'defined?(recvr.meth &&= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr.meth ||= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr.meth &&= rhs)', %q("assignment")
     end
 
     context '[] / []= method call' do
-      include_examples 'it rewrites', 'defined?(recvr[idx] ||= rhs)', %q("assignment")
-      include_examples 'it rewrites', 'defined?(recvr[idx] &&= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr[idx] ||= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr[idx] &&= rhs)', %q("assignment")
     end
 
     context '[] / []= method call with multiple arguments' do
-      include_examples 'it rewrites', 'defined?(recvr[idx1, idx2] ||= rhs)', %q("assignment")
-      include_examples 'it rewrites', 'defined?(recvr[idx1, idx2] &&= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr[idx1, idx2] ||= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr[idx1, idx2] &&= rhs)', %q("assignment")
     end
 
     context 'chain of method calls' do
-      include_examples 'it rewrites', 'defined?(recvr.a.b.c ||= rhs)', %q("assignment")
-      include_examples 'it rewrites', 'defined?(recvr.a.b.c &&= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr.a.b.c ||= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr.a.b.c &&= rhs)', %q("assignment")
     end
 
     context 'method call using safe nafigator' do
-      include_examples 'it rewrites', 'defined?(recvr&.meth ||= rhs)', %q("assignment")
-      include_examples 'it rewrites', 'defined?(recvr&.meth &&= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr&.meth ||= rhs)', %q("assignment")
+      include_examples 'it rewrites source-to-source', 'defined?(recvr&.meth &&= rhs)', %q("assignment")
     end
   end
 end

data/spec/lib/rewriters/numblocks_spec.rb

@@ -4,9 +4,7 @@ require 'opal/rewriters/numblocks'
 
 RSpec.describe Opal::Rewriters::Numblocks do
   include RewritersHelper
-  extend  RewritersHelper
-
-  before(:each) { Opal::Rewriters::ForRewriter.reset_tmp_counter! }
+  extend RewritersHelper # s() in example scope
 
   correct_names = proc do |ast|
     case ast
@@ -22,7 +20,7 @@ RSpec.describe Opal::Rewriters::Numblocks do
     end
   end
 
-  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(parse(<<~ENDDEST))
+  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(ast_of(<<~ENDDEST))
     proc do
       _1
     end
@@ -32,7 +30,7 @@ RSpec.describe Opal::Rewriters::Numblocks do
     end
   ENDDEST
 
-  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(parse(<<~ENDDEST))
+  include_examples 'it rewrites source-to-AST', <<~ENDSOURCE, correct_names.(ast_of(<<~ENDDEST))
     proc do
       _3
     end

data/spec/lib/rewriters/opal_engine_check_spec.rb

@@ -1,20 +1,8 @@
 require 'lib/spec_helper'
+require 'support/rewriters_helper'
 
 RSpec.describe Opal::Rewriters::OpalEngineCheck do
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
-  end
-
-  let(:rewriter) { Opal::Rewriters::OpalEngineCheck.new }
-
-  def expect_rewritten(node)
-    processed = rewriter.process(node)
-    expect(processed)
-  end
-
-  def expect_no_rewriting_for(node)
-    expect_rewritten(node).to eq(node)
-  end
+  include RewritersHelper
 
   let(:opal_str_sexp) { s(:str, 'opal') }
   let(:true_branch) { s(:int, 1) }

data/spec/lib/rewriters/rubyspec/filters_rewriter_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe Opal::Rubyspec::FiltersRewriter do
     SOURCE
   end
 
-  let(:ast) { ast_of(source) }
+  let(:ast) { parse(source) }
 
   context 'when spec is filtered' do
     around(:each) do |e|
@@ -44,16 +44,24 @@ RSpec.describe Opal::Rubyspec::FiltersRewriter do
       SOURCE
     end
 
-    let(:expected_ast) { ast_of(rewritten_source) }
+    let(:expected_ast) { parse(rewritten_source) }
 
     it 'replaces it with nil' do
       expect_rewritten(ast).to eq(expected_ast)
     end
+
+    it 'disables cache' do
+      expect(rewritten(ast).meta[:dynamic_cache_result]).to be_truthy
+    end
   end
 
   context 'when spec is not filtered' do
     it 'does not rewrite it' do
       expect_no_rewriting_for(ast)
     end
+
+    it 'disables cache' do
+      expect(rewritten(ast).meta[:dynamic_cache_result]).to be_truthy
+    end
   end
 end

data/spec/opal/compiler/irb_spec.rb

@@ -33,6 +33,10 @@ describe Opal::Compiler do
       $global["Opal"].irb_vars.bar.should == "HELLO WORLD"
     end
 
+    it "can reference an outer variable" do
+      eval_js("var a = 10;" + compile("a", :irb => true)).should == 10
+    end
+
     it "can still call top level methods" do
       eval_js(compile("to_s", :irb => true)).should == "main"
     end

data/spec/opal/core/language/super_spec.rb

@@ -1,24 +1,47 @@
+describe 'super without explicit argument' do
+  it 'passes arguments named with js reserved word' do
+    parent = Class.new do
+      def test_args(*args) = args
+      def test_rest_args(*args) = args
+      def test_kwargs(**args) = args
+      def test_rest_kwargs(**args) = args
+    end
+    klass = Class.new(parent) do
+      def test_args(native) = super
+      def test_rest_args(*native) = super
+      def test_kwargs(native:) = super
+      def test_rest_kwargs(**native) = super
+    end
+
+    klass.new.test_args(1).should == [1]
+    klass.new.test_rest_args(2).should == [2]
+    klass.new.test_kwargs(native: 3).should == {native: 3}
+    klass.new.test_rest_kwargs(native: 4).should == {native: 4}
+  end
+end
+
+class ABlockWithSuperSpec
+  BLOCK = proc {
+    return [self, super()]
+  }
+  def foo; :foo; end
+  def bar; :bar; end
+  def foo_bar; [foo, bar]; end
+end
+
 describe "a block with super" do
   it "can be used to define multiple methods" do
-    block = proc {
-      super()
-    }
-
-    c1 = Class.new {
-      def foo; :foo; end
-      def bar; :bar; end
-      def foo_bar; [foo, bar]; end
-    }
+    block = nil
 
-    c2 = Class.new(c1) {
-      define_method :foo, block
-      define_method :bar, block
-      define_method :foo_bar, block
+    c = Class.new(ABlockWithSuperSpec) {
+      define_method :foo, ABlockWithSuperSpec::BLOCK
+      define_method :bar, ABlockWithSuperSpec::BLOCK
+      define_method :foo_bar, ABlockWithSuperSpec::BLOCK
     }
 
-    obj = c2.new
-    obj.foo.should == :foo
-    obj.bar.should == :bar
-    obj.foo_bar.should == [:foo, :bar]
+    obj = c.new
+    obj.foo.should == [obj, :foo]
+    obj.bar.should == [obj, :bar]
+    obj.foo_bar.should == [obj, [[obj, :foo], [obj, :bar]]]
   end
 end

data/spec/opal/core/language/xstring_spec.rb

@@ -0,0 +1,13 @@
+describe "The x-string expression" do
+  it "works with multiline, case and assignment" do
+    a = case 1
+        when 1
+          %x{
+            var b = 5;
+            return b;
+          }
+        end
+    
+    a.should == 5
+  end
+end

data/spec/opal/core/regexp/assertions_spec.rb

@@ -0,0 +1,19 @@
+describe 'Regexp assertions' do
+  it 'matches the beginning of input' do
+    /\Atext/.should =~ 'text'
+    /\Atext/.should_not =~ 'the text'
+
+    regexp = Regexp.new('\Atext')
+    regexp.should =~ 'text'
+    regexp.should_not =~ 'the text'
+  end
+
+  it 'matches the end of input' do
+    /text\z/.should =~ 'the text'
+    /text\z/.should_not =~ 'text of'
+
+    regexp = Regexp.new('text\z')
+    regexp.should =~ 'the text'
+    regexp.should_not =~ 'text of'
+  end
+end

data/spec/opal/core/string/to_proc_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe "Symbol#to_proc" do
+  # bug #2417
+  it "correctly passes method name to #method_missing" do
+    obj = Object.new
+    def obj.method_missing(*args); args; end;
+    result = :a.to_proc.call(obj, 6, 7)
+    result.should == [:a, 6, 7]
+  end
+
+  it "correctly passes a block to #method_missing" do
+    obj = Object.new
+    block = ->{}
+    def obj.method_missing(*args, &block); block; end;
+    result = :a.to_proc.call(obj, 1, 2, 3, &block)
+    result.should == block
+  end
+end

data/spec/ruby_specs

@@ -176,6 +176,7 @@ ruby/library/base64
 ruby/library/bigdecimal
 !ruby/library/bigdecimal/util_spec
 ruby/library/date
+ruby/library/datetime
 ruby/library/delegate/delegator/send_spec
 ruby/library/erb/util/h_spec
 ruby/library/erb/util/html_escape_spec
@@ -203,4 +204,7 @@ ruby/library/singleton
 ruby/library/stringio/each_line_spec
 ruby/library/stringio/each_spec
 ruby/library/stringscanner
+
+ruby/library/time
+
 ruby/library/optionparser

data/spec/support/rewriters_helper.rb

@@ -1,13 +1,47 @@
 module RewritersHelper
-  def s(type, *children)
-    ::Opal::AST::Node.new(type, children)
+  module Common
+    def s(type, *children)
+      ::Opal::AST::Node.new(type, children)
+    end
+
+    def parse(source)
+      buffer = Opal::Parser::SourceBuffer.new('(eval)')
+      buffer.source = source
+      parser = Opal::Parser.default_parser
+      parser.parse(buffer)
+    end
+
+    # Parse, but drop the :top node
+    def ast_of(source)
+      parse(source).children.first
+    end
+  end
+
+  module DSL
+    def use_only_described_rewriter!
+      around(:each) do |e|
+        Opal::Rewriter.disable(except: described_class) { e.run }
+      end
+    end
+  end
+
+  include Common
+
+  def self.included(klass)
+    klass.extend(Common)
+    klass.extend(DSL)
+  end
+
+  def rewriter
+    described_class.new
   end
 
-  def rewritten(ast)
-    described_class.new.process(ast)
+  def rewritten(ast = input)
+    rewriter.process(ast)
   end
 
-  alias :rewrite :rewritten
+  alias rewrite rewritten
+  alias processed rewritten
 
   def expect_rewritten(ast)
     expect(rewritten(ast))
@@ -17,28 +51,15 @@ module RewritersHelper
     expect_rewritten(ast).to eq(ast)
   end
 
-  def parse(source)
-    buffer = Opal::Parser::SourceBuffer.new('(eval)')
-    buffer.source = source
-    parser = Opal::Parser.default_parser
-    parser.parse(buffer)
-  end
-
-  alias :ast_of :parse
-
   def parse_without_rewriting(source)
-    buffer = Opal::Parser::SourceBuffer.new('(eval)')
-    buffer.source = source
-    parser = Parser::Ruby31.new
-    parser.parse(buffer)
+    Opal::Rewriter.disable { parse(source) }
   end
 end
 
 RSpec.shared_examples 'it rewrites source-to-source' do |from_source, to_source|
   it "rewrites source #{from_source} to source #{to_source}" do
-    initial = ast_of(from_source)
-    rewritten = self.rewritten(initial)
-    expected = ast_of(to_source)
+    rewritten = parse(from_source)
+    expected = parse(to_source)
 
     expect(rewritten).to eq(expected)
   end
@@ -46,8 +67,7 @@ end
 
 RSpec.shared_examples 'it rewrites source-to-AST' do |from_source, to_ast|
   it "rewrites source #{from_source} to AST #{to_ast}" do
-    initial = ast_of(from_source)
-    rewritten = self.rewritten(initial)
+    rewritten = parse(from_source).children.first
 
     expect(rewritten).to eq(to_ast)
   end

data/stdlib/date/date_time.rb

@@ -0,0 +1,71 @@
+class DateTime < Date
+  class << self
+    def now
+      wrap Time.now
+    end
+
+    def parse(str)
+      wrap Time.parse(str)
+    end
+  end
+
+  def initialize(year = -4712, month = 1, day = 1, hours = 0, minutes = 0, seconds = 0, offset = 0, start = ITALY)
+    %x{
+      // Because of Gregorian reform calendar goes from 1582-10-04 to 1582-10-15.
+      // All days in between end up as 4 october.
+      if (year === 1582 && month === 10 && day > 4 && day < 15) {
+        day = 4;
+      }
+    }
+
+    @date = Time.new(year, month, day, hours, minutes, seconds, offset)
+    @start = start
+  end
+
+  def_delegators :@date, :min, :hour, :sec
+  alias minute min
+  alias second sec
+
+  def sec_fraction
+    @date.usec / 1_000_000r
+  end
+
+  alias second_fraction sec_fraction
+
+  def offset
+    @date.gmt_offset / (24 * 3600r)
+  end
+
+  def +(other)
+    ::DateTime.wrap @date + other
+  end
+
+  def -(other)
+    `if (Opal.is_a(other, #{::Date})) other = other.date`
+    result = @date - other
+    if result.is_a? ::Time
+      ::DateTime.wrap result
+    else
+      result
+    end
+  end
+
+  def new_offset(offset)
+    new_date = clone
+    offset = Time._parse_offset(offset)
+    `new_date.date.timezone = offset`
+    new_date
+  end
+
+  def to_datetime
+    self
+  end
+
+  def to_time
+    @date.dup
+  end
+
+  def to_date
+    Date.new(year, month, day)
+  end
+end