File Coverage

blib/lib/Number/Range/Regex.pm

Criterion	Covered	Total	%
statement	64	64	100.0
branch	22	24	91.6
condition	2	3	66.6
subroutine	11	11	100.0
pod	3	4	75.0
total	102	106	96.2

# Number::Range::Regex

#
# Copyright 2012 Brian Szymanski.  All rights reserved.  This module is
# free software; you can redistribute it and/or modify it under the same
# terms as Perl itself.

package Number::Range::Regex;

use strict;
use Number::Range::Regex::Range;
use Number::Range::Regex::Iterator;
use Number::Range::Regex::Util;
use Number::Range::Regex::Util::inf qw( neg_inf pos_inf );
use vars qw ( @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS $VERSION );
eval { require warnings; }; #it's ok if we can't load warnings

require Exporter;
use base 'Exporter';
@ISA    = qw( Exporter );
@EXPORT = qw( range rangespec );
@EXPORT_OK = qw ( init regex_range ) ;
%EXPORT_TAGS = ( all => [ @EXPORT, @EXPORT_OK ] );

$VERSION = '0.32';

my $init_opts = $Number::Range::Regex::Range::default_opts;

sub init {
  my ($self, @opts) = @_;

  # vestigial limb: init( foo => "bar" ) == init( { foo => "bar" } );
  my %opts = (@opts == 1) ? %{$opts[0]} :
             (@opts % 2 == 0) ? @opts :
             die 'usage: init( $options_ref )';

  $init_opts = $Number::Range::Regex::Range::default_opts;
  # override any values of init_opts that were passed to init
  while (my ($key, $value) = each %opts) {
    $init_opts->{$key} = $value;
  }
}

# regex_range( $min, $max ); #undef = no limit, so. e.g.
#   regex_range(3, undef) yields the equivalent of qr/[+]?[3-9]|\d+/;
sub regex_range {
  my ($min, $max, $passed_opts) = @_;
  my $opts = option_mangler( $init_opts, $passed_opts );
  return range($min, $max, $opts)->regex();
}

sub range {
  my $opts = option_mangler( ref $_[-1] eq 'HASH' ? pop : undef );
  my ($min, $max) = @_;
  if(!defined $min && !defined $max) {
    die "for the set of all integers, you must specify min as '-inf' and max as '+inf', or use the allow_wildcard argument" if !$opts->{allow_wildcard};
  }
  $min = neg_inf  if  !defined $min;
  $max = pos_inf  if  !defined $max;
  return rangespec( "$min..$max", $opts );
}

sub rangespec {
  my $opts = option_mangler( ref $_[-1] eq 'HASH' ? pop : undef );
  # we allow (but do not like) e.g. rangespec(5,7,10..18);
  # we don't like it because it can make us run out of memory for
  # large ranges. preferred: rangespec('5,7,10..18');
  my $spec;
  if(@_ > 1) {
    warn "passed literal range to rangespec!\n";
    $spec = join $opts->{range_separator}, @_;
  } else {
    $spec = $_[0];
  }

  my $base = $opts->{base};
  my $base_digits = base_digits($base);
  my $base_max   = substr($base_digits, -1);

  my $digits_validate  = "[$base_digits]+";
  my $range_operator   = '\s*'.quotemeta( $opts->{range_operator} ).'\s*';
  my $range_separator  = '\s*'.quotemeta( $opts->{range_separator} ).'\s*';
  my $section_validate = qr/(?:-?$digits_validate|(?:-?$digits_validate|-inf)$range_operator(?:\+?inf|-?$digits_validate))/;
  my $range_validate   = qr/(?:|$section_validate(?:$range_separator$section_validate)*)/;
  die "invalid rangespec '$spec' !~ /$range_validate/"  unless  $spec =~ /^$range_validate$/;

  my @sections = split /$range_separator/, $spec;
  my @ranges;
  foreach my $section (@sections) {
    if($section =~ /^(-?$digits_validate)$/) {
      push @ranges, Number::Range::Regex::SimpleRange->new( $1, $1, $opts );
    } else {
      my ($min, $max) = map { s/^\s+//; s/\s+$//; $_ } split /$range_operator/, $section, 2;
      push @ranges, Number::Range::Regex::SimpleRange->new( $min, $max, $opts );
    }
  }
  my $warn_overlap = defined $opts->{warn_overlap} ?
                     $opts->{warn_overlap} : 'rangespec';
  # note: multi_union() will have the side effect of sorting
  #       and de-overlap-ify-ing the input ranges
  return multi_union( @ranges, { warn_overlap => $warn_overlap } );
}

1;

__END__