lib/WebPAC/Config.pm

package WebPAC::Config;

use warnings;
use strict;

use base qw/WebPAC::Common/;

use Data::Dump qw/dump/;
use YAML qw/LoadFile/;

=head1 NAME

WebPAC::Config - handle WebPAC configuration file

=head1 VERSION

Version 0.02

=cut

our $VERSION = '0.02';

=head1 SYNOPSIS

FIXME

=head1 FUNCTIONS

=head2 new

Create new configuration object.

  my $config = new WebPAC::Config(
        path => '/optional/path/to/config.yml'
  );

=cut

sub new {
        my $class = shift;
        my $self = {@_};
        bless($self, $class);

        my $log = $self->_get_logger();

        if (! $self->{path}) {
                my $hostname = `hostname`;
                chomp($hostname);
                $hostname =~ s/\..+$//;
                if (-e "conf/$hostname.yml") {
                        $self->{path} = "conf/$hostname.yml";
                        $log->info("using host configuration file: ", $self->{path});
                }
        }

        $self->{path} ||= 'conf/config.yml';

        $self->{config} = LoadFile($self->{path}) ||
                $log->logdie("can't open ",$self->{path}, ": $!");

        $log->debug("config: ", dump( $self->{config} ));

        $self ? return $self : return undef;
}

=head2 databases

Return all databases in config

  my $config_databases_hash = $config->databases;
  my @config_databases_names = $config->databases;

=cut

sub databases {
        my $self = shift;
        return unless ($self->{config});
        if (wantarray) {
                return keys %{ $self->{config}->{databases} };
        } else {
                return $self->{config}->{databases};
        }
}

=head2 use_indexer

Which indexer are we using?

  $config->use_indexer;

=cut

sub use_indexer {
        my $self = shift;
        my $default = 'hyperestraier';
        return unless ($self->{config});
        return $self->{config}->{use_indexer} || $default;
}

=head2 get

  $config->get('top-level_key');

=cut

sub get {
        my $self = shift;
        my $what = shift || return;
        return $self->{config}->{$what};
}

=head2 webpac

Return C<< config -> webpac >> parts

  my @supported_inputs = $config->webpac('inputs');
  my $inputs_hash = $config->webpac('inputs');

=cut

sub webpac {
        my $self = shift;

        $self->_get_logger()->logdie("can't find config->webpac") unless defined( $self->{config}->{webpac} );

        my $what = shift || return $self->{config}->{webpac};

        if (wantarray && ref( $self->{config}->{webpac}->{$what} ) eq 'HASH') {
                return keys %{ $self->{config}->{webpac}->{$what} };
        } else {
                return $self->{config}->{webpac}->{$what};
        }

}

=head2 iterate_inputs

  $config->iterate_inputs( sub {
        my ($input, $database, $database_config_hash) = @_;
        # ... do something with input config hash
  } );

This function will also modify C<< $input->{normalize} >> to
be C<ARRAY>, even with just one element.

=cut

sub iterate_inputs {
        my $self = shift;

        my $log = $self->_get_logger();

        my $code_ref = shift;
        $log->logdie("called with CODE") unless ( ref($code_ref) eq 'CODE' );

        while (my ($database, $db_config) = each %{ $self->{config}->{databases} }) {
                my @inputs;
                if (ref($db_config->{input}) eq 'ARRAY') {
                        @inputs = @{ $db_config->{input} };
                } elsif ($db_config->{input}) {
                        push @inputs, $db_config->{input};
                } else {
                        $log->info("database $database doesn't have inputs defined");
                }

                foreach my $input (@inputs) {
                        $log->debug("iterating over input ", dump($input));
                        if ( defined( $input->{normalize} ) && ref($input->{normalize}) ne 'ARRAY' ) {
                                $input->{normalize} = [ $input->{normalize} ];
                        }
                        $code_ref->($input, $database, $db_config);
                }
        }

}


=head1 AUTHOR

Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>

=head1 COPYRIGHT & LICENSE

Copyright 2006 Dobrica Pavlinusic, All Rights Reserved.

This program is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

=cut

1; # End of WebPAC::Config
1	dpavlin	681	package WebPAC::Config;
2
3			use warnings;
4			use strict;
5
6			use base qw/WebPAC::Common/;
7
8			use Data::Dump qw/dump/;
9			use YAML qw/LoadFile/;
10
11			=head1 NAME
12
13			WebPAC::Config - handle WebPAC configuration file
14
15			=head1 VERSION
16
17	dpavlin	688	Version 0.02
18	dpavlin	681
19			=cut
20
21	dpavlin	688	our $VERSION = '0.02';
22	dpavlin	681
23			=head1 SYNOPSIS
24
25			FIXME
26
27			=head1 FUNCTIONS
28
29			=head2 new
30
31			Create new configuration object.
32
33	dpavlin	685	my $config = new WebPAC::Config(
34			path => '/optional/path/to/config.yml'
35			);
36
37	dpavlin	681	=cut
38
39			sub new {
40			my $class = shift;
41			my $self = {@_};
42			bless($self, $class);
43
44			my $log = $self->_get_logger();
45
46			if (! $self->{path}) {
47			my $hostname = `hostname`;
48			chomp($hostname);
49			$hostname =~ s/\..+$//;
50			if (-e "conf/$hostname.yml") {
51			$self->{path} = "conf/$hostname.yml";
52			$log->info("using host configuration file: ", $self->{path});
53			}
54			}
55
56			$self->{path} \|\|= 'conf/config.yml';
57
58			$self->{config} = LoadFile($self->{path}) \|\|
59			$log->logdie("can't open ",$self->{path}, ": $!");
60
61			$log->debug("config: ", dump( $self->{config} ));
62
63			$self ? return $self : return undef;
64			}
65
66			=head2 databases
67
68	dpavlin	685	Return all databases in config
69
70	dpavlin	681	my $config_databases_hash = $config->databases;
71			my @config_databases_names = $config->databases;
72
73			=cut
74
75			sub databases {
76			my $self = shift;
77			return unless ($self->{config});
78			if (wantarray) {
79			return keys %{ $self->{config}->{databases} };
80			} else {
81			return $self->{config}->{databases};
82			}
83			}
84
85			=head2 use_indexer
86
87	dpavlin	685	Which indexer are we using?
88
89	dpavlin	681	$config->use_indexer;
90
91			=cut
92
93			sub use_indexer {
94			my $self = shift;
95			my $default = 'hyperestraier';
96			return unless ($self->{config});
97			return $self->{config}->{use_indexer} \|\| $default;
98			}
99
100	dpavlin	682	=head2 get
101
102			$config->get('top-level_key');
103
104			=cut
105
106			sub get {
107			my $self = shift;
108			my $what = shift \|\| return;
109			return $self->{config}->{$what};
110			}
111
112			=head2 webpac
113
114			Return C<< config -> webpac >> parts
115
116			my @supported_inputs = $config->webpac('inputs');
117			my $inputs_hash = $config->webpac('inputs');
118
119			=cut
120
121			sub webpac {
122			my $self = shift;
123
124			$self->_get_logger()->logdie("can't find config->webpac") unless defined( $self->{config}->{webpac} );
125
126			my $what = shift \|\| return $self->{config}->{webpac};
127
128	dpavlin	683	if (wantarray && ref( $self->{config}->{webpac}->{$what} ) eq 'HASH') {
129	dpavlin	682	return keys %{ $self->{config}->{webpac}->{$what} };
130			} else {
131			return $self->{config}->{webpac}->{$what};
132			}
133
134			}
135
136	dpavlin	685	=head2 iterate_inputs
137
138			$config->iterate_inputs( sub {
139	dpavlin	688	my ($input, $database, $database_config_hash) = @_;
140	dpavlin	685	# ... do something with input config hash
141			} );
142
143	dpavlin	700	This function will also modify C<< $input->{normalize} >> to
144			be C<ARRAY>, even with just one element.
145
146	dpavlin	685	=cut
147
148			sub iterate_inputs {
149			my $self = shift;
150
151			my $log = $self->_get_logger();
152
153			my $code_ref = shift;
154			$log->logdie("called with CODE") unless ( ref($code_ref) eq 'CODE' );
155
156			while (my ($database, $db_config) = each %{ $self->{config}->{databases} }) {
157			my @inputs;
158			if (ref($db_config->{input}) eq 'ARRAY') {
159			@inputs = @{ $db_config->{input} };
160			} elsif ($db_config->{input}) {
161			push @inputs, $db_config->{input};
162			} else {
163			$log->info("database $database doesn't have inputs defined");
164			}
165
166			foreach my $input (@inputs) {
167			$log->debug("iterating over input ", dump($input));
168	dpavlin	700	if ( defined( $input->{normalize} ) && ref($input->{normalize}) ne 'ARRAY' ) {
169			$input->{normalize} = [ $input->{normalize} ];
170			}
171	dpavlin	688	$code_ref->($input, $database, $db_config);
172	dpavlin	685	}
173			}
174
175			}
176
177
178	dpavlin	681	=head1 AUTHOR
179
180			Dobrica Pavlinusic, C<< <dpavlin@rot13.org> >>
181
182			=head1 COPYRIGHT & LICENSE
183
184			Copyright 2006 Dobrica Pavlinusic, All Rights Reserved.
185
186			This program is free software; you can redistribute it and/or modify it
187			under the same terms as Perl itself.
188
189			=cut
190
191			1; # End of WebPAC::Config