lib/Perl/Tidy/VerticalAligner/Line.pm

   1 #####################################################################
   2 #
   3 # the Perl::Tidy::VerticalAligner::Line class supplies an object to
   4 # contain a single output line
   5 #
   6 #####################################################################
   7
   8 package Perl::Tidy::VerticalAligner::Line;
   9 use strict;
  10 use warnings;
  11 our $VERSION = '20181120';
  12
  13 {
  14
  15     ##use Carp;
  16
  17     my %default_data = (
  18         jmax                      => undef,
  19         jmax_original_line        => undef,
  20         rtokens                   => undef,
  21         rfields                   => undef,
  22         rpatterns                 => undef,
  23         indentation               => undef,
  24         leading_space_count       => undef,
  25         outdent_long_lines        => undef,
  26         list_type                 => undef,
  27         is_hanging_side_comment   => undef,
  28         ralignments               => [],
  29         maximum_line_length       => undef,
  30         rvertical_tightness_flags => undef
  31     );
  32     {
  33
  34         # methods to count object population
  35         my $_count = 0;
  36         sub get_count        { return $_count; }
  37         sub _increment_count { return ++$_count }
  38         sub _decrement_count { return --$_count }
  39     }
  40
  41     # Constructor may be called as a class method
  42     sub new {
  43         my ( $caller, %arg ) = @_;
  44         my $caller_is_obj = ref($caller);
  45         my $class         = $caller_is_obj || $caller;
  46         ##no strict "refs";
  47         my $self = bless {}, $class;
  48
  49         $self->{_ralignments} = [];
  50
  51         foreach my $key ( keys %default_data ) {
  52             my $_key = '_' . $key;
  53
  54             # Caller keys do not have an underscore
  55             if    ( exists $arg{$key} ) { $self->{$_key} = $arg{$key} }
  56             elsif ($caller_is_obj)      { $self->{$_key} = $caller->{$_key} }
  57             else { $self->{$_key} = $default_data{$_key} }
  58         }
  59
  60         $self->_increment_count();
  61         return $self;
  62     }
  63
  64     sub DESTROY {
  65         my $self = shift;
  66         $self->_decrement_count();
  67         return;
  68     }
  69
  70     sub get_jmax { my $self = shift; return $self->{_jmax} }
  71
  72     sub get_jmax_original_line {
  73         my $self = shift;
  74         return $self->{_jmax_original_line};
  75     }
  76     sub get_rtokens     { my $self = shift; return $self->{_rtokens} }
  77     sub get_rfields     { my $self = shift; return $self->{_rfields} }
  78     sub get_rpatterns   { my $self = shift; return $self->{_rpatterns} }
  79     sub get_indentation { my $self = shift; return $self->{_indentation} }
  80
  81     sub get_leading_space_count {
  82         my $self = shift;
  83         return $self->{_leading_space_count};
  84     }
  85
  86     sub get_outdent_long_lines {
  87         my $self = shift;
  88         return $self->{_outdent_long_lines};
  89     }
  90     sub get_list_type { my $self = shift; return $self->{_list_type} }
  91
  92     sub get_is_hanging_side_comment {
  93         my $self = shift;
  94         return $self->{_is_hanging_side_comment};
  95     }
  96
  97     sub get_rvertical_tightness_flags {
  98         my $self = shift;
  99         return $self->{_rvertical_tightness_flags};
 100     }
 101
 102     sub set_column {
 103         ## FIXME: does caller ever supply $val??
 104         my ( $self, $j, $val ) = @_;
 105         return $self->{_ralignments}->[$j]->set_column($val);
 106     }
 107
 108     sub get_alignment {
 109         my ( $self, $j ) = @_;
 110         return $self->{_ralignments}->[$j];
 111     }
 112     sub get_alignments { my $self = shift; return @{ $self->{_ralignments} } }
 113
 114     sub get_column {
 115         my ( $self, $j ) = @_;
 116         return $self->{_ralignments}->[$j]->get_column();
 117     }
 118
 119     sub get_starting_column {
 120         my ( $self, $j ) = @_;
 121         return $self->{_ralignments}->[$j]->get_starting_column();
 122     }
 123
 124     sub increment_column {
 125         my ( $self, $k, $pad ) = @_;
 126         $self->{_ralignments}->[$k]->increment_column($pad);
 127         return;
 128     }
 129
 130     sub set_alignments {
 131         my ( $self, @args ) = @_;
 132         @{ $self->{_ralignments} } = @args;
 133         return;
 134     }
 135
 136     sub current_field_width {
 137         my ( $self, $j ) = @_;
 138         if ( $j == 0 ) {
 139             return $self->get_column($j);
 140         }
 141         else {
 142             return $self->get_column($j) - $self->get_column( $j - 1 );
 143         }
 144     }
 145
 146     sub field_width_growth {
 147         my ( $self, $j ) = @_;
 148         return $self->get_column($j) - $self->get_starting_column($j);
 149     }
 150
 151     sub starting_field_width {
 152         my ( $self, $j ) = @_;
 153         if ( $j == 0 ) {
 154             return $self->get_starting_column($j);
 155         }
 156         else {
 157             return $self->get_starting_column($j) -
 158               $self->get_starting_column( $j - 1 );
 159         }
 160     }
 161
 162     sub increase_field_width {
 163
 164         my ( $self, $j, $pad ) = @_;
 165         my $jmax = $self->get_jmax();
 166         for my $k ( $j .. $jmax ) {
 167             $self->increment_column( $k, $pad );
 168         }
 169         return;
 170     }
 171
 172     sub get_available_space_on_right {
 173         my $self = shift;
 174         my $jmax = $self->get_jmax();
 175         return $self->{_maximum_line_length} - $self->get_column($jmax);
 176     }
 177
 178     sub set_jmax { my ( $self, $val ) = @_; $self->{_jmax} = $val; return }
 179
 180     sub set_jmax_original_line {
 181         my ( $self, $val ) = @_;
 182         $self->{_jmax_original_line} = $val;
 183         return;
 184     }
 185
 186     sub set_rtokens {
 187         my ( $self, $val ) = @_;
 188         $self->{_rtokens} = $val;
 189         return;
 190     }
 191
 192     sub set_rfields {
 193         my ( $self, $val ) = @_;
 194         $self->{_rfields} = $val;
 195         return;
 196     }
 197
 198     sub set_rpatterns {
 199         my ( $self, $val ) = @_;
 200         $self->{_rpatterns} = $val;
 201         return;
 202     }
 203
 204     sub set_indentation {
 205         my ( $self, $val ) = @_;
 206         $self->{_indentation} = $val;
 207         return;
 208     }
 209
 210     sub set_leading_space_count {
 211         my ( $self, $val ) = @_;
 212         $self->{_leading_space_count} = $val;
 213         return;
 214     }
 215
 216     sub set_outdent_long_lines {
 217         my ( $self, $val ) = @_;
 218         $self->{_outdent_long_lines} = $val;
 219         return;
 220     }
 221
 222     sub set_list_type {
 223         my ( $self, $val ) = @_;
 224         $self->{_list_type} = $val;
 225         return;
 226     }
 227
 228     sub set_is_hanging_side_comment {
 229         my ( $self, $val ) = @_;
 230         $self->{_is_hanging_side_comment} = $val;
 231         return;
 232     }
 233
 234     sub set_alignment {
 235         my ( $self, $j, $val ) = @_;
 236         $self->{_ralignments}->[$j] = $val;
 237         return;
 238     }
 239
 240 }
 241
 242 1;
 243