[gitmo/Perl-Critic-Dynamic-Moose.git] / t / DynamicMoose / RequireMethodModifiers.run

## name No superclass
## failures 0
## cut

package Class;
use Moose;

sub foo {}
sub bar {}

#-----------------------------------------------------------------------------

## name No overriding methods
## failures 0
## cut

package Parent;

sub parent {}

package Child;
use Moose;
extends 'Parent';

sub child {}

#-----------------------------------------------------------------------------

## name Implicitly overrides a method
## failures 1
## cut

package Parent;

sub parent {}

package Child;
use Moose;
extends 'Parent';

sub parent {}

#-----------------------------------------------------------------------------

## name Weirdly dispatching methods
## failures 0
## cut

package Parent;
use Moose;

sub BUILD {}
sub DEMOLISH {}

package Child;
use Moose;
extends 'Parent';

sub BUILD {}
sub DEMOLISH {}

#-----------------------------------------------------------------------------

## name Make immutable
## failures 0
## cut

package Parent;
use Moose;

__PACKAGE__->meta->make_immutable;

package Child;
use Moose;
extends 'Parent';

__PACKAGE__->meta->make_immutable;

#-----------------------------------------------------------------------------

## name Many modifiers
## failures 0
## cut

package Parent;
use Moose;

sub foo {}

sub ai { inner() }

sub os {}

package Child;
use Moose;
extends 'Parent';

before foo => sub {};
after  foo => sub {};
around foo => sub {};

augment ai => sub {};

override os => sub { super };

#-----------------------------------------------------------------------------

## name Pull in a method from a role. Could go either way here.
## failures 1
## cut

package Parent;
use Moose;

sub foo {}

package Role;
use Moose::Role;

sub foo {}

package Child;
use Moose;
extends 'Parent';
with 'Role';

#-----------------------------------------------------------------------------

## name Grandparent
## failures 1
## cut

package Grandparent;
use Moose;

sub foo {}

package Parent;
use Moose;
extends 'Grandparent';

sub bar {}

package Child;
use Moose;
extends 'Parent';

sub foo {}

#-----------------------------------------------------------------------------

## name Grandparent with modifiers
## failures 0
## cut

package Grandparent;
use Moose;

sub foo {}

package Parent;
use Moose;
extends 'Grandparent';

before foo => sub {};

package Child;
use Moose;
extends 'Parent';

after foo => sub {};

#-----------------------------------------------------------------------------

## name Pull in a method from a role. Could go either way here.
## failures 1
## cut

package Parent;
use Moose;

sub foo {}

package Role;
use Moose::Role;

sub foo {}

package Child;
use Moose;
extends 'Parent';
with 'Role';

#-----------------------------------------------------------------------------

## name Grandparent
## failures 1
## cut

package Grandparent;
use Moose;

sub foo {}

package Parent;
use Moose;
extends 'Grandparent';

sub bar {}

package Child;
use Moose;
extends 'Parent';

sub foo {}

#-----------------------------------------------------------------------------

## name Grandparent with modifiers
## failures 0
## cut

package Grandparent;
use Moose;

sub foo {}

package Parent;
use Moose;
extends 'Grandparent';

before foo => sub {};

package Child;
use Moose;
extends 'Parent';

after foo => sub {};

#-----------------------------------------------------------------------------

## name Wrapping an implicit override
## failures 1
## cut

package Parent;
use Moose;

sub foo {}

package Child;
use Moose;
extends 'Parent';

before foo => sub {};
sub foo {}

#-----------------------------------------------------------------------------

## name Wrapping an implicit override twice
## failures 1
## cut

package Parent;
use Moose;

sub foo {}

package Child;
use Moose;
extends 'Parent';

before foo => sub {};
before foo => sub {};
sub foo {}

#-----------------------------------------------------------------------------

## name Imported functions
## failures 0
## cut

package Parent;
use Moose;
use List::Util 'reduce';

package Child;
use Moose;
extends 'Parent';
use List::Util 'reduce';
Commit	Line	Data
fe411924	1	## name No superclass
	2	## failures 0
	3	## cut
	4
	5	package Class;
	6	use Moose;
	7
	8	sub foo {}
	9	sub bar {}
	10
	11	#-----------------------------------------------------------------------------
	12
	13	## name No overriding methods
	14	## failures 0
	15	## cut
	16
	17	package Parent;
	18
	19	sub parent {}
	20
	21	package Child;
	22	use Moose;
	23	extends 'Parent';
	24
	25	sub child {}
	26
	27	#-----------------------------------------------------------------------------
	28
	29	## name Implicitly overrides a method
	30	## failures 1
	31	## cut
	32
	33	package Parent;
	34
	35	sub parent {}
	36
	37	package Child;
	38	use Moose;
	39	extends 'Parent';
	40
	41	sub parent {}
	42
	43	#-----------------------------------------------------------------------------
	44
	45	## name Weirdly dispatching methods
	46	## failures 0
	47	## cut
	48
	49	package Parent;
	50	use Moose;
	51
	52	sub BUILD {}
	53	sub DEMOLISH {}
	54
	55	package Child;
	56	use Moose;
	57	extends 'Parent';
	58
	59	sub BUILD {}
	60	sub DEMOLISH {}
	61
	62	#-----------------------------------------------------------------------------
	63
	64	## name Make immutable
65	## failures 0
66	## cut
67
68	package Parent;
69	use Moose;
70
71	__PACKAGE__->meta->make_immutable;
72
73	package Child;
74	use Moose;
75	extends 'Parent';
76
77	__PACKAGE__->meta->make_immutable;
78
79	#-----------------------------------------------------------------------------
80
81	## name Many modifiers
82	## failures 0
83	## cut
84
85	package Parent;
86	use Moose;
87
88	sub foo {}
89
90	sub ai { inner() }
91
92	sub os {}
93
94	package Child;
95	use Moose;
96	extends 'Parent';
97
98	before foo => sub {};
99	after foo => sub {};
100	around foo => sub {};
101
102	augment ai => sub {};
103
104	override os => sub { super };
105
106	#-----------------------------------------------------------------------------
107
108	## name Pull in a method from a role. Could go either way here.
109	## failures 1
110	## cut
111
112	package Parent;
113	use Moose;
114
115	sub foo {}
116
117	package Role;
118	use Moose::Role;
119
120	sub foo {}
121
122	package Child;
123	use Moose;
124	extends 'Parent';
125	with 'Role';
126
127	#-----------------------------------------------------------------------------
128
129	## name Grandparent
130	## failures 1
131	## cut
132
133	package Grandparent;
134	use Moose;
135
136	sub foo {}
137
138	package Parent;
139	use Moose;
140	extends 'Grandparent';
141
142	sub bar {}
143
144	package Child;
145	use Moose;
146	extends 'Parent';
147
148	sub foo {}
149
150	#-----------------------------------------------------------------------------
151
152	## name Grandparent with modifiers
153	## failures 0
154	## cut
155
156	package Grandparent;
157	use Moose;
158
159	sub foo {}
160
161	package Parent;
162	use Moose;
163	extends 'Grandparent';
164
165	before foo => sub {};
166
167	package Child;
168	use Moose;
169	extends 'Parent';
170
171	after foo => sub {};
172
e842cd1d	173	#-----------------------------------------------------------------------------
	174
	175	## name Pull in a method from a role. Could go either way here.
	176	## failures 1
	177	## cut
	178
	179	package Parent;
	180	use Moose;
	181
	182	sub foo {}
	183
	184	package Role;
	185	use Moose::Role;
	186
	187	sub foo {}
	188
	189	package Child;
	190	use Moose;
	191	extends 'Parent';
	192	with 'Role';
	193
	194	#-----------------------------------------------------------------------------
	195
	196	## name Grandparent
	197	## failures 1
	198	## cut
	199
	200	package Grandparent;
	201	use Moose;
	202
	203	sub foo {}
	204
	205	package Parent;
	206	use Moose;
	207	extends 'Grandparent';
	208
	209	sub bar {}
	210
	211	package Child;
	212	use Moose;
	213	extends 'Parent';
	214
	215	sub foo {}
	216
	217	#-----------------------------------------------------------------------------
	218
	219	## name Grandparent with modifiers
	220	## failures 0
	221	## cut
	222
	223	package Grandparent;
	224	use Moose;
	225
	226	sub foo {}
	227
	228	package Parent;
	229	use Moose;
	230	extends 'Grandparent';
	231
	232	before foo => sub {};
	233
	234	package Child;
	235	use Moose;
	236	extends 'Parent';
237
238	after foo => sub {};
239
240	#-----------------------------------------------------------------------------
241
242	## name Wrapping an implicit override
243	## failures 1
244	## cut
245
246	package Parent;
247	use Moose;
248
249	sub foo {}
250
251	package Child;
252	use Moose;
253	extends 'Parent';
254
255	before foo => sub {};
256	sub foo {}
c07f8721	257
	258	#-----------------------------------------------------------------------------
	259
de63df59	260	## name Wrapping an implicit override twice
	261	## failures 1
	262	## cut
	263
	264	package Parent;
	265	use Moose;
	266
	267	sub foo {}
	268
	269	package Child;
	270	use Moose;
	271	extends 'Parent';
	272
	273	before foo => sub {};
	274	before foo => sub {};
	275	sub foo {}
	276
	277	#-----------------------------------------------------------------------------
	278
c07f8721	279	## name Imported functions
	280	## failures 0
	281	## cut
	282
	283	package Parent;
	284	use Moose;
	285	use List::Util 'reduce';
	286
	287	package Child;
	288	use Moose;
	289	extends 'Parent';
	290	use List::Util 'reduce';
	291