opal 0.3.37 → 0.3.38

data/lib/opal/processor.rb

@@ -9,6 +9,14 @@ module Opal
       true
     end
 
+    class << self
+      attr_accessor :method_missing_enabled
+      attr_accessor :optimized_operators_enabled
+    end
+
+    self.method_missing_enabled = true
+    self.optimized_operators_enabled = true
+
     def initialize_engine
       require_template_library 'opal'
     end
@@ -18,8 +26,11 @@ module Opal
     end
 
     def evaluate(context, locals, &block)
-      parser = Opal::Parser.new
-      result = parser.parse data
+      options = { :method_missing => self.class.method_missing_enabled,
+                  :optimized_operators => self.class.optimized_operators_enabled }
+
+      parser  = Opal::Parser.new 
+      result  = parser.parse data, options
 
       parser.requires.each { |r| context.require_asset r }
       result

data/lib/opal/version.rb

@@ -1,3 +1,3 @@
 module Opal
-  VERSION = '0.3.37'
+  VERSION = '0.3.38'
 end

data/opal.gemspec

@@ -16,4 +16,7 @@ Gem::Specification.new do |s|
   s.require_paths  = ['lib'] 
 
   s.add_runtime_dependency 'sprockets' 
+
+  s.add_development_dependency 'opal-spec', '~> 0.2.10'
+  s.add_development_dependency 'racc'
 end

data/spec/core/array/fill_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe "Array#fill" do
+  it "returns self" do
+    ary = [1, 2, 3]
+    ary.fill(:a).should equal(ary)
+  end
+
+  it "is destructive" do
+    ary = [1, 2, 3]
+    ary.fill(:a)
+    ary.should == [:a, :a, :a]
+  end
+
+  it "replaces all elements in the array with the filler if not given an index nor a length" do
+    ary = ['a', 'b', 'c', 'duh']
+    ary.fill(8).should == [8, 8, 8, 8]
+
+    str = "x"
+    ary.fill(str).should == [str, str, str, str]
+  end
+
+  it "replaces all elements with the value of block (index given to block)" do
+    [nil, nil, nil, nil].fill { |i| i * 2 }.should == [0, 2, 4, 6]
+  end
+end

data/spec/core/array/try_convert_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+ruby_version_is "1.9" do
+  describe "Array.try_convert" do
+    it "returns the argument if it's a Array" do
+      x = Array.new
+      Array.try_convert(x).should equal(x)
+    end
+
+    it "returns nil when the argument does not respond to #to_ary" do
+      Array.try_convert(Object.new).should be_nil
+    end
+  end
+end

data/spec/core/enumerable/each_slice_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe "Enumerable#each_slice" do
+  before :each do
+    @enum = EnumerableSpecs::Numerous.new(7,6,5,4,3,2,1)
+    @sliced = [[7,6,5],[4,3,2],[1]]
+  end
+
+  it "passes element groups to the block" do
+    acc = []
+    @enum.each_slice(3) { |g| acc << g }.should be_nil
+    acc.should == @sliced
+  end
+
+  it "works when n is >= full length" do
+    full = @enum.to_a
+    acc = []
+    @enum.each_slice(full.length) { |g| acc << g }
+    acc.should == [full]
+    acc = []
+    @enum.each_slice(full.length + 1) { |g| acc << g }
+    acc.should == [full]
+  end
+end

data/spec/core/enumerable/group_by_spec.rb

@@ -0,0 +1,16 @@
+describe "Enumerable#group_by" do
+  it "returns a hash with values grouped according to the block" do
+    grouped = [:foo, :bar, :baz].group_by { |word| word[0, 1].to_sym }
+    grouped.should == { :f => [:foo], :b => [:bar, :baz] }
+  end
+
+  it "returns an empty hash for empty enumerables" do
+    [].group_by { |x| x }.should == {}
+  end
+
+  it "allows nil as a valid key" do
+    grouped = [[nil, :foo], [nil, :baz], [42, 100]].group_by { |arr| arr.first }
+    grouped[nil].should == [[nil, :foo], [nil, :baz]]
+    grouped[42].should == [[42, 100]]
+  end
+end

data/spec/core/module/const_get_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../../../fixtures/constants', __FILE__)
+
+CS_CONST1 = :const1
+
+module ConstGetSpecs
+  FOO = 100
+  
+  module Bar
+    BAR = 200
+
+    module Baz
+      BAZ = 300
+    end
+  end
+end
+
+describe "Module#const_get" do
+  it "accepts a String or Symbol name" do
+    Object.const_get(:CS_CONST1).should == :const1
+    Object.const_get("CS_CONST1").should == :const1
+  end
+
+  it "raises a NameError if no constant is defined in the search path" do
+    lambda { Object.const_get :CS_CONSTX_BAD }.should raise_error(NameError)
+  end
+
+  it "searches parent scopes of classes and modules" do
+    ConstGetSpecs::Bar::Baz.const_get(:BAZ).should eq(300)
+    ConstGetSpecs::Bar::Baz.const_get(:BAR).should eq(200)
+    ConstGetSpecs::Bar::Baz.const_get(:FOO).should eq(100)
+    ConstGetSpecs::Bar::Baz.const_get(:Bar).should eq(ConstGetSpecs::Bar)
+  end
+end

data/spec/core/module/undef_method_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+require File.expand_path('../fixtures/classes', __FILE__)
+
+module ModuleSpecs
+  class NoInheritance
+    def method_to_undef() 1 end
+    def another_method_to_undef() 1 end
+  end
+
+  class Parent
+    def method_to_undef() 1 end
+    def another_method_to_undef() 1 end
+  end
+
+  class Child < Parent
+  end
+
+  class Ancestor
+    def method_to_undef() 1 end
+    def another_method_to_undef() 1 end
+  end
+
+  class Descendant < Ancestor
+  end
+end
+
+describe "Module#undef_method with symbol" do
+  it "removes a method defined in a class" do
+    x = ModuleSpecs::NoInheritance.new
+
+    x.method_to_undef.should == 1
+
+    ModuleSpecs::NoInheritance.send :undef_method, :method_to_undef
+
+    lambda { x.method_to_undef }.should raise_error(NoMethodError)
+  end
+
+  it "removes a method defined in a super class" do
+    child = ModuleSpecs::Child.new
+    child.method_to_undef.should == 1
+
+    ModuleSpecs::Child.send :undef_method, :method_to_undef
+
+    lambda { child.method_to_undef }.should raise_error(NoMethodError)
+  end
+end
+
+describe "Module#undef_method with string" do
+  it "removes a method defined in a class" do
+    x = ModuleSpecs::NoInheritance.new
+
+    x.another_method_to_undef.should == 1
+
+    ModuleSpecs::NoInheritance.send :undef_method, 'another_method_to_undef'
+
+    lambda { x.another_method_to_undef }.should raise_error(NoMethodError)
+  end
+
+  it "removes a method defined in a super class" do
+    child = ModuleSpecs::Child.new
+    child.another_method_to_undef.should == 1
+
+    ModuleSpecs::Child.send :undef_method, 'another_method_to_undef'
+
+    lambda { child.another_method_to_undef }.should raise_error(NoMethodError)
+  end
+end

data/spec/core/nil/to_h_spec.rb

@@ -0,0 +1,10 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+ruby_version_is "2.0" do
+  describe "NilClass#to_h" do
+    it "returns an empty hash" do
+      nil.to_h.should == {}
+      nil.to_h.default.should == nil
+    end
+  end
+end

data/spec/core/proc/element_reference_spec.rb

@@ -0,0 +1,21 @@
+describe "Proc#[]" do
+  it "invokes self" do
+    Proc.new { "test!" }[].should == "test!"
+    lambda { "test!" }[].should == "test!"
+    proc { "test!" }[].should == "test!"
+  end
+
+  it "sets self's parameters to the given values" do
+    Proc.new { |a, b| a + b }[1, 2].should == 3
+    Proc.new { |*args| args }[1, 2, 3, 4].should == [1, 2, 3, 4]
+    Proc.new { |_, *args| args }[1, 2, 3].should == [2, 3]
+
+    lambda { |a, b| a + b }[1, 2].should == 3
+    lambda { |*args| args }[1, 2, 3, 4].should == [1, 2, 3, 4]
+    lambda { |_, *args| args }[1, 2, 3].should == [2, 3]
+
+    proc { |a, b| a + b }[1, 2].should == 3
+    proc { |*args| args }[1, 2, 3, 4].should == [1, 2, 3, 4]
+    proc { |_, *args| args }[1, 2, 3].should == [2, 3]
+  end
+end

data/spec/core_ext/method_missing_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+module MethodMissingSpecs
+  class A
+    def method_missing(mid, *args)
+      [mid, args]
+    end
+  end
+
+  class B
+    def method_missing(mid, *args, &block)
+      [mid, block]
+    end
+  end
+end
+
+describe "method_missing" do
+  before do
+    @obj = MethodMissingSpecs::A.new
+  end
+
+  it "should pass the missing method name as first argument" do
+    @obj.foo.should eq([:foo, []])
+  end
+
+  it "should correctly pass arguments to method_missing" do
+    @obj.bar(1, 2, 3).should eq([:bar, [1, 2, 3]])
+  end
+
+  it "should pass blocks to method_missing" do
+    obj = MethodMissingSpecs::B.new
+    proc = proc { 1 }
+    obj.baz(1, 2, &proc).should eq([:baz, proc])
+  end
+end
+
+describe "BasicObject#method_missing" do
+  it "raises an error for the missing method" do
+    lambda {
+      BasicObject.new.foo_bar_baz
+    }.should raise_error(Exception)
+  end
+end

data/spec/core_ext/native/fixtures/classes.rb

@@ -0,0 +1,5 @@
+require "opal/native"
+
+class NativeSpecs
+  include Native
+end

data/spec/core_ext/native/initialize_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+
+describe "Native#initialize" do
+  it "raises an error when passed null or undefined" do
+    lambda { NativeSpecs.new(`null`) }.should raise_error(Exception)
+    lambda { NativeSpecs.new(`undefined`) }.should raise_error(Exception)
+  end
+end

data/spec/core_ext/native/method_missing_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe "Native#method_missing" do
+  it "forwards methods to wrapped object as native function calls" do
+    NativeSpecs.new("adam").toUpperCase.should eq("ADAM")
+  end
+end

data/spec/core_ext/native/to_native_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe "Native#to_native" do
+  it "returns the wrapped object" do
+    NativeSpecs.new(:foo).to_native.should eq(:foo)
+  end
+end

data/spec/grammar/parser_spec.rb

@@ -22,7 +22,7 @@ describe "Opal::Parser" do
   it "should parse constant lookups" do
     opal_eval("Object").should == Object
     opal_eval("Array").should == Array
-    opal_eval("OpalSpec::ExampleGroup").should == OpalSpec::ExampleGroup
+    opal_eval("Spec::ExampleGroup").should == Spec::ExampleGroup
   end
 
   it "should parse class and module definitions" do

data/spec/language/super_spec.rb

@@ -43,9 +43,29 @@ describe "The super keyword" do
   it "calls the superclass when initial method is define_method'd" do
     Super::S7.new.here.should == :good
   end
+
+  describe "with no arguments or parens" do
+    it "should pass all given arguments in current method to super" do
+      Super::NoArgs::B.new.foo(1, 4, 9).should eq([1, 4, 9, 42])
+    end
+  end
 end
 
 module Super
+  module NoArgs
+    class A
+      def foo(a, b, c)
+        [a, b, c]
+      end
+    end
+
+    class B < A
+      def foo(a, b, c)
+        super << 42
+      end
+    end
+  end
+
   module S1
     class A
       def foo(a)

data/spec/language/variables_spec.rb

@@ -23,6 +23,75 @@ describe "Basic assignment" do
     a = *[[]];      a.should == [[]]
     a = *[1,2];     a.should == [1,2]
   end
+
+  it "sets unavailable values to nil" do
+    ary = []
+    a, b, c = ary
+
+    a.should be_nil
+    b.should be_nil
+    c.should be_nil
+  end
+
+  it "sets the splat to an empty Array if there are no more values" do
+    ary = []
+    a, b, *c = ary
+
+    a.should be_nil
+    b.should be_nil
+    c.should == []
+  end
+
+  it "allows multiple values to be assigned" do
+    a,b,*c = nil;       [a,b,c].should == [nil, nil, []]
+    a,b,*c = 1;         [a,b,c].should == [1, nil, []]
+    a,b,*c = [];        [a,b,c].should == [nil, nil, []]
+    a,b,*c = [1];       [a,b,c].should == [1, nil, []]
+    a,b,*c = [nil];     [a,b,c].should == [nil, nil, []]
+    a,b,*c = [[]];      [a,b,c].should == [[], nil, []]
+    a,b,*c = [1,2];     [a,b,c].should == [1,2,[]]
+
+    a,b,*c = *nil;      [a,b,c].should == [nil, nil, []]
+    a,b,*c = *[];       [a,b,c].should == [nil, nil, []]
+    a,b,*c = *[nil];    [a,b,c].should == [nil, nil, []]
+    a,b,*c = *[[]];     [a,b,c].should == [[], nil, []]
+    a,b,*c = *[1,2];    [a,b,c].should == [1,2,[]]
+  end
+
+  it "allows assignment through lambda" do
+    f = lambda {|r,*l| r.should == []; l.should == [1]}
+    f.call([], *[1])
+
+    f = lambda{|x| x}
+    f.call(42).should == 42
+    f.call([42]).should == [42]
+    f.call([[42]]).should == [[42]]
+    f.call([42,55]).should == [42,55]
+
+    f = lambda{|*x| x}
+    f.call(42).should == [42]
+    f.call([42]).should == [[42]]
+    f.call([[42]]).should == [[[42]]]
+    f.call([42,55]).should == [[42,55]]
+    f.call(42,55).should == [42,55]
+  end
+
+  it "allows chained assignment" do
+    (a = 1 + b = 2 + c = 4 + d = 8).should == 15
+    d.should == 8
+    c.should == 12
+    b.should == 14
+    a.should == 15
+  end
+end
+
+describe "Assignment using expansion" do
+  ruby_version_is "1.9" do
+    it "succeeds without conversion" do
+      *x = (1..7).to_a
+      x.should == [1, 2, 3, 4, 5, 6, 7]
+    end
+  end
 end
 
 describe "Assigning multiple values" do