template-ruby 0.4.0 → 0.5.0

data/lib/language/parser.rb

@@ -0,0 +1,53 @@
+class Language
+  class Parser
+    attr_accessor :input, :buffer, :output, :root, :cursor
+
+    def initialize(root:, input:, cursor: 0, buffer: "", output: Output.new)
+      @root = root
+      @input = input
+      @cursor = cursor
+      @buffer = buffer
+      @output = output
+    end
+
+    def parse(check_end_of_input: true)
+      @root.parse(self)
+
+      if @cursor == @input.size || !check_end_of_input
+        @output.present? ? @output : Output.new(@buffer)
+      else
+        raise NotEndOfInput.new(self)
+      end
+    end
+
+    def consume(n)
+      if @cursor + n <= @input.size
+        @buffer += @input[@cursor, n]
+        @cursor += n
+      else
+        raise EndOfInput.new(self)
+      end
+    end
+
+    def aka(name)
+      if @buffer.empty?
+        @output = Output.new({ name => @output })
+      else
+        @output[name] = Output.new(@buffer)
+        @buffer = ""
+      end
+    end
+
+    def next?(string)
+      @input[@cursor...(@cursor + string.size)] == string
+    end
+
+    def buffer?
+      @buffer != ""
+    end
+
+    def output?
+      @output.present?
+    end
+  end
+end

data/lib/language-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/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

@@ -1,6 +1,6 @@
 class Template
   class Node
-    class CodePart
+    class CodePart < Node
       def initialize(code)
         @code = ::Code::Node::Code.new(code)
       end

data/lib/template/node/part.rb

@@ -1,6 +1,6 @@
 class Template
   class Node
-    class Part
+    class Part < Node
       def initialize(part)
         if part.key?(:text)
           @part = ::Template::Node::TextPart.new(part[:text])

data/lib/template/node/template.rb

@@ -1,6 +1,6 @@
 class Template
   class Node
-    class Template
+    class Template < Node
       def initialize(parts)
         @parts = parts.map { |part| ::Template::Node::Part.new(part) }
       end

data/lib/template/node/text_part.rb

@@ -1,6 +1,6 @@
 class Template
   class Node
-    class TextPart
+    class TextPart < Node
       def initialize(text)
         @text = text
       end

data/lib/template/node.rb

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

data/lib/template/parser/template.rb

@@ -1,30 +1,39 @@
 class Template
   class Parser
-    class Template < Parslet::Parser
-      rule(:code) { ::Code::Parser::Code.new }
+    class Template < Language
+      def code
+        ::Code::Parser::Code
+      end
+
+      def opening_curly_bracket
+        str("{")
+      end
 
-      rule(:left_curly_bracket) { str("{") }
-      rule(:right_curly_bracket) { str("}") }
-      rule(:escape) { str("\\") }
+      def closing_curly_bracket
+        str("}")
+      end
 
-      rule(:text_part) do
-        (
-          (escape.ignore >> left_curly_bracket) |
-            (left_curly_bracket.absent? >> any)
-        ).repeat(1)
+      def backslash
+        str("\\")
       end
 
-      rule(:code_part) do
-        left_curly_bracket.ignore >> code >>
-          (right_curly_bracket.ignore | any.absent?)
+      def code_part
+        opening_curly_bracket << code << (closing_curly_bracket | any.absent)
       end
 
-      rule(:template) do
-        (text_part.as(:text) | code_part.as(:code)).repeat(1) |
-          str("").as(:text).repeat(1, 1)
+      def text_character
+        (backslash.ignore << opening_curly_bracket) |
+          (opening_curly_bracket.absent << any)
       end
 
-      root(:template)
+      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

@@ -1,4 +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

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

data/lib/template-ruby.rb

@@ -1,19 +1,10 @@
-require "parslet"
-require "zeitwerk"
 require "bigdecimal"
-require "active_support"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/object/deep_dup"
 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
-
-class Hash
-  def multi_fetch(*keys)
-    keys.map { |key| [key, fetch(key)] }.to_h
-  end
-end

data/lib/template.rb

@@ -4,9 +4,7 @@ class Template
   def initialize(input, io: StringIO.new, timeout: DEFAULT_TIMEOUT, ruby: {})
     @input = input
     @parsed =
-      Timeout.timeout(timeout) do
-        ::Template::Parser::Template.new.parse(@input)
-      end
+      Timeout.timeout(timeout) { ::Template::Parser.parse(@input).to_raw }
     @io = io
     @timeout = timeout || DEFAULT_TIMEOUT
     @ruby = ::Code::Ruby.to_code(ruby || {})
@@ -24,19 +22,16 @@ class Template
 
   def render(context = "")
     Timeout.timeout(timeout) do
-      if context.present?
-        context = ::Code.evaluate(
-          context,
-          timeout: timeout,
-          io: io,
-          ruby: ruby
-        )
+      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")
+        raise ::Code::Template::IncompatibleContext.new(
+                "context must be a dictionnary"
+              )
       end
 
       context = context.merge(ruby)

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