Logo Search packages:      
Sourcecode: jabref version File versions  Download package

ImportFormatReader.java

/*
 * Copyright (C) 2003 Morten O. Alver and Nizar N. Batada
 *
 * All programs in this directory and subdirectories are published under the GNU
 * General Public License as described below.
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Further information about the GNU GPL is available at:
 * http://www.gnu.org/copyleft/gpl.ja.html
 *
 */
package net.sf.jabref.imports;

import java.io.*;
import net.sf.jabref.util.Pair;
import java.util.*;

import net.sf.jabref.*;
import net.sf.jabref.plugin.PluginCore;
import net.sf.jabref.plugin.core.JabRefPlugin;
import net.sf.jabref.plugin.core.generated._JabRefPlugin.ImportFormatExtension;


public class ImportFormatReader {

    public static String BIBTEX_FORMAT = "BibTeX";

  /** all import formats, in the default order of import formats */
  private SortedSet<ImportFormat> formats = new TreeSet<ImportFormat>();

  public ImportFormatReader() {
    super();
  }

  public void resetImportFormats() {
    formats.clear();
    
    // Add all our importers to the TreeMap. The map is used to build the import
    // menus, and .
    formats.add(new CsaImporter());   
    formats.add(new IsiImporter());
    formats.add(new EndnoteImporter());
    formats.add(new BibteXMLImporter());
    formats.add(new BiblioscapeImporter());
    formats.add(new SixpackImporter());
    formats.add(new InspecImporter());
    formats.add(new ScifinderImporter());
    formats.add(new OvidImporter());
    formats.add(new RisImporter());
    formats.add(new JstorImporter());
    formats.add(new SilverPlatterImporter());
    formats.add(new BiomailImporter());
    formats.add(new RepecNepImporter());  
    formats.add(new PdfXmpImporter());
    formats.add(new CopacImporter());
    formats.add(new MsBibImporter());

    /**
     * Get import formats that are plug-ins
     */
    JabRefPlugin jabrefPlugin = JabRefPlugin.getInstance(PluginCore.getManager());
      if (jabrefPlugin != null){
            for (ImportFormatExtension ext : jabrefPlugin.getImportFormatExtensions()){
                  ImportFormat importFormat = ext.getImportFormat();
                  if (importFormat != null){
                        formats.add(importFormat);
                  }
            }
      }
      
      /**
       * Get custom import formats
       */
    for (CustomImportList.Importer importer : Globals.prefs.customImports){
       try {
        ImportFormat imFo = importer.getInstance();
        formats.add(imFo);
      } catch(Exception e) {
        System.err.println("Could not instantiate " + importer.getName() + " importer, will ignore it. Please check if the class is still available.");
        e.printStackTrace();
      }      
    }
  }
  
  /**
   * Format for a given CLI-ID.
   * 
   * <p>Will return the first format according to the default-order of
   * format that matches the given ID.</p>
   * 
   * @param cliId  CLI-Id
   * @return  Import Format or <code>null</code> if none matches
   */
  public ImportFormat getByCliId(String cliId) {
    for (ImportFormat format : formats){
      if (format.getCLIId().equals(cliId)) {
        return format;
      }
    }
    return null;
  }
  
  public List<BibtexEntry> importFromStream(String format, InputStream in)
    throws IOException {
    ImportFormat importer = getByCliId(format);

    if (importer == null)
      throw new IllegalArgumentException("Unknown import format: " + format);

    List<BibtexEntry> res = importer.importEntries(in);

    // Remove all empty entries
    if (res != null)
      purgeEmptyEntries(res);

    return res;
  }

  public List<BibtexEntry> importFromFile(String format, String filename)
    throws IOException {
    ImportFormat importer = getByCliId(format);

    if (importer == null)
      throw new IllegalArgumentException("Unknown import format: " + format);

    return importFromFile(importer, filename);
  }

    public List<BibtexEntry> importFromFile(ImportFormat importer, String filename) throws IOException {
        List<BibtexEntry> result = null;
        InputStream stream = null;
        try {
            File file = new File(filename);
            stream = new FileInputStream(file);

            if (!importer.isRecognizedFormat(stream))
                throw new IOException(Globals.lang("Wrong file format"));

            stream = new FileInputStream(file);

            result = importer.importEntries(stream);
        } finally {

            try {
                if (stream != null)
                    stream.close();
            } catch (IOException ex) {
                throw ex;
            }
        }

        return result;
    }

  public static BibtexDatabase createDatabase(Collection<BibtexEntry> bibentries) {
    purgeEmptyEntries(bibentries);

    BibtexDatabase database = new BibtexDatabase();

    for (Iterator<BibtexEntry> i = bibentries.iterator(); i.hasNext();) {
      BibtexEntry entry = i.next();

      try {
        entry.setId(Util.createNeutralId());
        database.insertEntry(entry);
      } catch (KeyCollisionException ex) {
        System.err.println("KeyCollisionException [ addBibEntries(...) ]");
      }
    }

    return database;
  }

  /**
   * All custom importers.
   * 
   * <p>Elements are in default order.</p>
   * 
   * @return all custom importers, elements are of type InputFormat
   */
  public SortedSet<ImportFormat> getCustomImportFormats() {
    SortedSet<ImportFormat> result = new TreeSet<ImportFormat>();
    for (ImportFormat format : formats){
      if (format.getIsCustomImporter()) {
        result.add(format);  
      }
    }
    return result;
  }
  
  /**
   * All built-in importers.
   * 
   * <p>Elements are in default order.</p>
   * 
   * @return all custom importers, elements are of type InputFormat
   */
  public SortedSet<ImportFormat> getBuiltInInputFormats() {
            SortedSet<ImportFormat> result = new TreeSet<ImportFormat>();
            for (ImportFormat format : formats) {
                  if (!format.getIsCustomImporter()) {
                        result.add(format);
                  }
            }
            return result;
      }
  
  /**
       * All importers.
       * 
       * <p>
       * Elements are in default order.
       * </p>
       * 
       * @return all custom importers, elements are of type InputFormat
       */
  public SortedSet<ImportFormat> getImportFormats() {
    return this.formats;
  }

  /**
   * Human readable list of all known import formats (name and CLI Id).
   * 
   * <p>List is in default-order.</p>
   * 
   * @return  human readable list of all known import formats
   */
  public String getImportFormatList() {
    StringBuffer sb = new StringBuffer();

    for (ImportFormat imFo : formats){
      int pad = Math.max(0, 14 - imFo.getFormatName().length());
      sb.append("  ");
      sb.append(imFo.getFormatName());

      for (int j = 0; j < pad; j++)
        sb.append(" ");

      sb.append(" : ");
      sb.append(imFo.getCLIId());
      sb.append("\n");
    }

    String res = sb.toString();

    return res; //.substring(0, res.length()-1);
  }


    /**
     * Expand initials, e.g. EH Wissler -> E. H. Wissler or Wissler, EH -> Wissler, E. H.
     * @param name
     * @return The name after expanding initials.
     */
    public static String expandAuthorInitials(String name) {
      String[] authors = name.split(" and ");
      StringBuffer sb = new StringBuffer();
      for (int i=0; i<authors.length; i++) {
          if (authors[i].indexOf(", ") >= 0) {
              String[] names = authors[i].split(", ");
              if (names.length > 0) {
                  sb.append(names[0]);
                  if (names.length > 1)
                    sb.append(", ");
              }
              for (int j=1; j<names.length; j++) {
                  sb.append(expandAll(names[j]));
              }

          } else {
              String[] names = authors[i].split(" ");
              if (names.length > 0) {
                  sb.append(expandAll(names[0]));
              }
              for (int j=1; j<names.length; j++) {
                  sb.append(" ");
                  sb.append(names[j]);
              }
          }
          if (i < authors.length-1)
              sb.append(" and ");
      }

      return sb.toString().trim();
  }
  
//------------------------------------------------------------------------------


    public static String expandAll(String s) {
        //System.out.println("'"+s+"'");
        // Avoid arrayindexoutof.... :
        if (s.length() == 0)
          return s;
        // If only one character (uppercase letter), add a dot and return immediately:
        if ((s.length() == 1) && (Character.isLetter(s.charAt(0)) &&
                Character.isUpperCase(s.charAt(0))))
          return s+".";
        StringBuffer sb = new StringBuffer();
        char c = s.charAt(0), d = 0;
        for (int i=1; i<s.length(); i++) {
            d = s.charAt(i);
            if (Character.isLetter(c) && Character.isUpperCase(c) &&
                    Character.isLetter(d) && Character.isUpperCase(d)) {
                sb.append(c);
                sb.append(". ");
            }
            else {
                sb.append(c);
            }
            c = d;
        }
        if (Character.isLetter(c) && Character.isUpperCase(c) &&
              Character.isLetter(d) && Character.isUpperCase(d)) {
            sb.append(c);
            sb.append(". ");
        }
        else {
            sb.append(c);
        }
        return sb.toString().trim();
    }


  static File checkAndCreateFile(String filename) {
    File f = new File(filename);

    if (!f.exists() && !f.canRead() && !f.isFile()) {
      System.err.println("Error " + filename
        + " is not a valid file and|or is not readable.");
      Globals.logger("Error " + filename + " is not a valid file and|or is not readable.");

      return null;
    } else

      return f;
  }

  //==================================================
  // Set a field, unless the string to set is empty.
  //==================================================
  public static void setIfNecessary(BibtexEntry be, String field, String content) {
    if (!content.equals(""))
      be.setField(field, content);
  }



    public static Reader getReader(File f, String encoding)
      throws IOException {
      InputStreamReader reader;
      reader = new InputStreamReader(new FileInputStream(f), encoding);

      return reader;
    }

  public static Reader getReaderDefaultEncoding(InputStream in)
    throws IOException {
    InputStreamReader reader;
    reader = new InputStreamReader(in, Globals.prefs.get("defaultEncoding"));

    return reader;
  }

  public static BibtexDatabase import_File(String format, String filename)
    throws IOException {
    BibtexDatabase database = null;
    List<BibtexEntry> bibentries = null;
    File f = new File(filename);

    if (!f.exists())
      throw new IOException(Globals.lang("File not found") + ": " + filename);

    try {
      bibentries = Globals.importFormatReader.importFromFile(format, filename);
    } catch (IllegalArgumentException ex) {
      throw new IOException(Globals.lang("Could not resolve import format") + " '"
        + format + "'");
    }

    if (bibentries == null)
      throw new IOException(Globals.lang("Import failed"));

    // Remove all empty entries:
    purgeEmptyEntries(bibentries);

    // Add entries to database.
    database = new BibtexDatabase();

    Iterator<BibtexEntry> it = bibentries.iterator();

    while (it.hasNext()) {
      BibtexEntry entry = it.next();

      try {
        entry.setId(Util.createNeutralId());
        database.insertEntry(entry);
      } catch (KeyCollisionException ex) {
        //ignore
        System.err.println("KeyCollisionException [ addBibEntries(...) ]");
      }
    }

    return database;
  }

  /**
   * Receives an ArrayList of BibtexEntry instances, iterates through them, and
   * removes all entries that have no fields set. This is useful for rooting out
   * an unsucessful import (wrong format) that returns a number of empty entries.
   */
  public static void purgeEmptyEntries(Collection<BibtexEntry> entries) {
    for (Iterator<BibtexEntry> i = entries.iterator(); i.hasNext();) {
      BibtexEntry entry = i.next();

      // If there are no fields, remove the entry:
      if (entry.getAllFields().size() == 0)
        i.remove();
    }
  }

  /**
       * Tries to import a file by iterating through the available import filters,
       * and keeping the import that seems most promising.
       * 
       * If all fails this method attempts to read this file as bibtex.
       * 
       * @throws IOException 
       */
      public Pair<String, ParserResult> importUnknownFormat(String filename) throws IOException {

            Pair<String, ParserResult> result = null;
            
            // Cycle through all importers:
            int bestResult = 0;

        for (ImportFormat imFo : getImportFormats()) {

            try {

                List<BibtexEntry> entries = importFromFile(imFo, filename);

                if (entries != null)
                    purgeEmptyEntries(entries);

                int entryCount = ((entries != null) ? entries.size() : 0);

                if (entryCount > bestResult) {
                    bestResult = entryCount;

                    result = new Pair<String, ParserResult>(imFo.getFormatName(),
                    new ParserResult(entries));
                }
            } catch (IOException ex) {
                // The import didn't succeed. Go on.
            }
        }
            
            if (result != null)
                  return result;

      // Finally, if all else fails, see if it is a BibTeX file:
      try {
          ParserResult pr = OpenDatabaseAction.loadDatabase(new File(filename),
                  Globals.prefs.get("defaultEncoding"));
          if ((pr.getDatabase().getEntryCount() > 0)
                  || (pr.getDatabase().getStringCount() > 0)) {
              pr.setFile(new File(filename));

              return new Pair<String, ParserResult>(BIBTEX_FORMAT, pr);
          }
      } catch (RuntimeException ex) {
          return null;
      }

      return null;
      }
}

Generated by  Doxygen 1.6.0   Back to index