opal 0.5.5 → 0.6.0

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

@@ -1,38 +0,0 @@
-describe "String#sub with pattern, replacement" do
-  it "returns a copy of self with all occurrences of pattern replaced with replacement" do
-    "hello".sub(/[aeiou]/, '*').should == "h*llo"
-    "hello".sub(//, ".").should == ".hello"
-  end
-
-  it "ignores a block if supplied" do
-    "food".sub(/f/, "g") { "w" }.should == "good"
-  end
-
-  it "supports /i for ignoring case" do
-    "Hello".sub(/h/i, "j").should == "jello"
-    "hello".sub(/H/i, "j").should == "jello"
-  end
-
-  it "converts and supports back references in replacement string" do
-    "javascript".sub(/(j).*(s).*/, '.\\1\\2').should == '.js'
-  end
-end
-
-describe "String#sub with pattern and block" do
-  it "returns a copy of self with the first occurences of pattern replaces with block's return value" do
-    "hi".sub(/./) { |s| s + ' ' }.should == "h i"
-    "hi!".sub(/(.)(.)/) { |*a| a.inspect }.should == '["hi"]!'
-  end
-
-  it "should set the global match variable $~ inside block" do
-    match_datas = []
-    "hello".sub(/(.)./) { match_datas << $~; $~[1].succ }.should == "illo"
-    match_datas.length.should == 1
-    match_datas[0].length.should == 2
-    match_datas[0].should == ["he", "h"]
-  end
-
-  it "should set the global match variable $& inside block" do
-    "hello".sub(/./) { "#{$&} " }.should == "h ello"
-  end
-end

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

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

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

@@ -1,5 +0,0 @@
-describe "String#sum" do
-  it "returns a basic n-bit checksum of the characters in self" do
-    "ruby".sum.should == 450
-  end
-end

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

@@ -1,14 +0,0 @@
-describe "String#to_f" do
-  it "treats leading characters of self as a floating point number" do
-    "45.67 degress".to_f.should == 45.67
-    "0".to_f.should == 0.0
-
-    ".5".to_f.should == 0.5
-    "5e".to_f.should == 5.0
-    "5E".to_f.should == 5.0
-  end
-
-  it "treats special float value strings as characters" do
-    "NaN".to_f.should == 0
-  end
-end

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

@@ -1,25 +0,0 @@
-describe "String#to_i" do
-  it "returns 0 for strings with leading underscores" do
-    "_123".to_i.should == 0
-  end
-
-  it "ignores subsequent invalid characters" do
-    "123asdf".to_i.should == 123
-    "123#123".to_i.should == 123
-    "123 456".to_i.should == 123
-  end
-
-  it "interprets leading characters as a number in the given base" do
-    "10110010010".to_i(2).should == 1426
-    "100110201001".to_i(3).should == 186409
-    "103110201001".to_i(4).should == 5064769
-    "103110241001".to_i(5).should == 55165126
-    "153110241001".to_i(6).should == 697341529
-    "153160241001".to_i(7).should == 3521513430
-    "153160241701".to_i(8).should == 14390739905
-    "853160241701".to_i(9).should == 269716550518
-    "853160241791".to_i(10).should == 853160241791
-
-    "5e10".to_i.should == 5
-  end
-end

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

@@ -1,31 +0,0 @@
-describe "String#tr_s" do
-  it "replaces occurrences of character with substitute, dropping repeating substitutes" do
-    # identity checks (no substitution)
-    'abc'.tr_s('', 'a').should == 'abc'
-    'aabbcc'.tr_s('', 'a').should == 'aabbcc'
-
-    # single char substitutions
-    'a'.tr_s('a', 'b').should == 'b'
-    'aa'.tr_s('a', 'b').should == 'b'
-    'bbabcbb'.tr_s('b', 'z').should == 'zazcz'
-    'hello'.tr_s('l', 'r').should == 'hero'
-
-    # multiple char substitutions
-    'aabbcc'.tr_s('abc', 'abc').should == 'abc'
-    'hello'.tr_s('el', '*').should == 'h*o'
-    'hello'.tr_s('el', 'hx').should == 'hhxo'
-
-    # inverted substitutions
-    'hello'.tr_s('^aeiou', '*').should == '*e*o'
-
-    # range substitutions
-    'abc'.tr_s('a-c', '*').should == '*'
-    'hello'.tr_s('e-lo', 'rb').should == 'brb'
-    'hello'.tr_s('a-y', 'b-z').should == 'ifmp'
-
-    # truncation
-    'abcd'.tr_s('a', '').should == 'bcd'
-    'abcd'.tr_s('abc', '').should == 'd'
-    'abcd'.tr_s('b-d', '').should == 'a'
-  end
-end

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

@@ -1,31 +0,0 @@
-describe "String#tr" do
-  it "replaces occurances of character with substitute" do
-    # identity checks (no substitution)
-    'abc'.tr('', 'z').should == 'abc'
-    'abc'.tr('a', 'a').should == 'abc'
-    'abc'.tr('a', 'az').should == 'abc'
-
-    # single char substitutions
-    'a'.tr('a', 'b').should == 'b'
-    'aa'.tr('a', 'b').should == 'bb'
-    'abc'.tr('b', 'z').should == 'azc'
-    'hello'.tr('e', 'ip').should == 'hillo'
-
-    # multiple char substitutions
-    'hello'.tr('el', 'ip').should == 'hippo'
-    'hello'.tr('aeiou', '*').should == 'h*ll*'
-
-    # inverted substitutions
-    'hello'.tr('^aeiou', '*').should == '*e**o'
-
-    # range substitutions
-    'abc'.tr('a-c', '*').should == '***'
-    'hello'.tr('e-lo', 'ab').should == 'babbb'
-    'hello'.tr('a-y', 'b-z').should == 'ifmmp'
-
-    # truncation
-    'abcd'.tr('a', '').should == 'bcd'
-    'abcd'.tr('abc', '').should == 'd'
-    'abcd'.tr('b-d', '').should == 'a'
-  end
-end

data/spec/opal/filters/bugs/parser.rb

@@ -1,10 +0,0 @@
-opal_filter "Opal::Parser" do
-  fails "Singleton classes returns an empty s(:scope) when given an empty body"
-  fails "Singleton classes should accept any expressions for singleton part"
-  fails "Strings from %Q construction should match '{' and '}' pairs used to start string before ending match"
-  fails "Strings from %Q construction should match '(' and ')' pairs used to start string before ending match"
-  fails "Strings from %Q construction should match '[' and ']' pairs used to start string before ending match"
-  fails "x-strings created using %x notation should match '{' and '}' pairs used to start string before ending match"
-  fails "x-strings created using %x notation should match '(' and ')' pairs used to start string before ending match"
-  fails "x-strings created using %x notation should match '[' and ']' pairs used to start string before ending match"
-end

data/spec/opal/filters/unsupported/immutable_strings.rb

@@ -1,24 +0,0 @@
-opal_filter "immutable strings" do
-  fails "Array#fill does not replicate the filler"
-
-  fails "Hash literal freezes string keys on initialization"
-
-  fails "Time#strftime formats time according to the directives in the given format string"
-  fails "Time#strftime with %z formats a local time with positive UTC offset as '+HHMM'"
-  fails "Time#strftime with %z formats a local time with negative UTC offset as '-HHMM'"
-
-  fails "String#chomp when passed no argument returns a copy of the String when it is not modified"
-
-  fails "String#chop returns a new string when applied to an empty string"
-
-  fails "String#chop! removes the final character"
-  fails "String#chop! removes the final carriage return"
-  fails "String#chop! removes the final newline"
-  fails "String#chop! removes the final carriage return, newline"
-  fails "String#chop! removes the carrige return, newline if they are the only characters"
-  fails "String#chop! does not remove more than the final carriage return, newline"
-  fails "String#chop! returns self if modifications were made"
-  fails "String#chop! returns nil when called on an empty string"
-  fails "String#chop! raises a RuntimeError on a frozen instance that is modified"
-  fails "String#chop! raises a RuntimeError on a frozen instance that would not be modified"
-end

data/spec/opal/filters/unsupported/string_subclasses.rb

@@ -1,8 +0,0 @@
-opal_filter "String subclasses" do
-  fails "String#upcase returns a subclass instance for subclasses"
-  fails "String#swapcase returns subclass instances when called on a subclass"
-  fails "String#downcase returns a subclass instance for subclasses"
-  fails "String#capitalize returns subclass instances when called on a subclass"
-  fails "String#center with length, padding returns subclass instances when called on subclasses"
-  fails "String#chomp when passed no argument returns subclass instances when called on a subclass"
-end

data/spec/opal/parser/alias_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe "The alias keyword" do
-  describe "with fitem" do
-    it "should return an s(:alias) with s(:sym)" do
-      opal_parse("alias a b").should == [:alias, [:sym, :a], [:sym, :b]]
-      opal_parse("alias == equals").should == [:alias, [:sym, :==], [:sym, :equals]]
-    end
-
-    it "should accept symbols as names" do
-      opal_parse("alias :foo :bar").should == [:alias, [:sym, :foo], [:sym, :bar]]
-    end
-  end
-
-  describe "with gvar" do
-    it "should return a s(:valias) with two gvars as arguments" do
-      opal_parse("alias $foo $bar").should == [:valias, :$foo, :$bar]
-    end
-  end
-
-  describe "with gvar and nth ref" do
-    it "should return a s(:valias) with two values as arguments" do
-      opal_parse("alias $foo $1").should == [:valias, :$foo, :"1"]
-    end
-  end
-end

data/spec/opal/parser/and_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe "The and statement" do
-  it "should always return s(:and)" do
-    opal_parse("1 and 2").should == [:and, [:int, 1], [:int, 2]]
-  end
-end
-
-describe "The && expression" do
-  it "should always return s(:and)" do
-    opal_parse("1 && 2").should == [:and, [:int, 1], [:int, 2]]
-  end
-end

data/spec/opal/parser/array_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe "Arrays" do
-  it "should parse empty arrays as s(:array)" do
-    opal_parse("[]").should == [:array]
-  end
-
-  it "should append regular args onto end of array sexp" do
-    opal_parse("[1]").should == [:array, [:int, 1]]
-    opal_parse("[1, 2]").should == [:array, [:int, 1], [:int, 2]]
-    opal_parse("[1, 2, 3]").should == [:array, [:int, 1], [:int, 2], [:int, 3]]
-  end
-
-  it "should return a single item s(:array) with given splat if no norm args" do
-    opal_parse("[*1]").should == [:array, [:splat, [:int, 1]]]
-  end
-
-  it "should allow splats combined with any number of norm args" do
-    opal_parse("[1, *2]").should == [:array, [:int, 1], [:splat, [:int, 2]]]
-    opal_parse("[1, 2, *3]").should == [:array, [:int, 1], [:int, 2], [:splat, [:int, 3]]]
-  end
-end

data/spec/opal/parser/attrasgn_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe "Attribute assignments" do
-  it "should return a s(:attrasgn) for simple assignments" do
-    opal_parse('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
-    opal_parse('bar.foo = 1').should == [:attrasgn, [:call, nil, :bar, [:arglist]], :foo=, [:arglist, [:int, 1]]]
-    opal_parse('@bar.foo = 1').should == [:attrasgn, [:ivar, :@bar], :foo=, [:arglist, [:int, 1]]]
-  end
-
-  it "accepts both '.' and '::' for method call operators" do
-    opal_parse('self.foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
-    opal_parse('self::foo = 1').should == [:attrasgn, [:self], :foo=, [:arglist, [:int, 1]]]
-  end
-
-  it "can accept a constant as assignable name when using '.'" do
-    opal_parse('self.FOO = 1').should == [:attrasgn, [:self], :FOO=, [:arglist, [:int, 1]]]
-  end
-
-  describe "when setting element reference" do
-    it "uses []= as the method call" do
-      opal_parse('self[1] = 2').should == [:attrasgn, [:self], :[]=, [:arglist, [:int, 1], [:int, 2]]]
-    end
-
-    it "supports multiple arguments inside brackets" do
-      opal_parse('self[1, 2] = 3').should == [:attrasgn, [:self], :[]=, [:arglist, [:int, 1], [:int, 2], [:int, 3]]]
-    end
-  end
-end

data/spec/opal/parser/begin_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe "The begin keyword" do
-  it "should be removed when used without a resuce or enusre body" do
-    opal_parse('begin; 1; end').should == [:int, 1]
-    opal_parse('begin; 1; 2; end').should == [:block, [:int, 1], [:int, 2]]
-  end
-
-  describe "with 'rescue' bodies" do
-    it "should create a s(:rescue) sexp" do
-      opal_parse('begin; 1; rescue; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]]]
-    end
-
-    it "allows multiple rescue bodies" do
-      opal_parse('begin 1; rescue; 2; rescue; 3; end').should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]], [:resbody, [:array], [:int, 3]]]
-    end
-
-    it "accepts a list of classes used to match against the exception" do
-      opal_parse('begin 1; rescue Klass; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass]], [:int, 2]]]
-    end
-
-    it "accepts an identifier to assign exception to" do
-      opal_parse('begin 1; rescue => a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:lasgn, :a, [:gvar, :$!]]], [:int, 2]]]
-      opal_parse('begin 1; rescue Klass => a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass],[:lasgn, :a, [:gvar, :$!]]], [:int, 2]]]
-    end
-
-    it "accepts an ivar to assign exception to" do
-      opal_parse('begin 1; rescue => @a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:iasgn, :@a, [:gvar, :$!]]], [:int, 2]]]
-      opal_parse('begin 1; rescue Klass => @a; 2; end').should == [:rescue, [:int, 1], [:resbody, [:array, [:const, :Klass],[:iasgn, :@a, [:gvar, :$!]]], [:int, 2]]]
-    end
-
-    it "should parse newline right after rescue" do
-      opal_parse("begin; 1; rescue\n 2; end").should == [:rescue, [:int, 1], [:resbody, [:array], [:int, 2]]]
-    end
-  end
-
-  describe "with an 'ensure' block" do
-    it "should propagate into single s(:ensure) statement when no rescue block given" do
-      opal_parse('begin; 1; ensure; 2; end').should == [:ensure, [:int, 1], [:int, 2]]
-    end
-  end
-end

data/spec/opal/parser/block_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe "Block statements" do
-  it "should return the direct expression if only one expresssion in block" do
-    opal_parse("42").should == [:int, 42]
-  end
-
-  it "should return an s(:block) with all expressions appended for > 1 expression" do
-    opal_parse("42; 43").should == [:block, [:int, 42], [:int, 43]]
-    opal_parse("42; 43\n44").should == [:block, [:int, 42], [:int, 43], [:int, 44]]
-  end
-end

data/spec/opal/parser/break_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe "The break keyword" do
-  it "should return s(:break) when given no args" do
-    opal_parse("break").should == [:break]
-  end
-
-  it "returns s(:break) with a single arg not wrapped in s(:array)" do
-    opal_parse("break 1").should == [:break, [:int, 1]]
-    opal_parse("break *1").should == [:break, [:splat, [:int, 1]]]
-  end
-
-  it "returns s(:break) with an s(:array) for args size > 1" do
-    opal_parse("break 1, 2").should == [:break, [:array, [:int, 1], [:int, 2]]]
-    opal_parse("break 1, *2").should == [:break, [:array, [:int, 1], [:splat, [:int, 2]]]]
-  end
-end

data/spec/opal/parser/call_spec.rb

@@ -1,131 +0,0 @@
-require 'spec_helper'
-
-describe "Method calls" do
-  it "should use 'nil' for calls without a receiver" do
-    opal_parse("foo").should == [:call, nil, :foo, [:arglist]]
-    opal_parse("foo()").should == [:call, nil, :foo, [:arglist]]
-  end
-
-  it "should always have an arglist when not passed any arguments" do
-    opal_parse("foo").should == [:call, nil, :foo, [:arglist]]
-    opal_parse("self.foo").should == [:call, [:self], :foo, [:arglist]]
-    opal_parse("foo()").should == [:call, nil, :foo, [:arglist]]
-    opal_parse("self.foo()").should == [:call, [:self], :foo, [:arglist]]
-  end
-
-  it "appends all arguments onto arglist" do
-    opal_parse("foo 1").should == [:call, nil, :foo, [:arglist, [:int, 1]]]
-    opal_parse("foo 1, 2").should == [:call, nil, :foo, [:arglist, [:int, 1], [:int, 2]]]
-    opal_parse("foo 1, *2").should == [:call, nil, :foo, [:arglist, [:int, 1], [:splat, [:int, 2]]]]
-  end
-
-  it "supports leading dots on newline" do
-    opal_parse("foo\n.bar").should == [:call, [:call, nil, :foo, [:arglist]], :bar, [:arglist]]
-    lambda { opal_parse("foo\n..bar") }.should raise_error(Exception)
-  end
-end
-
-describe "Operator calls" do
-  it "should parse all other operators into method calls" do
-    opal_parse("1 % 2").should == [:call, [:int, 1], :%, [:arglist, [:int, 2]]]
-    opal_parse("1 ** 2").should == [:call, [:int, 1], :**, [:arglist, [:int, 2]]]
-
-    opal_parse("+self").should == [:call, [:self], :+@, [:arglist]]
-    opal_parse("-self").should == [:call, [:self], :-@, [:arglist]]
-
-    opal_parse("1 | 2").should == [:call, [:int, 1], :|, [:arglist, [:int, 2]]]
-    opal_parse("1 ^ 2").should == [:call, [:int, 1], :^, [:arglist, [:int, 2]]]
-    opal_parse("1 & 2").should == [:call, [:int, 1], :&, [:arglist, [:int, 2]]]
-    opal_parse("1 <=> 2").should == [:call, [:int, 1], :<=>, [:arglist, [:int, 2]]]
-
-    opal_parse("1 < 2").should == [:call, [:int, 1], :<, [:arglist, [:int, 2]]]
-    opal_parse("1 <= 2").should == [:call, [:int, 1], :<=, [:arglist, [:int, 2]]]
-    opal_parse("1 > 2").should == [:call, [:int, 1], :>, [:arglist, [:int, 2]]]
-    opal_parse("1 >= 2").should == [:call, [:int, 1], :>=, [:arglist, [:int, 2]]]
-
-    opal_parse("1 == 2").should == [:call, [:int, 1], :==, [:arglist, [:int, 2]]]
-    opal_parse("1 === 2").should == [:call, [:int, 1], :===, [:arglist, [:int, 2]]]
-    opal_parse("1 =~ 2").should == [:call, [:int, 1], :=~, [:arglist, [:int, 2]]]
-
-    opal_parse("~1").should == [:call, [:int, 1], :~, [:arglist]]
-    opal_parse("1 << 2").should == [:call, [:int, 1], :<<, [:arglist, [:int, 2]]]
-    opal_parse("1 >> 2").should == [:call, [:int, 1], :>>, [:arglist, [:int, 2]]]
-  end
-
-  it "optimizes +@ and -@ on numerics" do
-    opal_parse("+1").should == [:int, 1]
-    opal_parse("-1").should == [:int, -1]
-  end
-end
-
-describe "Optional paren calls" do
-  it "should correctly parse - and -@" do
-    opal_parse("x - 1").should == [:call, [:call, nil, :x, [:arglist]], :-, [:arglist, [:int, 1]]]
-    opal_parse("x -1").should == [:call, nil, :x, [:arglist, [:int, -1]]]
-  end
-
-  it "should correctly parse + and +@" do
-    opal_parse("x + 1").should == [:call, [:call, nil, :x, [:arglist]], :+, [:arglist, [:int, 1]]]
-    opal_parse("x +1").should == [:call, nil, :x, [:arglist, [:int, 1]]]
-  end
-
-  it "should correctly parse / and regexps" do
-    opal_parse("x / 500").should == [:call, [:call, nil, :x, [:arglist]], :/, [:arglist, [:int, 500]]]
-    opal_parse("x /foo/").should == [:call, nil, :x, [:arglist, [:regexp, /foo/]]]
-  end
-
-  it "should parse LPAREN_ARG correctly" do
-    opal_parse("x (1).y").should == [:call, nil, :x, [:arglist, [:call, [:int, 1], :y, [:arglist]]]]
-    opal_parse("x(1).y").should == [:call, [:call, nil, :x, [:arglist, [:int, 1]]], :y, [:arglist]]
-  end
-end
-
-describe "Operator precedence" do
-  it "should be raised with parentheses" do
-   opal_parse("(1 + 2) + (3 - 4)").should == [:call,
-                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
-                                               :+,
-                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
-                                              ]
-   opal_parse("(1 + 2) - (3 - 4)").should == [:call,
-                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
-                                               :-,
-                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
-                                              ]
-   opal_parse("(1 + 2) * (3 - 4)").should == [:call,
-                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
-                                               :*,
-                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
-                                              ]
-   opal_parse("(1 + 2) / (3 - 4)").should == [:call,
-                                               [:paren, [:call, [:int, 1], :+, [:arglist, [:int, 2]]]],
-                                               :/,
-                                               [:arglist, [:paren, [:call, [:int, 3], :-, [:arglist, [:int, 4]]]]],
-                                              ]
-  end
-end
-
-describe "Calls with keywords as method names" do
-
-  keywords = %w[class module defined? def undef end do if unless else elsif self true false
-                nil __LINE__ __FILE__ begin rescue ensure case when or and not return next
-                redo break super then while until yield alias]
-
-  it "should correctly parse the keyword as a method name when after a '.'" do
-    keywords.each do |kw|
-      opal_parse("self.#{kw}").should == [:call, [:self], kw.to_sym, [:arglist]]
-    end
-  end
-end
-
-describe "Calls with operators as method names" do
-  operators = %w[+ - * / & ** | ^ & <=> > >= < <= << >>]
-
-  it "should correctly parse the operator as method name after '.'" do
-    operators.each do |op|
-      opal_parse("self.#{op}").should == [:call, [:self], op.to_sym, [:arglist]]
-      opal_parse("self.#{op}(1)").should == [:call, [:self], op.to_sym, [:arglist, [:int, 1]]]
-      opal_parse("self.#{op}(1, 2)").should == [:call, [:self], op.to_sym, [:arglist, [:int, 1], [:int, 2]]]
-    end
-  end
-end