Run keyword arg specs

adambeynon · adambeynon · commit bf67f949ec77 · 2014-12-01T10:47:48.000Z
diff --git a/lib/opal/nodes/def.rb b/lib/opal/nodes/def.rb
@@ -15,6 +15,10 @@ def compile
 
         opt = args[1..-1].select { |a| a.first == :optarg }
 
+        @kwargs = args[1..-1].select do |arg|
+          [:kwarg, :kwoptarg, :kwrestarg].include? arg.first
+        end
+
         argc = args.length - 1
 
         # block name (&block)
@@ -35,7 +39,7 @@ def compile
         end
 
         if compiler.arity_check?
-          arity_code = arity_check(args, opt, uses_splat, block_name, mid)
+          arity_code = arity_check(args, opt, uses_splat, @kwargs, block_name, mid)
         end
 
         in_scope do
@@ -64,6 +68,8 @@ def compile
             line "}"
           end
 
+          compile_keyword_args
+
           # must do this after opt args incase opt arg uses yield
           scope_name = scope.identity
 
@@ -112,6 +118,39 @@ def compile
         wrap '(', ", nil) && '#{mid}'" if expr?
       end
 
+      def compile_keyword_args
+        return if @kwargs.empty?
+        helper :hash2
+
+        line "if ($kwargs == null) {"
+        line "  $kwargs = $hash2([], {});"
+        line "}"
+        line "if (!$kwargs.$$is_hash) {"
+        line "  throw new Error('expecting keyword args');"
+        line "}"
+
+        @kwargs.each do |kwarg|
+          case kwarg.first
+          when :kwoptarg
+            arg_name = kwarg[1]
+            var_name = variable(arg_name.to_s)
+            line "if ((#{var_name} = $kwargs.smap['#{arg_name}']) == null) {"
+            line "  #{var_name} = ", expr(kwarg[2])
+            line "}"
+          when :kwarg
+            arg_name = kwarg[1]
+            var_name = variable(arg_name.to_s)
+            line "if ((#{var_name} = $kwargs.smap['#{arg_name}']) == null) {"
+            line "  throw new Error('expecting keyword arg: #{arg_name}')"
+            line "}"
+          when :kwrestarg
+            nil
+          else
+            raise "unknown kwarg type #{kwarg.first}"
+          end
+        end
+      end
+
       # Simple helper to check whether this method should be defined through
       # `Opal.defn()` runtime helper.
       #
@@ -129,14 +168,18 @@ def uses_defn?(scope)
       end
 
       # Returns code used in debug mode to check arity of method call
-      def arity_check(args, opt, splat, block_name, mid)
+      def arity_check(args, opt, splat, kwargs, block_name, mid)
         meth = mid.to_s.inspect
 
         arity = args.size - 1
         arity -= (opt.size)
+
         arity -= 1 if splat
+
+        arity -= (kwargs.size)
+
         arity -= 1 if block_name
-        arity = -arity - 1 if !opt.empty? or splat
+        arity = -arity - 1 if !opt.empty? or !kwargs.empty? or splat
 
         # $arity will point to our received arguments count
         aritycode = "var $arity = arguments.length;"
@@ -154,15 +197,26 @@ class ArgsNode < Base
       handle :args
 
       def compile
+        done_kwargs = false
         children.each_with_index do |child, idx|
           next if :blockarg == child.first
           next if :restarg == child.first and child[1].nil?
 
-          child = child[1].to_sym
-          push ', ' unless idx == 0
-          child = variable(child)
-          scope.add_arg child.to_sym
-          push child.to_s
+          case child.first
+          when :kwarg, :kwoptarg, :kwrestarg
+            unless done_kwargs
+              done_kwargs = true
+              push ', ' unless idx == 0
+              scope.add_arg '$kwargs'
+              push '$kwargs'
+            end
+          else
+            child = child[1].to_sym
+            push ', ' unless idx == 0
+            child = variable(child)
+            scope.add_arg child.to_sym
+            push child.to_s
+          end
         end
       end
     end
diff --git a/opal/corelib/hash.rb b/opal/corelib/hash.rb
@@ -3,6 +3,9 @@
 class Hash
   include Enumerable
 
+  # Mark all hash instances as valid hashes (used to check keyword args, etc)
+  `def.$$is_hash = true`
+
   def self.[](*objs)
     `Opal.hash.apply(null, objs)`
   end
diff --git a/spec/opal/core/language/versions/def_2_0_spec.rb b/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
