template-ruby 0.1.0

data/lib/code/parser/boolean.rb

@@ -0,0 +1,14 @@
+class Code
+  class Parser
+    class Boolean < Parslet::Parser
+      rule(:nothing) { ::Code::Parser::Nothing.new }
+
+      rule(:true_keyword) { str("true") }
+      rule(:false_keyword) { str("false") }
+
+      rule(:boolean) { (true_keyword | false_keyword).as(:boolean) | nothing }
+
+      root(:boolean)
+    end
+  end
+end

data/lib/code/parser/call.rb

@@ -0,0 +1,16 @@
+class Code
+  class Parser
+    class Call < Parslet::Parser
+      rule(:dictionnary) { ::Code::Parser::Dictionnary.new }
+
+      rule(:dot) { str(".") }
+
+      rule(:call) do
+        (dictionnary.as(:left) >> dot >> call.as(:right)).as(:call) |
+          dictionnary
+      end
+
+      root(:call)
+    end
+  end
+end

data/lib/code/parser/code.rb

@@ -0,0 +1,18 @@
+class Code
+  class Parser
+    class Code < Parslet::Parser
+      rule(:statement) { ::Code::Parser::Statement.new }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:code) do
+        (whitespace? >> statement >> whitespace?).repeat(1) | whitespace?
+      end
+
+      root(:code)
+    end
+  end
+end

data/lib/code/parser/dictionnary.rb

@@ -0,0 +1,41 @@
+class Code
+  class Parser
+    class Dictionnary < Parslet::Parser
+      rule(:list) { ::Code::Parser::List.new }
+      rule(:code) { ::Code::Parser::Code.new }
+      rule(:string) { ::Code::Parser::String.new }
+
+      rule(:opening_curly_bracket) { str("{") }
+      rule(:closing_curly_bracket) { str("}") }
+      rule(:colon) { str(":") }
+      rule(:equal) { str("=") }
+      rule(:right_caret) { str(">") }
+      rule(:comma) { str(",") }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:key_value) do
+        (string.as(:key) >> colon >> whitespace? >> code.as(:value)) |
+          (
+            code.as(:key) >> whitespace? >> equal >> right_caret >>
+              whitespace? >> code.as(:value)
+          )
+      end
+
+      rule(:dictionnary) do
+        (
+          opening_curly_bracket.ignore >> whitespace?.ignore >>
+            key_value.repeat(0, 1) >>
+            (whitespace? >> comma >> whitespace? >> key_value).repeat >>
+            whitespace?.ignore >> comma.maybe.ignore >> whitespace?.ignore >>
+            closing_curly_bracket.ignore
+        ).as(:dictionnary) | list
+      end
+
+      root(:dictionnary)
+    end
+  end
+end

data/lib/code/parser/list.rb

@@ -0,0 +1,29 @@
+class Code
+  class Parser
+    class List < Parslet::Parser
+      rule(:string) { ::Code::Parser::String.new }
+      rule(:code) { ::Code::Parser::Code.new }
+
+      rule(:opening_square_bracket) { str("[") }
+      rule(:closing_square_bracket) { str("]") }
+      rule(:comma) { str(",") }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:list) do
+        (
+          opening_square_bracket.ignore >> whitespace?.ignore >>
+            code.as(:code).repeat(0, 1) >>
+            (whitespace? >> comma >> whitespace? >> code.as(:code)).repeat >>
+            whitespace?.ignore >> comma.maybe.ignore >> whitespace?.ignore >>
+            closing_square_bracket.ignore
+        ).as(:list) | string
+      end
+
+      root(:list)
+    end
+  end
+end

data/lib/code/parser/name.rb

@@ -0,0 +1,49 @@
+class Code
+  class Parser
+    class Name < Parslet::Parser
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:comma) { str(",") }
+      rule(:colon) { str(":") }
+      rule(:dot) { str(".") }
+      rule(:single_quote) { str("'") }
+      rule(:double_quote) { str('"') }
+      rule(:opening_curly_bracket) { str("{") }
+      rule(:closing_curly_bracket) { str("}") }
+      rule(:opening_square_bracket) { str("[") }
+      rule(:closing_square_bracket) { str("]") }
+      rule(:equal) { str("=") }
+      rule(:left_caret) { str("<") }
+      rule(:right_caret) { str(">") }
+
+      rule(:zero) { str("0") }
+      rule(:one) { str("1") }
+      rule(:two) { str("2") }
+      rule(:three) { str("3") }
+      rule(:four) { str("4") }
+      rule(:five) { str("5") }
+      rule(:six) { str("6") }
+      rule(:seven) { str("7") }
+      rule(:eight) { str("8") }
+      rule(:nine) { str("9") }
+
+      rule(:digit) do
+        zero | one | two | three | four | five | six | seven | eight | nine
+      end
+
+      rule(:name_character) do
+        space.absent? >> newline.absent? >> comma.absent? >> colon.absent? >>
+          dot.absent? >> single_quote.absent? >> double_quote.absent? >>
+          opening_curly_bracket.absent? >> closing_curly_bracket.absent? >>
+          opening_square_bracket.absent? >> closing_square_bracket.absent? >>
+          equal.absent? >> left_caret.absent? >> right_caret.absent? >> any
+      end
+
+      rule(:name) do
+        (digit.absent? >> name_character >> name_character.repeat).as(:name)
+      end
+
+      root(:name)
+    end
+  end
+end

data/lib/code/parser/nothing.rb

@@ -0,0 +1,17 @@
+class Code
+  class Parser
+    class Nothing < Parslet::Parser
+      rule(:name) { ::Code::Parser::Name.new }
+
+      rule(:nothing_keyword) { str("nothing") }
+      rule(:null_keyword) { str("null") }
+      rule(:nil_keyword) { str("nil") }
+
+      rule(:nothing) do
+        (nothing_keyword | null_keyword | nil_keyword).as(:nothing) | name
+      end
+
+      root(:nothing)
+    end
+  end
+end

data/lib/code/parser/number.rb

@@ -0,0 +1,98 @@
+class Code
+  class Parser
+    class Number < Parslet::Parser
+      rule(:boolean) { ::Code::Parser::Boolean.new }
+
+      rule(:dot) { str(".") }
+      rule(:plus) { str("+") }
+      rule(:minus) { str("-") }
+
+      rule(:zero) { str("0") }
+      rule(:one) { str("1") }
+      rule(:two) { str("2") }
+      rule(:three) { str("3") }
+      rule(:four) { str("4") }
+      rule(:five) { str("5") }
+      rule(:six) { str("6") }
+      rule(:seven) { str("7") }
+      rule(:eight) { str("8") }
+      rule(:nine) { str("9") }
+      rule(:a) { str("a") | str("A") }
+      rule(:b) { str("b") | str("B") }
+      rule(:b) { str("b") | str("B") }
+      rule(:c) { str("c") | str("C") }
+      rule(:d) { str("d") | str("D") }
+      rule(:e) { str("e") | str("E") }
+      rule(:f) { str("f") | str("F") }
+      rule(:o) { str("o") | str("O") }
+      rule(:x) { str("x") | str("X") }
+
+      # sign
+
+      rule(:sign) { plus | minus }
+
+      # base 2
+
+      rule(:base_2_digit) { zero | one }
+
+      rule(:base_2_number) { zero.ignore >> b.ignore >> base_2_digit.repeat(1) }
+
+      # base 8
+
+      rule(:base_8_digit) do
+        zero | one | two | three | four | five | six | seven
+      end
+
+      rule(:base_8_number) { zero.ignore >> o.ignore >> base_8_digit.repeat(1) }
+
+      # base 10
+
+      rule(:base_10_digit) do
+        zero | one | two | three | four | five | six | seven | eight | nine
+      end
+
+      rule(:base_10_whole) { base_10_digit.repeat(1) }
+
+      rule(:base_10_exponent) { e.ignore >> base_10_number }
+
+      rule(:base_10_integer) do
+        sign.as(:sign).maybe >> base_10_whole.as(:whole) >>
+          base_10_exponent.as(:exponent).maybe
+      end
+
+      rule(:base_10_decimal_decimal) { dot.ignore >> base_10_digit.repeat(1) }
+
+      rule(:base_10_decimal) do
+        sign.as(:sign).maybe >> base_10_whole.as(:whole) >>
+          base_10_decimal_decimal.as(:decimal) >>
+          base_10_exponent.as(:exponent).maybe
+      end
+
+      rule(:base_10_number) do
+        base_10_decimal.as(:decimal) | base_10_integer.as(:integer)
+      end
+
+      # base 16
+
+      rule(:base_16_digit) do
+        zero | one | two | three | four | five | six | seven | eight | nine |
+          a | b | c | d | e | f
+      end
+
+      rule(:base_16_number) do
+        zero.ignore >> x.ignore >> base_16_digit.repeat(1)
+      end
+
+      # number
+
+      rule(:number) do
+        (
+          base_2_number.as(:base_2) | base_8_number.as(:base_8) |
+            base_16_number.as(:base_16) | base_10_number.as(:base_10)
+        ).as(:number) | boolean
+      end
+
+      root(:number)
+    end
+  end
+end

data/lib/code/parser/statement.rb

@@ -0,0 +1,11 @@
+class Code
+  class Parser
+    class Statement < Parslet::Parser
+      rule(:call) { ::Code::Parser::Call.new }
+
+      rule(:statement) { call }
+
+      root(:statement)
+    end
+  end
+end

data/lib/code/parser/string.rb

@@ -0,0 +1,66 @@
+class Code
+  class Parser
+    class String < Parslet::Parser
+      rule(:number) { ::Code::Parser::Number.new }
+
+      rule(:single_quote) { str("'") }
+      rule(:double_quote) { str('"') }
+      rule(:backslash) { str("\\") }
+      rule(:zero) { str("0") }
+      rule(:one) { str("1") }
+      rule(:two) { str("2") }
+      rule(:three) { str("3") }
+      rule(:four) { str("4") }
+      rule(:five) { str("5") }
+      rule(:six) { str("6") }
+      rule(:seven) { str("7") }
+      rule(:eight) { str("8") }
+      rule(:nine) { str("9") }
+      rule(:a) { str("a") | str("A") }
+      rule(:b) { str("b") | str("B") }
+      rule(:b) { str("b") | str("B") }
+      rule(:c) { str("c") | str("C") }
+      rule(:d) { str("d") | str("D") }
+      rule(:e) { str("e") | str("E") }
+      rule(:f) { str("f") | str("F") }
+      rule(:n) { str("n") | str("N") }
+      rule(:r) { str("r") | str("R") }
+      rule(:t) { str("t") | str("T") }
+      rule(:u) { str("u") | str("U") }
+
+      rule(:base_16_digit) do
+        zero | one | two | three | four | five | six | seven | eight | nine |
+          a | b | c | d | e | f
+      end
+
+      rule(:escaped_character) do
+        (backslash >> u >> base_16_digit.repeat(4, 4)) |
+          (backslash >> (b | f | n | r | t)) | (backslash.ignore >> any)
+      end
+
+      rule(:single_quoted_character) do
+        escaped_character | (single_quote.absent? >> any)
+      end
+
+      rule(:double_quoted_character) do
+        escaped_character | (double_quote.absent? >> any)
+      end
+
+      rule(:single_quoted_string) do
+        single_quote.ignore >> single_quoted_character.repeat >>
+          single_quote.ignore
+      end
+
+      rule(:double_quoted_string) do
+        double_quote.ignore >> double_quoted_character.repeat >>
+          double_quote.ignore
+      end
+
+      rule(:string) do
+        (single_quoted_string | double_quoted_string).as(:string) | number
+      end
+
+      root(:string)
+    end
+  end
+end

data/lib/code/parser.rb

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

data/lib/code.rb

@@ -0,0 +1,27 @@
+require "active_support"
+require "active_support/core_ext/object/blank"
+
+class Code
+  def initialize(input)
+    @input = input
+    @parsed = ::Code::Parser::Code.new.parse(@input)
+  end
+
+  def self.evaluate(input, context = "")
+    new(input).evaluate(context)
+  end
+
+  def evaluate(context = "")
+    if context.present?
+      context = ::Code.evaluate(context)
+    else
+      context = ::Code::Object::Dictionnary.new
+    end
+
+    ::Code::Node::Code.new(parsed).evaluate(context)
+  end
+
+  private
+
+  attr_reader :input, :parsed
+end

data/lib/template/node/code_part.rb

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

data/lib/template/node/part.rb

@@ -0,0 +1,19 @@
+class Template
+  class Node
+    class Part
+      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(context)
+        @part.evaluate(context)
+      end
+    end
+  end
+end

data/lib/template/node/template.rb

@@ -0,0 +1,13 @@
+class Template
+  class Node
+    class Template
+      def initialize(parts)
+        @parts = parts.map { |part| ::Template::Node::Part.new(part) }
+      end
+
+      def evaluate(context)
+        ::Code::Object::List.new(@parts.map { |part| part.evaluate(context) })
+      end
+    end
+  end
+end

data/lib/template/node/text_part.rb

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

data/lib/template/node.rb

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

data/lib/template/parser/template.rb

@@ -0,0 +1,26 @@
+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 >> code >> (right_curly_bracket | any.absent?)
+      end
+
+      rule(:template) { (text_part.as(:text) | code_part.as(:code)).repeat(1) }
+
+      root(:template)
+    end
+  end
+end

data/lib/template/parser.rb

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

data/lib/template-ruby.rb

@@ -0,0 +1,6 @@
+require "parslet"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore(__FILE__)
+loader.setup

data/lib/template.rb

@@ -0,0 +1,20 @@
+class Template
+  def initialize(input)
+    @input = input
+    @parsed = ::Template::Parser::Template.new.parse(@input)
+  end
+
+  def self.render(input, context = "")
+    new(input).render(context)
+  end
+
+  def render(context = "")
+    if context.present?
+      context = ::Code.evaluate(context)
+    else
+      context = ::Code::Object::Dictionnary.new
+    end
+
+    ::Template::Node::Template.new(@parsed).evaluate(context).map(&:to_s).join
+  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,39 @@
+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
+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/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