template-ruby 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51afb6ed8605217e5960882e6b007cdd3b96dd8c3f72e0cb372e67b55d96e88b
-  data.tar.gz: 18bfdbb2a0a22b736aa9282f2875021d4e5398f0d61c1c35f402c4a1a8e2d4dd
+  metadata.gz: 5e240c31089e37775df02ba1ea0646922413b26860318456d19ed5d2b38ed077
+  data.tar.gz: 25f45bb4ef78e1f62e63a960ce3fa46245b60dfab8fd96a273caf823ee2b016f
 SHA512:
-  metadata.gz: 7cd8c95144f5a535b704f79cbb559d1868bfad164d8c08a261ae915afb94d3c06b02fae4eb2cc51000a49547a48a282cbf35043e7d769ff890338c78958f4b42
-  data.tar.gz: 00cd29f362d8bb6b93ae782daaef8a87e4dcade2c299ce9504e2579faa5558005fa4305706006fa21b54b7c9b3d5b4ef74d561d7a28775454112c6181d4be00c
+  metadata.gz: a2870be4d39f138c269946c935985d2de54c4364307630011b8de8095d50dd7a72de3a71f401414c64e416832c2d4f6e9a8e92d7e6038855725e35c7e0cbbdd9
+  data.tar.gz: 77fd004c7464e2715726dfec039925e8c4653d6a78993cf6d1c6cecb717f08fcb5e04f9cebf7acf130bb3ed7fcac7891e65ef8fe0db37ab9c66724ef9b2cd923

data/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true

data/.gitignore

@@ -1 +1,2 @@
 *.gem
+examples.txt

data/.prettierrc

@@ -0,0 +1,3 @@
+{
+  "rubyPlugins": "plugin/trailing_comma"
+}

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+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.2.2 / 2022-08-31
+
+- Fix parsing error when the template is empty, e.g. ""
+
+## 0.2.1 / 2022-08-31
+
+- Fix parsing error on empty code like `Hello {`
+
+## 0.2.0 / 2022-08-30
+
+- Programming language capable of solving the first 5 Project Euler problems
+
+## 0.1.0 / 2022-07-28
+
+- Initial version with interpolation

data/Gemfile.lock

@@ -1,10 +1,10 @@
 PATH
   remote: .
   specs:
-    template-ruby (0.1.0)
+    template-ruby (0.2.2)
       activesupport (~> 7)
       parslet (~> 2)
-      zeitwerk (~> 2)
+      zeitwerk (~> 2.6)
 
 GEM
   remote: https://rubygems.org/
@@ -21,7 +21,7 @@ GEM
       tilt
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    minitest (5.16.2)
+    minitest (5.16.3)
     parslet (2.0.0)
     prettier (3.2.0)
       syntax_tree (>= 2.7.1)
@@ -42,9 +42,9 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.11.0)
     rspec-support (3.11.0)
-    syntax_tree (3.2.1)
+    syntax_tree (3.5.0)
       prettier_print
-    syntax_tree-haml (1.3.0)
+    syntax_tree-haml (1.3.1)
       haml (>= 5.2)
       prettier_print
       syntax_tree (>= 2.0.1)

data/README.md

@@ -0,0 +1,10 @@
+# `template-ruby`
+
+A templating programming language
+
+Like `Hello {name}` with `{name: "Dorian"}` gives `Hello Dorian`.
+
+```ruby
+> Template.render("Hello {name}", '{name: "Dorian"}')
+=> "Hello Dorian"
+```

data/bin/template

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require_relative "../lib/template-ruby"
+
+options = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{$PROGRAM_NAME} [options]"
+
+  opts.on("-i INPUT", "--input=INPUT", "Input in the template language") 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") 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
+end.parse!
+
+input = options.fetch(:input, "")
+context = options.fetch(:context, "")
+
+if options[:parse]
+  pp ::Template::Parser::Template.new.parse(input)
+else
+  Template.render(input, context, io: $stdout)
+end

data/docs/euler/1.template

@@ -0,0 +1,14 @@
+{
+  sum = 0
+
+  i = 1
+
+  while i < 1000
+    if i % 3 == 0 or i % 5 == 0
+      sum += i
+    end
+
+    i += 1
+  end
+
+  sum

data/docs/euler/2.template

@@ -0,0 +1,16 @@
+{
+  a = 1
+  b = 2
+  sum = 2
+
+  while b < 4000000
+    c = a + b
+    a = b
+    b = c
+
+    if b % 2 == 0
+      sum += b
+    end
+  end
+
+  sum

data/docs/euler/3.template

@@ -0,0 +1,16 @@
+{
+  n = 600851475143
+  max = 0
+
+  i = 2
+
+  until n == 1
+    while n % i == 0
+      max = i
+      n = n / i
+    end
+
+    i += 1
+  end
+
+  max

data/docs/euler/4.template

@@ -0,0 +1,11 @@
+{
+
+  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
+    end || 0) * i
+  end.max

data/docs/euler/5.template

@@ -0,0 +1,14 @@
+{
+  min = 1
+  max = 20
+
+  step = [2, 3, 5, 7, 11, 13, 17].reduce do |acc, el|
+    acc * el
+  end
+
+  (step..(step * step)).step(step).detect do |i|
+    (min..max).all? do |j|
+      i % j == 0
+    end
+  end
+}

data/docs/precedence.template

@@ -0,0 +1,94 @@
+- Code
+  - {a = "Go" a += "od" a}
+- Statement
+  - {a = "Good"}
+  - {
+     a = 0
+     while a < 10
+       a += 1
+       "Good"
+    end
+    }
+- While
+  - {
+     a = 0
+     until a > 10
+       a += 1
+       "Good"
+    end
+    }
+  - {
+    a = 0
+    while
+      if a > 10
+        false
+      else
+        true
+      end
+      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"}
+- Range
+  - {("Good".."Bad").first}
+- OrOperator
+  - {false || "Good"}
+- AndOperator
+  - {"Bad" && "Good"}
+- Equality
+  - {1 == 1 ? "Good"}
+- GreaterThan
+  - {2 > 1 ? "Good"}
+- BitwiseOr
+  - {2 | 1 == 3 ? "Good"}
+- BitwiseAnd
+  - {2 & 1 == 0 ? "Good"}
+- Shift
+  - {1 << 1 == 2 ? "Good"}
+- Addition
+  - {1 + 1 == 2 ? "Good"}
+- Multiplication
+  - {1 * 2 == 2 ? "Good"}
+- UnaryMinus
+  - {-1 == 1 - 2 ? "Good"}
+- Power
+  - {2 ** 2 == 4 ? "Good"}
+- Negation
+  - {!false ? "Good"}
+- Function
+  - {good = () => { "Good" } good}
+- Call
+  - {["Good"].first}
+- Dictionnary
+  - {{a: "Good"}.a}
+- List
+  - {["Good", "Bad"].first}
+- String
+  - {"Good"}
+- Number
+  - {1 == 1 ? "Good"}
+- Boolean
+  - {true ? "Good"}
+- Nothing
+  - {nothing ? "Bad" : "Good"}
+- Group
+  - {(a = 0 a += 1 a) == 1 ? "Good"}
+- Name
+  - {a = "Good" a}

data/lib/code/error.rb

@@ -0,0 +1,15 @@
+class Code
+  class Error < StandardError
+    class TypeError < ::Code::Error
+    end
+
+    class Undefined < ::Code::Error
+    end
+
+    class UndefinedVariable < ::Code::Error
+    end
+
+    class ArgumentError < ::Code::Error
+    end
+  end
+end

data/lib/code/node/base_10_decimal.rb

@@ -1,6 +1,6 @@
 class Code
   class Node
-    class Base10Decimal
+    class Base10Decimal < Node
       def initialize(number)
         @sign = number[:sign]
         @whole = number.fetch(:whole)
@@ -11,12 +11,17 @@ class Code
         end
       end
 
-      def evaluate(context)
-        @exponent = @exponent.evaluate(context) if @exponent
-        ::Code::Object::Decimal.new(
-          "#{sign}#{whole}.#{decimal}",
-          exponent: @exponent
-        )
+      def evaluate(**args)
+        if @exponent
+          exponent = @exponent.evaluate(**args)
+
+          ::Code::Object::Decimal.new(
+            "#{sign}#{whole}.#{decimal}",
+            exponent: exponent,
+          )
+        else
+          ::Code::Object::Decimal.new("#{sign}#{whole}.#{decimal}")
+        end
       end
 
       private

data/lib/code/node/base_10_integer.rb

@@ -1,6 +1,6 @@
 class Code
   class Node
-    class Base10Integer
+    class Base10Integer < Node
       def initialize(number)
         @sign = number[:sign]
         @whole = number.fetch(:whole)
@@ -10,9 +10,18 @@ class Code
         end
       end
 
-      def evaluate(context)
-        @exponent = @exponent.evaluate(context) if @exponent
-        ::Code::Object::Integer.new("#{sign}#{whole}", exponent: @exponent)
+      def evaluate(**args)
+        if @exponent
+          exponent = @exponent.evaluate(**args)
+
+          if exponent.is_a?(::Code::Object::Decimal)
+            ::Code::Object::Decimal.new("#{sign}#{whole}", exponent: exponent)
+          else
+            ::Code::Object::Integer.new("#{sign}#{whole}", exponent: exponent)
+          end
+        else
+          ::Code::Object::Integer.new("#{sign}#{whole}")
+        end
       end
 
       private

data/lib/code/node/base_10_number.rb

@@ -1,6 +1,6 @@
 class Code
   class Node
-    class Base10Number
+    class Base10Number < Node
       def initialize(number)
         if number.key?(:integer)
           @number = ::Code::Node::Base10Integer.new(number[:integer])
@@ -11,8 +11,8 @@ class Code
         end
       end
 
-      def evaluate(context)
-        @number.evaluate(context)
+      def evaluate(**args)
+        @number.evaluate(**args)
       end
     end
   end

data/lib/code/node/base_16_number.rb

@@ -1,11 +1,11 @@
 class Code
   class Node
-    class Base16Number
+    class Base16Number < Node
       def initialize(number)
         @number = number
       end
 
-      def evaluate(context)
+      def evaluate(**args)
         ::Code::Object::Integer.new(number)
       end
 

data/lib/code/node/base_2_number.rb

@@ -1,11 +1,11 @@
 class Code
   class Node
-    class Base2Number
+    class Base2Number < Node
       def initialize(number)
         @number = number
       end
 
-      def evaluate(context)
+      def evaluate(**args)
         ::Code::Object::Integer.new(number)
       end
 

data/lib/code/node/base_8_number.rb

@@ -1,11 +1,11 @@
 class Code
   class Node
-    class Base8Number
+    class Base8Number < Node
       def initialize(number)
         @number = number
       end
 
-      def evaluate(context)
+      def evaluate(**args)
         ::Code::Object::Integer.new(number)
       end
 

data/lib/code/node/block.rb

@@ -0,0 +1,17 @@
+class Code
+  class Node
+    class Block < Node
+      def initialize(block)
+        @body = ::Code::Node::Code.new(block.fetch(:body))
+        @arguments = block.fetch(:arguments, [])
+        @arguments.map! do |argument|
+          ::Code::Node::FunctionArgument.new(argument)
+        end
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Function.new(arguments: @arguments, body: @body)
+      end
+    end
+  end
+end

data/lib/code/node/boolean.rb

@@ -1,12 +1,21 @@
 class Code
   class Node
-    class Boolean
+    class Boolean < Node
+      TRUE = "true"
+      FALSE = "false"
+
       def initialize(boolean)
-        @boolean = boolean == "true" ? true : false
+        @boolean = boolean
       end
 
-      def evaluate(_context)
-        ::Code::Object::Boolean.new(@boolean)
+      def evaluate(**args)
+        if @boolean == TRUE
+          ::Code::Object::Boolean.new(true)
+        elsif @boolean == FALSE
+          ::Code::Object::Boolean.new(false)
+        else
+          raise NotImplementedError, @boolean.inspect
+        end
       end
     end
   end

data/lib/code/node/call.rb

@@ -1,19 +1,52 @@
 class Code
   class Node
-    class Call
+    class Call < Node
       def initialize(call)
         @left = ::Code::Node::Statement.new(call.fetch(:left))
-        @right = ::Code::Node::Statement.new(call.fetch(:right))
-      end
 
-      def evaluate(context)
-        context = left.evaluate(context)
-        right.evaluate(context)
+        @arguments = call.fetch(:arguments, [])
+        @arguments.map! { |argument| ::Code::Node::CallArgument.new(argument) }
+
+        if call.key?(:right)
+          @right =
+            call
+              .fetch(:right)
+              .map { |right| ::Code::Node::ChainedCall.new(right) }
+        end
+
+        if call.key?(:block)
+          @block = ::Code::Node::Block.new(call.fetch(:block))
+        end
       end
 
-      private
+      def evaluate(**args)
+        if @right
+          left = @left.evaluate(**args)
+          @right.reduce(left) do |acc, element|
+            element.evaluate(**args.merge(object: acc))
+          end
+        else
+          arguments =
+            @arguments.map do |argument|
+              ::Code::Object::Argument.new(
+                argument.evaluate(**args),
+                name: argument.name,
+                splat: argument.splat?,
+                keyword_splat: argument.keyword_splat?,
+                block: argument.block?,
+              )
+            end
 
-      attr_reader :left, :right
+          if @block
+            arguments << ::Code::Object::Argument.new(
+              @block.evaluate(**args),
+              block: true,
+            )
+          end
+
+          @left.evaluate(**args.merge(arguments: arguments))
+        end
+      end
     end
   end
 end

data/lib/code/node/call_argument.rb

@@ -0,0 +1,37 @@
+class Code
+  class Node
+    class CallArgument < Node
+      def initialize(argument)
+        if argument.key?(:regular)
+          @argument =
+            ::Code::Node::RegularCallArgument.new(argument.fetch(:regular))
+        elsif argument.key?(:keyword)
+          @argument =
+            ::Code::Node::KeywordCallArgument.new(argument.fetch(:keyword))
+        else
+          raise NotImplementedError.new(argument.inspect)
+        end
+      end
+
+      def evaluate(**args)
+        @argument.evaluate(**args)
+      end
+
+      def name
+        @argument.name
+      end
+
+      def block?
+        @argument.block?
+      end
+
+      def splat?
+        @argument.splat?
+      end
+
+      def keyword_splat?
+        @argument.keyword_splat?
+      end
+    end
+  end
+end

data/lib/code/node/chained_call.rb

@@ -0,0 +1,38 @@
+class Code
+  class Node
+    class ChainedCall < Node
+      def initialize(chained_call)
+        @name = ::Code::Node::Name.new(chained_call.fetch(:name))
+
+        @arguments = chained_call.fetch(:arguments, [])
+        @arguments.map! { |argument| ::Code::Node::CallArgument.new(argument) }
+
+        if chained_call.key?(:block)
+          @block = ::Code::Node::Block.new(chained_call.fetch(:block))
+        end
+      end
+
+      def evaluate(**args)
+        arguments =
+          @arguments.map do |argument|
+            ::Code::Object::Argument.new(
+              argument.evaluate(**args.merge(object: nil)),
+              name: argument.name,
+              splat: argument.splat?,
+              keyword_splat: argument.keyword_splat?,
+              block: argument.block?,
+            )
+          end
+
+        if @block
+          arguments << ::Code::Object::Argument.new(
+            @block.evaluate(**args.merge(object: nil)),
+            block: true,
+          )
+        end
+
+        @name.evaluate(**args.merge(arguments: arguments))
+      end
+    end
+  end
+end

data/lib/code/node/code.rb

@@ -1,18 +1,15 @@
-require "active_support"
-require "active_support/core_ext/object/blank"
-
 class Code
   class Node
-    class Code
+    class Code < Node
       def initialize(statements)
-        statements = [] if statements.blank?
+        statements = [] if statements.to_s.blank?
 
         @statements =
           statements.map { |statement| ::Code::Node::Statement.new(statement) }
       end
 
-      def evaluate(context)
-        @statements.map { |statement| statement.evaluate(context) }.last
+      def evaluate(**args)
+        @statements.map { |statement| statement.evaluate(**args) }.last
       end
     end
   end

data/lib/code/node/defined.rb

@@ -0,0 +1,19 @@
+class Code
+  class Node
+    class Defined < Node
+      def initialize(defined)
+        @name = defined.fetch(:name)
+      end
+
+      def evaluate(**args)
+        ::Code::Object::Boolean.new(args.fetch(:context).key?(name))
+      end
+
+      private
+
+      def name
+        ::Code::Object::String.new(@name.to_s)
+      end
+    end
+  end
+end