package MooseX::Getopt;
use Moose::Role;
-use Getopt::Long;
+use Getopt::Long ();
use MooseX::Getopt::OptionTypeMap;
use MooseX::Getopt::Meta::Attribute;
-our $VERSION = '0.03';
+our $VERSION = '0.06';
our $AUTHORITY = 'cpan:STEVAN';
-has ARGV => (is => 'rw', isa => 'ArrayRef');
+has ARGV => (is => 'rw', isa => 'ArrayRef');
+has extra_argv => (is => 'rw', isa => 'ArrayRef');
sub new_with_options {
my ($class, %params) = @_;
- my (@options, %name_to_init_arg);
+ my %processed = $class->_parse_argv(
+ options => [
+ $class->_attrs_to_options( %params )
+ ]
+ );
+
+ $class->new(
+ ARGV => $processed{argv_copy},
+ extra_argv => $processed{argv},
+ %params, # explicit params to ->new
+ %{ $processed{params} }, # params from CLI
+ );
+}
+
+sub _parse_argv {
+ my ( $class, %params ) = @_;
+
+ local @ARGV = @{ $params{argv} || \@ARGV };
+
+ my ( @options, %name_to_init_arg, %options );
+
+ foreach my $opt ( @{ $params{options} } ) {
+ push @options, $opt->{opt_string};
+ $name_to_init_arg{ $opt->{name} } = $opt->{init_arg};
+ }
+
+ # Get a clean copy of the original @ARGV
+ my $argv_copy = [ @ARGV ];
+
+ {
+ local $SIG{__WARN__} = sub { die $_[0] };
+ Getopt::Long::GetOptions(\%options, @options);
+ }
+
+ # Get a copy of the Getopt::Long-mangled @ARGV
+ my $argv_mangled = [ @ARGV ];
+
+ return (
+ argv_copy => $argv_copy,
+ argv => $argv_mangled,
+ params => {
+ map {
+ $name_to_init_arg{$_} => $options{$_}
+ } keys %options,
+ }
+ );
+}
+
+sub _attrs_to_options {
+ my $class = shift;
+
+ my @options;
+
foreach my $attr ($class->meta->compute_all_applicable_attributes) {
my $name = $attr->name;
}
else {
next if $name =~ /^_/;
+ next if $attr->isa('MooseX::Getopt::Meta::NoGetopt');
}
-
- $name_to_init_arg{$name} = $attr->init_arg;
-
+
my $opt_string = $aliases
? join(q{|}, $name, @$aliases)
: $name;
$opt_string .= MooseX::Getopt::OptionTypeMap->get_option_type($type_name);
}
}
-
- push @options => $opt_string;
+
+ push @options, {
+ name => $name,
+ init_arg => $attr->init_arg,
+ opt_string => $opt_string,
+ required => $attr->is_required,
+ ( $attr->has_documentation ? ( doc => $attr->documentation ) : () ),
+ }
}
- my $saved_argv = [ @ARGV ];
- my %options;
-
- GetOptions(\%options, @options);
-
- #use Data::Dumper;
- #warn Dumper \@options;
- #warn Dumper \%name_to_init_arg;
- #warn Dumper \%options;
-
- $class->new(
- ARGV => $saved_argv,
- %params,
- map {
- $name_to_init_arg{$_} => $options{$_}
- } keys %options,
- );
+ return @options;
}
no Moose::Role; 1;
Better examples are certainly welcome :)
+=head2 Inferred Type Constraints
+
+If you define a custom subtype which is a subtype of one of the
+standard L</Supported Type Constraints> above, and do not explicitly
+provide custom support as in L</Custom Type Constraints> above,
+MooseX::Getopt will treat it like the parent type for Getopt
+purposes.
+
+For example, if you had the same custom C<ArrayOfInts> subtype
+from the examples above, but did not add a new custom option
+type for it to the C<OptionTypeMap>, it would be treated just
+like a normal C<ArrayRef> type for Getopt purposes (that is,
+C<=s@>).
+
=head1 METHODS
=over 4
params from the command line (possibly overriding those in C<%params>)
and then return a newly constructed object.
+If L<Getopt::Long/GetOptions> fails (due to invalid arguments),
+C<new_with_options> will throw an exception.
+
=item B<ARGV>
This accessor contains a reference to a copy of the C<@ARGV> array
-which was copied before L<Getopt::Long> mangled it, in case you want
-to see your original options.
+as it originally existed at the time of C<new_with_options>.
+
+=item B<extra_argv>
+
+This accessor contains an arrayref of leftover C<@ARGV> elements that
+L<Getopt::Long> did not parse. Note that the real C<@ARGV> is left
+un-mangled.
=item B<meta>