opal 0.3.43 → 0.3.44

data/spec/rubyspec/core/module/const_set_spec.rb

@@ -1,7 +1,6 @@
 require File.expand_path('../../../spec_helper', __FILE__)
 require File.expand_path('../../../fixtures/constants', __FILE__)
 
-
 module ConstantSpecs
 end
 
@@ -37,7 +36,8 @@ describe "Module#const_set" do
     lambda { ConstantSpecs.const_set "::Name", 1 }.should raise_error(NameError)
   end
 
-  it "raises a NameError if the name contains non-alphabetic characters except '_'" do
+  it "raises a NameError if the name contains non-word characters" do
+    # underscore (i.e., _) is a valid word character
     ConstantSpecs.const_set("CS_CONST404", :const404).should == :const404
     lambda { ConstantSpecs.const_set "Name=", 1 }.should raise_error(NameError)
     lambda { ConstantSpecs.const_set "Name?", 1 }.should raise_error(NameError)

data/spec/rubyspec/core/module/constants_spec.rb

@@ -0,0 +1,49 @@
+module ConstantsSpecsModule
+  MOD_CONST1 = "1"
+  MOD_CONST2 = "2"
+  MOD_CONST3 = "3"
+
+  module Foo
+    FOO = "foo"
+  end
+end
+
+class ConstantsSpecsClass
+  CLASS_CONST1 = "1"
+  CLASS_CONST2 = "2"
+  CLASS_CONST3 = "3"
+end
+
+class SubConstantsSpecsClass < ConstantsSpecsClass
+  CLASS_CONST4 = "4"
+end
+
+describe "Module#constants" do
+  it "should return constants in global scope when called from Module or Class" do
+    result = Module.constants
+    result.should include("Module", "Object", "TrueClass", "FalseClass", "RUBY_ENGINE")
+    result2 = Class.constants
+    result.should == result2
+  end
+
+  it "should only return constants and child modules defined directly on module" do
+    result = ConstantsSpecsModule.constants
+    result.size.should == 4
+    result.should include("MOD_CONST1", "MOD_CONST2", "MOD_CONST3", "Foo")
+    result = ConstantsSpecsModule::Foo.constants
+    result.size.should == 1
+    result.should include("FOO")
+  end
+  
+  it "should only return constants defined directly on class" do
+    result = ConstantsSpecsClass.constants
+    result.size.should == 3
+    result.should include("CLASS_CONST1", "CLASS_CONST2", "CLASS_CONST3")
+  end
+
+  it "should include constants inherited from superclass" do
+    result = SubConstantsSpecsClass.constants
+    result.size.should == 4
+    result.should include("ClASS_CONST4", "CLASS_CONST1", "CLASS_CONST2", "CLASS_CONST3")
+  end
+end

data/spec/rubyspec/core/regexp/match_spec.rb

@@ -17,6 +17,71 @@ describe "Regexp#match on a successful match" do
     /1/.match(nil)
     $~.should be_nil
   end
+
+  it "returns a MatchData object that exposes pre_match and post_match strings for inline regexp" do
+    re = /note: /i
+    result = re.match('preamble NOTE: This is just a test.')
+    result.pre_match.should == 'preamble '
+    result.post_match.should == 'This is just a test.'
+  end
+
+  it "returns a MatchData object that exposes pre_match and post_match strings for constructed regexp" do
+    re = Regexp.new(/note: /i)
+    result = re.match('preamble NOTE: This is just a test.')
+    result.pre_match.should == 'preamble '
+    result.post_match.should == 'This is just a test.'
+  end
+
+  it "sets $` and $' variables on match" do
+    re = /note: /i
+    re.match('preamble NOTE: This is just a test.')
+    $`.should == 'preamble '
+    $'.should == 'This is just a test.'
+  end
+
+  it "resets $` and $' when no match" do
+    re = /note: /i
+    re.match('preamble NOTE: This is just a test.')
+    $`.should_not be_nil
+    $'.should_not be_nil
+    re.match(nil)
+    $`.should be_nil
+    $'.should be_nil
+  end
+
+  it "returns a MatchData object that exposes match array" do
+    re = /(note): (.*)/i
+    result = re.match('preamble NOTE: This is just a test.')
+    result.length.should == 3
+    result.size.should == 3
+    result.captures.should == ['NOTE', 'This is just a test.']
+    result.to_a.should == ['NOTE: This is just a test.', 'NOTE', 'This is just a test.']
+    result[1].should == ['NOTE']
+    result.values_at(1, -1).should == ['NOTE', 'This is just a test.']
+    result.values_at(-3, 0).should == [nil, 'NOTE: This is just a test.']
+  end
+
+  it "replaces undefined with nil in match array" do
+    re = /(a(b)c)?(def)/
+    result = re.match("def")
+    result.to_a.size.should == 4
+    result.to_a.should == ["def", nil, nil, "def"]
+  end
+
+  it "returns a MatchData object that exposes regexp and string" do
+    re = /(note): (.*)/i
+    result = re.match('preamble NOTE: This is just a test.')
+    result.string.should == 'preamble NOTE: This is just a test.'
+    result.regexp.to_s.should == re.to_s
+  end
+
+  it "returns a MatchData object that provides access to offset of 0th element only" do
+    re = /(note): (.*)/i
+    result = re.match('preamble NOTE: This is just a test.')
+    result.begin(0).should == 9
+    result.begin(1).should == 9
+    lambda { result.begin(2) }.should raise_error(ArgumentError)
+  end
 end
 
 describe :regexp_match do
@@ -27,4 +92,4 @@ describe :regexp_match do
   it "returns nil if the object is nil" do
     /xyz/.match(nil).should be_nil
   end
-end
+end

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

@@ -0,0 +1,71 @@
+describe "String#center" do
+
+  it "does nothing if the specified width is lower than the string's size" do
+    "abc".center(2).should == "abc"
+  end
+
+  it "center a string with a strange pattern" do
+    "ab".center(17, '12345').should == "1234512ab12345123"
+  end
+
+  describe "centers an odd string with a odd number of padding strings" do
+    it "uses default padding" do
+      "abc".center(5).should == " abc "
+    end
+
+    it "uses a custum padding" do
+      "abc".center(5, '-').should == "-abc-"
+    end
+
+    it "works with bigger patterns" do
+      "abc".center(7, '~!{').should == "~!abc~!"
+    end
+
+    it "repeats the pattern if needed" do
+      "abc".center(10, '~!{').should == "~!{abc~!{~"
+    end
+  end
+
+  describe "centers an even string with an odd number of padding strings" do
+    it "uses default padding" do
+      "abcd".center(7).should == " abcd  "
+    end
+
+    it "works with bigger patterns" do
+      "abcd".center(7, '~!{').should == "~abcd~!"
+    end
+
+    it "repeats the pattern if needed" do
+      "abcd".center(11, '~!{').should == "~!{abcd~!{~"
+    end
+  end
+
+  describe "centers an even string with an even number of padding strings" do
+    it "uses default padding" do
+      "abcd".center(8).should == "  abcd  "
+    end
+
+    it "works with bigger patterns" do
+      "abcd".center(8, '~!{').should == "~!abcd~!"
+    end
+
+    it "repeats the pattern if needed" do
+      "abcd".center(12, '~!{').should == "~!{~abcd~!{~"
+    end
+  end
+
+  describe "center an odd string with an even number" do
+    it "uses default padding" do
+      "abc".center(4).should == "abc "
+    end
+
+    it "works with bigger patterns" do
+      "abc".center(4, '~!{').should == "abc~"
+    end
+
+    it "repeats the pattern if needed" do
+      "abc".center(12, '~!{').should == "~!{~abc~!{~!"
+    end
+  end
+
+end

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

@@ -30,6 +30,11 @@ describe "String#chomp with separator" do
     "hello\n\r\n".chomp("\r\n").should == "hello\n"
   end
 
+  it "removes separator character" do
+    "hello)".chomp(")").should == "hello"
+    "hello*)".chomp("*)").should == "hello"
+  end
+
   it "returns self if the separator is nil" do
     "hello\n\n".chomp(nil).should == "hello\n\n"
   end
@@ -40,4 +45,4 @@ describe "String#chomp with separator" do
     "".chomp("").should == ""
     "".chomp(nil).should == ""
   end
-end
+end

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

@@ -0,0 +1,8 @@
+describe "String#clone" do
+  it "produces a copy of the original" do
+    str = "a string"
+    str_copy = str.dup
+    str_copy.should == str
+    str_copy.object_id.should_not == str.object_id
+  end
+end

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

@@ -0,0 +1,8 @@
+describe "String#dup" do
+  it "produces a copy of the original" do
+    str = "a string"
+    str_copy = str.dup
+    str_copy.should == str
+    str_copy.object_id.should_not == str.object_id
+  end
+end

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

@@ -9,4 +9,8 @@ describe "String#end_with?" do
   it "returns true only if any ending match" do
     "hello".end_with?('x', 'y', 'llo', 'z').should be_true
   end
-end
+
+  it "should not return true if suffix length is 1 greater than string length" do
+    "-".end_with?(' +').should be_false
+  end
+end

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

@@ -14,4 +14,18 @@ describe "String#gsub with pattern and block" do
     "hello!".gsub(/(.)(.)/) { |*a| a.inspect }.should == '["he"]["ll"]["o!"]'
     "hello".gsub('l') { 'x'}.should == 'hexxo'
   end
-end
+
+  it "should set the global match variable $~ inside block" do
+    match_data = nil
+    "hello".gsub(/(.)(.)(.)(.)(.)/) { match_data = $~; $~[1] }.should == "h"
+    match_data.length.should == 6
+    match_data.should == ["hello", "h", "e", "l", "l", "o"]
+  end
+
+  it "should replace match group with undefined value with nil in match array" do
+    match_data = nil
+    "def".gsub(/(a(b)c)?d(e)f/) { match_data = $~; $~[3] }.should == "e"
+    match_data.length.should == 4
+    match_data.should == ["def", nil, nil, "e"]
+  end
+end

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

@@ -0,0 +1,9 @@
+describe "String#lines" do
+  pending "should split on the default record separator and return enumerator if not block is given" do
+    "first\nsecond\nthird".lines.class.should == Enumerator
+    "first\nsecond\nthird".lines.entries.class.should == Array
+    "first\nsecond\nthird".lines.entries.size.should == 3
+    "first\nsecond\nthird".lines.entries.should == ["first\n", "second\n", "third"]
+    "first\nsecond\nthird\n".lines.entries.should == ["first\n", "second\n", "third\n"]
+  end
+end

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

@@ -0,0 +1,17 @@
+describe "String#ljust" do
+  it "does nothing if the specified width is lower than the string's size" do
+    "abc".ljust(2).should == "abc"
+  end
+
+  it "uses default padding" do
+    "abc".ljust(5).should == "  abc"
+  end
+
+  it "uses a custum padding" do
+    "abc".ljust(5, '-').should == "--abc"
+  end
+
+  it "uses wisely a bigger pattern" do
+    "abc".ljust(10, "123").should == "1231231abc"
+  end
+end

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

@@ -1,10 +1,18 @@
 describe "String#=~" do
   it "sets $~ to MatchData when there is a match and nil then there's none" do
-    'hello' =~ /./
-    $~[0].should == 'h'
+    'hello' =~ /(l)(l)/
+    $~.should be_kind_of(MatchData)
+    $~[0].should == "ll"
+    $~.captures.should == ["l", "l"]
+    $~.pre_match.should == "he"
+    $`.should == "he"
+    $~.post_match.should == "o"
+    $'.should == "o"
 
     'hello' =~ /not/
     $~.should == nil
+    $`.should == nil
+    $'.should == nil
   end
 end
 
@@ -24,4 +32,18 @@ describe "String#match" do
     'hello'.match(/X/)
     $~.should == nil
   end
-end
+
+  it "sets $` to pre_match and $' to post_match or nil when there is no match" do
+    result = 'hello'.match(/ll/)
+    $`.should == 'he'
+    $'.should == 'o'
+    result.pre_match.should == 'he'
+    result.post_match.should == 'o'
+
+    'hello'.match(/X/)
+    $`.should == nil
+    $'.should == nil
+    result.pre_match.should == 'he'
+    result.post_match.should == 'o'
+  end
+end

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

@@ -0,0 +1,50 @@
+describe "String#rindex" do
+  it "should return index of last occurrence of search string" do
+    "camal".rindex("a").should == 3
+  end
+
+  it "should return index of last occurrence of RegExp match" do
+    "camal".rindex(/a/).should == 3
+  end
+
+  it "should return nil if non-empty search is not found" do
+    "camal".rindex("x").should be_nil
+  end
+
+  it "should return nil if RegExp is not matched" do
+    "camal".rindex(/x/).should be_nil
+  end
+
+  it "should return 0 if string and search string are both empty" do
+    "".rindex("").should == 0
+  end
+
+  it "should return index of last occurrence of search string from offset" do
+    "camal".rindex("a", 1).should == 1
+    "camal".rindex(/a/, 4).should == 3
+    "camal".rindex("a", -4).should == 1
+    "camal".rindex("a", -2).should == 3
+  end
+
+  it "should return index of last occurrence of RegExp match from offset" do
+    "camal".rindex(/a/, 1).should == 1
+    "camal".rindex(/a/, 4).should == 3
+    "camal".rindex(/a/, -4).should == 1
+    "camal".rindex(/a/, -2).should == 3
+  end
+
+  it "should return nil of last occurrence is after offset" do
+    "camal".rindex("a", 0).should be_nil
+    "camal".rindex("a", -5).should be_nil
+  end
+
+  it "should return nil of last occurrence of RegExp match is after offset" do
+    "camal".rindex(/a/, 0).should be_nil
+    "camal".rindex(/a/, -5).should be_nil
+  end
+
+  it "should raise TypeError if search is not String or RegExp" do
+    lambda { "camal".rindex(nil) }.should raise_error(TypeError)
+    lambda { "camal".rindex(1) }.should raise_error(TypeError)
+  end
+end

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

@@ -0,0 +1,17 @@
+describe "String#rjust" do
+  it "does nothing if the specified width is lower than the string's size" do
+    "abc".rjust(2).should == "abc"
+  end
+
+  it "uses default padding" do
+    "abc".rjust(5).should == "abc  "
+  end
+
+  it "uses a custum padding" do
+    "abc".rjust(5, '-').should == "abc--"
+  end
+
+  it "uses wisely a bigger pattern" do
+    "abc".rjust(10, "123").should == "abc1231231"
+  end
+end

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

@@ -0,0 +1,66 @@
+describe "String#scan" do
+  VOWELS_RE_NO_CAPTURE = /[aeiou]/
+  VOWELS_RE_CAPTURE = /([aeiou])/
+  it "should create one-dimensional array of matches if pattern has no capture groups" do
+    result = "string-a-long".scan(VOWELS_RE_NO_CAPTURE)
+    result.should be_kind_of(Array)
+    result.size.should == 3
+    result.should == ["i", "a", "o"]
+  end
+
+  it "should create two-dimensional array of matches if pattern has capture groups" do
+    result = "string-a-long".scan(VOWELS_RE_CAPTURE)
+    result.should be_kind_of(Array)
+    result.size.should == 3
+    result.should == [["i"], ["a"], ["o"]]
+  end
+
+  it "should set implicit match variables to final match when no block" do
+    result = "string-a-long".scan(VOWELS_RE_CAPTURE)
+    $~.should be_kind_of(MatchData)
+    $~.size.should == 2
+    $~[0].should == "o"
+    $~[1].should == "o"
+    $`.should == "string-a-l"
+    $~.pre_match.should == "string-a-l"
+    $'.should == "ng"
+    $~.post_match == "ng"
+    result.should == [["i"], ["a"], ["o"]]
+  end
+
+  it "should set implicit match variables for each iteration of block" do
+    iterations = 0
+    vals = {
+      :match_data => [],
+      :capture1 => [],
+      :pre_match => [],
+      :post_match => []
+    }
+
+    result = "string-a-long".scan(VOWELS_RE_CAPTURE) do |capture1|
+      iterations += 1
+      vals[:match_data] << $~
+      vals[:capture1] << capture1
+      vals[:pre_match] << $`
+      vals[:post_match] << $'
+    end
+
+    iterations.should == 3
+    vals[:capture1].should == ["i", "a", "o"]
+    vals[:pre_match].should == ["str", "string-", "string-a-l"]
+    vals[:post_match].should == ["ng-a-long", "-long", "ng"]
+    vals[:match_data][0][0].should == "i"
+    vals[:match_data][1][0].should == "a"
+    vals[:match_data][2][0].should == "o"
+    result.should == "string-a-long"
+  end
+
+  # this verifies that the lastIndex is reset before using the regexp
+  it "should get same matches on consecutive runs" do
+    re = Regexp.new('[aeiou]', 'g')
+    results1 = 'hello'.scan(re)
+    results2 = 'hello'.scan(re)
+    results1.should == ["e", "o"]
+    results2.should == results1
+  end
+end