Java ResourceGroovyMethods类代码示例

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
private Object parseFile(File file, String charset) {
    Reader reader = null;
    try {
        if (charset == null || charset.length() == 0) {
            reader = ResourceGroovyMethods.newReader(file);
        } else {
            reader = ResourceGroovyMethods.newReader(file, charset);
        }
        return parse(reader);
    } catch (IOException ioe) {
        throw new JsonException("Unable to process file: " + file.getPath(), ioe);
    } finally {
        if (reader != null) {
            DefaultGroovyMethodsSupport.closeWithWarning(reader);
        }
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
private Object parseURL(URL url, Map params) {
    Reader reader = null;
    try {
        if (params == null || params.isEmpty()) {
            reader = ResourceGroovyMethods.newReader(url);
        } else {
            reader = ResourceGroovyMethods.newReader(url, params);
        }
        return parse(reader);
    } catch (IOException ioe) {
        throw new JsonException("Unable to process url: " + url.toString(), ioe);
    } finally {
        if (reader != null) {
            DefaultGroovyMethodsSupport.closeWithWarning(reader);
        }
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
public Object parse(File file, String charset) {
    Reader reader = null;
    try {
        if (charset == null || charset.length() == 0) {
            reader = ResourceGroovyMethods.newReader(file);
        } else {
            reader = ResourceGroovyMethods.newReader(file, charset);
        }
        return parse(reader);
    } catch (IOException ioe) {
        throw new JsonException("Unable to process file: " + file.getPath(), ioe);
    } finally {
        if (reader != null) {
            DefaultGroovyMethodsSupport.closeWithWarning(reader);
        }
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
private Object parseURL(URL url, Map params) {
    Reader reader = null;
    try {
        if (params == null || params.isEmpty()) {
            reader = ResourceGroovyMethods.newReader(url);
        } else {
            reader = ResourceGroovyMethods.newReader(url, params);
        }
        return createParser().parse(reader);
    } catch (IOException ioe) {
        throw new JsonException("Unable to process url: " + url.toString(), ioe);
    } finally {
        if (reader != null) {
            DefaultGroovyMethodsSupport.closeWithWarning(reader);
        }
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
public void testCustomClassTemplate() throws Exception {
    executeTarget("testCustomClassTemplate");

    final File testfilesPackageDir = new File(tmpDir, "org/codehaus/groovy/tools/groovydoc/testfiles");
    System.err.println("testfilesPackageDir = " + testfilesPackageDir);
    final String[] list = testfilesPackageDir.list(new FilenameFilter() {
        public boolean accept(File file, String name) {
            return name.equals("DocumentedClass.html");
        }
    });

    assertNotNull("Dir not found: " + testfilesPackageDir.getAbsolutePath(), list);
    assertEquals(1, list.length);
    File documentedClassHtmlDoc = new File(testfilesPackageDir, list[0]);

    List<String> lines = ResourceGroovyMethods.readLines(documentedClassHtmlDoc);
    assertTrue("\"<title>DocumentedClass</title>\" not in: " + lines, lines.contains("<title>DocumentedClass</title>"));
    assertTrue("\"This is a custom class template.\" not in: " + lines, lines.contains("This is a custom class template."));
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
public GroovyCodeSource(URL url) {
    if (url == null) {
        throw new RuntimeException("Could not construct a GroovyCodeSource from a null URL");
    }
    this.url = url;
    // TODO: GROOVY-6561: GroovyMain got the name this way: script.substring(script.lastIndexOf("/") + 1)
    this.name = url.toExternalForm();
    this.codeSource = new CodeSource(url, (java.security.cert.Certificate[]) null);
    try {
        String contentEncoding = getContentEncoding(url);
        if (contentEncoding != null) {
            this.scriptText = ResourceGroovyMethods.getText(url, contentEncoding);
        } else {
            this.scriptText = ResourceGroovyMethods.getText(url); // falls-back on default encoding
        }
    } catch (IOException e) {
        throw new RuntimeException("Impossible to read the text content from " + name, e);
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
public void testLaunchesJUnitTestSuite() throws Exception {
    // create a valid (empty) test suite on disk
    String testName = "GroovyShellTestJUnit3Test"+System.currentTimeMillis();
    File testSuite = new File(System.getProperty("java.io.tmpdir"), testName);
    ResourceGroovyMethods.write(testSuite, "import junit.framework.*; \r\n" +
            "public class " + testName + " extends TestSuite { \r\n" +
            "    public static Test suite() { \r\n" +
            "        return new TestSuite(); \r\n" +
            "    } \r\n" +
            "} \r\n");
    testSuite.deleteOnExit();
    
    PrintStream out = System.out;
    System.setOut( new PrintStream(new ByteArrayOutputStream()) );
    try {
        // makes this more of an integration test than a unit test...
        GroovyShell.main( new String[] { testSuite.getCanonicalPath() });
    } finally {
        System.setOut( out );
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
public TestFile leftShift(Object content) {
    getParentFile().mkdirs();
    try {
        ResourceGroovyMethods.leftShift(this, content);
        return this;
    } catch (IOException e) {
        throw new RuntimeException(String.format("Could not append to test file '%s'", this), e);
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
public TestFile setText(String content) {
    getParentFile().mkdirs();
    try {
        ResourceGroovyMethods.setText(this, content);
        return this;
    } catch (IOException e) {
        throw new RuntimeException(String.format("Could not append to test file '%s'", this), e);
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
private void setOverview() {
    String path = properties.getProperty("overviewFile");
    if (path != null && path.length() > 0) {
        try {
            String content = ResourceGroovyMethods.getText(new File(path));
            calcThenSetOverviewDescription(content);
        } catch (IOException e) {
            System.err.println("Unable to load overview file: " + e.getMessage());
        }
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
private void createNewArgs(String txt) throws IOException {
    final String[] args = cmdline.getCommandline();
    // Temporary file - delete on exit, create (assured unique name).
    final File tempFile = FileUtils.getFileUtils().createTempFile(PREFIX, SUFFIX, null, true, true);
    final String[] commandline = new String[args.length + 1];
    ResourceGroovyMethods.write(tempFile, txt);
    commandline[0] = tempFile.getCanonicalPath();
    System.arraycopy(args, 0, commandline, 1, args.length);
    super.clearArgs();
    for (String arg : commandline) {
        final Commandline.Argument argument = super.createArg();
        argument.setValue(arg);
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
private void safeScanScript(File file) {
    try {
        scanScript(new StringReader(ResourceGroovyMethods.getText(file)));
    } catch (final Exception ex) {
        ex.printStackTrace();
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的package包/类
public static void processFiles(List<String> fileNames) throws Exception {
    Iterator i = fileNames.iterator();
    while (i.hasNext()) {
        String filename = (String) i.next();
        File f = new File(filename);
        String text = ResourceGroovyMethods.getText(f);
        System.out.println(convert(filename, text, true, true));
    }
}
 

import org.codehaus.groovy.runtime.ResourceGroovyMethods; //导入依赖的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.ResourceGroovyMethods; //导入依赖的package包/类
public void visit(ASTNode[] nodes, final SourceUnit source) {
    if (nodes.length != 2 || !(nodes[0] instanceof AnnotationNode) || !(nodes[1] instanceof AnnotatedNode)) {
        throw new RuntimeException("Internal error: expecting [AnnotationNode, AnnotatedNode] but got: " + Arrays.asList(nodes));
    }
    AnnotatedNode parent = (AnnotatedNode) nodes[1];
    File f = new File("temp/log.txt");
    try {
        ResourceGroovyMethods.append(f, parent.getClass().getSimpleName() + " " +
                parent.getAnnotations().get(0).getMember("value").getText() + " ");
    } catch (IOException e) {
        e.printStackTrace();
    }
}