rsql_parser 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 716f47ee34f3a7940273ea8e80c7455b9ae13be5c93012f149583768ae00c762
+  data.tar.gz: bb977f10808ea4b793a702c0e3cd6298de2c700979fe41b08e52577f541a3dcc
+SHA512:
+  metadata.gz: c184118105113d2fe6dbf257498a9ea834b6bb07dee3739e42b3bb25a570e74803a8c462a492ae398fb962c30d6ac173645b333b285098c33e245b0afb45c403
+  data.tar.gz: 578825e47740a7e4d731be0f28cc6cfc57cdd0cb18bfacd4f64ec0c29dd464574d8b79f80d027e0c08d9a1d8b24608f4788ae9bc804f1b856313633066e8ed2f

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## [1.0.0] - 2026-03-27
+
+* First version
+

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ruby_odata.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2010 - 2020 Blue Spire Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,289 @@
+# rsql_parser
+
+A Ruby parser library for **RSQL** and **FIQL** query expressions. Parses query strings into structured Ruby hashes that can be used to build database queries, filter collections, or power search APIs.
+
+- **FIQL** (Feed Item Query Language): [RFC draft](https://datatracker.ietf.org/doc/html/draft-nottingham-atompub-fiql-00)
+- **RSQL**: a superset of FIQL with additional convenience syntax
+
+## Installation
+
+Add to your `Gemfile`:
+
+```ruby
+gem 'rsql_parser'
+```
+
+Or install directly:
+
+```bash
+gem install rsql_parser
+```
+
+## Quick Start
+
+```ruby
+require 'rsql_parser'
+
+result = RsqlParser.parse('name=="Kill Bill";year=gt=2003')
+# => {
+#      type: :COMBINATION,
+#      operator: :AND,
+#      lhs: { type: :CONSTRAINT, selector: "name", comparison: "==", argument: "Kill Bill" },
+#      rhs: { type: :CONSTRAINT, selector: "year", comparison: "=gt=", argument: "2003" }
+#    }
+```
+
+## Return Value Structure
+
+Every call to `RsqlParser.parse` returns a **node hash**. There are two node types:
+
+### `:CONSTRAINT` — a single condition
+
+| Key          | Type     | Description                        |
+|--------------|----------|------------------------------------|
+| `:type`      | Symbol   | Always `:CONSTRAINT`               |
+| `:selector`  | String   | The field/attribute name           |
+| `:comparison`| String   | The comparison operator            |
+| `:argument`  | String or Array | The value(s) to compare against |
+
+```ruby
+RsqlParser.parse('year==2003')
+# => { type: :CONSTRAINT, selector: "year", comparison: "==", argument: "2003" }
+```
+
+### `:COMBINATION` — two conditions joined by a logical operator
+
+| Key         | Type   | Description                         |
+|-------------|--------|-------------------------------------|
+| `:type`     | Symbol | Always `:COMBINATION`               |
+| `:operator` | Symbol | `:AND` or `:OR`                     |
+| `:lhs`      | Hash   | Left-hand side node                 |
+| `:rhs`      | Hash   | Right-hand side node                |
+
+```ruby
+RsqlParser.parse('a==1;b==2')
+# => {
+#      type: :COMBINATION,
+#      operator: :AND,
+#      lhs: { type: :CONSTRAINT, selector: "a", comparison: "==", argument: "1" },
+#      rhs: { type: :CONSTRAINT, selector: "b", comparison: "==", argument: "2" }
+#    }
+```
+
+## Syntax Reference
+
+### Selectors
+
+A selector is a field name consisting of unreserved characters: letters, digits, and `-._~:`.
+
+```
+name
+created_at
+user.email
+http://schema.org/name
+```
+
+### Comparison Operators
+
+#### FIQL / RSQL operators
+
+| Operator  | Meaning                  | Example              |
+|-----------|--------------------------|----------------------|
+| `==`      | Equal                    | `name==Alice`        |
+| `!=`      | Not equal                | `status!=inactive`   |
+| `=gt=`    | Greater than             | `year=gt=2000`       |
+| `=gte=`   | Greater than or equal    | `year=gte=2000`      |
+| `=lt=`    | Less than                | `price=lt=100`       |
+| `=lte=`   | Less than or equal       | `price=lte=100`      |
+| `=in=`    | In a set                 | `status=in=(a,b,c)`  |
+| `=out=`   | Not in a set             | `status=out=(x,y)`   |
+| `=custom=`| Any custom operator      | `field=op=value`     |
+
+Custom FIQL operators follow the pattern `=[a-z!]*=` — any lowercase letters or `!` between two `=` signs.
+
+#### Simplified comparison operators
+
+| Operator | Meaning                  | Example       |
+|----------|--------------------------|---------------|
+| `>`      | Greater than             | `year>2000`   |
+| `>=`     | Greater than or equal    | `year>=2000`  |
+| `<`      | Less than                | `price<100`   |
+| `<=`     | Less than or equal       | `price<=100`  |
+
+### Logical Operators
+
+Conditions can be combined with AND and OR. AND has higher precedence than OR.
+
+#### Symbol syntax
+
+| Symbol | Operator | Example           |
+|--------|----------|-------------------|
+| `;`    | AND      | `a==1;b==2`       |
+| `,`    | OR       | `a==1,b==2`       |
+
+#### Keyword syntax (case-insensitive)
+
+| Keyword       | Operator | Example              |
+|---------------|----------|----------------------|
+| `and` / `AND` | AND      | `a==1 and b==2`      |
+| `or` / `OR`   | OR       | `a==1 or b==2`       |
+
+Symbol and keyword syntax can be mixed freely. Whitespace around keywords is ignored.
+
+### Arguments
+
+#### Unquoted values
+
+Sequences of unreserved characters (`[a-zA-Z0-9\-._~:]`):
+
+```
+year==2003
+status==active
+date==2018-09-01T12:14:28Z
+```
+
+#### Single-quoted strings
+
+Allows spaces, semicolons, commas, and double quotes inside the value. Use `\'` to include a literal single quote:
+
+```
+name=='Kill;"Bill"'
+tag=='it\'s fine'
+```
+
+#### Double-quoted strings
+
+Allows spaces, semicolons, commas, and single quotes inside the value. Use `\"` to include a literal double quote:
+
+```
+name=="Kill Bill"
+title=="She said \"hello\""
+```
+
+#### Array arguments
+
+A parenthesised, comma-separated list. Used with operators like `=in=`:
+
+```
+status=in=(active,pending,review)
+name=in=("Kill Bill","Pulp Fiction")
+```
+
+The `:argument` key will contain a Ruby `Array` instead of a `String`:
+
+```ruby
+RsqlParser.parse('genre=in=(sci-fi,action)')
+# => { type: :CONSTRAINT, selector: "genre", comparison: "=in=",
+#      argument: ["sci-fi", "action"] }
+```
+
+### Grouping
+
+Parentheses override the default AND-before-OR precedence:
+
+```ruby
+# Without grouping: (a AND b) OR c
+RsqlParser.parse('a==1;b==2,c==3')
+
+# With grouping: a AND (b OR c)
+RsqlParser.parse('a==1;(b==2,c==3)')
+```
+
+## Examples
+
+```ruby
+require 'rsql_parser'
+
+# Single constraint
+RsqlParser.parse('year==2003')
+# => { type: :CONSTRAINT, selector: "year", comparison: "==", argument: "2003" }
+
+# Simplified comparison syntax
+RsqlParser.parse('price<=99')
+# => { type: :CONSTRAINT, selector: "price", comparison: "<=", argument: "99" }
+
+# AND combination (semicolon and keyword are equivalent)
+RsqlParser.parse('name=="Kill Bill" and year=gt=2003')
+RsqlParser.parse('name=="Kill Bill";year=gt=2003')
+
+# OR combination
+RsqlParser.parse('status==active or status==pending')
+RsqlParser.parse('status==active,status==pending')
+
+# Array argument
+RsqlParser.parse("genre=in=(sci-fi,action);year>2000")
+# => {
+#      type: :COMBINATION,
+#      operator: :AND,
+#      lhs: { type: :CONSTRAINT, selector: "genre", comparison: "=in=",
+#             argument: ["sci-fi", "action"] },
+#      rhs: { type: :CONSTRAINT, selector: "year", comparison: ">",
+#             argument: "2000" }
+#    }
+
+# Chained AND — right-associative tree
+RsqlParser.parse('a=eq=b;c=ne=d;e=gt=f')
+# => {
+#      type: :COMBINATION, operator: :AND,
+#      lhs: { type: :CONSTRAINT, selector: "a", comparison: "=eq=", argument: "b" },
+#      rhs: {
+#        type: :COMBINATION, operator: :AND,
+#        lhs: { type: :CONSTRAINT, selector: "c", comparison: "=ne=", argument: "d" },
+#        rhs: { type: :CONSTRAINT, selector: "e", comparison: "=gt=", argument: "f" }
+#      }
+#    }
+
+# Grouping to change precedence
+RsqlParser.parse('a=eq=b;(c=ne=d,e=gt=f)')
+# => {
+#      type: :COMBINATION, operator: :AND,
+#      lhs: { type: :CONSTRAINT, selector: "a", comparison: "=eq=", argument: "b" },
+#      rhs: {
+#        type: :COMBINATION, operator: :OR,
+#        lhs: { type: :CONSTRAINT, selector: "c", comparison: "=ne=", argument: "d" },
+#        rhs: { type: :CONSTRAINT, selector: "e", comparison: "=gt=", argument: "f" }
+#      }
+#    }
+
+# Escaped quotes inside strings
+RsqlParser.parse('title=="She said \"hello\""')
+# => { type: :CONSTRAINT, selector: "title", comparison: "==",
+#      argument: 'She said "hello"' }
+```
+
+## Operator Precedence
+
+From highest to lowest:
+
+1. Parentheses `( )`
+2. AND — `;` or `and`
+3. OR — `,` or `or`
+
+## Requirements
+
+- Ruby >= 2.7.0
+- [racc](https://github.com/ruby/racc) ~> 1.8
+
+## Development
+
+```bash
+# Run tests
+rake test
+
+# Regenerate the lexer after editing lib/rsql_parser/lexer.rex
+ruby -roedipus_lex -e "
+  lex = OedipusLex.new
+  lex.parse_file('lib/rsql_parser/lexer.rex')
+  File.write('lib/rsql_parser/lexer.rex.rb', lex.generate)
+"
+```
+
+Development dependencies: `oedipus_lex ~> 2.6`, `minitest ~> 5.21`, `rake ~> 13.0`.
+
+## Contributing
+
+Open a pull request with your changes and a corresponding test.
+
+## License
+
+MIT © [Ekzo](https://github.com/ekzo-dev)

data/Rakefile

@@ -0,0 +1,56 @@
+require "rake/testtask"
+
+GEMSPEC = Gem::Specification.load("rsql_ruby.gemspec")
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb", "test/**/test_*.rb"]
+  t.verbose = false
+end
+
+LEX_INPUT  = "lib/rsql_parser/lexer.rex"
+LEX_OUTPUT = "lib/rsql_parser/lexer.rex.rb"
+
+file LEX_OUTPUT => LEX_INPUT do
+  ruby <<~RUBY
+    -roedipus_lex -e "
+      lex = OedipusLex.new
+      lex.parse_file('#{LEX_INPUT}')
+      File.write('#{LEX_OUTPUT}', lex.generate)
+    "
+  RUBY
+  puts "Generated #{LEX_OUTPUT}"
+end
+
+desc "Regenerate #{LEX_OUTPUT} from #{LEX_INPUT}"
+task :lexer => LEX_OUTPUT
+
+PARSER_INPUT  = "lib/rsql_parser/parser.y"
+PARSER_OUTPUT = "lib/rsql_parser/parser.rb"
+
+file PARSER_OUTPUT => PARSER_INPUT do
+  sh "racc #{PARSER_INPUT} -o #{PARSER_OUTPUT}"
+  puts "Generated #{PARSER_OUTPUT}"
+end
+
+desc "Regenerate #{PARSER_OUTPUT} from #{PARSER_INPUT}"
+task :parser => PARSER_OUTPUT
+
+desc "Regenerate lexer and parser from their source files"
+task :generate => [:lexer, :parser]
+
+GEM_FILE = "pkg/#{GEMSPEC.name}-#{GEMSPEC.version}.gem"
+
+directory "pkg"
+
+desc "Build #{GEMSPEC.name}-#{GEMSPEC.version}.gem into pkg/"
+task :build => "pkg" do
+  sh "gem build rsql_ruby.gemspec --output #{GEM_FILE}"
+end
+
+desc "Build and push #{GEMSPEC.name}-#{GEMSPEC.version}.gem to RubyGems"
+task :release => [:test, :build] do
+  sh "gem push #{GEM_FILE}"
+end
+
+task default: :test

data/lib/rsql_parser/lexer.rex

@@ -0,0 +1,54 @@
+module RsqlParser
+
+class Parser < Racc::Parser
+
+macro
+  BLANK         /(\ |\t)+/
+  UNRESERVED    /[a-zA-Z0-9\-._~:]+/
+  COMPARATOR    />=|<=|!=|>|<|(=([a-z]|!)*=)/
+
+  # Operator query
+  AND_OPERATOR  /;/
+  OR_COMMA_OPERATOR   /,/
+
+  # String Parser
+  SINGLE_QUOTE /'/
+  DOUBLE_QUOTE /"/
+  SINGLE_QUOTED_STRING /((\\')|[^'])+/
+  DOUBLE_QUOTED_STRING /((\\")|[^"])+/
+
+  # Brakets
+  OPENING_BRACKET /\(/
+  CLOSING_BRACKET /\)/
+  ESCAPE /\\/
+
+rule
+                  /#{BLANK}/ { }
+                  /#{ESCAPE}/ { [:ESCAPE, text] }
+                  /and(?![a-zA-Z0-9\-._~:])/i { [:AND_OPERATOR, text] }
+                  /or(?![a-zA-Z0-9\-._~:])/i { [:OR_COMMA_OPERATOR, text] }
+                  /#{UNRESERVED}/ { [:UNRESERVED, text] }
+
+                  /#{COMPARATOR}/ { [:COMPARATOR, text] }
+
+                  /#{OR_COMMA_OPERATOR}/ { [:OR_COMMA_OPERATOR, text] }
+                  /#{AND_OPERATOR}/ { [:AND_OPERATOR, text] }
+
+                  /#{OPENING_BRACKET}/ { [:OPENING_BRACKET, text] }
+                  /#{CLOSING_BRACKET}/ { [:CLOSING_BRACKET, text] }
+
+                  /#{SINGLE_QUOTE}/ { self.state = :SINGLE_QUOTE; [:SINGLE_QUOTE, text] }
+  :SINGLE_QUOTE   /#{SINGLE_QUOTED_STRING}/ { [:SINGLE_QUOTED_STRING, text.gsub("\\'", "'")] }
+  :SINGLE_QUOTE   /#{SINGLE_QUOTE}/ { self.state = nil; [:SINGLE_QUOTE, text] }
+
+                  /#{DOUBLE_QUOTE}/ { self.state = :DOUBLE_QUOTE; [:DOUBLE_QUOTE, text] }
+  :DOUBLE_QUOTE   /#{DOUBLE_QUOTED_STRING}/ { [:DOUBLE_QUOTED_STRING, text.gsub("\\\"", '"')] }
+  :DOUBLE_QUOTE   /#{DOUBLE_QUOTE}/ { self.state = nil; [:DOUBLE_QUOTE, text] }
+
+option
+
+inner
+
+end
+
+end

data/lib/rsql_parser/lexer.rex.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+# encoding: UTF-8
+#--
+# This file is automatically generated. Do not modify it.
+# Generated by: oedipus_lex version 2.6.3.
+# Source: lib/rsql_parser/lexer.rex
+#++
+
+module RsqlParser
+
+
+##
+# The generated lexer Parser < Racc::Parser
+
+class Parser < Racc::Parser
+  require 'strscan'
+
+  # :stopdoc:
+  BLANK                = /(\ |\t)+/
+  UNRESERVED           = /[a-zA-Z0-9\-._~:]+/
+  COMPARATOR           = />=|<=|!=|>|<|(=([a-z]|!)*=)/
+  AND_OPERATOR         = /;/
+  OR_COMMA_OPERATOR    = /,/
+  SINGLE_QUOTE         = /'/
+  DOUBLE_QUOTE         = /"/
+  SINGLE_QUOTED_STRING = /((\\')|[^'])+/
+  DOUBLE_QUOTED_STRING = /((\\")|[^"])+/
+  OPENING_BRACKET      = /\(/
+  CLOSING_BRACKET      = /\)/
+  ESCAPE               = /\\/
+  # :startdoc:
+  # :stopdoc:
+  class LexerError < StandardError ; end
+  class ScanError < LexerError ; end
+  # :startdoc:
+
+  ##
+  # The file name / path
+
+  attr_accessor :filename
+
+  ##
+  # The StringScanner for this lexer.
+
+  attr_accessor :ss
+
+  ##
+  # The current lexical state.
+
+  attr_accessor :state
+
+  alias :match :ss
+
+  ##
+  # The match groups for the current scan.
+
+  def matches
+    m = (1..9).map { |i| ss[i] }
+    m.pop until m[-1] or m.empty?
+    m
+  end
+
+  ##
+  # Yields on the current action.
+
+  def action
+    yield
+  end
+
+  ##
+  # The current scanner class. Must be overridden in subclasses.
+
+  def scanner_class
+    StringScanner
+  end unless instance_methods(false).map(&:to_s).include?("scanner_class")
+
+  ##
+  # Parse the given string.
+
+  def parse str
+    self.ss     = scanner_class.new str
+    self.state  ||= nil
+
+    do_parse
+  end
+
+  ##
+  # Read in and parse the file at +path+.
+
+  def parse_file path
+    self.filename = path
+    open path do |f|
+      parse f.read
+    end
+  end
+
+  ##
+  # The current location in the parse.
+
+  def location
+    [
+      (filename || "<input>"),
+    ].compact.join(":")
+  end
+
+  ##
+  # Lex the next token.
+
+  def next_token
+
+    token = nil
+
+    until ss.eos? or token do
+      token =
+        case state
+        when nil then
+          case
+          when ss.skip(/#{BLANK}/) then
+            action { }
+          when text = ss.scan(/#{ESCAPE}/) then
+            action { [:ESCAPE, text] }
+          when text = ss.scan(/and(?![a-zA-Z0-9\-._~:])/i) then
+            action { [:AND_OPERATOR, text] }
+          when text = ss.scan(/or(?![a-zA-Z0-9\-._~:])/i) then
+            action { [:OR_COMMA_OPERATOR, text] }
+          when text = ss.scan(/#{UNRESERVED}/) then
+            action { [:UNRESERVED, text] }
+          when text = ss.scan(/#{COMPARATOR}/) then
+            action { [:COMPARATOR, text] }
+          when text = ss.scan(/#{OR_COMMA_OPERATOR}/) then
+            action { [:OR_COMMA_OPERATOR, text] }
+          when text = ss.scan(/#{AND_OPERATOR}/) then
+            action { [:AND_OPERATOR, text] }
+          when text = ss.scan(/#{OPENING_BRACKET}/) then
+            action { [:OPENING_BRACKET, text] }
+          when text = ss.scan(/#{CLOSING_BRACKET}/) then
+            action { [:CLOSING_BRACKET, text] }
+          when text = ss.scan(/#{SINGLE_QUOTE}/) then
+            action { self.state = :SINGLE_QUOTE; [:SINGLE_QUOTE, text] }
+          when text = ss.scan(/#{DOUBLE_QUOTE}/) then
+            action { self.state = :DOUBLE_QUOTE; [:DOUBLE_QUOTE, text] }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        when :SINGLE_QUOTE then
+          case
+          when text = ss.scan(/#{SINGLE_QUOTED_STRING}/) then
+            action { [:SINGLE_QUOTED_STRING, text.gsub("\\'", "'")] }
+          when text = ss.scan(/#{SINGLE_QUOTE}/) then
+            action { self.state = nil; [:SINGLE_QUOTE, text] }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        when :DOUBLE_QUOTE then
+          case
+          when text = ss.scan(/#{DOUBLE_QUOTED_STRING}/) then
+            action { [:DOUBLE_QUOTED_STRING, text.gsub("\\\"", '"')] }
+          when text = ss.scan(/#{DOUBLE_QUOTE}/) then
+            action { self.state = nil; [:DOUBLE_QUOTE, text] }
+          else
+            text = ss.string[ss.pos .. -1]
+            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
+          end
+        else
+          raise ScanError, "undefined state at #{location}: '#{state}'"
+        end # token = case state
+
+      next unless token # allow functions to trigger redo w/ nil
+    end # while
+
+    raise LexerError, "bad lexical result at #{location}: #{token.inspect}" unless
+      token.nil? || (Array === token && token.size >= 2)
+
+    # auto-switch state
+    self.state = token.last if token && token.first == :state
+
+    token
+  end # def next_token
+end # class
+
+  end

data/lib/rsql_parser/parser.rb

@@ -0,0 +1,254 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.8.1
+# from Racc grammar file "parser.y".
+#
+
+require 'racc/parser.rb'
+
+  # Generated by racc
+  require_relative 'lexer.rex'
+
+module RsqlParser
+  class Parser < Racc::Parser
+
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 44)
+
+def create_logical_operator(operator, lhs, rhs)
+  {
+    type: :COMBINATION,
+    operator: operator,
+    lhs: lhs,
+    rhs: rhs
+  }
+end
+
+def create_constraint(selector, comparison, argument)
+  {
+    type: :CONSTRAINT,
+    selector: selector,
+    comparison: comparison,
+    argument: argument
+  }
+end
+
+...end parser.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    19,     8,    20,    21,     9,    22,    25,    20,    21,    30,
+    22,    20,    21,    29,    22,     6,     6,     7,     7,     6,
+     6,     7,     7,    10,    11,    13,    23,    27,    28,    31,
+    32 ]
+
+racc_action_check = [
+    11,     1,    11,    11,     3,    11,    19,    19,    19,    24,
+    19,    30,    30,    24,    30,     0,     6,     0,     6,     9,
+    10,     9,    10,     4,     5,     8,    12,    21,    22,    27,
+    28 ]
+
+racc_action_pointer = [
+     8,     1,   nil,     0,    18,    18,     9,   nil,    25,    12,
+    13,    -7,    18,   nil,   nil,   nil,   nil,   nil,   nil,    -2,
+   nil,    16,    15,   nil,     5,   nil,   nil,    19,    18,   nil,
+     2,   nil,   nil,   nil ]
+
+racc_action_default = [
+   -19,   -19,    -1,    -3,    -5,    -7,   -19,    -9,   -19,   -19,
+   -19,   -19,   -19,    34,    -2,    -4,    -6,   -10,   -11,   -19,
+   -16,   -19,   -19,    -8,   -19,   -13,   -14,   -19,   -19,   -12,
+   -19,   -17,   -18,   -15 ]
+
+racc_goto_table = [
+    18,     2,     1,    15,    16,    17,    24,    12,    26,   nil,
+    14,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    33 ]
+
+racc_goto_check = [
+     8,     2,     1,     3,     6,     7,     9,     2,     8,   nil,
+     2,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,     8 ]
+
+racc_goto_pointer = [
+   nil,     2,     1,    -7,   nil,   nil,    -7,    -6,   -11,   -13 ]
+
+racc_goto_default = [
+   nil,   nil,   nil,     3,     4,     5,   nil,   nil,   nil,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 15, :_reduce_none,
+  3, 16, :_reduce_2,
+  1, 16, :_reduce_none,
+  3, 17, :_reduce_4,
+  1, 17, :_reduce_none,
+  3, 18, :_reduce_6,
+  1, 18, :_reduce_none,
+  3, 18, :_reduce_8,
+  1, 19, :_reduce_none,
+  1, 20, :_reduce_none,
+  1, 20, :_reduce_none,
+  3, 21, :_reduce_12,
+  2, 21, :_reduce_13,
+  1, 23, :_reduce_14,
+  3, 23, :_reduce_15,
+  1, 22, :_reduce_none,
+  3, 22, :_reduce_17,
+  3, 22, :_reduce_18 ]
+
+racc_reduce_n = 19
+
+racc_shift_n = 34
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  ";" => 2,
+  "," => 3,
+  :OR_COMMA_OPERATOR => 4,
+  :AND_OPERATOR => 5,
+  :COMPARATOR => 6,
+  :OPENING_BRACKET => 7,
+  :CLOSING_BRACKET => 8,
+  :UNRESERVED => 9,
+  :SINGLE_QUOTE => 10,
+  :SINGLE_QUOTED_STRING => 11,
+  :DOUBLE_QUOTE => 12,
+  :DOUBLE_QUOTED_STRING => 13 }
+
+racc_nt_base = 14
+
+racc_use_result_var = false
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+Ractor.make_shareable(Racc_arg) if defined?(Ractor)
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "\";\"",
+  "\",\"",
+  "OR_COMMA_OPERATOR",
+  "AND_OPERATOR",
+  "COMPARATOR",
+  "OPENING_BRACKET",
+  "CLOSING_BRACKET",
+  "UNRESERVED",
+  "SINGLE_QUOTE",
+  "SINGLE_QUOTED_STRING",
+  "DOUBLE_QUOTE",
+  "DOUBLE_QUOTED_STRING",
+  "$start",
+  "target",
+  "disjunction",
+  "conjuction",
+  "constraint",
+  "selector",
+  "argument",
+  "array",
+  "value",
+  "contents" ]
+Ractor.make_shareable(Racc_token_to_s_table) if defined?(Ractor)
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+module_eval(<<'.,.,', 'parser.y', 12)
+  def _reduce_2(val, _values)
+     create_logical_operator(:OR, val[0], val[2])
+  end
+.,.,
+
+# reduce 3 omitted
+
+module_eval(<<'.,.,', 'parser.y', 15)
+  def _reduce_4(val, _values)
+     create_logical_operator(:AND, val[0], val[2])
+  end
+.,.,
+
+# reduce 5 omitted
+
+module_eval(<<'.,.,', 'parser.y', 18)
+  def _reduce_6(val, _values)
+     create_constraint(val[0], val[1], val[2])
+  end
+.,.,
+
+# reduce 7 omitted
+
+module_eval(<<'.,.,', 'parser.y', 20)
+  def _reduce_8(val, _values)
+     val[1]
+  end
+.,.,
+
+# reduce 9 omitted
+
+# reduce 10 omitted
+
+# reduce 11 omitted
+
+module_eval(<<'.,.,', 'parser.y', 27)
+  def _reduce_12(val, _values)
+     val[1]
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 28)
+  def _reduce_13(val, _values)
+     []
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 30)
+  def _reduce_14(val, _values)
+     [val[0]]
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 31)
+  def _reduce_15(val, _values)
+     val[0].push(val[2]); val[0]
+  end
+.,.,
+
+# reduce 16 omitted
+
+module_eval(<<'.,.,', 'parser.y', 34)
+  def _reduce_17(val, _values)
+     val[1]
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 35)
+  def _reduce_18(val, _values)
+     val[1]
+  end
+.,.,
+
+def _reduce_none(val, _values)
+  val[0]
+end
+
+  end   # class Parser
+end   # module RsqlParser
+
+

data/lib/rsql_parser/parser.y

@@ -0,0 +1,63 @@
+# RSQL parser
+
+class RsqlParser::Parser
+  prechigh
+    left ';'
+    left ','
+  preclow
+options
+  no_result_var
+rule
+  target      : disjunction
+
+  disjunction : conjuction OR_COMMA_OPERATOR disjunction { create_logical_operator(:OR, val[0], val[2]) }
+              | conjuction
+
+  conjuction  : constraint AND_OPERATOR conjuction { create_logical_operator(:AND, val[0], val[2]) }
+              | constraint
+
+  constraint  : selector COMPARATOR argument { create_constraint(val[0], val[1], val[2]) }
+              | selector
+              | OPENING_BRACKET disjunction CLOSING_BRACKET { val[1] }
+
+  selector    : UNRESERVED
+
+  argument    : array
+              | value
+
+  array       : OPENING_BRACKET contents CLOSING_BRACKET { val[1] }
+              | OPENING_BRACKET CLOSING_BRACKET { [] }
+
+  contents    : value { [val[0]] }
+              | contents OR_COMMA_OPERATOR value { val[0].push(val[2]); val[0] }
+
+  value       : UNRESERVED
+              | SINGLE_QUOTE SINGLE_QUOTED_STRING SINGLE_QUOTE { val[1] }
+              | DOUBLE_QUOTE DOUBLE_QUOTED_STRING DOUBLE_QUOTE { val[1] }
+end
+
+---- header
+  # Generated by racc
+  require_relative 'lexer.rex'
+
+---- inner
+
+def create_logical_operator(operator, lhs, rhs)
+  {
+    type: :COMBINATION,
+    operator: operator,
+    lhs: lhs,
+    rhs: rhs
+  }
+end
+
+def create_constraint(selector, comparison, argument)
+  {
+    type: :CONSTRAINT,
+    selector: selector,
+    comparison: comparison,
+    argument: argument
+  }
+end
+
+---- footer

data/lib/rsql_parser/version.rb

@@ -0,0 +1,3 @@
+module RsqlParser
+  VERSION = "1.0.0"
+end

data/lib/rsql_parser.rb

@@ -0,0 +1,9 @@
+require_relative 'rsql_parser/parser'
+
+module RsqlParser
+  # Parse string to AST nodes
+  def self.parse(str)
+    parser = RsqlParser::Parser.new
+    parser.parse(str)
+  end
+end

data/rsql_ruby.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require_relative 'lib/rsql_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name    = 'rsql_parser'
+  spec.version = RsqlParser::VERSION
+  spec.authors = ['Dmitry Arkhipov']
+  spec.email   = ['d.arkhipov@ekzo.dev']
+
+  spec.summary     = 'RSQL/FIQL parser for Ruby'
+  spec.description = 'Parse RSQL/FIQL string expression into AST nodes'
+
+  spec.homepage              = 'https://github.com/ekzo-dev/ruby-rsql'
+  spec.license               = 'MIT'
+  spec.required_ruby_version = '>= 2.7.0'
+
+  spec.metadata['homepage_uri']    = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri']   = 'https://github.com/ekzo-dev/ruby-rsql/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) || f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor])
+    end
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'racc', '~> 1.8'
+  spec.add_development_dependency 'oedipus_lex', '~> 2.6'
+  spec.add_development_dependency 'minitest', '~> 5.21'
+  spec.add_development_dependency 'rake', '~> 13.0'
+end

data/sig/rsql_parser.rbs

@@ -0,0 +1,14 @@
+# RSQL parsed AST
+type rsql_ast = {
+    type: :COMBINATION | :CONSTRAINT,
+    ?lhs: rsql_ast,
+    ?rhs: rsql_ast,
+    ?selector: String,
+    ?comparison: String,
+    ?argument: String,
+  }
+
+module RsqlParser
+  # Parse string to AST nodes
+  def self.parse: (String str) -> rsql_ast
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: rsql_parser
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Dmitry Arkhipov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: oedipus_lex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.21'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Parse RSQL/FIQL string expression into AST nodes
+email:
+- d.arkhipov@ekzo.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/rsql_parser.rb
+- lib/rsql_parser/lexer.rex
+- lib/rsql_parser/lexer.rex.rb
+- lib/rsql_parser/parser.rb
+- lib/rsql_parser/parser.y
+- lib/rsql_parser/version.rb
+- rsql_ruby.gemspec
+- sig/rsql_parser.rbs
+homepage: https://github.com/ekzo-dev/ruby-rsql
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/ekzo-dev/ruby-rsql
+  source_code_uri: https://github.com/ekzo-dev/ruby-rsql
+  changelog_uri: https://github.com/ekzo-dev/ruby-rsql/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: RSQL/FIQL parser for Ruby
+test_files: []