genfile 0.6.0

CLI for genfile_core template archive management - create, manage, and materialize code generation templates.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307

//! Integration tests for archive analysis commands
//!
//! Tests FR8: Archive Analysis - .info, .status, .discover.parameters, .analyze
//!
//! ## Why These Tests Exist
//!
//! Analysis commands are critical for understanding template archives before use.
//! These tests ensure users can:
//! 1. View archive metadata and statistics (.info)
//! 2. Auto-discover template parameters (.discover.parameters)
//! 3. Check archive readiness status (.status)
//! 4. Get comprehensive analysis (.analyze)
//!
//! ## Test Approach
//!
//! Uses REPL mode to test analysis workflow:
//! 1. Create archive with templates containing {{variables}}
//! 2. Load archive
//! 3. Run analysis commands to inspect archive
//!
//! This validates the natural workflow: load → analyze → understand → configure

use std::fs;

mod cli_runner;

// FR8: Archive Analysis Tests

#[ test ]
fn info_displays_archive_metadata()
{
  // Test: .info command shows archive name, version, description, file counts
  //
  // WHY: Users need quick overview of archive contents before working with it.
  // This is the first command they'll run after loading an archive.
  //
  // VALIDATES:
  // - Archive name displayed
  // - File count statistics
  // - Metadata fields present
  // - Clear, readable output format

  let temp_dir = std::env::temp_dir();
  let source_dir = temp_dir.join( "test_info_source" );
  let archive_path = temp_dir.join( "test_info.json" );

  // Clean up
  let _ = fs::remove_dir_all( &source_dir );
  let _ = fs::remove_file( &archive_path );

  // Create source with multiple files
  fs::create_dir_all( &source_dir ).expect( "Should create source dir" );
  fs::write( source_dir.join( "file1.txt" ), "Content 1" ).expect( "Should write file1" );
  fs::write( source_dir.join( "file2.txt" ), "Content 2" ).expect( "Should write file2" );
  fs::create_dir_all( source_dir.join( "subdir" ) ).expect( "Should create subdir" );
  fs::write( source_dir.join( "subdir" ).join( "file3.txt" ), "Content 3" ).expect( "Should write file3" );

  // REPL workflow: pack → load → info
  let script = format!(
    ".pack input::{} output::{}\n\
     .archive.load path::{}\n\
     .info\n\
     exit",
    source_dir.display(),
    archive_path.display(),
    archive_path.display()
  );

  let output = cli_runner::repl_command( &script )
    .output()
    .expect( "Info workflow should execute" );

  let stdout = String::from_utf8_lossy( &output.stdout );
  let stderr = String::from_utf8_lossy( &output.stderr );

  assert!( output.status.success(), "Workflow should succeed. stdout: {stdout}, stderr: {stderr}" );

  // Verify output contains metadata
  assert!( stdout.contains( "test_info_source" ) || stdout.contains( "Archive" ), "Should show archive name" );
  assert!( stdout.contains( '3' ) || stdout.contains( "Files" ), "Should show file count (3 files)" );

  // Clean up
  let _ = fs::remove_dir_all( &source_dir );
  let _ = fs::remove_file( &archive_path );
}

#[ test ]
fn discover_parameters_finds_template_variables()
{
  // Test: .discover.parameters auto-detects {{variables}} in template files
  //
  // WHY: Manual parameter definition is error-prone. Auto-discovery helps users
  // find all template variables without reading every file.
  //
  // VALIDATES:
  // - Handlebars {{variable}} syntax detected
  // - All unique parameters found across multiple files
  // - Output lists discovered parameter names
  //
  // CRITICAL: This is the key differentiator - automatic parameter detection

  let temp_dir = std::env::temp_dir();
  let source_dir = temp_dir.join( "test_discover_source" );
  let archive_path = temp_dir.join( "test_discover.json" );

  // Clean up
  let _ = fs::remove_dir_all( &source_dir );
  let _ = fs::remove_file( &archive_path );

  // Create templates with multiple parameters
  fs::create_dir_all( &source_dir ).expect( "Should create source dir" );
  fs::write(
    source_dir.join( "template1.txt" ),
    "Project: {{project_name}}\nVersion: {{version}}"
  ).expect( "Should write template1" );
  fs::write(
    source_dir.join( "template2.txt" ),
    "Author: {{author}}\nLicense: {{license}}\nProject: {{project_name}}"
  ).expect( "Should write template2" );

  // REPL workflow: pack → load → discover
  let script = format!(
    ".pack input::{} output::{}\n\
     .archive.load path::{}\n\
     .discover.parameters\n\
     exit",
    source_dir.display(),
    archive_path.display(),
    archive_path.display()
  );

  let output = cli_runner::repl_command( &script )
    .output()
    .expect( "Discover workflow should execute" );

  let stdout = String::from_utf8_lossy( &output.stdout );
  let stderr = String::from_utf8_lossy( &output.stderr );

  assert!( output.status.success(), "Workflow should succeed. stdout: {stdout}, stderr: {stderr}" );

  // Verify all parameters discovered
  assert!( stdout.contains( "project_name" ), "Should discover project_name parameter" );
  assert!( stdout.contains( "version" ), "Should discover version parameter" );
  assert!( stdout.contains( "author" ), "Should discover author parameter" );
  assert!( stdout.contains( "license" ), "Should discover license parameter" );

  // Should show count
  assert!( stdout.contains( '4' ) || stdout.contains( "parameters" ), "Should show parameter count" );

  // Clean up
  let _ = fs::remove_dir_all( &source_dir );
  let _ = fs::remove_file( &archive_path );
}

#[ test ]
fn status_shows_archive_readiness()
{
  // Test: .status command shows completeness/readiness for materialization
  //
  // WHY: Users need to know if archive is ready to materialize or if they need
  // to configure parameters first. Status provides actionable guidance.
  //
  // VALIDATES:
  // - Shows defined parameters
  // - Shows set values
  // - Indicates missing mandatory parameters
  // - Clear readiness indicator

  let temp_dir = std::env::temp_dir();
  let source_dir = temp_dir.join( "test_status_source" );
  let archive_path = temp_dir.join( "test_status.json" );

  // Clean up
  let _ = fs::remove_dir_all( &source_dir );
  let _ = fs::remove_file( &archive_path );

  // Create simple template
  fs::create_dir_all( &source_dir ).expect( "Should create source dir" );
  fs::write( source_dir.join( "template.txt" ), "Name: {{name}}" )
    .expect( "Should write template" );

  // REPL workflow: pack → load → add parameter → status
  let script = format!(
    ".pack input::{} output::{}\n\
     .archive.load path::{}\n\
     .parameter.add name::name mandatory::1\n\
     .status\n\
     exit",
    source_dir.display(),
    archive_path.display(),
    archive_path.display()
  );

  let output = cli_runner::repl_command( &script )
    .output()
    .expect( "Status workflow should execute" );

  let stdout = String::from_utf8_lossy( &output.stdout );
  let stderr = String::from_utf8_lossy( &output.stderr );

  assert!( output.status.success(), "Workflow should succeed. stdout: {stdout}, stderr: {stderr}" );

  // Verify status shows parameter state
  assert!( stdout.contains( "name" ) || stdout.contains( "parameter" ), "Should show parameter name" );
  assert!( stdout.contains( "mandatory" ) || stdout.contains( "required" ) || stdout.contains( '1' ), "Should indicate mandatory status" );

  // Clean up
  let _ = fs::remove_dir_all( &source_dir );
  let _ = fs::remove_file( &archive_path );
}

#[ test ]
fn analyze_provides_comprehensive_overview()
{
  // Test: .analyze command combines all analysis information
  //
  // WHY: Power users want complete picture in one command rather than running
  // multiple analysis commands separately.
  //
  // VALIDATES:
  // - Includes archive metadata (like .info)
  // - Shows parameter information
  // - Displays file statistics
  // - Comprehensive output format

  let temp_dir = std::env::temp_dir();
  let source_dir = temp_dir.join( "test_analyze_source" );
  let archive_path = temp_dir.join( "test_analyze.json" );

  // Clean up
  let _ = fs::remove_dir_all( &source_dir );
  let _ = fs::remove_file( &archive_path );

  // Create archive with templates
  fs::create_dir_all( &source_dir ).expect( "Should create source dir" );
  fs::write( source_dir.join( "file1.txt" ), "Content {{var1}}" )
    .expect( "Should write file1" );
  fs::write( source_dir.join( "file2.txt" ), "Data {{var2}}" )
    .expect( "Should write file2" );

  // REPL workflow: pack → load → analyze
  let script = format!(
    ".pack input::{} output::{}\n\
     .archive.load path::{}\n\
     .analyze\n\
     exit",
    source_dir.display(),
    archive_path.display(),
    archive_path.display()
  );

  let output = cli_runner::repl_command( &script )
    .output()
    .expect( "Analyze workflow should execute" );

  let stdout = String::from_utf8_lossy( &output.stdout );
  let stderr = String::from_utf8_lossy( &output.stderr );

  assert!( output.status.success(), "Workflow should succeed. stdout: {stdout}, stderr: {stderr}" );

  // Verify comprehensive output
  assert!( stdout.contains( "test_analyze_source" ) || stdout.contains( "Archive" ), "Should show archive name" );
  assert!( stdout.contains( '2' ) || stdout.contains( "Files" ) || stdout.contains( "file" ), "Should show file count" );

  // Should mention analysis or summary
  assert!( stdout.contains( "Analysis" ) || stdout.contains( "Summary" ) || stdout.contains( "Overview" ), "Should indicate analysis output" );

  // Clean up
  let _ = fs::remove_dir_all( &source_dir );
  let _ = fs::remove_file( &archive_path );
}

#[ test ]
fn analysis_commands_require_loaded_archive()
{
  // Test: All analysis commands fail gracefully without loaded archive
  //
  // WHY: Common user error - running analysis before loading archive.
  // All analysis commands should provide consistent error messaging.
  //
  // VALIDATES:
  // - .info requires archive
  // - .discover.parameters requires archive
  // - .status requires archive
  // - .analyze requires archive
  // - Clear error messages

  let commands = vec![ ".info", ".discover.parameters", ".status", ".analyze" ];

  for cmd in commands
  {
    let output = cli_runner::cargo_run_command( &[ cmd ] )
      .output()
      .expect( "Command should execute" );

    let combined = format!(
      "{}{}",
      String::from_utf8_lossy( &output.stdout ),
      String::from_utf8_lossy( &output.stderr )
    );

    assert!(
      !output.status.success() || combined.contains( "ERROR" ) || combined.contains( "No archive" ) || combined.contains( "load" ),
      "{cmd} should fail or error without loaded archive. output: {combined}"
    );
  }
}