M7: extract pure CCFE::Config section tokenizer from load_config

The top-level `SECTION { ... }` walk -- the third copy of the same
extract_bracketed loop (after the menu and form parsers) -- becomes a
pure, terminal-free CCFE::Config module returning the sections in file
order ({name, body} + status), matching the MenuFile/FormFile shape.

Unlike menu/form, the config parser's per-section dispatch is not purely
extractable: it is dominated by `eval "$VAR = ..."` colour/attribute
assignments that must run in ccfe.pl's own package to see its colour
helpers and curses constants, plus term-specific (FIELD_ATTR.$TERM) and
$COLS-dependent handling. That effectful, scope-bound dispatch stays in
load_config verbatim -- only the section walk is lifted out, removing
the duplicated bracket boilerplate and making the tokenizer testable.

Unit-tested in t/15-config.t (17 cases); the colour/theme integration
test (t/06-color.t) and the full suite (now 252 tests) stay green. All
four CI checks pass locally (compile, prove, perlcritic src/lib,
perltidy).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: claude

ROADMAP.md

@@ -175,8 +175,18 @@ the conformance tests.
   layout not parsing), select-item resolution and the `%form`/`$SCREEN_DIR`
   side effects. This cut ~325 lines of inline parser to a ~20-line call. Unit-
   tested in `t/14-formfile.t` (40 cases); the multipage-form pty test and full
-  suite (235 tests) stay green. Next: `Config`, `Action`, the pure `Layout`
-  helpers, and finally the `$ctx` threading.
+  suite (235 tests) stay green.
+- 🔄 **`CCFE::Config`** (done): the top-level `SECTION { ... }` walk -- the third
+  copy of the same `extract_bracketed` loop -- is now a pure tokenizer returning
+  the sections in file order (`{name, body}` + status). Unlike the menu/form
+  parsers, the config parser's per-section dispatch is *not* purely extractable:
+  it is dominated by `eval "$VAR = ..."` colour/attribute assignments that must
+  run in `ccfe.pl`'s own package to see its colour helpers and curses constants,
+  plus term-specific (`FIELD_ATTR.$TERM`) and `$COLS`-dependent handling -- so
+  that (effectful, scope-bound) dispatch stays in `load_config` verbatim. Unit-
+  tested in `t/15-config.t` (17 cases); the colour/theme integration test
+  (`t/06-color.t`) and full suite (252 tests) stay green. Next: `Action`, the
+  pure `Layout` helpers, and finally the `$ctx` threading.
 
 ## M8 — Non-functional close-out audit  _(final gate)_
 Five dimensions: **test coverage, code quality, performance, security,

src/ccfe.pl

@@ -48,6 +48,7 @@
 use CCFE::Theme    ();
 use CCFE::MenuFile ();    # pure .menu/.item parser (see load_menu)
 use CCFE::FormFile ();    # pure .form parser (see load_form)
+use CCFE::Config   ();    # pure .conf section tokenizer (see load_config)
 use FindBin ();    # to locate the program at runtime (see the path block below)
 
 # Optional display-width support.  In a UTF-8 locale a label/title can occupy
@@ -1373,13 +1374,16 @@ sub load_config {
                 $text = join( '', @lines );
 
                 my $term = uc $ENV{TERM};
-                ( $val, undef, $key ) =
-                  extract_bracketed( $text, '{', '\s*[a-zA-Z_\.]+\s*' );
-                while ($key) {
-                    $val =~ s/^\{\s*//;
-                    $val =~ s/\s*\n?\s*\}$//;
-                    $key =~ s/^\s+//;
-                    $key =~ s/\s+$//;
+
+                # The top-level `SECTION { ... }` walk now lives in the pure
+                # CCFE::Config tokenizer (ROADMAP M7).  The (effectful,
+                # scope-bound) per-section dispatch below -- including the
+                # `eval "$VAR = ..."` colour/attribute assignments and the
+                # term-/$COLS-dependent handling -- stays here.
+                my ( $sections, $cstatus ) = CCFE::Config::parse($text);
+                foreach my $sec ( @{$sections} ) {
+                    $key = $sec->{name};
+                    $val = $sec->{body};
                   SWITCH: {
                         $_ = uc $key;
                         if (/^GLOBAL$/) {
@@ -1915,12 +1919,8 @@ sub load_config {
                             $res = $ES_SYNTAX_ERR;
                         }
                     }
-                    ( $val, undef, $key ) =
-                      extract_bracketed( $text, '{', '\s*[a-zA-Z_\.]+\s*' );
-                }
-                $res = $ES_SYNTAX_ERR if !pos($text);
-                if ( $res == $ES_NO_ERR ) {
                 }
+                $res = $ES_SYNTAX_ERR if $cstatus eq 'syntax_error';
             }
             else {
                 trace("error opening $fname: $!");

src/lib/CCFE/Config.pm

@@ -0,0 +1,53 @@
+package CCFE::Config;
+
+# Pure tokenizer for CCFE `.conf` content (ROADMAP M7, REFACTOR.md §3).
+#
+# parse($text) walks the top-level `SECTION { ... }` blocks of an already
+# comment-stripped config and returns them in file order as a plain list, with
+# no terminal, no globals and no I/O.  load_config() in ccfe.pl keeps the file
+# finding/reading/comment-stripping and owns the (heavily effectful,
+# scope-bound) dispatch: validating each section's `key = value` lines and
+# assigning the program globals -- including the `eval "$VAR = ..."` colour and
+# attribute settings, which must run in ccfe.pl's own package to see its colour
+# helpers and curses constants, and the term-specific (`FIELD_ATTR.$TERM`) and
+# $COLS-dependent handling.  So this module is just the section walk -- the one
+# genuinely pure, duplicated-three-ways piece -- and its tests drive it
+# directly.
+#
+# Returns ($sections, $status, \@warnings):
+#   $sections = [ { name => 'GLOBAL', body => "KEY = val\n..." }, ... ] in file
+#               order.  A section may legitimately repeat; the caller applies
+#               each in turn.  `name` keeps the file's case (e.g.
+#               "FIELD_ATTR.xterm"); the caller upper-cases for matching.
+#   $status   = 'ok' | 'syntax_error'   ('syntax_error' only for an
+#               unterminated bracket walk; an unknown section or key is the
+#               caller's concern, since it owns the dispatch)
+#   warnings  = kept for shape-consistency with the other parsers (empty here)
+
+use v5.36;
+use Text::Balanced qw(extract_bracketed);
+
+our $VERSION = '2.1';
+
+sub parse ($text) {
+    my @sections;
+    my @warn;
+    my $status = 'ok';
+
+    my ( $val, $key );
+    ( $val, undef, $key ) =
+      extract_bracketed( $text, '{', '\s*[a-zA-Z_\.]+\s*' );
+    while ($key) {
+        $val =~ s/^\{\s*//;
+        $val =~ s/\s*\n?\s*\}$//;
+        $key =~ s/^\s+//;
+        $key =~ s/\s+$//;
+        push @sections, { name => $key, body => $val };
+        ( $val, undef, $key ) =
+          extract_bracketed( $text, '{', '\s*[a-zA-Z_\.]+\s*' );
+    }
+    $status = 'syntax_error' if !pos($text);
+    return ( \@sections, $status, \@warn );
+}
+
+1;

src/t/15-config.t

@@ -0,0 +1,64 @@
+#!/usr/bin/perl
+#
+# Unit tests for the pure CCFE::Config section tokenizer (ROADMAP M7).
+#
+# The top-level `SECTION { ... }` walk was lifted out of load_config() -- the
+# third copy of the same extract_bracketed loop -- into a pure, terminal-free
+# module.  load_config keeps the (effectful, scope-bound) per-section dispatch:
+# the eval-based colour/attribute assignments, the term-specific matching and
+# the global side effects all stay there.  These tests drive parse($text) and
+# check the returned section list, ordering, status and body trimming.
+#
+use strict;
+use warnings;
+use FindBin qw($Bin);
+use lib "$Bin/../lib";
+use Test::More;
+
+require_ok('CCFE::Config') or BAIL_OUT('cannot load CCFE::Config');
+
+# ---- several sections, in file order ------------------------------------
+my ( $secs, $st, $w ) = CCFE::Config::parse( <<'EOT');
+GLOBAL {
+  SCREEN_LAYOUT = smit
+  HIDE_CURSOR = yes
+}
+FORM_GLOBAL {
+  SHOW_DOTS = no
+}
+EOT
+
+is( $st, 'ok', 'a well-formed config parses with status ok' );
+is( scalar @{$secs}, 2,        '  two sections' );
+is( $secs->[0]{name}, 'GLOBAL', '  section 0 name' );
+is( $secs->[1]{name}, 'FORM_GLOBAL', '  section 1 name (order preserved)' );
+like( $secs->[0]{body}, qr/SCREEN_LAYOUT = smit/, '  section 0 body captured' );
+like( $secs->[0]{body}, qr/HIDE_CURSOR = yes/,    '  section 0 second line' );
+unlike( $secs->[0]{body}, qr/[{}]/, '  body has the braces trimmed off' );
+like( $secs->[1]{body}, qr/^SHOW_DOTS = no$/, '  section 1 body trimmed' );
+is_deeply( $w, [], '  no warnings' );
+
+# ---- a repeated section is kept in order, applied by the caller ---------
+( $secs, $st, $w ) = CCFE::Config::parse(
+    "GLOBAL { PATH = a }\nGLOBAL { PATH = b }\n");
+is( scalar @{$secs}, 2, 'a repeated section is kept (not merged)' );
+like( $secs->[0]{body}, qr/PATH = a/, '  first occurrence' );
+like( $secs->[1]{body}, qr/PATH = b/, '  second occurrence' );
+
+# ---- a term-specific section keeps its dotted name verbatim -------------
+( $secs, $st, $w ) =
+  CCFE::Config::parse("FIELD_ATTR.xterm {\n  LABEL_FG = COLOR_RED\n}\n");
+is( $secs->[0]{name}, 'FIELD_ATTR.xterm',
+    'a dotted/term-specific section name is preserved verbatim (case kept)' );
+
+# ---- an unterminated bracket walk is a syntax error ---------------------
+( $secs, $st, $w ) = CCFE::Config::parse("GLOBAL { PATH = a\n");
+is( $st, 'syntax_error', 'an unterminated section -> syntax_error' );
+
+# ---- empty input: no sections (the !pos guard flags it, as the original
+#      load_config did -- an empty/comment-only config is a syntax error) ----
+( $secs, $st, $w ) = CCFE::Config::parse('');
+is( $st, 'syntax_error', 'empty input trips the unterminated-walk guard' );
+is_deeply( $secs, [], '  no sections (empty array, not undef)' );
+
+done_testing();