/ 
HTTP-Headers-Fancy-1.000
River stage one • 2 direct dependents • 2 total dependents
/ HTTP::Headers::Fancy

NAME

HTTP::Headers::Fancy - Fancy naming schema of HTTP headers

VERSION

version 1.000

SYNOPSIS

my %fancy = decode_hash('content-type' => ..., 'x-foo-bar-baf-baz' => ...);
my $content_type = $fancy{ContentType};
my $x_foo_bar_baf_baz = $fancy{-FooBarBafBaz};

my %headers = encode_hash(ContentType => ..., -foo_bar => ...);
# %headers = ('content-type' => ..., 'x-foo-bar' => ...);

DESCRIPTION

This module provides method for renaming HTTP header keys to a lightier, easier-to-use format.

METHODS

new

Creates a new instance of ourself. No options are supported.

my $fancy = HTTP::Headers::Fancy->new;

encode

Wrapper for "encode_hash" or "encode_key", depending on what is given.

$fancy->encode(%hash)    # encode_hash(%hash);
$fancy->encode($hashref) # encode_hash($hashref);
$fancy->encode($scalar)  # encode_key($scalar);

decode

Wrapper for "decode_hash" or "decode_key", depending on what is given

$fancy->decode(%hash)    # decode_hash(%hash);
$fancy->decode($hashref) # decode_hash($hashref);
$fancy->decode($scalar)  # decode_key($scalar);

split

Wrapper for "split_field_list" or "split_field_hash", depending on what is given

$fancy->split(q{"a", "b", "c"}) # split_field_list(...)
$fancy->split(q{W/"a", ...})    # split_field_list(...)
$fancy->split(q{no-cache})      # split_field_hash(...)

Or deflate a HashRef directly:

$headers = $fancy->decode(...);
$fancy->split($headers, qw(CacheControl Etag));
$headers->{CacheControl}->{NoCache};
$headers->{Etag}->[0];

build

Wrapper for "build_field_hash" or "build_field_list"

$fancy->build(NoCache => undef) # build_field_hash(...)
$fancy->build({ ... }) # build_field_hash(...)
$fancy->build([ ... ]) # build_field_list(...)

etags

Wrapper for "build_field_list"

$fancy->build('a', \'b', 'c') # build_field_list(...)

FUNCTIONS

decode_key

Decode original HTTP header name

my $new = decode_key($old);

The header field name will be separated by the dash ('-') sign into pieces. Every piece will be lowercased and the first character uppercased. The pieces will be concatenated.

# Original -> Fancy
# Accept   Accept
# accept   Accept
# aCCEPT   Accept
# Acc-Ept  AccEpt
# Content-Type ContentType
# a-b-c    ABC
# abc      Abc
# a-bc     ABc
# ab-c     AbC

Experimental headers starting with X- will be accessable by a preleading dash sign:

# Original -> Fancy
# x-abc    -Abc

decode_hash

Decode a hash (or HashRef) of HTTP headers and rename the keys

my %new_hash = decode_hash(%old_hash);
my $new_hashref = decode_hash($old_hashref);

encode_key

Encode fancy key name to a valid HTTP header key name

my $new = encode_key($old);

Any uppercase (if not at beginning) will be prepended with a dash sign. Underscores will be replaced by a dash-sign too. The result will be lowercased.

# Fancy -> Original
# FooBar   foo-bar
# foo_bar  foo-bar
# FoOoOoF  fo-oo-oo-f

Experimental headers starting with X- are also createable with a preleading dash sign:

# Fancy -> Original
# -foo     x-foo

encode_hash

Encode a hash (or HashRef) of HTTP headers and rename the keys

Removes also a keypair if a value in undefined.

my %new_hash = encode_hash(%old_hash);
my $new_hashref = encode_hash($old_hashref);

split_field_hash

Split a HTTP header field into a hash with decoding of keys

my %cc = split_field('no-cache, s-maxage=5');
# %cc = (NoCache => undef, SMaxage => 5);

Or deflate fields in a hashref directly:

# First, get a fancy hashref of header fields;
my $headers = decode_hash(...);
# Second deflate the CacheControl field
split_field_hash($headers, qw( CacheControl ));
# Then access the fancy way
$headers->{CacheControl}->{SMaxage};

The first argument has to be a hashref, all other argument a list of fields to be deflated by split_field_hash

split_field_list

Split a field into pieces

my @list = split_field('"a", "b", "c"');
# @list = qw( a b c );

Weak values are stored as ScalarRef

my @list = split_field('"a", W/"b"', W/"c"');
# @list = ('a', \'b', \'c');

Or deflate fields in a hashref directly:

# First, get a fancy hashref of header fields;
my $headers = decode_hash(...);
# Second deflate the Etag field
split_field_list($headers, qw( Etag ));
# Then access the fancy way
$headers->{Etag}->[0];

The first argument has to be a hashref, all other argument a list of fields to be deflated by split_field_list

build_field_hash

The opposite method of "split_field_hash" with encoding of keys.

my $field_value = build_field_hash(NoCache => undef, MaxAge => 3600);
# $field_value = 'no-cache,maxage=3600'

An HashRef as first argument is interpreted as hash

build_field_hash({ NoCache => undef })

build_field_list

Build a list from pieces

my $field_value = build_field_list(qw( a b c ));
# $field_value = '"a", "b", "c"'

ScalarRefs evaluates to a weak value

my $field_value = build_field_list('a', \'b', \'c');
# $field_value = '"a", W/"b", W/"c"';

An ArrayRef as first argument is interpreted as list

build_field_list([ 'a', 'b', ... ])

BUGS

Please report any bugs or feature requests on the bugtracker website https://github.com/zurborg/libhttp-headers-fancy-perl/issues

When submitting a bug or request, please include a test-file or a patch to an existing test-file that illustrates the bug or desired feature.

AUTHOR

David Zurborg <zurborg@cpan.org>

COPYRIGHT AND LICENSE

This software is Copyright (c) 2015 by David Zurborg.

This is free software, licensed under:

The ISC License