jql_ruby 0.1.0

data/lib/jql_ruby/ast/operand.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  module Ast
+    class ValueOperand < Node
+      attr_reader :value
+
+      def initialize(value:, **rest)
+        super(**rest)
+        @value = value
+      end
+
+      def accept(visitor)
+        visitor.visit_value_operand(self)
+      end
+    end
+
+    class FunctionOperand < Node
+      attr_reader :name, :arguments
+
+      def initialize(name:, arguments: [], **rest)
+        super(**rest)
+        @name = name
+        @arguments = arguments
+      end
+
+      def accept(visitor)
+        visitor.visit_function_operand(self)
+      end
+    end
+
+    class ListOperand < Node
+      attr_reader :values
+
+      def initialize(values:, **rest)
+        super(**rest)
+        @values = values
+      end
+
+      def accept(visitor)
+        visitor.visit_list_operand(self)
+      end
+    end
+
+    class KeywordOperand < Node
+      attr_reader :value
+
+      def initialize(value:, **rest)
+        super(**rest)
+        @value = value
+      end
+
+      def accept(visitor)
+        visitor.visit_keyword_operand(self)
+      end
+    end
+  end
+end

data/lib/jql_ruby/ast/operator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  module Ast
+    class Operator < Node
+      attr_reader :value
+
+      TYPES = %i[
+        eq not_eq
+        lt gt lteq gteq
+        like not_like
+        in not_in
+        is is_not
+        was was_not was_in was_not_in
+        changed
+      ].freeze
+
+      def initialize(value:, **rest)
+        super(**rest)
+        @value = value
+      end
+
+      def accept(visitor)
+        visitor.visit_operator(self)
+      end
+    end
+  end
+end

data/lib/jql_ruby/ast/order_by.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  module Ast
+    class OrderBy < Node
+      attr_reader :fields
+
+      def initialize(fields:, **rest)
+        super(**rest)
+        @fields = fields
+      end
+
+      def accept(visitor)
+        visitor.visit_order_by(self)
+      end
+    end
+
+    class SearchSort < Node
+      attr_reader :field, :direction
+
+      def initialize(field:, direction: nil, **rest)
+        super(**rest)
+        @field = field
+        @direction = direction
+      end
+
+      def accept(visitor)
+        visitor.visit_search_sort(self)
+      end
+    end
+  end
+end

data/lib/jql_ruby/ast/predicate.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  module Ast
+    class Predicate < Node
+      attr_reader :operator, :operand
+
+      OPERATORS = %i[after before during on by from to].freeze
+
+      def initialize(operator:, operand:, **rest)
+        super(**rest)
+        @operator = operator
+        @operand = operand
+      end
+
+      def accept(visitor)
+        visitor.visit_predicate(self)
+      end
+    end
+  end
+end

data/lib/jql_ruby/ast/query.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  module Ast
+    class Query < Node
+      attr_reader :where_clause, :order_by
+
+      def initialize(where_clause: nil, order_by: nil, **rest)
+        super(**rest)
+        @where_clause = where_clause
+        @order_by = order_by
+      end
+
+      def accept(visitor)
+        visitor.visit_query(self)
+      end
+    end
+  end
+end

data/lib/jql_ruby/ast/terminal_clause.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  module Ast
+    class TerminalClause < Node
+      attr_reader :field, :operator, :operand, :predicates
+
+      def initialize(field:, operator:, operand: nil, predicates: [], **rest)
+        super(**rest)
+        @field = field
+        @operator = operator
+        @operand = operand
+        @predicates = predicates
+      end
+
+      def accept(visitor)
+        visitor.visit_terminal_clause(self)
+      end
+    end
+  end
+end

data/lib/jql_ruby/ast.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "ast/node"
+require_relative "ast/query"
+require_relative "ast/compound_clause"
+require_relative "ast/not_clause"
+require_relative "ast/terminal_clause"
+require_relative "ast/field"
+require_relative "ast/operator"
+require_relative "ast/operand"
+require_relative "ast/order_by"
+require_relative "ast/predicate"

data/lib/jql_ruby/errors.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  class Error < StandardError; end
+
+  class ParseError < Error
+    attr_reader :position, :line, :column
+
+    def initialize(message, position: nil, line: nil, column: nil)
+      @position = position
+      @line = line
+      @column = column
+
+      parts = [message]
+      parts << "at position #{position}" if position
+      super(parts.join(" "))
+    end
+  end
+
+  class LexerError < ParseError; end
+
+  class AdapterError < Error; end
+  class UnknownFieldError < AdapterError; end
+  class UnknownFunctionError < AdapterError; end
+  class UnsupportedOperatorError < AdapterError; end
+end

data/lib/jql_ruby/lexer.rb

@@ -0,0 +1,245 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  class Lexer
+    KEYWORDS = {
+      "and"     => TokenType::AND,
+      "or"      => TokenType::OR,
+      "not"     => TokenType::NOT,
+      "in"      => TokenType::IN,
+      "is"      => TokenType::IS,
+      "was"     => TokenType::WAS,
+      "changed" => TokenType::CHANGED,
+      "order"   => TokenType::ORDER,
+      "by"      => TokenType::BY,
+      "asc"     => TokenType::ASC,
+      "desc"    => TokenType::DESC,
+      "empty"   => TokenType::EMPTY,
+      "null"    => TokenType::NULL,
+      "after"   => TokenType::AFTER,
+      "before"  => TokenType::BEFORE,
+      "during"  => TokenType::DURING,
+      "on"      => TokenType::ON,
+      "from"    => TokenType::FROM,
+      "to"      => TokenType::TO,
+    }.freeze
+
+    # characters that terminate an unquoted string
+    STRING_TERMINATORS = Set.new([
+      " ", "\t", "\n", "\r",
+      "(", ")", "[", "]", ",", ".",
+      "=", "!", "<", ">", "~",
+      nil,
+    ]).freeze
+
+    def initialize(input)
+      @input = input
+      @pos = 0
+      @tokens = []
+    end
+
+    def tokenize
+      @tokens = []
+      @pos = 0
+
+      while @pos < @input.length
+        skip_whitespace
+        break if @pos >= @input.length
+
+        token = read_next_token
+        @tokens << token if token
+      end
+
+      @tokens << Token.new(type: TokenType::EOF, value: nil, position: @pos)
+      @tokens
+    end
+
+    private
+
+    def current_char
+      @input[@pos]
+    end
+
+    def peek_char
+      @input[@pos + 1]
+    end
+
+    def advance
+      @pos += 1
+    end
+
+    def skip_whitespace
+      advance while @pos < @input.length && @input[@pos].match?(/\s/)
+    end
+
+    def read_next_token
+      start = @pos
+
+      case current_char
+      when "("
+        advance
+        Token.new(type: TokenType::LPAREN, value: "(", position: start)
+      when ")"
+        advance
+        Token.new(type: TokenType::RPAREN, value: ")", position: start)
+      when ","
+        advance
+        Token.new(type: TokenType::COMMA, value: ",", position: start)
+      when "["
+        advance
+        Token.new(type: TokenType::LBRACKET, value: "[", position: start)
+      when "]"
+        advance
+        Token.new(type: TokenType::RBRACKET, value: "]", position: start)
+      when "."
+        advance
+        Token.new(type: TokenType::DOT, value: ".", position: start)
+      when "="
+        advance
+        Token.new(type: TokenType::EQUALS, value: "=", position: start)
+      when "!"
+        advance
+        if current_char == "="
+          advance
+          Token.new(type: TokenType::NOT_EQUALS, value: "!=", position: start)
+        elsif current_char == "~"
+          advance
+          Token.new(type: TokenType::NOT_LIKE, value: "!~", position: start)
+        else
+          Token.new(type: TokenType::BANG, value: "!", position: start)
+        end
+      when "<"
+        advance
+        if current_char == "="
+          advance
+          Token.new(type: TokenType::LTEQ, value: "<=", position: start)
+        else
+          Token.new(type: TokenType::LT, value: "<", position: start)
+        end
+      when ">"
+        advance
+        if current_char == "="
+          advance
+          Token.new(type: TokenType::GTEQ, value: ">=", position: start)
+        else
+          Token.new(type: TokenType::GT, value: ">", position: start)
+        end
+      when "~"
+        advance
+        Token.new(type: TokenType::LIKE, value: "~", position: start)
+      when '"', "'"
+        read_quoted_string(start)
+      when "-"
+        if peek_char&.match?(/\d/)
+          read_number(start)
+        else
+          read_unquoted_string(start)
+        end
+      when /\d/
+        read_number(start)
+      else
+        read_unquoted_string(start)
+      end
+    end
+
+    def read_quoted_string(start)
+      quote = current_char
+      advance
+      value = +""
+
+      while @pos < @input.length && current_char != quote
+        if current_char == "\\"
+          advance
+          case current_char
+          when "\\", quote
+            value << current_char
+          when "n"
+            value << "\n"
+          when "t"
+            value << "\t"
+          when "'"
+            value << "'"
+          when '"'
+            value << '"'
+          when "u"
+            # unicode escape: \uXXXX
+            advance
+            hex = @input[@pos, 4]
+            if hex&.match?(/\A[0-9a-fA-F]{4}\z/)
+              value << hex.to_i(16).chr(Encoding::UTF_8)
+              @pos += 3
+            else
+              value << "u"
+              next
+            end
+          else
+            value << "\\" << (current_char || "")
+          end
+        else
+          value << current_char
+        end
+        advance
+      end
+
+      if @pos >= @input.length
+        raise LexerError.new("unterminated string", position: start)
+      end
+
+      advance
+      Token.new(type: TokenType::QUOTED_STRING, value: value, position: start)
+    end
+
+    def read_number(start)
+      value = +""
+      if current_char == "-"
+        value << "-"
+        advance
+      end
+
+      while @pos < @input.length && current_char.match?(/\d/)
+        value << current_char
+        advance
+      end
+
+      if @pos < @input.length && current_char == "." && peek_char&.match?(/\d/)
+        value << "."
+        advance
+        while @pos < @input.length && current_char.match?(/\d/)
+          value << current_char
+          advance
+        end
+      end
+
+      # if followed by a non-terminating char, this is actually a string (e.g. "3.14a")
+      unless STRING_TERMINATORS.include?(current_char)
+        value << read_remaining_unquoted_string
+        return classify_unquoted(value, start)
+      end
+
+      Token.new(type: TokenType::NUMBER, value: value, position: start)
+    end
+
+    def read_unquoted_string(start)
+      value = read_remaining_unquoted_string
+      classify_unquoted(value, start)
+    end
+
+    def read_remaining_unquoted_string
+      value = +""
+      until STRING_TERMINATORS.include?(current_char)
+        value << current_char
+        advance
+      end
+      value
+    end
+
+    def classify_unquoted(value, start)
+      keyword_type = KEYWORDS[value.downcase]
+      if keyword_type
+        Token.new(type: keyword_type, value: value, position: start)
+      else
+        Token.new(type: TokenType::STRING, value: value, position: start)
+      end
+    end
+  end
+end