jql_ruby 0.1.0

data/lib/jql_ruby/parser.rb

@@ -0,0 +1,576 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  class Parser
+    attr_reader :errors
+
+    def initialize(tokens)
+      @tokens = tokens
+      @pos = 0
+      @errors = []
+    end
+
+    def parse
+      query = parse_query
+      expect(TokenType::EOF)
+      query
+    end
+
+    private
+
+    # query = where? orderBy? EOF
+    def parse_query
+      where_clause = nil
+      order_by = nil
+
+      unless current_type == TokenType::EOF
+        if current_type == TokenType::ORDER
+          order_by = parse_order_by
+        else
+          where_clause = parse_where
+          order_by = parse_order_by if current_type == TokenType::ORDER
+        end
+      end
+
+      Ast::Query.new(where_clause: where_clause, order_by: order_by, position: 0)
+    end
+
+    # where = orClause
+    def parse_where
+      parse_or_clause
+    end
+
+    # orClause = andClause (OR andClause)*
+    def parse_or_clause
+      pos = current_position
+      left = parse_and_clause
+      clauses = [left]
+
+      while current_type == TokenType::OR
+        advance
+        clauses << parse_and_clause
+      end
+
+      return clauses.first if clauses.size == 1
+
+      Ast::OrClause.new(clauses: clauses, position: pos)
+    end
+
+    # andClause = notClause (AND notClause)*
+    def parse_and_clause
+      pos = current_position
+      left = parse_not_clause
+      clauses = [left]
+
+      while current_type == TokenType::AND
+        advance
+        clauses << parse_not_clause
+      end
+
+      return clauses.first if clauses.size == 1
+
+      Ast::AndClause.new(clauses: clauses, position: pos)
+    end
+
+    # notClause = NOT notClause | '!' notClause | subClause | terminalClause
+    def parse_not_clause
+      pos = current_position
+
+      if current_type == TokenType::NOT
+        advance
+        clause = parse_not_clause
+        return Ast::NotClause.new(clause: clause, operator: :not, position: pos)
+      end
+
+      if current_type == TokenType::BANG
+        advance
+        clause = parse_not_clause
+        return Ast::NotClause.new(clause: clause, operator: :bang, position: pos)
+      end
+
+      if current_type == TokenType::LPAREN
+        return parse_sub_clause
+      end
+
+      parse_terminal_clause
+    end
+
+    # subClause = '(' orClause ')'
+    def parse_sub_clause
+      expect(TokenType::LPAREN)
+      clause = parse_or_clause
+      expect(TokenType::RPAREN)
+      clause
+    end
+
+    # terminalClause = field terminalClauseRhs
+    def parse_terminal_clause
+      pos = current_position
+      field = parse_field
+
+      parse_terminal_clause_rhs(field, pos)
+    end
+
+    # terminalClauseRhs dispatches based on operator lookahead
+    def parse_terminal_clause_rhs(field, pos)
+      case current_type
+      when TokenType::EQUALS, TokenType::NOT_EQUALS
+        parse_equals_clause(field, pos)
+      when TokenType::LT, TokenType::GT, TokenType::LTEQ, TokenType::GTEQ
+        parse_comparison_clause(field, pos)
+      when TokenType::LIKE, TokenType::NOT_LIKE
+        parse_like_clause(field, pos)
+      when TokenType::NOT
+        # NOT IN
+        if peek_type == TokenType::IN
+          parse_in_clause(field, pos)
+        else
+          error("unexpected NOT after field")
+        end
+      when TokenType::IN
+        parse_in_clause(field, pos)
+      when TokenType::IS
+        parse_is_clause(field, pos)
+      when TokenType::WAS
+        parse_was_clause(field, pos)
+      when TokenType::CHANGED
+        parse_changed_clause(field, pos)
+      else
+        error("expected operator after field '#{field_name(field)}'")
+      end
+    end
+
+    # equalsClause = ('=' | '!=') (value | function | empty)
+    def parse_equals_clause(field, pos)
+      op_value = current_type == TokenType::EQUALS ? :eq : :not_eq
+      advance
+      operator = Ast::Operator.new(value: op_value, position: pos)
+
+      operand = if current_type == TokenType::EMPTY || current_type == TokenType::NULL
+        parse_keyword_operand
+      else
+        parse_value_or_function
+      end
+
+      Ast::TerminalClause.new(field: field, operator: operator, operand: operand, position: pos)
+    end
+
+    # comparisonClause = ('<' | '>' | '<=' | '>=') (value | function)
+    def parse_comparison_clause(field, pos)
+      op_map = {
+        TokenType::LT => :lt,
+        TokenType::GT => :gt,
+        TokenType::LTEQ => :lteq,
+        TokenType::GTEQ => :gteq,
+      }
+      op_value = op_map[current_type]
+      advance
+      operator = Ast::Operator.new(value: op_value, position: pos)
+      operand = parse_value_or_function
+
+      Ast::TerminalClause.new(field: field, operator: operator, operand: operand, position: pos)
+    end
+
+    # likeClause = ('~' | '!~') (value | function | empty)
+    def parse_like_clause(field, pos)
+      op_value = current_type == TokenType::LIKE ? :like : :not_like
+      advance
+      operator = Ast::Operator.new(value: op_value, position: pos)
+
+      operand = if current_type == TokenType::EMPTY || current_type == TokenType::NULL
+        parse_keyword_operand
+      else
+        parse_value_or_function
+      end
+
+      Ast::TerminalClause.new(field: field, operator: operator, operand: operand, position: pos)
+    end
+
+    # inClause = [NOT] IN (list | function)
+    def parse_in_clause(field, pos)
+      negated = false
+      if current_type == TokenType::NOT
+        negated = true
+        advance
+      end
+
+      expect(TokenType::IN)
+      op_value = negated ? :not_in : :in
+      operator = Ast::Operator.new(value: op_value, position: pos)
+
+      operand = if current_type == TokenType::LPAREN
+        parse_list_operand
+      else
+        parse_function
+      end
+
+      Ast::TerminalClause.new(field: field, operator: operator, operand: operand, position: pos)
+    end
+
+    # isClause = IS [NOT] empty
+    def parse_is_clause(field, pos)
+      advance
+      negated = false
+      if current_type == TokenType::NOT
+        negated = true
+        advance
+      end
+
+      op_value = negated ? :is_not : :is
+      operator = Ast::Operator.new(value: op_value, position: pos)
+      operand = parse_keyword_operand
+
+      Ast::TerminalClause.new(field: field, operator: operator, operand: operand, position: pos)
+    end
+
+    # wasClause / wasInClause
+    def parse_was_clause(field, pos)
+      advance
+
+      negated = false
+      if current_type == TokenType::NOT
+        negated = true
+        advance
+      end
+
+      # WAS [NOT] IN => wasInClause
+      if current_type == TokenType::IN
+        return parse_was_in_clause(field, pos, negated)
+      end
+
+      op_value = negated ? :was_not : :was
+      operator = Ast::Operator.new(value: op_value, position: pos)
+      operand = parse_value_or_function
+      predicates = parse_predicates
+
+      Ast::TerminalClause.new(
+        field: field, operator: operator, operand: operand,
+        predicates: predicates, position: pos
+      )
+    end
+
+    def parse_was_in_clause(field, pos, negated)
+      advance
+      op_value = negated ? :was_not_in : :was_in
+      operator = Ast::Operator.new(value: op_value, position: pos)
+
+      operand = if current_type == TokenType::LPAREN
+        parse_list_operand
+      else
+        parse_function
+      end
+
+      predicates = parse_predicates
+
+      Ast::TerminalClause.new(
+        field: field, operator: operator, operand: operand,
+        predicates: predicates, position: pos
+      )
+    end
+
+    # changedClause = CHANGED changedPredicate*
+    def parse_changed_clause(field, pos)
+      advance
+      operator = Ast::Operator.new(value: :changed, position: pos)
+      predicates = parse_predicates
+
+      Ast::TerminalClause.new(
+        field: field, operator: operator,
+        predicates: predicates, position: pos
+      )
+    end
+
+    PREDICATE_KEYWORDS = Set.new([
+      TokenType::AFTER, TokenType::BEFORE, TokenType::ON,
+      TokenType::DURING, TokenType::BY,
+      TokenType::FROM, TokenType::TO,
+    ]).freeze
+
+    def parse_predicates
+      predicates = []
+      while PREDICATE_KEYWORDS.include?(current_type)
+        predicates << parse_predicate
+      end
+      predicates
+    end
+
+    def parse_predicate
+      pos = current_position
+      op_map = {
+        TokenType::AFTER => :after,
+        TokenType::BEFORE => :before,
+        TokenType::ON => :on,
+        TokenType::DURING => :during,
+        TokenType::BY => :by,
+        TokenType::FROM => :from,
+        TokenType::TO => :to,
+      }
+      op = op_map[current_type]
+      advance
+
+      operand = if current_type == TokenType::LPAREN
+        parse_list_operand
+      else
+        parse_value_or_function
+      end
+
+      Ast::Predicate.new(operator: op, operand: operand, position: pos)
+    end
+
+    # field = string fieldProperty* | number | customField fieldProperty*
+    def parse_field
+      pos = current_position
+
+      case current_type
+      when TokenType::NUMBER
+        name = current_value
+        advance
+        Ast::Field.new(name: name, position: pos)
+      when TokenType::STRING, TokenType::QUOTED_STRING
+        value = current_value
+        advance
+
+        # check for custom field: cf[12345]
+        if value.downcase == "cf" && current_type == TokenType::LBRACKET
+          return parse_custom_field(pos)
+        end
+
+        properties = parse_field_properties
+        Ast::Field.new(name: value, properties: properties, position: pos)
+      else
+        error("expected field name")
+        # return a placeholder to allow parser to continue
+        advance
+        Ast::Field.new(name: "", position: pos)
+      end
+    end
+
+    def parse_custom_field(pos)
+      expect(TokenType::LBRACKET)
+      id_str = current_value
+      expect(TokenType::NUMBER) || expect(TokenType::STRING)
+      expect(TokenType::RBRACKET)
+      properties = parse_field_properties
+      Ast::CustomField.new(id: id_str.to_i, properties: properties, position: pos)
+    end
+
+    def parse_field_properties
+      properties = []
+      while current_type == TokenType::DOT
+        properties << parse_field_property
+      end
+      properties
+    end
+
+    # fieldProperty = '.' propertyArgument+ ('[' argument ']')?
+    def parse_field_property
+      pos = current_position
+      advance
+      keys = []
+
+      while current_type == TokenType::STRING || current_type == TokenType::QUOTED_STRING || current_type == TokenType::NUMBER
+        keys << current_value
+        advance
+        break unless current_type == TokenType::DOT && peek_type != TokenType::LPAREN
+        advance if current_type == TokenType::DOT
+      end
+
+      argument = nil
+      if current_type == TokenType::LBRACKET
+        advance
+        argument = current_value if current_type == TokenType::STRING || current_type == TokenType::QUOTED_STRING || current_type == TokenType::NUMBER
+        advance
+        expect(TokenType::RBRACKET)
+      end
+
+      Ast::FieldProperty.new(keys: keys, argument: argument, position: pos)
+    end
+
+    # value = string | number
+    def parse_value
+      pos = current_position
+      case current_type
+      when TokenType::STRING, TokenType::QUOTED_STRING
+        val = current_value
+        advance
+        Ast::ValueOperand.new(value: val, position: pos)
+      when TokenType::NUMBER
+        val = current_value
+        advance
+        Ast::ValueOperand.new(value: val, position: pos)
+      else
+        error("expected value")
+        advance
+        Ast::ValueOperand.new(value: "", position: pos)
+      end
+    end
+
+    # parse value or function, checking for '(' after a name to distinguish
+    def parse_value_or_function
+      pos = current_position
+      if (current_type == TokenType::STRING || current_type == TokenType::QUOTED_STRING || current_type == TokenType::NUMBER) && peek_type == TokenType::LPAREN
+        return parse_function
+      end
+
+      parse_value
+    end
+
+    # function = functionName '(' argumentList? ')'
+    def parse_function
+      pos = current_position
+      name = current_value
+      advance
+      expect(TokenType::LPAREN)
+
+      arguments = []
+      unless current_type == TokenType::RPAREN
+        arguments << parse_argument
+        while current_type == TokenType::COMMA
+          advance
+          arguments << parse_argument
+        end
+      end
+
+      expect(TokenType::RPAREN)
+      Ast::FunctionOperand.new(name: name, arguments: arguments, position: pos)
+    end
+
+    def parse_argument
+      pos = current_position
+      case current_type
+      when TokenType::STRING, TokenType::QUOTED_STRING, TokenType::NUMBER
+        val = current_value
+        advance
+        Ast::ValueOperand.new(value: val, position: pos)
+      else
+        error("expected function argument")
+        advance
+        Ast::ValueOperand.new(value: "", position: pos)
+      end
+    end
+
+    # list = '(' operand (',' operand)* ')'
+    def parse_list_operand
+      pos = current_position
+      expect(TokenType::LPAREN)
+
+      values = []
+      values << parse_operand
+      while current_type == TokenType::COMMA
+        advance
+        values << parse_operand
+      end
+
+      expect(TokenType::RPAREN)
+      Ast::ListOperand.new(values: values, position: pos)
+    end
+
+    # operand = value | function | list | empty
+    def parse_operand
+      if current_type == TokenType::EMPTY || current_type == TokenType::NULL
+        return parse_keyword_operand
+      end
+
+      if current_type == TokenType::LPAREN
+        return parse_list_operand
+      end
+
+      parse_value_or_function
+    end
+
+    def parse_keyword_operand
+      pos = current_position
+      val = current_type == TokenType::EMPTY ? :empty : :null
+      advance
+      Ast::KeywordOperand.new(value: val, position: pos)
+    end
+
+    # orderBy = ORDER BY searchSort (',' searchSort)*
+    def parse_order_by
+      pos = current_position
+      expect(TokenType::ORDER)
+      expect(TokenType::BY)
+
+      sorts = []
+      sorts << parse_search_sort
+      while current_type == TokenType::COMMA
+        advance
+        sorts << parse_search_sort
+      end
+
+      Ast::OrderBy.new(fields: sorts, position: pos)
+    end
+
+    # searchSort = field (ASC | DESC)?
+    def parse_search_sort
+      pos = current_position
+      field = parse_field
+
+      direction = nil
+      if current_type == TokenType::ASC
+        direction = :asc
+        advance
+      elsif current_type == TokenType::DESC
+        direction = :desc
+        advance
+      end
+
+      Ast::SearchSort.new(field: field, direction: direction, position: pos)
+    end
+
+    # token helpers
+
+    def current_token
+      @tokens[@pos] || Token.new(type: TokenType::EOF, value: nil, position: @pos)
+    end
+
+    def current_type
+      current_token.type
+    end
+
+    def current_value
+      current_token.value
+    end
+
+    def current_position
+      current_token.position || @pos
+    end
+
+    def peek_token
+      @tokens[@pos + 1] || Token.new(type: TokenType::EOF, value: nil, position: @pos)
+    end
+
+    def peek_type
+      peek_token.type
+    end
+
+    def advance
+      @pos += 1
+    end
+
+    def expect(type)
+      if current_type == type
+        token = current_token
+        advance
+        token
+      else
+        error("expected #{type}, got #{current_type} (#{current_value.inspect})")
+        nil
+      end
+    end
+
+    def error(message)
+      err = ParseError.new(message, position: current_position)
+      @errors << err
+      err
+    end
+
+    def field_name(field)
+      case field
+      when Ast::Field then field.name
+      when Ast::CustomField then "cf[#{field.id}]"
+      else ""
+      end
+    end
+  end
+end

data/lib/jql_ruby/result.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  class Result
+    attr_reader :query, :errors
+
+    def initialize(query:, errors: [])
+      @query = query
+      @errors = errors
+    end
+
+    def success?
+      @errors.empty?
+    end
+  end
+end

data/lib/jql_ruby/token.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  Token = Struct.new(:type, :value, :position, keyword_init: true) do
+    def keyword?
+      KEYWORD_TYPES.include?(type)
+    end
+
+    KEYWORD_TYPES = %i[
+      and or not in is was changed
+      order by asc desc
+      empty null
+      after before during on from to
+    ].freeze
+  end
+
+  module TokenType
+    # delimiters
+    LPAREN   = :lparen
+    RPAREN   = :rparen
+    COMMA    = :comma
+    LBRACKET = :lbracket
+    RBRACKET = :rbracket
+    DOT      = :dot
+
+    # operators
+    EQUALS     = :equals
+    NOT_EQUALS = :not_equals
+    LT         = :lt
+    GT         = :gt
+    LTEQ       = :lteq
+    GTEQ       = :gteq
+    LIKE       = :like
+    NOT_LIKE   = :not_like
+    BANG       = :bang
+
+    # keywords
+    AND     = :and
+    OR      = :or
+    NOT     = :not
+    IN      = :in
+    IS      = :is
+    WAS     = :was
+    CHANGED = :changed
+    ORDER   = :order
+    BY      = :by
+    ASC     = :asc
+    DESC    = :desc
+    EMPTY   = :empty
+    NULL    = :null
+    AFTER   = :after
+    BEFORE  = :before
+    DURING  = :during
+    ON      = :on
+    FROM    = :from
+    TO      = :to
+
+    # literals
+    STRING        = :string
+    QUOTED_STRING = :quoted_string
+    NUMBER        = :number
+
+    # special
+    EOF = :eof
+  end
+end

data/lib/jql_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module JqlRuby
+  VERSION = "0.1.0"
+end

data/lib/jql_ruby.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "jql_ruby/version"
+require_relative "jql_ruby/errors"
+require_relative "jql_ruby/token"
+require_relative "jql_ruby/lexer"
+require_relative "jql_ruby/ast"
+require_relative "jql_ruby/parser"
+require_relative "jql_ruby/result"
+require_relative "jql_ruby/adapters"
+
+module JqlRuby
+  def self.parse(input)
+    tokens = Lexer.new(input).tokenize
+    parser = Parser.new(tokens)
+    query = parser.parse
+    Result.new(query: query, errors: parser.errors)
+  end
+end