Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2005 JBoss Inc
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.drools.guvnor.server.contenthandler;
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 
This is used for handling jar models for the rules.
 
 public class ModelContentHandler extends ContentHandler
     implements
     ICanHasAttachment {
 
     public void retrieveAssetContent(Asset asset,
                                      AssetItem itemthrows SerializationException {
         // do nothing, as we have an attachment
     }
 
     public void storeAssetContent(Asset asset,
                                   AssetItem repoAssetthrows SerializationException {
         // do nothing, as we have an attachment
     }

    
This is called when a model jar is attached, it will peer into it, and then automatically add imports if there aren't any already in the package header configuration.
 
     public void onAttachmentAdded(AssetItem assetthrows IOException {
 
         ModuleItem pkg = asset.getModule();
         StringBuilder header = createNewHeader( DroolsHeader.getDroolsHeaderpkg ) );
 
         Set<Stringimports = getImportsFromJarasset );
 
         for ( String importLine : imports ) {
             Pattern pattern = Pattern.compile"\\s" + importLine.replace".",
                                                                            "\\." ) + "\\s" );
             if ( !pattern.matcherheader ).find() ) {
                 header.appendimportLine ).append"\n" );
             }
         }
 
         DroolsHeader.updateDroolsHeaderheader.toString(),
                                          pkg );
         pkg.checkin"Imports setup automatically on model import." );
 
     }
 
     public void onAttachmentRemoved(AssetItem itemthrows IOException {
 
         ModuleItem pkg = item.getModule();
         StringBuilder header = createNewHeader( DroolsHeader.getDroolsHeaderpkg ) );
 
         Set<Stringimports = getImportsFromJaritem );
 
         for ( String importLine : imports ) {
             String importLineWithLineEnd = importLine + "\n";
 
             header = removeImportIfItExistsheader,
                                              importLineWithLineEnd );
         }
 
         DroolsHeader.updateDroolsHeaderheader.toString(),
                                                   pkg );
 
         pkg.checkin"Imports removed automatically on model archiving." );
    }
                                                 String importLine) {
        if ( header.indexOfimportLine ) >= 0 ) {
            int indexOfImportLine = header.indexOfimportLine );
            header = header.replaceindexOfImportLine,
                                     indexOfImportLine + importLine.length(),
                                     "" );
        }
        return header;
    }
    private StringBuilder createNewHeader(String header) {
        StringBuilder buf = new StringBuilder();
        if ( header != null ) {
            buf.appendheader );
            buf.append'\n' );
        }
        return buf;
    }
    private Set<StringgetImportsFromJar(AssetItem assetItemthrows IOException {
        Set<Stringimports = new HashSet<String>();
        Map<StringStringnonCollidingImports = new HashMap<StringString>();
        String assetPackageName = assetItem.getModuleName();
        //Setup class-loader to check for class visibility
        JarInputStream cljis = new JarInputStreamassetItem.getBinaryContentAttachment() );
        List<JarInputStreamjarInputStreams = new ArrayList<JarInputStream>();
        jarInputStreams.addcljis );
        ClassLoaderBuilder clb = new ClassLoaderBuilderjarInputStreams );
        ClassLoader cl = clb.buildClassLoader();
        //Reset stream to read classes
        JarInputStream jis = new JarInputStreamassetItem.getBinaryContentAttachment() );
        JarEntry entry = null;
        //Get Class names from JAR, only the first occurrence of a given Class leaf name will be inserted. Thus 
        //"org.apache.commons.lang.NumberUtils" will be imported but "org.apache.commons.lang.math.NumberUtils"
        //will not, assuming it follows later in the JAR structure.
        while ( (entry = jis.getNextJarEntry()) != null ) {
            if ( !entry.isDirectory() ) {
                if ( entry.getName().endsWith".class" ) && !entry.getName().endsWith"package-info.class" ) ) {
                    final String fullyQualifiedName = convertPathToNameentry.getName() );
                    final String fullyQualifiedClassName = convertPathToClassNameentry.getName() );
                    if ( isClassVisiblecl,
                                         fullyQualifiedClassName,
                                         assetPackageName ) ) {
                        String leafName = getLeafNamefullyQualifiedName );
                        if ( !nonCollidingImports.containsKeyleafName ) ) {
                            nonCollidingImports.putleafName,
                                                     fullyQualifiedName );
                        }
                    }
                }
            }
        }
        //Build list of imports
        for ( String value : nonCollidingImports.values() ) {
            String line = "import " + value;
            imports.addline );
        }
        return imports;
    }
    private String getLeafName(String fullyQualifiedName) {
        int index = fullyQualifiedName.lastIndexOf"." );
        if ( index == -1 ) {
            return fullyQualifiedName;
        }
        return fullyQualifiedName.substringindex + 1 );
    }
    //Only import public classes; or those in the same package as the Asset
    private boolean isClassVisible(ClassLoader cl,
                                   String className,
                                   String assetPackageName) {
        try {
            Class< ? > cls = cl.loadClassclassName );
            int modifiers = cls.getModifiers();
            if ( Modifier.isPublicmodifiers ) ) {
                return true;
            }
            String packageName = className.substring( 0,
                                                      className.lastIndexOf"." ) );
            if ( !packageName.equalsassetPackageName ) ) {
                return false;
            }
        } catch ( Exception e ) {
            return false;
        }
        return true;
    }
    private static String convertPathToClassName(String name) {
        String convertedName = name.replace".class",
                                             "" );
        convertedName = convertedName.replace"/",
                                               "." );
        return convertedName;
    }
    public static String convertPathToName(String name) {
        String convertedName = convertPathToClassNamename );
        convertedName = convertedName.replaceAll"\\$",
                                                  "." );
        return convertedName;
    }
New to GrepCode? Check out our FAQ X