template-ruby 0.2.3 → 0.3.0

data/lib/code/object/integer.rb

@@ -21,13 +21,13 @@ class Code
 
         if operator == "even?"
           even?(arguments)
-        elsif operator == "to_string"
-          code_to_s(arguments)
         elsif operator == "*"
           multiplication(arguments)
         elsif operator == "/"
           division(arguments)
-        elsif %w[% - + **].detect { |o| operator == o }
+        elsif operator == "+"
+          plus(arguments)
+        elsif %w[% - **].detect { |o| operator == o }
           integer_or_decimal_operation(operator.to_sym, arguments)
         elsif %w[> >= < <=].detect { |o| operator == o }
           comparaison(operator.to_sym, arguments)
@@ -38,16 +38,6 @@ class Code
         end
       end
 
-      def +(other)
-        if other.is_a?(::Code::Object::Integer)
-          ::Code::Object::Integer.new(raw + other.raw)
-        elsif other.is_a?(::Code::Object::Decimal)
-          ::Code::Object::Decimal.new(raw + other.raw)
-        else
-          raise ::Code::Error::TypeError
-        end
-      end
-
       def succ
         ::Code::Object::Integer.new(raw + 1)
       end
@@ -67,11 +57,6 @@ class Code
         ::Code::Object::Boolean.new(raw.even?)
       end
 
-      def code_to_s(arguments)
-        sig(arguments)
-        ::Code::Object::String.new(raw.to_s)
-      end
-
       def multiplication(arguments)
         sig(arguments, [::Code::Object::Number, ::Code::Object::String])
         other = arguments.first.value
@@ -84,6 +69,19 @@ class Code
         end
       end
 
+      def plus(arguments)
+        sig(arguments, ::Code::Object)
+        other = arguments.first.value
+
+        if other.is_a?(::Code::Object::Integer)
+          ::Code::Object::Integer.new(raw + other.raw)
+        elsif other.is_a?(::Code::Object::Decimal)
+          ::Code::Object::Decimal.new(raw + other.raw)
+        else
+          ::Code::Object::String.new(to_s + other.to_s)
+        end
+      end
+
       def division(arguments)
         sig(arguments, ::Code::Object::Number)
         other = arguments.first.value
@@ -101,9 +99,9 @@ class Code
       end
 
       def integer_operation(operator, arguments)
-        sig(arguments, ::Code::Object::Integer)
+        sig(arguments, ::Code::Object::Number)
         other = arguments.first.value
-        ::Code::Object::Integer.new(raw.public_send(operator, other.raw))
+        ::Code::Object::Integer.new(raw.to_i.public_send(operator, other.raw.to_i))
       end
 
       def comparaison(operator, arguments)

data/lib/code/object/list.rb

@@ -63,6 +63,10 @@ class Code
         )
       end
 
+      def deep_dup
+        ::Code::Object::List.new(raw.deep_dup)
+      end
+
       def to_s
         "[#{raw.map(&:inspect).join(", ")}]"
       end

data/lib/code/object/string.rb

@@ -15,6 +15,8 @@ class Code
           to_function(arguments)
         elsif operator == "+"
           plus(arguments)
+        elsif operator == "*"
+          multiplication(arguments)
         elsif operator == "reverse"
           reverse(arguments)
         else
@@ -46,9 +48,15 @@ class Code
       end
 
       def plus(arguments)
-        sig(arguments, ::Code::Object::String)
+        sig(arguments, ::Code::Object)
         other = arguments.first.value
-        ::Code::Object::String.new(raw + other.raw)
+        ::Code::Object::String.new(raw + other.to_s)
+      end
+
+      def multiplication(arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        ::Code::Object::String.new(raw * other.raw)
       end
 
       def reverse(arguments)

data/lib/code/object.rb

@@ -13,6 +13,8 @@ class Code
         and_operator(arguments)
       elsif operator == "||"
         or_operator(arguments)
+      elsif operator == "to_string"
+        to_string(arguments)
       else
         raise ::Code::Error::Undefined.new(
                 "#{operator} not defined on #{inspect}",
@@ -126,5 +128,10 @@ class Code
       other = arguments.first.value
       truthy? ? self : other
     end
+
+    def to_string(arguments)
+      sig(arguments)
+      ::Code::Object::String.new(to_s)
+    end
   end
 end

data/lib/code/parser/and_operator.rb

@@ -1,7 +1,7 @@
 class Code
   class Parser
     class AndOperator < Parslet::Parser
-      rule(:equality) { ::Code::Parser::Equality.new }
+      rule(:greater_than) { ::Code::Parser::GreaterThan.new }
 
       rule(:ampersand) { str("&") }
 
@@ -14,12 +14,12 @@ class Code
 
       rule(:and_operator) do
         (
-          equality.as(:first) >>
+          greater_than.as(:first) >>
             (
               whitespace? >> operator.as(:operator) >> whitespace? >>
-                equality.as(:statement)
+                greater_than.as(:statement)
             ).repeat(1).as(:rest)
-        ).as(:and_operator) | equality
+        ).as(:and_operator) | greater_than
       end
 
       root(:and_operator)

data/lib/code/parser/call.rb

@@ -2,7 +2,7 @@ class Code
   class Parser
     class Call < Parslet::Parser
       rule(:dictionnary) { ::Code::Parser::Dictionnary.new }
-      rule(:code) { ::Code::Parser::Code.new }
+      rule(:code) { ::Code::Parser::Code.new.present }
       rule(:name) { ::Code::Parser::Name.new }
       rule(:function_arguments) { ::Code::Parser::Function.new.arguments }
 
@@ -72,12 +72,12 @@ class Code
       rule(:block) do
         (
           whitespace >> do_keyword >> whitespace >>
-            block_arguments.as(:arguments).maybe >> code.as(:body) >>
+            block_arguments.as(:arguments).maybe >> code.as(:body).maybe >>
             end_keyword
         ) |
           (
             whitespace? >> opening_curly_bracket >> whitespace >>
-              block_arguments.as(:arguments).maybe >> code.as(:body) >>
+              block_arguments.as(:arguments).maybe >> code.as(:body).maybe >>
               closing_curly_bracket
           )
       end

data/lib/code/parser/code.rb

@@ -8,11 +8,10 @@ class Code
       rule(:whitespace) { (space | newline).repeat(1) }
       rule(:whitespace?) { whitespace.maybe }
 
-      rule(:code) do
-        (whitespace?.ignore >> statement >> whitespace?.ignore).repeat(1) |
-          whitespace?.ignore
+      rule(:present) do
+        (whitespace?.ignore >> statement >> whitespace?.ignore).repeat(1)
       end
-
+      rule(:code) { present | whitespace?.ignore }
       root(:code)
     end
   end

data/lib/code/parser/defined.rb

@@ -1,7 +1,7 @@
 class Code
   class Parser
     class Defined < Parslet::Parser
-      rule(:equal) { ::Code::Parser::Equal.new }
+      rule(:range) { ::Code::Parser::Range.new }
       rule(:name) { ::Code::Parser::Name.new }
 
       rule(:defined_keyword) { str("defined?") }
@@ -11,7 +11,7 @@ class Code
       rule(:defined) do
         (
           defined_keyword >> opening_parenthesis >> name >> closing_parenthesis
-        ).as(:defined) | equal
+        ).as(:defined) | range
       end
 
       root(:defined)

data/lib/code/parser/dictionnary.rb

@@ -2,7 +2,7 @@ class Code
   class Parser
     class Dictionnary < Parslet::Parser
       rule(:list) { ::Code::Parser::List.new }
-      rule(:code) { ::Code::Parser::Code.new }
+      rule(:code) { ::Code::Parser::Code.new.present }
       rule(:string) { ::Code::Parser::String.new }
 
       rule(:opening_curly_bracket) { str("{") }

data/lib/code/parser/equality.rb

@@ -1,7 +1,7 @@
 class Code
   class Parser
     class Equality < Parslet::Parser
-      rule(:greater_than) { ::Code::Parser::GreaterThan.new }
+      rule(:while_parser) { ::Code::Parser::While.new }
 
       rule(:right_caret) { str(">") }
       rule(:left_caret) { str("<") }
@@ -22,12 +22,12 @@ class Code
 
       rule(:equality) do
         (
-          greater_than.as(:first) >>
+          while_parser.as(:first) >>
             (
               whitespace? >> operator.as(:operator) >> whitespace? >>
-                greater_than.as(:statement)
+                while_parser.as(:statement)
             ).repeat(1).as(:rest)
-        ).as(:equality) | greater_than
+        ).as(:equality) | while_parser
       end
 
       root(:equality)

data/lib/code/parser/function.rb

@@ -2,6 +2,7 @@ class Code
   class Parser
     class Function < Parslet::Parser
       rule(:call) { ::Code::Parser::Call.new }
+      rule(:code_present) { ::Code::Parser::Code.new.present }
       rule(:code) { ::Code::Parser::Code.new }
       rule(:name) { ::Code::Parser::Name.new }
 
@@ -22,14 +23,14 @@ class Code
       rule(:whitespace?) { whitespace.maybe }
 
       rule(:keyword_argument) do
-        name >> whitespace? >> colon >> (whitespace? >> code.as(:default)).maybe
+        name >> whitespace? >> colon >> code_present.as(:default).maybe
       end
 
       rule(:regular_argument) do
         ampersand.as(:block).maybe >>
           (asterisk >> asterisk).as(:keyword_splat).maybe >>
           asterisk.as(:splat).maybe >> name >>
-          (whitespace? >> equal >> whitespace? >> code.as(:default)).maybe
+          (whitespace? >> equal >> whitespace? >> code_present.as(:default)).maybe
       end
 
       rule(:argument) do

data/lib/code/parser/group.rb

@@ -2,7 +2,7 @@ class Code
   class Parser
     class Group < Parslet::Parser
       rule(:name) { ::Code::Parser::Name.new }
-      rule(:code) { ::Code::Parser::Code.new }
+      rule(:code) { ::Code::Parser::Code.new.present }
 
       rule(:opening_parenthesis) { str("(") }
       rule(:closing_parenthesis) { str(")") }

data/lib/code/parser/if.rb

@@ -2,7 +2,7 @@ class Code
   class Parser
     class If < Parslet::Parser
       rule(:if_modifier) { ::Code::Parser::IfModifier.new }
-      rule(:code) { ::Code::Parser::Code.new }
+      rule(:code) { ::Code::Parser::Code.new.present }
 
       rule(:if_keyword) { str("if") }
       rule(:else_keyword) { str("else") }
@@ -16,13 +16,13 @@ class Code
       rule(:if_rule) do
         (
           (if_keyword | unless_keyword).as(:if_operator) >> whitespace >>
-            if_modifier.as(:if_statement) >> code.as(:if_body) >>
+          if_modifier.as(:if_statement) >> code.as(:if_body).maybe >>
             (
               else_keyword >>
                 (
                   whitespace >> (if_keyword | unless_keyword).as(:operator) >>
                     whitespace >> if_modifier.as(:statement)
-                ).maybe >> code.as(:body)
+                ).maybe >> code.as(:body).maybe
             ).repeat(1).as(:elses).maybe >> end_keyword
         ).as(:if) | if_modifier
       end

data/lib/code/parser/list.rb

@@ -2,7 +2,7 @@ class Code
   class Parser
     class List < Parslet::Parser
       rule(:string) { ::Code::Parser::String.new }
-      rule(:code) { ::Code::Parser::Code.new }
+      rule(:code) { ::Code::Parser::Code.new.present }
 
       rule(:opening_square_bracket) { str("[") }
       rule(:closing_square_bracket) { str("]") }

data/lib/code/parser/not_keyword.rb

@@ -1,7 +1,7 @@
 class Code
   class Parser
     class NotKeyword < Parslet::Parser
-      rule(:defined) { ::Code::Parser::Defined.new }
+      rule(:equal) { ::Code::Parser::Equal.new }
 
       rule(:not_keyword) { str("not") }
 
@@ -12,7 +12,7 @@ class Code
       rule(:whitespace) { (space | newline).repeat(1) }
 
       rule(:not_rule) do
-        (not_keyword >> whitespace >> not_rule).as(:not_keyword) | defined
+        (not_keyword >> whitespace >> not_rule).as(:not_keyword) | equal
       end
 
       root(:not_rule)

data/lib/code/parser/statement.rb

@@ -1,7 +1,7 @@
 class Code
   class Parser
     class Statement < Parslet::Parser
-      rule(:statement) { ::Code::Parser::While.new }
+      rule(:statement) { ::Code::Parser::Equality.new }
       root(:statement)
     end
   end

data/lib/code/parser/string.rb

@@ -3,11 +3,14 @@ class Code
     class String < Parslet::Parser
       rule(:number) { ::Code::Parser::Number.new }
       rule(:name) { ::Code::Parser::Name.new.name }
+      rule(:code) { ::Code::Parser::Code.new }
 
       rule(:single_quote) { str("'") }
       rule(:double_quote) { str('"') }
       rule(:backslash) { str("\\") }
       rule(:colon) { str(":") }
+      rule(:opening_curly_bracket) { str("{") }
+      rule(:closing_curly_bracket) { str("}") }
 
       rule(:zero) { str("0") }
       rule(:one) { str("1") }
@@ -31,6 +34,10 @@ class Code
       rule(:t) { str("t") | str("T") }
       rule(:u) { str("u") | str("U") }
 
+      rule(:interpolation) do
+        opening_curly_bracket >> code >> closing_curly_bracket
+      end
+
       rule(:base_16_digit) do
         zero | one | two | three | four | five | six | seven | eight | nine |
           a | b | c | d | e | f
@@ -42,20 +49,28 @@ class Code
       end
 
       rule(:single_quoted_character) do
-        escaped_character | (single_quote.absent? >> any)
+        escaped_character | (opening_curly_bracket.absent? >> single_quote.absent? >> any)
       end
 
       rule(:double_quoted_character) do
-        escaped_character | (double_quote.absent? >> any)
+        escaped_character | (opening_curly_bracket.absent? >> double_quote.absent? >> any)
       end
 
       rule(:single_quoted_string) do
-        single_quote.ignore >> single_quoted_character.repeat >>
+        single_quote.ignore >>
+          (
+            interpolation.as(:interpolation) |
+            single_quoted_character.repeat(1).as(:characters)
+          ).repeat >>
           single_quote.ignore
       end
 
       rule(:double_quoted_string) do
-        double_quote.ignore >> double_quoted_character.repeat >>
+        double_quote.ignore >>
+          (
+            interpolation.as(:interpolation) |
+            double_quoted_character.repeat(1).as(:characters)
+          ).repeat >>
           double_quote.ignore
       end
 

data/lib/code/parser/ternary.rb

@@ -1,7 +1,7 @@
 class Code
   class Parser
     class Ternary < Parslet::Parser
-      rule(:range) { ::Code::Parser::Range.new }
+      rule(:defined) { ::Code::Parser::Defined.new }
 
       rule(:question_mark) { str("?") }
       rule(:colon) { str(":") }
@@ -13,10 +13,10 @@ class Code
 
       rule(:ternary) do
         (
-          range.as(:left) >> whitespace >> question_mark >> whitespace? >>
+          defined.as(:left) >> whitespace >> question_mark >> whitespace? >>
             ternary.as(:middle) >>
             (whitespace? >> colon >> whitespace? >> ternary.as(:right)).maybe
-        ).as(:ternary) | range
+        ).as(:ternary) | defined
       end
 
       root(:ternary)

data/lib/code-ruby.rb

@@ -0,0 +1,12 @@
+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.expand_path("lib/template-ruby.rb"))
+loader.ignore(File.expand_path("lib/code-ruby.rb"))
+loader.setup

data/lib/code.rb

@@ -1,30 +1,30 @@
 class Code
-  def initialize(input, io: $stdout, timeout: 10)
+  DEFAULT_TIMEOUT = Template::DEFAULT_TIMEOUT
+
+  def initialize(input, io: $stdout, timeout: DEFAULT_TIMEOUT)
     @input = input
-    @parsed = Timeout::timeout(timeout) do
-      ::Code::Parser::Code.new.parse(@input)
-    end
+    @parsed = Timeout.timeout(timeout) { ::Code::Parser::Code.new.parse(@input) }
     @io = io
-    @timeout = timeout
+    @timeout = timeout || DEFAULT_TIMEOUT
   end
 
-  def self.evaluate(input, context = "", io: $stdout, timeout: 10)
+  def self.evaluate(input, context = "", io: $stdout, timeout: DEFAULT_TIMEOUT)
     new(input, io: io, timeout: timeout).evaluate(context)
   end
 
   def evaluate(context = "")
-    Timeout::timeout(@timeout) do
+    Timeout.timeout(timeout) do
       if context.present?
-        context = ::Code.evaluate(context, timeout: @timeout)
+        context = ::Code.evaluate(context, timeout: timeout)
       else
         context = ::Code::Object::Dictionnary.new
       end
 
-      ::Code::Node::Code.new(parsed).evaluate(context: context, io: @io)
+      ::Code::Node::Code.new(parsed).evaluate(context: context, io: io)
     end
   end
 
   private
 
-  attr_reader :input, :parsed
+  attr_reader :input, :parsed, :timeout, :io
 end

data/lib/template/version.rb

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

data/lib/template-ruby.rb

@@ -3,9 +3,11 @@ 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"
 
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
-loader.ignore(__FILE__)
+loader.ignore(File.expand_path("lib/template-ruby.rb"))
+loader.ignore(File.expand_path("lib/code-ruby.rb"))
 loader.setup

data/lib/template.rb

@@ -1,30 +1,40 @@
 class Template
-  VERSION = Gem::Version.new("0.2.3")
+  DEFAULT_TIMEOUT = 10
 
-  def initialize(input, io: StringIO.new, timeout: 10)
+  def initialize(input, io: StringIO.new, timeout: DEFAULT_TIMEOUT)
     @input = input
-    @parsed = Timeout::timeout(timeout) do
-      ::Template::Parser::Template.new.parse(@input)
-    end
+    @parsed =
+      Timeout.timeout(timeout) do
+        ::Template::Parser::Template.new.parse(@input)
+      end
     @io = io
-    @timeout = timeout
+    @timeout = timeout || DEFAULT_TIMEOUT
   end
 
-  def self.render(input, context = "", io: StringIO.new, timeout: 10)
+  def self.render(input, context = "", io: StringIO.new, timeout: DEFAULT_TIMEOUT)
     new(input, io: io, timeout: timeout).render(context)
   end
 
   def render(context = "")
-    Timeout::timeout(@timeout) do
+    Timeout.timeout(timeout) do
       if context.present?
-        context = ::Code.evaluate(context, timeout: @timeout)
+        context = ::Code.evaluate(context, timeout: timeout)
       else
         context = ::Code::Object::Dictionnary.new
       end
 
-      ::Template::Node::Template.new(@parsed).evaluate(context: context, io: @io)
+      ::Template::Node::Template.new(parsed).evaluate(
+        context: context,
+        io: io,
+      )
 
-      @io.is_a?(StringIO) ? @io.string : nil
+      io.is_a?(StringIO) ? io.string : nil
     end
   end
+
+  private
+
+  attr_reader :parsed, :io, :timeout
 end
+
+require_relative "template/version"

data/spec/code/error/type_error_spec.rb

@@ -14,7 +14,6 @@ RSpec.describe ::Code::Error::TypeError do
       '1 / ""',
       '1 ** ""',
       '1 % ""',
-      '1 + ""',
       '1 - ""',
       '1 << ""',
       '1 >> ""',
@@ -48,7 +47,6 @@ RSpec.describe ::Code::Error::TypeError do
       '1.0 ** ""',
       '1.0 * ""',
       '1.0 % ""',
-      '1.0 + ""',
       '1.0 - ""',
       '1.0 > ""',
       '1.0 >= ""',

data/spec/code/parser/dictionnary_spec.rb

@@ -4,42 +4,15 @@ 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)|
+    '{name: "Dorian"}',
+    '{a: true, "b": false}',
+    "{ true => 1, false => 2}",
+  ].each do |input|
     context input.inspect do
       let(:input) { input }
 
       it "succeeds" do
-        expect(subject).to eq(expected)
+        expect { subject }.to_not raise_error
       end
     end
   end