template-ruby 0.1.0 → 0.2.0

data/lib/code/parser/rescue.rb

@@ -0,0 +1,23 @@
+class Code
+  class Parser
+    class Rescue < Parslet::Parser
+      rule(:ternary) { ::Code::Parser::Ternary.new }
+
+      rule(:rescue_keyword) { str("rescue") }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:rescue) do
+        (
+          ternary.as(:left) >> whitespace? >> rescue_keyword >> whitespace? >>
+            ternary.as(:right)
+        ).as(:rescue) | ternary
+      end
+
+      root(:rescue)
+    end
+  end
+end

data/lib/code/parser/shift.rb

@@ -0,0 +1,31 @@
+class Code
+  class Parser
+    class Shift < Parslet::Parser
+      rule(:addition) { ::Code::Parser::Addition.new }
+
+      rule(:right_caret) { str(">") }
+      rule(:left_caret) { str("<") }
+
+      rule(:operator) do
+        (left_caret >> left_caret) | (right_caret >> right_caret)
+      end
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:shift) do
+        (
+          addition.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                addition.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:shift) | addition
+      end
+
+      root(:shift)
+    end
+  end
+end

data/lib/code/parser/statement.rb

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

data/lib/code/parser/string.rb

@@ -2,10 +2,13 @@ class Code
   class Parser
     class String < Parslet::Parser
       rule(:number) { ::Code::Parser::Number.new }
+      rule(:name) { ::Code::Parser::Name.new.name }
 
       rule(:single_quote) { str("'") }
       rule(:double_quote) { str('"') }
       rule(:backslash) { str("\\") }
+      rule(:colon) { str(":") }
+
       rule(:zero) { str("0") }
       rule(:one) { str("1") }
       rule(:two) { str("2") }
@@ -56,8 +59,11 @@ class Code
           double_quote.ignore
       end
 
+      rule(:symbol) { colon.ignore >> name }
+
       rule(:string) do
-        (single_quoted_string | double_quoted_string).as(:string) | number
+        (single_quoted_string | double_quoted_string | symbol).as(:string) |
+          number
       end
 
       root(:string)

data/lib/code/parser/ternary.rb

@@ -0,0 +1,25 @@
+class Code
+  class Parser
+    class Ternary < Parslet::Parser
+      rule(:range) { ::Code::Parser::Range.new }
+
+      rule(:question_mark) { str("?") }
+      rule(:colon) { str(":") }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:ternary) do
+        (
+          range.as(:left) >> whitespace >> question_mark >> whitespace? >>
+            ternary.as(:middle) >>
+            (whitespace? >> colon >> whitespace? >> ternary.as(:right)).maybe
+        ).as(:ternary) | range
+      end
+
+      root(:ternary)
+    end
+  end
+end

data/lib/code/parser/unary_minus.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class UnaryMinus < Parslet::Parser
+      rule(:power) { ::Code::Parser::Power.new }
+
+      rule(:minus) { str("-") }
+
+      rule(:unary_minus) { (minus >> unary_minus).as(:unary_minus) | power }
+
+      root(:unary_minus)
+    end
+  end
+end

data/lib/code/parser/while.rb

@@ -0,0 +1,25 @@
+class Code
+  class Parser
+    class While < Parslet::Parser
+      rule(:if_rule) { ::Code::Parser::If.new }
+      rule(:code) { ::Code::Parser::Code.new }
+
+      rule(:while_keyword) { str("while") }
+      rule(:until_keyword) { str("until") }
+      rule(:end_keyword) { str("end") }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+
+      rule(:while_rule) do
+        (
+          (while_keyword | until_keyword).as(:operator) >> whitespace >>
+            if_rule.as(:statement) >> code.as(:body) >> end_keyword
+        ).as(:while) | if_rule
+      end
+
+      root(:while_rule)
+    end
+  end
+end

data/lib/code.rb

@@ -1,14 +1,12 @@
-require "active_support"
-require "active_support/core_ext/object/blank"
-
 class Code
-  def initialize(input)
+  def initialize(input, io: $stdout)
     @input = input
     @parsed = ::Code::Parser::Code.new.parse(@input)
+    @io = io
   end
 
-  def self.evaluate(input, context = "")
-    new(input).evaluate(context)
+  def self.evaluate(input, context = "", io: $stdout)
+    new(input, io: io).evaluate(context)
   end
 
   def evaluate(context = "")
@@ -18,7 +16,7 @@ class Code
       context = ::Code::Object::Dictionnary.new
     end
 
-    ::Code::Node::Code.new(parsed).evaluate(context)
+    ::Code::Node::Code.new(parsed).evaluate(context: context, io: @io)
   end
 
   private

data/lib/template/node/code_part.rb

@@ -5,8 +5,8 @@ class Template
         @code = ::Code::Node::Code.new(code)
       end
 
-      def evaluate(context)
-        @code.evaluate(context)
+      def evaluate(**args)
+        @code.evaluate(**args)
       end
     end
   end

data/lib/template/node/part.rb

@@ -11,8 +11,8 @@ class Template
         end
       end
 
-      def evaluate(context)
-        @part.evaluate(context)
+      def evaluate(**args)
+        @part.evaluate(**args)
       end
     end
   end

data/lib/template/node/template.rb

@@ -5,8 +5,10 @@ class Template
         @parts = parts.map { |part| ::Template::Node::Part.new(part) }
       end
 
-      def evaluate(context)
-        ::Code::Object::List.new(@parts.map { |part| part.evaluate(context) })
+      def evaluate(**args)
+        io = args.fetch(:io)
+
+        @parts.each { |part| io.print(part.evaluate(**args)) }
       end
     end
   end

data/lib/template/node/text_part.rb

@@ -5,7 +5,7 @@ class Template
         @text = text
       end
 
-      def evaluate(_context)
+      def evaluate(**args)
         ::Code::Object::String.new(@text.to_s)
       end
     end

data/lib/template-ruby.rb

@@ -1,5 +1,9 @@
 require "parslet"
 require "zeitwerk"
+require "bigdecimal"
+require "active_support"
+require "active_support/core_ext/object/blank"
+require "stringio"
 
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
 loader.ignore(__FILE__)

data/lib/template.rb

@@ -1,11 +1,14 @@
 class Template
-  def initialize(input)
+  VERSION = Gem::Version.new("0.2.0")
+
+  def initialize(input, io: StringIO.new)
     @input = input
     @parsed = ::Template::Parser::Template.new.parse(@input)
+    @io = io
   end
 
-  def self.render(input, context = "")
-    new(input).render(context)
+  def self.render(input, context = "", io: StringIO.new)
+    new(input, io: io).render(context)
   end
 
   def render(context = "")
@@ -15,6 +18,8 @@ class Template
       context = ::Code::Object::Dictionnary.new
     end
 
-    ::Template::Node::Template.new(@parsed).evaluate(context).map(&:to_s).join
+    ::Template::Node::Template.new(@parsed).evaluate(context: context, io: @io)
+
+    @io.is_a?(StringIO) ? @io.string : nil
   end
 end

data/spec/call_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+RSpec.describe Code do
+  subject { described_class.evaluate(input).to_s }
+
+  [
+    %w[(1..2).any?(&:even?) true],
+    %w[(1..1).any?(&:even?) false],
+    %w[(3..3).any?(&:even?) false],
+    %w[(2..5).any?(&:even?) true],
+    ["(2..5).any? { |n| n.even? }", "true"],
+    ["(2..5).select { |i| i.even? }.any? { |n| n.even? }", "true"],
+  ].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/error/type_error_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+
+RSpec.describe ::Code::Error::TypeError do
+  describe "Integer" do
+    context "creating an integer with a non-number exponent" do
+      it "raises" do
+        expect { ::Code::Object::Integer.new(1, exponent: "2") }.to raise_error(
+          described_class,
+        )
+      end
+    end
+
+    [
+      '1 / ""',
+      '1 ** ""',
+      '1 % ""',
+      '1 + ""',
+      '1 - ""',
+      '1 << ""',
+      '1 >> ""',
+      '1 & ""',
+      '1 | ""',
+      '1 ^ ""',
+      '1 > ""',
+      '1 >= ""',
+      '1 < ""',
+      '1 <= ""',
+    ].each do |input|
+      context input.inspect do
+        it "raises" do
+          expect { ::Code.evaluate(input) }.to raise_error(described_class)
+        end
+      end
+    end
+  end
+
+  describe "Decimal" do
+    context "creating an integer with a non-number exponent" do
+      it "raises" do
+        expect { ::Code::Object::Decimal.new(1, exponent: "2") }.to raise_error(
+          described_class,
+        )
+      end
+    end
+
+    [
+      '1.0 / ""',
+      '1.0 ** ""',
+      '1.0 * ""',
+      '1.0 % ""',
+      '1.0 + ""',
+      '1.0 - ""',
+      '1.0 > ""',
+      '1.0 >= ""',
+      '1.0 < ""',
+      '1.0 <= ""',
+    ].each do |input|
+      context input.inspect do
+        it "raises" do
+          expect { ::Code.evaluate(input) }.to raise_error(described_class)
+        end
+      end
+    end
+  end
+end

data/spec/code/parser/boolean_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Code::Parser::Boolean do
 
   [
     ["true", { boolean: "true" }],
-    ["false", { boolean: "false" }]
+    ["false", { boolean: "false" }],
   ].each do |(input, expected)|
     context input.inspect do
       let(:input) { input }

data/spec/code/parser/call_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Code::Parser::Call do
   [
     [
       "user.first_name",
-      { call: { left: { name: "user" }, right: { name: "first_name" } } }
+      { call: { left: { name: "user" }, right: [{ name: "first_name" }] } },
     ],
     [
       "3.times",
@@ -16,17 +16,17 @@ RSpec.describe Code::Parser::Call do
             number: {
               base_10: {
                 integer: {
-                  whole: "3"
-                }
-              }
-            }
+                  whole: "3",
+                },
+              },
+            },
           },
-          right: {
-            name: "times"
-          }
-        }
-      }
-    ]
+          right: [{
+            name: "times",
+          }],
+        },
+      },
+    ],
   ].each do |(input, expected)|
     context input.inspect do
       let(:input) { input }
@@ -36,4 +36,33 @@ RSpec.describe Code::Parser::Call do
       end
     end
   end
+
+  [
+    "User.first",
+    "User.first(10)",
+    'User.find_by(name: "Dorian")',
+    "User.update_all(**attributes)",
+    "User.each(&block)",
+    "user.update(*args)",
+    "sort([1, 2, 3], :asc)",
+    "render()",
+    "render(item)",
+    "Renderer.render(item)",
+    "render(item) { 'Hello' }",
+    "render(item) { |item| item * 2 }",
+    "render(item) { |item1, item2| item1 + item2 }",
+    "render(item) do 'Hello' end",
+    "render(item) do |item| item * 2 end",
+    "render(item) do |item1, item2| item1 + item2 end",
+    "(1..2).any?(&:even?)",
+    "(2..5).select { |i| i.even? }.any? { |n| n.even? }",
+  ].each do |input|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect { subject }.to_not raise_error
+      end
+    end
+  end
 end

data/spec/code/parser/dictionnary_spec.rb

@@ -7,17 +7,17 @@ RSpec.describe Code::Parser::Dictionnary do
     [
       '{name: "Dorian"}',
       {
-        dictionnary: [{ key: { name: "name" }, value: [{ string: "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" }] }
-        ]
-      }
+          { key: { string: "b" }, value: [{ boolean: "false" }] },
+        ],
+      },
     ],
     [
       "{ true => 1, false => 2}",
@@ -25,15 +25,15 @@ RSpec.describe Code::Parser::Dictionnary do
         dictionnary: [
           {
             key: [{ boolean: "true" }],
-            value: [{ number: { base_10: { integer: { whole: "1" } } } }]
+            value: [{ number: { base_10: { integer: { whole: "1" } } } }],
           },
           {
             key: [{ boolean: "false" }],
-            value: [{ number: { base_10: { integer: { whole: "2" } } } }]
-          }
-        ]
-      }
-    ]
+            value: [{ number: { base_10: { integer: { whole: "2" } } } }],
+          },
+        ],
+      },
+    ],
   ].each do |(input, expected)|
     context input.inspect do
       let(:input) { input }

data/spec/code/parser/function_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+RSpec.describe Code::Parser::Function do
+  subject { described_class.new.parse(input) }
+
+  [
+    "() => {}",
+    '() => { "Hello" }',
+    "(a) => { }",
+    "(a = 1)=> {}",
+    "(a, b) =>{}",
+    "(a, b = 2, c = b)=>{}",
+    "(a:)=>{}",
+    "(a:, b:)=>{}",
+    "(a, b:, c)=>{}",
+    "(a:, b: 1)=>{}",
+    "(a, b: 1, c)=>{}",
+    "(*args)=>{}",
+    "(*args, **kargs)=>{}",
+    "(&block)=>{}",
+    "(a = b = 1 + 1 b)=>{}",
+    "(a: b = 1 + 1 b)=>{}",
+  ].each do |input|
+    context input.inspect do
+      let(:input) { input }
+
+      it "succeeds" do
+        expect { subject }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/code/parser/list_spec.rb

@@ -9,14 +9,14 @@ RSpec.describe Code::Parser::List do
       {
         list: [
           { code: [{ boolean: "true" }] },
-          { code: [{ boolean: "false" }] }
-        ]
-      }
+          { code: [{ boolean: "false" }] },
+        ],
+      },
     ],
     [
       "[nothing, a]",
-      { list: [{ code: [{ nothing: "nothing" }] }, { code: [{ name: "a" }] }] }
-    ]
+      { list: [{ code: [{ nothing: "nothing" }] }, { code: [{ name: "a" }] }] },
+    ],
   ].each do |(input, expected)|
     context input.inspect do
       let(:input) { input }

data/spec/code/parser/nothing_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Code::Parser::Nothing do
   [
     ["nothing", { nothing: "nothing" }],
     ["null", { nothing: "null" }],
-    ["nil", { nothing: "nil" }]
+    ["nil", { nothing: "nil" }],
   ].each do |(input, expected)|
     context input.inspect do
       let(:input) { input }

data/spec/code/parser/number_spec.rb

@@ -15,11 +15,11 @@ RSpec.describe Code::Parser::Number do
             decimal: {
               sign: "-",
               whole: "1",
-              decimal: "0"
-            }
-          }
-        }
-      }
+              decimal: "0",
+            },
+          },
+        },
+      },
     ],
     [
       "+1.0",
@@ -29,11 +29,11 @@ RSpec.describe Code::Parser::Number do
             decimal: {
               sign: "+",
               whole: "1",
-              decimal: "0"
-            }
-          }
-        }
-      }
+              decimal: "0",
+            },
+          },
+        },
+      },
     ],
     ["0", { number: { base_10: { integer: { whole: "0" } } } }],
     ["+0", { number: { base_10: { integer: { sign: "+", whole: "0" } } } }],
@@ -42,7 +42,7 @@ RSpec.describe Code::Parser::Number do
     ["0o01234567", { number: { base_8: "01234567" } }],
     [
       "0x0123456789aAbBcCdDeEfF",
-      { number: { base_16: "0123456789aAbBcCdDeEfF" } }
+      { number: { base_16: "0123456789aAbBcCdDeEfF" } },
     ],
     [
       "10e20",
@@ -53,13 +53,13 @@ RSpec.describe Code::Parser::Number do
               whole: "10",
               exponent: {
                 integer: {
-                  whole: "20"
-                }
-              }
-            }
-          }
-        }
-      }
+                  whole: "20",
+                },
+              },
+            },
+          },
+        },
+      },
     ],
     [
       "10.34e23.45",
@@ -72,13 +72,13 @@ RSpec.describe Code::Parser::Number do
               exponent: {
                 decimal: {
                   whole: "23",
-                  decimal: "45"
-                }
-              }
-            }
-          }
-        }
-      }
+                  decimal: "45",
+                },
+              },
+            },
+          },
+        },
+      },
     ],
     [
       "+10e-20e1.0",
@@ -95,16 +95,16 @@ RSpec.describe Code::Parser::Number do
                   exponent: {
                     decimal: {
                       whole: "1",
-                      decimal: "0"
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    ]
+                      decimal: "0",
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    ],
   ].each do |(input, expected)|
     context input.inspect do
       let(:input) { input }

data/spec/code/parser/string_spec.rb

@@ -15,8 +15,9 @@ RSpec.describe Code::Parser::String do
     ['"\\uABCG"', { string: "uABCG" }],
     [
       "'\\u0123\\u4567\\u89aA\\ubBcC\\UdDeE\\ufFfF'",
-      { string: "\\u0123\\u4567\\u89aA\\ubBcC\\UdDeE\\ufFfF" }
-    ]
+      { string: "\\u0123\\u4567\\u89aA\\ubBcC\\UdDeE\\ufFfF" },
+    ],
+    [":asc", { string: "asc" }],
   ].each do |(input, expected)|
     context input.inspect do
       let(:input) { input }