Coverage report

  %line %branch
org.apache.turbine.services.mimetype.TurbineMimeTypeService
0% 
0% 

 1  
 package org.apache.turbine.services.mimetype;
 2  
 
 3  
 /*
 4  
  * Copyright 2001-2005 The Apache Software Foundation.
 5  
  *
 6  
  * Licensed under the Apache License, Version 2.0 (the "License")
 7  
  * you may not use this file except in compliance with the License.
 8  
  * You may obtain a copy of the License at
 9  
  *
 10  
  *     http://www.apache.org/licenses/LICENSE-2.0
 11  
  *
 12  
  * Unless required by applicable law or agreed to in writing, software
 13  
  * distributed under the License is distributed on an "AS IS" BASIS,
 14  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15  
  * See the License for the specific language governing permissions and
 16  
  * limitations under the License.
 17  
  */
 18  
 
 19  
 import java.io.File;
 20  
 import java.io.IOException;
 21  
 
 22  
 import java.util.Locale;
 23  
 
 24  
 import org.apache.commons.configuration.Configuration;
 25  
 
 26  
 import org.apache.turbine.services.InitializationException;
 27  
 import org.apache.turbine.services.TurbineBaseService;
 28  
 import org.apache.turbine.services.mimetype.util.CharSetMap;
 29  
 import org.apache.turbine.services.mimetype.util.MimeType;
 30  
 import org.apache.turbine.services.mimetype.util.MimeTypeMap;
 31  
 import org.apache.turbine.services.servlet.TurbineServlet;
 32  
 
 33  
 /**
 34  
  * The MimeType Service maintains mappings between MIME types and
 35  
  * the corresponding file name extensions, and between locales and
 36  
  * character encodings.
 37  
  *
 38  
  * <p>The MIME type mappings can be defined in MIME type files
 39  
  * located in user's home directory, Java home directory or
 40  
  * the current class jar. The default mapping file is defined
 41  
  * with the mime.type.file property. In addition, the service maintains
 42  
  * a set of most common mappings.
 43  
  *
 44  
  * <p>The charset mappings can be defined in property files
 45  
  * located in user's home directory, Java home directory or
 46  
  * the current class jar. The default mapping file is defined
 47  
  * with the charset.file property. In addition, the service maintains
 48  
  * a set of most common mappings.
 49  
  *
 50  
  * @author <a href="mailto:ilkka.priha@simsoft.fi">Ilkka Priha</a>
 51  
  * @version $Id: TurbineMimeTypeService.java 264148 2005-08-29 14:21:04Z henning $
 52  
  */
 53  
 public class TurbineMimeTypeService
 54  
         extends TurbineBaseService
 55  
         implements MimeTypeService
 56  
 {
 57  
     /**
 58  
      * The MIME type file property.
 59  
      */
 60  
     public static final String MIME_TYPES = "mime.types";
 61  
 
 62  
     /**
 63  
      * The charset file property.
 64  
      */
 65  
     public static final String CHARSETS = "charsets";
 66  
 
 67  
     /**
 68  
      * The MIME type map used by the service.
 69  
      */
 70  
     private MimeTypeMap mimeTypeMap;
 71  
 
 72  
     /**
 73  
      * The charset map used by the service.
 74  
      */
 75  
     private CharSetMap charSetMap;
 76  
 
 77  
     /**
 78  
      * Constructs a new service.
 79  
      */
 80  
     public TurbineMimeTypeService()
 81  0
     {
 82  0
     }
 83  
 
 84  
     /**
 85  
      * Initializes the service.
 86  
      *
 87  
      * @throws InitializationException if initialization fails.
 88  
      */
 89  
     public void init()
 90  
             throws InitializationException
 91  
     {
 92  0
         String path = null;
 93  0
         Configuration conf = getConfiguration();
 94  0
         if (conf != null)
 95  
         {
 96  0
             path = conf.getString(MIME_TYPES);
 97  0
             if (path != null)
 98  
             {
 99  0
                 path = TurbineServlet.getRealPath(path);
 100  
             }
 101  
         }
 102  0
         if (path != null)
 103  
         {
 104  
             try
 105  
             {
 106  0
                 mimeTypeMap = new MimeTypeMap(path);
 107  
             }
 108  0
             catch (IOException x)
 109  
             {
 110  0
                 throw new InitializationException(path, x);
 111  0
             }
 112  
         }
 113  
         else
 114  
         {
 115  0
             mimeTypeMap = new MimeTypeMap();
 116  
         }
 117  
 
 118  0
         if (conf != null)
 119  
         {
 120  0
             path = conf.getString(CHARSETS);
 121  0
             if (path != null)
 122  
             {
 123  0
                 path = TurbineServlet.getRealPath(path);
 124  
             }
 125  
         }
 126  0
         if (path != null)
 127  
         {
 128  
             try
 129  
             {
 130  0
                 charSetMap = new CharSetMap(path);
 131  
             }
 132  0
             catch (IOException x)
 133  
             {
 134  0
                 throw new InitializationException(path, x);
 135  0
             }
 136  
         }
 137  
         else
 138  
         {
 139  0
             charSetMap = new CharSetMap();
 140  
         }
 141  0
         setInit(true);
 142  0
     }
 143  
 
 144  
     /**
 145  
      * Sets a MIME content type mapping to extensions to the map.
 146  
      * The extension is specified by a MIME type name followed
 147  
      * by a list of file name extensions separated by a whitespace.
 148  
      *
 149  
      * @param spec a MIME type extension specification to add.
 150  
      */
 151  
     public void setContentType(String spec)
 152  
     {
 153  0
         mimeTypeMap.setContentType(spec);
 154  0
     }
 155  
 
 156  
     /**
 157  
      * Gets the MIME content type for a file as a string.
 158  
      *
 159  
      * @param file the file.
 160  
      * @return the MIME type string.
 161  
      */
 162  
     public String getContentType(File file)
 163  
     {
 164  0
         return mimeTypeMap.getContentType(file);
 165  
     }
 166  
 
 167  
     /**
 168  
      * Gets the MIME content type for a named file as a string.
 169  
      *
 170  
      * @param name the name of the file.
 171  
      * @return the MIME type string.
 172  
      */
 173  
     public String getContentType(String name)
 174  
     {
 175  0
         return mimeTypeMap.getContentType(name);
 176  
     }
 177  
 
 178  
     /**
 179  
      * Gets the MIME content type for a file name extension as a string.
 180  
      *
 181  
      * @param ext the file name extension.
 182  
      * @param def the default type if none is found.
 183  
      * @return the MIME type string.
 184  
      */
 185  
     public String getContentType(String ext,
 186  
                                  String def)
 187  
     {
 188  0
         return mimeTypeMap.getContentType(ext, def);
 189  
     }
 190  
 
 191  
     /**
 192  
      * Gets the MIME content type for a file.
 193  
      *
 194  
      * @param file the file.
 195  
      * @return the MIME type.
 196  
      */
 197  
     public MimeType getMimeContentType(File file)
 198  
     {
 199  0
         return mimeTypeMap.getMimeContentType(file);
 200  
     }
 201  
 
 202  
     /**
 203  
      * Gets the MIME content type for a named file.
 204  
      *
 205  
      * @param name the name of the file.
 206  
      * @return the MIME type.
 207  
      */
 208  
     public MimeType getMimeContentType(String name)
 209  
     {
 210  0
         return mimeTypeMap.getMimeContentType(name);
 211  
     }
 212  
 
 213  
     /**
 214  
      * Gets the MIME content type for a file name extension.
 215  
      *
 216  
      * @param ext the file name extension.
 217  
      * @param def the default type if none is found.
 218  
      * @return the MIME type.
 219  
      */
 220  
     public MimeType getMimeContentType(String ext,
 221  
                                        String def)
 222  
     {
 223  0
         return mimeTypeMap.getMimeContentType(ext, def);
 224  
     }
 225  
 
 226  
     /**
 227  
      * Gets the default file name extension for a MIME type.
 228  
      * Note that the mappers are called in the reverse order.
 229  
      *
 230  
      * @param type the MIME type as a string.
 231  
      * @return the file name extension or null.
 232  
      */
 233  
     public String getDefaultExtension(String type)
 234  
     {
 235  0
         return mimeTypeMap.getDefaultExtension(type);
 236  
     }
 237  
 
 238  
     /**
 239  
      * Gets the default file name extension for a MIME type.
 240  
      * Note that the mappers are called in the reverse order.
 241  
      *
 242  
      * @param mime the MIME type.
 243  
      * @return the file name extension or null.
 244  
      */
 245  
     public String getDefaultExtension(MimeType mime)
 246  
     {
 247  0
         return mimeTypeMap.getDefaultExtension(mime);
 248  
     }
 249  
 
 250  
     /**
 251  
      * Sets a locale-charset mapping.
 252  
      *
 253  
      * @param key the key for the charset.
 254  
      * @param charset the corresponding charset.
 255  
      */
 256  
     public void setCharSet(String key,
 257  
                            String charset)
 258  
     {
 259  0
         charSetMap.setCharSet(key, charset);
 260  0
     }
 261  
 
 262  
     /**
 263  
      * Gets the charset for a locale. First a locale specific charset
 264  
      * is searched for, then a country specific one and lastly a language
 265  
      * specific one. If none is found, the default charset is returned.
 266  
      *
 267  
      * @param locale the locale.
 268  
      * @return the charset.
 269  
      */
 270  
     public String getCharSet(Locale locale)
 271  
     {
 272  0
         return charSetMap.getCharSet(locale);
 273  
     }
 274  
 
 275  
     /**
 276  
      * Gets the charset for a locale with a variant. The search
 277  
      * is performed in the following order:
 278  
      * "lang"_"country"_"variant"="charset",
 279  
      * _"counry"_"variant"="charset",
 280  
      * "lang"__"variant"="charset",
 281  
      * __"variant"="charset",
 282  
      * "lang"_"country"="charset",
 283  
      * _"country"="charset",
 284  
      * "lang"="charset".
 285  
      * If nothing of the above is found, the default charset is returned.
 286  
      *
 287  
      * @param locale the locale.
 288  
      * @param variant a variant field.
 289  
      * @return the charset.
 290  
      */
 291  
     public String getCharSet(Locale locale,
 292  
                              String variant)
 293  
     {
 294  0
         return charSetMap.getCharSet(locale, variant);
 295  
     }
 296  
 
 297  
     /**
 298  
      * Gets the charset for a specified key.
 299  
      *
 300  
      * @param key the key for the charset.
 301  
      * @return the found charset or the default one.
 302  
      */
 303  
     public String getCharSet(String key)
 304  
     {
 305  0
         return charSetMap.getCharSet(key);
 306  
     }
 307  
 
 308  
     /**
 309  
      * Gets the charset for a specified key.
 310  
      *
 311  
      * @param key the key for the charset.
 312  
      * @param def the default charset if none is found.
 313  
      * @return the found charset or the given default.
 314  
      */
 315  
     public String getCharSet(String key,
 316  
                              String def)
 317  
     {
 318  0
         return charSetMap.getCharSet(key, def);
 319  
     }
 320  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.