Parsing Code

PeskyNestedBraces.md

#!/usr/bin/env raku
my regex nested-parens {
  :ratchet
  '(
   '$<before>=<-[)\s(]>*
    <inside=~~>
    $<after>=<-[)\s(]>*
  ')'
};

my regex nested-braces {
  :ratchet
  '{'
     [
        $<before>=<-[{]>*
        <inside=~~>
        $<after>=<-[}]>*
     ]*
  #'}'
};

my rule class-def {
  'class'
    $<name>=[ \S+ ]
    $<misc>=(<-[\{]>+)
  <nested-braces>
}

my regex method-def {
  $<m>=[ 'sub'?'method' ]     \s*
    $<name>=(<-[)(}{\s]>+)    \s*
    $<args>=<nested-parens>?  \s*
    [ $<misc>=(<-[{]>+) ]?
  #<nested-braces>
}

my $contents;

sub MAIN {
  $contents ~~ / <class-def> /;

  if $/<class-def> -> $cd {
    $cd.gist.say;

    if $cd<nested-braces><inside> -> $i {
      if $i.Str ~~ m:g/ <method-def> / {
        $/.gist.say;
        exit;

        my $sorted-methods = $/<method-def>.sort( *<name> );
        say "Methods found:\n{
             $sorted-methods.map( "\t" ~ *<name>.Str ).join("\n") }";
      } else {
        say 'No methods found!';
      }
    }
  } else {
    say 'No classes found!';
  }
}


INIT {
$contents = q:to/CODE/;
class Rest::Parmas::Iter {
  has RestParamsIter $!rpi;

  submethod BUILD ( :$rest-params-iter ) {
    $!rpi = $rest-params-iter
  }

  method new (RestParams() $rp) {
    my $rest-params-iter = RestParamsIter.new;
    Rest::Params::Iter.init($rest-params-iter, $rp);

    $rest-params-iter ?? self.bless( :$rest-params-iter ) !! Nil;
  }

  method init (
    ::?CLASS:U:

    RestParamsIter $iter,
    RestParams     $params
  ) {
    rest_params_iter_init($iter, $params);
  }

  proto method next (|)
  { * }

  multi method next ( :$raw = False ) {
    my $cn = newCArray(Str);
    my $cp = newCArray(RestParam);

    samewith($cn, $cp, :$raw);
  }
  multi method next (
    CArray[Str]        $name,
    CArray[RestParam]  $param,
                      :$raw = False
  ) {
    rest_params_iter_next($!rpi, $name, $param);

    my $rpr = propReturnObject( ppr($param), $raw, |Rest::Param.getTypePair );

    ( ppr($name), $rpr )
  }
}
CODE

}