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.util;
 
 
 import java.util.*;
This class imports legacy DRL into a structure suitable for storing more normalised in the repository.
 
 public class ClassicDRLImporter {
 
     private String               source;
 
     private String               packageName;
 
     private static final Pattern functionPattern            = Pattern.compile"function\\s+.*\\s+(.*)\\(.*\\).*" );
 
     private static final Pattern declarationNamePattern     = Pattern.compile"declare\\s+(\\w+)\\s*.*" );
 
     //Single line declarations
     private static final Pattern declarationCompletePattern = Pattern.compile"declare\\s+(\\w+).*\\s+end" );
 
     private static final Pattern endPattern                 = Pattern.compile"\\s*end" );
 
     private final List<Asset>    declaredTypes              = new ArrayList<Asset>();
 
     private final List<Asset>    assets                     = new ArrayList<Asset>();
 
     private StringBuilder        header;
 
     private boolean              usesDSL;

    

Parameters:
in will be closed after it's read
 
     public ClassicDRLImporter(InputStream inthrows DroolsParserException {
         BufferedReader reader = new BufferedReadernew InputStreamReaderin ) );
         try {
             StringBuilder drl = new StringBuilder();
             String line;
             while ( (line = reader.readLine()) != null ) {
                 drl.append"\n" ).appendline );
             }
             this. = drl.toString();
         } catch (IOException e) {
             throw new IllegalArgumentException("Could not read DRL inputStream."e);
         } finally {
             IOUtils.closeQuietly(reader);
         }
 
         parse();
     }
 
     private void parse() throws DroolsParserException {
         StringTokenizer lines = new StringTokenizer,
                                                      "\r\n" );
 
          = new StringBuilder();
         while ( lines.hasMoreTokens() ) {
             String line = lines.nextToken().trim();
 
             if ( line.startsWith"package" ) ) {
                  = getPackageline );
 
             } else if ( line.startsWith"rule" ) ) {
                 String ruleName = getRuleNameline );
                 StringBuilder currentRule = new StringBuilder();
                 laConsumeToEndlines,
                                 currentRule,
                                 "end",
                                 false );
                 addRuleruleName,
                         currentRule );
            } else if ( line.startsWith"function" ) ) {
                String functionName = getFuncNameline );
                StringBuilder currentFunc = new StringBuilder();
                int counter = 0;
                currentFunc.appendline ).append"\n" );
                counter = countBracketscounter,
                                         line );
                if ( counter > 0 ) {
                    laConsumeBracketsToEndcounter,
                                            lines,
                                            currentFunc );
                }
                addFunctionfunctionName,
                             currentFunc );
            } else if ( line.startsWith"declare" ) ) {
                String declarationName = getDeclarationNameline );
                StringBuilder currentDeclaration = new StringBuilder();
                currentDeclaration.appendline ).append"\n" );
                if ( !isDeclarationCompleteline ) ) {
                    laConsumeDeclarationToEndlines,
                                               currentDeclaration );
                }
                addDeclaredModeldeclarationName,
                                  currentDeclaration );
            } else if ( line.startsWith"/*" ) ) {
                StringBuilder comment = new StringBuilder();
                comment.appendline ).append"\n" );
                laConsumeToEndlines,
                                comment,
                                "*/",
                                true );
                .appendcomment );
            } else if ( line.startsWith"expander" ) ) {
                 = true;
            } else {
                .appendline );
                .append"\n" );
            }
        }
        addDeclaredModels();
    }
    private void addFunction(String functionName,
                             StringBuilder currentFunc) {
        this..addnew AssetfunctionName,
                                    currentFunc.toString(),
                                    . ) );
    }
    //Add a single Type to the collection from which a Declarative Model will be composed
    private void addDeclaredModel(String declarationName,
                                  StringBuilder currentDeclaration) {
        this..addnew AssetdeclarationName,
                                           currentDeclaration.toString(),
                                           . ) );
    }
    //Add a new Declarative Model asset for all Types identified
    private void addDeclaredModels() {
        final StringBuilder types = new StringBuilder();
        if ( this..size() > 0 ) {
            for ( Asset declaredType : this. ) {
                types.appenddeclaredType.content );
            }
            this..addnew Asset"model",
                                        types.toString(),
                                        . ) );
        }
    }
    private String getFuncName(String line) {
        Matcher m = .matcherline );
        m.matches();
        return m.group( 1 );
    }
    private String getDeclarationName(String line) {
        Matcher m = .matcherline );
        m.matches();
        return m.group( 1 );
    }
    private boolean isDeclarationComplete(String line) {
        Matcher m = .matcherline );
        return m.matches();
    }
    private boolean isEnd(String line) {
        Matcher m = .matcherline );
        return m.matches();
    }

    
Consumes function to the ending curly bracket.

Parameters:
lines
currentFunc
    private void laConsumeBracketsToEnd(int counter,
                                        StringTokenizer lines,
                                        StringBuilder currentFunc) {
        /*
         * Check if the first line contains matching amount of brackets.
         */
        boolean multilineIsOpen = false;
        // Start counting brackets
        while ( lines.hasMoreTokens() ) {
            String line = lines.nextToken();
            currentFunc.appendline );
            currentFunc.append"\n" );
            if ( multilineIsOpen ) {
                int commentEnd = line.indexOf"*/" );
                if ( commentEnd != -1 ) {
                    multilineIsOpen = false;
                    line = line.substringcommentEnd );
                }
            } else {
                multilineIsOpen = checkIfMultilineCommentStartsline );
                line = removeCommentsline );
            }
            if ( !multilineIsOpen ) {
                counter = countBracketscounter,
                                         line );
            }
            if ( counter == 0 ) {
                break;
            }
        }
    }

    
Consumes Declaration to the "end".

Parameters:
lines
currentFunc
    private void laConsumeDeclarationToEnd(StringTokenizer lines,
                                           StringBuilder currentDeclaration) {
        boolean multilineIsOpen = false;
        while ( lines.hasMoreTokens() ) {
            String line = lines.nextToken();
            currentDeclaration.appendremoveCommentsline ) );
            currentDeclaration.append"\n" );
            if ( multilineIsOpen ) {
                int commentEnd = line.indexOf"*/" );
                if ( commentEnd != -1 ) {
                    multilineIsOpen = false;
                    line = line.substringcommentEnd );
                }
            } else {
                multilineIsOpen = checkIfMultilineCommentStartsline );
                line = removeCommentsline );
            }
            if ( isEndline ) ) {
                break;
            }
        }
    }

    

Parameters:
line
Returns:
    private boolean checkIfMultilineCommentStarts(String line) {
        int commentMultiLineStart = line.indexOf"/*" );
        int commentMultiLineEnd = line.indexOf"*/" );
        //        int commentSingleLine = line.indexOf( "//" );
        return commentMultiLineStart != -1 && commentMultiLineEnd == -1;
    }
    private int countBrackets(int counter,
                              String line) {
        char[] chars = line.toCharArray();
        for ( char aChar : chars ) {
            if ( aChar == '{' ) {
                counter++;
            } else if ( aChar == '}' ) {
                counter--;
            }
        }
        return counter;
    }
    private String removeComments(String line) {
        int commentMultiLineStart = line.indexOf"/*" );
        int commentMultiLineEnd = line.indexOf"*/" );
        int commentSingleLine = line.indexOf"//" );
        // Single line comment is first
        // Case: some code // /* */
        // Another case: some code // No comments
        if ( commentSingleLine != -1 && commentMultiLineStart > commentSingleLine ) {
            return line.substring( 0,
                                   commentSingleLine );
        }
        // There is only a start for the multiline comment.
        // Case: some code here /* commented out
        if ( commentMultiLineStart != -1 && commentMultiLineEnd == -1 ) {
            return line.substring( 0,
                                   commentMultiLineStart );
        }
        // Two ends are on the same line
        // some code /* comment */ some code
        if ( commentMultiLineStart != -1 && commentMultiLineEnd != -1 ) {
            line = line.substring( 0,
                                   commentMultiLineStart ) + line.substringcommentMultiLineEnd + "*/".length() );
            return line;
        }
        return line;
    }
    private void laConsumeToEnd(StringTokenizer lines,
                                StringBuilder currentRule,
                                String end,
                                boolean addLastLine) {
        String line;
        while ( lines.hasMoreTokens() ) {
            line = lines.nextToken();
            if ( line.trim().startsWithend ) ) {
                if ( addLastLine ) {
                    currentRule.appendline ).append"\n" );
                }
                break;
            }
            currentRule.appendline );
            currentRule.append"\n" );
        }
    }
    private void addRule(String ruleName,
                         StringBuilder currentRule) {
        ruleName = ruleName.replace'\'',
                                     ' ' );
        if ( this.isDSLEnabled() ) {
            this..addnew AssetruleName,
                                        currentRule.toString(),
                                        . ) );
        } else {
            this..addnew AssetruleName,
                                        currentRule.toString(),
                                        . ) );
        }
    }

    
Get the rule name from a declaration line
    public static String getRuleName(String linethrows DroolsParserException {
        DrlParser parser = new DrlParser();
        line = line + "\n when\n then \n end";
        RuleDescr rule = parser.parseline ).getRules().get( 0 );
        return rule.getName();
    }
    private String getPackage(String linethrows DroolsParserException {
        DrlParser parser = new DrlParser();
        return parser.parseline ).getName();
    }
    public List<AssetgetAssets() {
        return this.;
    }
    public String getPackageName() {
        return this.;
    }
    public String getPackageHeader() {
        return this..toString();
    }
    public boolean isDSLEnabled() {
        return this.;
    }

    
Holds a rule to import. The content does not include the "end".
    public static class Asset {
        public Asset(String name,
                     String content,
                     String format) {
            this. = name;
            this. = content;
            this. = format;
        }
        public final String format;
        public final String name;
        public final String content;
    }

    
This merges the toMerge new schtuff into the existing. Line by line, simple stuff.
    @SuppressWarnings("rawtypes")
    public static String mergeLines(String existing,
                                    String toMerge) {
        if ( toMerge == null || toMerge.equals"" ) ) {
            return existing;
        }
        if ( existing == null || existing.equals"" ) ) {
            return toMerge;
        }
        Set existingLines = new HashSet<String>( Arrays.asListexisting.split"\n" ) ) );
        String[] newLines = toMerge.split"\n" );
        for ( String newLine1 : newLines ) {
            String newLine = newLine1.trim();
            if ( !newLine.equals"" ) && !existingLines.containsnewLine1.trim() ) ) {
                existing = existing + "\n" + newLine1;
            }
        }
        return existing;
    }
New to GrepCode? Check out our FAQ X