pax_global_header 0000666 0000000 0000000 00000000064 12107037722 0014513 g ustar 00root root 0000000 0000000 52 comment=ccb5d2479c7e20ee9f8a99abae164e5be49a4d08
access-modifier-access-modifier-1.4/ 0000775 0000000 0000000 00000000000 12107037722 0017447 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/.gitignore 0000664 0000000 0000000 00000000031 12107037722 0021431 0 ustar 00root root 0000000 0000000 target
*.iml
*.ipr
*.iws
access-modifier-access-modifier-1.4/README 0000664 0000000 0000000 00000000605 12107037722 0020330 0 ustar 00root root 0000000 0000000 Allows applications to define custom access modifiers programmatically,
to be enforced at compile time in the opt-in basis. Obviously,
there's no runtime check either --- this is strictly a voluntary annotations.
This mechanism is useful for actually making sure that deprecated features are not used
(without actually removing such declarations, which would break binary compatibility.)
access-modifier-access-modifier-1.4/access-modifier-annotation/ 0000775 0000000 0000000 00000000000 12107037722 0024654 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/pom.xml 0000664 0000000 0000000 00000001527 12107037722 0026176 0 ustar 00root root 0000000 0000000
4.0.0access-modifierorg.kohsuke1.4access-modifier-annotationCustom Acess Modifier annotationsorg.jenkins-ciannotation-indexer1.4junitjunit3.8.1test access-modifier-access-modifier-1.4/access-modifier-annotation/src/ 0000775 0000000 0000000 00000000000 12107037722 0025443 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/ 0000775 0000000 0000000 00000000000 12107037722 0026367 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/ 0000775 0000000 0000000 00000000000 12107037722 0027310 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/ 0000775 0000000 0000000 00000000000 12107037722 0030077 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/ 0000775 0000000 0000000 00000000000 12107037722 0031550 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod/ 0000775 0000000 0000000 00000000000 12107037722 0032776 5 ustar 00root root 0000000 0000000 AccessRestriction.java 0000664 0000000 0000000 00000007060 12107037722 0037214 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod /*
* The MIT License
*
* Copyright (c) 2010, Kohsuke Kawaguchi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.accmod;
import org.kohsuke.accmod.impl.ErrorListener;
import org.kohsuke.accmod.impl.Location;
import org.kohsuke.accmod.impl.RestrictedElement;
import org.kohsuke.accmod.restrictions.None;
/**
* Access restriction policy — determines what access is OK and what are not.
*
*
* The subtype of this interface is a strategy object. Instances of
* these classes are created during the access enforcement to perform constraint checks.
*
*
* Single execution of the enforcement check would create at most one instance
* of a given {@link AccessRestriction} type, so instance fields can be used to store
* heavy-weight objects or other indicies that you might need for implementing
* access control checks.
*
* @author Kohsuke Kawaguchi
*/
public abstract class AccessRestriction {
/**
* The type on which this restriction is placed is used as a supertype by another class.
* The location points to the subtype.
*
* @param loc
* Points to the subtype.
* @param errorListener
* Report any error here.
*/
public abstract void usedAsSuperType(Location loc, RestrictedElement target, ErrorListener errorListener);
/**
* The type on which this restriction is placed is used as an interface that another class/interface implements.
*
* @param loc
* Points to the subtype.
* @param errorListener
* Report any error here.
*/
public abstract void usedAsInterface(Location loc, RestrictedElement target, ErrorListener errorListener);
/**
* The type on which this restriction is placed is instantiated elsewhere.
*/
public abstract void instantiated(Location loc, RestrictedElement target, ErrorListener errorListener);
/**
* The method on which this restriction is placed is invoked elsewhere.
*/
public abstract void invoked(Location loc, RestrictedElement target, ErrorListener errorListener);
/**
* The field on which this restriction is placed is read.
*/
public abstract void read(Location loc, RestrictedElement target, ErrorListener errorListener);
/**
* The field on which this restriction is placed is updated.
*/
public abstract void written(Location loc, RestrictedElement target, ErrorListener errorListener);
/**
* {@link AccessRestriction} that imposes no restriction.
*/
public static final AccessRestriction NONE = new None();
}
Restricted.java 0000664 0000000 0000000 00000003731 12107037722 0035676 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod /*
* The MIT License
*
* Copyright (c) 2010, Kohsuke Kawaguchi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.accmod;
import org.jvnet.hudson.annotation_indexer.Indexed;
import java.lang.annotation.Documented;
import java.lang.annotation.Retention;
import static java.lang.annotation.RetentionPolicy.CLASS;
/**
* Indicates that a particular element is really deprecated and that the access to it
* is subject to the additional restrictions.
*
*
* These annotations and restrictions introduced by them are enforced by the
* "access-modifier-checker" mojo.
*
* @author Kohsuke Kawaguchi
*/
@Retention(CLASS)
@Documented
@Indexed
public @interface Restricted {
/**
* Kind of access that are restricted.
* If multiple values are specified, those restrictions are OR-ed — thus if an use
* violates any of the restrictions, it'll be considered as an error.
*/
Class[] value();
}
0000775 0000000 0000000 00000000000 12107037722 0033660 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod/impl ErrorListener.java 0000664 0000000 0000000 00000003126 12107037722 0037324 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod/impl /*
* The MIT License
*
* Copyright (c) 2010, Kohsuke Kawaguchi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.accmod.impl;
/**
* @author Kohsuke Kawaguchi
*/
public interface ErrorListener {
void onError(Throwable t, Location loc, String msg);
void onWarning(Throwable t, Location loc, String msg);
/**
* No-op listener.
*/
ErrorListener NULL = new ErrorListener() {
public void onError(Throwable t, Location loc, String msg) {
}
public void onWarning(Throwable t, Location loc, String msg) {
}
};
}
Location.java 0000664 0000000 0000000 00000005103 12107037722 0036272 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod/impl /*
* The MIT License
*
* Copyright (c) 2010, Kohsuke Kawaguchi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.accmod.impl;
import org.kohsuke.accmod.AccessRestriction;
/**
* Indicates the location that the use occurred.
*
* @author Kohsuke Kawaguchi
*/
public interface Location {
/**
* The fully-qualified class name in which the use happened,
* for example "abc.def.Ghi"
*/
String getClassName();
/**
* If the use happened in the byte code instruction,
* method name that the use occurred in.
*
* For example "getAbc"
*/
String getMethodName();
/**
* This is the encoded method signature like "(II)Z"
* in which the use happened. Used in conjunction with
* {@link #getMethodName()} to disambiguate overload.
*/
String getMethodDescriptor();
/**
* The line number in the source file where the use happened.
*/
int getLineNumber();
/**
* Obtains a human readable description of the location.
* Useful for an error message.
*/
String toString();
/**
* {@link AccessRestriction} implementations can use this classloader
* to access the classes referenced by classes being inspected.
*
*
* Loading a class has a side effect, so it's generally not recommended
* to do so, but the caller can use {@link ClassLoader#getResource(String)}
* and parse the class files via libraries like ASM to define more elaborate
* access restrictions.
*/
ClassLoader getDependencyClassLoader();
}
RestrictedElement.java 0000664 0000000 0000000 00000003146 12107037722 0040151 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod/impl /*
* The MIT License
*
* Copyright (c) 2010, Kohsuke Kawaguchi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.accmod.impl;
import org.kohsuke.accmod.Restricted;
/**
* Represents the element annotated by {@link Restricted}
*
* @author Kohsuke Kawaguchi
*/
public interface RestrictedElement {
/**
* True if the restricted element is a part of the code that's being inspected.
* Often you want to relax restrictions for those that are in the same module,
* and this can be used for that.
*/
boolean isInTheInspectedModule();
String toString();
}
0000775 0000000 0000000 00000000000 12107037722 0035447 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod/restrictions DoNotUse.java 0000664 0000000 0000000 00000005030 12107037722 0040010 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod/restrictions /*
* The MIT License
*
* Copyright (c) 2010, Kohsuke Kawaguchi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.accmod.restrictions;
import org.kohsuke.accmod.AccessRestriction;
import org.kohsuke.accmod.impl.ErrorListener;
import org.kohsuke.accmod.impl.Location;
import org.kohsuke.accmod.impl.RestrictedElement;
/**
* This type, field, or method shall never be referenced from anywhere at all.
*
* @author Kohsuke Kawaguchi
*/
public class DoNotUse extends AccessRestriction {
public void written(Location loc, RestrictedElement target, ErrorListener errorListener) {
error(loc,target,errorListener);
}
public void usedAsSuperType(Location loc, RestrictedElement target, ErrorListener errorListener) {
error(loc,target,errorListener);
}
public void usedAsInterface(Location loc, RestrictedElement target, ErrorListener errorListener) {
error(loc,target,errorListener);
}
public void instantiated(Location loc, RestrictedElement target, ErrorListener errorListener) {
error(loc,target,errorListener);
}
public void invoked(Location loc, RestrictedElement target, ErrorListener errorListener) {
error(loc,target,errorListener);
}
public void read(Location loc, RestrictedElement target, ErrorListener errorListener) {
error(loc,target,errorListener);
}
public void error(Location loc, RestrictedElement target, ErrorListener errorListener) {
errorListener.onError(null,loc,target+" must not be used");
}
}
NoExternalUse.java 0000664 0000000 0000000 00000001355 12107037722 0041052 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod/restrictions package org.kohsuke.accmod.restrictions;
import org.kohsuke.accmod.impl.ErrorListener;
import org.kohsuke.accmod.impl.Location;
import org.kohsuke.accmod.impl.RestrictedElement;
/**
* References are allowed only when they are within the same module
* (that is, if the reference is compiled at the same time as the restricted element.)
*
*
* Otherwise the access is rejected.
*
* @author Kohsuke Kawaguchi
*/
public class NoExternalUse extends DoNotUse {
@Override
public void error(Location loc, RestrictedElement target, ErrorListener errorListener) {
if (target.isInTheInspectedModule())
return; // OK as long as the use happens in the same module
super.error(loc, target, errorListener);
}
}
None.java 0000664 0000000 0000000 00000001723 12107037722 0037214 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-annotation/src/main/java/org/kohsuke/accmod/restrictions package org.kohsuke.accmod.restrictions;
import org.kohsuke.accmod.AccessRestriction;
import org.kohsuke.accmod.impl.ErrorListener;
import org.kohsuke.accmod.impl.Location;
import org.kohsuke.accmod.impl.RestrictedElement;
/**
* No access restriction whatsoever.
*
* @author Kohsuke Kawaguchi
*/
public class None extends AccessRestriction {
public void usedAsSuperType(Location loc, RestrictedElement target, ErrorListener errorListener) {
}
public void usedAsInterface(Location loc, RestrictedElement target, ErrorListener errorListener) {
}
public void instantiated(Location loc, RestrictedElement target, ErrorListener errorListener) {
}
public void invoked(Location loc, RestrictedElement target, ErrorListener errorListener) {
}
public void read(Location loc, RestrictedElement target, ErrorListener errorListener) {
}
public void written(Location loc, RestrictedElement target, ErrorListener errorListener) {
}
}
access-modifier-access-modifier-1.4/access-modifier-checker/ 0000775 0000000 0000000 00000000000 12107037722 0024106 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/pom.xml 0000664 0000000 0000000 00000003026 12107037722 0025424 0 ustar 00root root 0000000 0000000
4.0.0access-modifierorg.kohsuke1.4access-modifier-checkermaven-pluginCustom Access Modifier Checkerjunitjunit3.8.1test${project.groupId}access-modifier-annotation${project.version}asmasm-debug-all3.2org.apache.mavenmaven-plugin-api2.0.1org.apache.mavenmaven-project2.0.1org.kohsuke.metainf-servicesmetainf-services1.1true access-modifier-access-modifier-1.4/access-modifier-checker/src/ 0000775 0000000 0000000 00000000000 12107037722 0024675 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/ 0000775 0000000 0000000 00000000000 12107037722 0025621 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/java/ 0000775 0000000 0000000 00000000000 12107037722 0026542 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/java/org/ 0000775 0000000 0000000 00000000000 12107037722 0027331 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/java/org/kohsuke/ 0000775 0000000 0000000 00000000000 12107037722 0031002 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/java/org/kohsuke/accmod/ 0000775 0000000 0000000 00000000000 12107037722 0032230 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/java/org/kohsuke/accmod/impl/ 0000775 0000000 0000000 00000000000 12107037722 0033171 5 ustar 00root root 0000000 0000000 AccessRestrictionFactory.java 0000664 0000000 0000000 00000004333 12107037722 0040737 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/java/org/kohsuke/accmod/impl /*
* The MIT License
*
* Copyright (c) 2010, Kohsuke Kawaguchi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.accmod.impl;
import org.kohsuke.accmod.AccessRestriction;
import org.objectweb.asm.Type;
import java.util.HashMap;
import java.util.Map;
/**
* Pool of {@link AccessRestriction} instances.
*
* @author Kohsuke Kawaguchi
*/
public class AccessRestrictionFactory {
private final Map instances = new HashMap();
private final ClassLoader cl;
public AccessRestrictionFactory(ClassLoader cl) {
this.cl = cl;
}
public AccessRestriction get(Type type) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
String className = type.getClassName();
AccessRestriction a = instances.get(className);
if (a!=null) return a;
// in this way, even if the restriction fails to load, we'll just report an error once
a = AccessRestriction.NONE;
try {
Class c = cl.loadClass(className);
a = (AccessRestriction)c.newInstance();
return a;
} finally {
instances.put(className,a);
}
}
}
Checker.java 0000664 0000000 0000000 00000031176 12107037722 0035331 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/java/org/kohsuke/accmod/impl /*
* The MIT License
*
* Copyright (c) 2010, Kohsuke Kawaguchi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.accmod.impl;
import org.kohsuke.accmod.AccessRestriction;
import org.kohsuke.accmod.Restricted;
import org.kohsuke.accmod.impl.Restrictions.Parser;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.FieldVisitor;
import org.objectweb.asm.Label;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.EmptyVisitor;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import static org.objectweb.asm.ClassReader.SKIP_FRAMES;
/**
* Performs check.
*
* @author Kohsuke Kawaguchi
*/
public class Checker {
/**
* Where dependencies are loaded. We don't actually load classes,
* but this is used to search for class files and indexed restrictions.
*/
public final ClassLoader dependencies;
/**
* Where errors and warnings are sent.
*/
private final ErrorListener errorListener;
/**
* Restrictions found from dependencies.
*
* The string is either:
*
*
internal name of a type
*
internal name of a type + '.' + field name
*
internal name of a type + '.' + method name + method descriptor
*
*/
private final Map restrictions = new HashMap();
private final AccessRestrictionFactory factory;
public Checker(ClassLoader dependencies, ErrorListener errorListener) throws IOException {
this.dependencies = dependencies;
this.errorListener = errorListener;
this.factory = new AccessRestrictionFactory(dependencies);
// load access restrictions
loadAccessRestrictions();
}
public ErrorListener getErrorListener() {
return errorListener;
}
/**
* Checks a single class file or a directory full of class files (recursively.)
*/
public void check(File f) throws IOException {
if (f.isDirectory()) {
for (File c : f.listFiles())
check(c);
return;
}
if (f.getPath().endsWith(".class"))
checkClass(f);
}
/**
* Loads all the access restrictions defined in our dependencies.
*/
private void loadAccessRestrictions() throws IOException {
final Enumeration res = dependencies.getResources("META-INF/annotations/"+Restricted.class.getName());
while (res.hasMoreElements()) {
URL url = res.nextElement();
loadRestrictions(url.openStream(),false);
}
}
/**
* Loads an additional restriction from the specified "META-INF/annotations/org.kohsuke.accmod.Restricted" file.
*
* @param isInTheInspectedModule
* This value shows up in {@link RestrictedElement#isInTheInspectedModule()}.
* @param stream
*/
public void loadRestrictions(InputStream stream, final boolean isInTheInspectedModule) throws IOException {
if (stream==null) return;
BufferedReader r = new BufferedReader(new InputStreamReader(stream, "UTF-8"));
String className;
while ((className=r.readLine())!=null) {
InputStream is = dependencies.getResourceAsStream(className.replace('.','/') + ".class");
if (is==null) {
errorListener.onWarning(null,null,"Failed to find class file for "+ className);
continue;
}
try {
new ClassReader(is).accept(new EmptyVisitor() {
private String className;
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
this.className = name;
}
@Override
public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
return onAnnotationFor(className,desc);
}
@Override
public FieldVisitor visitField(int access, final String name, String desc, String signature, Object value) {
return new EmptyVisitor() {
@Override
public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
return onAnnotationFor(className+'.'+name,desc);
}
};
}
@Override
public MethodVisitor visitMethod(int access, final String methodName, final String methodDesc, String signature, String[] exceptions) {
return new EmptyVisitor() {
@Override
public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
return onAnnotationFor(className+'.'+methodName+methodDesc,desc);
}
};
}
/**
* Parse {@link Restricted} annotation on some annotated element.
*/
private AnnotationVisitor onAnnotationFor(final String keyName, String desc) {
if (RESTRICTED_DESCRIPTOR.equals(desc)) {
RestrictedElement target = new RestrictedElement() {
public boolean isInTheInspectedModule() {
return isInTheInspectedModule;
}
public String toString() { return keyName; }
};
return new Parser(target) {
@Override
public void visitEnd() {
try {
restrictions.put(keyName,build(factory));
} catch (ClassNotFoundException e) {
failure(e);
} catch (InstantiationException e) {
failure(e);
} catch (IllegalAccessException e) {
failure(e);
}
}
/**
* Fails to load a {@link AccessRestriction} instance.
*/
private void failure(Exception e) {
errorListener.onError(e,null,"Failed to load restrictions");
}
};
}
return null;
}
}, ClassReader.SKIP_CODE);
} finally {
is.close();
}
}
}
/**
* Inspects a class for the restriction violations.
*/
public void checkClass(File clazz) throws IOException {
FileInputStream in = new FileInputStream(clazz);
try {
ClassReader cr = new ClassReader(in);
cr.accept(new EmptyVisitor() {
private String className;
private String methodName,methodDesc;
private int line;
@Override
public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
this.className = name;
if (superName!=null)
getRestrictions(superName).usedAsSuperType(currentLocation,errorListener);
if (interfaces!=null) {
for (String intf : interfaces)
getRestrictions(intf).usedAsInterface(currentLocation,errorListener);
}
}
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
this.methodName = name;
this.methodDesc = desc;
return new EmptyVisitor() {
@Override
public void visitLineNumber(int _line, Label start) {
line = _line;
}
public void visitTypeInsn(int opcode, String type) {
switch (opcode) {
case Opcodes.NEW:
getRestrictions(type).instantiated(currentLocation,errorListener);
}
}
@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc) {
getRestrictions(owner+'.'+name+desc).invoked(currentLocation,errorListener);
}
@Override
public void visitFieldInsn(int opcode, String owner, String name, String desc) {
Restrictions r = getRestrictions(owner + '.' + name);
switch (opcode) {
case Opcodes.GETSTATIC:
case Opcodes.GETFIELD:
r.read(currentLocation,errorListener);
break;
case Opcodes.PUTSTATIC:
case Opcodes.PUTFIELD:
r.written(currentLocation,errorListener);
break;
}
super.visitFieldInsn(opcode, owner, name, desc);
}
};
}
/**
* Constant that represents the current location.
*/
private final Location currentLocation = new Location() {
public String getClassName() {
return className.replace('/','.');
}
public String getMethodName() {
return methodName;
}
public String getMethodDescriptor() {
return methodDesc;
}
public int getLineNumber() {
return line;
}
public String toString() {
return className+':'+line;
}
public ClassLoader getDependencyClassLoader() {
return dependencies;
}
public boolean isInTheSameModuleAs(RestrictedElement e) {
// TODO
throw new UnsupportedOperationException();
}
};
}, SKIP_FRAMES);
} finally {
in.close();
}
}
private Restrictions getRestrictions(String keyName) {
Restrictions r = restrictions.get(keyName);
if (r==null) return Restrictions.NONE;
return r;
}
private static final String RESTRICTED_DESCRIPTOR = Type.getDescriptor(Restricted.class);
}
EnforcerMojo.java 0000664 0000000 0000000 00000005401 12107037722 0036345 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/java/org/kohsuke/accmod/impl package org.kohsuke.accmod.impl;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.kohsuke.accmod.Restricted;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* Enforces the {@link Restricted} access modifier annotations.
*
* @author Kohsuke Kawaguchi
* @goal enforce
* @phase process-classes
* @requiresDependencyResolution compile
* @author Kohsuke Kawaguchi
*/
public class EnforcerMojo extends AbstractMojo {
/**
* The maven project.
*
* @parameter expression="${project}"
* @required
* @readonly
*/
protected MavenProject project;
public void execute() throws MojoExecutionException, MojoFailureException {
try {
File outputDir = new File(project.getBuild().getOutputDirectory());
List dependencies = new ArrayList();
for (Artifact a : (Collection)project.getArtifacts())
dependencies.add(a.getFile().toURI().toURL());
URL outputURL = outputDir.toURI().toURL();
dependencies.add(outputURL);
final boolean[] failed = new boolean[1];
Checker checker = new Checker(new URLClassLoader(dependencies.toArray(new URL[dependencies.size()]), getClass().getClassLoader()),
new ErrorListener() {
public void onError(Throwable t, Location loc, String msg) {
getLog().error(loc+" "+msg,t);
failed[0] = true;
}
public void onWarning(Throwable t, Location loc, String msg) {
getLog().warn(loc+" "+msg,t);
}
});
{// if there's restriction list in the inspected module itself, load it as well
InputStream self = null;
try {
self = new URL(outputURL, "META-INF/annotations/" + Restricted.class.getName()).openStream();
} catch (IOException e) {
}
if (self!=null)
checker.loadRestrictions(self, true);
}
// perform checks
checker.check(outputDir);
if (failed[0])
throw new MojoFailureException("Access modifier checks failed. See the details above");
} catch (IOException e) {
throw new MojoExecutionException("Failed to enforce @Restricted constraints",e);
}
}
}
Restrictions.java 0000664 0000000 0000000 00000010005 12107037722 0036441 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/java/org/kohsuke/accmod/impl /*
* The MIT License
*
* Copyright (c) 2010, Kohsuke Kawaguchi
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
package org.kohsuke.accmod.impl;
import org.kohsuke.accmod.AccessRestriction;
import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
/**
* @author Kohsuke Kawaguchi
*/
public class Restrictions extends ArrayList {
private final RestrictedElement target;
public Restrictions(RestrictedElement target, Collection c) {
super(c);
this.target = target;
}
public Restrictions(RestrictedElement target) {
this.target = target;
}
public void usedAsSuperType(Location loc, ErrorListener errorListener) {
for (AccessRestriction ar : this)
ar.usedAsSuperType(loc,target,errorListener);
}
public void usedAsInterface(Location loc, ErrorListener errorListener) {
for (AccessRestriction ar : this)
ar.usedAsInterface(loc,target,errorListener);
}
public void instantiated(Location loc, ErrorListener errorListener) {
for (AccessRestriction ar : this)
ar.instantiated(loc,target,errorListener);
}
public void invoked(Location location, ErrorListener errorListener) {
for (AccessRestriction ar : this)
ar.invoked(location,target,errorListener);
}
public void read(Location location, ErrorListener errorListener) {
for (AccessRestriction ar : this)
ar.read(location,target,errorListener);
}
public void written(Location location, ErrorListener errorListener) {
for (AccessRestriction ar : this)
ar.written(location,target,errorListener);
}
public static final Restrictions NONE = new Restrictions(new RestrictedElement() {
public boolean isInTheInspectedModule() { return false; }
public String toString() { return "NONE"; }
});
abstract static class Parser implements AnnotationVisitor {
private List restrictions = new ArrayList();
private final RestrictedElement target;
protected Parser(RestrictedElement target) {
this.target = target;
}
public void visit(String name, Object value) {
restrictions.add((Type)value);
}
public void visitEnum(String name, String desc, String value) {
}
public AnnotationVisitor visitAnnotation(String name, String desc) {
return this;
}
public AnnotationVisitor visitArray(String name) {
return this;
}
public abstract void visitEnd();
public Restrictions build(AccessRestrictionFactory f) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
Restrictions r = new Restrictions(target);
for (Type t : restrictions) {
r.add(f.get(t));
}
return r;
}
}
}
access-modifier-access-modifier-1.4/access-modifier-checker/src/main/resources/ 0000775 0000000 0000000 00000000000 12107037722 0027633 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/resources/META-INF/ 0000775 0000000 0000000 00000000000 12107037722 0030773 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/resources/META-INF/m2e/ 0000775 0000000 0000000 00000000000 12107037722 0031456 5 ustar 00root root 0000000 0000000 lifecycle-mapping-metadata.xml 0000664 0000000 0000000 00000000475 12107037722 0037275 0 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/access-modifier-checker/src/main/resources/META-INF/m2e enforce access-modifier-access-modifier-1.4/pom.xml 0000664 0000000 0000000 00000005302 12107037722 0020764 0 ustar 00root root 0000000 0000000
4.0.0org.kohsukepom3access-modifier1.4Custom access modifier for JavapomExtensible application-specific access modifiers for Javaaccess-modifier-annotationaccess-modifier-checkerkohsuke.orgscp://kohsuke.org/home/kohsuke/kohsuke.org/access-modifier/maven-compiler-plugin1.51.5org.apache.maven.pluginsmaven-release-plugin2.0org.apache.maven.scmmaven-scm-provider-gitexe1.2org.apache.maven.pluginsmaven-scm-plugin1.3org.jvnet.wagon-svnwagon-svn1.9scm:git:git@github.com/kohsuke/${project.artifactId}.gitscm:git:ssh://git@github.com/kohsuke/${project.artifactId}.githttp://${project.artifactId}.kohsuke.org/kohsukeKohsuke Kawaguchiorg.apache.maven.pluginsmaven-javadoc-pluginMIT Licenserepositoryhttp://www.opensource.org/licenses/mit-license.php
access-modifier-access-modifier-1.4/src/ 0000775 0000000 0000000 00000000000 12107037722 0020236 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/src/site/ 0000775 0000000 0000000 00000000000 12107037722 0021202 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/src/site/apt/ 0000775 0000000 0000000 00000000000 12107037722 0021766 5 ustar 00root root 0000000 0000000 access-modifier-access-modifier-1.4/src/site/apt/index.apt 0000664 0000000 0000000 00000004043 12107037722 0023604 0 ustar 00root root 0000000 0000000
What is this?
This library defines an annotation and extensible mechanism to let you define your own access modifiers. Those additional custom access modifiers can be enforced when you compile other source files that refer them.
For example, consider a deprecated feature in your library that you plan to remove in a near future. If you just put <<<@Deprecated>>>, code can be still written to use them quite casually (I still often use <<>>, for example.) But if you remove it, it'll break existing applications out there. Custom access modifier can fix this. With the following annotation on your method, you can flag an error whenever someone tries to call this method.
-----------------
public class Library {
@Deprecated @Restricted(DoNotUse.class)
public void foo() {
...
}
}
-----------------
These checks are not enforced during the runtime, so in this way, you can keep the old application working, and at the same time prevent the new code from using this feature. (I should point out that technically speaking the enforcement is optional, even during the compile time --- after all, it's just a semantics imposed by a library external to Javac.)
Extensible Access Modifiers
The library comes with a few built-in access modifiers, but your application can define your own by extending the <<>> type. For example, maybe you want to allow read but prevent write to a field. Maybe you want to only allow certain methods to be called from within the constructor (or the other way around.)
There's a lot of freedom.
Enforcing Access Modifiers
Currently we provide a Maven mojo to enforce access modifiers. Use it like the following:
-----------------
org.kohsukeaccess-modifier-checker1.0enforce
-----------------
access-modifier-access-modifier-1.4/src/site/site.xml 0000664 0000000 0000000 00000001527 12107037722 0022675 0 ustar 00root root 0000000 0000000
Custom Access Modifierhttp://kohsuke.org/access-modifierorg.kohsukemaven-skin1.1