start adding more test cases

Author: fractaledmind

test/processor.test.rb

@@ -1,29 +1,200 @@
 # frozen_string_literal: true
 
-test "basic" do
+test "no return type, no args leaves as is" do
 	processed = Literally::Processor.call(<<~RUBY)
-		def foo(a: Integer, b: String) = Numeric do
+		def foo
+			"a"
+		end
+	RUBY
+
+	assert_equal_ruby processed, <<~RUBY
+		def foo
+			"a"
+		end
+	RUBY
+end
+
+test "no return type, required keyword arg leaves as is" do
+	processed = Literally::Processor.call(<<~RUBY)
+		def foo(a:)
 			a
 		end
 	RUBY
 
 	assert_equal_ruby processed, <<~RUBY
-		def foo(a: nil, b: nil);binding.assert(a: Integer, b: String);__literally_returns__ = (;
+		def foo(a:)
 			a
-		;);binding.assert(__literally_returns__: Numeric);__literally_returns__;end
+		end
 	RUBY
 end
 
-test "no args" do
+test "no return type, optional keyword arg leaves as is" do
 	processed = Literally::Processor.call(<<~RUBY)
-		def foo = Numeric do
+		def foo(a: nil)
+			a
+		end
+	RUBY
+
+	assert_equal_ruby processed, <<~RUBY
+		def foo(a: nil)
+			a
+		end
+	RUBY
+end
+
+test "no return type, required positional arg leaves as is" do
+	processed = Literally::Processor.call(<<~RUBY)
+		def foo(a)
+			a
+		end
+	RUBY
+
+	assert_equal_ruby processed, <<~RUBY
+		def foo(a)
+			a
+		end
+	RUBY
+end
+
+test "no return type, optional positional arg leaves as is" do
+	processed = Literally::Processor.call(<<~RUBY)
+		def foo(a = nil)
+			a
+		end
+	RUBY
+
+	assert_equal_ruby processed, <<~RUBY
+		def foo(a = nil)
+			a
+		end
+	RUBY
+end
+
+test "no return type, mixed args leaves as is" do
+	processed = Literally::Processor.call(<<~RUBY)
+		def foo(a, b = nil, c:, d: nil)
+			a
+		end
+	RUBY
+
+	assert_equal_ruby processed, <<~RUBY
+		def foo(a, b = nil, c:, d: nil)
+			a
+		end
+	RUBY
+end
+
+test "return type, no args processes" do
+	processed = Literally::Processor.call(<<~RUBY)
+		def say_hello = String do
+			"Hello World!"
+		end
+	RUBY
+
+	assert_equal_ruby processed, <<~RUBY
+		def say_hello;__literally_returns__ = (;
+			"Hello World!"
+		;);binding.assert(__literally_returns__: String);__literally_returns__;end
+	RUBY
+end
+
+test "_Void return type, no args processes" do
+	processed = Literally::Processor.call(<<~RUBY)
+		def return_nothing = _Void do
+			background_work
+		end
+	RUBY
+
+	assert_equal_ruby processed, <<~RUBY
+		def return_nothing;__literally_returns__ = (;
+			background_work
+		;);binding.assert(__literally_returns__: _Void);__literally_returns__;end
+	RUBY
+end
+
+test "_Any? return type, no args processes" do
+	processed = Literally::Processor.call(<<~RUBY)
+		def foo = _Any? do
 			a
 		end
 	RUBY
 
 	assert_equal_ruby processed, <<~RUBY
 		def foo;__literally_returns__ = (;
 			a
+		;);binding.assert(__literally_returns__: _Any?);__literally_returns__;end
+	RUBY
+end
+
+test "return type, positional arg processes" do
+	processed = Literally::Processor.call(<<~'RUBY')
+		def say_hello(name = String) = String do
+			"Hello #{name}!"
+		end
+	RUBY
+
+	assert_equal_ruby(processed, <<~'RUBY')
+		def say_hello(name = nil);binding.assert(name: String);__literally_returns__ = (;
+			"Hello #{name}!"
+		;);binding.assert(__literally_returns__: String);__literally_returns__;end
+	RUBY
+end
+
+test "return type, positional arg with default processes" do
+	processed = Literally::Processor.call(<<~'RUBY')
+		def say_hello(name = String {"World"}) = String do
+			"Hello #{name}!"
+		end
+	RUBY
+
+	assert_equal_ruby(processed, <<~'RUBY')
+		def say_hello(name = "World");binding.assert(name: String);__literally_returns__ = (;
+			"Hello #{name}!"
+		;);binding.assert(__literally_returns__: String);__literally_returns__;end
+	RUBY
+end
+
+test "return type, keyword arg processes" do
+	processed = Literally::Processor.call(<<~'RUBY')
+		def say_hello(name: String) = String do
+			"Hello #{name}!"
+		end
+	RUBY
+
+	assert_equal_ruby(processed, <<~'RUBY')
+		def say_hello(name: nil);binding.assert(name: String);__literally_returns__ = (;
+			"Hello #{name}!"
+		;);binding.assert(__literally_returns__: String);__literally_returns__;end
+	RUBY
+end
+
+test "return type, keyword arg with default processes" do
+	processed = Literally::Processor.call(<<~'RUBY')
+		def say_hello(name: String {"World"}) = String do
+			"Hello #{name}!"
+		end
+	RUBY
+
+	assert_equal_ruby(processed, <<~'RUBY')
+		def say_hello(name: "World");binding.assert(name: String);__literally_returns__ = (;
+			"Hello #{name}!"
+		;);binding.assert(__literally_returns__: String);__literally_returns__;end
+	RUBY
+end
+
+
+
+
+test "basic" do
+	processed = Literally::Processor.call(<<~RUBY)
+		def foo(a: Integer, b: String) = Numeric do
+			a
+		end
+	RUBY
+
+	assert_equal_ruby processed, <<~RUBY
+		def foo(a: nil, b: nil);binding.assert(a: Integer, b: String);__literally_returns__ = (;
+			a
 		;);binding.assert(__literally_returns__: Numeric);__literally_returns__;end
 	RUBY
 end
@@ -85,16 +256,3 @@ def foo(a: nil, b: nil);binding.assert(a: Integer, b: String);__literally_return
 	RUBY
 end
 
-test "positionals" do
-	processed = Literally::Processor.call(<<~RUBY)
-		def foo(a = Integer, b = String) = Numeric do
-			a
-		end
-	RUBY
-
-	assert_equal_ruby processed, <<~RUBY
-		def foo(a = nil, b = nil);binding.assert(a: Integer, b: String);__literally_returns__ = (;
-			a
-		;);binding.assert(__literally_returns__: Numeric);__literally_returns__;end
-	RUBY
-end