opal 0.4.4 → 0.5.0

data/spec/opal/module/attr_accessor_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-describe "Module#attr_accessor" do
-  it "can be passed a splat of arguments" do
-    eval "class OpalAttrAccessorSpec; attr_accessor *%w{foo bar baz}; end"
-    OpalAttrAccessorSpec.new.foo.should be_nil
-  end
-end

data/spec/opal/native/new_spec.rb

@@ -1,19 +0,0 @@
-describe "Native.new" do
-  it "fails when trying to instantiate a non derived class" do
-    lambda {
-      Native.new
-    }.should raise_error ArgumentError
-  end
-
-  it "should pass all arguments to derived classes" do
-    Class.new(Native) {
-      def initialize(a, b, &c)
-        @a, @b, @c = a, b, c
-      end
-
-      def proper?
-        not (@a.nil? || @b.nil? || @c.nil?)
-      end
-    }.new(1, 2) { }.proper?.should be_true
-  end
-end

data/spec/opal/native/nil_spec.rb

@@ -1,14 +0,0 @@
-describe "Native#nil?" do
-  it "returns true for wrapped null" do
-    Native(`null`).nil?.should be_true
-  end
-
-  it "returns true for wrapped undefined" do
-    Native(`undefined`).nil?.should be_true
-  end
-
-  it "returns false for everything else" do
-    Native(`false`).nil?.should be_false
-    Native(`{}`).nil?.should be_false
-  end
-end

data/spec/opal/nil/to_json_spec.rb

@@ -1,7 +0,0 @@
-require 'json'
-
-describe "NilClass#to_json" do
-  it "returns 'null'" do
-    nil.to_json.should == "null"
-  end
-end

data/spec/opal/numeric/equal_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe "Numeric#==" do
-  it "should be true when two js Number objects are compared" do
-    first = `new Number(42)`
-    second = `new Number(42)`
-    first.should == second
-  end
-end

data/spec/opal/runtime2/call_spec.rb

@@ -1,16 +0,0 @@
-class OpalMethodCallingSpec
-  def foo(a)
-    42 + a
-  end
-
-  def self.bar
-    3.142
-  end
-end
-
-describe "Calling methods" do
-  it "should support '::' syntax" do
-    OpalMethodCallingSpec::bar.should == 3.142
-    OpalMethodCallingSpec.new.foo(10).should == 52
-  end
-end

data/spec/opal/runtime2/class_hierarchy_spec.rb

@@ -1,21 +0,0 @@
-describe "Class Hierarchy" do
-  it "should have the right superclasses" do
-    BasicObject.superclass.should == nil
-    Object.superclass.should == BasicObject
-    Module.superclass.should == Object
-    Class.superclass.should == Module
-  end
-
-  it "should have the right classes" do
-    BasicObject.class.should == Class
-    Object.class.should == Class
-    Class.class.should == Class
-    Module.class.should == Class
-  end
-
-  it "instances should have the right class" do
-    Object.new.class.should == Object
-    Class.new.class.should == Class
-    Module.new.class.should == Module
-  end
-end

data/spec/opal/runtime2/defined_spec.rb

@@ -1,11 +0,0 @@
-describe "The defined? keyword for x-strings" do
-  it "returns true for defined variables" do
-    `var SomeClass = {}`
-    defined?(`{}`).should be_true
-    defined?(`SomeClass`).should be_true
-  end
-
-  it "retuens false for undefined variables" do
-    defined?(`SomeBadVar`).should be_false
-  end
-end

data/spec/opal/runtime2/super_spec.rb

@@ -1,16 +0,0 @@
-class OpalSuperDefineMethodSpec
-  def foo
-    "bar"
-  end
-end
-
-describe "Super keyword" do
-  it "works with methods defined with define_singleton_method" do
-    a = OpalSuperDefineMethodSpec.new
-    a.define_singleton_method(:foo) do
-      super + " baz"
-    end
-
-    a.foo.should == "bar baz"
-  end
-end

data/spec/opal/string/to_json_spec.rb

@@ -1,8 +0,0 @@
-require 'json'
-
-describe "String#to_json" do
-  it "returns an escaped string" do
-    "foo".to_json.should == "\"foo\""
-    "bar\nbaz".to_json.should == "\"bar\\nbaz\""
-  end
-end

data/spec/parser/iter_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe "Iters" do
-  describe "Iter on a command" do
-    it "the outer command call gets the iter" do
-      opal_parse("a b do; end").should == [:iter, [:call, nil, :a, [:arglist, [:call, nil, :b, [:arglist]]]], nil]
-      opal_parse("a 1, b do; end").should == [:iter, [:call, nil, :a, [:arglist, [:int, 1], [:call, nil, :b, [:arglist]]]], nil]
-    end
-  end
-
-  describe "with no args" do
-    it "has 'nil' as the args part of sexp" do
-      opal_parse("proc do; end")[2].should == nil
-    end
-  end
-
-  describe "with empty || args" do
-    it "should have args set to 0" do
-      opal_parse("proc do ||; end")[2].should == 0
-    end
-  end
-
-  describe "with normal args" do
-    it "adds a single s(:lasgn) for 1 norm arg" do
-      opal_parse("proc do |a|; end")[2].should == [:lasgn, :a]
-    end
-
-    it "lists multiple norm args inside a s(:masgn)" do
-      opal_parse("proc do |a, b|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
-      opal_parse("proc do |a, b, c|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
-    end
-  end
-
-  describe "with splat arg" do
-    it "adds a s(:masgn) for the s(:splat) even if its the only arg" do
-      opal_parse("proc do |*a|; end")[2].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
-      opal_parse("proc do |a, *b|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
-    end
-  end
-
-  describe "with opt args" do
-    it "adds a s(:block) arg to end of s(:masgn) for each lasgn" do
-      opal_parse("proc do |a = 1|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
-      opal_parse("proc do |a = 1, b = 2|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
-    end
-
-    it "should add lasgn block after all other args" do
-      opal_parse("proc do |a, b = 1|; end")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :b, [:int, 1]]]]]
-      opal_parse("proc do |b = 1, *c|; end")[2].should == [:masgn, [:array, [:lasgn, :b], [:splat, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
-      opal_parse("proc do |b = 1, &c|; end")[2].should == [:masgn, [:array, [:lasgn, :b], [:block_pass, [:lasgn, :c]], [:block, [:lasgn, :b, [:int, 1]]]]]
-    end
-  end
-
-  describe "with block arg" do
-    it "should add block arg with s(:block_pass) wrapping s(:lasgn) prefix" do
-      opal_parse("proc do |&a|; end")[2].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
-    end
-  end
-end

data/spec/parser/lambda_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-describe "Lambda literals" do
-  it "should parse with either do/end construct or curly braces" do
-    opal_parse("-> {}").first.should == :iter
-    opal_parse("-> do; end").first.should == :iter
-  end
-
-  it "should parse as a call to 'lambda' with the lambda body as a block" do
-    opal_parse("-> {}").should == [:iter, [:call, nil, :lambda, [:arglist]], nil]
-  end
-
-  describe "with no args" do
-    it "should accept no args" do
-      opal_parse("-> {}")[2].should == nil
-    end
-  end
-
-  describe "with normal args" do
-    it "adds a single s(:lasgn) for 1 norm arg" do
-      opal_parse("->(a) {}")[2].should == [:lasgn, :a]
-    end
-
-    it "lists multiple norm args inside a s(:masgn)" do
-      opal_parse("-> (a, b) {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
-      opal_parse("-> (a, b, c) {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:lasgn, :c]]]
-    end
-  end
-
-  describe "with optional braces" do
-    it "parses normal args" do
-      opal_parse("-> a {}")[2].should == [:lasgn, :a]
-      opal_parse("-> a, b {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b]]]
-    end
-
-    it "parses splat args" do
-      opal_parse("-> *a {}")[2].should == [:masgn, [:array, [:splat, [:lasgn, :a]]]]
-      opal_parse("-> a, *b {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:splat, [:lasgn, :b]]]]
-    end
-
-    it "parses opt args" do
-      opal_parse("-> a = 1 {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:block, [:lasgn, :a, [:int, 1]]]]]
-      opal_parse("-> a = 1, b = 2 {}")[2].should == [:masgn, [:array, [:lasgn, :a], [:lasgn, :b], [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]]
-    end
-
-    it "parses block args" do
-      opal_parse("-> &a {}")[2].should == [:masgn, [:array, [:block_pass, [:lasgn, :a]]]]
-    end
-  end
-
-  describe "with body statements" do
-    it "should be nil when no statements given" do
-      opal_parse("-> {}")[3].should == nil
-    end
-
-    it "should be the single sexp when given one statement" do
-      opal_parse("-> { 42 }")[3].should == [:int, 42]
-    end
-
-    it "should wrap multiple statements into a s(:block)" do
-      opal_parse("-> { 42; 3.142 }")[3].should == [:block, [:int, 42], [:float, 3.142]]
-    end
-  end
-end

data/spec/parser/parser_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe Opal::Parser do
-  before { @parser = Opal::Parser.new }
-
-  describe "extract parser options" do
-    it "should return a hash" do
-      @parser.extract_parser_options("").should be_kind_of(Hash)
-    end
-
-    it "extracts options when first line starts with '# opal:'" do
-      @parser.extract_parser_options("# opal: foo, bar, baz").keys.should == [:foo, :bar, :baz]
-    end
-
-    it "converts any '-' in option name to '_'" do
-      @parser.extract_parser_options("# opal: foo, bar-ba, baz-ba").keys.should == [:foo, :bar_ba, :baz_ba]
-    end
-
-    it "sets extracted options as true" do
-      @parser.extract_parser_options("# opal: foo, bar").should == { :foo => true, :bar => true }
-    end
-
-    it "removes prefix of 'no-' or 'no_' from options" do
-      @parser.extract_parser_options("# opal: no-foo, no_bar").keys.should == [:foo, :bar]
-    end
-
-    it "sets extracted no_ options as false" do
-      @parser.extract_parser_options("# opal: no-foo, no_bar").should == { :foo => false, :bar => false }
-    end
-
-    it "can have a mixture of false and true options" do
-      @parser.extract_parser_options("# opal: no-foo, bar").should == { :foo => false, :bar => true }
-    end
-
-    it "only extracts options on first line, if present" do
-      @parser.extract_parser_options("# hello world").should == {}
-      @parser.extract_parser_options("# hello world\n# opal: foo").should == {}
-      @parser.extract_parser_options("# opal:    ").should == {}
-    end
-  end
-end

data/spec/parser/strscan/check_spec.rb

@@ -1,13 +0,0 @@
-describe "StringScanner#check" do
-  before :each do
-    @s = StringScanner.new("This is a test")
-  end
-
-  it "returns the value that scan would return, without advancing the scan pointer" do
-    @s.check(/This/).should == "This"
-    @s.matched.should == "This"
-    @s.pos.should == 0
-    @s.check(/is/).should == nil
-    @s.matched.should == nil
-  end
-end

data/spec/parser/strscan/get_byte_spec.rb

@@ -1,29 +0,0 @@
-describe "StringScanner#get_byte" do
-  before :each do
-    @s = StringScanner.new("abc")
-  end
-
-  it "should return the next byte in string" do
-    @s.get_byte.should == "a"
-  end
-
-  it "should set matched to next byte in string" do
-    @s.matched.should be_nil
-    @s.get_byte
-    @s.matched.should == "a"
-  end
-
-  it "should advance position by 1" do
-    @s.pos.should == 0
-    @s.get_byte
-    @s.pos.should == 1
-  end
-
-  it "should return nil if beyond end of string" do
-    @s.get_byte.should == "a"
-    @s.get_byte.should == "b"
-    @s.get_byte.should == "c"
-    @s.get_byte.should be_nil
-    @s.matched.should be_nil
-  end
-end

data/spec/parser/strscan/scan_spec.rb

@@ -1,33 +0,0 @@
-describe "StringScanner#scan" do
-  before :each do
-    @s = StringScanner.new("This is a test")
-  end
-
-  it "returns the matched string" do
-    @s.scan(/\w+/).should == "This"
-    @s.scan(/.../).should == " is"
-    @s.scan(//).should == ""
-    @s.scan(/\s+/).should == " "
-  end
-
-  it "treats ^ as matching from the beginning of the current position" do
-    @s.scan(/\w+/).should == "This"
-    @s.scan(/^\d/).should be_nil
-    @s.scan(/^\s/).should == " "
-  end
-
-  it "returns nil if there is no match" do
-    @s.scan(/\d/).should == nil
-  end
-
-  it "returns nil when there is no more to scan" do
-    @s.scan(/[\w\s]+/).should == "This is a test"
-    @s.scan(/\w+/).should be_nil
-  end
-
-  it "returns an empty string when the pattern matches empty" do
-    @s.scan(/.*/).should == "This is a test"
-    @s.scan(/.*/).should == ""
-    @s.scan(/./).should be_nil
-  end
-end

data/spec/parser/strscan/skip_spec.rb

@@ -1,40 +0,0 @@
-describe "StringScanner#skip" do
-  before :each do
-    @s = StringScanner.new("This is a test")
-  end
-
-  it "returns the number of characters skipped when matched" do
-    @s.skip(/This/).should == 4
-  end
-
-  it "matches strictly at position" do
-    @s.skip(/This/)
-    @s.skip(/is/).should be_nil
-  end
-
-  it "returns nil when not matched" do
-    @s.skip(/foo/).should be_nil
-  end
-
-  it "advances the scan pointer when matched" do
-    @s.skip(/This/)
-    @s.pos.should == 4
-  end
-
-  it "does not advance the scan pointer when not matched" do
-    @s.skip(/foo/)
-    @s.pos.should == 0
-  end
-
-  it "captures the matched string when matched" do
-    @s.skip(/This/)
-    @s.matched.should == "This"
-  end
-
-  it "clears the matched string when not matched" do
-    @s.skip(/This/)
-    @s.matched.should == "This"
-    @s.skip(/foo/)
-    @s.matched.should be_nil
-  end
-end

data/spec/parser/super_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe "The super keyword" do
-  it "should return s(:zsuper) when no arguments or parans" do
-    opal_parse("super").should == [:zsuper]
-  end
-
-  it "should return s(:super) for any arguments" do
-    opal_parse("super 1").should == [:super, [:int, 1]]
-    opal_parse("super 1, 2").should == [:super, [:int, 1], [:int, 2]]
-    opal_parse("super 1, *2").should == [:super, [:int, 1], [:splat, [:int, 2]]]
-  end
-
-  it "should always return s(:super) when parans are used" do
-    opal_parse("super()").should == [:super]
-    opal_parse("super(1)").should == [:super, [:int, 1]]
-    opal_parse("super(1, 2)").should == [:super, [:int, 1], [:int, 2]]
-    opal_parse("super(1, *2)").should == [:super, [:int, 1], [:splat, [:int, 2]]]
-  end
-end