code-ruby 0.3.1 → 0.5.0

data/spec/code/if_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+RSpec.describe "if" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["if true 1", "1"],
+    ["unless false 1", "1"],
+    ["if false 1", ""],
+    ["unless true 1", ""],
+    ["if false 1 else 2", "2"],
+    ["if false 1 elsif true 2", "2"],
+    ["if false 1 elsif false 2", ""],
+    ["if false 1 else if true 2", "2"],
+    ["if false 1 else if false 2", ""],
+    ["if false 1 else unless false 2", "2"],
+    ["if false 1 else unless true 2", ""]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/list_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+RSpec.describe "list" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["[]", "[]"],
+    ["[1, 2, 3]", "[1, 2, 3]"],
+    ["[[true]]", "[[true]]"]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/multiplication_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+RSpec.describe "multiplication" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["2 * 3", "6"],
+    ["2 * 3 + 2", "8"],
+    ["2 / 4", "0.5"],
+    ["4 % 3", "1"]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/negation_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+RSpec.describe "function" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    %w[!false true],
+    %w[!!true true],
+    %w[!!1 true],
+    %w[+1 1],
+    %w[+1.0 1.0],
+    %w[+true true]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/not_keyword_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe "not keyword" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [["not true", "false"], ["not not false", "false"]].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/nothing_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+RSpec.describe "nothing" do
+  subject { Code.evaluate(input).to_s }
+
+  [
+    ["nothing", ""],
+    ["null", ""],
+    ["nil", ""],
+    ["nothing null", ""]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/number_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+RSpec.describe "number" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    %w[0 0],
+    %w[1.1 1.1],
+    %w[0x10 16],
+    %w[0o10 8],
+    %w[0b10 2],
+    %w[1e1 10],
+    %w[1.0e1 10.0],
+    %w[10e1.0 100.0]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/or_keyword_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+RSpec.describe "or keyword" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["true or false", "true"],
+    ["true and false", "false"],
+    ["random = 1 random", "1"]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/or_operator_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+RSpec.describe "or operator" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["true || false", "true"],
+    ["false || false", "false"]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/parser/boolean_spec.rb

@@ -1,18 +1,16 @@
 require "spec_helper"
 
 RSpec.describe Code::Parser::Boolean do
-  subject { described_class.new.parse(input) }
+  subject { Code::Parser.parse(input) }
 
   [
-    ["true", { boolean: "true" }],
-    ["false", { boolean: "false" }],
-  ].each do |(input, expected)|
+    ["true", [{ boolean: "true" }]],
+    ["false", [{ boolean: "false" }]]
+  ].each do |input, output|
     context input.inspect do
       let(:input) { input }
 
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
+      it { expect(subject).to eq(output) }
     end
   end
 end

data/spec/code/parser/call_spec.rb

@@ -1,66 +1,26 @@
 require "spec_helper"
 
 RSpec.describe Code::Parser::Call do
-  subject { described_class.new.parse(input) }
+  subject { Code::Parser.parse(input) }
 
   [
-    [
-      "user.first_name",
-      { call: { left: { name: "user" }, right: [{ name: "first_name" }] } },
-    ],
-    [
-      "3.times",
-      {
-        call: {
-          left: {
-            number: {
-              base_10: {
-                integer: {
-                  whole: "3",
-                },
-              },
-            },
-          },
-          right: [{ name: "times" }],
-        },
-      },
-    ],
-  ].each do |(input, expected)|
-    context input.inspect do
-      let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
-    end
-  end
-
-  [
-    "User.first",
-    "User.first(10)",
-    'User.find_by(name: "Dorian")',
-    "User.update_all(**attributes)",
-    "User.each(&block)",
-    "user.update(*args)",
-    "sort([1, 2, 3], :asc)",
-    "render()",
-    "render(item)",
-    "Renderer.render(item)",
-    "render(item) { 'Hello' }",
-    "render(item) { |item| item * 2 }",
-    "render(item) { |item1, item2| item1 + item2 }",
-    "render(item) do 'Hello' end",
-    "render(item) do |item| item * 2 end",
-    "render(item) do |item1, item2| item1 + item2 end",
-    "(1..2).any?(&:even?)",
-    "(2..5).select { |i| i.even? }.any? { |n| n.even? }",
+    "a",
+    "hello",
+    "hello()",
+    "render(user)",
+    'render(user, first_name: "Dorian")',
+    "render { }",
+    "render do end",
+    "render { |name| name.upcase }",
+    "render(user) { |name| name.upcase }",
+    "render(user) do |name| name.upcase end",
+    'render { "Dorian" }',
+    'render(user) { "Dorian" }',
+    'render(user) do "Dorian" end'
   ].each do |input|
-    context input.inspect do
+    context input do
       let(:input) { input }
-
-      it "succeeds" do
-        expect { subject }.to_not raise_error
-      end
+      it { subject }
     end
   end
 end

data/spec/code/parser/chained_call.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::ChainedCall do
+  subject { Code::Parser.parse(input) }
+
+  [
+    "a.b",
+    "user.first_name",
+    "user.admin?",
+    'user.update!(name: "Dorian")'
+  ].each do |input|
+    context input do
+      let(:input) { input }
+      it { subject }
+    end
+  end
+end

data/spec/code/parser/dictionnary_spec.rb

@@ -1,19 +1,18 @@
 require "spec_helper"
 
 RSpec.describe Code::Parser::Dictionnary do
-  subject { described_class.new.parse(input) }
+  subject { Code::Parser.parse(input) }
 
   [
-    '{name: "Dorian"}',
-    '{a: true, "b": false}',
-    "{ true => 1, false => 2}",
+    "{}",
+    "{ }",
+    "{/* comment */}",
+    "{ a: 1, b: 2, c: 3 }",
+    '{ "first_name": "Dorian" }'
   ].each do |input|
-    context input.inspect do
+    context input do
       let(:input) { input }
-
-      it "succeeds" do
-        expect { subject }.to_not raise_error
-      end
+      it { subject }
     end
   end
 end

data/spec/code/parser/function_spec.rb

@@ -1,32 +1,16 @@
 require "spec_helper"
 
 RSpec.describe Code::Parser::Function do
-  subject { described_class.new.parse(input) }
+  subject { Code::Parser.parse(input) }
 
   [
     "() => {}",
-    '() => { "Hello" }',
-    "(a) => { }",
-    "(a = 1)=> {}",
-    "(a, b) =>{}",
-    "(a, b = 2, c = b)=>{}",
-    "(a:)=>{}",
-    "(a:, b:)=>{}",
-    "(a, b:, c)=>{}",
-    "(a:, b: 1)=>{}",
-    "(a, b: 1, c)=>{}",
-    "(*args)=>{}",
-    "(*args, **kargs)=>{}",
-    "(&block)=>{}",
-    "(a = b = 1 + 1 b)=>{}",
-    "(a: b = 1 + 1 b)=>{}",
+    "(a, b) => { add(a, b) }",
+    "(a:, b:) => { add(a, b) }"
   ].each do |input|
-    context input.inspect do
+    context input do
       let(:input) { input }
-
-      it "succeeds" do
-        expect { subject }.to_not raise_error
-      end
+      it { subject }
     end
   end
 end

data/spec/code/parser/group_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::Group do
+  subject { Code::Parser.parse(input) }
+
+  [
+    [
+      "(true (nothing))",
+      [{ group: [{ boolean: "true" }, { group: [{ nothing: "nothing" }] }] }]
+    ]
+  ].each do |input, output|
+    context input.inspect do
+      let(:input) { input }
+
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/parser/list_spec.rb

@@ -1,29 +1,18 @@
 require "spec_helper"
 
 RSpec.describe Code::Parser::List do
-  subject { described_class.new.parse(input) }
+  subject { Code::Parser.parse(input) }
 
   [
-    [
-      "[true, false]",
-      {
-        list: [
-          { code: [{ boolean: "true" }] },
-          { code: [{ boolean: "false" }] },
-        ],
-      },
-    ],
-    [
-      "[nothing, a]",
-      { list: [{ code: [{ nothing: "nothing" }] }, { code: [{ name: "a" }] }] },
-    ],
-  ].each do |(input, expected)|
-    context input.inspect do
+    "[]",
+    "[ ]",
+    "[/* comment */]",
+    "[1, 2, 3]",
+    "['hello', 1, true, [false, nothing]]"
+  ].each do |input|
+    context input do
       let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
+      it { subject }
     end
   end
 end

data/spec/code/parser/number_spec.rb

@@ -1,117 +1,12 @@
 require "spec_helper"
 
 RSpec.describe Code::Parser::Number do
-  subject { described_class.new.parse(input) }
+  subject { Code::Parser.parse(input) }
 
-  [
-    ["1", { number: { base_10: { integer: { whole: "1" } } } }],
-    ["3", { number: { base_10: { integer: { whole: "3" } } } }],
-    ["1.0", { number: { base_10: { decimal: { whole: "1", decimal: "0" } } } }],
-    [
-      "-1.0",
-      {
-        number: {
-          base_10: {
-            decimal: {
-              sign: "-",
-              whole: "1",
-              decimal: "0",
-            },
-          },
-        },
-      },
-    ],
-    [
-      "+1.0",
-      {
-        number: {
-          base_10: {
-            decimal: {
-              sign: "+",
-              whole: "1",
-              decimal: "0",
-            },
-          },
-        },
-      },
-    ],
-    ["0", { number: { base_10: { integer: { whole: "0" } } } }],
-    ["+0", { number: { base_10: { integer: { sign: "+", whole: "0" } } } }],
-    ["-0", { number: { base_10: { integer: { sign: "-", whole: "0" } } } }],
-    ["0b010", { number: { base_2: "010" } }],
-    ["0o01234567", { number: { base_8: "01234567" } }],
-    [
-      "0x0123456789aAbBcCdDeEfF",
-      { number: { base_16: "0123456789aAbBcCdDeEfF" } },
-    ],
-    [
-      "10e20",
-      {
-        number: {
-          base_10: {
-            integer: {
-              whole: "10",
-              exponent: {
-                integer: {
-                  whole: "20",
-                },
-              },
-            },
-          },
-        },
-      },
-    ],
-    [
-      "10.34e23.45",
-      {
-        number: {
-          base_10: {
-            decimal: {
-              whole: "10",
-              decimal: "34",
-              exponent: {
-                decimal: {
-                  whole: "23",
-                  decimal: "45",
-                },
-              },
-            },
-          },
-        },
-      },
-    ],
-    [
-      "+10e-20e1.0",
-      {
-        number: {
-          base_10: {
-            integer: {
-              sign: "+",
-              whole: "10",
-              exponent: {
-                integer: {
-                  sign: "-",
-                  whole: "20",
-                  exponent: {
-                    decimal: {
-                      whole: "1",
-                      decimal: "0",
-                    },
-                  },
-                },
-              },
-            },
-          },
-        },
-      },
-    ],
-  ].each do |(input, expected)|
-    context input.inspect do
+  %w[0 1 1.1 123.123 1_000.12_244 0xf0 0o70 0b10].each do |input|
+    context input do
       let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
+      it { subject }
     end
   end
 end

data/spec/code/parser/string_spec.rb

@@ -1,29 +1,21 @@
 require "spec_helper"
 
 RSpec.describe Code::Parser::String do
-  subject { described_class.new.parse(input) }
+  subject { Code::Parser.parse(input) }
 
   [
-    "'hello'",
-    '"hello"',
     "''",
     '""',
-    "'\\''",
-    '"\\t"',
-    "'\\r'",
-    '"\\b\\f\\n\\r\\t"',
-    '"\\uABCG"',
-    "'\\u0123\\u4567\\u89aA\\ubBcC\\UdDeE\\ufFfF'",
-    ":asc",
-    "'1 + 1 = {1 + 1}'",
-    "'a + b = {'{'a'}{'b'}'}'"
+    "'Hello Dorian'",
+    '"Hello Dorian"',
+    "'Hello \\{name}'",
+    '"Hello \\{name}"',
+    "'Hello {name}'",
+    '"Hello {name}"'
   ].each do |input|
-    context input.inspect do
+    context input do
       let(:input) { input }
-
-      it "succeeds" do
-        expect { subject }.to_not raise_error
-      end
+      it { subject }
     end
   end
 end

data/spec/code/parser_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+RSpec.describe "Code::Parser" do
+  subject { Code::Parser.parse(input) }
+
+  [
+    ["", []],
+    ["  ", []],
+    ["\n", []],
+    ["nothing", [{ nothing: "nothing" }]],
+    ["  nothing  ", [{ nothing: "nothing" }]],
+    [
+      "nothing null nil",
+      [{ nothing: "nothing" }, { nothing: "null" }, { nothing: "nil" }]
+    ]
+  ].each do |input, output|
+    context input.inspect do
+      let(:input) { input }
+
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/power_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe "function" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [["2 ** 3", "8"], ["2 ** 3 ** 2", "512"]].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/range_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+RSpec.describe "range" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["(0..1).to_list", "[0, 1]"],
+    ["(0...1).to_list", "[0]"]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/rescue_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe "rescue" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [["a rescue 'oops'", "oops"]].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/shift_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe "shift" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [["1 >> 1", "0"], ["1 << 1", "2"]].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end