opal 0.5.5 → 0.6.0

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

@@ -1,9 +0,0 @@
-describe "String#%" do
-  it "returns formatted string as same as Kernel#format" do
-    ("%-5d" % 123).should == "123  "
-  end
-
-  it "can accept multiple arguments by passing them in an array" do
-    ("%d %s" % [456, "foo"]).should == "456 foo"
-  end
-end

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

@@ -1,15 +0,0 @@
-# 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/opal/core/string/gsub_spec.rb

@@ -1,31 +0,0 @@
-describe "String#gsub with pattern and replacement" do
-  it "returns a copy of self with all occurrences of pattern replaced with replacement" do
-    "hello".gsub(/[aeiou]/, '*').should == "h*ll*"
-  end
-
-  it "ignores a block if supplied" do
-    "food".gsub(/f/, "g") { "w" }.should == "good"
-  end
-end
-
-describe "String#gsub with pattern and block" do
-  it "returns a copy of self with all occurrences of pattern replaced with the block's return value" do
-    "hello".gsub(/./) { |s| s.succ + ' ' }.should == "i f m m p "
-    "hello!".gsub(/(.)(.)/) { |*a| a.inspect }.should == '["he"]["ll"]["o!"]'
-    "hello".gsub('l') { 'x'}.should == 'hexxo'
-  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/opal/core/string/lines_spec.rb

@@ -1,9 +0,0 @@
-describe "String#lines" do
-  it "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/opal/core/string/ljust_spec.rb

@@ -1,32 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../fixtures/classes.rb', __FILE__)
-
-describe "String#ljust" do
-  it "returns a new string of specified length with self left justified and padded with padstr" do
-    "hello".ljust(20, '1234').should == "hello123412341234123"
-
-    "".ljust(1, "abcd").should == "a"
-    "".ljust(2, "abcd").should == "ab"
-    "".ljust(3, "abcd").should == "abc"
-    "".ljust(4, "abcd").should == "abcd"
-    "".ljust(6, "abcd").should == "abcdab"
-
-    "OK".ljust(3, "abcd").should == "OKa"
-    "OK".ljust(4, "abcd").should == "OKab"
-    "OK".ljust(6, "abcd").should == "OKabcd"
-    "OK".ljust(8, "abcd").should == "OKabcdab"
-  end
-
-  it "pads with whitespace if no padstr is given" do
-    "hello".ljust(20).should == "hello               "
-  end
-
-  it "returns self if it's longer than or as long as the specified length" do
-    "".ljust(0).should == ""
-    "".ljust(-1).should == ""
-    "hello".ljust(4).should == "hello"
-    "hello".ljust(-1).should == "hello"
-    "this".ljust(3).should == "this"
-    "radiology".ljust(8, '-').should == "radiology"
-  end
-end

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

@@ -1,7 +0,0 @@
-describe "String#lstrip" do
-  it "returns a copy of self with leading whitespace removed" do
-    "    hello    ".lstrip.should == "hello    "
-    "    hello world    ".lstrip.should == "hello world    "
-    "hello".lstrip.should == "hello"
-  end
-end

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

@@ -1,49 +0,0 @@
-describe "String#=~" do
-  it "sets $~ to MatchData when there is a match and nil then there's none" do
-    '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
-
-describe "String#match" do
-  it "matches the pattern against self" do
-    'hello'.match(/(.)\1/)[0].should == "ll"
-  end
-
-  it "returns nil if there's no match" do
-    'hello'.match('xx').should == nil
-  end
-
-  it "sets $~ to MatchData of match or nil when there is none" do
-    'hello'.match(/./)
-    $~[0].should == 'h'
-
-    'hello'.match(/X/)
-    $~.should == nil
-  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/opal/core/string/next_spec.rb

@@ -1,10 +0,0 @@
-describe "String#next" do
-  it "returns an empty string for empty strings" do
-    "".next.should == ""
-  end
-
-  it "returns the successor by increasing the rightmost alphanumeric" do
-    "abcd".next.should == "abce"
-    "THX1138".next.should == "THX1139"
-  end
-end

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

@@ -1,9 +0,0 @@
-describe "String#ord" do
-  it "returns a Fixnum" do
-    'a'.ord.should be_kind_of(Numeric)
-  end
-
-  it "returns the codepoint of the first character in the String" do
-    'a'.ord.should == 97
-  end
-end

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

@@ -1,10 +0,0 @@
-describe "String#partition" do
-  it "returns an array of substrings based on splitting on the given string" do
-    "hello world".partition("o").should == ["hell", "o", " world"]
-  end
-
-  it "always returns 3 elements" do
-    "hello".partition("x").should == ["hello", "", ""]
-    "hello".partition("hello").should == ["", "hello", ""]
-  end
-end

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

@@ -1,50 +0,0 @@
-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/opal/core/string/rjust_spec.rb

@@ -1,32 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../fixtures/classes.rb', __FILE__)
-
-describe "String#rjust with length, padding" do
-  it "returns a new string of specified length with self right justified and padded with padstr" do
-    "hello".rjust(20, '1234').should == "123412341234123hello"
-
-    "".rjust(1, "abcd").should == "a"
-    "".rjust(2, "abcd").should == "ab"
-    "".rjust(3, "abcd").should == "abc"
-    "".rjust(4, "abcd").should == "abcd"
-    "".rjust(6, "abcd").should == "abcdab"
-
-    "OK".rjust(3, "abcd").should == "aOK"
-    "OK".rjust(4, "abcd").should == "abOK"
-    "OK".rjust(6, "abcd").should == "abcdOK"
-    "OK".rjust(8, "abcd").should == "abcdabOK"
-  end
-
-  it "pads with whitespace if no padstr is given" do
-    "hello".rjust(20).should == "               hello"
-  end
-
-  it "returns self if it's longer than or as long as the specified length" do
-    "".rjust(0).should == ""
-    "".rjust(-1).should == ""
-    "hello".rjust(4).should == "hello"
-    "hello".rjust(-1).should == "hello"
-    "this".rjust(3).should == "this"
-    "radiology".rjust(8, '-').should == "radiology"
-  end
-end

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

@@ -1,7 +0,0 @@
-describe "String#rstrip" do
-  it "returns a copy of self with trailing whitespace removed" do
-    "    hello    ".rstrip.should == "    hello"
-    "    hello world    ".rstrip.should == "    hello world"
-    "hello".rstrip.should == "hello"
-  end
-end

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

@@ -1,66 +0,0 @@
-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

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

@@ -1,74 +0,0 @@
-require File.expand_path('../fixtures/classes', __FILE__)
-
-describe "String#slice" do
-  it "returns the character code of the character at the given index" do
-    "hello".slice(0).should == "h"
-    "hello".slice(-1).should == "o"
-  end
-
-  it "returns nil if index is outside of self" do
-    "hello".slice(20).should == nil
-    "hello".slice(-20).should == nil
-
-    "".slice(0).should == nil
-    "".slice(-1).should == nil
-  end
-end
-
-describe "String#slice with index, length" do
-  it "returns the substring starting at the given index with the given length" do
-    "hello there".slice(0, 0).should == ""
-    "hello there".slice(0, 1).should == "h"
-    "hello there".slice(0, 3).should == "hel"
-    "hello there".slice(0, 6).should == "hello "
-    "hello there".slice(0, 9).should == "hello the"
-    "hello there".slice(0, 12).should == "hello there"
-
-    "hello there".slice(1, 0).should == ""
-    "hello there".slice(1, 1).should == "e"
-    "hello there".slice(1, 3).should == "ell"
-    "hello there".slice(1, 6).should == "ello t"
-    "hello there".slice(1, 9).should == "ello ther"
-    "hello there".slice(1, 12).should == "ello there"
-
-    "hello there".slice(3, 0).should == ""
-    "hello there".slice(3, 1).should == "l"
-    "hello there".slice(3, 3).should == "lo "
-    "hello there".slice(3, 6).should == "lo the"
-    "hello there".slice(3, 9).should == "lo there"
-
-    "hello there".slice(4, 0).should == ""
-    "hello there".slice(4, 3).should == "o t"
-    "hello there".slice(4, 6).should == "o ther"
-    "hello there".slice(4, 9).should == "o there"
-
-    "foo".slice(2, 1).should == "o"
-    "foo".slice(3, 0).should == ""
-    "foo".slice(3, 1).should == ""
-
-    "".slice(0, 0).should == ""
-    "".slice(0, 1).should == ""
-
-    "x".slice(0, 0).should == ""
-    "x".slice(0, 1).should == "x"
-    "x".slice(1, 0).should == ""
-    "x".slice(-1, 1).should == "x"
-  end
-
-  it "returns nil if the offset falls outside of self" do
-    "hello there".slice(20, 3).should == nil
-    "hello there".slice(-20, 3).should == nil
-
-    "".slice(1, 0).should == nil
-    "".slice(1, 1).should == nil
-
-    "".slice(2, 0).should == nil
-    "".slice(2, 1).should == nil
-
-    "x".slice(2, 0).should == nil
-    "x".slice(2, 1).should == nil
-
-    "x".slice(-2, 0).should == nil
-    "x".slice(-2, 1).should == nil
-  end
-end

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

@@ -1,5 +0,0 @@
-describe "String#split with String" do
-  it "returns an array of substrings based on splitting on the given string" do
-    "mellow yellow".split("ello").should == ["m", "w y", "w"]
-  end
-end

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

@@ -1,6 +0,0 @@
-describe "String#strip" do
-  it "returns a new string with leading and trailing whitespace removed" do
-    "    hello    ".strip.should == "hello"
-    "    hello world    ".strip.should == "hello world"
-  end
-end