NAME
    uSAC::MIME - MIME Type database with concise lookups

SYNOPSIS
            use uSAC::MIME;

            #Create a new DB using inbuild data
            my $db=uSAC::MIME->new;         

            #Database with no entries
            my $db=uSAC::MIME->new_empty;

            #Create data base from contents of file
            my $db=uSAC::MIME->new_from_file("path_to_nginx_or_apache_mime");

            #Create default from internal database and then add a custom entry
            my $db=uSAC::MIME->new("xyz"=>"special/type");


            #Add a custom entry to an existing database
            $db->add("abc"=>"another/type");

            #Remove a file extension from a mime type
            $db->rem("abc"=>"another/type");


            #Index the database. Forward only mapping in scalar context
            my $forward=$db->index;
        
            #Index the database. Forward and reverse mapping in list context
            my ($forward,$reverse)=$db->index;



            #Do Lookups 
            $forward->{txt};           #return  "text/plain"
            $backward->{"text/plain"}; #returns a array ref of extension

DESCRIPTION
    Provides concise file extension to MIME type (forward) mapping and MIME
    type to file extension set (backwards) mapping.

    Features include:

    Internal Default Database
        Internally it has its own MIME database source, however when you
        create a new instance you receive a copy which you can add or remove
        entries as you please.

    Load and Save from file
        An external MIME type database in nginx or Apache formats can be
        used to create an instance

    Low overhead
        The database in indexed into a anonymous hash ref for direct lookup

Motivation
    Performance. The indexed database is a straight perl hash so no method
    or subroutine overheads. When responding to as many HTTP requests as
    possible, this seemed like easy pickings to improve performance.

What this module doesn't do
    It is not a general purpose MIME type manipulator or generator. Module
    such as MIME::Type more suited for that purpose.

    It also doesn't export and lookup methods/subs. All lookups are done via
    the hashes returned from calling the "index" method

    File paths are not really handled. You need to split them off before
    hand.

API
  Constructors
   "new(%mappings_to_add)"
    Creates a new mime database from the internal database. Adds the
    optional mappings to it The "index" method needs to be called on the
    returned object to perform lookups

   "new_empty(%mappings_to_add)"
    Creates a new empty database. Adds the optional mappings to it The
    "index" method needs to be called on the returned object to perform
    lookups

  File IO
   "load_from_handle"
    Reads the contents of a handle and adds it to the db

   "save_to_handle"
    Writes out the DB as a text to the specified handle

  Indexing
   "index"
    Generates the hash tables for forward (extension to mime) mappings, and
    backwards(mime to extension set) mapping.

            my ($forward,$backward)=$db->index; $forward->{"txt");

  Database Manipulation
   "add"
    Adds a single mapping from file extension to mime type. The "index"
    method will need to be called after to construct a new lookup hashes

   "rem"
    Removes a single mapping from file extension to mime type. The "index"
    method will need to be called after to construct a new lookup hashes

  Forward Lookups
    Once indexed, lookups are simply done via hash reference:

            my $forward=$db->index; #Previously index db to $forward
        
            $forward->{ext};        #Direct hash lookup

    A single MIME type will be returned in the forward lookup. If the hash
    doesn't contain the extension to MIME mapping, undef is returned.

  Reverse Lookups
    To get the reverse lookup table, list context must be used when
    indexing:

            my ($forward, $revsere)=$db->index; #previously index

            $reverse->{mime};       #Direct hash lookup

    An anonymous array of extension types are returned with zero or more
    file extensions

  Default/Fallback
    When forward lookups fails to locate a MIME type for the extension, use
    the 'defined or' operator to specify a fallback.

            $forward->{unkown_extension}//"my_default/type";

    For reverse lookup failure, an empty anonymous array is returned.

            my @exts=$reverse->{unkown_mime}->@*||qw<my_default>;

PERFORMANCE
    A very basic benchmark of performing a forward lookup of a "txt"
    extension. Comparing this modules to Plack::MIME and MIME::Detect
    locally on my laptop give the following lookup rates:

            Module                 Lookup rate

            MIME::Detect                 167/s
            Plack::MIME              5208333/s
            uSAC::MIME              43478261/s

REPOSITORY
    Checkout the repo at <https://github.com/drclaw1394/perl-usac-mime>

AUTHOR
    Ruben Westerberg

COPYRIGHT
    Copyright (C) 2022 Ruben Westerberg

LICENSE
    MIT or Perl, whichever you choose.

