Example usage for org.apache.commons.lang StringUtils substringBeforeLast

List of usage examples for org.apache.commons.lang StringUtils substringBeforeLast

Introduction

In this page you can find the example usage for org.apache.commons.lang StringUtils substringBeforeLast.

Prototype

public static String substringBeforeLast(String str, String separator) 

Source Link

Document

Gets the substring before the last occurrence of a separator.

Usage

From source file:org.bigmouth.nvwa.utils.PathUtils.java

/**
 * ?WebRoot//from w  ww .  ja v a2s.  c  o  m
 * 
 * @return WebRoot
 */
public static String getWebRootPath() {
    return StringUtils.substringBeforeLast(getWebInfPath(), "/");
}

From source file:org.cloudifysource.quality.iTests.framework.utils.network.OpenstackNetworkApiHelper.java

public String getGatewayForSubnet(final String subnetRange) {
    // calc the gateway address according to the subnet
    return StringUtils.substringBeforeLast(subnetRange, ".") + "." + DEFAULT_GATEWAY_SUFFIX;
}

From source file:org.cloudifysource.rest.util.RestUtils.java

/**
 * Creates a folder a unique name based on the given basicFolderName, inside the specified parent folder.
 * If the folder by that name already exists in the parent folder - a number is appended to that name, until
 * a unique name is found. e.g.: "myfolder1", "myfolder2" ... "myfolder99" (max index is set by maxAppender).
 * If all those names are already in use (meaning there are existing folders with these names) -
 * we create a completely new random name using "File.createTempFile".
 * /*www .  j  a  v  a2 s.  co  m*/
 * @param parentFolder The folder to contain the new folder created by this method.
 * @param basicFolderName The base name to be used for the new folder. Numbers might be appended to this name to 
 * reach uniqueness. 
 * @param maxAppender The maximum number appended to the basic folder name to reach uniqueness. If a unique name
 * is not found for the folder and the maximum is reached, a new random name using "File.createTempFile".
 * @return The unique name
 * @throws IOException Indicates a failure to generate a unique folder name
 */
public static String createUniqueFolderName(final File parentFolder, final String basicFolderName,
        final int maxAppender) throws IOException {

    int index = 0;
    boolean uniqueNameFound = false;
    String folderName = basicFolderName;

    while (!uniqueNameFound && index < maxAppender) {
        //create a new name (temp1, temp2... temp99)
        folderName = basicFolderName + (++index);

        File restTempFolder = new File(parentFolder, folderName);
        if (!restTempFolder.exists()) {
            uniqueNameFound = true;
        }
    }

    if (!uniqueNameFound) {
        //create folder with a new unique name
        File tempFile = File.createTempFile(folderName, ".tmp");
        tempFile.deleteOnExit();
        folderName = StringUtils.substringBeforeLast(tempFile.getName(), ".tmp");
        uniqueNameFound = true;
    }

    if (uniqueNameFound) {
        return folderName;
    } else {
        throw new IOException(CloudifyMessageKeys.UPLOAD_DIRECTORY_CREATION_FAILED.getName());
    }
}

From source file:org.codehaus.groovy.grails.web.binding.GrailsDataBinder.java

private Class<?> getPropertyTypeForPath(String propertyName) {
    Class<?> type = bean.getPropertyType(propertyName);
    if (type == null) {
        // type not available via BeanWrapper - this happens with e.g. empty list indexes - so
        // find type by examining GrailsDomainClass
        Object target = bean.getWrappedInstance();
        String path = propertyName.replaceAll("\\[.+?\\]", "");
        if (path.indexOf(PATH_SEPARATOR) > -1) {
            // transform x.y.z into value of x.y and path z
            String nestedProp = StringUtils.substringBeforeLast(propertyName, ".");
            target = bean.getPropertyValue(nestedProp);
            path = StringUtils.substringAfterLast(path, ".");
        }//from   w  ww .  j  a v a2s .com
        if (target != null) {
            type = getReferencedTypeForCollection(path, target);
        }
    }
    return type;
}

From source file:org.codice.ddf.catalog.ui.config.ConfigurationApplication.java

public String getProductName() {
    if (branding != null) {
        // Remove the version number
        return StringUtils.substringBeforeLast(branding.getProductName(), " ");
    } else {//from w  w  w  .  j a  v  a  2s. c  o m
        return "";
    }
}

From source file:org.codice.ddf.spatial.ogc.csw.catalog.common.GetRecordsRequest.java

/**
 * Convert the KVP values into a GetRecordsType, validates format of fields and enumeration
 * constraints required to meet the schema requirements of the GetRecordsType. No further
 * validation is done at this point/*ww  w .  j  av  a2s . co  m*/
 *
 * @return GetRecordsType representation of this key-value representation
 * @throws CswException
 *             An exception when some field cannot be converted to the equivalent GetRecordsType
 *             value
 */
public GetRecordsType get202RecordsType() throws CswException {
    GetRecordsType getRecords = new GetRecordsType();

    getRecords.setOutputSchema(getOutputSchema());
    getRecords.setRequestId(getRequestId());

    if (getMaxRecords() != null) {
        getRecords.setMaxRecords(getMaxRecords());
    }
    if (getStartPosition() != null) {
        getRecords.setStartPosition(getStartPosition());
    }
    if (getOutputFormat() != null) {
        getRecords.setOutputFormat(getOutputFormat());
    }
    if (getResponseHandler() != null) {
        getRecords.setResponseHandler(Arrays.asList(getResponseHandler()));
    }
    if (getResultType() != null) {
        try {
            getRecords.setResultType(ResultType.fromValue(getResultType()));
        } catch (IllegalArgumentException iae) {
            LOGGER.warn("Failed to find \"{}\" as a valid ResultType, Exception {}", getResultType(), iae);
            throw new CswException(
                    "A CSW getRecords request ResultType must be \"hits\", \"results\", or \"validate\"");
        }
    }
    if (getDistributedSearch() != null && getDistributedSearch()) {
        DistributedSearchType disSearch = new DistributedSearchType();
        disSearch.setHopCount(getHopCount());
        getRecords.setDistributedSearch(disSearch);
    }

    QueryType query = new QueryType();

    Map<String, String> namespaces = parseNamespaces(getNamespace());
    List<QName> typeNames = typeStringToQNames(getTypeNames(), namespaces);
    query.setTypeNames(typeNames);

    if (getElementName() != null && getElementSetName() != null) {
        LOGGER.warn(
                "CSW getRecords request received with mutually exclusive ElementName and SetElementName set");
        throw new CswException(
                "A CSW getRecords request can only have an \"ElementName\" or an \"ElementSetName\"");
    }

    if (getElementName() != null) {
        query.setElementName(typeStringToQNames(getElementName(), namespaces));
    }

    if (getElementSetName() != null) {
        try {
            ElementSetNameType eleSetName = new ElementSetNameType();
            eleSetName.setTypeNames(typeNames);
            eleSetName.setValue(ElementSetType.fromValue(getElementSetName()));
            query.setElementSetName(eleSetName);
        } catch (IllegalArgumentException iae) {
            LOGGER.warn("Failed to find \"{}\" as a valid elementSetType, Exception {}", getElementSetName(),
                    iae);
            throw new CswException(
                    "A CSW getRecords request ElementSetType must be \"brief\", \"summary\", or \"full\"");
        }

    }

    if (getSortBy() != null) {
        SortByType sort = new SortByType();

        List<SortPropertyType> sortProps = new LinkedList<SortPropertyType>();

        String[] sortOptions = getSortBy().split(",");

        for (String sortOption : sortOptions) {
            if (sortOption.lastIndexOf(':') < 1) {
                throw new CswException("Invalid Sort Order format: " + getSortBy());
            }
            SortPropertyType sortProperty = new SortPropertyType();
            PropertyNameType propertyName = new PropertyNameType();

            String propName = StringUtils.substringBeforeLast(sortOption, ":");
            String direction = StringUtils.substringAfterLast(sortOption, ":");
            propertyName.setContent(Arrays.asList((Object) propName));
            SortOrderType sortOrder;

            if (direction.equals("A")) {
                sortOrder = SortOrderType.ASC;
            } else if (direction.equals("D")) {
                sortOrder = SortOrderType.DESC;
            } else {
                throw new CswException("Invalid Sort Order format: " + getSortBy());
            }

            sortProperty.setPropertyName(propertyName);
            sortProperty.setSortOrder(sortOrder);

            sortProps.add(sortProperty);
        }

        sort.setSortProperty(sortProps);

        query.setElementName(typeStringToQNames(getElementName(), namespaces));
        query.setSortBy(sort);
    }

    if (getConstraint() != null) {
        QueryConstraintType queryConstraint = new QueryConstraintType();

        if (getConstraintLanguage().equalsIgnoreCase(CswConstants.CONSTRAINT_LANGUAGE_CQL)) {
            queryConstraint.setCqlText(getConstraint());
        } else if (getConstraintLanguage().equalsIgnoreCase(CswConstants.CONSTRAINT_LANGUAGE_FILTER)) {
            try {
                XMLInputFactory xmlInputFactory = XMLInputFactory.newFactory();
                xmlInputFactory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
                xmlInputFactory.setProperty(XMLInputFactory.SUPPORT_DTD, false);
                XMLStreamReader xmlStreamReader = xmlInputFactory
                        .createXMLStreamReader(new StringReader(constraint));

                Unmarshaller unmarshaller = JAX_BCONTEXT.createUnmarshaller();
                @SuppressWarnings("unchecked")
                JAXBElement<FilterType> jaxbFilter = (JAXBElement<FilterType>) unmarshaller
                        .unmarshal(xmlStreamReader);
                queryConstraint.setFilter(jaxbFilter.getValue());
            } catch (JAXBException e) {
                throw new CswException("JAXBException parsing OGC Filter:" + getConstraint(), e);
            } catch (Exception e) {
                throw new CswException("Unable to parse OGC Filter:" + getConstraint(), e);
            }
        } else {
            throw new CswException("Invalid Constraint Language defined: " + getConstraintLanguage());
        }
        query.setConstraint(queryConstraint);
    }

    JAXBElement<QueryType> jaxbQuery = new JAXBElement<QueryType>(new QName(CswConstants.CSW_OUTPUT_SCHEMA),
            QueryType.class, query);

    getRecords.setAbstractQuery(jaxbQuery);

    return getRecords;
}

From source file:org.codice.solr.factory.TestConfigurationFileProxy.java

private File createTestFile(String filename) throws IOException {
    File file = tempFolder.newFile(filename);

    OutputStream stream = new FileOutputStream(file);
    IOUtils.write(StringUtils.substringBeforeLast(filename, ".txt"), stream);
    IOUtils.closeQuietly(stream);//from  w  w w. j av  a 2s.c o m

    return file;
}

From source file:org.debux.webmotion.netbeans.completion.WebMotionCompletion.java

@Override
public CompletionTask createTask(int queryType, JTextComponent component) {
    if (queryType != CompletionProvider.COMPLETION_QUERY_TYPE) {
        return null;
    }/*from ww  w  .jav  a2  s  .  c  o  m*/

    return new AsyncCompletionTask(new AsyncCompletionQuery() {
        @Override
        protected void query(CompletionResultSet completionResultSet, Document document, int caretOffset) {

            String filter = null;
            int startOffset = caretOffset - 1;
            int column = 0;

            try {
                // Get filter
                StyledDocument doc = (StyledDocument) document;
                int lineStartOffset = Utils.getRowFirstNonWhite(doc, caretOffset);
                char[] line = doc.getText(lineStartOffset, caretOffset - lineStartOffset).toCharArray();
                int whiteOffset = Utils.indexOfWhite(line);
                filter = new String(line, whiteOffset + 1, line.length - whiteOffset - 1);
                if (whiteOffset > 0) {
                    startOffset = lineStartOffset + whiteOffset + 1;
                } else {
                    startOffset = lineStartOffset;
                }

                // Get position
                Element lineElement = doc.getParagraphElement(caretOffset);
                String lineValue = doc.getText(lineElement.getStartOffset(),
                        caretOffset - lineElement.getStartOffset());

                Pattern pattern = Pattern.compile("\\s+");
                Matcher matcher = pattern.matcher(lineValue);
                while (matcher.find()) {
                    column++;
                }

            } catch (BadLocationException ex) {
                Exceptions.printStackTrace(ex);
            }

            // Get section
            Section section = LexerUtils.getSection(document, caretOffset);

            // Get the package in configuration
            String packageBase = Utils.getPackageValue("package.base", null);
            String packageTarget = null;
            String filterSuperClass = null;
            String separator = "/";
            boolean onlyFolder = false;
            String onlyMimeType = null;

            String[] keywords = {};
            if (section != null) {

                if (section == Section.CONFIG) {
                    keywords = KEYWORDS_CONFIG;

                } else if (section == Section.ERRORS && column % 2 == 0) {
                    keywords = KEYWORDS_ERROR;
                    packageTarget = "";
                    filterSuperClass = "java.lang.Exception";

                } else if (section == Section.ERRORS && column % 2 == 1) {
                    keywords = KEYWORDS_ERROR_ACTION;

                    if (filter.startsWith("view:")) {
                        packageTarget = Utils.getPackageValue("package.views", null);

                    } else if (filter.startsWith("action:") || !filter.contains(":")) {
                        packageTarget = Utils.getPackageValue("package.errors", packageBase);
                        filterSuperClass = "org.debux.webmotion.server.WebMotionController";
                    }

                } else if (section == Section.EXTENSIONS && column % 2 == 0) {
                    keywords = KEYWORDS_EXTENSION;

                } else if (section == Section.EXTENSIONS && column % 2 == 1) {
                    packageTarget = "";
                    onlyMimeType = WebMotionLanguage.MIME_TYPE;

                } else if (section == Section.FILTERS && column % 3 == 0) {
                    keywords = KEYWORDS_METHODS;

                } else if (section == Section.FILTERS && column % 3 == 1) {
                    keywords = KEYWORDS_FILTER;

                } else if (section == Section.FILTERS && column % 3 == 2) {
                    keywords = KEYWORDS_FILTER_ACTION;
                    packageTarget = Utils.getPackageValue("package.filters", packageBase);
                    filterSuperClass = "org.debux.webmotion.server.WebMotionFilter";

                } else if (section == Section.ACTIONS && column % 3 == 0) {
                    keywords = KEYWORDS_METHODS;

                } else if (section == Section.ACTIONS && column % 3 == 1) {
                    keywords = KEYWORDS_ACTION;

                } else if (section == Section.ACTIONS && column % 3 == 2) {
                    keywords = KEYWORDS_ACTION_ACTION;

                    if (filter.startsWith("view:")) {
                        packageTarget = Utils.getPackageValue("package.views", null);

                    } else if (filter.startsWith("action:") || !filter.contains(":")) {
                        packageTarget = Utils.getPackageValue("package.actions", packageBase);
                        filterSuperClass = "org.debux.webmotion.server.WebMotionController";
                    }

                } else if (section == Section.PROPERTIES) {
                    keywords = KEYWORDS_SECTIONS;
                }

            } else {
                keywords = KEYWORDS_SECTIONS;
            }

            // Keywords
            if (keywords == KEYWORDS_METHODS && filter.contains(",")) {
                keywords = KEYWORDS_METHOD;
                startOffset += StringUtils.substringBeforeLast(filter, ",").length();
                filter = StringUtils.substringAfterLast(filter, ",");

            } else if (keywords == KEYWORDS_ERROR && filter.contains("code:")) {
                keywords = KEYWORDS_ERROR_CODE;
                startOffset += "code:".length();
                filter = filter.substring("code:".length());
                packageTarget = null;

            } else if (filter.startsWith("javac.debug=") || filter.startsWith("server.async=")
                    || filter.startsWith("server.static.autodetect=")) {
                keywords = KEYWORDS_CONFIG_BOOLEAN;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("server.error.page=")) {
                keywords = KEYWORDS_CONFIG_ERROR;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("server.controller.scope=")) {
                keywords = KEYWORDS_CONFIG_SCOPE;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("package.base=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=").replaceAll("\\.", "/");

                packageTarget = "";
                filterSuperClass = null;
                separator = ".";
                onlyFolder = true;

            } else if (filter.startsWith("package.views=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=").replaceAll("\\.", "/");

                packageTarget = "";
                filterSuperClass = null;
                separator = "/";
                onlyFolder = true;

            } else if (filter.startsWith("server.listener.class=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

                packageTarget = "";
                filterSuperClass = "org.debux.webmotion.server.WebMotionServerListener";

            } else if (filter.startsWith("server.main.handler.class=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

                packageTarget = "";
                filterSuperClass = "org.debux.webmotion.server.WebMotionHandler";

            } else if (filter.startsWith("default.render=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

                packageTarget = "";
                filterSuperClass = "org.debux.webmotion.server.render.Render";

            } else if (filter.startsWith("package.actions=") || filter.startsWith("package.filters=")
                    || filter.startsWith("package.errors=")) {
                keywords = KEYWORDS_EMPTY;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

                packageTarget = Utils.getPackageValue("package.base", null);
                filterSuperClass = null;
                separator = ".";
                onlyFolder = true;

            } else if (filter.startsWith("server.encoding=")) {
                keywords = KEYWORDS_CONFIG_ENCODING;
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("server.secret=")) {
                keywords = new String[] { RandomStringUtils.random(31, true, true) };
                startOffset += StringUtils.substringBefore(filter, "=").length() + 1;
                filter = StringUtils.substringAfter(filter, "=");

            } else if (filter.startsWith("javac.debug") || filter.startsWith("server.async")
                    || filter.startsWith("server.static.autodetect") || filter.startsWith("server.error.page")
                    || filter.startsWith("server.controller.scope") || filter.startsWith("package.base")
                    || filter.startsWith("package.views") || filter.startsWith("server.listener.class")
                    || filter.startsWith("server.main.handler.class") || filter.startsWith("package.actions")
                    || filter.startsWith("package.filters") || filter.startsWith("package.errors")
                    || filter.startsWith("server.encoding") || filter.startsWith("server.secret")) {

                keywords = KEYWORDS_CONFIG_EQUAL;
                startOffset += StringUtils.substringBefore(filter, "=").length();
                filter = "";
            }

            for (String keyword : keywords) {
                if (keyword.startsWith(filter)) {
                    completionResultSet.addItem(new WebMotionCompletionItem(keyword, startOffset, caretOffset));
                }
            }

            if (packageTarget != null) {

                // File
                if (filterSuperClass == null) {
                    String path = packageTarget.replaceAll("\\.", "/");
                    String filterFile = filter;
                    int startOffsetFile = startOffset;
                    Set<String> names = new HashSet<String>();

                    if (filter.startsWith("view:")) {
                        filterFile = filter.replaceFirst("view:", "");
                        startOffsetFile += "view:".length();
                    }

                    if (filterFile.contains("/")) {
                        String current = StringUtils.substringBeforeLast(filterFile, "/");
                        path += current;
                        startOffsetFile += current.length() + 1;
                        filterFile = StringUtils.substringAfterLast(filterFile, "/");

                    } else if (packageTarget.isEmpty() && separator.equals("/")) {
                        String fileName = "WEB-INF";
                        names.add(fileName);
                        if (fileName.startsWith(filterFile)) {
                            if (!fileName.equals(filterFile)) {
                                completionResultSet.addItem(
                                        new WebMotionCompletionItem(fileName, startOffsetFile, caretOffset));
                            } else {
                                completionResultSet.addItem(new WebMotionCompletionItem(separator,
                                        startOffsetFile + fileName.length(), caretOffset));
                            }
                        }
                    }

                    GlobalPathRegistry registry = GlobalPathRegistry.getDefault();
                    List<ClassPath> paths = new ArrayList<ClassPath>();
                    paths.addAll(registry.getPaths(ClassPath.BOOT));
                    paths.addAll(registry.getPaths(ClassPath.COMPILE));
                    paths.addAll(registry.getPaths(ClassPath.SOURCE));

                    for (ClassPath classPath : paths) {
                        FileObject resource = classPath.findResource(path);

                        if (resource != null) {
                            FileObject[] children = resource.getChildren();
                            for (FileObject child : children) {
                                String fileName = child.getNameExt();

                                if ((!onlyFolder || onlyFolder && child.isFolder())
                                        && (onlyMimeType == null || child.isFolder()
                                                || onlyMimeType != null
                                                        && child.getMIMEType().equals(onlyMimeType))
                                        && fileName.startsWith(filterFile) && !fileName.startsWith(".")) {

                                    if (!names.contains(fileName)) {
                                        if (!fileName.equals(filterFile)) {
                                            completionResultSet.addItem(new WebMotionCompletionItem(fileName,
                                                    startOffsetFile, caretOffset));
                                        } else {
                                            completionResultSet.addItem(new WebMotionCompletionItem(separator,
                                                    startOffsetFile + fileName.length(), caretOffset));
                                        }
                                        names.add(fileName);
                                    }
                                }
                            }
                        }
                    }
                    completionResultSet.finish();

                } else {

                    // Class
                    if (filter.contains(":") && !filter.startsWith("code:")) {
                        startOffset += StringUtils.substringBefore(filter, ":").length() + 1;
                        filter = StringUtils.substringAfter(filter, ":");
                    }

                    int startOffsetClass = startOffset;
                    if (filter.contains(".")) {
                        startOffsetClass += StringUtils.substringBeforeLast(filter, ".").length() + 1;
                    }

                    String fullName = packageTarget + filter;
                    String rootPackage = "";
                    String filerPackage = fullName;
                    if (fullName.contains(".")) {
                        rootPackage = StringUtils.substringBeforeLast(fullName, ".");
                        filerPackage = StringUtils.substringAfterLast(fullName, ".");
                    }

                    String folderPackage = rootPackage.replaceAll("\\.", "/");

                    FileObject fo = Utils.getFO(document);
                    ClassPath bootCp = ClassPath.getClassPath(fo, ClassPath.BOOT);
                    ClassPath compileCp = ClassPath.getClassPath(fo, ClassPath.COMPILE);
                    ClassPath sourcePath = ClassPath.getClassPath(fo, ClassPath.SOURCE);
                    ClasspathInfo info = ClasspathInfo.create(bootCp, compileCp, sourcePath);
                    JavaSource src = JavaSource.create(info);

                    final String filterSuperJavaClass = filterSuperClass;
                    final CompletionResultSet completionResultSetClass = completionResultSet;
                    final int startOffsetJavaClass = startOffsetClass;
                    final int caretOffsetClass = caretOffset;

                    // Package names
                    List<FileObject> folders = new ArrayList<FileObject>();
                    folders.addAll(bootCp.findAllResources(folderPackage));
                    folders.addAll(compileCp.findAllResources(folderPackage));
                    folders.addAll(sourcePath.findAllResources(folderPackage));

                    final String rootPackageFilter = rootPackage;
                    final String filterPackageFilter = filerPackage;
                    final Set<String> names = new HashSet<String>();
                    for (final FileObject folder : folders) {

                        try {
                            src.runUserActionTask(new CancellableTask<CompilationController>() {
                                @Override
                                public void cancel() {
                                }

                                @Override
                                public void run(CompilationController cu) throws Exception {
                                    Types types = cu.getTypes();
                                    Elements elements = cu.getElements();

                                    TypeElement superElement = elements.getTypeElement(filterSuperJavaClass);
                                    TypeMirror superType = null;
                                    if (superElement != null) {
                                        superType = superElement.asType();
                                    }

                                    FileObject[] children = folder.getChildren();
                                    for (FileObject child : children) {
                                        String name = child.getName();
                                        if (!name.startsWith(".") && name.startsWith(filterPackageFilter)) {

                                            if (!names.contains(name)) {
                                                names.add(name);

                                                TypeElement element;
                                                if (rootPackageFilter.isEmpty()) {
                                                    element = elements.getTypeElement(name);
                                                } else {
                                                    element = elements
                                                            .getTypeElement(rootPackageFilter + "." + name);
                                                }

                                                if (name.equals(filterPackageFilter)) {

                                                    if (element == null
                                                            || element.getKind() != ElementKind.CLASS
                                                            || element.getKind() == ElementKind.CLASS
                                                                    && (filterSuperJavaClass.equals(
                                                                            "org.debux.webmotion.server.WebMotionFilter")
                                                                            || filterSuperJavaClass.equals(
                                                                                    "org.debux.webmotion.server.WebMotionController"))) {

                                                        WebMotionCompletionItem item = new WebMotionCompletionItem(
                                                                ".", startOffsetJavaClass + name.length(),
                                                                caretOffsetClass);
                                                        completionResultSetClass.addItem(item);
                                                    }

                                                } else if (child.isFolder()) {
                                                    WebMotionCompletionItem item = new WebMotionCompletionItem(
                                                            name, startOffsetJavaClass, caretOffsetClass);
                                                    completionResultSetClass.addItem(item);

                                                } else if (element != null) {
                                                    Set<Modifier> modifiers = element.getModifiers();
                                                    ElementKind kind = element.getKind();
                                                    TypeMirror resolveType = element.asType();

                                                    if (kind == ElementKind.CLASS
                                                            && modifiers.contains(Modifier.PUBLIC)
                                                            && !modifiers.contains(Modifier.ABSTRACT)
                                                            && superType != null
                                                            && types.isSubtype(resolveType, superType)) {

                                                        WebMotionCompletionItem item = new WebMotionCompletionItem(
                                                                name, cu, element, startOffsetJavaClass,
                                                                caretOffsetClass);
                                                        completionResultSetClass.addItem(item);
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }, false);

                        } catch (IOException ex) {
                            Exceptions.printStackTrace(ex);
                        }
                    }

                    // Method
                    if (filter.contains(".") && (filterSuperJavaClass
                            .equals("org.debux.webmotion.server.WebMotionFilter")
                            || filterSuperJavaClass.equals("org.debux.webmotion.server.WebMotionController"))) {

                        final String className = StringUtils.substringBeforeLast(filter, ".");
                        final String fullClassName = packageTarget + className;
                        final String filterMethod = StringUtils.substringAfterLast(filter, ".");

                        final CompletionResultSet completionResultSetJavaSource = completionResultSet;
                        final int startOffsetJavaSource = startOffset + className.length() + 1;
                        final int caretOffesetJavaSource = caretOffset;

                        try {
                            src.runUserActionTask(new CancellableTask<CompilationController>() {

                                @Override
                                public void cancel() {
                                }

                                @Override
                                public void run(CompilationController cu) throws Exception {
                                    cu.toPhase(JavaSource.Phase.PARSED);

                                    Elements elements = cu.getElements();
                                    TypeElement classElement = elements.getTypeElement(fullClassName);
                                    if (classElement != null) {

                                        List<? extends javax.lang.model.element.Element> members = elements
                                                .getAllMembers(classElement);
                                        for (javax.lang.model.element.Element member : members) {
                                            if (member.getKind() == ElementKind.METHOD) {

                                                Set<Modifier> modifiers = member.getModifiers();
                                                String methodName = member.getSimpleName().toString();
                                                String className = member.getEnclosingElement().getSimpleName()
                                                        .toString();

                                                if (!"Object".equals(className)
                                                        && !"WebMotionController".equals(className)
                                                        && !"WebMotionFilter".equals(className)
                                                        && modifiers.contains(Modifier.PUBLIC)
                                                        && !modifiers.contains(Modifier.STATIC)
                                                        && methodName.startsWith(filterMethod)) {

                                                    WebMotionCompletionItem item = new WebMotionCompletionItem(
                                                            methodName, cu, member, startOffsetJavaSource,
                                                            caretOffesetJavaSource);
                                                    completionResultSetJavaSource.addItem(item);
                                                }
                                            }
                                        }
                                    }

                                    completionResultSetJavaSource.finish();
                                }
                            }, false);
                        } catch (IOException ex) {
                            Exceptions.printStackTrace(ex);
                        }
                    } else {
                        completionResultSet.finish();
                    }
                }

            } else {
                completionResultSet.finish();
            }
        }
    }, component);
}

From source file:org.debux.webmotion.netbeans.hints.ActionRule.java

@Override
public void run(RuleContext context, final List<Hint> hints) {
    WebMotionParserResult parserResult = (WebMotionParserResult) context.parserResult;

    Source source = parserResult.getSnapshot().getSource();
    final Document document = source.getDocument(false);
    final FileObject fileObject = source.getFileObject();

    FileObject fo = Utils.getFO(document);
    ClassPath bootCp = ClassPath.getClassPath(fo, ClassPath.BOOT);
    ClassPath compileCp = ClassPath.getClassPath(fo, ClassPath.COMPILE);
    ClassPath sourcePath = ClassPath.getClassPath(fo, ClassPath.SOURCE);
    ClasspathInfo info = ClasspathInfo.create(bootCp, compileCp, sourcePath);
    final JavaSource src = JavaSource.create(info);

    try {//  w ww  .j a  va  2  s  .c om
        src.runUserActionTask(new CancellableTask<CompilationController>() {
            @Override
            public void cancel() {
            }

            @Override
            public void run(CompilationController cu) throws Exception {
                String packageBase = Utils.getPackageValue("package.base", null);

                List<OffsetRange> tokens = LexerUtils.getTokens(document, "FILTER_ACTION");
                String packageTarget = Utils.getPackageValue("package.filters", packageBase);
                String superClass = "org.debux.webmotion.server.WebMotionFilter";

                runAction(cu, tokens, packageTarget, superClass);

                tokens = LexerUtils.getTokens(document, "ERROR_ACTION_JAVA");
                packageTarget = Utils.getPackageValue("package.errors", packageBase);
                superClass = "org.debux.webmotion.server.WebMotionController";

                runAction(cu, tokens, packageTarget, superClass);

                tokens = LexerUtils.getTokens(document, "ACTION_ACTION_IDENTIFIER",
                        "ACTION_ACTION_JAVA_IDENTIFIER", "ACTION_ACTION_JAVA_QUALIFIED_IDENTIFIER",
                        "ACTION_ACTION_JAVA_VARIABLE");
                packageTarget = Utils.getPackageValue("package.actions", packageBase);
                superClass = "org.debux.webmotion.server.WebMotionController";

                runAction(cu, tokens, packageTarget, superClass);
            }

            protected void runAction(CompilationController cu, List<OffsetRange> tokens, String packageTarget,
                    String superClass) {
                Elements elements = cu.getElements();
                Types types = cu.getTypes();
                for (OffsetRange range : tokens) {
                    try {
                        String value = LexerUtils.getText(document, range);
                        String className = StringUtils.substringBeforeLast(value, ".");
                        String methodName = StringUtils.substringAfterLast(value, ".");

                        if (Utils.isNotVariable(className)) {
                            TypeElement classElement = elements.getTypeElement(packageTarget + className);
                            if (classElement != null) {

                                // Check class
                                TypeElement controllerElement = elements.getTypeElement(superClass);
                                if (controllerElement != null) {
                                    TypeMirror controllerType = controllerElement.asType();

                                    Set<Modifier> modifiers = classElement.getModifiers();
                                    ElementKind kind = classElement.getKind();
                                    TypeMirror resolveType = classElement.asType();

                                    if (kind == ElementKind.CLASS) {
                                        if (!modifiers.contains(Modifier.PUBLIC)) {
                                            hints.add(new Hint(ActionRule.this, "The class is not public",
                                                    fileObject, range,
                                                    WebMotionHintsProvider.asList(
                                                            new PublicModifierClassFix(src, classElement)),
                                                    100));
                                        }
                                        if (modifiers.contains(Modifier.ABSTRACT)) {
                                            hints.add(new Hint(ActionRule.this, "The class is abstract",
                                                    fileObject, range,
                                                    WebMotionHintsProvider.asList(
                                                            new AbstractModifierClassFix(src, classElement)),
                                                    100));
                                        }
                                        if (!types.isSubtype(resolveType, controllerType)) {
                                            hints.add(new Hint(ActionRule.this,
                                                    "Requires super class " + superClass, fileObject, range,
                                                    WebMotionHintsProvider.asList(
                                                            new ExtendsClassFix(src, classElement, superClass)),
                                                    100));
                                        }
                                    }
                                }

                                // Check method
                                if (Utils.isNotVariable(methodName)) {
                                    List<? extends Element> members = elements.getAllMembers(classElement);
                                    Element method = null;
                                    for (Element member : members) {
                                        ElementKind kind = member.getKind();
                                        String name = member.getSimpleName().toString();
                                        if (kind == ElementKind.METHOD && name.equals(methodName)) {
                                            method = member;
                                            break;
                                        }
                                    }

                                    if (method != null) {
                                        Set<Modifier> modifiers = method.getModifiers();
                                        String currentClass = method.getEnclosingElement().getSimpleName()
                                                .toString();

                                        if ("Object".equals(currentClass)
                                                || "WebMotionController".equals(currentClass)
                                                || "WebMotionFilter".equals(currentClass)) {
                                            hints.add(new Hint(ActionRule.this, "Invalid method", fileObject,
                                                    range, WebMotionHintsProvider.NO_FIXES, 100));
                                        }
                                        if (!modifiers.contains(Modifier.PUBLIC)) {
                                            hints.add(
                                                    new Hint(ActionRule.this, "The method is not public",
                                                            fileObject, range,
                                                            WebMotionHintsProvider
                                                                    .asList(new PublicModifierMethodFix(src,
                                                                            classElement, methodName)),
                                                            100));
                                        }
                                        if (modifiers.contains(Modifier.STATIC)) {
                                            hints.add(
                                                    new Hint(ActionRule.this, "The method is static",
                                                            fileObject, range,
                                                            WebMotionHintsProvider
                                                                    .asList(new StaticModifierMethodFix(src,
                                                                            classElement, methodName)),
                                                            100));
                                        }

                                    } else {
                                        hints.add(new Hint(ActionRule.this, "Invalid method", fileObject, range,
                                                WebMotionHintsProvider.asList(
                                                        new MethodClassFix(src, classElement, methodName)),
                                                100));
                                    }
                                }

                            } else {
                                hints.add(new Hint(ActionRule.this, "Invalid class", fileObject, range,
                                        WebMotionHintsProvider.asList(
                                                new CreateClassFix(src, packageTarget, superClass, className)),
                                        100));
                            }
                        }
                    } catch (BadLocationException ex) {
                        Exceptions.printStackTrace(ex);
                    }
                }
            }
        }, false);
    } catch (IOException ex) {
        Exceptions.printStackTrace(ex);
    }
}

From source file:org.debux.webmotion.netbeans.hints.CreateClassFix.java

@Override
public void implement() throws Exception {
    ClasspathInfo classpathInfo = src.getClasspathInfo();
    ClassPath classPath = classpathInfo.getClassPath(ClasspathInfo.PathKind.SOURCE);
    FileObject targetSourceRoot = classPath.findResource(packageTarget.replaceAll("\\.", "/"));

    String packageName = "";
    String simpleName = fullClassName;
    if (fullClassName.contains(".")) {
        packageName = StringUtils.substringBeforeLast(fullClassName, ".");
        simpleName = StringUtils.substringAfterLast(fullClassName, ".");
    }/*from   w w  w.  jav a  2 s. co  m*/

    FileObject pack = FileUtil.createFolder(targetSourceRoot, packageName.replace('.', '/')); // NOI18N
    FileObject classTemplate = FileUtil.getConfigFile("Templates/Classes/Class.java");
    FileObject target;
    if (classTemplate != null) {
        DataObject classTemplateDO = DataObject.find(classTemplate);
        DataObject od = classTemplateDO.createFromTemplate(DataFolder.findFolder(pack), simpleName);
        target = od.getPrimaryFile();
    } else {
        target = FileUtil.createData(pack, simpleName + ".java");
    }

    JavaSource.forFileObject(target).runModificationTask(new Task<WorkingCopy>() {
        @Override
        public void run(WorkingCopy workingCopy) throws Exception {
            workingCopy.toPhase(JavaSource.Phase.RESOLVED);
            TreeMaker make = workingCopy.getTreeMaker();
            CompilationUnitTree cut = workingCopy.getCompilationUnit();
            for (Tree type : cut.getTypeDecls()) {
                if (Tree.Kind.CLASS == type.getKind()) {
                    ClassTree clazz = (ClassTree) type;
                    TypeElement element = workingCopy.getElements().getTypeElement(superClass);
                    ExpressionTree implementsClause = make.QualIdent(element);
                    ClassTree modifiedClazz = make.setExtends(clazz, implementsClause);
                    workingCopy.rewrite(clazz, modifiedClazz);
                }
            }
        }
    }).commit();
}