code-ruby 0.2.4

data/lib/template/parser/template.rb

@@ -0,0 +1,30 @@
+class Template
+  class Parser
+    class Template < Parslet::Parser
+      rule(:code) { ::Code::Parser::Code.new }
+
+      rule(:left_curly_bracket) { str("{") }
+      rule(:right_curly_bracket) { str("}") }
+      rule(:escape) { str("\\") }
+
+      rule(:text_part) do
+        (
+          (escape.ignore >> left_curly_bracket) |
+            (left_curly_bracket.absent? >> any)
+        ).repeat(1)
+      end
+
+      rule(:code_part) do
+        left_curly_bracket.ignore >> code >>
+          (right_curly_bracket.ignore | any.absent?)
+      end
+
+      rule(:template) do
+        (text_part.as(:text) | code_part.as(:code)).repeat(1) |
+          str("").as(:text).repeat(1, 1)
+      end
+
+      root(:template)
+    end
+  end
+end

data/lib/template/parser.rb

@@ -0,0 +1,4 @@
+class Template
+  class Parser
+  end
+end

data/lib/template/version.rb

@@ -0,0 +1,3 @@
+require_relative "../template"
+
+Template::Version = Gem::Version.new("0.2.4")

data/lib/template-ruby.rb

@@ -0,0 +1,11 @@
+require "parslet"
+require "zeitwerk"
+require "bigdecimal"
+require "active_support"
+require "active_support/core_ext/object/blank"
+require "stringio"
+require "timeout"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore(__FILE__)
+loader.setup

data/lib/template.rb

@@ -0,0 +1,34 @@
+class Template
+  def initialize(input, io: StringIO.new, timeout: 10)
+    @input = input
+    @parsed =
+      Timeout.timeout(timeout) do
+        ::Template::Parser::Template.new.parse(@input)
+      end
+    @io = io
+    @timeout = timeout
+  end
+
+  def self.render(input, context = "", io: StringIO.new, timeout: 10)
+    new(input, io: io, timeout: timeout).render(context)
+  end
+
+  def render(context = "")
+    Timeout.timeout(@timeout) do
+      if context.present?
+        context = ::Code.evaluate(context, timeout: @timeout)
+      else
+        context = ::Code::Object::Dictionnary.new
+      end
+
+      ::Template::Node::Template.new(@parsed).evaluate(
+        context: context,
+        io: @io,
+      )
+
+      @io.is_a?(StringIO) ? @io.string : nil
+    end
+  end
+end
+
+require_relative "template/version"

data/spec/call_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+RSpec.describe Code do
+  subject { described_class.evaluate(input).to_s }
+
+  [
+    %w[(1..2).any?(&:even?) true],
+    %w[(1..1).any?(&:even?) false],
+    %w[(3..3).any?(&:even?) false],
+    %w[(2..5).any?(&:even?) true],
+    ["(2..5).any? { |n| n.even? }", "true"],
+    ["(2..5).select { |i| i.even? }.any? { |n| n.even? }", "true"],
+  ].each do |(input, expected)|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect(subject).to eq(expected)
+      end
+    end
+  end
+end

data/spec/code/error/type_error_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+RSpec.describe ::Code::Error::TypeError do
+  describe "Integer" do
+    context "creating an integer with a non-number exponent" do
+      it "raises" do
+        expect { ::Code::Object::Integer.new(1, exponent: "2") }.to raise_error(
+          described_class,
+        )
+      end
+    end
+
+    [
+      '1 / ""',
+      '1 ** ""',
+      '1 % ""',
+      '1 + ""',
+      '1 - ""',
+      '1 << ""',
+      '1 >> ""',
+      '1 & ""',
+      '1 | ""',
+      '1 ^ ""',
+      '1 > ""',
+      '1 >= ""',
+      '1 < ""',
+      '1 <= ""',
+    ].each do |input|
+      context input.inspect do
+        it "raises" do
+          expect { ::Code.evaluate(input) }.to raise_error(described_class)
+        end
+      end
+    end
+  end
+
+  describe "Decimal" do
+    context "creating an integer with a non-number exponent" do
+      it "raises" do
+        expect { ::Code::Object::Decimal.new(1, exponent: "2") }.to raise_error(
+          described_class,
+        )
+      end
+    end
+
+    [
+      '1.0 / ""',
+      '1.0 ** ""',
+      '1.0 * ""',
+      '1.0 % ""',
+      '1.0 + ""',
+      '1.0 - ""',
+      '1.0 > ""',
+      '1.0 >= ""',
+      '1.0 < ""',
+      '1.0 <= ""',
+    ].each do |input|
+      context input.inspect do
+        it "raises" do
+          expect { ::Code.evaluate(input) }.to raise_error(described_class)
+        end
+      end
+    end
+  end
+end

data/spec/code/parser/boolean_spec.rb

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

data/spec/code/parser/call_spec.rb

@@ -0,0 +1,66 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::Call do
+  subject { described_class.new.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? }",
+  ].each do |input|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect { subject }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/code/parser/dictionnary_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::Dictionnary do
+  subject { described_class.new.parse(input) }
+
+  [
+    [
+      '{name: "Dorian"}',
+      {
+        dictionnary: [{ key: { name: "name" }, value: [{ string: "Dorian" }] }],
+      },
+    ],
+    [
+      '{a: true, "b": false}',
+      {
+        dictionnary: [
+          { key: { name: "a" }, value: [{ boolean: "true" }] },
+          { key: { string: "b" }, value: [{ boolean: "false" }] },
+        ],
+      },
+    ],
+    [
+      "{ true => 1, false => 2}",
+      {
+        dictionnary: [
+          {
+            key: [{ boolean: "true" }],
+            value: [{ number: { base_10: { integer: { whole: "1" } } } }],
+          },
+          {
+            key: [{ boolean: "false" }],
+            value: [{ number: { base_10: { integer: { whole: "2" } } } }],
+          },
+        ],
+      },
+    ],
+  ].each do |(input, expected)|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect(subject).to eq(expected)
+      end
+    end
+  end
+end

data/spec/code/parser/function_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::Function do
+  subject { described_class.new.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)=>{}",
+  ].each do |input|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect { subject }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/code/parser/list_spec.rb

@@ -0,0 +1,29 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::List do
+  subject { described_class.new.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
+      let(:input) { input }
+
+      it "succeeds" do
+        expect(subject).to eq(expected)
+      end
+    end
+  end
+end

data/spec/code/parser/name_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::Name do
+  subject { described_class.new.parse(input) }
+
+  %w[user dorian User RSpec describe?].each do |(input, expected)|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect(subject).to eq({ name: input })
+      end
+    end
+  end
+end

data/spec/code/parser/nothing_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::Nothing do
+  subject { described_class.new.parse(input) }
+
+  [
+    ["nothing", { nothing: "nothing" }],
+    ["null", { nothing: "null" }],
+    ["nil", { nothing: "nil" }],
+  ].each do |(input, expected)|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect(subject).to eq(expected)
+      end
+    end
+  end
+end

data/spec/code/parser/number_spec.rb

@@ -0,0 +1,117 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::Number do
+  subject { described_class.new.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
+      let(:input) { input }
+
+      it "succeeds" do
+        expect(subject).to eq(expected)
+      end
+    end
+  end
+end

data/spec/code/parser/string_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::String do
+  subject { described_class.new.parse(input) }
+
+  [
+    ["'hello'", { string: "hello" }],
+    ['"hello"', { string: "hello" }],
+    ["''", { string: "" }],
+    ['""', { string: "" }],
+    ["'\\''", { string: "'" }],
+    ['"\\t"', { string: "\\t" }],
+    ["'\\r'", { string: "\\r" }],
+    ['"\\b\\f\\n\\r\\t"', { string: "\\b\\f\\n\\r\\t" }],
+    ['"\\uABCG"', { string: "uABCG" }],
+    [
+      "'\\u0123\\u4567\\u89aA\\ubBcC\\UdDeE\\ufFfF'",
+      { string: "\\u0123\\u4567\\u89aA\\ubBcC\\UdDeE\\ufFfF" },
+    ],
+    [":asc", { string: "asc" }],
+  ].each do |(input, expected)|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect(subject).to eq(expected)
+      end
+    end
+  end
+end

data/spec/code_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+RSpec.describe Code do
+  subject { described_class.evaluate(input).to_s }
+
+  [
+    ["nothing", ""],
+    ["null", ""],
+    ["nil", ""],
+    %w[true true],
+    %w[false false],
+    %w[1 1],
+    %w[1.2 1.2],
+    %w[0b10 2],
+    %w[0o10 8],
+    %w[0x10 16],
+    %w[1e2 100],
+    %w[1.2e2.2 190.1871830953336182242521644],
+    %w[1e1e1 10000000000],
+    %w['hello' hello],
+    %w["hello" hello],
+    ["[true, 1, nothing]", "[true, 1, nothing]"],
+    ['{a: 1, "b": 2}', '{"a" => 1, "b" => 2}'],
+    %w[!true false],
+    %w[!!true true],
+    %w[!!nothing false],
+    %w[!!1 true],
+    %w[+1 1],
+    %w[++++1 1],
+    ["++++nothing", ""],
+    %w[+{} {}],
+    ["2 ** 2", "4"],
+    ["2 ** 2 ** 3", "256"],
+    %w[-2 -2],
+    %w[--2 2],
+    ["2 * 3", "6"],
+    ["1 / 2", "0.5"],
+    ["1 / 2 / 2", "0.25"],
+    ["12 % 10", "2"],
+    ["8 / -2 ** 3", "-1.0"],
+    ["1 + 2 * 3 + 4", "11"],
+    ["1e1.1 * 2", "25.1785082358833442084790822"],
+    ["1 / 3 * 3", "0.999999999999999999999999999999999999"],
+    ['3 * "hello"', "hellohellohello"],
+    ['"Go" + "od"', "Good"],
+    ["1 << 2", "4"],
+    ["4 >> 2", "1"],
+    ["2 & 1", "0"],
+    ["2 | 1", "3"],
+    ["5 ^ 6", "3"],
+    ["5 > 6", "false"],
+    ["5 > 5", "false"],
+    ["5 > 4", "true"],
+    ["2 > 1 == 3 > 2", "true"],
+    ["true && false", "false"],
+    ["true || false", "true"],
+    %w[1..3 1..3],
+    ['1 > 3 ? "Impossible" : "Sounds about right"', "Sounds about right"],
+    ['1 < 3 ? "OK"', "OK"],
+    ['1 < "" rescue "oops"', "oops"],
+    ['"fine" rescue "oops"', "fine"],
+    ["a = 1", "1"],
+    ["a = 1 a * 2", "2"],
+    ["a = 1 a += 1 a", "2"],
+    ["a = 1 a -= 1 a", "0"],
+    %w[defined?(a) false],
+    ["a = 1 defined?(a)", "true"],
+    ["not true", "false"],
+    ["not false", "true"],
+    ["not not 1", "true"],
+    ["1 or 2", "1"],
+    ["true or false", "true"],
+    ["1 and 2", "2"],
+    ["false and 2", "false"],
+    ["true and false", "false"],
+    ["true and true", "true"],
+    ["1 if false", ""],
+    ["1 if true", "1"],
+    ["1 if true if true", "1"],
+    ["1 unless false", "1"],
+    ["1 unless true", ""],
+    ["a = 0 a += 1 while a < 10 a", "10"],
+    ["a = 0 a += 1 until a > 10 a", "11"],
+    ["if true 1 end", "1"],
+    ["if false 1 end", ""],
+    ["if false 1 else 2 end", "2"],
+    ["unless false 1 end", "1"],
+    ["unless true 1 end", ""],
+    ["if false 1 else if true 2 else 3 end", "2"],
+    ["if false 1 else if false 2 else 3 end", "3"],
+    ["unless false 1 else if false 2 else 3 end", "1"],
+    ["if false 1 else unless false 2 else 3 end", "2"],
+    ["a = 0\n while a < 10 a += 1 end a", "10"],
+    ["a = 0\n until a > 10 a += 1 end a", "11"],
+    ["until true end", ""],
+    ["until true\nend", ""],
+    %w[("Good".."Bad").first Good],
+    ['"Dorian " * 2', "Dorian Dorian "],
+  ].each do |(input, expected)|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect(subject).to eq(expected)
+      end
+    end
+  end
+end

data/spec/function_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+RSpec.describe Code do
+  subject { described_class.evaluate(input).to_s }
+
+  [
+    ['hello = () => { "Hello" } hello', "Hello"],
+    ["add = (a, b) => { a + b } add(1, 2)", "3"],
+    ["add = (a:, b:) => { a + b } add(a: 1, b: 2)", "3"],
+    ["add = (a = 1, b = 2) => { a + b } add", "3"],
+    ["add = (a: 1, b: 2) => { a + b } add", "3"],
+    ["add = (*args) => { args.first + args.last } add(1, 2)", "3"],
+    [
+      "add = (**kargs) => { kargs.values.first + kargs.values.last } add(a: 1, b: 2)",
+      "3",
+    ],
+  ].each do |(input, expected)|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect(subject).to eq(expected)
+      end
+    end
+  end
+end