code-ruby 0.2.4

data/lib/code/parser/name.rb

@@ -0,0 +1,89 @@
+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(:opening_parenthesis) { str("(") }
+      rule(:closing_parenthesis) { str(")") }
+      rule(:equal) { str("=") }
+      rule(:left_caret) { str("<") }
+      rule(:right_caret) { str(">") }
+      rule(:tilde) { str("~") }
+      rule(:pipe) { str("|") }
+      rule(:ampersand) { str("&") }
+      rule(:asterisk) { str("*") }
+      rule(:slash) { str("/") }
+      rule(:antislash) { str("\\") }
+      rule(:percent) { str("%") }
+      rule(:plus) { str("+") }
+      rule(:minus) { str("-") }
+      rule(:equal) { str("=") }
+
+      rule(:exclamation_point) { str("!") }
+      rule(:question_mark) { str("?") }
+
+      rule(:rescue_keyword) { str("rescue") }
+      rule(:defined_keyword) { str("defined?") }
+      rule(:not_keyword) { str("not") }
+      rule(:or_keyword) { str("or") }
+      rule(:and_keyword) { str("and") }
+      rule(:if_keyword) { str("if") }
+      rule(:else_keyword) { str("else") }
+      rule(:unless_keyword) { str("unless") }
+      rule(:until_keyword) { str("until") }
+      rule(:while_keyword) { str("while") }
+      rule(:end_keyword) { str("end") }
+
+      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
+        opening_parenthesis.absent? >> closing_parenthesis.absent? >>
+          exclamation_point.absent? >> question_mark.absent? >> tilde.absent? >>
+          pipe.absent? >> ampersand.absent? >> asterisk.absent? >>
+          slash.absent? >> antislash.absent? >> percent.absent? >>
+          plus.absent? >> minus.absent? >> equal.absent? >> 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
+        rescue_keyword.absent? >> defined_keyword.absent? >>
+          not_keyword.absent? >> or_keyword.absent? >> and_keyword.absent? >>
+          if_keyword.absent? >> else_keyword.absent? >>
+          unless_keyword.absent? >> until_keyword.absent? >>
+          while_keyword.absent? >> digit.absent? >> end_keyword.absent? >>
+          name_character >> name_character.repeat >> question_mark.maybe >>
+          exclamation_point.maybe
+      end
+
+      rule(:name_rule) { name.as(:name) }
+
+      root(:name_rule)
+    end
+  end
+end

data/lib/code/parser/negation.rb

@@ -0,0 +1,19 @@
+class Code
+  class Parser
+    class Negation < Parslet::Parser
+      rule(:function) { ::Code::Parser::Function.new }
+
+      rule(:exclamation_point) { str("!") }
+      rule(:plus) { str("+") }
+
+      rule(:operator) { exclamation_point | plus }
+
+      rule(:negation) do
+        (operator.as(:operator) >> negation.as(:statement)).as(:negation) |
+          function
+      end
+
+      root(:negation)
+    end
+  end
+end

data/lib/code/parser/not_keyword.rb

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

data/lib/code/parser/nothing.rb

@@ -0,0 +1,17 @@
+class Code
+  class Parser
+    class Nothing < Parslet::Parser
+      rule(:group) { ::Code::Parser::Group.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) | group
+      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/or_keyword.rb

@@ -0,0 +1,29 @@
+class Code
+  class Parser
+    class OrKeyword < Parslet::Parser
+      rule(:not_keyword) { ::Code::Parser::NotKeyword.new }
+
+      rule(:or_keyword) { str("or") }
+      rule(:and_keyword) { str("and") }
+
+      rule(:operator) { or_keyword | and_keyword }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:or_rule) do
+        (
+          not_keyword.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                not_keyword.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:or_keyword) | not_keyword
+      end
+
+      root(:or_rule)
+    end
+  end
+end

data/lib/code/parser/or_operator.rb

@@ -0,0 +1,28 @@
+class Code
+  class Parser
+    class OrOperator < Parslet::Parser
+      rule(:and_operator) { ::Code::Parser::AndOperator.new }
+
+      rule(:pipe) { str("|") }
+
+      rule(:operator) { pipe >> pipe }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:or_operator) do
+        (
+          and_operator.as(:first) >>
+            (
+              whitespace? >> operator.as(:operator) >> whitespace? >>
+                and_operator.as(:statement)
+            ).repeat(1).as(:rest)
+        ).as(:or_operator) | and_operator
+      end
+
+      root(:or_operator)
+    end
+  end
+end

data/lib/code/parser/power.rb

@@ -0,0 +1,25 @@
+class Code
+  class Parser
+    class Power < Parslet::Parser
+      rule(:negation) { ::Code::Parser::Negation.new }
+
+      rule(:asterisk) { str("*") }
+
+      rule(:operator) { asterisk >> asterisk }
+
+      rule(:space) { str(" ") }
+      rule(:newline) { str("\n") }
+      rule(:whitespace) { (space | newline).repeat(1) }
+      rule(:whitespace?) { whitespace.maybe }
+
+      rule(:power) do
+        (
+          negation.as(:left) >> whitespace? >> operator >> whitespace? >>
+            power.as(:right)
+        ).as(:power) | negation
+      end
+
+      root(:power)
+    end
+  end
+end

data/lib/code/parser/range.rb

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

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

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

data/lib/code/parser/string.rb

@@ -0,0 +1,72 @@
+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") }
+      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(:symbol) { colon.ignore >> name }
+
+      rule(:string) do
+        (single_quoted_string | double_quoted_string | symbol).as(:string) |
+          number
+      end
+
+      root(:string)
+    end
+  end
+end

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/parser.rb

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

data/lib/code-ruby.rb

@@ -0,0 +1,11 @@
+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__)
+loader.setup

data/lib/code.rb

@@ -0,0 +1,29 @@
+class Code
+  def initialize(input, io: $stdout, timeout: 10)
+    @input = input
+    @parsed =
+      Timeout.timeout(timeout) { ::Code::Parser::Code.new.parse(@input) }
+    @io = io
+    @timeout = timeout
+  end
+
+  def self.evaluate(input, context = "", io: $stdout, timeout: 10)
+    new(input, io: io, timeout: timeout).evaluate(context)
+  end
+
+  def evaluate(context = "")
+    Timeout.timeout(@timeout) do
+      if context.present?
+        context = ::Code.evaluate(context, timeout: @timeout)
+      else
+        context = ::Code::Object::Dictionnary.new
+      end
+
+      ::Code::Node::Code.new(parsed).evaluate(context: context, io: @io)
+    end
+  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(**args)
+        @code.evaluate(**args)
+      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(**args)
+        @part.evaluate(**args)
+      end
+    end
+  end
+end

data/lib/template/node/template.rb

@@ -0,0 +1,15 @@
+class Template
+  class Node
+    class Template
+      def initialize(parts)
+        @parts = parts.map { |part| ::Template::Node::Part.new(part) }
+      end
+
+      def evaluate(**args)
+        io = args.fetch(:io)
+
+        @parts.each { |part| io.print(part.evaluate(**args)) }
+      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(**args)
+        ::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