public static CharSequence headerFrom(CharSequence source) { if (source.length() != 0) { return PostprocessingMachine.collectHeader(source); } return SourceExtractor.UNABLE_TO_EXTRACT; }
public static Imports importsFrom(CharSequence source) { if (source.length() != 0) { return PostprocessingMachine.collectImports(source); } return Imports.empty(); }
static CharSequence collectHeader(CharSequence content) { try { return rewrite(content, new ImportsBuilder(), ScanAtMost.HEADER); } catch (UnsupportedEncodingException ex) { return ""; } }
private static boolean isAlphabetic(char c) { return isLowerCaseAlphabetic(c) || isUpperCaseAlphabetic(c); }
@Test public void safelySkipImportStartsWithUnderscore() { SourceExtraction.Imports imports = PostprocessingMachine.collectImports( LINES.join( "import b._TYPE;", "class B { _TYPE b; }")); check(imports.all).has("b._TYPE"); check(PostprocessingMachine.rewrite( "class B { b._STATUS_TYPE s; }")) .hasToString( "class B { b._STATUS_TYPE s; }"); }
static CharSequence rewrite(CharSequence content) { try { return rewrite(content, new ImportsBuilder(), ScanAtMost.ALL); } catch (UnsupportedEncodingException ex) { return content; } }
@Test public void importsHaveUnderscores() { SourceExtraction.Imports imports = PostprocessingMachine.collectImports( LINES.join("package start;", "import b.PAYMENT_STATUS_TYPE;", "final class B {", "}")); check(imports.classes.values()).hasContentInAnyOrder("b.PAYMENT_STATUS_TYPE"); }
@Test public void onlyCollectHeader() { String header = PostprocessingMachine.collectHeader( LINES.join("// sdsd", "/* sdsd", " * * * */", "//!", "/** */", "package start;", "import java.util.List;", "import org.junit.*;", "import static org.junit.My.*;", "import some.Some.Nested;", "final class My extends java.util.Set {", "}")).toString(); check(header).startsWith("// sdsd"); check(header).endsWith("/** */"); }
private CharSequence extractSourceCode() { CharSequence charSequence = consumer.asCharSequence(); if (Strings.commonPrefix(charSequence, NO_IMPORTS).startsWith(NO_IMPORTS)) { return charSequence; } return PostprocessingMachine.rewrite(charSequence); } }
@Test public void onlyCollectImports() { SourceExtraction.Imports imports = PostprocessingMachine.collectImports( LINES.join("package start;", "import java.util.List;", "import org.junit.*;", "import static org.junit.My.*;", "import some.Some.Nested;", "final class My extends java.util.Set {", " private java.util.Map<java.lang.String, Integer> map = com.google.common.collect.Maps.newHashMap();", "}")); check(imports.classes.keySet()).hasContentInAnyOrder("List", "Nested"); check(imports.classes.values()).hasContentInAnyOrder("java.util.List", "some.Some.Nested"); }
static Imports collectImports(CharSequence content) { try { ImportsBuilder importsBuilder = new ImportsBuilder(); rewrite(content, importsBuilder, ScanAtMost.IMPORTS); return Imports.of(importsBuilder.imports, importsBuilder.originalImports); } catch (UnsupportedEncodingException ex) { return Imports.empty(); } }
@Test public void javaLangInOriginalImports() { CharSequence rewrited = PostprocessingMachine.rewrite(LINES.join( "import java.lang.String;", "class X {", " java.lang.String method(String s);", "}")); check(rewrited).hasToString(LINES.join( "class X {", " String method(String s);", "}")); }
@Test public void staticImport() { CharSequence rewrited = PostprocessingMachine.rewrite(LINES.join( "import static org.immutables.check.Checkers.*;", "class My extends java.util.Set {}")); check(rewrited).hasToString(LINES.join( "import java.util.Set;", "import static org.immutables.check.Checkers.*;", "class My extends Set {}")); }
@Test public void noConflictInDifferentPackages() { CharSequence rewrited = PostprocessingMachine.rewrite(LINES.join( "import my.other.Set;", "class X {", " my.Set same(Set set);", "}")); check(rewrited).hasToString(LINES.join( "import my.other.Set;", "class X {", " my.Set same(Set set);", "}")); }
@Test public void underscoreNamesImport() { check(PostprocessingMachine.rewrite( "class X { a.SET_OPT s; }")) .hasToString(LINES.join( "import a.SET_OPT;", "class X { SET_OPT s; }")); check(PostprocessingMachine.rewrite( "class X { a.T.SET_OPT s; }")) .hasToString(LINES.join( "import a.T;", "class X { T.SET_OPT s; }")); } }
@Test public void classNameInImportHasUnderscores() { CharSequence rewrited = PostprocessingMachine.rewrite(LINES.join( "import b.PAYMENT_TYPE;", " public interface SomeValue { ", " PAYMENT_TYPE getPaymentType();", "}")); check(rewrited).hasToString(LINES.join( "import b.PAYMENT_TYPE;", " public interface SomeValue { ", " PAYMENT_TYPE getPaymentType();", "}")); }
@Test public void annotationTypeImport() { check(PostprocessingMachine.rewrite( "@interface Set { @javax.annotation.Generated int x; }")) .hasToString(LINES.join( "import javax.annotation.Generated;", "@interface Set { @Generated int x; }")); }
@Test public void currentPackageInOriginalImports() { CharSequence rewrited = PostprocessingMachine.rewrite(LINES.join( "package my.pack;", "import my.pack.Y;", "class X {", " my.pack.Y method(Y s);", "}")); check(rewrited).hasToString(LINES.join( "package my.pack;", "", "class X {", " Y method(Y s);", "}")); }
@Test public void annotationBeforeClass() { check(PostprocessingMachine.rewrite( "@javax.annotation.Generated class Set {}")) .hasToString(LINES.join( "import javax.annotation.Generated;", "@Generated class Set {}")); }
@Test public void annotationImportInsideClass() { CharSequence rewrited = PostprocessingMachine.rewrite( "class Set { @javax.annotation.Generated int x; }"); check(rewrited).hasToString(LINES.join( "import javax.annotation.Generated;", "class Set { @Generated int x; }")); }