view release on metacpan or  search on metacpan

lib/Email/MIME/CreateHTML.pm  view on Meta::CPAN

A scalar value holding the HTML message body.

=item body_attributes =E<gt> I<hash reference>

This is passed as the attributes parameter to the C<create> method (supplied by C<Email::MIME::Creator>) that creates the html part of the mail.
The body content-type will be set to C<text/html> unless it is overidden here.

=item embed =E<gt> I<boolean>

Attach relative images and other media to the message. This is enabled by default.
The module will attempt to embed objects defined by C<embed_elements>.

 view release on metacpan or  search on metacpan

lib/Email/MIME/MobileJP/Parser.pm  view on Meta::CPAN

    }
}

sub get_parts {
    my ($self, $content_type) = @_;
    Carp::croak("missing content-type") unless defined $content_type;

    my @parts;
    $self->mail->walk_parts(sub {
        my $part = shift;
        return if $part->parts > 1; # multipart

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

	- fixed bug when Content-Type is not specified; and default to text/plain
	  (and do not base64-encode body text)

0.38	Mon Jul  4 19:22:27 CEST 2005

	- fixed bug in _XMLbodyEncode() to make content-type checking
	  case insensistive
	- added POD patches as reported by Mike Castel <dalgoda@ix.netcom.com>

0.37	Tue May 24 01:42:29 CEST 2005

 view release on metacpan or  search on metacpan

t/full_structure.t  view on Meta::CPAN

  my $m = shift;

  my @names = sort grep(!/^content-id$/, map {lc $_} $m->header_names);
  my @arr = map {
    my @h = map { $_ =~ s/\s\s*/ /sg; $_ } sort $m->header($_);
    @h = map { sanitize_content_type($_) } @h if lc $_ eq 'content-type';
    @h = map { sanitize_content_disposition($_) } @h if lc $_ eq 'content-disposition';
    $_ . ": " . join "\n", @h;
  } @names;
  return \@arr;
}

 view release on metacpan or  search on metacpan

t/test.t  view on Meta::CPAN

]);

is($complex->parts, 2, "one reply part, one original part");

like(
  ($complex->parts)[1]->header('content-type'),
  qr{^message/rfc822},
  'the second part is the original, rfc822-style',
);

like $complex->header('from'), qr/human\@earth\.sol/, "correct from";

 view release on metacpan or  search on metacpan

lib/Email/Send/Netease.pm  view on Meta::CPAN

        Type     => 'text/html',
        Data     => $html_body,
        Encoding => 'base64',
    ) or croak "create container failed: $!";

    $msg->attr('content-type.charset' => 'UTF-8');
    $msg->send(  'smtp',
                 $smtpsvr,
                 AuthUser=>$user,
                 AuthPass=>$self->{passwd},
                 Debug=>$self->{debug}

 view release on metacpan or  search on metacpan

lib/Email/Send/YYClouds.pm  view on Meta::CPAN

        Subject => encode( 'MIME-Header', $subject ),
        Data    => encode_utf8($body),
        Encoding => 'quoted-printable',
    ) or die "create container failed: $!";

    $msg->attr('content-type.charset' => 'UTF-8');

    $msg->send(  'smtp',
                 $smtprelay,
                 Debug => $self->{debug}
              );

 view release on metacpan or  search on metacpan

lib/Email/Send/Zoho.pm  view on Meta::CPAN

        Type     => 'text/html',
        Data     => $html_body,
        Encoding => 'base64',
    ) or croak "create container failed: $!";

    $msg->attr('content-type.charset' => 'UTF-8');
    $msg->send('smtp',
               'smtp.zoho.com',
                Port => 465,
                AuthUser => $from_address,
                AuthPass => $self->{passwd},

 view release on metacpan or  search on metacpan

t/send.t  view on Meta::CPAN

        my $request = { headers => {} };

        # https://github.com/chansen/p5-http-tiny/blob/ce7583b7ea85abf69282f89746248c3a5e1e961a/lib/HTTP/Tiny.pm#L815
        if ( defined $args->{content} ) {
            if (ref $args->{content} eq 'CODE') {
                $request->{headers}{'content-type'} ||= "application/octet-stream";
                $request->{headers}{'transfer-encoding'} = 'chunked'
                    unless $request->{headers}{'content-length'}
                        || $request->{headers}{'transfer-encoding'};
                $request->{cb} = $args->{content};
            }

t/send.t  view on Meta::CPAN

                my $content = $args->{content};
                if ( $] ge '5.008' ) {
                    utf8::downgrade($content, 1)
                        or die(qq/Wide character in request message body\n/);
                }
                $request->{headers}{'content-type'} ||= "application/octet-stream";
                $request->{headers}{'content-length'} = length $content
                    unless $request->{headers}{'content-length'}
                        || $request->{headers}{'transfer-encoding'};
                $request->{cb} = sub { substr $content, 0, length $content, '' };
            }

 view release on metacpan or  search on metacpan

t/success.t  view on Meta::CPAN

is($result->id, $id, 'Return id correct');

my $req = shift @requests;
is($req->{method}, 'POST', 'POST method');
is($req->{uri}, "$proto://api:$api_key\@$host/$domain/messages.mime", 'URI ok');
like($req->{data}->{headers}->{'content-type'}, qr{^multipart/form-data},
        'Used multipart/form-data');

sub body {
    return (@_ > 1) ?  [ map { body($_) } @_ ] : { body => $_[0] };
}

 view release on metacpan or  search on metacpan

t/preserve-linefeed.t  view on Meta::CPAN

use_ok( 'Email::Simple' );

my $original = <<'EOM';
subject:
 =?utf-8?B?ZGVsLmljaW8udXMvbmV0d29yay9qb2VlIC0gW2Zyb20gbWlqaXRdIEJMQiBFY2MgMw==?=
content-type: text/plain

empty body
EOM

my $mail = Email::Simple->new( $original );

 view release on metacpan or  search on metacpan

webdemo/test_site/pod.html  view on Meta::CPAN

<?xml version="1.0" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>WebIT</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<link rev="made" href="mailto:root@localhost" />
</head>

<body style="background-color: white">

 view release on metacpan or  search on metacpan

htdocs/index.html  view on Meta::CPAN

<html>
<head>
   <meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
   <style type="text/css">
   <!-- 
   a:link    {text-decoration:none}
   a:visited {text-decoration:none}
   a:active  {text-decoration:none} 

 view release on metacpan or  search on metacpan

Embperl/Syntax/Mail.pm  view on Meta::CPAN

    {
    my ($self) = @_ ;

    $self -> AddTagBlock ('mail:send', ['from', 'to', 'cc', 'bcc', 'subject', 'reply-to', 
                                        'mailhost', 'mailhelo', 'maildebug', 'content-type'], 
                                        undef, undef, 
                { 
                removenode  =>  106,
		compiletimeperlcode => q{
			$_ep_mail_opt_save = $Embperl::req->component->config->options ;

Embperl/Syntax/Mail.pm  view on Meta::CPAN

                        'subject'     => %&'subject%,
                        'reply-to'    => %&'reply-to%,
                        'mailhost'    => %&'mailhost%,
                        'mailhelo'    => %&'mailhelo%,
                        'maildebug'   => %&'maildebug%,
                        'mailheaders' => [ (( %&'content-type% ) ? ('Content-Type: '.%&'content-type%) : ()) ],
                        }) ;
                    print STDERR join ('; ', @errors) if (@errors) ;
                    }
                  },
                stackname   => 'mail_send',

Embperl/Syntax/Mail.pm  view on Meta::CPAN

=item mailhelo   

=item maildebug  

=item content-type

=back


On success it sets C<$?> to zero, otherwise to a value other then zero.

 view release on metacpan or  search on metacpan

t/basic.t  view on Meta::CPAN

    [{"Set-Cookie", "foo"}, {"Set-Cookie", "bar"}] = ?MODULE:to_list(H3),
    "foo, bar" = ?MODULE:get_value("set-cookie", H3),
    {value, {"Set-Cookie", "foo, bar"}} = ?MODULE:lookup("set-cookie", H3),
    undefined = ?MODULE:get_value("shibby", H3),
    none = ?MODULE:lookup("shibby", H3),
    H4 = ?MODULE:insert("content-type",
                        "application/x-www-form-urlencoded; charset=utf8",
                        H3),
    "application/x-www-form-urlencoded" = ?MODULE:get_primary_value(
                                             "content-type", H4),
    H4 = ?MODULE:delete_any("nonexistent-header", H4),
    H3 = ?MODULE:delete_any("content-type", H4),
    HB = <<"Content-Length: 47\r\nContent-Type: text/plain\r\n\r\n">>,
    H_HB = ?MODULE:from_binary(HB),
    H_HB = ?MODULE:from_binary(binary_to_list(HB)),
    "47" = ?MODULE:get_value("Content-Length", H_HB),
    "text/plain" = ?MODULE:get_value("Content-Type", H_HB),

t/basic.t  view on Meta::CPAN

        undefined ->
            fun (Next) ->
                    parse_form_value(Next, {Name, []}, FileHandler, State)
            end;
        _ ->
            ContentType = proplists:get_value("content-type", H),
            Handler = FileHandler(Filename, ContentType),
            fun (Next) ->
                    parse_form_file(Next, {Name, Handler}, FileHandler, State)
            end
    end.

t/basic.t  view on Meta::CPAN

parse_multipart_request(Req, Callback) ->
    %% TODO: Support chunked?
    Length = list_to_integer(Req:get_header_value("content-length")),
    Boundary = iolist_to_binary(
                 get_boundary(Req:get_header_value("content-type"))),
    Prefix = <<"\r\n--", Boundary/binary>>,
    BS = byte_size(Boundary),
    Chunk = read_chunk(Req, Length),
    Length1 = Length - byte_size(Chunk),
    <<"--", Boundary:BS/binary, "\r\n", Rest/binary>> = Chunk,

t/basic.t  view on Meta::CPAN

    mochiweb_request:new(Socket,
                         'POST',
                         "/multipart",
                         {1,1},
                         mochiweb_headers:make(
                           [{"content-type", ContentType},
                            {"content-length", Length}])).

test_callback({body, <<>>}, Rest=[body_end | _]) ->
    %% When expecting the body_end we might get an empty binary
    fun (Next) -> test_callback(Next, Rest) end;

t/basic.t  view on Meta::CPAN

              {body, <<"multipart message">>},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "file"}, {"filename", "test_file.txt"}]}},
                {"content-type", {"text/plain", []}}]},
              {body, <<"Woo multiline text file\n\nLa la la">>},
              body_end,
              eof],
    TestCallback = fun (Next) -> test_callback(Next, Expect) end,
    ServerFun = fun (Socket) ->

t/basic.t  view on Meta::CPAN

              {body, <<"multipart message">>},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "file"}, {"filename", ""}]}},
                {"content-type", {"application/octet-stream", []}}]},
              {body, <<>>},
              body_end,
              eof],
    TestCallback = fun (Next) -> test_callback(Next, Expect) end,
    ServerFun = fun (Socket) ->

t/basic.t  view on Meta::CPAN

              {body, <<"Larry">>},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "files"}, {"filename", "file1.txt"}]}},
                 {"content-type", {"text/plain", []}}]},
              {body, <<"... contents of file1.txt ...">>},
              body_end,
              eof],
    TestCallback = fun (Next) -> test_callback(Next, Expect) end,
    ServerFun = fun (Socket) ->

t/basic.t  view on Meta::CPAN

              {body, <<"Larry">>},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "files"}, {"filename", "file1.txt"}]}},
                {"content-type", {"text/plain", []}}
               ]},
              {body, <<"... contents of file1.txt ...">>},
              body_end,
              eof],
    TestCallback = fun (Next) -> test_callback(Next, Expect) end,

t/basic.t  view on Meta::CPAN

              {body, <<"Larry">>},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "files"}, {"filename", "file1.txt"}]}},
                {"content-type", {"text/plain", []}},
                {"x-large-header", {string:copies("%", 4096), []}}
               ]},
              {body, <<"... contents of file1.txt ...">>},
              body_end,
              eof],

t/basic.t  view on Meta::CPAN

              {body, <<"201">>},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "file"}, {"filename", "hello.txt"}]}},
                {"content-type", {"application/octet-stream", []}}]},
              {body, <<"hello\n">>},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "Upload"}]}}]},

t/basic.t  view on Meta::CPAN

              {body, <<"201">>},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "file"}, {"filename", "hello.txt"}]}},
                {"content-type", {"application/octet-stream", []}}]},
              {body, Chunk},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "Upload"}]}}]},

t/basic.t  view on Meta::CPAN

              {body, <<"201">>},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "file"}, {"filename", "hello.txt"}]}},
                {"content-type", {"application/octet-stream", []}}]},
              {body, Chunk},
              body_end,
              {headers,
               [{"content-disposition",
                 {"form-data", [{"name", "Upload"}]}}]},

t/basic.t  view on Meta::CPAN

        undefined ->
            Parsed = case recv_body() of
                         undefined ->
                             [];
                         Binary ->
                             case get_primary_header_value("content-type") of
                                 "application/x-www-form-urlencoded" ++ _ ->
                                     mochiweb_util:parse_qs(Binary);
                                 _ ->
                                     []
                             end

 view release on metacpan or  search on metacpan

lib/Eve/HttpResource/Template.pm  view on Meta::CPAN

(optional) if a user is not authenticated, throw a
C<Eve::Exception::Http::401Unauthorized>,

=item C<content_type>

(optional) response content-type, defaults to C<text/html>,

=item C<charset>

(optional) response character set, defaults to C<UTF-8>.

 view release on metacpan or  search on metacpan

lib/EveOnline/SSO/Client.pm  view on Meta::CPAN

        $body = $json->encode( $params );

        $request->content( $body );
    }
    $request->header( 'content-type'   => 'application/json; charset=UTF-8' );
    $request->header( 'content-length' => length( $body ) );
    $request->header( 'X-User-Agent'   => $self->x_user_agent );
    $request->header( 'Authorization'  => 'Bearer ' . $self->token );

    return 1;

 view release on metacpan or  search on metacpan

lib/Excel/ValueWriter/XLSX.pm  view on Meta::CPAN

  my @tables_xml
    = map {qq{  <Override PartName="/xl/tables/table$_.xml" ContentType="$spreadsheetml.table+xml"/>}} 1 .. $self->n_tables;

  my @xml = (
    qq{<?xml version="1.0" encoding="UTF-8" standalone="yes"?>},
    qq{<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">},
    qq{<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>},
    qq{<Default Extension="xml" ContentType="application/xml"/>},
    qq{<Override PartName="/xl/workbook.xml" ContentType="$spreadsheetml.sheet.main+xml"/>},
    qq{<Override PartName="/xl/styles.xml" ContentType="$spreadsheetml.styles+xml"/>},
    qq{<Override PartName="/xl/sharedStrings.xml" ContentType="$spreadsheetml.sharedStrings+xml"/>},

 view release on metacpan or  search on metacpan

lib/Excel/Writer/XLSX/Package/ContentTypes.pm  view on Meta::CPAN

#
sub _add_vba_project {

    my $self = shift;

    # Change the workbook.xml content-type from xlsx to xlsm.
    for my $aref ( @{ $self->{_overrides} } ) {
        if ( $aref->[0] eq '/xl/workbook.xml' ) {
            $aref->[1] = 'application/vnd.ms-excel.sheet.macroEnabled.main+xml';
        }
    }

lib/Excel/Writer/XLSX/Package/ContentTypes.pm  view on Meta::CPAN

# Write the <Types> element.
#
sub _write_types {

    my $self  = shift;
    my $xmlns = 'http://schemas.openxmlformats.org/package/2006/content-types';

    my @attributes = ( 'xmlns' => $xmlns, );

    $self->xml_start_tag( 'Types', @attributes );
}

 view release on metacpan or  search on metacpan

public/javascripts/vendor/jquery/jquery-1.7.2.min.js  view on Meta::CPAN

	/*! jQuery v1.7.2 jquery.com | jquery.org/license */
(function(a,b){function cy(a){return f.isWindow(a)?a:a.nodeType===9?a.defaultView||a.parentWindow:!1}function cu(a){if(!cj[a]){var b=c.body,d=f("<"+a+">").appendTo(b),e=d.css("display");d.remove();if(e==="none"||e===""){ck||(ck=c.createElement("ifram...
a){var b=F.exec(a);b&&(b[1]=(b[1]||"").toLowerCase(),b[3]=b[3]&&new RegExp("(?:^|\\s)"+b[3]+"(?:\\s|$)"));return b},H=function(a,b){var c=a.attributes||{};return(!b[1]||a.nodeName.toLowerCase()===b[1])&&(!b[2]||(c.id||{}).value===b[2])&&(!b[3]||b[3]....
.clean(arguments);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,!1,function(a){this.parentNode.insertBefore(a,this.nextSibling)});if(argumen...

 view release on metacpan or  search on metacpan

bin/fb3_to_fb2.pl  view on Meta::CPAN

  $Img->{NewId} = $ImgRels{$Img->{'Id'}} = $NewImgId;

  next if exists $ImgReverse{$NewImgId}; #иногда описания картинок совпадают. например обложка залетает дважды из описаний
  $ImgReverse{$NewImgId} = 1;

  push @FB2ImgXML, '<binary content-type="'.$ImgType.'" id="'.$NewImgId.'">'.MIME::Base64::encode($ImgContent).'</binary>';
}

#работаем с DESCRIPTION
my $DescrXML = $FB3Package->PartContents($DescrRelsPartName);
my $xc = XML::LibXML::XPathContext->new($Parser->parse_string($DescrXML)); 

 view release on metacpan or  search on metacpan

share/FictionBook.xsd  view on Meta::CPAN

            <xs:documentation>Any binary data that is required for the presentation of this book in base64 format. Currently only images are used.</xs:documentation>
          </xs:annotation>
          <xs:complexType>
            <xs:simpleContent>
              <xs:extension base="xs:base64Binary">
                <xs:attribute name="content-type" type="xs:string" use="required"/>
                <xs:attribute name="id" type="xs:ID" use="required"/>
              </xs:extension>
            </xs:simpleContent>
          </xs:complexType>
        </xs:element>

 view release on metacpan or  search on metacpan

lib/FCGI/Buffer.pm  view on Meta::CPAN

	my $self = shift;
	my $headers = shift;

	foreach my $header (split(/\r?\n/, $headers)) {
		my ($header_name, $header_value) = split /\:\s*/, $header, 2;
		if(lc($header_name) eq 'content-type') {
			my @content_type = split /\//, $header_value, 2;
			$self->{content_type} = \@content_type;
			return;
		}
	}

 view release on metacpan or  search on metacpan

lib/FCGI/IIS.pm  view on Meta::CPAN

With this mode eval is used instead of the do operator. Slower run time, but allows 
you to trap errors.

=item perl -MFCGI::IIS=evalhead

With this mode eval is used instead of the do operator, also the content-type 
text/html header is returned first. Allowing you to trap wrong header errors.

=item perl -MFCGI::IIS=do

This is the default mode, and will be called if no arguments are given, i.e. 

 view release on metacpan or  search on metacpan

FU.pm  view on Meta::CPAN

    log_write(sprintf "%.0fms%s %s-%s %d-%s\n", $proc_ms,
        $REQ->{trace_nsql} ?
            sprintf ' (sql %.0f+%.0fms, %d/%d/%d)',
            ($REQ->{trace_sqlexec}||0)*1000, ($REQ->{trace_sqlprep}||0)*1000,
            $REQ->{trace_nsqldirect}||0, $REQ->{trace_nsqlprep}||0, $REQ->{trace_nsql} : '',
        $REQ->{status}, ($REQ->{reshdr}{'content-type'}//'-') =~ s/;.+$//r,
        length($REQ->{resbody}), substr($REQ->{reshdr}{'content-encoding'}//'r', 0, 1)
    ) if FU::debug || $proc_ms > (FU::log_slow_reqs||1e10);
}

FU.pm  view on Meta::CPAN

    _getfield $FU::REQ->{cookie}, @_;
}

sub json {
    shift;
    fu->error(400, "Invalid content type for json") if (fu->header('content-type')||'') !~ m{^application/json(?:;\s*charset=utf-?8)?$}i;
    return FU::Util::utf8_decode(my $x = $FU::REQ->{body}) if !@_;
    $FU::REQ->{json} ||= eval {
        FU::Util::json_parse($FU::REQ->{body}, utf8 => 1)
    } || fu->error(400, "JSON parse error: $@");
    _getfield $FU::REQ->{json}, @_;
}

sub formdata {
    shift;
    fu->error(400, "Invalid content type for form data") if (fu->header('content-type')||'') ne 'application/x-www-form-urlencoded';
    return FU::Util::utf8_decode(my $x = $FU::REQ->{body}) if !@_;
    $FU::REQ->{formdata} ||= eval {
        FU::Util::query_decode($FU::REQ->{body});
    } || fu->error(400, $@);
    _getfield $FU::REQ->{formdata}, @_;
}

sub multipart {
    require FU::MultipartFormData;
    $FU::REQ->{multipart} ||= eval {
        FU::MultipartFormData->parse(fu->header('content-type')||'', $FU::REQ->{body})
    } || fu->error(400, $@);
}

FU.pm  view on Meta::CPAN

sub reset {
    fu->status(200);
    fu->set_body('');
    $FU::REQ->{reshdr} = {
        'content-type', 'text/html',
    };
    delete $FU::REQ->{rescookie};
}

FU.pm  view on Meta::CPAN

    }
    $FU::REQ->{rescookie}{$name} = $c;
}

sub send_json($, $data) {
    fu->set_header('content-type', 'application/json');
    fu->set_body(FU::Util::json_format($data, canonical => 1, utf8 => 1));
    fu->done;
}

sub send_file($, $root, $path) {

FU.pm  view on Meta::CPAN

        local $/=undef;
        my $body = <$fh>;
        $ctype ||= substr($body, 0, 1024) =~ /[\x00-\x08\x0e-\x1f]/ ? 'application/octet-stream' : 'text/plain';
        fu->set_body($body);
    }
    fu->set_header('content-type', $ctype);
    fu->done;
}

sub redirect($, $code, $location) {
    state $alias = {qw/ perm 301  temp 302  tempget 303  tempsame 307  permsame 308 /};
    fu->status($alias->{$code} // $code);
    fu->set_header(location => "$location");
    fu->set_header('content-type', 'text/plain');
    fu->set_body("Redirecting to $location\n");
    fu->done;
}

sub _error_page($, $code, $title, $msg) {

FU.pm  view on Meta::CPAN

    fu->add_header('set-cookie', $_) for $r->{rescookie} ? sort values $r->{rescookie}->%* : ();

    if ($r->{status} == 204 || $r->{status} == 304) {
        delete $r->{reshdr}{'content-length'};
        delete $r->{reshdr}{'content-encoding'};
        delete $r->{reshdr}{'content-type'};
        $r->{resbody} = '';

    } else {
        my @vary = ref $r->{reshdr}{vary} eq 'ARRAY' ? $r->{reshdr}{vary}->@* : defined $r->{reshdr}{vary} ? ($r->{reshdr}{vary}) : ();
        if (($hasgzip || $hasbrotli) && length($r->{resbody}) > 256
                && !defined $r->{reshdr}{'content-encoding'}
                && FU::compress_mimes->{$r->{reshdr}{'content-type'}}
        ) {
            push @vary, 'accept-encoding';
            if ($hasbrotli && ($r->{hdr}{'accept-encoding'}||'') =~ /\bbr\b/) {
                $r->{resbody_orig} = $r->{resbody};
                $r->{resbody} = FU::Util::brotli_compress(6, $r->{resbody});

FU.pm  view on Meta::CPAN

        $r->{reshdr}{vary} = @vary ? join ', ', @vary : undef;
        $r->{reshdr}{'content-length'} = length $r->{resbody};
        $r->{resbody} = '' if (fu->method//'') eq 'HEAD';
    }

    $r->{reshdr}{'content-type'} .= '; charset=UTF-8' if FU::utf8_mimes->{ $r->{reshdr}{'content-type'}||'' };
}

sub _flush($, $sock) {
    _finalize;

FU.pm  view on Meta::CPAN

This method loads the entire file contents in memory and does not support range
requests, so DO NOT use it to send large files. Actual web servers are much
more efficient at serving static files.

The content-type header is determined from the file extension in C<$path>,
using the configured C<FU::mime_types>. As fallback, files that look like they
might be text get C<text/plain> and binary files are served with
C<application/octet-stream>.

This method sets an appropriate C<last-modified> header and supports

 view release on metacpan or  search on metacpan

t/004_response/01_basic.t  view on Meta::CPAN

subtest 'accessor' => sub {
    my $headers = [
        'etag',
        '"a376a57cb3a4bd3a3c6a53fca06b0fd5badee50b"',
        'content-type',
        'text/javascript; charset=UTF-8',
        'pragma',
        'no-cache',
        'access-control-allow-origin',
        '*',

 view release on metacpan or  search on metacpan

lib/Farabi/files/public/assets/codemirror/addon/hint/html-hint.js  view on Meta::CPAN

    meta: {
      attrs: {
        content: null,
        charset: charsets,
        name: ["viewport", "application-name", "author", "description", "generator", "keywords"],
        "http-equiv": ["content-language", "content-type", "default-style", "refresh"]
      }
    },
    meter: { attrs: { value: null, min: null, low: null, high: null, max: null, optimum: null } },
    nav: s,
    noframes: s,

 view release on metacpan or  search on metacpan

lib/Feersum/Connection.pm  view on Meta::CPAN

an array of headers if form of [name, value, name, value, ...]

normalization_style is one of:

0 - skip normalization (default)
HEADER_NORM_LOCASE - "content-type"
HEADER_NORM_UPCASE - "CONTENT-TYPE"
HEADER_NORM_LOCASE_DASH - "content_type"
HEADER_NORM_UPCASE_DASH - "CONTENT_TYPE" (like PSGI, but without "HTTP_" prefix)

One can export these constants via c<<use Feersum 'HEADER_NORM_LOCASE'>>

=item C<< my $value = $req->header(name) >>

simple lookup for header value, name should be in lowercase, eg. 'content-type'

=item C<< my $env = $req->remote_address >>

remote address (psgi REMOTE_ADDR)

 view release on metacpan or  search on metacpan

lib/Fetch/Image.pm  view on Meta::CPAN

    my $head = $ua->head( $url );

    $head->is_error && Exception::Simple->throw("transfer error");

    exists( $self->{'config'}->{'allowed_types'}->{ $head->header('content-type') } )
        || Exception::Simple->throw("invalid content-type");

    if (
        $head->header('content-length')
        && ( $head->header('content-length') > $self->{'config'}->{'max_filesize'} )
    ){

 view release on metacpan or  search on metacpan

lib/File/HTTP.pod  view on Meta::CPAN

If set to follow redirections, $request_headers and $response_headers
will correspond to the last emitted request.

=item post URL TYPE BODY

Similar to C<get> but with a post request, with a content-type,and a body.
Always ignore redirections.

=item open_at URL OFFSET

Similar to to C<open>, but with an offset. It is more efficient than using