1use std::fmt::Write;
2use std::path::Path;
3
4use scythe_backend::manifest::{BackendManifest, load_manifest};
5use scythe_backend::naming::{
6 enum_type_name, enum_variant_name, fn_name, row_struct_name, to_pascal_case,
7};
8
9use scythe_core::analyzer::{AnalyzedQuery, CompositeInfo, EnumInfo};
10use scythe_core::errors::{ErrorCode, ScytheError};
11use scythe_core::parser::QueryCommand;
12
13use crate::backend_trait::{CodegenBackend, RbsGenerationContext, ResolvedColumn, ResolvedParam};
14
15const DEFAULT_MANIFEST_TOML: &str = include_str!("../../manifests/ruby-trilogy.toml");
16
17pub struct RubyTrilogyBackend {
18 manifest: BackendManifest,
19}
20
21impl RubyTrilogyBackend {
22 pub fn new(engine: &str) -> Result<Self, ScytheError> {
23 match engine {
24 "mysql" | "mariadb" => {}
25 _ => {
26 return Err(ScytheError::new(
27 ErrorCode::InternalError,
28 format!("ruby-trilogy only supports MySQL, got engine '{}'", engine),
29 ));
30 }
31 }
32 let manifest_path = Path::new("backends/ruby-trilogy/manifest.toml");
33 let manifest = if manifest_path.exists() {
34 load_manifest(manifest_path)
35 .map_err(|e| ScytheError::new(ErrorCode::InternalError, format!("manifest: {e}")))?
36 } else {
37 toml::from_str(DEFAULT_MANIFEST_TOML)
38 .map_err(|e| ScytheError::new(ErrorCode::InternalError, format!("manifest: {e}")))?
39 };
40 Ok(Self { manifest })
41 }
42}
43
44fn ruby_coercion(neutral_type: &str) -> &'static str {
46 match neutral_type {
47 "int16" | "int32" | "int64" => ".to_i",
48 "float32" | "float64" => ".to_f",
49 "bool" => " == 1",
50 _ => "",
51 }
52}
53
54impl CodegenBackend for RubyTrilogyBackend {
55 fn name(&self) -> &str {
56 "ruby-trilogy"
57 }
58
59 fn manifest(&self) -> &scythe_backend::manifest::BackendManifest {
60 &self.manifest
61 }
62
63 fn supported_engines(&self) -> &[&str] {
64 &["mysql"]
65 }
66
67 fn generate_rbs_file(&self, context: &RbsGenerationContext) -> Option<String> {
68 Some(super::ruby_rbs::generate_rbs_content(context, "Trilogy"))
69 }
70
71 fn file_header(&self) -> String {
72 "# frozen_string_literal: true\n\n# Auto-generated by scythe. Do not edit.\n\nmodule Queries"
73 .to_string()
74 }
75
76 fn file_footer(&self) -> String {
77 "end".to_string()
78 }
79
80 fn generate_row_struct(
81 &self,
82 query_name: &str,
83 columns: &[ResolvedColumn],
84 ) -> Result<String, ScytheError> {
85 let struct_name = row_struct_name(query_name, &self.manifest.naming);
86 let fields = columns
87 .iter()
88 .map(|c| format!(":{}", c.field_name))
89 .collect::<Vec<_>>()
90 .join(", ");
91 let mut out = String::new();
92 let _ = writeln!(out, " {} = Data.define({})", struct_name, fields);
93 Ok(out)
94 }
95
96 fn generate_model_struct(
97 &self,
98 table_name: &str,
99 columns: &[ResolvedColumn],
100 ) -> Result<String, ScytheError> {
101 let name = to_pascal_case(table_name);
102 self.generate_row_struct(&name, columns)
103 }
104
105 fn generate_query_fn(
106 &self,
107 analyzed: &AnalyzedQuery,
108 struct_name: &str,
109 columns: &[ResolvedColumn],
110 params: &[ResolvedParam],
111 ) -> Result<String, ScytheError> {
112 let func_name = fn_name(&analyzed.name, &self.manifest.naming);
113 let sql = super::clean_sql_with_optional(
114 &analyzed.sql,
115 &analyzed.optional_params,
116 &analyzed.params,
117 );
118 let mut out = String::new();
119
120 let param_list = params
121 .iter()
122 .map(|p| p.field_name.clone())
123 .collect::<Vec<_>>()
124 .join(", ");
125 let sep = if param_list.is_empty() { "" } else { ", " };
126
127 let param_array = if params.is_empty() {
128 "[]".to_string()
129 } else {
130 format!(
131 "[{}]",
132 params
133 .iter()
134 .map(|p| p.field_name.clone())
135 .collect::<Vec<_>>()
136 .join(", ")
137 )
138 };
139
140 match &analyzed.command {
141 QueryCommand::One => {
142 let _ = writeln!(out, " def self.{}(client{}{})", func_name, sep, param_list);
143 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
144 let _ = writeln!(
145 out,
146 " results = stmt.execute({})",
147 param_array.trim_start_matches('[').trim_end_matches(']')
148 );
149 let _ = writeln!(out, " row = results.first");
150 let _ = writeln!(out, " return nil if row.nil?");
151
152 let fields = columns
153 .iter()
154 .enumerate()
155 .map(|(i, c)| {
156 let coercion = ruby_coercion(&c.neutral_type);
157 if c.nullable {
158 format!("{}: row[{}]&.then {{ |v| v{} }}", c.field_name, i, coercion)
159 } else {
160 format!("{}: row[{}]{}", c.field_name, i, coercion)
161 }
162 })
163 .collect::<Vec<_>>()
164 .join(", ");
165 let _ = writeln!(out, " {}.new({})", struct_name, fields);
166 }
167 QueryCommand::Batch => {
168 let batch_fn_name = format!("{}_batch", func_name);
169 let _ = writeln!(out, " def self.{}(client, items)", batch_fn_name);
171 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
172 let _ = writeln!(out, " items.each do |item|");
173 if params.len() > 1 {
174 let _ = writeln!(out, " stmt.execute(*item)");
175 } else if params.len() == 1 {
176 let _ = writeln!(out, " stmt.execute(item)");
177 } else {
178 let _ = writeln!(out, " stmt.execute");
179 }
180 let _ = writeln!(out, " end");
181 let _ = write!(out, " end");
182 return Ok(out);
183 }
184 QueryCommand::Many => {
185 let _ = writeln!(out, " def self.{}(client{}{})", func_name, sep, param_list);
186 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
187 let _ = writeln!(
188 out,
189 " results = stmt.execute({})",
190 param_array.trim_start_matches('[').trim_end_matches(']')
191 );
192 let _ = writeln!(out, " results.map do |row|");
193 let fields = columns
194 .iter()
195 .enumerate()
196 .map(|(i, c)| {
197 let coercion = ruby_coercion(&c.neutral_type);
198 if c.nullable {
199 format!("{}: row[{}]&.then {{ |v| v{} }}", c.field_name, i, coercion)
200 } else {
201 format!("{}: row[{}]{}", c.field_name, i, coercion)
202 }
203 })
204 .collect::<Vec<_>>()
205 .join(", ");
206 let _ = writeln!(out, " {}.new({})", struct_name, fields);
207 let _ = writeln!(out, " end");
208 }
209 QueryCommand::Exec => {
210 let _ = writeln!(out, " def self.{}(client{}{})", func_name, sep, param_list);
211 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
212 let _ = writeln!(
213 out,
214 " stmt.execute({})",
215 param_array.trim_start_matches('[').trim_end_matches(']')
216 );
217 let _ = writeln!(out, " nil");
218 }
219 QueryCommand::ExecResult | QueryCommand::ExecRows => {
220 let _ = writeln!(out, " def self.{}(client{}{})", func_name, sep, param_list);
221 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
222 let _ = writeln!(
223 out,
224 " stmt.execute({})",
225 param_array.trim_start_matches('[').trim_end_matches(']')
226 );
227 let _ = writeln!(out, " client.affected_rows");
228 }
229 QueryCommand::Grouped => unreachable!("handled as Many in codegen"),
230 }
231
232 let _ = write!(out, " end");
233 Ok(out)
234 }
235
236 fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
237 let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
238 let mut out = String::new();
239 let _ = writeln!(out, " module {}", type_name);
240 for value in &enum_info.values {
241 let variant = enum_variant_name(value, &self.manifest.naming);
242 let _ = writeln!(out, " {} = \"{}\"", variant, value);
243 }
244 let all_values = enum_info
245 .values
246 .iter()
247 .map(|v| enum_variant_name(v, &self.manifest.naming))
248 .collect::<Vec<_>>()
249 .join(", ");
250 let _ = writeln!(out, " ALL = [{}].freeze", all_values);
251 let _ = write!(out, " end");
252 Ok(out)
253 }
254
255 fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
256 let name = to_pascal_case(&composite.sql_name);
257 let mut out = String::new();
258 if composite.fields.is_empty() {
259 let _ = writeln!(out, " {} = Data.define()", name);
260 } else {
261 let fields = composite
262 .fields
263 .iter()
264 .map(|f| format!(":{}", f.name))
265 .collect::<Vec<_>>()
266 .join(", ");
267 let _ = writeln!(out, " {} = Data.define({})", name, fields);
268 }
269 Ok(out)
270 }
271}