code-ruby 3.0.13 → 3.1.2

data/spec/code/object/function_spec.rb

@@ -3,22 +3,22 @@
 require "spec_helper"
 
 RSpec.describe Code::Object::Function do
-  #   [
-  #     ["even? = (i) => { i.even? } even?(2)", "true"],
-  #     ["even? = (i:) => { i.even? } even?(i: 2)", "true"],
-  #     ["add = (a, b) => { a + b } add(1, 2)", "3"],
-  #     ["minus = (a:, b:) => { a - b } minus(b: 1, a: 2)", "1"]
-  #   ].each do |input, expected|
-  #     it "#{input} == #{expected}" do
-  #       expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
-  #     end
-  #   end
+  [
+    ["even? = (i) => { i.even? } even?(2)", "true"],
+    ["even? = (i:) => { i.even? } even?(i: 2)", "true"],
+    ["add = (a, b) => { a + b } add(1, 2)", "3"],
+    ["minus = (a:, b:) => { a - b } minus(b: 1, a: 2)", "1"]
+  ].each do |input, expected|
+    it "#{input} == #{expected}" do
+      expect(Code.evaluate(input)).to eq(Code.evaluate(expected))
+    end
+  end
 
   context "valid" do
     [
       "f = () => {} f",
-      "f = (x) => {} f(1)"
-      #      "f = (x:) => {} f(x: 1)"
+      "f = (x) => {} f(1)",
+      "f = (x:) => {} f(x: 1)"
     ].each do |input|
       it "#{input} is valid" do
         Code.evaluate(input)
@@ -38,6 +38,46 @@ RSpec.describe Code::Object::Function do
     end
   end
 
+  it "evaluates omitted keyword argument defaults" do
+    result = Code.evaluate(<<~CODE)
+      f = (number: 1, text: "fallback", missing: nothing, headers: {}) => {
+        [
+          number,
+          text,
+          missing.nothing?,
+          headers.merge({ authorization: "Bearer x" })
+        ]
+      }
+
+      f()
+    CODE
+
+    expect(result).to eq(
+      Code.evaluate('[1, "fallback", true, { authorization: "Bearer x" }]')
+    )
+  end
+
+  it "evaluates keyword defaults in the call context" do
+    expect(Code.evaluate("f = (a:, b: a + 1) => { b } f(a: 2)")).to eq(
+      Code.evaluate("3")
+    )
+  end
+
+  it "binds self when calling a function stored on a dictionary" do
+    result = Code.evaluate(<<~CODE)
+      object = {}
+      object.value = 1
+      object.fetch = () => {
+        self.value
+      }
+      object.fetch()
+    CODE
+
+    expect(result).to eq(
+      Code.evaluate("1")
+    )
+  end
+
   it "captures self for constructor-like functions that return self" do
     result = Code.evaluate(<<~CODE)
         User = (given_name:, family_name:, birth_date:) => {
@@ -72,6 +112,73 @@ RSpec.describe Code::Object::Function do
     )
   end
 
+  it "binds parent to the enclosing self for nested constructor functions" do
+    result = Code.evaluate(<<~CODE)
+        Account = (name:) => {
+          self.name = name
+
+          self.Project = (name:) => {
+            self.name = name
+
+            self.Task = (name:) => {
+              self.name = name
+
+              [
+                self.name,
+                parent.name,
+                parent.parent.name
+              ]
+            }
+
+            return(self)
+          }
+
+          return(self)
+        }
+
+        account = Account(name: "Acme")
+        Project = account.get(:Project)
+        project = Project(name: "Migration")
+        Task = project.get(:Task)
+        Task(name: "Import")
+      CODE
+
+    expect(result).to eq(
+      Code.evaluate('["Import", "Migration", "Acme"]')
+    )
+  end
+
+  it "allows parent chains deeper than two levels" do
+    result = Code.evaluate(<<~CODE)
+        A = (name:) => {
+          self.name = name
+          self.B = (name:) => {
+            self.name = name
+            self.C = (name:) => {
+              self.name = name
+              self.D = (name:) => {
+                self.name = name
+                parent.parent.parent.name
+              }
+              return(self)
+            }
+            return(self)
+          }
+          return(self)
+        }
+
+        a = A(name: "a")
+        B = a.get(:B)
+        b = B(name: "b")
+        C = b.get(:C)
+        c = C(name: "c")
+        D = c.get(:D)
+        D(name: "d")
+      CODE
+
+    expect(result).to eq(Code::Object::String.new("a"))
+  end
+
   it "supports constructor methods on functions" do
     result = Code.evaluate(<<~CODE)
         User = (given_name:, family_name:) => {

data/spec/code/object/list_spec.rb

@@ -5,6 +5,8 @@ require "spec_helper"
 RSpec.describe Code::Object::List do
   [
     ["[] == []", "true"],
+    ["[nothing, 1, false, \"\"].compact", '[1, false, ""]'],
+    ["[nothing, 1, false, \"\"].compact(&:blank?)", "[1]"],
     ["[1, 2, 3].sum", "6"],
     ["[1, 2] + [3, 4]", "[1, 2, 3, 4]"],
     ["[] + []", "[]"],

data/spec/code_spec.rb

@@ -13,6 +13,74 @@ RSpec.describe Code do
     [result, output.string]
   end
 
+  def control_flow_block_calls
+    [
+      "[1].each { CONTROL }",
+      "[1, 2].any? { CONTROL }",
+      "[1].detect { CONTROL }",
+      "[1].map { CONTROL }",
+      "xs = [1] xs.map! { CONTROL }",
+      "[1].max { CONTROL }",
+      "[1].none? { CONTROL }",
+      "[1].all? { CONTROL }",
+      "[1, 2].reduce { |acc, item| CONTROL }",
+      "[nothing].compact { CONTROL }",
+      "xs = [nothing] xs.compact! { CONTROL }",
+      "[1].select { CONTROL }",
+      "xs = [1] xs.select! { CONTROL }",
+      "[1].reject { CONTROL }",
+      "xs = [1] xs.reject! { CONTROL }",
+      "[1].sort { CONTROL }",
+      "[1].uniq { CONTROL }",
+      "(1..1).all? { CONTROL }",
+      "(1..1).any? { CONTROL }",
+      "(1..1).each { CONTROL }",
+      "(1..1).map { CONTROL }",
+      "(1..1).select { CONTROL }",
+      "{a: 1}.any? { CONTROL }",
+      "{a: 1}.compact { CONTROL }",
+      "hash = {a: 1} hash.compact! { CONTROL }",
+      "{a: 1}.delete(:b) { CONTROL }",
+      "hash = {a: 1} hash.delete_if { CONTROL }",
+      "hash = {a: 1} hash.delete_unless { CONTROL }",
+      "{a: 1}.each { CONTROL }",
+      "{a: 1}.fetch(:b) { CONTROL }",
+      "hash = {a: 1} hash.keep_if { CONTROL }",
+      "hash = {a: 1} hash.keep_unless { CONTROL }",
+      "{a: 1}.key(2) { CONTROL }",
+      "{a: 1}.merge({a: 2}) { CONTROL }",
+      "hash = {a: 1} hash.merge!({a: 2}) { CONTROL }",
+      "{a: 1}.select { CONTROL }",
+      "hash = {a: 1} hash.select! { CONTROL }",
+      "{a: 1}.transform_values { CONTROL }",
+      "1.times { CONTROL }",
+      "Html.p { CONTROL }",
+      "Html.escape { CONTROL }",
+      "Html.unescape { CONTROL }",
+      "Html.join(Html.br) { CONTROL }",
+      "Html.text { CONTROL }",
+      "Html.raw { CONTROL }",
+      "Html.raw(\"<p>a</p>\").css(\"p\").map { CONTROL }"
+    ]
+  end
+
+  %w[return break next continue].each do |control_flow|
+    it "continues after #{control_flow} in block methods" do
+      aggregate_failures do
+        control_flow_block_calls.each do |block_call|
+          input = "#{block_call.sub("CONTROL", control_flow)} puts(:end)"
+          formatted = format_input(input)
+
+          _result, output = evaluate_with_output(input)
+          _formatted_result, formatted_output = evaluate_with_output(formatted)
+
+          expect(output).to eq("end\n"), input
+          expect(formatted_output).to eq("end\n"), formatted
+        end
+      end
+    end
+  end
+
   (
     [
       "{ a: 1, b: 2 }.transform_values { |key| key.upcase }",
@@ -328,6 +396,18 @@ RSpec.describe Code do
       ["[1, 2, 3]", "[1, 2, 3]"],
       ["[1, 2, 3].include?(2)", "true"],
       ["[1, 2, 3].include?(4)", "false"],
+      [
+        "summary = { by_status: { draft: 1 } } k = \"draft\" summary.by_status[k]",
+        "1"
+      ],
+      [
+        "summary = { by_status: {} } k = \"draft\" summary.by_status[k] = 1 summary",
+        '{"by_status" => {"draft" => 1}}'
+      ],
+      [
+        "summary = { by_status: {} } [{status: \"draft\"}].each { |track| summary.by_status[track[:status]] = 1 } summary",
+        '{"by_status" => {"draft" => 1}}'
+      ],
       ["[1, 2, 3].map { |i| continue(0) if i.even? i ** 2}", "[1, 0, 9]"],
       ["[1, 2, 3].map { |i| next if i == 2 i ** 2}", "[1, nothing, 9]"],
       ["[1, 2, 3].map { |i| next(0) if i.even? i ** 2}", "[1, 0, 9]"],
@@ -340,6 +420,7 @@ RSpec.describe Code do
       ["[1, 2].map(&:to_string)", '["1", "2"]'],
       ["[1, 2].map(&:to_string)", '["1", "2"]'],
       ["[1].each do end", "[1]"],
+      ["x = [1].each { break(42) } x", "42"],
       ["[[true]]", "[[true]]"],
       ["[]", "[]"],
       ["\r\n", "nothing"],
@@ -350,6 +431,8 @@ RSpec.describe Code do
       ],
       ["a = 0 loop a += 1 break end a", "1"],
       ["x = loop break(42) end x", "42"],
+      ["x = loop { |index| break(index) if index > 3 } x", "4"],
+      ["x = loop do |index| break(index) if index > 3 end x", "4"],
       ["a = 0\nuntil a > 10 a += 1 end a", "11"],
       ["a = 0\nwhile a < 10 a += 1 end a", "10"],
       ["a = 1 3.times { a += 1 } a", "4"],
@@ -529,7 +612,11 @@ RSpec.describe Code do
     end
   end
 
-  [["puts(true)", "true\n"], %w[print(false) false]].each do |input, expected|
+  [
+    ["puts(true)", "true\n"],
+    %w[print(false) false],
+    ["[1].each { break } puts(:end)", "end\n"]
+  ].each do |input, expected|
     it "#{input} prints #{expected}" do
       formatted = format_input(input)
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 3.0.13
+  version: 3.1.2
 platform: ruby
 authors:
 - Dorian Marié