rails_agent_console 0.1.0

data/lib/rails_agent_console/rewriter/distinct.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Rewriter
+    module Distinct
+      SINGLE_ROW = %i[belongs_to has_one].freeze
+      NOTE = "`distinct` changes nothing when every join is a belongs_to, and PostgreSQL refuses it " \
+             "next to an order by a joined column, so it is left out."
+
+      module_function
+
+      def drop(chain)
+        model = Schema.find(chain.receiver)
+        index = chain.calls.index { |call| call.text.match?(/\A\.\s*distinct\s*\z/) }
+        return if model.nil? || index.nil?
+        return unless foreign_order?(chain, model) && single_row_joins?(chain, model)
+
+        [chain.with_calls(chain.calls.reject.with_index { |_, position| position == index }), NOTE]
+      end
+
+      def foreign_order?(chain, model)
+        chain.calls.any? do |call|
+          %w[order reorder].include?(call.name) &&
+            call.text.scan(/(\w+)\./).flatten.any? { |table| ![model.table, "Arel"].include?(table) }
+        end
+      end
+
+      def single_row_joins?(chain, model)
+        joins = chain.calls.select { |call| JOINS.key?(call.name) }
+        joins.any? && joins.all? do |call|
+          names = call.symbol_arguments
+          names&.all? { |name| SINGLE_ROW.include?(macro(model, name)) }
+        end
+      end
+
+      def macro(model, name)
+        model.associations.find { |association| association[:name].to_s == name }&.dig(:macro)
+      end
+    end
+  end
+end

data/lib/rails_agent_console/rewriter/joined.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Rewriter
+    module Joined
+      NESTED = /(\w+):\s*:(\w+)/
+
+      module_function
+
+      def tables(calls, model)
+        calls.select { |call| JOINS.key?(call.name) }.each_with_object({}) do |call, tables|
+          arguments = call.text[/\((.*)\)\s*\z/m, 1].to_s
+          arguments.scan(NESTED).each { |parent, child| add_nested(tables, model, parent, child) }
+          arguments.gsub(NESTED, "").gsub(/"[^"]*"|'[^']*'/, "").scan(/:(\w+)/).flatten.each do |name|
+            add(tables, model, name)
+          end
+          call.text.scan(/JOIN\s+"?(\w+)"?/i).flatten.each { |table| tables[table] ||= table }
+        end
+      end
+
+      def add_nested(tables, model, parent, child)
+        through = add(tables, model, parent)
+        add(tables, through, child) if through
+      end
+
+      def add(tables, model, name)
+        target = target(model, name)
+        tables[name] = target.table if target
+        target
+      end
+
+      def target(model, name)
+        association = model.associations.find { |candidate| candidate[:name].to_s == name.to_s }
+        association && Schema.find(association[:class_name])
+      end
+
+      def model_for(table)
+        Schema.models.find { |model| model.table == table }
+      end
+    end
+  end
+end

data/lib/rails_agent_console/rewriter/qualifier.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Rewriter
+    class Qualifier
+      SQL_CALLS = (RELATION + AGGREGATES + %w[pluck pick]).freeze
+      SUBQUERY = /\(\s*SELECT\b/i
+      STRING_LITERAL = /"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'/
+
+      def initialize(chain, model)
+        @chain = chain
+        @model = model
+        @renamed = {}
+        @qualified = []
+      end
+
+      def rewrite
+        calls = sql_calls
+        tables = joined_tables(calls)
+        return if tables.empty?
+
+        @ambiguous = ambiguous_columns(tables)
+        rewritten = calls.map { |call| JOINS.key?(call.name) ? call : qualify(call) }
+        return if @renamed.empty? && @qualified.empty?
+
+        [@chain.with_calls(rewritten + @chain.calls.drop(calls.size)), note]
+      end
+
+      private
+
+      def sql_calls
+        count = @chain.calls.index { |call| !SQL_CALLS.include?(call.name) } || @chain.calls.size
+        @chain.calls.first(count)
+      end
+
+      def joined_tables(calls)
+        Joined.tables(calls, @model)
+      end
+
+      def ambiguous_columns(tables)
+        joined = tables.values.uniq.flat_map { |table| Joined.model_for(table)&.column_names || [] }
+        (@model.column_names & joined).to_set
+      end
+
+      def qualify(call)
+        text = call.text.gsub(STRING_LITERAL) do |literal|
+          quote = literal[0]
+          "#{quote}#{rewrite_sql(literal[1...-1])}#{quote}"
+        end
+        text == call.text ? call : Chain::Call.new(call.name, text)
+      end
+
+      def rewrite_sql(sql)
+        outside_subqueries(sql) do |part|
+          part = rename_associations(part)
+          @ambiguous.reduce(part) { |current, column| qualify_column(current, column) }
+        end
+      end
+
+      def outside_subqueries(sql)
+        output = +""
+        rest = sql
+        while (start = rest =~ SUBQUERY)
+          finish = closing_paren(rest, start)
+          output << yield(rest[0...start]) << rest[start..finish]
+          rest = rest[(finish + 1)..]
+        end
+        output << yield(rest)
+      end
+
+      def closing_paren(sql, start)
+        depth = 0
+        (start...sql.length).each do |index|
+          depth += 1 if sql[index] == "("
+          depth -= 1 if sql[index] == ")"
+          return index if depth.zero?
+        end
+        sql.length - 1
+      end
+
+      def rename_associations(sql)
+        joined_names.reduce(sql) do |current, (name, table)|
+          current.gsub(/(?<![\w."])#{Regexp.escape(name)}\.(?=\w)/) do
+            @renamed[name] = table
+            "#{table}."
+          end
+        end
+      end
+
+      def joined_names
+        @joined_names ||= joined_tables(sql_calls).reject { |name, table| name == table }
+      end
+
+      def qualify_column(sql, column)
+        sql.gsub(/(?<![\w."'])(?<!AS\s)(?<!as\s)#{Regexp.escape(column)}(?![\w"'(])/) do
+          @qualified << column unless @qualified.include?(column)
+          "#{@model.table}.#{column}"
+        end
+      end
+
+      def note
+        parts = []
+        if @qualified.any?
+          parts << "#{list(@qualified)} is in more than one of the joined tables, so it now " \
+                   "reads #{@model.table}.#{@qualified.first}, the table the query starts from"
+        end
+        @renamed.each { |name, table| parts << "`#{name}.` is the association; SQL needs the table, #{table}" }
+        "#{parts.join("; ")}."
+      end
+
+      def list(columns)
+        columns.map { |column| "`#{column}`" }.join(", ")
+      end
+    end
+  end
+end

data/lib/rails_agent_console/rewriter/quotes.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module RailsAgentConsole
+  module Rewriter
+    module Quotes
+      SINGLE_QUOTED_SQL = /(\w\()'(.*?)'(\)(?=[.)\s,]|\z))/m
+      ARGUMENT_BREAK = /'\s*,/
+      NOTE = "SQL with its own single quotes was inside a single-quoted Ruby string, " \
+             "so the Ruby string now uses double quotes."
+
+      module_function
+
+      def fix(code)
+        broken = Ripper.sexp(code).nil?
+        fixed = code.gsub(SINGLE_QUOTED_SQL) do
+          prefix, sql, suffix = Regexp.last_match.captures
+          nested?(sql, broken) ? %(#{prefix}"#{sql}"#{suffix}) : Regexp.last_match(0)
+        end
+        fixed != code && Ripper.sexp(fixed) ? [fixed, NOTE] : [code, nil]
+      end
+
+      def nested?(sql, broken)
+        sql.include?("'") && !sql.include?('"') && (broken || !sql.match?(ARGUMENT_BREAK))
+      end
+    end
+  end
+end

data/lib/rails_agent_console/rewriter/sql_repair.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module RailsAgentConsole
+  module Rewriter
+    class SqlRepair
+      STRING_LITERAL = /"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'/
+      AGGREGATE_WITHOUT_PARENS = /\b(AVG|SUM|MIN|MAX|COUNT)\s+(\w+\((?:[^()]|\([^()]*\))*\))/i
+      POSTFIX_LENGTH = /\b((?:\w+\.)?\w+(?:::\w+)?)\s+length\b(?!\s*\()/i
+      AVERAGE_OF = /\bAVG\(\s*((?:\w+\.)?\w+)\s*\)/i
+      PAD_NUMBER = /\b([LR]PAD)\(\s*(EXTRACT\([^()]*\))\s*,/i
+      INTEGER_DIVISION = %r{
+        \b((?:SUM|COUNT)\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\))
+        (\s*/\s*)
+        (?=(?:COUNT|SUM|NULLIF)\s*\()
+      }xi
+      ALREADY_DECIMAL = /(?:\d\.\d+\s*\*\s*|::(?:float|numeric|decimal|real)\w*\s*\(?\s*)\z/i
+      SQL_WORDS = %w[select where and or not by as on from having order group].to_set.freeze
+      TIME_TYPES = %w[datetime timestamp timestamptz date time].to_set.freeze
+      NO_ALIAS = %w[group order reorder].to_set.freeze
+
+      NOTES = {
+        parens: "an aggregate takes its argument in parentheses, AVG(LENGTH(x))",
+        length: "LENGTH is a function, LENGTH(x), not a postfix",
+        alias: "AS names a selected column; GROUP BY and ORDER BY take the expression alone",
+        pad: "LPAD pads text, so the number from EXTRACT is cast to text first",
+        division: "a count divided by a count is whole-number division, so it is multiplied by 1.0 first",
+        epoch: "SQL has no average of a timestamp, so it averages EXTRACT(EPOCH FROM ...), " \
+               "which orders the same way"
+      }.freeze
+
+      def initialize(chain, model)
+        @chain = chain
+        @model = model
+        @fixed = []
+      end
+
+      def rewrite
+        calls = @chain.calls.map { |call| JOINS.key?(call.name) ? call : repair(call) }
+        return if @fixed.empty?
+
+        [@chain.with_calls(calls), "In the SQL: #{@fixed.uniq.map { |key| NOTES[key] }.join("; ")}."]
+      end
+
+      private
+
+      def repair(call)
+        text = call.text.gsub(STRING_LITERAL) do |literal|
+          quote = literal[0]
+          "#{quote}#{fix(literal[1...-1], call.name)}#{quote}"
+        end
+        text == call.text ? call : Chain::Call.new(call.name, text)
+      end
+
+      def fix(sql, name)
+        sql = replace(sql, AGGREGATE_WITHOUT_PARENS, :parens) { |match| "#{match[1]}(#{match[2]})" }
+        sql = replace(sql, POSTFIX_LENGTH, :length) { |match| postfix_length(match) }
+        sql = replace(sql, AVERAGE_OF, :epoch) { |match| average_of(match) }
+        sql = replace(sql, PAD_NUMBER, :pad) { |match| "#{match[1]}(#{match[2]}::text," }
+        sql = replace(sql, INTEGER_DIVISION, :division) { |match| decimal_division(match) }
+        NO_ALIAS.include?(name) ? drop_aliases(sql) : sql
+      end
+
+      def replace(sql, pattern, key)
+        sql.gsub(pattern) do
+          match = Regexp.last_match
+          replacement = yield(match)
+          @fixed << key unless replacement == match[0]
+          replacement
+        end
+      end
+
+      def decimal_division(match)
+        return match[0] if match.pre_match.match?(ALREADY_DECIMAL)
+
+        "#{match[1]} * 1.0#{match[2]}"
+      end
+
+      def postfix_length(match)
+        SQL_WORDS.include?(match[1].downcase) ? match[0] : "LENGTH(#{match[1]})"
+      end
+
+      def average_of(match)
+        time_column?(match[1]) ? "AVG(EXTRACT(EPOCH FROM #{match[1]}))" : match[0]
+      end
+
+      def time_column?(reference)
+        table, column = reference.include?(".") ? reference.split(".", 2) : [nil, reference]
+        model = table ? Schema.models.find { |candidate| candidate.table == table } : @model
+        type = model&.columns&.find { |name, _| name == column }&.[](1)
+        TIME_TYPES.include?(type.to_s)
+      end
+
+      def drop_aliases(sql)
+        depth = 0
+        quoted = false
+        out = +""
+        index = 0
+        while index < sql.length
+          char = sql[index]
+          quoted = !quoted if char == "'"
+          depth += { "(" => 1, ")" => -1 }.fetch(char, 0) unless quoted
+          if !quoted && depth.zero? && (alias_match = sql[index..].match(/\A\s+AS\s+"?\w+"?/i))
+            @fixed << :alias
+            index += alias_match[0].length
+            next
+          end
+          out << char
+          index += 1
+        end
+        out
+      end
+    end
+  end
+end

data/lib/rails_agent_console/rewriter.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "set"
+
+require_relative "rewriter/chain"
+require_relative "rewriter/date_ranges"
+
+module RailsAgentConsole
+  module Rewriter
+    Result = Struct.new(:code, :notes)
+
+    RELATION = %w[
+      all where not or and rewhere unscope joins left_joins left_outer_joins includes
+      preload eager_load references group having order reorder limit offset distinct
+      select readonly none
+    ].to_set.freeze
+
+    JOINS = { "joins" => "INNER", "left_joins" => "LEFT OUTER", "left_outer_joins" => "LEFT OUTER" }.freeze
+    AGGREGATES = %w[count sum average minimum maximum calculate].to_set.freeze
+    MOVABLE = %w[where having order reorder limit offset].to_set.freeze
+    REWRITES = %i[
+      spell_out_joins repair_arguments repair_sql qualify_columns aggregate_last first_group drop_distinct
+    ].freeze
+
+    class << self
+      def apply(code)
+        code, quote_note = Quotes.fix(code.to_s)
+        code, range_note = DateRanges.fix(code)
+        notes = [quote_note, range_note].compact
+        chain = Chain.parse(code)
+        return Result.new(code, notes) if chain.nil?
+
+        rewritten_notes = REWRITES.filter_map do |name|
+          rewritten, note = method(name).call(chain)
+          next if rewritten.nil?
+
+          chain = rewritten
+          note
+        end
+        Result.new(rewritten_notes.empty? ? code : chain.to_s, notes + rewritten_notes)
+      end
+
+      private
+
+      def spell_out_joins(chain)
+        model = Schema.find(chain.receiver)
+        return if model.nil? || model.inbound.empty?
+
+        spelled = []
+        calls = relation_calls(chain).flat_map do |call|
+          replacement = spell_out(call, model)
+          next [call] if replacement.nil?
+
+          spelled.concat(replacement[:tables])
+          replacement[:calls]
+        end
+        return if spelled.empty?
+
+        [chain.with_calls(calls + chain.calls.drop(calls_scanned(chain))), joins_note(model, spelled)]
+      end
+
+      def spell_out(call, model)
+        kind = JOINS[call.name]
+        names = kind && call.symbol_arguments
+        return if names.nil?
+
+        references = names.to_h { |name| [name, missing_association(model, name)] }
+        return if references.values.none?
+
+        missing = references.values.compact
+        kept = references.select { |_, reference| reference.nil? }.keys
+        calls = kept_joins(call, kept) + missing.map { |reference| sql_join(kind, model, reference) }
+        { calls: calls, tables: missing.map { |reference| reference[:table] } }
+      end
+
+      def kept_joins(call, names)
+        return [] if names.empty?
+
+        [Chain::Call.new(call.name, ".#{call.name}(#{names.map { |name| ":#{name}" }.join(", ")})")]
+      end
+
+      def missing_association(model, name)
+        return if model.association_names.include?(name)
+
+        model.inbound.find { |reference| reference[:table].to_s == name }
+      end
+
+      def sql_join(kind, model, reference)
+        on = "#{reference[:table]}.#{reference[:foreign_key]} = #{model.table}.#{primary_key(model)}"
+        Chain::Call.new("joins", %(.joins("#{kind} JOIN #{reference[:table]} ON #{on}")))
+      end
+
+      def primary_key(model)
+        column = model.columns.find { |_, _, extra| extra.to_s.include?("pk") }
+        column ? column.first : "id"
+      end
+
+      def joins_note(model, tables)
+        "#{model.name} has no has_many for #{tables.join(" or ")}, so the join is written out " \
+          "in SQL, the same one the association would have built."
+      end
+
+      def drop_distinct(chain)
+        Distinct.drop(chain)
+      end
+
+      def qualify_columns(chain)
+        model = Schema.find(chain.receiver)
+        model && Qualifier.new(chain, model).rewrite
+      end
+
+      def repair_arguments(chain)
+        model = Schema.find(chain.receiver)
+        model && Arguments.new(chain, model).rewrite
+      end
+
+      def repair_sql(chain)
+        SqlRepair.new(chain, Schema.find(chain.receiver)).rewrite
+      end
+
+      def aggregate_last(chain)
+        index = chain.calls.index { |call| AGGREGATES.include?(call.name) }
+        return if index.nil?
+
+        before = chain.calls.first(index)
+        after = chain.calls.drop(index + 1)
+        return unless misplaced?(before, after)
+
+        aggregate = chain.calls[index]
+        [chain.with_calls(before + after + [aggregate]), aggregate_note(aggregate, after)]
+      end
+
+      def first_group(chain)
+        index = calls_scanned(chain)
+        return unless chain.calls[index]&.text&.match?(/\A\.\s*first\s*\z/)
+
+        column = grouped_column(chain.calls.first(index))
+        return if column.nil?
+
+        rest = chain.calls.drop(index + 1)
+        rest = rest.drop(1) if rest.first&.text&.match?(/\A\.\s*#{column}\s*\z/)
+        pluck = Chain::Call.new("pluck", ".limit(1).pluck(:#{column}).first")
+        [chain.with_calls(chain.calls.first(index) + [pluck] + rest), first_group_note(column)]
+      end
+
+      def grouped_column(calls)
+        columns = calls.select { |call| call.name == "group" }.flat_map { |call| call.symbol_arguments || [] }
+        columns.first if columns.size == 1
+      end
+
+      def first_group_note(column)
+        "`first` on a grouped relation orders by id, which the GROUP BY does not contain, " \
+          "so the top group's #{column} is plucked instead."
+      end
+
+      def misplaced?(before, after)
+        after.any? && after.all? { |call| MOVABLE.include?(call.name) } &&
+          before.all? { |call| RELATION.include?(call.name) }
+      end
+
+      def aggregate_note(aggregate, moved)
+        names = moved.map { |call| "`#{call.name}`" }.uniq.join(" and ")
+        "#{names} came after `#{aggregate.name}`, which returns a result rather than a " \
+          "relation, so they now run before it."
+      end
+
+      def relation_calls(chain)
+        chain.calls.first(calls_scanned(chain))
+      end
+
+      def calls_scanned(chain)
+        chain.calls.index { |call| !RELATION.include?(call.name) } || chain.calls.size
+      end
+    end
+  end
+end
+
+require_relative "rewriter/distinct"
+require_relative "rewriter/joined"
+require_relative "rewriter/quotes"
+require_relative "rewriter/arguments"
+require_relative "rewriter/qualifier"
+require_relative "rewriter/sql_repair"