opal 1.4.1 → 1.5.0.rc1

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

@@ -19,3 +19,29 @@ describe 'super without explicit argument' do
     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 = nil
+
+    c = Class.new(ABlockWithSuperSpec) {
+      define_method :foo, ABlockWithSuperSpec::BLOCK
+      define_method :bar, ABlockWithSuperSpec::BLOCK
+      define_method :foo_bar, ABlockWithSuperSpec::BLOCK
+    }
+
+    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/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

data/stdlib/date/formatters.rb

@@ -0,0 +1,28 @@
+class Date
+  def self.def_formatter(*args, **kwargs)
+    Time.def_formatter(*args, **kwargs, on: self)
+  end
+
+  def_formatter :asctime, '%c'
+  alias ctime asctime
+  def_formatter :iso8601, '%F'
+  alias xmlschema iso8601
+  def_formatter :rfc3339, '%FT%T%:z'
+  def_formatter :rfc2822, '%a, %-d %b %Y %T %z'
+  alias rfc822 rfc2822
+  def_formatter :httpdate, '%a, %d %b %Y %T GMT', utc: true
+  def_formatter :jisx0301, '%J'
+
+  alias to_s iso8601
+end
+
+class DateTime < Date
+  def_formatter :xmlschema, '%FT%T', fractions: true, tz_format: '%:z'
+  alias iso8601 xmlschema
+  alias rfc3339 xmlschema
+  def_formatter :jisx0301, '%JT%T', fractions: true, tz_format: '%:z'
+
+  alias to_s xmlschema
+
+  def_formatter :zone, '%:z'
+end

data/stdlib/date/infinity.rb

@@ -0,0 +1,73 @@
+class Date
+  class Infinity < Numeric
+    include Comparable
+
+    def initialize(d = 1)
+      @d = d <=> 0
+    end
+
+    attr_reader :d
+
+    def zero?
+      false
+    end
+
+    def finite?
+      false
+    end
+
+    def infinite?
+      d.nonzero?
+    end
+
+    def nan?
+      d.zero?
+    end
+
+    def abs
+      self.class.new
+    end
+
+    def -@
+      self.class.new(-d)
+    end
+
+    def +@
+      self.class.new(+d)
+    end
+
+    def <=>(other)
+      case other
+      when Infinity
+        d <=> other.d
+      when Numeric
+        d
+      else
+        begin
+          l, r = other.coerce(self)
+          l <=> r
+        rescue NoMethodError
+          nil
+        end
+      end
+    end
+
+    def coerce(other)
+      case other
+      when Numeric
+        [-d, d]
+      else
+        super
+      end
+    end
+
+    def to_f
+      return 0 if @d == 0
+      if @d > 0
+        Float::INFINITY
+      else
+        -Float::INFINITY
+      end
+    end
+  end
+end