para

use Doc::Type;
use Doc::TypeGraph::Decl;
use Doc::TypeGraph::DeclActions;

constant BASE_CLASS = "Any";

unit class Doc::TypeGraph;



head

Doc::TypeGraph - Parse a class description file, return a type graph.


# create and initialize it
my $tg = Doc::TypeGraph.new-from-file("./resources/type-graph.txt");


Doc::TypeGraph creates a graph of all types in a file. It gives you info
about what classes a type inherits from and the roles it does. In addition,
it also computes the inversion of this relations, which let you know what
types inherit a given type and the types implementing a specific role.


[ Category ]
# only one-line comments are supported
packagetype typename[role-signature]
packagetype typename[role-signature] is typename[role-signature] # inheritance
packagetype typename[role-signature] does typename[role-signature] # roles


item

[Metamodel]
# Metamodel
class Metamodel::Archetypes
role  Metamodel::AttributeContainer
class Metamodel::GenericHOW       does Metamodel::Naming
class Metamodel::MethodDispatcher is Metamodel::BaseDispatcher is Another::Something
enum  Bool                          is Int
module Test


Moritz <@moritz>
Antonio Gámiz <@antoniogamiz>


This module has been spun off from the Official Doc repo, if you want to see past changes go
to the L<official doc|https://github.com/Raku/doc>.


Copyright 2019-21 Raku Team
This library is free software; you can redistribute it and/or modify
it under the Artistic License 2.0.



#| Format: $name => Doc::Type.
has %.types;
#| Sorted array of type names.
has @.sorted;

#| Initialize %.types from a file.
method new-from-file($fn = "type-graph.txt") {
    my $filename = $fn.IO.e ?? $fn
                            !! %?RESOURCES<data/type-graph.txt>;
    my $n = self.bless;
    $n.parse-from-file($filename);
    $n;
}

#| Parse the file (using the C<Decl> grammar) and initialize C<%.types> and
#| C<@.sorted>. C<Any> will always be there, since any type (but Junctions)
#| subclass it.
method parse-from-file($fn) {
    my $f = open $fn;

    %!types{BASE_CLASS} = Doc::Type.new(:name(BASE_CLASS));

    my @categories;
    for $f.lines -> $l {
        # ignore comments
        next if $l ~~ / ^ '#' /;

        # ignore empty lines
        if $l ~~ / ^ \s* $ / {
            @categories = Empty;
            next;
        }

        # new [category]
        if $l ~~ / :s ^ '[' (\S+) + ']' $/ {
            @categories = @0>>.lc;
            next;
        }

        # parse line
        my $m = Doc::TypeGraph::Decl.parse($l, :actions(Doc::TypeGraph::DeclActions.new)).actions;

        # initialize the type
        my $type = %!types{$m.type} //= Doc::Type.new(:name($m.type));
        $type.packagetype = $m.packagetype;
        $type.categories = @categories;

        for $m.super -> $t {
            %!types{$t} //= Doc::Type.new(:name($t));
            $type.super.append: %!types{$t};
        }
        for $m.role -> $t {
            %!types{$t} //= Doc::Type.new(:name($t));
            $type.roles.append: %!types{$t};
        }

    }

    for %!types.values -> $t {
        # roles that have a superclass actually apply that superclass
        # to the class that does them, so mimic that here, including
        # parent roles
        my @roles = $t.roles;
        while @roles {
            my $r = @roles.shift;

            $t.super.append: $r.super if $r.super;
            @roles.append: $r.roles if $r.roles;
        }

        # non-roles default to superclass Any
        if $t.packagetype ne 'role' && !$t.super && $t ne 'Mu' && $t.name ne BASE_CLASS {
            $t.super.append: %!types<Any>;
        }
    }

    # this for loop initializes sub and doers attributes
    # of every Doc::Type object in %.types in order to
    # cache the inversion of all type relationships
    for %!types.values -> $t {
        $_.sub.append($t)   for $t.super;
        $_.doers.append($t) for $t.roles;
    }

    self!topo-sort;
}

#| This method takes all Doc::Type objects in %.types
#| and sort them by its name. After that, recursively,
#| add all roles and supers in the object to @!sorted
method !topo-sort {
    my %seen;
    sub visit($n) {
        return if %seen{$n};
        %seen{$n} = True;
        visit($_) for flat $n.super, $n.roles;
        @!sorted.append: $n;
    }
    visit($_) for %!types.values.sort(*.name);
}

method gist {
    @.sorted;
}


root

Type

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


TypeGraph

NAME

SYNOPSIS

DESCRIPTION

FILE SYNTAX

AUTHOR

COPYRIGHT AND LICENSE

Doc::TypeGraph v2.2.1.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation