language-ruby 0.5.0

data/lib/language.rb

@@ -0,0 +1,80 @@
+class Language
+  def self.parse(input)
+    new.parse(input)
+  end
+
+  def self.absent
+    Atom::Absent.new(parent: new)
+  end
+
+  def self.ignore
+    Atom::Ignore.new(parent: new)
+  end
+
+  def self.maybe
+    Atom::Maybe.new(parent: new)
+  end
+
+  def self.repeat(min = 0, max = nil)
+    Atom::Repeat.new(parent: new, min: min, max: max)
+  end
+
+  def self.aka(name)
+    Atom::Aka.new(parent: new, name: name)
+  end
+
+  def self.|(other)
+    Atom::Or.new(left: new, right: other)
+  end
+
+  def self.>>(other)
+    Atom::And.new(left: new, right: other)
+  end
+
+  def self.<<(other)
+    Atom::And.new(left: new, right: other)
+  end
+
+  def self.then(&block)
+    Atom::Then.new(parent: new, block: block)
+  end
+
+  def parse(input_or_parser)
+    if input_or_parser.is_a?(Parser)
+      parser = input_or_parser
+      clone =
+        Parser.new(
+          root: root,
+          input: parser.input,
+          cursor: parser.cursor,
+          buffer: parser.buffer,
+          output: parser.output
+        )
+
+      clone.parse(check_end_of_input: false)
+
+      parser.cursor = clone.cursor
+      parser.buffer = clone.buffer
+      parser.output = clone.output
+    else
+      input = input_or_parser
+      Parser.new(root: root, input: input).parse
+    end
+  end
+
+  def str(string)
+    Atom::Str.new(string: string)
+  end
+
+  def any
+    Atom::Any.new
+  end
+
+  def to_s
+    "<#{self.class.name}>"
+  end
+
+  def inspect
+    to_s
+  end
+end

data/lib/template/node/code_part.rb

@@ -0,0 +1,13 @@
+class Template
+  class Node
+    class CodePart < Node
+      def initialize(code)
+        @code = ::Code::Node::Code.new(code)
+      end
+
+      def evaluate(**args)
+        @code.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/template/node/part.rb

@@ -0,0 +1,19 @@
+class Template
+  class Node
+    class Part < Node
+      def initialize(part)
+        if part.key?(:text)
+          @part = ::Template::Node::TextPart.new(part[:text])
+        elsif part.key?(:code)
+          @part = ::Template::Node::CodePart.new(part[:code])
+        else
+          raise NotImplementedError.new(part.inspect)
+        end
+      end
+
+      def evaluate(**args)
+        @part.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/template/node/template.rb

@@ -0,0 +1,15 @@
+class Template
+  class Node
+    class Template < Node
+      def initialize(parts)
+        @parts = parts.map { |part| ::Template::Node::Part.new(part) }
+      end
+
+      def evaluate(**args)
+        io = args.fetch(:io)
+
+        @parts.each { |part| io.print(part.evaluate(**args)) }
+      end
+    end
+  end
+end

data/lib/template/node/text_part.rb

@@ -0,0 +1,13 @@
+class Template
+  class Node
+    class TextPart < Node
+      def initialize(text)
+        @text = text
+      end
+
+      def evaluate(**args)
+        ::Code::Object::String.new(@text.to_s)
+      end
+    end
+  end
+end

data/lib/template/node.rb

@@ -0,0 +1,4 @@
+class Template
+  class Node < ::Code::Node
+  end
+end

data/lib/template/parser/template.rb

@@ -0,0 +1,39 @@
+class Template
+  class Parser
+    class Template < Language
+      def code
+        ::Code::Parser::Code
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
+
+      def closing_curly_bracket
+        str("}")
+      end
+
+      def backslash
+        str("\\")
+      end
+
+      def code_part
+        opening_curly_bracket << code << (closing_curly_bracket | any.absent)
+      end
+
+      def text_character
+        (backslash.ignore << opening_curly_bracket) |
+          (opening_curly_bracket.absent << any)
+      end
+
+      def text_part
+        text_character.repeat(1)
+      end
+
+      def root
+        (code_part.aka(:code) | text_part.aka(:text)).repeat |
+          str("").aka(:text).repeat(1, 1)
+      end
+    end
+  end
+end

data/lib/template/parser.rb

@@ -0,0 +1,19 @@
+class Template
+  class Parser
+    def initialize(input)
+      @input = input
+    end
+
+    def self.parse(input)
+      new(input).parse
+    end
+
+    def parse
+      ::Template::Parser::Template.parse(input)
+    end
+
+    private
+
+    attr_reader :input
+  end
+end

data/lib/template/version.rb

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

data/lib/template-ruby.rb

@@ -0,0 +1,10 @@
+require "bigdecimal"
+require "stringio"
+require "timeout"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/template-ruby.rb")
+loader.ignore("#{__dir__}/code-ruby.rb")
+loader.ignore("#{__dir__}/language-ruby.rb")
+loader.setup

data/lib/template.rb

@@ -0,0 +1,50 @@
+class Template
+  DEFAULT_TIMEOUT = 10
+
+  def initialize(input, io: StringIO.new, timeout: DEFAULT_TIMEOUT, ruby: {})
+    @input = input
+    @parsed =
+      Timeout.timeout(timeout) { ::Template::Parser.parse(@input).to_raw }
+    @io = io
+    @timeout = timeout || DEFAULT_TIMEOUT
+    @ruby = ::Code::Ruby.to_code(ruby || {})
+  end
+
+  def self.render(
+    input,
+    context = "",
+    io: StringIO.new,
+    timeout: DEFAULT_TIMEOUT,
+    ruby: {}
+  )
+    new(input, io: io, timeout: timeout, ruby: ruby).render(context)
+  end
+
+  def render(context = "")
+    Timeout.timeout(timeout) do
+      if context != ""
+        context = ::Code.evaluate(context, timeout: timeout, io: io, ruby: ruby)
+      else
+        context = ::Code::Object::Dictionnary.new
+      end
+
+      if !context.is_a?(::Code::Object::Dictionnary)
+        raise ::Code::Template::IncompatibleContext.new(
+                "context must be a dictionnary"
+              )
+      end
+
+      context = context.merge(ruby)
+
+      ::Template::Node::Template.new(parsed).evaluate(context: context, io: io)
+
+      io.is_a?(StringIO) ? io.string : nil
+    end
+  end
+
+  private
+
+  attr_reader :parsed, :io, :timeout, :ruby
+end
+
+require_relative "template/version"

data/spec/code/addition_spec.rb

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

data/spec/code/and_operator_spec.rb

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

data/spec/code/bitwise_and_spec.rb

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

data/spec/code/bitwise_or_spec.rb

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

data/spec/code/boolean_spec.rb

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

data/spec/code/call_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+RSpec.describe "call" do
+  let(:timeout) { 0 }
+
+  context "inspecting the io" do
+    let(:io) { StringIO.new }
+
+    subject do
+      Code.evaluate(input, io: io, timeout: timeout)
+      io.string
+    end
+
+    [["puts(true)", "true\n"], %w[print(false) false]].each do |input, output|
+      context input do
+        let(:input) { input }
+        it { expect(subject).to eq(output) }
+      end
+    end
+  end
+end

data/spec/code/chained_call_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+RSpec.describe "chained call" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["[1, 2, 3].select { |n| n.even? }", "[2]"],
+    ["[1, 2, 3].select { |n| n.even? }.select { |n| n.odd? }", "[]"]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/dictionnary_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+RSpec.describe "dictionnary" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    %w[{} {}],
+    ["{ a: 1, b: 2, c: 3 }", '{"a" => 1, "b" => 2, "c" => 3}'],
+    ['{ "first_name": "Dorian" }', '{"first_name" => "Dorian"}']
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/equal_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+RSpec.describe "function" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["a = 1 a", "1"],
+    ["a = 1 a += 1 a", "2"],
+    ["a = 1 a -= 1 a", "0"],
+    ["a = 1 a *= 2 a", "2"],
+    ["a = 1 a /= 2 a", "0.5"],
+    ["a = 10 a %= 2 a", "0"],
+    ["a = 1 a >>= 1 a", "0"],
+    ["a = 1 a <<= 1 a", "2"],
+    ["a = 1 a |= 2 a", "3"],
+    ["a = 1 a ^= 2 a", "3"],
+    ["a = false a ||= true a", "true"],
+    ["a = false a &&= true a", "false"]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/equality_spec.rb

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

data/spec/code/function_spec.rb

@@ -0,0 +1,18 @@
+require "spec_helper"
+
+RSpec.describe "function" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["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, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

data/spec/code/greater_spec.rb

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

data/spec/code/group_spec.rb

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

data/spec/code/if_modifier_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+RSpec.describe "if modifier" do
+  let(:timeout) { 0 }
+  subject { Code.evaluate(input, timeout: timeout).to_s }
+
+  [
+    ["1 if true", "1"],
+    ["1 if false", ""],
+    ["1 unless true", ""],
+    ["1 unless false", "1"],
+    ["a = 0 a += 1 while a < 10 a", "10"],
+    ["a = 0 a += 1 until a > 10 a", "11"]
+  ].each do |input, output|
+    context input do
+      let(:input) { input }
+      it { expect(subject).to eq(output) }
+    end
+  end
+end

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