archive/net.sourceforge.phpeclipse.wiki/src/net/sourceforge/phpeclipse/wiki/builder/CreatePageAction.java

   1 package net.sourceforge.phpeclipse.wiki.builder;
   2
   3 import java.io.BufferedInputStream;
   4 import java.io.File;
   5 import java.io.FileNotFoundException;
   6 import java.io.FileOutputStream;
   7 import java.io.FileWriter;
   8 import java.io.IOException;
   9 import java.io.InputStream;
  10 import java.io.InputStreamReader;
  11 import java.util.Iterator;
  12
  13 import net.sourceforge.phpeclipse.wiki.editor.WikiEditorPlugin;
  14 import net.sourceforge.phpeclipse.wiki.preferences.Util;
  15 import net.sourceforge.phpeclipse.wiki.renderer.IContentRenderer;
  16 import net.sourceforge.phpeclipse.wiki.renderer.RendererFactory;
  17 import net.sourceforge.phpeclipse.wiki.renderer.StringUtil;
  18
  19 import org.eclipse.core.resources.IFile;
  20 import org.eclipse.core.resources.IResource;
  21 import org.eclipse.core.runtime.CoreException;
  22 import org.eclipse.jface.action.IAction;
  23 import org.eclipse.jface.viewers.ISelection;
  24 import org.eclipse.jface.viewers.ISelectionProvider;
  25 import org.eclipse.jface.viewers.StructuredSelection;
  26 import org.eclipse.ui.IActionDelegate;
  27 import org.eclipse.ui.IObjectActionDelegate;
  28 import org.eclipse.ui.IWorkbenchPart;
  29
  30 /**
  31  * Create a static HTML page
  32  */
  33 public class CreatePageAction implements IObjectActionDelegate {
  34   /**
  35    * Constant for an empty char array
  36    */
  37   public static final char[] NO_CHAR = new char[0];
  38
  39   private static final int DEFAULT_READING_SIZE = 8192;
  40
  41   private IWorkbenchPart workbenchPart;
  42
  43   /**
  44    *
  45    */
  46   public CreatePageAction() {
  47     super();
  48   }
  49
  50   /**
  51    * @see IObjectActionDelegate#setActivePart(IAction, IWorkbenchPart)
  52    */
  53   public void setActivePart(IAction action, IWorkbenchPart targetPart) {
  54     workbenchPart = targetPart;
  55   }
  56
  57   public void run(IAction action) {
  58     ISelectionProvider selectionProvider = null;
  59     selectionProvider = workbenchPart.getSite().getSelectionProvider();
  60
  61     StructuredSelection selection = null;
  62     selection = (StructuredSelection) selectionProvider.getSelection();
  63
  64     //Shell shell = null;
  65     Iterator iterator = null;
  66     iterator = selection.iterator();
  67     while (iterator.hasNext()) {
  68       //  obj => selected object in the view
  69       Object obj = iterator.next();
  70
  71       // is it a resource
  72       if (obj instanceof IResource) {
  73         IResource resource = (IResource) obj;
  74
  75         // check if it's a file resource
  76         switch (resource.getType()) {
  77
  78         case IResource.FILE:
  79           createPage((IFile) resource);
  80         }
  81       }
  82     }
  83   }
  84
  85   /**
  86    * @see IActionDelegate#selectionChanged(IAction, ISelection)
  87    */
  88   public void selectionChanged(IAction action, ISelection selection) {
  89   }
  90
  91   public static boolean createFragmentPage(IFile file, StringBuffer htmlBuffer) {
  92     BufferedInputStream stream = null;
  93     boolean noContent = true;
  94     try {
  95 //      String templateFileName = Util.getLocalTemplate(file);
  96       //    String cssUrl = Util.getLocalCssUrl(file);
  97       String srcBasePath = Util.getWikiTextsPath(file);
  98       String binBasePath = Util.getProjectsWikiOutputPath(file.getProject(), WikiEditorPlugin.HTML_OUTPUT_PATH);
  99       IContentRenderer renderer = RendererFactory.createContentRenderer(file.getProject());
 100       stream = new BufferedInputStream(file.getContents());
 101
 102       String fileName = Util.getHTMLFileName(file, binBasePath, srcBasePath);
 103       String content = new String(getInputStreamAsCharArray(stream, -1, "utf-8"));
 104       noContent = StringUtil.checkNoContent(content);
 105       String filePath = file.getLocation().toString(); // file.getProjectRelativePath().toString()
 106       if (filePath.startsWith(srcBasePath)) {
 107         filePath = filePath.substring(srcBasePath.length() + 1);
 108       }
 109       // calculate the <i>depth</i> of the file (i.e. ../../../ as much as needed)
 110       int index = 0;
 111       int level = 0;
 112       while (index >= 0) {
 113         index = fileName.indexOf('/', index);
 114         if (index >= 0) {
 115           level++;
 116           index++;
 117         }
 118       }
 119       renderer.render(null, content, htmlBuffer, level, false);
 120
 121     } catch (Exception e) {
 122       e.printStackTrace();
 123     } finally {
 124       try {
 125         if (stream != null) {
 126           stream.close();
 127         }
 128       } catch (IOException e) {
 129       }
 130     }
 131     return noContent;
 132   }
 133
 134   public static void createPage(IFile file) {
 135     String templateFileName = Util.getLocalTemplate(file);
 136     String cssUrl = Util.getLocalCssUrl(file);
 137     String srcBasePath = Util.getWikiTextsPath(file);
 138     String binBasePath = Util.getProjectsWikiOutputPath(file.getProject(), WikiEditorPlugin.HTML_OUTPUT_PATH);
 139     createPage(templateFileName, file, binBasePath, srcBasePath);
 140   }
 141
 142   public static void createPage(String templateFileName, IFile file, String binBasePath, String srcBasePath) {
 143     //          only interested in files with the "wp" extension
 144     if ("wp".equalsIgnoreCase(file.getFileExtension())) {
 145       try {
 146         IContentRenderer renderer = RendererFactory.createContentRenderer(file.getProject());
 147         convertWikiFile(templateFileName, file, binBasePath, srcBasePath, renderer);
 148       } catch (InstantiationException e) {
 149         // TODO Auto-generated catch block
 150         e.printStackTrace();
 151       } catch (IllegalAccessException e) {
 152         // TODO Auto-generated catch block
 153         e.printStackTrace();
 154       } catch (ClassNotFoundException e) {
 155         // TODO Auto-generated catch block
 156         e.printStackTrace();
 157       } catch (CoreException e1) {
 158         // TODO Auto-generated catch block
 159         e1.printStackTrace();
 160       } catch (Exception e) {
 161         // TODO Auto-generated catch block
 162         e.printStackTrace();
 163       }
 164     } else {
 165       String fname = file.getName().toLowerCase();
 166       if ((fname.charAt(0) == '.') || "project.index".equals(fname) || "cvs".equals(fname) || "entries".equals(fname)
 167           || "repository".equals(fname) || "root".equals(fname)) {
 168         // ignore meta information
 169         return;
 170       }
 171       // copy the file
 172       FileOutputStream output = null;
 173       InputStream contentStream = null;
 174
 175       try {
 176         String filename = Util.getHTMLFileName(file, binBasePath, srcBasePath);
 177         if (filename != null) {
 178           int index = filename.lastIndexOf('/');
 179           if (index >= 0) {
 180             File ioFile = new File(filename.substring(0, index));
 181             if (!ioFile.isDirectory()) {
 182               ioFile.mkdirs();
 183             }
 184           }
 185           output = new FileOutputStream(filename);
 186
 187           contentStream = file.getContents(false);
 188           int chunkSize = contentStream.available();
 189           byte[] readBuffer = new byte[chunkSize];
 190           int n = contentStream.read(readBuffer);
 191
 192           while (n > 0) {
 193             output.write(readBuffer);
 194             n = contentStream.read(readBuffer);
 195           }
 196         }
 197       } catch (Exception e) {
 198
 199       } finally {
 200         try {
 201           if (output != null)
 202             output.close();
 203           if (contentStream != null)
 204             contentStream.close();
 205         } catch (IOException e1) {
 206         }
 207       }
 208     }
 209   }
 210
 211   public static void convertWikiFile(String templateFileName, IFile file, String binBasePath, String srcBasePath,
 212       IContentRenderer renderer) throws CoreException {
 213     StringBuffer htmlBuffer = new StringBuffer();
 214     convertWikiBuffer(templateFileName, htmlBuffer, file, renderer, true);
 215     String htmlName = Util.getHTMLFileName(file, binBasePath, srcBasePath);
 216     if (htmlName != null) {
 217       writeHTMLFile(htmlBuffer, htmlName);
 218     }
 219   }
 220
 221   public static void getWikiBuffer(StringBuffer htmlBuffer, IFile file) throws CoreException {
 222     BufferedInputStream stream = new BufferedInputStream(file.getContents());
 223     try {
 224       htmlBuffer.append(getInputStreamAsCharArray(stream, -1, null));
 225       return;
 226       //new String(getInputStreamAsCharArray(stream, -1, null));
 227     } catch (IOException e) {
 228       e.printStackTrace();
 229     } finally {
 230       try {
 231         if (stream != null) {
 232           stream.close();
 233         }
 234       } catch (IOException e) {
 235       }
 236     }
 237     return;
 238   }
 239
 240   public static void convertWikiBuffer(String templateFileName, StringBuffer htmlBuffer, IFile file, IContentRenderer renderer,
 241       boolean completeHTML) throws CoreException {
 242     BufferedInputStream stream = new BufferedInputStream(file.getContents());
 243     try {
 244       String content = new String(getInputStreamAsCharArray(stream, -1, null));
 245       String srcPath = Util.getWikiTextsPath(file);
 246       String filePath = file.getLocation().toString(); // file.getProjectRelativePath().toString()
 247       if (filePath.startsWith(srcPath)) {
 248         filePath = filePath.substring(srcPath.length() + 1);
 249       }
 250       createWikiBuffer(templateFileName, htmlBuffer, filePath, content, renderer, completeHTML);
 251     } catch (IOException e) {
 252       e.printStackTrace();
 253     } finally {
 254       try {
 255         if (stream != null) {
 256           stream.close();
 257         }
 258       } catch (IOException e) {
 259       }
 260     }
 261   }
 262
 263   /**
 264    * @param htmlBuffer
 265    * @param fileName
 266    * @param content
 267    * @param renderer
 268    */
 269   public static void createWikiBuffer(String templateFileName, StringBuffer htmlBuffer, String fileName, String content,
 270       IContentRenderer renderer, boolean completeHTML) {
 271     // calculate the <i>depth</i> of the file (i.e. ../../../ as much as needed)
 272     int index = 0;
 273     int level = 0;
 274     while (index >= 0) {
 275       index = fileName.indexOf('/', index);
 276       if (index >= 0) {
 277         level++;
 278         index++;
 279       }
 280     }
 281     renderer.render(templateFileName, content, htmlBuffer, level, completeHTML);
 282   }
 283
 284   public static void writeHTMLFile(StringBuffer buffer, String filename) {
 285     int index = filename.lastIndexOf('/');
 286     if (index >= 0) {
 287       File file = new File(filename.substring(0, index));
 288       if (!file.isDirectory()) {
 289         file.mkdirs();
 290       }
 291     }
 292     FileWriter fileWriter;
 293     try {
 294       fileWriter = new FileWriter(filename);
 295       fileWriter.write(buffer.toString());
 296       fileWriter.close();
 297     } catch (FileNotFoundException e) {
 298       // ignore exception; project is deleted by fUser
 299     } catch (IOException e) {
 300       // TODO Auto-generated catch block
 301       e.printStackTrace();
 302     }
 303   }
 304
 305   /**
 306    * Returns the given input stream's contents as a character array. If a length is specified (ie. if length != -1), only length
 307    * chars are returned. Otherwise all chars in the stream are returned. Note this doesn't close the stream.
 308    *
 309    * @throws IOException
 310    *           if a problem occured reading the stream.
 311    */
 312   public static char[] getInputStreamAsCharArray(InputStream stream, int length, String encoding) throws IOException {
 313     InputStreamReader reader = null;
 314     reader = encoding == null ? new InputStreamReader(stream) : new InputStreamReader(stream, encoding);
 315     char[] contents;
 316     if (length == -1) {
 317       contents = NO_CHAR;
 318       int contentsLength = 0;
 319       int amountRead = -1;
 320       do {
 321         int amountRequested = Math.max(stream.available(), DEFAULT_READING_SIZE); // read at least 8K
 322
 323         // resize contents if needed
 324         if (contentsLength + amountRequested > contents.length) {
 325           System.arraycopy(contents, 0, contents = new char[contentsLength + amountRequested], 0, contentsLength);
 326         }
 327
 328         // read as many chars as possible
 329         amountRead = reader.read(contents, contentsLength, amountRequested);
 330
 331         if (amountRead > 0) {
 332           // remember length of contents
 333           contentsLength += amountRead;
 334         }
 335       } while (amountRead != -1);
 336
 337       // resize contents if necessary
 338       if (contentsLength < contents.length) {
 339         System.arraycopy(contents, 0, contents = new char[contentsLength], 0, contentsLength);
 340       }
 341     } else {
 342       contents = new char[length];
 343       int len = 0;
 344       int readSize = 0;
 345       while ((readSize != -1) && (len != length)) {
 346         // See PR 1FMS89U
 347         // We record first the read size. In this case len is the actual
 348         // read size.
 349         len += readSize;
 350         readSize = reader.read(contents, len, length - len);
 351       }
 352       // See PR 1FMS89U
 353       // Now we need to resize in case the default encoding used more than
 354       // one byte for each
 355       // character
 356       if (len != length)
 357         System.arraycopy(contents, 0, (contents = new char[len]), 0, len);
 358     }
 359
 360     return contents;
 361   }
 362 }