code-ruby-parser 0.1.0

data/lib/code/parser/rescue.rb

@@ -0,0 +1,38 @@
+class Code
+  class Parser
+    class Rescue < ::Code::Parser
+      def parse
+        left = parse_subclass(::Code::Parser::Ternary)
+
+        previous_cursor = cursor
+
+        comments_before = parse_comments
+
+        if match(RESCUE_KEYWORD)
+          previous_cursor = cursor
+          comments_after = parse_comments
+          right = parse_subclass(::Code::Parser::Rescue)
+
+          if right
+            {
+              rescue: {
+                left: left,
+                right: right,
+                comments_before: comments_before,
+                comments_after: comments_after
+              }.compact
+            }
+          else
+            @cursor = previous_cursor
+            buffer!
+            { rescue: { left: left, comments_before: comments_before }.compact }
+          end
+        else
+          @cursor = previous_cursor
+          buffer!
+          left
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/shift.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class Shift < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [GREATER + GREATER, LESSER + LESSER],
+          subclass: ::Code::Parser::Addition
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/statement.rb

@@ -0,0 +1,9 @@
+class Code
+  class Parser
+    class Statement < ::Code::Parser
+      def parse
+        parse_subclass(::Code::Parser::Class)
+      end
+    end
+  end
+end

data/lib/code/parser/string.rb

@@ -0,0 +1,61 @@
+class Code
+  class Parser
+    class String < ::Code::Parser
+      def parse
+        if match(SINGLE_QUOTE)
+          parse_string(SINGLE_QUOTE)
+        elsif match(DOUBLE_QUOTE)
+          parse_string(DOUBLE_QUOTE)
+        elsif match(COLON) && !next?(SPECIAL)
+          buffer!
+          consume while !next?(SPECIAL) && !end_of_input?
+          { string: buffer }
+        else
+          parse_subclass(::Code::Parser::Number)
+        end
+      end
+
+      private
+
+      def parse_string(quote)
+        buffer!
+        output = []
+
+        while !next?(quote) && !end_of_input?
+          c = consume
+
+          if c == BACKSLASH
+            match(OPENING_CURLY_BRACKET) || match(quote)
+          elsif c == OPENING_CURLY_BRACKET
+            output << { text: escape_string(buffer![..-2]) } if buffer?
+
+            output << { code: parse_code }
+
+            match(CLOSING_CURLY_BRACKET)
+            buffer!
+          end
+        end
+
+        output << { text: escape_string(buffer) } if buffer?
+
+        match(quote)
+
+        if output.empty?
+          { string: EMPTY_STRING }
+        elsif output.one? && output.first.key?(:text)
+          { string: output.first[:text] }
+        else
+          { string: output }
+        end
+      end
+
+      def escape_string(string)
+        string
+          .gsub(SPECIAL_NEWLINE, SPECIAL_NEWLINE_ESCAPED)
+          .gsub(BACKSLASH + OPENING_CURLY_BRACKET, OPENING_CURLY_BRACKET)
+          .gsub(BACKSLASH + SINGLE_QUOTE, SINGLE_QUOTE)
+          .gsub(BACKSLASH + DOUBLE_QUOTE, DOUBLE_QUOTE)
+      end
+    end
+  end
+end

data/lib/code/parser/ternary.rb

@@ -0,0 +1,73 @@
+class Code
+  class Parser
+    class Ternary < ::Code::Parser
+      def parse
+        left = parse_subclass(::Code::Parser::Range)
+
+        previous_cursor = cursor
+        return left if !match(WHITESPACE) && !(first_comments = parse_comments)
+        first_comments ||= parse_comments
+
+        if match(QUESTION_MARK)
+          second_comments = parse_comments
+
+          middle = parse_subclass(::Code::Parser::Ternary)
+
+          if middle
+            previous_cursor = cursor
+            third_comments = parse_comments
+
+            if match(COLON)
+              fourth_comments = parse_comments
+              right = parse_subclass(::Code::Parser::Ternary)
+
+              if right
+                {
+                  ternary: {
+                    left: left,
+                    middle: middle,
+                    right: right,
+                    first_comments: first_comments,
+                    second_comments: second_comments,
+                    third_comments: third_comments,
+                    fourth_comments: fourth_comments
+                  }.compact
+                }
+              else
+                @cursor = previous_cursor
+                buffer!
+                {
+                  ternary: {
+                    left: left,
+                    middle: middle,
+                    first_comments: first_comments,
+                    second_comments: second_comments
+                  }.compact
+                }
+              end
+            else
+              @cursor = previous_cursor
+              buffer!
+              {
+                ternary: {
+                  left: left,
+                  middle: middle,
+                  first_comments: first_comments,
+                  second_comments: second_comments
+                }.compact
+              }
+            end
+          else
+            @cursor = previous_cursor
+            buffer!
+            left
+          end
+        else
+          @cursor = previous_cursor
+          buffer!
+          left
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/unary_minus.rb

@@ -0,0 +1,23 @@
+class Code
+  class Parser
+    class UnaryMinus < ::Code::Parser
+      def parse
+        if match(MINUS)
+          previous_cursor = cursor
+          comments = parse_comments
+          right = parse_subclass(::Code::Parser::UnaryMinus)
+
+          if right
+            { unary_minus: { right: right, comments: comments }.compact }
+          else
+            @cursor = previous_cursor
+            buffer!
+            parse_subclass(::Code::Parser::Power)
+          end
+        else
+          parse_subclass(::Code::Parser::Power)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/while.rb

@@ -0,0 +1,36 @@
+class Code
+  class Parser
+    class While < ::Code::Parser
+      def parse
+        if operator = match([WHILE_KEYWORD, UNTIL_KEYWORD])
+          previous_cursor = cursor
+
+          comments = parse_comments
+
+          condition = parse_subclass(::Code::Parser::While)
+
+          if condition
+            body = parse_code
+
+            match(END_KEYWORD)
+
+            {
+              while: {
+                operator: operator,
+                comments: comments,
+                condition: condition,
+                body: body
+              }.compact
+            }
+          else
+            @cursor = previous_cursor
+            buffer!
+            parse_subclass(::Code::Parser::If)
+          end
+        else
+          parse_subclass(::Code::Parser::If)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser.rb

@@ -0,0 +1,237 @@
+class Code
+  class Parser
+    attr_accessor :input, :cursor, :buffer
+
+    EMPTY_STRING = ""
+
+    DIGITS = %w[0 1 2 3 4 5 6 7 8 9]
+    NON_ZERO_DIGITS = %w[1 2 3 4 5 6 7 8 9]
+
+    X = "x"
+    O = "o"
+    B = "b"
+
+    SINGLE_QUOTE = "'"
+    DOUBLE_QUOTE = '"'
+    OPENING_CURLY_BRACKET = "{"
+    CLOSING_CURLY_BRACKET = "}"
+    OPENING_SQUARE_BRACKET = "["
+    CLOSING_SQUARE_BRACKET = "]"
+    OPENING_PARENTHESIS = "("
+    CLOSING_PARENTHESIS = ")"
+    DOT = "."
+    BACKSLASH = "\\"
+    COMMA = ","
+    SPACE = " "
+    SLASH = "/"
+    ASTERISK = "*"
+    NEWLINE = "\n"
+    HASH = "#"
+    COLON = ":"
+    EQUAL = "="
+    GREATER = ">"
+    LESSER = "<"
+    AMPERSAND = "&"
+    PIPE = "|"
+    UNDERSCORE = "_"
+    EXCLAMATION_POINT = "!"
+    QUESTION_MARK = "?"
+    MINUS = "-"
+    PLUS = "+"
+    PERCENT = "%"
+    CARET = "^"
+    TILDE = "~"
+
+    EQUALS = [
+      EQUAL,
+      PLUS + EQUAL,
+      MINUS + EQUAL,
+      ASTERISK + EQUAL,
+      SLASH + EQUAL,
+      PERCENT + EQUAL,
+      GREATER + GREATER + EQUAL,
+      LESSER + LESSER + EQUAL,
+      AMPERSAND + EQUAL,
+      PIPE + EQUAL,
+      CARET + EQUAL,
+      PIPE + PIPE + EQUAL,
+      AMPERSAND + AMPERSAND + EQUAL
+    ]
+
+    WHITESPACE = [SPACE, NEWLINE]
+
+    SPECIAL_NEWLINE = "\\n"
+    SPECIAL_NEWLINE_ESCAPED = "\n"
+
+    NOTHING_KEYWORD = "nothing"
+    NULL_KEYWORD = "null"
+    NIL_KEYWORD = "nil"
+    TRUE_KEYWORD = "true"
+    FALSE_KEYWORD = "false"
+    DO_KEYWORD = "do"
+    END_KEYWORD = "end"
+    RESCUE_KEYWORD = "rescue"
+    NOT_KEYWORD = "not"
+    OR_KEYWORD = "or"
+    AND_KEYWORD = "and"
+    IF_KEYWORD = "if"
+    UNLESS_KEYWORD = "unless"
+    ELSE_KEYWORD = "else"
+    ELSIF_KEYWORD = "elsif"
+    ELSUNLESS_KEYWORD = "elsunless"
+    WHILE_KEYWORD = "while"
+    UNTIL_KEYWORD = "until"
+    CLASS_KEYWORD = "class"
+
+    NOTHING_KEYWORDS = [NOTHING_KEYWORD, NULL_KEYWORD, NIL_KEYWORD]
+    BOOLEAN_KEYWORDS = [TRUE_KEYWORD, FALSE_KEYWORD]
+    KEYWORDS =
+      NOTHING_KEYWORDS + BOOLEAN_KEYWORDS +
+        [
+          DO_KEYWORD, END_KEYWORD, RESCUE_KEYWORD, NOT_KEYWORD, OR_KEYWORD,
+          AND_KEYWORD, IF_KEYWORD, UNLESS_KEYWORD, ELSE_KEYWORD, ELSIF_KEYWORD,
+          ELSUNLESS_KEYWORD, WHILE_KEYWORD, UNTIL_KEYWORD, CLASS_KEYWORD
+        ]
+
+    SPECIAL = [
+      SINGLE_QUOTE, DOUBLE_QUOTE, OPENING_CURLY_BRACKET, CLOSING_CURLY_BRACKET,
+      OPENING_SQUARE_BRACKET, CLOSING_SQUARE_BRACKET, BACKSLASH, DOT, COMMA,
+      SPACE, SLASH, ASTERISK, NEWLINE, HASH, COLON, EQUAL, GREATER, LESSER,
+      OPENING_PARENTHESIS, CLOSING_PARENTHESIS, AMPERSAND, PIPE,
+      EXCLAMATION_POINT, QUESTION_MARK, MINUS, PLUS, TILDE
+    ]
+
+    def initialize(
+      input,
+      cursor: 0,
+      buffer: EMPTY_STRING,
+      check_end_of_input: true
+    )
+      @input = input
+      @cursor = cursor
+      @buffer = buffer
+      @check_end_of_input = check_end_of_input
+    end
+
+    def self.parse(input)
+      new(input).parse
+    end
+
+    def parse
+      output = parse_subclass(::Code::Parser::Code)
+
+      if check_end_of_input && cursor != input.size
+        syntax_error("Unexpected end of input")
+      end
+
+      output
+    end
+
+    private
+
+    attr_reader :check_end_of_input
+
+    def syntax_error(message)
+      raise(
+        ::Code::Parser::Error::SyntaxError.new(
+          message,
+          input: input,
+          line: line,
+          column: column,
+          offset_lines: offset_lines,
+          offset_columns: offset_columns
+        )
+      )
+    end
+
+    def line
+      input[0...cursor].count("\n")
+    end
+
+    def column
+      cursor - input.lines[0...line].map(&:size).sum
+    end
+
+    def offset_lines
+      buffer.count("\n")
+    end
+
+    def offset_columns
+      buffer.size + 1
+    end
+
+    def consume(n = 1)
+      if cursor + n <= input.size
+        consumed = input[cursor, n]
+        @buffer += input[cursor, n]
+        @cursor += n
+        consumed
+      else
+        syntax_error("Unexpected end of input")
+      end
+    end
+
+    def add(output)
+      @output << output if output
+      output
+    end
+
+    def next?(expected)
+      if expected.is_a?(Array)
+        expected.any? { |e| input[cursor, e.size] == e }
+      else
+        input[cursor, expected.size] == expected
+      end
+    end
+
+    def next_next?(expected)
+      if expected.is_a?(Array)
+        expected.any? { |e| next_next?(e) }
+      else
+        input[cursor + 1, expected.size] == expected
+      end
+    end
+
+    def match(expected)
+      if expected.is_a?(Array)
+        expected.detect { |e| match(e) }
+      else
+        if input[cursor, expected.size] == expected
+          @buffer += expected
+          @cursor += expected.size
+          expected
+        else
+          false
+        end
+      end
+    end
+
+    def parse_subclass(subclass, **kargs)
+      parser =
+        subclass.new(input, cursor: cursor, check_end_of_input: false, **kargs)
+      output = parser.parse
+      @cursor = parser.cursor
+      output
+    end
+
+    def parse_code
+      parse_subclass(::Code::Parser::Code)
+    end
+
+    def parse_comments(whitespace: WHITESPACE)
+      parse_subclass(::Code::Parser::Comments, whitespace: whitespace)
+    end
+
+    def end_of_input?
+      cursor >= input.size
+    end
+
+    def buffer?
+      buffer != EMPTY_STRING
+    end
+
+    def buffer!
+      buffer.tap { @buffer = EMPTY_STRING }
+    end
+  end
+end

data/lib/code-ruby-parser.rb

@@ -0,0 +1,7 @@
+require "zeitwerk"
+require "forwardable"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/template-ruby-parser.rb")
+loader.ignore("#{__dir__}/code-ruby-parser.rb")
+loader.setup

data/lib/code.rb

@@ -0,0 +1,2 @@
+class Code
+end

data/lib/template/parser.rb

@@ -0,0 +1,32 @@
+class Template
+  class Parser < ::Code::Parser
+    Version = Gem::Version.new("0.1.0")
+
+    def parse
+      parts = []
+
+      while !end_of_input?
+        c = consume
+
+        if c == OPENING_CURLY_BRACKET
+          parts << { text: escape(buffer!) } if buffer?
+          parts << { code: parse_code }
+          match(CLOSING_CURLY_BRACKET)
+          buffer!
+        elsif c == BACKSLASH
+          match(OPENING_CURLY_BRACKET)
+        end
+      end
+
+      parts << { text: escape(buffer!) } if buffer?
+
+      parts
+    end
+
+    private
+
+    def escape(text)
+      text.gsub(BACKSLASH + OPENING_CURLY_BRACKET, OPENING_CURLY_BRACKET)
+    end
+  end
+end

data/lib/template-ruby-parser.rb

@@ -0,0 +1,7 @@
+require "zeitwerk"
+require "forwardable"
+
+loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
+loader.ignore("#{__dir__}/template-ruby-parser.rb")
+loader.ignore("#{__dir__}/code-ruby-parser.rb")
+loader.setup

data/lib/template.rb

@@ -0,0 +1,2 @@
+class Template
+end

data/spec/code/parser/addition_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+RSpec.describe ::Code::Parser do
+  subject { ::Code::Parser.parse(input) }
+
+  ["a + b", "a - b", "(a - b) + c", "a - (b + c)"].each do |input|
+    context input do
+      let!(:input) { input }
+
+      it { expect { subject }.to_not raise_error }
+    end
+  end
+
+  [
+    "a /* cool */ * b",
+    "a + /* cool */ b",
+    "a + b - c /* cool */",
+    "a + b - /* cool */ c"
+  ].each do |input|
+    context input do
+      let!(:input) { input }
+
+      it { expect(subject.to_json).to include("cool") }
+    end
+  end
+end

data/spec/code/parser/and_operator_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+RSpec.describe ::Code::Parser do
+  subject { ::Code::Parser.parse(input) }
+
+  ["a && b", "a && b && c"].each do |input|
+    context input do
+      let!(:input) { input }
+
+      it { expect { subject }.to_not raise_error }
+    end
+  end
+
+  [
+    "a /* cool */ && b",
+    "a && /* cool */ b",
+    "a && b && c /* cool */",
+    "a && b && /* cool */ c"
+  ].each do |input|
+    context input do
+      let!(:input) { input }
+
+      it { expect(subject.to_json).to include("cool") }
+    end
+  end
+end

data/spec/code/parser/bitwise_and_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+RSpec.describe ::Code::Parser do
+  subject { ::Code::Parser.parse(input) }
+
+  ["a & b", "a & b & c"].each do |input|
+    context input do
+      let!(:input) { input }
+
+      it { expect { subject }.to_not raise_error }
+    end
+  end
+
+  [
+    "a /* cool */ & b",
+    "a & /* cool */ b",
+    "a &  b & c /* cool */",
+    "a & b & /* cool */ c"
+  ].each do |input|
+    context input do
+      let!(:input) { input }
+
+      it { expect(subject.to_json).to include("cool") }
+    end
+  end
+end

data/spec/code/parser/bitwise_or_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+RSpec.describe ::Code::Parser do
+  subject { ::Code::Parser.parse(input) }
+
+  ["a | b", "a | b | c"].each do |input|
+    context input do
+      let!(:input) { input }
+
+      it { expect { subject }.to_not raise_error }
+    end
+  end
+
+  [
+    "a /* cool */ | b",
+    "a | /* cool */ b",
+    "a |  b | c /* cool */",
+    "a | b | /* cool */ c"
+  ].each do |input|
+    context input do
+      let!(:input) { input }
+
+      it { expect(subject.to_json).to include("cool") }
+    end
+  end
+end

data/spec/code/parser/boolean_spec.rb

@@ -0,0 +1,13 @@
+require "spec_helper"
+
+RSpec.describe ::Code::Parser do
+  subject { ::Code::Parser.parse(input) }
+
+  %w[true false].each do |input|
+    context input do
+      let!(:input) { input }
+
+      it { expect { subject }.to_not raise_error }
+    end
+  end
+end