opal 0.7.0.beta3 → 0.7.0.rc1

data/opal/corelib/string.rb

@@ -71,7 +71,7 @@ class String
   end
 
   def <<(other)
-    raise NotImplementedError, 'Mutable String methods are not supported in Opal.'
+    raise NotImplementedError, '#<< not supported. Mutable String methods are not supported in Opal.'
   end
 
   def ==(other)

data/opal/corelib/struct.rb

@@ -22,13 +22,7 @@ class Struct
 
     members << name
 
-    define_method name do
-      instance_variable_get "@#{name}"
-    end
-
-    define_method "#{name}=" do |value|
-      instance_variable_set "@#{name}", value
-    end
+    attr_accessor name
   end
 
   def self.members

data/spec/README.md

@@ -0,0 +1,8 @@
+# Opal specs overview
+
+* **rubyspecs** (file) a whitelist of RubySpec files to be ran
+* **corelib** RubySpec examples (submodule)
+* **stdlib** `rubysl-*` examples (submodules)
+* **filters** The list of MSpec/RubySpec examples that are either bugs or unsupported
+* **opal** opal additions/special behaviour in the runtime/corelib
+* **lib** specs for opal lib (parser, lexer, grammar, compiler etc)

data/spec/filters/bugs/language.rb

@@ -147,6 +147,7 @@ opal_filter "language" do
   fails "A singleton method definition can be declared for a global variable"
   fails "A singleton method definition can be declared for an instance variable"
   fails "A singleton method definition can be declared for a local variable"
+  fails "An instance method with keyword arguments when there is a single keyword argument raises an argument error when an unknown keyword argument is provided"
 
   fails "The defined? keyword for a scoped constant returns nil when an undefined constant is scoped to a defined constant"
   fails "The defined? keyword for a top-level scoped constant returns nil when an undefined constant is scoped to a defined constant"

data/spec/filters/bugs/module.rb

@@ -12,6 +12,9 @@ opal_filter "Module" do
   fails "Module#const_defined? should not search parent scopes of classes and modules if inherit is false"
   fails "Module#const_get should not search parent scopes of classes and modules if inherit is false"
 
+  fails "Module#class_variable_set sets the value of a class variable with the given name defined in an included module"
+  fails "Module#class_variable_get returns the value of a class variable with the given name defined in an included module"
+
   fails "Module#module_function as a toggle (no arguments) in a Module body functions normally if both toggle and definitions inside a eval"
   fails "Module#module_function as a toggle (no arguments) in a Module body does not affect definitions when inside an eval even if the definitions are outside of it"
 
@@ -24,4 +27,5 @@ opal_filter "Module" do
   fails "Module#module_function with specific method names can make accessible private methods"
   fails "Module#module_function as a toggle (no arguments) in a Module body does not affect module_evaled method definitions also if outside the eval itself"
   fails "Module#module_function as a toggle (no arguments) in a Module body has no effect if inside a module_eval if the definitions are outside of it"
+  fails "Module#module_function with specific method names creates an independent copy of the method, not a redirect"
 end

data/spec/filters/unsupported/frozen.rb

@@ -87,4 +87,6 @@ opal_filter "Object#frozen" do
   fails "Hash#update raises a RuntimeError on a frozen instance that is modified"
   fails "Hash#rehash raises a RuntimeError if called on a frozen instance"
   fails "Hash#[]= duplicates and freezes string keys"
+
+  fails "Module#class_variable_set raises a RuntimeError when self is frozen"
 end

data/spec/lib/compiler/pre_processed_conditionals_spec.rb

@@ -0,0 +1,87 @@
+require 'lib/spec_helper'
+
+describe Opal::Compiler do
+  def expect_compiled(*args)
+    expect(Opal::Compiler.new(*args).compile)
+  end
+
+  describe "pre-processed if conditions" do
+    it "compiles if blocks using RUBY_ENGINE/RUBY_PLATFORM == opal" do
+      expect_compiled(<<-RUBY).to include("should_compile_fine")
+      if RUBY_ENGINE == 'opal'
+        :should_compile_fine
+      end
+      RUBY
+
+      expect_compiled(<<-RUBY).to include("so_should_this")
+      if RUBY_PLATFORM == 'opal'
+        :so_should_this
+      end
+      RUBY
+    end
+
+    it "does not compile if blocks using RUBY_ENGINE/RUBY_PLATFORM != opal" do
+      expect_compiled(<<-RUBY).to_not include('should_not_compile')
+        if RUBY_ENGINE != 'opal'
+          :should_not_compile
+        end
+      RUBY
+
+      expect_compiled(<<-RUBY).to_not include('should_not_compile')
+        if RUBY_PLATFORM != 'opal'
+          :should_not_compile
+        end
+      RUBY
+    end
+
+    it "skips elsif/else parts for CONST == opal" do
+      expect_compiled(<<-RUBY).to_not include("should_be_skipped")
+      if RUBY_PLATFORM == "opal"
+        :ok
+      else
+        :should_be_skipped
+      end
+      RUBY
+
+      result = expect_compiled(<<-RUBY)
+      if RUBY_ENGINE == 'opal'
+        :this_compiles
+      elsif false
+        :this_does_not_compile
+      else
+        :this_neither
+      end
+      RUBY
+
+      result.to_not include("this_does_not_compile", "this_neither")
+    end
+
+    it "generates if-code as normal without check" do
+      expect_compiled(<<-RUBY).to include("should_compile", "and_this")
+      if some_conditional
+        :should_compile
+      else
+        :and_this
+      end
+      RUBY
+    end
+  end
+
+  describe "pre-processed unless conditionals" do
+    it "skips over if using RUBY_ENGINE/RUBY_PLATFORM == 'opal'" do
+      expect_compiled(<<-RUBY).to_not include("should_not_compile")
+      unless RUBY_ENGINE == 'opal'
+        :should_not_compile
+      end
+      RUBY
+    end
+
+    it "generates unless code as normal if no check" do
+      expect_compiled(<<-RUBY).to include("this_should_compile")
+      unless this_is_true
+        :this_should_compile
+      end
+      RUBY
+    end
+  end
+end

data/spec/lib/compiler_spec.rb

@@ -83,73 +83,7 @@ describe Opal::Compiler do
     end
   end
 
-  describe "pre-processed if conditions" do
-    it "compiles if blocks using RUBY_ENGINE/RUBY_PLATFORM == opal" do
-      expect_compiled(<<-RUBY).to include("should_compile_fine")
-        if RUBY_ENGINE == 'opal'
-          :should_compile_fine
-        end
-      RUBY
-
-      expect_compiled(<<-RUBY).to include("so_should_this")
-        if RUBY_PLATFORM == 'opal'
-          :so_should_this
-        end
-      RUBY
-    end
-
-    it "skips elsif/else parts" do
-      expect_compiled(<<-RUBY).to_not include("should_be_skipped")
-        if RUBY_PLATFORM == "opal"
-          :ok
-        else
-          :should_be_skipped
-        end
-      RUBY
-
-      result = expect_compiled(<<-RUBY)
-        if RUBY_ENGINE == 'opal'
-          :this_compiles
-        elsif false
-          :this_does_not_compile
-        else
-          :this_neither
-        end
-      RUBY
-
-      result.to_not include("this_does_not_compile", "this_neither")
-    end
-
-    it "generates if-code as normal without check" do
-      expect_compiled(<<-RUBY).to include("should_compile", "and_this")
-        if some_conditional
-          :should_compile
-        else
-          :and_this
-        end
-      RUBY
-    end
-  end
-
-  describe "pre-processed unless conditionals" do
-    it "skips over if using RUBY_ENGINE/RUBY_PLATFORM == 'opal'" do
-      expect_compiled(<<-RUBY).to_not include("should_not_compile")
-        unless RUBY_ENGINE == 'opal'
-          :should_not_compile
-        end
-      RUBY
-    end
-
-    it "generates unless code as normal if no check" do
-      expect_compiled(<<-RUBY).to include("this_should_compile")
-        unless this_is_true
-          :this_should_compile
-        end
-      RUBY
-    end
-  end
-
-  describe 'pre-processing require-ish methods' do
+    describe 'pre-processing require-ish methods' do
     describe '#require' do
       it 'parses and resolve #require argument' do
         compiler = compiler_for(%Q{require "#{__FILE__}"})

data/spec/lib/fixtures/file_with_directives.js

@@ -0,0 +1,2 @@
+//= require required_file
+console.log('file with directives');

data/spec/lib/fixtures/required_file.js

@@ -0,0 +1 @@
+console.log('required file');

data/spec/lib/parser/def_spec.rb

@@ -23,39 +23,52 @@ describe "The def keyword" do
 
   describe "with normal args" do
     it "should list all args" do
-      parsed("def foo(a); end")[3].should == [:args, :a]
-      parsed("def foo(a, b); end")[3].should == [:args, :a, :b]
-      parsed("def foo(a, b, c); end")[3].should == [:args, :a, :b, :c]
+      parsed("def foo(a); end")[3].should == [:args, [:arg, :a]]
+      parsed("def foo(a, b); end")[3].should == [:args, [:arg, :a], [:arg, :b]]
     end
   end
 
   describe "with opt args" do
     it "should list all opt args as well as block with each lasgn" do
-      parsed("def foo(a = 1); end")[3].should == [:args, :a, [:block, [:lasgn, :a, [:int, 1]]]]
-      parsed("def foo(a = 1, b = 2); end")[3].should == [:args, :a, :b, [:block, [:lasgn, :a, [:int, 1]], [:lasgn, :b, [:int, 2]]]]
-    end
-
-    it "should list lasgn block after all other args" do
-      parsed("def foo(a, b = 1); end")[3].should == [:args, :a, :b, [:block, [:lasgn, :b, [:int, 1]]]]
-      parsed("def foo(b = 1, *c); end")[3].should == [:args, :b, :"*c", [:block, [:lasgn, :b, [:int, 1]]]]
-      parsed("def foo(b = 1, &block); end")[3].should == [:args, :b, :"&block", [:block, [:lasgn, :b, [:int, 1]]]]
+      parsed("def foo(a = 1); end")[3].should == [:args, [:optarg, :a, [:int, 1]]]
+      parsed("def foo(a = 1, b = 2); end")[3].should == [:args, [:optarg, :a, [:int, 1]], [:optarg, :b, [:int, 2]]]
     end
   end
 
   describe "with rest args" do
     it "should list rest args in place as a symbol with '*' prefix" do
-      parsed("def foo(*a); end")[3].should == [:args, :"*a"]
+      parsed("def foo(*a); end")[3].should == [:args, [:restarg, :a]]
     end
 
     it "uses '*' as an arg name for rest args without a name" do
-      parsed("def foo(*); end")[3].should == [:args, :"*"]
+      parsed("def foo(*); end")[3].should == [:args, [:restarg]]
     end
   end
 
   describe "with block arg" do
-    it "should list block argument with the '&' prefix" do
-      parsed("def foo(&a); end")[3].should == [:args, :"&a"]
+    it "should list block argument" do
+      parsed("def foo(&a); end")[3].should == [:args, [:blockarg, :a]]
     end
   end
-end
 
+  describe "with keyword args" do
+    it "should list all required keyword args" do
+      parsed("def foo(a:); end")[3].should == [:args, [:kwarg, :a]]
+      parsed("def foo(a:, b:); end")[3].should == [:args, [:kwarg, :a], [:kwarg, :b]]
+    end
+
+    it "should list all optional keyword args" do
+      parsed("def foo(a: 1); end")[3].should == [:args, [:kwoptarg, :a, [:int, 1]]]
+      parsed("def foo(a: 1, b: 2); end")[3].should == [:args, [:kwoptarg, :a, [:int, 1]], [:kwoptarg, :b, [:int, 2]]]
+    end
+
+    it "should list any keyword rest arg" do
+      parsed("def foo(**); end")[3].should == [:args, [:kwrestarg]]
+      parsed("def foo(**bar); end")[3].should == [:args, [:kwrestarg, :bar]]
+    end
+
+    it "should parse combinations of keyword args" do
+      parsed("def foo(a:, b: 1, **c); end")[3].should == [:args, [:kwarg, :a], [:kwoptarg, :b, [:int, 1]], [:kwrestarg, :c]]
+    end
+  end
+end

data/spec/lib/parser/variables_spec.rb

@@ -27,20 +27,20 @@ describe Opal::Parser do
 
   describe "parses local variables inside a def" do
     it "should created by a norm arg" do
-      parsed("def a(b); b; end").should == [:def, nil, :a, [:args, :b], [:block, [:lvar, :b]]]
-      parsed("def a(b, c); c; end").should == [:def, nil, :a, [:args, :b, :c], [:block, [:lvar, :c]]]
+      parsed("def a(b); b; end").should == [:def, nil, :a, [:args, [:arg, :b]], [:block, [:lvar, :b]]]
+      parsed("def a(b, c); c; end").should == [:def, nil, :a, [:args, [:arg, :b], [:arg, :c]], [:block, [:lvar, :c]]]
     end
 
     it "should be created by an opt arg" do
-      parsed("def a(b=10); b; end").should == [:def, nil, :a, [:args, :b, [:block, [:lasgn, :b, [:int, 10]]]], [:block, [:lvar, :b]]]
+      parsed("def a(b=10); b; end").should == [:def, nil, :a, [:args, [:optarg, :b, [:int, 10]]], [:block, [:lvar, :b]]]
     end
 
     it "should be created by a rest arg" do
-      parsed("def a(*b); b; end").should == [:def, nil, :a, [:args, :"*b"], [:block, [:lvar, :b]]]
+      parsed("def a(*b); b; end").should == [:def, nil, :a, [:args, [:restarg, :b]], [:block, [:lvar, :b]]]
     end
 
     it "should be created by a block arg" do
-      parsed("def a(&b); b; end").should == [:def, nil, :a, [:args, :"&b"], [:block, [:lvar, :b]]]
+      parsed("def a(&b); b; end").should == [:def, nil, :a, [:args, [:blockarg, :b]], [:block, [:lvar, :b]]]
     end
 
     it "should not be created from locals outside the def" do

data/spec/lib/sprockets/path_reader_spec.rb

@@ -3,17 +3,19 @@ require 'lib/shared/path_reader_shared'
 require 'opal/sprockets/path_reader'
 
 describe Opal::Sprockets::PathReader do
-  subject(:path_reader) { described_class.new(env, context) }
-
-  let(:env) { Sprockets::Environment.new.tap { |e| Opal.paths.each {|p| e.append_path(p)} } }
+  let(:env) { Sprockets::Environment.new }
   let(:context) { double('context', depend_on: nil, depend_on_asset: nil) }
-
-  let(:logical_path) { 'sprockets_file' }
-  let(:fixtures_dir) { File.expand_path('../../fixtures/', __FILE__) }
-  let(:full_path) { File.join(fixtures_dir, logical_path+'.js.rb') }
   let(:contents) { File.read(full_path) }
+  let(:full_path) { fixtures_dir.join(logical_path+'.js.rb') }
+  let(:logical_path) { 'sprockets_file' }
+  let(:fixtures_dir) { Pathname('../../fixtures/').expand_path(__FILE__) }
+
+  subject(:path_reader) { described_class.new(env, context) }
 
-  before { env.append_path fixtures_dir }
+  before do
+    Opal.paths.each {|p| env.append_path(p)}
+    env.append_path fixtures_dir
+  end
 
   include_examples :path_reader do
     let(:path) { logical_path }
@@ -22,4 +24,18 @@ describe Opal::Sprockets::PathReader do
   it 'can read stuff from sprockets env' do
     expect(path_reader.read(logical_path)).to eq(contents)
   end
+
+  it 'reads js files processing their directives' do
+    path              = 'file_with_directives.js'
+    full_path         = fixtures_dir.join(path)
+    required_contents = File.read(fixtures_dir.join('required_file.js')).strip
+    read_contents     = path_reader.read(path)
+    actual_contents   = full_path.read
+
+    expect(actual_contents).to include('//= require')
+    expect(read_contents).not_to include('//= require')
+
+    expect(read_contents).to include(required_contents)
+    expect(actual_contents).not_to include(required_contents)
+  end
 end

data/spec/lib/sprockets/server_spec.rb

@@ -10,7 +10,7 @@ describe Opal::Server do
       s.main = 'opal'
       s.debug = false
       s.append_path File.expand_path('../../fixtures', __FILE__)
-      s.sprockets.logger = Logger.new('/dev/null')
+      s.sprockets.logger = Logger.new(nil)
     }
   end
 
@@ -36,7 +36,7 @@ describe Opal::Server do
 
       expect(last_response).to be_ok
       received_map_path = extract_linked_map(last_response.body)
-      expect(File.expand_path(received_map_path, js_path+'/..')).to eq(map_path)
+      expect(expand_path(received_map_path, js_path+'/..')).to eq(map_path)
 
       get '/assets/source_map/subfolder/other_file.map'
       expect(last_response).to be_ok
@@ -50,7 +50,7 @@ describe Opal::Server do
 
       expect(last_response).to be_ok
       received_map_path = extract_linked_map(last_response.body)
-      expect(File.expand_path(received_map_path, js_path+'/..')).to eq(map_path)
+      expect(expand_path(received_map_path, js_path+'/..')).to eq(map_path)
 
 
       get '/assets/source_map/subfolder/other_file.map'
@@ -65,4 +65,11 @@ describe Opal::Server do
     expect(body).to match(source_map_comment_regexp)
     body.scan(source_map_comment_regexp).first.first
   end
+
+  def expand_path(file_name, dir_string)
+    path = File.expand_path(file_name, dir_string)
+    # Remove Windows letter and colon (eg. C:) from path
+    path = path[2..-1] if !(RUBY_PLATFORM =~ /mswin|mingw/).nil?
+    path
+  end
 end

data/spec/opal/core/date_spec.rb

@@ -34,6 +34,20 @@ describe Date do
     end
   end
 
+  describe '<=>' do
+    it 'returns -1 when self is less than other' do
+      (Date.new(2015, 1, 1) <=> Date.new(2015, 1, 2)).should == -1
+    end
+
+    it 'returns 0 when self is equal to other' do
+      (Date.new(2015, 1, 1) <=> Date.new(2015, 1, 1)).should == 0
+    end
+
+    it 'returns 1 when self is greater than other' do
+      (Date.new(2015, 1, 2) <=> Date.new(2015, 1, 1)).should == 1
+    end
+  end
+
   describe "#==" do
     it "returns true if self is equal to other date" do
       (Date.new(2013, 9, 13) == Date.new(2013, 9, 13)).should == true

data/spec/opal/core/language/versions/def_2_0_spec.rb

@@ -0,0 +1,62 @@
+# TODO: this should be loaded from rubyspec instead
+
+describe "An instance method with keyword arguments" do
+  context "when there is a single keyword argument" do
+    before do
+      def foo(a: 1)
+        a
+      end
+    end
+
+    it "evaluates to the default when a value isn't provided" do
+      foo.should == 1
+    end
+
+    it "evaluates to the provided value" do
+      foo(a: 20).should == 20
+      foo(a: nil).should be_nil
+    end
+
+    it "raises an argument error when an unknown keyword argument is provided" do
+      lambda { foo(b: 20) }.should raise_error(ArgumentError)
+    end
+
+    it "raises an argument error when a non-keyword argument is provided" do
+      lambda { foo(1) }.should raise_error(ArgumentError)
+    end
+  end
+
+  it "treats a sole hash argument correctly" do
+    def foo(a, b: 10)
+      [a, b]
+    end
+    foo(b: "b").should == [{:b => "b"}, 10]
+    foo("a", b: "b").should == ["a", "b"]
+  end
+
+  it "correctly distinguishes between optional and keyword arguments" do
+    def foo(a = true, b: 10)
+      [a, b]
+    end
+    foo(b: 42).should == [true, 42]
+    foo(false, b: 42).should == [false, 42]
+  end
+
+  it "correctly distinguishes between rest and keyword arguments" do
+    def foo(*a, b: 10)
+      [a, b]
+    end
+    foo(1, 2, 3, 4).should == [[1, 2, 3, 4], 10]
+    foo(1, 2, 3, 4, b: 42).should == [[1, 2, 3, 4], 42]
+    foo(b: 42).should == [[], 42]
+  end
+
+  it "should allow keyword rest arguments" do
+    def foo(a: 1, **b)
+      [a, b]
+    end
+    foo(b: 2, c: 3, d: 4).should == [1, {:b => 2, :c => 3, :d => 4}]
+    foo(a: 4, b: 2).should == [4, {:b => 2}]
+    foo.should == [1, {}]
+  end
+end