Java StringGroovyMethods类代码示例

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
private void addInstallTask(final Project project, final Distribution distribution) {
    String taskName = TASK_INSTALL_NAME;
    if (!MAIN_DISTRIBUTION_NAME.equals(distribution.getName())) {
        taskName = "install" + StringGroovyMethods.capitalize(distribution.getName()) + "Dist";
    }

    Sync installTask = project.getTasks().create(taskName, Sync.class);
    installTask.setDescription("Installs the project as a distribution as-is.");
    installTask.setGroup(DISTRIBUTION_GROUP);
    installTask.with(distribution.getContents());
    installTask.into(new Callable<File>() {
        @Override
        public File call() throws Exception {
            return project.file("" + project.getBuildDir() + "/install/" + distribution.getBaseName());
        }
    });
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
/**
 * Escape the following characters {@code " ' & < >} with their XML entities, e.g.
 * {@code "bread" & "butter"} becomes {@code &quot;bread&quot; &amp; &quot;butter&quot}.
 * Notes:<ul>
 * <li>Supports only the five basic XML entities (gt, lt, quot, amp, apos)</li>
 * <li>Does not escape control characters</li>
 * <li>Does not support DTDs or external entities</li>
 * <li>Does not treat surrogate pairs specially</li>
 * <li>Does not perform Unicode validation on its input</li>
 * </ul>
 *
 * @param orig the original String
 * @return A new string in which all characters that require escaping
 *         have been replaced with the corresponding XML entities.
 * @see #escapeControlCharacters(String)
 */
public static String escapeXml(String orig) {
    return StringGroovyMethods.collectReplacements(orig, new Closure<String>(null) {
        public String doCall(Character arg) {
            switch (arg) {
                case '&':
                    return "&amp;";
                case '<':
                    return "&lt;";
                case '>':
                    return "&gt;";
                case '"':
                    return "&quot;";
                case '\'':
                    return "&apos;";
            }
            return null;
        }
    });
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
public static String replaceHexEscapes(String text) {
	if (!text.contains(BACKSLASH)) {
		return text;
	}

	Pattern p = Pattern.compile("(\\\\*)\\\\u([0-9abcdefABCDEF]{4})");
	return StringGroovyMethods.replaceAll((CharSequence) text, p, new Closure<Void>(null, null) {
		Object doCall(String _0, String _1, String _2) {
			if (isLengthOdd(_1)) {
				return _0;
			}

			return _1 + new String(Character.toChars(Integer.parseInt(_2, 16)));
		}
	});
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
public static String replaceOctalEscapes(String text) {
	if (!text.contains(BACKSLASH)) {
		return text;
	}

	Pattern p = Pattern.compile("(\\\\*)\\\\([0-3]?[0-7]?[0-7])");
	return StringGroovyMethods.replaceAll((CharSequence) text, p, new Closure<Void>(null, null) {
		Object doCall(String _0, String _1, String _2) {
			if (isLengthOdd(_1)) {
				return _0;
			}

			return _1 + new String(Character.toChars(Integer.parseInt(_2, 8)));
		}
	});
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
public static String replaceStandardEscapes(String text) {
	if (!text.contains(BACKSLASH)) {
		return text;
	}

	Pattern p = Pattern.compile("(\\\\*)\\\\([btnfr\"'])");

	String result = StringGroovyMethods.replaceAll((CharSequence) text, p, new Closure<Void>(null, null) {
		Object doCall(String _0, String _1, String _2) {
			if (isLengthOdd(_1)) {
				return _0;
			}

			Character character = STANDARD_ESCAPES.get(_2.charAt(0));
			return _1 + (character != null ? character : _2);
		}
	});

	return replace(result,"\\\\", "\\");
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
private static String replaceLineEscape(String text) {
	if (!text.contains(BACKSLASH)) {
		return text;
	}

	Pattern p = Pattern.compile("(\\\\*)\\\\\r?\n");
	text = StringGroovyMethods.replaceAll((CharSequence) text, p, new Closure<Void>(null, null) {
		Object doCall(String _0, String _1) {
			if (isLengthOdd(_1)) {
				return _0;
			}

			return _1;
		}
	});

	return text;
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
public String toString() {
    List buffer = new ArrayList();

    if (this.years != 0) buffer.add(this.years + " years");
    if (this.months != 0) buffer.add(this.months + " months");
    if (this.days != 0) buffer.add(this.days + " days");
    if (this.hours != 0) buffer.add(this.hours + " hours");
    if (this.minutes != 0) buffer.add(this.minutes + " minutes");

    if (this.seconds != 0 || this.millis != 0) {
        int norm_millis = this.millis % 1000;
        int norm_seconds = this.seconds + DefaultGroovyMethods.intdiv(this.millis - norm_millis, 1000).intValue();
        CharSequence millisToPad = "" + Math.abs(norm_millis);
        buffer.add((norm_seconds == 0 ? (norm_millis < 0 ? "-0" : "0") : norm_seconds) + "." + StringGroovyMethods.padLeft(millisToPad, 3, "0") + " seconds");
    }

    if (!buffer.isEmpty()) {
        return DefaultGroovyMethods.join(buffer.iterator(), ", ");
    } else {
        return "0";
    }
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
private void addAssembleTask(Project project, Distribution distribution, Task... tasks) {
    String taskName = TASK_ASSEMBLE_NAME;
    if (!MAIN_DISTRIBUTION_NAME.equals(distribution.getName())) {
        taskName = "assemble" + StringGroovyMethods.capitalize(distribution.getName()) + "Dist";
    }

    Task assembleTask = project.getTasks().create(taskName);
    assembleTask.setDescription("Assembles the " + distribution.getName() + " distributions");
    assembleTask.setGroup(DISTRIBUTION_GROUP);
    assembleTask.dependsOn((Object[]) tasks);
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
private ShrinkResources createShrinkResourcesTask(
        final ApkVariantOutputData variantOutputData) {
    BaseVariantData<?> variantData = (BaseVariantData<?>) variantOutputData.variantData;
    ShrinkResources task = scope.getGlobalScope().getProject().getTasks()
            .create("shrink" + StringGroovyMethods
                    .capitalize(variantOutputData.getFullName())
                    + "Resources", ShrinkResources.class);
    task.setAndroidBuilder(scope.getGlobalScope().getAndroidBuilder());
    task.variantOutputData = variantOutputData;

    final String outputBaseName = variantOutputData.getBaseName();
    task.setCompressedResources(new File(
            scope.getGlobalScope().getBuildDir() + "/" + FD_INTERMEDIATES + "/res/" +
                    "resources-" + outputBaseName + "-stripped.ap_"));

    ConventionMappingHelper.map(task, "uncompressedResources", new Callable<File>() {
        @Override
        public File call() {
            return variantOutputData.processResourcesTask.getPackageOutputFile();
        }
    });

    task.dependsOn(
            scope.getVariantScope().getObfuscationTask().getName(),
            scope.getManifestProcessorTask().getName(),
            variantOutputData.processResourcesTask);

    return task;
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
private org.codehaus.groovy.syntax.Token createGroovyToken(Token token, int cardinality) {
    String text = StringGroovyMethods.multiply((CharSequence) token.getText(), cardinality);
    return new org.codehaus.groovy.syntax.Token(
            "..<".equals(token.getText()) || "..".equals(token.getText())
                    ? Types.RANGE_OPERATOR
                    : Types.lookup(text, Types.ANY),
            text,
            token.getLine(),
            token.getCharPositionInLine() + 1
    );
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
@Override
public void paintComponent(Graphics g) {
    super.paintComponent(g);
    // starting position in document
    int start = textEditor.viewToModel(getViewport().getViewPosition());
    // end position in document
    int end = textEditor.viewToModel(new Point(10,
            getViewport().getViewPosition().y +
                    (int) textEditor.getVisibleRect().getHeight())
    );

    // translate offsets to lines
    Document doc = textEditor.getDocument();
    int startline = doc.getDefaultRootElement().getElementIndex(start) + 1;
    int endline = doc.getDefaultRootElement().getElementIndex(end) + 1;
    Font f = textEditor.getFont();
    int fontHeight = g.getFontMetrics(f).getHeight();
    int fontDesc = g.getFontMetrics(f).getDescent();
    int startingY = -1;

    try {
        startingY = textEditor.modelToView(start).y + fontHeight - fontDesc;
    } catch (BadLocationException e1) {
        System.err.println(e1.getMessage());
    }
    g.setFont(f);
    for (int line = startline, y = startingY; line <= endline; y += fontHeight, line++) {
        String lineNumber = StringGroovyMethods.padLeft(Integer.toString(line), 4, " ");
        g.drawString(lineNumber, 0, y);
    }
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
private static void createComparatorFor(ClassNode classNode, PropertyNode property, boolean reversed) {
    String propName = StringGroovyMethods.capitalize((CharSequence) property.getName());
    String className = classNode.getName() + "$" + propName + "Comparator";
    ClassNode superClass = makeClassSafeWithGenerics(AbstractComparator.class, classNode);
    InnerClassNode cmpClass = new InnerClassNode(classNode, className, ACC_PRIVATE | ACC_STATIC, superClass);
    classNode.getModule().addClass(cmpClass);

    cmpClass.addMethod(new MethodNode(
            "compare",
            ACC_PUBLIC,
            ClassHelper.int_TYPE,
            params(param(newClass(classNode), ARG0), param(newClass(classNode), ARG1)),
            ClassNode.EMPTY_ARRAY,
            createCompareMethodBody(property, reversed)
    ));

    String fieldName = "this$" + propName + "Comparator";
    // private final Comparator this$<property>Comparator = new <type>$<property>Comparator();
    FieldNode cmpField = classNode.addField(
            fieldName,
            ACC_STATIC | ACC_FINAL | ACC_PRIVATE | ACC_SYNTHETIC,
            COMPARATOR_TYPE,
            ctorX(cmpClass));

    classNode.addMethod(new MethodNode(
            "comparatorBy" + propName,
            ACC_PUBLIC | ACC_STATIC,
            COMPARATOR_TYPE,
            Parameter.EMPTY_ARRAY,
            ClassNode.EMPTY_ARRAY,
            returnS(fieldX(cmpField))
    ));
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
public static Collection asCollection(Object value) {
    if (value == null) {
        return Collections.EMPTY_LIST;
    } else if (value instanceof Collection) {
        return (Collection) value;
    } else if (value instanceof Map) {
        Map map = (Map) value;
        return map.entrySet();
    } else if (value.getClass().isArray()) {
        return arrayAsCollection(value);
    } else if (value instanceof MethodClosure) {
        MethodClosure method = (MethodClosure) value;
        IteratorClosureAdapter adapter = new IteratorClosureAdapter(method.getDelegate());
        method.call(adapter);
        return adapter.asList();
    } else if (value instanceof String || value instanceof GString) {
        return StringGroovyMethods.toList((CharSequence) value);
    } else if (value instanceof File) {
        try {
            return ResourceGroovyMethods.readLines((File) value);
        } catch (IOException e) {
            throw new GroovyRuntimeException("Error reading file: " + value, e);
        }
    } else if (value instanceof Class && ((Class) value).isEnum()) {
        Object[] values = (Object[]) InvokerHelper.invokeMethod(value, "values", EMPTY_OBJECT_ARRAY);
        return Arrays.asList(values);
    } else {
        // let's assume it's a collection of 1
        return Collections.singletonList(value);
    }
}
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
private static void writeValue(String key, String space, String prefix, Object value, BufferedWriter out) throws IOException {
//        key = key.indexOf('.') > -1 ? InvokerHelper.inspect(key) : key;
        boolean isKeyword = KEYWORDS.contains(key);
        key = isKeyword ? InvokerHelper.inspect(key) : key;

        if (!StringGroovyMethods.asBoolean(prefix) && isKeyword) prefix = "this.";
        out.append(space).append(prefix).append(key).append('=').append(InvokerHelper.inspect(value));
        out.newLine();
    }
 

import org.codehaus.groovy.runtime.StringGroovyMethods; //导入依赖的package包/类
@And("^a file \"([^\"]*)\":$")
public void aFile(String file, String body) throws Throwable {
  Files.write(projectDir.resolve(file), StringUtils.trim(StringGroovyMethods.stripIndent((CharSequence) body)).getBytes());
}