1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
/**
* Copyright 2007 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.tonicsystems.jarjar.transform.jar;
import com.tonicsystems.jarjar.transform.config.PatternUtils;
import com.tonicsystems.jarjar.transform.config.ClassKeepTransitive;
import com.tonicsystems.jarjar.transform.Transformable;
import com.tonicsystems.jarjar.util.ClassNameUtils;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nonnull;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.commons.Remapper;
import org.objectweb.asm.commons.RemappingClassAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Keeps all classes reachable from a given set of roots.
*
* Put this early in the chain as it does not honour renames.
*/
public class ClassClosureJarProcessor extends AbstractFilterJarProcessor {
private static final Logger LOG = LoggerFactory.getLogger(ClassClosureJarProcessor.class);
private static class DependencyCollector extends Remapper {
private final Set<String> dependencies = new HashSet<String>();
@Override
public String map(String key) {
if (key.startsWith("java/") || key.startsWith("javax/"))
return null;
dependencies.add(key);
return null;
}
@Override
public Object mapValue(Object value) {
if (value instanceof String) {
String s = (String) value;
if (ClassNameUtils.isArrayForName(s)) {
mapDesc(s.replace('.', '/'));
} else if (ClassNameUtils.isForName(s)) {
map(s.replace('.', '/'));
}
return value;
} else {
return super.mapValue(value);
}
}
}
private final List<ClassKeepTransitive> patterns;
private final List<String> roots = new ArrayList<String>();
private final Map<String, Set<String>> dependencies = new HashMap<String, Set<String>>();
private Set<String> closure;
public ClassClosureJarProcessor(@Nonnull Iterable<? extends ClassKeepTransitive> patterns) {
this.patterns = PatternUtils.toList(patterns);
}
public ClassClosureJarProcessor(@Nonnull ClassKeepTransitive... patterns) {
this(Arrays.asList(patterns));
}
public void addKeep(@Nonnull ClassKeepTransitive pattern) {
patterns.add(pattern);
}
private boolean isEnabled() {
return !patterns.isEmpty();
}
@Override
public Result scan(Transformable struct) throws IOException {
if (!isEnabled())
return Result.KEEP;
try {
if (ClassNameUtils.isClass(struct.name)) {
String name = struct.name.substring(0, struct.name.length() - 6);
for (ClassKeepTransitive pattern : patterns)
if (pattern.matches(name))
roots.add(name);
DependencyCollector collector = new DependencyCollector();
dependencies.put(name, collector.dependencies);
new ClassReader(new ByteArrayInputStream(struct.data)).accept(new RemappingClassAdapter(null, collector), ClassReader.EXPAND_FRAMES);
collector.dependencies.remove(name);
}
} catch (Exception e) {
LOG.warn("Error reading " + struct.name + ": " + e.getMessage());
}
return Result.KEEP;
}
private void addTransitiveClosure(Collection<? super String> out, Collection<String> itemDependencies) {
if (itemDependencies == null)
return;
for (String name : itemDependencies)
if (out.add(name))
addTransitiveClosure(out, dependencies.get(name));
}
@Override
protected boolean isFiltered(String name) {
if (closure == null) {
closure = new HashSet<String>();
addTransitiveClosure(closure, roots);
}
return !closure.contains(name);
}
@Override
public Result process(Transformable struct) throws IOException {
if (!isEnabled())
return Result.KEEP;
if (!ClassNameUtils.isClass(struct.name))
return Result.KEEP;
return super.process(struct);
}
}
|
