X-Git-Url: http://git.vpit.fr/?a=blobdiff_plain;f=lib%2FLaTeX%2FTikZ%2FFunctor.pm;h=00c441a885d4a5cedcc6b3524205e7a69d29f5c8;hb=2f8d25c7ced8c8bc43802025240ab7d673892f5d;hp=eaf13cabed4a9b35bc7eb778cbc7977e8624ce47;hpb=f0b56a8644ce9573f173c6b477e254f0f42401d0;p=perl%2Fmodules%2FLaTeX-TikZ.git diff --git a/lib/LaTeX/TikZ/Functor.pm b/lib/LaTeX/TikZ/Functor.pm index eaf13ca..00c441a 100644 --- a/lib/LaTeX/TikZ/Functor.pm +++ b/lib/LaTeX/TikZ/Functor.pm @@ -18,7 +18,32 @@ our $VERSION = '0.01'; =head1 DESCRIPTION A functor takes a L tree and clones it according to certain rules. -Rules can apply not only to L objects, but also to the L objects they contain. + +Rules can apply not only to L consumer objects, but also to the L consumer objects they contain. +The are stored as L objects. + +When the functor is called onto a set object, all its associated rules are tried successively, and the handler of the first matching rule is executed with : + +=over 4 + +=item * + +the functor object as its first argument ; + +=item * + +the current set object as its second argument ; + +=item * + +the arguments passed to the functor itself starting at the third argument. + +=back + +The handler is expected to return the new set/mod that will in the resulting set tree. +If the new set is different from the original, then the functor is applied to all the mods of the set, and their cloned version are added to the new set. + +If no matching rule is found, the object is returned as-is. =cut @@ -26,21 +51,18 @@ use Carp (); use Sub::Name (); +use LaTeX::TikZ::Functor::Rule; + use LaTeX::TikZ::Interface; use LaTeX::TikZ::Tools; -use Any::Moose 'Util' => [ qw[find_meta does_role] ]; - my $lts_tc = LaTeX::TikZ::Tools::type_constraint('LaTeX::TikZ::Set'); -my @default_set_rules; -my @default_mod_rules; - -my ($validate_rule, $insert_rule); +my $validate_spec; BEGIN { - $validate_rule = Sub::Name::subname('validate_rule' => sub { - my ($spec, $handler) = @_; + $validate_spec = Sub::Name::subname('validate_spec' => sub { + my ($spec) = @_; my ($replace, $target); if (defined $spec and ref $spec eq '' @@ -51,73 +73,7 @@ BEGIN { Carp::confess("Invalid rule spec $spec"); } - (my $pm = $target) =~ s{::}{/}g; - $pm .= '.pm'; - require $pm; - - my $meta = find_meta($target); - Carp::confess("No meta object associated with target $target") - unless defined $meta; - my $is_role = $meta->isa(any_moose('Meta::Role')); - - my $is_set; - if (does_role($target, 'LaTeX::TikZ::Set')) { - $is_set = 1; - } elsif (does_role($target, 'LaTeX::TikZ::Mod')) { - $is_set = 0; - } else { - Carp::confess("Target $target is neither a set nor a mod"); - } - - Carp::confess("Invalid handler for rule spec $spec") - unless defined $handler and ref $handler eq 'CODE'; - - return [ $target, $handler, $replace, $is_role, $is_set ]; - }); - - $insert_rule = Sub::Name::subname('insert_rule' => sub { - my ($rule, $list, $overwrite) = @_; - - my ($target, $replace, $is_role) = @{$rule}[0, 2, 3]; - - if ($replace) { - my @remove; - - for my $i (0 .. $#$list) { - my $old_target = $list->[$i]->[0]; - if ($is_role ? does_role($old_target, $target) - : $old_target->isa($target)) { - if (defined $rule) { - splice @$list, $i, 1, $rule; - $rule = undef; - } else { - push @remove, $i; - } - } - } - - my $shift; - for (@remove) { - splice @$list, $_ - $shift, 1; - ++$shift; - } - return 1 unless defined $rule; - - } else { # Replace only an existent rule - - for my $i (0 .. $#$list) { - my $old_target = $list->[$i]->[0]; - if ($old_target eq $target) { - Carp::confess("Default rule already defined for target $target") - unless $overwrite; - splice @$list, $i, 1, $rule; - return 1; - } - } - } - - push @$list, $rule; - return 0; + return $target, $replace; }); } @@ -168,6 +124,9 @@ Thus, if you define your own L or L object, =cut +my @default_set_rules; +my @default_mod_rules; + sub new { my ($class, %args) = @_; @@ -178,12 +137,21 @@ sub new { while (@user_rules) { my ($spec, $handler) = splice @user_rules, 0, 2; - my $rule = $validate_rule->($spec, $handler); + my ($target, $replace) = $validate_spec->($spec); - $insert_rule->($rule, $rule->[4] ? \@set_rules : \@mod_rules, 1); + my $rule = LaTeX::TikZ::Functor::Rule->new( + target => $target, + handler => $handler, + ); + + $rule->insert( + into => $rule->is_set ? \@set_rules : \@mod_rules, + overwrite => 1, + replace => $replace, + ); } - my %dispatch = map { $_->[0] => $_ } @set_rules, @mod_rules; + my %dispatch = map { $_->target => $_ } @set_rules, @mod_rules; my $self; @@ -195,15 +163,16 @@ sub new { my $rule = $dispatch{ref($set)}; unless ($rule) { for (@set_rules) { - if ($_->[2] ? $set->does($_->[0]) : $set->isa($_->[0])) { + if ($_->handles($set)) { $rule = $_; last; } } - $rule = [ undef, sub { $_[1] } ] unless $rule; } - my $new_set = $rule->[1]->($self, $set, @_); - my $is_new = $new_set ne $set; + return $set unless $rule; + + my $new_set = $rule->handler->($self, $set, @_); + return $set if $new_set == $set; my @new_mods; MOD: @@ -211,20 +180,16 @@ MOD: my $rule = $dispatch{ref($mod)}; unless ($rule) { for (@mod_rules) { - if ($_->[2] ? $mod->does($_->[0]) : $mod->isa($_->[0])) { + if ($_->handles($mod)) { $rule = $_; last; } } - unless ($rule) { - push @new_mods, $mod; - next MOD; - } } - push @new_mods, $rule->[1]->($self, $mod, @_); + push @new_mods, $rule ? $rule->handler->($self, $mod, @_) + : $mod; } - - $new_set->mod(@new_mods) if $is_new; + $new_set->mod(@new_mods); return $new_set; }, $class; @@ -251,19 +216,25 @@ Returns true if and only if an existent rule was replaced. sub default_rule { shift; + my ($spec, $handler) = @_; + + my ($target, $replace) = $validate_spec->($spec); - my $rule = $validate_rule->(@_); + my $rule = LaTeX::TikZ::Functor::Rule->new( + target => $target, + handler => $handler, + ); - $insert_rule->( - $rule, - $rule->[4] ? \@default_set_rules : \@default_mod_rules, - 0, + $rule->insert( + into => $rule->is_set ? \@default_set_rules : \@default_mod_rules, + overwrite => 0, + replace => $replace, ); } =head1 SEE ALSO -L. +L, L. =head1 AUTHOR