gmail_search_syntax 0.1.0

data/test/postgres_visitor_test.rb

@@ -0,0 +1,156 @@
+require_relative "test_helper"
+
+class PostgresVisitorTest < Minitest::Test
+  def parse_and_visit(query, current_user_email: nil)
+    ast = GmailSearchSyntax.parse!(query)
+    visitor = GmailSearchSyntax::PostgresVisitor.new(current_user_email: current_user_email)
+    visitor.visit(ast)
+    visitor.to_query.to_sql
+  end
+
+  def test_from_operator
+    sql, params = parse_and_visit("from:alice@example.com")
+
+    assert_includes sql, "INNER JOIN message_addresses"
+    assert_includes sql, "ma1.address_type = ?"
+    assert_includes sql, "ma1.email_address = ?"
+    assert_equal ["from", "cc", "bcc", "alice@example.com"], params
+  end
+
+  def test_subject_operator
+    sql, params = parse_and_visit("subject:meeting")
+
+    assert_includes sql, "m0.subject LIKE ?"
+    assert_equal ["%meeting%"], params
+  end
+
+  def test_older_than_relative_postgres_syntax
+    sql, params = parse_and_visit("older_than:1y")
+
+    assert_includes sql, "m0.internal_date < (NOW() - ?::interval)"
+    assert_equal ["1 years"], params
+  end
+
+  def test_newer_than_relative_postgres_syntax
+    sql, params = parse_and_visit("newer_than:2d")
+
+    assert_includes sql, "m0.internal_date > (NOW() - ?::interval)"
+    assert_equal ["2 days"], params
+  end
+
+  def test_older_than_7_days_postgres
+    sql, params = parse_and_visit("older_than:7d")
+
+    assert_includes sql, "m0.internal_date < (NOW() - ?::interval)"
+    assert_equal ["7 days"], params
+  end
+
+  def test_newer_than_3_months_postgres
+    sql, params = parse_and_visit("newer_than:3m")
+
+    assert_includes sql, "m0.internal_date > (NOW() - ?::interval)"
+    assert_equal ["3 months"], params
+  end
+
+  def test_older_than_2_years_postgres
+    sql, params = parse_and_visit("older_than:2y")
+
+    assert_includes sql, "m0.internal_date < (NOW() - ?::interval)"
+    assert_equal ["2 years"], params
+  end
+
+  def test_or_operator
+    sql, params = parse_and_visit("from:alice@example.com OR from:bob@example.com")
+
+    assert_includes sql, "OR"
+    assert_includes sql, ".email_address = ?"
+    assert_equal ["from", "cc", "bcc", "alice@example.com", "from", "cc", "bcc", "bob@example.com"], params
+  end
+
+  def test_and_operator
+    sql, params = parse_and_visit("from:alice@example.com AND subject:meeting")
+
+    assert_includes sql, "AND"
+    assert_includes sql, "ma1.email_address = ?"
+    assert_includes sql, "m0.subject LIKE ?"
+    assert_equal ["from", "cc", "bcc", "alice@example.com", "%meeting%"], params
+  end
+
+  def test_not_operator
+    sql, params = parse_and_visit("-from:spam@example.com")
+
+    assert_includes sql, "NOT"
+    assert_includes sql, "ma1.email_address = ?"
+    assert_equal ["from", "cc", "bcc", "spam@example.com"], params
+  end
+
+  def test_complex_query
+    sql, params = parse_and_visit("from:alice@example.com subject:meeting has:attachment")
+
+    assert_includes sql, "ma1.email_address = ?"
+    assert_includes sql, "m0.subject LIKE ?"
+    assert_includes sql, "m0.has_attachment = 1"
+    assert_equal ["from", "cc", "bcc", "alice@example.com", "%meeting%"], params
+  end
+
+  def test_label_operator
+    sql, params = parse_and_visit("label:important")
+
+    assert_includes sql, "INNER JOIN message_labels"
+    assert_includes sql, "INNER JOIN labels"
+    assert_includes sql, ".name = ?"
+    assert_equal ["important"], params
+  end
+
+  def test_is_starred
+    sql, params = parse_and_visit("is:starred")
+
+    assert_includes sql, "m0.is_starred = 1"
+    assert_equal [], params
+  end
+
+  def test_has_attachment
+    sql, params = parse_and_visit("has:attachment")
+
+    assert_includes sql, "m0.has_attachment = 1"
+    assert_equal [], params
+  end
+
+  def test_larger_operator
+    sql, params = parse_and_visit("larger:10M")
+
+    assert_includes sql, "m0.size_bytes > ?"
+    assert_equal [10 * 1024 * 1024], params
+  end
+
+  def test_filename_operator
+    sql, params = parse_and_visit("filename:report.pdf")
+
+    assert_includes sql, "INNER JOIN attachments"
+    assert_includes sql, ".filename = ?"
+    assert_equal ["report.pdf"], params
+  end
+
+  def test_backward_compatibility_with_older_than_and_newer_than
+    # Test that we properly inherit all other behavior from SQLiteVisitor
+    sql1, params1 = parse_and_visit("from:alice@example.com")
+
+    ast = GmailSearchSyntax.parse!("from:alice@example.com")
+    sqlite_visitor = GmailSearchSyntax::SQLiteVisitor.new
+    sqlite_visitor.visit(ast)
+    sql2, params2 = sqlite_visitor.to_query.to_sql
+
+    # Structure should be the same (just the relative date handling differs)
+    assert_equal params1, params2
+    # The SQL should be identical for non-date queries
+    assert_equal sql1, sql2
+  end
+
+  def test_combined_relative_dates_and_other_operators
+    sql, params = parse_and_visit("from:alice@example.com newer_than:7d")
+
+    assert_includes sql, "ma1.email_address = ?"
+    assert_includes sql, "m0.internal_date > (NOW() - ?::interval)"
+    assert_equal ["from", "cc", "bcc", "alice@example.com", "7 days"], params
+  end
+end

data/test/sql_visitor_test.rb

@@ -0,0 +1,346 @@
+require "test_helper"
+
+class SqlVisitorTest < Minitest::Test
+  include GmailSearchSyntax::AST
+
+  def parse_and_visit(query_string, current_user_email: nil)
+    ast = GmailSearchSyntax.parse!(query_string)
+    visitor = GmailSearchSyntax::SqlVisitor.new(current_user_email: current_user_email)
+    visitor.visit(ast)
+    visitor.to_query.to_sql
+  end
+
+  def test_simple_from_operator
+    sql, params = parse_and_visit("from:amy@example.com")
+
+    assert_includes sql, "INNER JOIN message_addresses"
+    assert_includes sql, "address_type = ?"
+    assert_includes sql, "email_address = ?"
+    assert_equal ["from", "cc", "bcc", "amy@example.com"], params
+  end
+
+  def test_from_with_prefix_match
+    sql, params = parse_and_visit("from:amy@")
+
+    assert_includes sql, "email_address LIKE ?"
+    assert_equal ["from", "cc", "bcc", "amy@%"], params
+  end
+
+  def test_from_with_suffix_match
+    sql, params = parse_and_visit("from:@example.com")
+
+    assert_includes sql, "email_address LIKE ?"
+    assert_equal ["from", "cc", "bcc", "%@example.com"], params
+  end
+
+  def test_to_operator
+    sql, params = parse_and_visit("to:john@example.com")
+
+    assert_includes sql, "INNER JOIN message_addresses"
+    assert_includes sql, "address_type = ?"
+    assert_equal ["to", "cc", "bcc", "john@example.com"], params
+  end
+
+  def test_subject_operator
+    sql, params = parse_and_visit("subject:dinner")
+
+    assert_includes sql, "m0.subject LIKE ?"
+    assert_equal ["%dinner%"], params
+  end
+
+  def test_after_date_operator
+    sql, params = parse_and_visit("after:2004/04/16")
+
+    assert_includes sql, "m0.internal_date > ?"
+    assert_equal ["2004-04-16"], params
+  end
+
+  def test_before_date_operator
+    sql, params = parse_and_visit("before:2004/04/18")
+
+    assert_includes sql, "m0.internal_date < ?"
+    assert_equal ["2004-04-18"], params
+  end
+
+  def test_older_than_relative
+    sql, params = parse_and_visit("older_than:1y")
+
+    assert_includes sql, "m0.internal_date < datetime('now', ?)"
+    assert_equal ["-1 years"], params
+  end
+
+  def test_newer_than_relative
+    sql, params = parse_and_visit("newer_than:2d")
+
+    assert_includes sql, "m0.internal_date > datetime('now', ?)"
+    assert_equal ["-2 days"], params
+  end
+
+  def test_or_operator
+    sql, params = parse_and_visit("from:amy OR from:david")
+
+    assert_includes sql, "OR"
+    assert_equal ["from", "cc", "bcc", "amy", "from", "cc", "bcc", "david"], params
+  end
+
+  def test_or_operator_uses_unique_table_aliases
+    sql, _params = parse_and_visit("from:alice@example.com OR from:bob@example.com")
+
+    # Ensure we have two different aliases (ma1 and ma3, not reused)
+    # This was a bug where subvisitors would reuse the same alias counter
+    # (ma1 and ma3 because messages table uses fixed m0)
+    assert_includes sql, "message_addresses AS ma1"
+    assert_includes sql, "message_addresses AS ma3"
+
+    # Count occurrences of each alias in the SQL
+    ma1_count = sql.scan(/\bma1\b/).size
+    ma3_count = sql.scan(/\bma3\b/).size
+
+    # Each alias should appear multiple times (in JOIN and WHERE clauses)
+    assert ma1_count > 1, "ma1 should appear multiple times"
+    assert ma3_count > 1, "ma3 should appear multiple times"
+  end
+
+  def test_and_operator
+    sql, params = parse_and_visit("from:amy AND to:david")
+
+    assert_includes sql, "AND"
+    assert_equal ["from", "cc", "bcc", "amy", "to", "cc", "bcc", "david"], params
+  end
+
+  def test_implicit_and
+    sql, params = parse_and_visit("from:amy to:david")
+
+    assert_includes sql, "AND"
+    assert_equal ["from", "cc", "bcc", "amy", "to", "cc", "bcc", "david"], params
+  end
+
+  def test_negation
+    sql, _ = parse_and_visit("dinner -movie")
+
+    assert_includes sql, "NOT"
+    assert_includes sql, "m0.subject LIKE ?"
+    assert_includes sql, "m0.body LIKE ?"
+  end
+
+  def test_label_operator
+    sql, params = parse_and_visit("label:friends")
+
+    assert_includes sql, "INNER JOIN message_labels"
+    assert_includes sql, "INNER JOIN labels"
+    assert_includes sql, "name = ?"
+    assert_equal ["friends"], params
+  end
+
+  def test_category_operator
+    sql, params = parse_and_visit("category:primary")
+
+    assert_includes sql, "m0.category = ?"
+    assert_equal ["primary"], params
+  end
+
+  def test_has_attachment
+    sql, params = parse_and_visit("has:attachment")
+
+    assert_includes sql, "m0.has_attachment = 1"
+    assert_equal [], params
+  end
+
+  def test_has_yellow_star
+    sql, params = parse_and_visit('has:"yellow-star"')
+
+    assert_includes sql, "m0.has_yellow_star = 1"
+    assert_equal [], params
+  end
+
+  def test_has_userlabels
+    sql, params = parse_and_visit("has:userlabels")
+
+    assert_includes sql, "INNER JOIN message_labels"
+    assert_includes sql, "is_system_label = 0"
+    assert_equal [], params
+  end
+
+  def test_has_nouserlabels
+    sql, params = parse_and_visit("has:nouserlabels")
+
+    assert_includes sql, "NOT EXISTS"
+    assert_includes sql, "is_system_label = 0"
+    assert_equal [], params
+  end
+
+  def test_filename_extension
+    sql, params = parse_and_visit("filename:pdf")
+
+    assert_includes sql, "INNER JOIN attachments"
+    assert_includes sql, "filename LIKE ?"
+    assert_equal ["%.pdf", "pdf%"], params
+  end
+
+  def test_filename_exact
+    sql, params = parse_and_visit("filename:homework.txt")
+
+    assert_includes sql, "INNER JOIN attachments"
+    assert_includes sql, "filename = ?"
+    assert_equal ["homework.txt"], params
+  end
+
+  def test_in_inbox
+    sql, params = parse_and_visit("in:inbox")
+
+    assert_includes sql, "m0.in_inbox = 1"
+    assert_equal [], params
+  end
+
+  def test_in_anywhere
+    sql, _ = parse_and_visit("in:anywhere")
+
+    refute_includes sql, "in_inbox"
+    refute_includes sql, "in_archive"
+  end
+
+  def test_is_starred
+    sql, params = parse_and_visit("is:starred")
+
+    assert_includes sql, "m0.is_starred = 1"
+    assert_equal [], params
+  end
+
+  def test_is_unread
+    sql, params = parse_and_visit("is:unread")
+
+    assert_includes sql, "m0.is_unread = 1"
+    assert_equal [], params
+  end
+
+  def test_size_operator
+    sql, params = parse_and_visit("size:1000000")
+
+    assert_includes sql, "m0.size_bytes = ?"
+    assert_equal [1000000], params
+  end
+
+  def test_larger_operator_with_m_suffix
+    sql, params = parse_and_visit("larger:10M")
+
+    assert_includes sql, "m0.size_bytes > ?"
+    assert_equal [10 * 1024 * 1024], params
+  end
+
+  def test_smaller_operator
+    sql, params = parse_and_visit("smaller:1M")
+
+    assert_includes sql, "m0.size_bytes < ?"
+    assert_equal [1 * 1024 * 1024], params
+  end
+
+  def test_rfc822msgid_operator
+    sql, params = parse_and_visit("rfc822msgid:200503292@example.com")
+
+    assert_includes sql, "m0.rfc822_message_id = ?"
+    assert_equal ["200503292@example.com"], params
+  end
+
+  def test_plain_text_search
+    sql, params = parse_and_visit("meeting")
+
+    assert_includes sql, "m0.subject LIKE ?"
+    assert_includes sql, "m0.body LIKE ?"
+    assert_equal ["meeting", "%meeting%", "%meeting%"], params
+  end
+
+  def test_complex_query
+    sql, _ = parse_and_visit("from:amy subject:meeting has:attachment")
+
+    assert_includes sql, "AND"
+    assert_includes sql, "INNER JOIN message_addresses"
+    assert_includes sql, "m0.subject LIKE ?"
+    assert_includes sql, "m0.has_attachment = 1"
+  end
+
+  def test_or_with_parentheses
+    sql, _ = parse_and_visit("from:(amy@example.com OR bob@example.com)")
+
+    assert_includes sql, "OR"
+    assert_includes sql, "INNER JOIN message_addresses"
+  end
+
+  def test_braces_as_or
+    sql, _ = parse_and_visit("from:{amy@example.com bob@example.com}")
+
+    assert_includes sql, "OR"
+  end
+
+  def test_negation_with_operator
+    sql, params = parse_and_visit("-from:spam@example.com")
+
+    assert_includes sql, "NOT"
+    assert_includes sql, "INNER JOIN message_addresses"
+    assert_equal ["from", "cc", "bcc", "spam@example.com"], params
+  end
+
+  def test_around_operator_generates_noop
+    sql, params = parse_and_visit("holiday AROUND 10 vacation")
+
+    assert_includes sql, "(1 = 0)"
+    assert_equal [], params
+  end
+
+  def test_list_operator
+    sql, params = parse_and_visit("list:info@example.com")
+
+    assert_includes sql, "m0.mailing_list = ?"
+    assert_equal ["info@example.com"], params
+  end
+
+  def test_list_with_suffix_match
+    sql, params = parse_and_visit("list:@example.com")
+
+    assert_includes sql, "m0.mailing_list LIKE ?"
+    assert_equal ["%@example.com"], params
+  end
+
+  def test_deliveredto_operator
+    sql, params = parse_and_visit("deliveredto:username@example.com")
+
+    assert_includes sql, "INNER JOIN message_addresses"
+    assert_includes sql, "address_type = ?"
+    assert_equal ["delivered_to", "username@example.com"], params
+  end
+
+  def test_cc_operator
+    sql, params = parse_and_visit("cc:john@example.com")
+
+    assert_includes sql, "address_type = ?"
+    assert_equal ["cc", "john@example.com"], params
+  end
+
+  def test_bcc_operator
+    sql, params = parse_and_visit("bcc:david@example.com")
+
+    assert_includes sql, "address_type = ?"
+    assert_equal ["bcc", "david@example.com"], params
+  end
+
+  def test_from_me_with_current_user
+    sql, params = parse_and_visit("from:me", current_user_email: "test@example.com")
+
+    assert_includes sql, "email_address = ?"
+    assert_equal ["from", "cc", "bcc", "test@example.com"], params
+  end
+
+  def test_nested_conditions
+    sql, _ = parse_and_visit("from:amy (subject:meeting OR subject:call)")
+
+    assert_includes sql, "AND"
+    assert_includes sql, "OR"
+    assert_includes sql, "m0.subject LIKE ?"
+  end
+
+  def test_multiple_joins_with_same_table
+    sql, _ = parse_and_visit("from:amy to:bob")
+
+    join_count = sql.scan("INNER JOIN message_addresses").length
+    assert_equal 2, join_count
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+require "gmail_search_syntax"
+require "minitest/autorun"
+
+# Helper module for Gmail message ID generation
+module GmailMessageIdHelper
+  # Generates a Gmail-style message ID from a timestamp
+  # Based on: https://www.metaspike.com/dates-gmail-message-id-thread-id-timestamps/
+  #
+  # Gmail Message IDs encode the timestamp in the first part (all but last 5 hex digits)
+  # To generate: take timestamp in milliseconds, convert to hex, append 5 random hex digits
+  #
+  # @param time [Time] The timestamp to encode in the message ID
+  # @param random [Random, nil] Optional Random instance for reproducible testing
+  # @return [String] A hexadecimal Gmail message ID (15-16 digits)
+  def generate_gmail_message_id(time, random: Random.new)
+    # Get timestamp in milliseconds since epoch
+    timestamp_ms = (time.to_f * 1000).to_i
+    # Convert timestamp to hex and append first 5 hex digits from random bytes
+    timestamp_hex = timestamp_ms.to_s(16)
+    # Generate 3 random bytes (24 bits = 6 hex digits, we'll use first 5)
+    # Using bytes is much faster than generating individual hex digits
+    random_hex = random.bytes(3).unpack1("H*")[0, 5]
+
+    timestamp_hex + random_hex
+  end
+end