code-ruby-parser 0.1.7 → 0.2.0

data/lib/code/parser/while.rb

@@ -1,36 +0,0 @@
-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

@@ -1,237 +0,0 @@
-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.rb

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

data/lib/template/parser.rb

@@ -1,32 +0,0 @@
-class Template
-  class Parser < ::Code::Parser
-    Version = Gem::Version.new("0.1.7")
-
-    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.rb

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

data/spec/code/parser/addition_spec.rb

@@ -1,26 +0,0 @@
-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 { subject }
-    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

@@ -1,26 +0,0 @@
-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 { subject }
-    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

@@ -1,26 +0,0 @@
-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 { subject }
-    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

@@ -1,26 +0,0 @@
-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 { subject }
-    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

@@ -1,13 +0,0 @@
-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 { subject }
-    end
-  end
-end

data/spec/code/parser/call_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-
-RSpec.describe ::Code::Parser do
-  subject { ::Code::Parser.parse(input) }
-
-  [
-    "a",
-    "admin?",
-    "update!",
-    "*args",
-    "**kargs",
-    "&block",
-    "update!(user)",
-    "puts(1)",
-    "print(1)",
-    "defined?(a)",
-    "each{}",
-    "each do end",
-    "render(a, *b, **c, &d) { |e, *f, **g, &h| puts(e) }",
-    "&render {}"
-  ].each do |input|
-    context input do
-      let!(:input) { input }
-
-      it { subject }
-    end
-  end
-
-  [
-    "update! /* cool */ { }",
-    "each{/* cool */}",
-    "render(/* cool */ a)",
-    "render(a /* cool */)",
-    "render(a, /* cool */ b)",
-    "render(a, b /* cool */)",
-    "render(/* cool */ a: 1)",
-    "render(a: 1 /* cool */)",
-    "render(a: 1, /* cool */ b: 2)",
-    "render(a: 1, b: 2 /* cool */)",
-    "render { /* cool */ |a, b| }",
-    "render { |/* cool */ a, b| }",
-    "render { |a /* cool */, b| }",
-    "render { |a: 1, /* cool */ b: 2| }",
-    "render { |a: 1, b: 2 /* cool */| }"
-  ].each do |input|
-    context input do
-      let!(:input) { input }
-
-      it { expect(subject.to_json).to include("cool") }
-    end
-  end
-end

data/spec/code/parser/chained_call_spec.rb

@@ -1,33 +0,0 @@
-require "spec_helper"
-
-RSpec.describe ::Code::Parser do
-  subject { ::Code::Parser.parse(input) }
-
-  [
-    "a.b",
-    "a.b.c",
-    "a(1).b.c(2)",
-    "user.first_name",
-    "User.all",
-    "User::Email.first",
-    "User.each do |user| user.update(created_at: Time.now) end"
-  ].each do |input|
-    context input do
-      let!(:input) { input }
-
-      it { subject }
-    end
-  end
-
-  [
-    "a /* cool */ . b",
-    "a . /* cool */ b",
-    "a . # cool\n /* cool */ b"
-  ].each do |input|
-    context input do
-      let!(:input) { input }
-
-      it { expect(subject.to_json).to include("cool") }
-    end
-  end
-end

data/spec/code/parser/class_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-
-RSpec.describe ::Code::Parser do
-  subject { ::Code::Parser.parse(input) }
-
-  [
-    "class A",
-    "class A self.b = 1",
-    "class A < B",
-    "class A end",
-    "class A self.b = 1 end",
-    "class A < B end"
-  ].each do |input|
-    context input do
-      let!(:input) { input }
-
-      it { subject }
-    end
-  end
-
-  [
-    "class /* cool */ A",
-    "class A /* cool */ < B",
-    "class A </* cool */ B"
-  ].each do |input|
-    context input do
-      let!(:input) { input }
-
-      it { expect(subject.to_json).to include("cool") }
-    end
-  end
-end

data/spec/code/parser/code_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-RSpec.describe ::Code::Parser do
-  subject { ::Code::Parser.parse(input) }
-
-  ["nothing", "nothing null nil"].each do |input|
-    context input do
-      let!(:input) { input }
-
-      it { subject }
-    end
-  end
-end

data/spec/code/parser/dictionnary_spec.rb

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

data/spec/code/parser/equal_spec.rb

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

data/spec/code/parser/equality_spec.rb

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