code-ruby 0.2.4 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82ade8726d95b0c6a5305197d56eeba0470ba5ae02df49ae96ec5fb1d16a46bf
-  data.tar.gz: 004cc8befedb42093761f65464c24d937e8437b14adba8d8bcd0998831be972e
+  metadata.gz: 1dfeedb1e668e150c3039e1cee85eee9072ea16d0f619f45e71263c8c94ae707
+  data.tar.gz: 1c2fb6de918462b02df14191ab14f7d27a92f0bea9113a54fa8344e7b8bab48e
 SHA512:
-  metadata.gz: 817a6ae6b29e967cca049d5b31c39348a8dfb9c4e84c78bae33053389f3d8e2768689e07b290b6e3ed66e3929871d95c5efd0df190f2b54623b00be283847603
-  data.tar.gz: 4535e7a6cfad6639b837c75fc54ad369b6b7666007cc360300aa3ef520f4da5e8b4ce402e6e65bf74460a3fd8eecc8ff25db7c94097c9cfadb38e53874658a19
+  metadata.gz: c810a7b5a9ca1cbfc9c710e1ec615dd043dccf047fd220f35b71cf8e7fa2feab9cbf3fde9b1f31b57c690e25f5be1e71f4881a0efced0baea0b9f51e4a9abd78
+  data.tar.gz: 45571c9a8247d75f3c513e52dfebc4ed3e3fe527996c5a1dc8717fb740c6fa4736c6fb26da93c57a73558318f45a4bf5dc3d2ccf38b460d570b58d1171e8a776

data/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.3.1 / 2022-10-13
+
+- Fix Zeitwerk auto-loading issue
+
+## 0.3.0 / 2022-10-10
+
+- `bin/template` accepts `--timeout` (or `-t`) parameter
+- Adds `bin/code` with same options as `bin/template`
+- Prevent loose syntax like `{ a: }`, `[1,,,]` and `()`
+- Change precedence of defined? (to allow `defined?(name) ? name : nothing`)
+- Updates parsers to allow `while false end == nothing`
+- String interpolations like `"1 + 1 = {1 + 1}"`
+- `context(:name)` to get a function without calling it for instance
+- `.to_string` on all objects
+- `1 + "a"` and `"a" + 1.0` for instance now convert to strings
+- `Dictionnary#each` e.g. `{ a: 1 }.each { |k, v| print(k) }`
+- Fix context duplication issue that was preventing implementation of recursive
+  functions like Fibonacci
+
 ## 0.2.4 / 2022-08-02
 
 - Add method `String#*`, e.g. `{"Dorian " \* 2}" -> "Dorian Dorian "

data/Gemfile

@@ -1,3 +1,4 @@
 source "https://rubygems.org"
 
-gemspec
+gemspec name: "template-ruby"
+gemspec name: "code-ruby"

data/Gemfile.lock

@@ -1,7 +1,11 @@
 PATH
   remote: .
   specs:
-    template-ruby (0.2.3)
+    code-ruby (0.2.4)
+      activesupport (~> 7)
+      parslet (~> 2)
+      zeitwerk (~> 2.6)
+    template-ruby (0.2.4)
       activesupport (~> 7)
       parslet (~> 2)
       zeitwerk (~> 2.6)
@@ -62,6 +66,7 @@ PLATFORMS
   arm64-darwin-21
 
 DEPENDENCIES
+  code-ruby!
   prettier (~> 3)
   rspec (~> 3)
   template-ruby!

data/bin/code

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require_relative "../lib/template-ruby"
+
+options = { timeout: 0 }
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: bin/code [options]"
+
+  opts.on(
+    "-i INPUT",
+    "--input=INPUT",
+    "Input in the code language (String or File)"
+  ) do |input|
+    if File.exists?(input)
+      input = File.read(input)
+    end
+
+    options[:input] = input
+  end
+
+  opts.on(
+    "-c CONTEXT",
+    "--context=CONTEXT",
+    "Context in the code language (String or File)"
+  ) do |context|
+    if File.exists?(context)
+      context = File.read(context)
+    end
+
+    options[:context] = context
+  end
+
+  opts.on("-p", "--parse", "Get parser results for input") do |parse|
+    options[:parse] = parse
+  end
+
+  opts.on("-t TIMEOUT", "--timeout=TIMEOUT", "Set timeout in seconds") do |timeout|
+    options[:timeout] = timeout.to_f
+  end
+end.parse!
+
+input = options.fetch(:input, "")
+context = options.fetch(:context, "")
+
+if options[:parse]
+  pp ::Code::Parser::Code.new.parse(input)
+else
+  print Code.evaluate(input, context, io: $stdout, timeout: options[:timeout]).to_s
+end

data/bin/template

@@ -3,7 +3,7 @@
 require "optparse"
 require_relative "../lib/template-ruby"
 
-options = {}
+options = { timeout: 0 }
 
 OptionParser.new do |opts|
   opts.banner = "Usage: template [options]"
@@ -27,6 +27,10 @@ OptionParser.new do |opts|
   opts.on("-p", "--parse", "Get parser results for input") do |parse|
     options[:parse] = parse
   end
+
+  opts.on("-t TIMEOUT", "--timeout=TIMEOUT", "Set timeout in seconds") do |timeout|
+    options[:timeout] = timeout.to_f
+  end
 end.parse!
 
 input = options.fetch(:input, "")
@@ -35,5 +39,5 @@ context = options.fetch(:context, "")
 if options[:parse]
   pp ::Template::Parser::Template.new.parse(input)
 else
-  Template.render(input, context, io: $stdout)
+  Template.render(input, context, io: $stdout, timeout: options[:timeout])
 end

data/docs/euler/4.template

@@ -3,7 +3,6 @@
   min = 1
   max = 999
 
-
   (min..max).map do |i|
     ((min..max).to_list.reverse.detect do |j|
       (i * j).to_string.reverse == (i * j).to_string

data/docs/fibonnaci.template

@@ -0,0 +1,14 @@
+{
+  fibonnaci = (n) => {
+    if n < 2
+      n
+    else
+      fibonnaci(n - 1) + fibonnaci(n - 2)
+    end
+  }
+
+  (0..20).each do |i|
+    puts("fibonnaci({i}) = {fibonnaci(i)}")
+  end
+
+  nothing

data/docs/precedence.template

@@ -2,58 +2,33 @@
   - {a = "Go" a += "od" a}
 - Statement
   - {a = "Good"}
-  - {
-     a = 0
-     while a < 10
-       a += 1
-       "Good"
-    end
-    }
+- Equality
+  - {1 == 1 ? "Good"}
 - While
-  - {
-     a = 0
-     until a > 10
-       a += 1
-       "Good"
-    end
-    }
-  - {
-    a = 0
-    while
-      if a > 10
-        false
-      else
-        true
-      end
-      a += 1
-      "Good"
-    end
-    }
+  - {a = 0
+     while a < 10 a += 1 "Good" end}
 - If
   - {if true "Good" end}
-  - {if true if false "Bad" else "Good" end}
 - IfModifier
   - {"Good" if true}
 - OrKeyword
   - {false or "Good"}
 - NotKeyword
   - {not false and "Good"}
-- Defined
-  - {a = 1 "Good" if defined?(a)}
 - Equal
   - {a = "Good"}
 - Rescue
   - {0 > "String" rescue "Good"}
 - Ternary
   - {nothing ? "Bad" : "Good"}
+- Defined
+  - {a = 1 "Good" if defined?(a)}
 - Range
   - {("Good".."Bad").first}
 - OrOperator
   - {false || "Good"}
 - AndOperator
   - {"Bad" && "Good"}
-- Equality
-  - {1 == 1 ? "Good"}
 - GreaterThan
   - {2 > 1 ? "Good"}
 - BitwiseOr

data/lib/code/node/code.rb

@@ -9,7 +9,13 @@ class Code
       end
 
       def evaluate(**args)
-        @statements.map { |statement| statement.evaluate(**args) }.last
+        last = ::Code::Object::Nothing.new
+
+        @statements.each do |statement|
+          last = statement.evaluate(**args)
+        end
+
+        last
       end
     end
   end

data/lib/code/node/list.rb

@@ -2,13 +2,13 @@ class Code
   class Node
     class List < Node
       def initialize(codes)
-        @codes =
-          codes
-            .map do |code|
-              code.fetch(:code).presence &&
-                ::Code::Node::Code.new(code.fetch(:code))
-            end
-            .compact
+        if codes.to_s.blank?
+          @codes = []
+        else
+          @codes = codes.map do |code|
+            ::Code::Node::Code.new(code.fetch(:code))
+          end
+        end
       end
 
       def evaluate(**args)

data/lib/code/node/name.rb

@@ -33,8 +33,13 @@ class Code
           end
         elsif name == "puts"
           arguments.each { |argument| io.puts argument.value }
-
           ::Code::Object::Nothing.new
+        elsif name == "print"
+          arguments.each { |argument| io.print argument.value }
+          ::Code::Object::Nothing.new
+        elsif name == "context"
+          return ::Code::Object::Nothing.new if arguments.size != 1
+          context[arguments.first&.value] || ::Code::Object::Nothing.new
         else
           raise ::Code::Error::Undefined.new("#{name} undefined")
         end

data/lib/code/node/string.rb

@@ -2,16 +2,21 @@ class Code
   class Node
     class String < Node
       def initialize(string)
-        @string = string
+        if string.to_s.blank?
+          @string = []
+        elsif string.is_a?(Array)
+          @string = string.map do |component|
+            ::Code::Node::StringComponent.new(component)
+          end
+        else
+          @string = [::Code::Node::StringCharacters.new(string)]
+        end
       end
 
       def evaluate(**args)
-        ::Code::Object::String.new(string.to_s)
+        string = @string.map { |component| component.evaluate(**args) }.map(&:to_s).join
+        ::Code::Object::String.new(string)
       end
-
-      private
-
-      attr_reader :string
     end
   end
 end

data/lib/code/node/string_characters.rb

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

data/lib/code/node/string_component.rb

@@ -0,0 +1,23 @@
+class Code
+  class Node
+    class StringComponent < Node
+      def initialize(component)
+        if component.key?(:characters)
+          @component = ::Code::Node::StringCharacters.new(
+            component.fetch(:characters)
+          )
+        elsif component.key?(:interpolation)
+          @component = ::Code::Node::StringInterpolation.new(
+            component.fetch(:interpolation)
+          )
+        else
+          raise NotImplementedError.new(component.inspect)
+        end
+      end
+
+      def evaluate(**args)
+        @component.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/code/node/string_interpolation.rb

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

data/lib/code/object/argument.rb

@@ -30,7 +30,7 @@ class Code
       end
 
       def to_s
-        "argument"
+        "<Argument #{value.inspect}>"
       end
 
       def inspect

data/lib/code/object/decimal.rb

@@ -19,10 +19,14 @@ class Code
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
 
-        if %w[% - + / * **].detect { |o| operator == o }
+        if %w[% - / * **].detect { |o| operator == o }
           number_operation(operator.to_sym, arguments)
         elsif %w[< <= > >=].detect { |o| operator == o }
           comparaison(operator.to_sym, arguments)
+        elsif %w[<< >> & | ^].detect { |o| operator == o }
+          integer_operation(operator.to_sym, arguments)
+        elsif operator == "+"
+          plus(arguments)
         else
           super
         end
@@ -44,11 +48,28 @@ class Code
         ::Code::Object::Decimal.new(raw.public_send(operator, other.raw))
       end
 
+      def integer_operation(operator, arguments)
+        sig(arguments, ::Code::Object::Number)
+        other = arguments.first.value
+        ::Code::Object::Integer.new(raw.to_i.public_send(operator, other.raw.to_i))
+      end
+
       def comparaison(operator, arguments)
         sig(arguments, ::Code::Object::Number)
         other = arguments.first.value
         ::Code::Object::Boolean.new(raw.public_send(operator, other.raw))
       end
+
+      def plus(arguments)
+        sig(arguments, ::Code::Object)
+        other = arguments.first.value
+
+        if other.is_a?(::Code::Object::Number)
+          ::Code::Object::Decimal.new(raw + other.raw)
+        else
+          ::Code::Object::String.new(to_s + other.to_s)
+        end
+      end
     end
   end
 end

data/lib/code/object/dictionnary.rb

@@ -10,9 +10,13 @@ class Code
       def call(**args)
         operator = args.fetch(:operator, nil)
         arguments = args.fetch(:arguments, [])
+        context = args.fetch(:context)
+        io = args.fetch(:io)
 
         if operator == "values"
           values(arguments)
+        elsif operator == "each"
+          each(arguments, context: context, io: io)
         elsif key?(operator)
           fetch(operator)
         else
@@ -36,6 +40,10 @@ class Code
         raw.key?(key)
       end
 
+      def deep_dup
+        ::Code::Object::Dictionnary.new(raw.deep_dup)
+      end
+
       def to_s
         "{#{raw.map { |key, value| "#{key.inspect} => #{value.inspect}" }.join(", ")}}"
       end
@@ -50,6 +58,22 @@ class Code
         sig(arguments)
         ::Code::Object::List.new(raw.values)
       end
+
+      def each(arguments, context:, io:)
+        sig(arguments, ::Code::Object::Function)
+        argument = arguments.first.value
+        raw.each do |key, value|
+          argument.call(
+            arguments: [
+              ::Code::Object::Argument.new(key),
+              ::Code::Object::Argument.new(value)
+            ],
+            context: context,
+            io: io,
+          )
+        end
+        self
+      end
     end
   end
 end

data/lib/code/object/function.rb

@@ -32,7 +32,8 @@ class Code
       attr_reader :arguments, :body
 
       def call_function(args:, context:, io:)
-        new_context = context.dup
+        new_context = context.deep_dup
+
         arguments.each.with_index do |argument, index|
           if argument.regular?
             if argument.splat?

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

@@ -48,9 +48,9 @@ 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)

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

@@ -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("#{__dir__}/template-ruby.rb")
+loader.ignore("#{__dir__}/code-ruby.rb")
 loader.setup

data/lib/code.rb

@@ -1,29 +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) { ::Code::Parser::Code.new.parse(@input) }
+    @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

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

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("#{__dir__}/template-ruby.rb")
+loader.ignore("#{__dir__}/code-ruby.rb")
 loader.setup

data/lib/template.rb

@@ -1,34 +1,40 @@
 class Template
-  def initialize(input, io: StringIO.new, timeout: 10)
+  DEFAULT_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
     @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(
+      ::Template::Node::Template.new(parsed).evaluate(
         context: context,
-        io: @io,
+        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

data/spec/code/parser/string_spec.rb

@@ -4,26 +4,25 @@ 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)|
+    "'hello'",
+    '"hello"',
+    "''",
+    '""',
+    "'\\''",
+    '"\\t"',
+    "'\\r'",
+    '"\\b\\f\\n\\r\\t"',
+    '"\\uABCG"',
+    "'\\u0123\\u4567\\u89aA\\ubBcC\\UdDeE\\ufFfF'",
+    ":asc",
+    "'1 + 1 = {1 + 1}'",
+    "'a + b = {'{'a'}{'b'}'}'"
+  ].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

data/spec/code_spec.rb

@@ -96,6 +96,18 @@ RSpec.describe Code do
     ["until true\nend", ""],
     %w[("Good".."Bad").first Good],
     ['"Dorian " * 2', "Dorian Dorian "],
+    ["while false end == nothing", "true"],
+    ['"1 + 1 = {1 + 1}"', "1 + 1 = 2"],
+    ["'1 + 1 = {1 + 1}'", "1 + 1 = 2"],
+    ["{}.to_string + [].to_string", "{}[]"],
+    ["'a' + 1", "a1"],
+    ["'a' + 1.0", "a1.0"],
+    ["1 + 'a'", "1a"],
+    ["1.0 + 'a'", "1.0a"],
+    ["1 << 1", "2"],
+    ["1.0 << 1", "2"],
+    ["1 << 1.0", "2"],
+    ["1.0 << 1.0", "2"],
   ].each do |(input, expected)|
     context input.inspect do
       let(:input) { input }

data/spec/template_spec.rb

@@ -12,7 +12,13 @@ RSpec.describe Template do
       '{ user: { first_name: "Dorian" } }',
       "Hello Dorian",
     ],
+    [
+      "{add(1, 2)",
+      'add = (a, b) => { a + b } { add: context(:add) }',
+      "3",
+    ],
     ["Hello {", "", "Hello "],
+    ["{{a: 1}.each { |k, v| print(k) } nothing", "", "a"],
     ["", "", ""],
   ].each do |(input, input_context, expected)|
     context "#{input.inspect} #{input_context.inspect}" do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code-ruby
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.1
 platform: ruby
 authors:
 - Dorian Marié
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-02 00:00:00.000000000 Z
+date: 2022-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -96,7 +96,7 @@ files:
 - Gemfile.lock
 - LICENSE
 - README.md
-- TODO.md
+- bin/code
 - bin/template
 - code-ruby.gemspec
 - docs/euler/1.template
@@ -104,6 +104,7 @@ files:
 - docs/euler/3.template
 - docs/euler/4.template
 - docs/euler/5.template
+- docs/fibonnaci.template
 - docs/precedence.template
 - lib/code-ruby.rb
 - lib/code.rb
@@ -147,6 +148,9 @@ files:
 - lib/code/node/rescue.rb
 - lib/code/node/statement.rb
 - lib/code/node/string.rb
+- lib/code/node/string_characters.rb
+- lib/code/node/string_component.rb
+- lib/code/node/string_interpolation.rb
 - lib/code/node/ternary.rb
 - lib/code/node/unary_minus.rb
 - lib/code/node/while.rb
@@ -243,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.18
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: A programming language

data/TODO.md

@@ -1 +0,0 @@
-- Code gem