opal 0.3.44 → 0.4.0

data/spec/opal/parser/irb_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Opal::Parser do
+  describe "irb parser option" do
+    before do
+      @parser = Opal::Parser.new
+    end
+
+    it "creates Opal.irb_vars if it does not exist" do
+      $global["Opal"].irb_vars = nil
+      opal_eval_compiled(@parser.parse "nil", :irb => true)
+
+      ($global["Opal"].irb_vars == nil).should be_false
+    end
+
+    it "does not create Opal.irb_vars if :irb option not passed" do
+      $global["Opal"].irb_vars = nil
+      opal_eval_compiled(@parser.parse "nil")
+
+      ($global["Opal"].irb_vars == nil).should be_true
+    end
+
+    it "sets each s(:lasgn) in the top level onto irb_vars" do
+      opal_eval_compiled @parser.parse "foo = 42", :irb => true
+      $global["Opal"].irb_vars.foo.should == 42
+    end
+
+    it "gets each s(:lvar) in the top level from irb_vars" do
+      opal_eval_compiled @parser.parse "foo = 3.142; bar = foo", :irb => true
+      $global["Opal"].irb_vars.bar.should == 3.142
+    end
+
+    it "persists local vars between parses" do
+      opal_eval_compiled @parser.parse "foo = 'hello world'", :irb => true
+      opal_eval_compiled @parser.parse "bar = foo.upcase", :irb => true
+      $global["Opal"].irb_vars.bar.should == "HELLO WORLD"
+    end
+
+    it "can still call top level methods" do
+      opal_eval_compiled(@parser.parse("to_s", :irb => true)).should == "main"
+    end
+  end
+end

data/spec/opal/runtime/block_send_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+class RuntimeOpalBlockSendSpec
+  def simple
+    42
+  end
+
+  def yielder(&block)
+    yield 3.142
+  end
+end
+
+describe "Opal.block_send()" do
+  before do
+    @obj = RuntimeOpalBlockSendSpec.new
+  end
+
+  it "calls receiver with given method" do
+    `Opal.block_send(#{@obj}, 'simple')`.should == 42
+  end
+
+  it "calls method with given block" do
+    val = nil
+    p = proc { |a| val = a }
+    `Opal.block_send(#{@obj}, 'yielder', p)`
+    val.should == 3.142
+  end
+end

data/spec/opal/source_map_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'opal-source-maps'
+
+describe Opal::SourceMap do
+  before do
+    pathname = 'foo.rb'
+    @source = Opal.parse('1 + 1', pathname)
+    @map    = Opal::SourceMap.new(@source, pathname)
+  end
+
+  it 'source has the magic comments' do
+    Opal::SourceMap::FILE_REGEXP.should =~ @source
+    Opal::SourceMap::LINE_REGEXP.should =~ @source
+  end
+
+  it 'does not blow while generating the map' do
+    lambda { @map.as_json }.should_not raise_error
+  end
+end

data/spec/opal/string/freeze_spec.rb

@@ -0,0 +1,15 @@
+# Just accepting reality of immutability
+
+describe "String#freeze" do
+  it "is always frozen" do
+    s = "a string"
+    s.frozen?.should be_true
+    s.freeze
+    s.frozen?.should be_true
+  end
+
+  it "returns self" do
+    s = "a string"
+    s.freeze.should equal(s)
+  end
+end

data/spec/ospec/runner.rb

@@ -2,6 +2,8 @@
 require 'date'
 require 'observer'
 
+ENV['MSPEC_RUNNER'] = true
+
 class OSpecFilter
   def self.main
     @main ||= self.new
@@ -176,6 +178,7 @@ module Kernel
   # FIXME: remove
   def ruby_version_is(*); end
   def pending(*); end
+  def language_version(*); end
 end
 
 module MSpec

data/spec/parser/str_spec.rb

@@ -99,5 +99,9 @@ describe "Strings" do
       opal_parse("?a").should == [:str, "a"]
       opal_parse("?&").should == [:str, "&"]
     end
+
+    it "parses a string sexp as a command arg" do
+      opal_parse("foo ?a").should == [:call, nil, :foo, [:arglist, [:str, "a"]]]
+    end
   end
 end

data/spec/rubyspec/core/enumerable/fixtures/classes.rb

@@ -120,14 +120,14 @@ module EnumerableSpecs
       @values
     end
   end
-  
+
   class EnumConvertable
     attr_accessor :called
     attr_accessor :sym
     def initialize(delegate)
       @delegate = delegate
     end
-    
+
     def to_enum(sym)
       self.called = :to_enum
       self.sym = sym

data/spec/rubyspec/core/enumerable/none_spec.rb

@@ -0,0 +1,68 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+#ruby_version_is "1.8.7" do
+  describe "Enumerable#none?" do
+    it "returns true if none of the elements in self are true" do
+      e = EnumerableSpecs::Numerous.new(false, nil, false)
+      e.none?.should be_true
+    end
+
+    it "returns false if at least one of the elements in self are true" do
+      e = EnumerableSpecs::Numerous.new(false, nil, true, false)
+      e.none?.should be_false
+    end
+
+    it "gathers whole arrays as elements when each yields multiple" do
+      multi = EnumerableSpecs::YieldsMultiWithFalse.new
+      multi.none?.should be_false
+    end
+  end
+
+  describe "Enumerable#none? with a block" do
+    before(:each) do
+      @e = EnumerableSpecs::Numerous.new(1,1,2,3,4)
+    end
+
+    it "passes each element to the block in turn until it returns true" do
+      acc = []
+      @e.none? {|e| acc << e; false }
+      acc.should == [1,1,2,3,4]
+    end
+
+    it "stops passing elements to the block when it returns true" do
+      acc = []
+      @e.none? {|e| acc << e; e == 3 ? true : false }
+      acc.should == [1,1,2,3]
+    end
+
+    it "returns true if the block never returns true" do
+      @e.none? {|e| false }.should be_true
+    end
+
+    it "returns false if the block ever returns true" do
+      @e.none? {|e| e == 3 ? true : false }.should be_false
+    end
+
+    ruby_version_is ""..."1.9" do
+      it "gathers whole arrays as elements when each yields multiple" do
+        multi = EnumerableSpecs::YieldsMulti.new
+        multi.none? {|e| e == 1 }.should be_true
+      end
+    end
+
+    ruby_version_is "1.9" do
+      it "gathers initial args as elements when each yields multiple" do
+        multi = EnumerableSpecs::YieldsMulti.new
+        multi.none? {|e| e == [1, 2] }.should be_true
+      end
+    end
+
+    it "yields multiple arguments when each yields multiple" do
+      multi = EnumerableSpecs::YieldsMulti.new
+      yielded = []
+      multi.none? {|e, i| yielded << [e, i] }
+      yielded.should == [[1, 2]]
+    end
+  end
+#end

data/spec/rubyspec/core/enumerable/sort_by_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+describe "Enumerable#sort_by" do
+  it "returns an array of elements ordered by the result of block" do
+    a = EnumerableSpecs::Numerous.new("once", "upon", "a", "time")
+    a.sort_by { |i| i[0] }.should == ["a", "once", "time", "upon"]
+  end
+
+  it "sorts the object by the given attribute" do
+    a = EnumerableSpecs::SortByDummy.new("fooo")
+    b = EnumerableSpecs::SortByDummy.new("bar")
+
+    ar = [a, b].sort_by { |d| d.s }
+    ar.should == [b, a]
+  end
+
+  ruby_version_is "1.8.7" do
+    it "returns an Enumerator when a block is not supplied" do
+      a = EnumerableSpecs::Numerous.new("a","b")
+      a.sort_by.should be_an_instance_of(enumerator_class)
+      a.to_a.should == ["a", "b"]
+    end
+  end
+
+  it "gathers whole arrays as elements when each yields multiple" do
+    # TODO: fix support for yielding multiple values (see fixtures/classes)
+    multi = EnumerableSpecs::YieldsMulti.new
+    multi.sort_by {|e| e.size}.should == [[1, 2], [3, 4, 5], [6, 7, 8, 9]]
+  end
+end

data/spec/rubyspec/core/hash/size_spec.rb

@@ -7,4 +7,4 @@ describe "Hash#size" do
     Hash.new(5).size.should == 0
     Hash.new { 5 }.size.should == 0
   end
-end
+end

data/spec/rubyspec/core/hash/to_native_spec.rb

@@ -1,5 +1,5 @@
-describe "Hash#to_native" do
+describe "Hash#to_n" do
   it "should return a js object representing hash" do
-    Hash.from_native({:a => 100, :b => 200}.to_native).should == {:a => 100, :b => 200}
+    Hash.new({:a => 100, :b => 200}.to_n).should == {:a => 100, :b => 200}
   end
-end
+end

data/spec/rubyspec/core/string/fixtures/classes.rb

@@ -0,0 +1,49 @@
+class Object
+  # This helper is defined here rather than in MSpec because
+  # it is only used in #unpack specs.
+  def unpack_format(count=nil, repeat=nil)
+    format = "#{instance_variable_get(:@method)}#{count}"
+    format *= repeat if repeat
+    format
+  end
+end
+
+module StringSpecs
+  class MyString < String; end
+  class MyArray < Array; end
+  class MyRange < Range; end
+
+  class SubString < String
+    attr_reader :special
+
+    def initialize(str=nil)
+      @special = str
+    end
+  end
+
+  class InitializeString < String
+    attr_reader :ivar
+
+    def initialize(other)
+      super
+      @ivar = 1
+    end
+
+    def initialize_copy(other)
+      ScratchPad.record object_id
+    end
+  end
+
+  module StringModule
+    def repr
+      1
+    end
+  end
+
+  class StringWithRaisingConstructor < String
+    def initialize(str)
+      raise ArgumentError.new('constructor was called') unless str == 'silly:string'
+      self.replace(str)
+    end
+  end
+end

data/spec/rubyspec/core/string/index_spec.rb

@@ -0,0 +1,405 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes.rb', __FILE__)
+
+describe "String#index" do
+  it "raises a TypeError if passed nil" do
+    lambda { "abc".index nil }.should raise_error(TypeError)
+  end
+
+  it "raises a TypeError if passed a boolean" do
+    lambda { "abc".index true }.should raise_error(TypeError)
+  end
+
+  not_compliant_on :opal do
+    it "raises a TypeError if passed a Symbol" do
+      lambda { "abc".index :a }.should raise_error(TypeError)
+    end
+
+    it "calls #to_str to convert the first argument" do
+      char = mock("string index char")
+      char.should_receive(:to_str).and_return("b")
+      "abc".index(char).should == 1
+    end
+
+    it "calls #to_int to convert the second argument" do
+      offset = mock("string index offset")
+      offset.should_receive(:to_int).and_return(1)
+      "abc".index("c", offset).should == 2
+    end
+  end
+
+  ruby_version_is ""..."1.9" do
+    it "does not call #to_int to convert the first argument" do
+      char = mock("string index char")
+      char.should_not_receive(:to_int)
+      lambda { "abc".index char }.should raise_error(TypeError)
+    end
+  end
+
+  ruby_version_is "1.9" do
+    it "raises a TypeError if passed a Fixnum" do
+      lambda { "abc".index 97 }.should raise_error(TypeError)
+    end
+  end
+end
+
+ruby_version_is ""..."1.9" do
+  describe "String#index with Fixnum" do
+    it "returns the index of the first occurrence of the given character" do
+      "hello".index(?e).should == 1
+      "hello".index(?l).should == 2
+    end
+
+    it "character values over 255 (256th ASCII character) always result in nil" do
+      # A naive implementation could try to use % 256
+      "hello".index(?e + 256 * 3).should == nil
+    end
+
+    it "negative character values always result in nil" do
+      # A naive implementation could try to use % 256
+      "hello".index(-(256 - ?e)).should == nil
+    end
+
+    it "starts the search at the given offset" do
+      "blablabla".index(?b, 0).should == 0
+      "blablabla".index(?b, 1).should == 3
+      "blablabla".index(?b, 2).should == 3
+      "blablabla".index(?b, 3).should == 3
+      "blablabla".index(?b, 4).should == 6
+      "blablabla".index(?b, 5).should == 6
+      "blablabla".index(?b, 6).should == 6
+
+      "blablabla".index(?a, 0).should == 2
+      "blablabla".index(?a, 2).should == 2
+      "blablabla".index(?a, 3).should == 5
+      "blablabla".index(?a, 4).should == 5
+      "blablabla".index(?a, 5).should == 5
+      "blablabla".index(?a, 6).should == 8
+      "blablabla".index(?a, 7).should == 8
+      "blablabla".index(?a, 8).should == 8
+    end
+
+    it "starts the search at offset + self.length if offset is negative" do
+      str = "blablabla"
+
+      [?a, ?b].each do |needle|
+        (-str.length .. -1).each do |offset|
+          p offset
+          str.index(needle, offset).should ==
+          str.index(needle, offset + str.length)
+        end
+      end
+
+      "blablabla".index(?b, -9).should == 0
+    end
+
+    it "returns nil if offset + self.length is < 0 for negative offsets" do
+      "blablabla".index(?b, -10).should == nil
+      "blablabla".index(?b, -20).should == nil
+    end
+
+    it "returns nil if the character isn't found" do
+      "hello".index(0).should == nil
+
+      "hello".index(?H).should == nil
+      "hello".index(?z).should == nil
+      "hello".index(?e, 2).should == nil
+
+      "blablabla".index(?b, 7).should == nil
+      "blablabla".index(?b, 10).should == nil
+
+      "blablabla".index(?a, 9).should == nil
+      "blablabla".index(?a, 20).should == nil
+    end
+  end
+end
+
+describe "String#index with String" do
+  it "behaves the same as String#index(char) for one-character strings" do
+    ["blablabla", "hello cruel world...!"].each do |str|
+      str.split("").uniq.each do |str|
+        chr = str[0]
+        str.index(str).should == str.index(chr)
+
+        0.upto(str.size + 1) do |start|
+          str.index(str, start).should == str.index(chr, start)
+        end
+
+        (-str.size - 1).upto(-1) do |start|
+          str.index(str, start).should == str.index(chr, start)
+        end
+      end
+    end
+  end
+
+  it "returns the index of the first occurrence of the given substring" do
+    "blablabla".index("").should == 0
+    "blablabla".index("b").should == 0
+    "blablabla".index("bla").should == 0
+    "blablabla".index("blabla").should == 0
+    "blablabla".index("blablabla").should == 0
+
+    "blablabla".index("l").should == 1
+    "blablabla".index("la").should == 1
+    "blablabla".index("labla").should == 1
+    "blablabla".index("lablabla").should == 1
+
+    "blablabla".index("a").should == 2
+    "blablabla".index("abla").should == 2
+    "blablabla".index("ablabla").should == 2
+  end
+
+  it "doesn't set $~" do
+    $~ = nil
+
+    'hello.'.index('ll')
+    $~.should == nil
+  end
+
+  it "ignores string subclasses" do
+    "blablabla".index(StringSpecs::MyString.new("bla")).should == 0
+    StringSpecs::MyString.new("blablabla").index("bla").should == 0
+    StringSpecs::MyString.new("blablabla").index(StringSpecs::MyString.new("bla")).should == 0
+  end
+
+  it "starts the search at the given offset" do
+    "blablabla".index("bl", 0).should == 0
+    "blablabla".index("bl", 1).should == 3
+    "blablabla".index("bl", 2).should == 3
+    "blablabla".index("bl", 3).should == 3
+
+    "blablabla".index("bla", 0).should == 0
+    "blablabla".index("bla", 1).should == 3
+    "blablabla".index("bla", 2).should == 3
+    "blablabla".index("bla", 3).should == 3
+
+    "blablabla".index("blab", 0).should == 0
+    "blablabla".index("blab", 1).should == 3
+    "blablabla".index("blab", 2).should == 3
+    "blablabla".index("blab", 3).should == 3
+
+    "blablabla".index("la", 1).should == 1
+    "blablabla".index("la", 2).should == 4
+    "blablabla".index("la", 3).should == 4
+    "blablabla".index("la", 4).should == 4
+
+    "blablabla".index("lab", 1).should == 1
+    "blablabla".index("lab", 2).should == 4
+    "blablabla".index("lab", 3).should == 4
+    "blablabla".index("lab", 4).should == 4
+
+    "blablabla".index("ab", 2).should == 2
+    "blablabla".index("ab", 3).should == 5
+    "blablabla".index("ab", 4).should == 5
+    "blablabla".index("ab", 5).should == 5
+
+    "blablabla".index("", 0).should == 0
+    "blablabla".index("", 1).should == 1
+    "blablabla".index("", 2).should == 2
+    "blablabla".index("", 7).should == 7
+    "blablabla".index("", 8).should == 8
+    "blablabla".index("", 9).should == 9
+  end
+
+  it "starts the search at offset + self.length if offset is negative" do
+    str = "blablabla"
+
+    ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|
+      (-str.length .. -1).each do |offset|
+        str.index(needle, offset).should ==
+        str.index(needle, offset + str.length)
+      end
+    end
+  end
+
+  it "returns nil if the substring isn't found" do
+    "blablabla".index("B").should == nil
+    "blablabla".index("z").should == nil
+    "blablabla".index("BLA").should == nil
+    "blablabla".index("blablablabla").should == nil
+    "blablabla".index("", 10).should == nil
+    "blablabla".index("", 10).should == nil
+
+    "12345".index("", 6).should == nil
+    "hello".index("he", 1).should == nil
+    "hello".index("he", 2).should == nil
+  end
+
+  with_feature :encoding do
+    it "returns the character index of a multibyte character" do
+      "ありがとう".index("が").should == 2
+    end
+
+    it "returns the character index after offset" do
+      "われわれ".index("わ", 1).should == 2
+    end
+
+    it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
+      char = "れ".encode Encoding::EUC_JP
+      lambda do
+        "あれ".index char
+      end.should raise_error(Encoding::CompatibilityError)
+    end
+  end
+end
+
+describe "String#index with Regexp" do
+  it "behaves the same as String#index(string) for escaped string regexps" do
+    ["blablabla", "hello cruel world...!"].each do |str|
+      ["", "b", "bla", "lab", "o c", "d."].each do |needle|
+        regexp = Regexp.new(Regexp.escape(needle))
+        str.index(regexp).should == str.index(needle)
+
+        0.upto(str.size + 1) do |start|
+          str.index(regexp, start).should == str.index(needle, start)
+        end
+
+        (-str.size - 1).upto(-1) do |start|
+          str.index(regexp, start).should == str.index(needle, start)
+        end
+      end
+    end
+  end
+
+  it "returns the index of the first match of regexp" do
+    "blablabla".index(/bla/).should == 0
+    "blablabla".index(/BLA/i).should == 0
+
+    "blablabla".index(/.{0}/).should == 0
+    "blablabla".index(/.{6}/).should == 0
+    "blablabla".index(/.{9}/).should == 0
+
+    "blablabla".index(/.*/).should == 0
+    "blablabla".index(/.+/).should == 0
+
+    "blablabla".index(/lab|b/).should == 0
+
+    not_compliant_on :opal do
+      "blablabla".index(/\A/).should == 0
+      "blablabla".index(/\Z/).should == 9
+      "blablabla".index(/\z/).should == 9
+      "blablabla\n".index(/\Z/).should == 9
+      "blablabla\n".index(/\z/).should == 10
+    end
+
+    "blablabla".index(/^/).should == 0
+    "\nblablabla".index(/^/).should == 0
+
+    not_compliant_on :opal do
+      "b\nablabla".index(/$/).should == 1
+      "bl\nablabla".index(/$/).should == 2
+    end
+
+    "blablabla".index(/.l./).should == 0
+  end
+
+  it "sets $~ to MatchData of match and nil when there's none" do
+    'hello.'.index(/.(.)/)
+    $~[0].should == 'he'
+
+    'hello.'.index(/not/)
+    $~.should == nil
+  end
+
+  it "starts the search at the given offset" do
+    "blablabla".index(/.{0}/, 5).should == 5
+    "blablabla".index(/.{1}/, 5).should == 5
+    "blablabla".index(/.{2}/, 5).should == 5
+    "blablabla".index(/.{3}/, 5).should == 5
+    "blablabla".index(/.{4}/, 5).should == 5
+
+    "blablabla".index(/.{0}/, 3).should == 3
+    "blablabla".index(/.{1}/, 3).should == 3
+    "blablabla".index(/.{2}/, 3).should == 3
+    "blablabla".index(/.{5}/, 3).should == 3
+    "blablabla".index(/.{6}/, 3).should == 3
+
+    "blablabla".index(/.l./, 0).should == 0
+    "blablabla".index(/.l./, 1).should == 3
+    "blablabla".index(/.l./, 2).should == 3
+    "blablabla".index(/.l./, 3).should == 3
+
+    "xblaxbla".index(/x./, 0).should == 0
+    "xblaxbla".index(/x./, 1).should == 4
+    "xblaxbla".index(/x./, 2).should == 4
+
+    not_compliant_on :opal do
+      "blablabla\n".index(/\Z/, 9).should == 9
+    end
+  end
+
+  it "starts the search at offset + self.length if offset is negative" do
+    str = "blablabla"
+
+    ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|
+      (-str.length .. -1).each do |offset|
+        str.index(needle, offset).should ==
+        str.index(needle, offset + str.length)
+      end
+    end
+  end
+
+  it "returns nil if the substring isn't found" do
+    "blablabla".index(/BLA/).should == nil
+
+    "blablabla".index(/.{10}/).should == nil
+    "blaxbla".index(/.x/, 3).should == nil
+    "blaxbla".index(/..x/, 2).should == nil
+  end
+
+  it "returns nil if the Regexp matches the empty string and the offset is out of range" do
+    "ruby".index(//,12).should be_nil
+  end
+
+  not_compliant_on :opal do
+    it "supports \\G which matches at the given start offset" do
+      "helloYOU.".index(/\GYOU/, 5).should == 5
+      "helloYOU.".index(/\GYOU/).should == nil
+
+      re = /\G.+YOU/
+      # The # marks where \G will match.
+      [
+        ["#hi!YOUall.", 0],
+        ["h#i!YOUall.", 1],
+        ["hi#!YOUall.", 2],
+        ["hi!#YOUall.", nil]
+      ].each do |spec|
+
+        start = spec[0].index("#")
+        str = spec[0].delete("#")
+
+        str.index(re, start).should == spec[1]
+      end
+    end
+  end
+
+  not_compliant_on :opal do
+    it "converts start_offset to an integer via to_int" do
+      obj = mock('1')
+      obj.should_receive(:to_int).and_return(1)
+      "RWOARW".index(/R./, obj).should == 4
+    end
+  end
+
+  with_feature :encoding do
+    it "returns the character index of a multibyte character" do
+      "ありがとう".index(/が/).should == 2
+    end
+
+    it "returns the character index after offset" do
+      "われわれ".index(/わ/, 1).should == 2
+    end
+
+    it "treats the offset as a character index" do
+      "われわわれ".index(/わ/, 3).should == 3
+    end
+
+    it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
+      re = Regexp.new "れ".encode(Encoding::EUC_JP)
+      lambda do
+        "あれ".index re
+      end.should raise_error(Encoding::CompatibilityError)
+    end
+  end
+end