483e2f609

Build Type

push

github-actions

Committed by GitHub

Commit Message

<a href="https://github.com/tobyink/p5-type-tiny/commit/<a class=hub.com/tobyink/p5-type-tiny/commit/483e2f6092b1de3ede153574cebe7eef0236b122">483e2f609<a href="https://github.com/tobyink/p5-type-tiny/commit/483e2f6092b1de3ede153574cebe7eef0236b122">">Merge </a><a class="double-link" href="https://github.com/tobyink/p5-type-tiny/commit/<a class="double-link" href="https://github.com/tobyink/p5-type-tiny/commit/8b9e26e7c7c688ef876d738f3eea0ffa895646aa">8b9e26e7c</a>">8b9e26e7c</a><a href="https://github.com/tobyink/p5-type-tiny/commit/483e2f6092b1de3ede153574cebe7eef0236b122"> into d5248b7b1">d5248b7b1</a>

Run Details

58 of 58 new or added lines in 1 file covered. (100.0%)

3575 of 3578 relevant lines covered (99.92%)

28968.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.83

/lib/Type/Tiny/Bitfield.pm

package Type::Tiny::Bitfield;

use 5.008001;
use strict;
use warnings;

BEGIN {
        $Type::Tiny::Bitfield::AUTHORITY = 'cpan:TOBYINK';
        $Type::Tiny::Bitfield::VERSION   = '2.002001';
}

$Type::Tiny::Bitfield::VERSION =~ tr/_//d;

sub _croak ($;@) { require Error::TypeTiny; goto \&Error::TypeTiny::croak }

use Exporter::Tiny 1.004001 ();
use Type::Tiny ();
our @ISA = qw( Type::Tiny Exporter::Tiny );

sub _is_power_of_two { not $_[0] & $_[0]-1 }

sub _exporter_fail {
        my ( $class, $type_name, $values, $globals ) = @_;
        my $caller = $globals->{into};
        my $type = $class->new(
                name      => $type_name,
                values    => { %$values },
                #coercion  => 1,
        );
        $INC{'Type/Registry.pm'}
                ? 'Type::Registry'->for_class( $caller )->add_type( $type, $type_name )
                : ( $Type::Registry::DELAYED{$caller}{$type_name} = $type )
                unless( ref($caller) or $caller eq '-lexical' or $globals->{'lexical'} );
        return map +( $_->{name} => $_->{code} ), @{ $type->exportables };
}

sub new {
        my $proto = shift;
        
        my %opts = ( @_ == 1 ) ? %{ $_[0] } : @_;
        _croak
                "Bitfield type constraints cannot have a parent constraint passed to the constructor"
                if exists $opts{parent};
        _croak
                "Bitfield type constraints cannot have a constraint coderef passed to the constructor"
                if exists $opts{constraint};
        _croak
                "Bitfield type constraints cannot have a inlining coderef passed to the constructor"
                if exists $opts{inlined};
        _croak "Need to supply hashref of values"
                unless exists $opts{values};
        
        require Types::Common::Numeric;
        $opts{parent} = Types::Common::Numeric::PositiveOrZeroInt();
        
        my $ALL = 0;
        my %already = ();
        for my $value ( values %{ $opts{values} } ) {
                _croak "Not a positive power of 2 in a bitfield: $value"
                        unless _is_power_of_two $value;
                _croak "Duplicate value in a bitfield: $value"
                        if $already{$value}++;
                $ALL |= ( 0 + $value );
        }
        $opts{ALL} = $ALL;
        
        # TODO: ensure all keys in $opt{values} are caps
        
        $opts{constraint} = sub {
                not shift() & ~$ALL;
        };
        
        # TODO: coercion
        
        return $proto->SUPER::new( %opts );
} #/ sub new

sub values {
        $_[0]{values}
}

sub _lockdown {
        my ( $self, $callback ) = @_;
        $callback->( $self->{values} );
}

sub exportables {
        my ( $self, $base_name ) = @_;
        if ( not $self->is_anon ) {
                $base_name ||= $self->name;
        }
        
        my $exportables = $self->SUPER::exportables( $base_name );
        
        require Eval::TypeTiny;
        require B;
        
        for my $key ( keys %{ $self->values } ) {
                my $value = $self->values->{$key};
                push @$exportables, {
                        name => uc( sprintf '%s_%s', $base_name, $key ),
                        tags => [ 'constants' ],
                        code => Eval::TypeTiny::eval_closure(
                                source      => sprintf( 'sub () { %d }', $value ),
                                environment => {},
                        ),
                };
        }
        
        return $exportables;
}

sub can_be_inlined {
        !!1;
}

sub inline_check {
        my ( $self, $var ) = @_;
        
        return sprintf(
                '( %s and not %s & ~%d )',
                Types::Common::Numeric::PositiveOrZeroInt()->inline_check( $var ),
                $var,
                $self->{ALL},
        );
}

sub AUTOLOAD {
        my $self = shift;
        my ( $m ) = ( our $AUTOLOAD =~ /::(\w+)$/ );
        return if $m eq 'DESTROY';
        if ( ref $self and exists $self->{values}{$m} ) {
                return $self->{values}{$m};
        }
        return $self->SUPER::AUTOLOAD( @_ );
}

sub can {
        my ( $self, $m ) = ( shift, @_ );
        if ( ref $self and exists $self->{values}{$m} ) {
                return sub () { $self->{values}{$m} };
        }
        return $self->SUPER::can( @_ );
}

1;

1	package Type::Tiny::Bitfield;
2
3	use 5.008001;	8✔
4	use strict;	8✔
5	use warnings;	8✔
6
7	BEGIN {
8	$Type::Tiny::Bitfield::AUTHORITY = 'cpan:TOBYINK';	8✔
9	$Type::Tiny::Bitfield::VERSION = '2.002001';	8✔
10	}
11
12	$Type::Tiny::Bitfield::VERSION =~ tr/_//d;
13
14	sub _croak ($;@) { require Error::TypeTiny; goto \&Error::TypeTiny::croak }	8✔
15
16	use Exporter::Tiny 1.004001 ();	8✔
17	use Type::Tiny ();	8✔
18	our @ISA = qw( Type::Tiny Exporter::Tiny );
19
20	sub _is_power_of_two { not $_[0] & $_[0]-1 }	52✔
21
22	sub _exporter_fail {
23	my ( $class, $type_name, $values, $globals ) = @_;	16✔
24	my $caller = $globals->{into};	16✔
25	my $type = $class->new(	16✔
26	name => $type_name,
27	values => { %$values },
28	#coercion => 1,
29	);
30	$INC{'Type/Registry.pm'}
31	? 'Type::Registry'->for_class( $caller )->add_type( $type, $type_name )
32	: ( $Type::Registry::DELAYED{$caller}{$type_name} = $type )
33	unless( ref($caller) or $caller eq '-lexical' or $globals->{'lexical'} );	8✔
34	return map +( $_->{name} => $_->{code} ), @{ $type->exportables };	8✔
35	}
36
37	sub new {
38	my $proto = shift;	16✔
39
40	my %opts = ( @_ == 1 ) ? %{ $_[0] } : @_;	16✔
41	_croak
42	"Bitfield type constraints cannot have a parent constraint passed to the constructor"
43	if exists $opts{parent};	16✔
44	_croak
45	"Bitfield type constraints cannot have a constraint coderef passed to the constructor"
46	if exists $opts{constraint};	16✔
47	_croak
48	"Bitfield type constraints cannot have a inlining coderef passed to the constructor"
49	if exists $opts{inlined};	16✔
50	_croak "Need to supply hashref of values"
51	unless exists $opts{values};	16✔
52
53	require Types::Common::Numeric;	16✔
54	$opts{parent} = Types::Common::Numeric::PositiveOrZeroInt();	16✔
55
56	my $ALL = 0;	16✔
57	my %already = ();	16✔
58	for my $value ( values %{ $opts{values} } ) {	16✔
59	_croak "Not a positive power of 2 in a bitfield: $value"	52✔
60	unless _is_power_of_two $value;
61	_croak "Duplicate value in a bitfield: $value"
62	if $already{$value}++;	44✔
63	$ALL \|= ( 0 + $value );	44✔
64	}
65	$opts{ALL} = $ALL;	8✔
66
67	# TODO: ensure all keys in $opt{values} are caps
68
69	$opts{constraint} = sub {
70	not shift() & ~$ALL;	×
71	};	8✔
72
73	# TODO: coercion
74
75	return $proto->SUPER::new( %opts );	8✔
76	} #/ sub new
77
78	sub values {
79	$_[0]{values}
80	}	40✔
81
82	sub _lockdown {
83	my ( $self, $callback ) = @_;	8✔
84	$callback->( $self->{values} );	8✔
85	}
86
87	sub exportables {
88	my ( $self, $base_name ) = @_;	8✔
89	if ( not $self->is_anon ) {	8✔
90	$base_name \|\|= $self->name;	8✔
91	}
92
93	my $exportables = $self->SUPER::exportables( $base_name );	8✔
94
95	require Eval::TypeTiny;	8✔
96	require B;	8✔
97
98	for my $key ( keys %{ $self->values } ) {	8✔
99	my $value = $self->values->{$key};	32✔
100	push @$exportables, {	32✔
101	name => uc( sprintf '%s_%s', $base_name, $key ),
102	tags => [ 'constants' ],
103	code => Eval::TypeTiny::eval_closure(
104	source => sprintf( 'sub () { %d }', $value ),
105	environment => {},
106	),
107	};
108	}
109
110	return $exportables;	8✔
111	}
112
113	sub can_be_inlined {
114	!!1;	32✔
115	}
116
117	sub inline_check {
118	my ( $self, $var ) = @_;	24✔
119
120	return sprintf(
121	'( %s and not %s & ~%d )',
122	Types::Common::Numeric::PositiveOrZeroInt()->inline_check( $var ),
123	$var,
124	$self->{ALL},
125	);	24✔
126	}
127
128	sub AUTOLOAD {
129	my $self = shift;	32✔
130	my ( $m ) = ( our $AUTOLOAD =~ /::(\w+)$/ );	32✔
131	return if $m eq 'DESTROY';	32✔
132	if ( ref $self and exists $self->{values}{$m} ) {	32✔
133	return $self->{values}{$m};	32✔
134	}
135	return $self->SUPER::AUTOLOAD( @_ );	×
136	}
137
138	sub can {
139	my ( $self, $m ) = ( shift, @_ );	8✔
140	if ( ref $self and exists $self->{values}{$m} ) {	8✔
141	return sub () { $self->{values}{$m} };	×
142	}
143	return $self->SUPER::can( @_ );	8✔
144	}
145
146	1;

tobyink / p5-type-tiny / 483e2f609

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous