Coverage Report

Coverage Report - org.apache.creadur.whisker.app.analysis.LicenseAnalyst

Classes in this File

Line Coverage

Branch Coverage

Complexity

LicenseAnalyst

0/64

0/22

1.737

 /**
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  *  to you 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 org.apache.creadur.whisker.app.analysis;
 
 import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.TreeSet;
 
 
 import org.apache.commons.lang3.tuple.Pair;
 import org.apache.creadur.whisker.model.Resource;
 import org.apache.creadur.whisker.model.ResourceNamesCollator;
 import org.apache.creadur.whisker.model.Descriptor;
 import org.apache.creadur.whisker.scan.Directory;
 
 /**
  * 
  */
 public class LicenseAnalyst {
     
     /**
      * @return
      */
     private static Map<ResourceDefinitionError, Collection<ResourceDescription>> buildIssueMap() {
         final Map<ResourceDefinitionError, Collection<ResourceDescription>> results = new HashMap<ResourceDefinitionError, Collection<ResourceDescription>>();
         for (final ResourceDefinitionError error: ResourceDefinitionError.values()) {
             initIssues(results, error);
         }
         return results;
     }
 
     /**
      * @param results
      * @param error
      */
     private static void initIssues(
             final Map<ResourceDefinitionError, Collection<ResourceDescription>> results,
             ResourceDefinitionError error) {
         results.put(error, new TreeSet<ResourceDescription>());
     }
 
     
     private final Collection<Directory> directories;
     private final Map<ResourceDefinitionError, Collection<ResourceDescription>> issues;
     
     public LicenseAnalyst() {
         this(null);
     }
     
     /**
      * @param work
      * @param directories
      */
     public LicenseAnalyst(Collection<Directory> directories) {
         super();
         this.directories = directories;
         issues = buildIssueMap();
     }
 
     public LicenseAnalyst analyse(final Descriptor work) {
         if (directories == null) {
             final ResourceNamesCollator collator = new ResourceNamesCollator();
             work.traverse(collator);
             analyseDuplicates(collator);
             
             final ResourceSourceAuditor sourceAuditor = new ResourceSourceAuditor();
             work.traverse(sourceAuditor);
             analyse(sourceAuditor);
         } else {
             for (final Directory directory: directories) {
                 final ResourceNamesCollator collator = new ResourceNamesCollator();
                 work.traverseDirectory(collator, directory.getName());
                 analyseLicenses(directory, collator);
                 analyseDuplicates(collator);
                 
                 final ResourceSourceAuditor sourceAuditor = new ResourceSourceAuditor();
                 work.traverseDirectory(sourceAuditor, directory.getName());
                 analyse(sourceAuditor);
             }
         }
         return this;
     }
 
     /**
      * @param sourceAuditor
      */
     private void analyse(ResourceSourceAuditor sourceAuditor) {
         addIssues(sourceAuditor.getResourcesMissingSource(), ResourceDefinitionError.MISSING_SOURCE);
     }
 
     public boolean isValid() {
         for (final ResourceDefinitionError error: ResourceDefinitionError.values()) {
             if (!getIssues(error).isEmpty()) {
                 return false;
             }
         }
         return true;
     }
     
     public Descriptor validate(final Descriptor work) throws ResourceDefinitionException {
         analyse(work);
         if (isValid()) {
             return work;
         } else {
             throw new ResourceDefinitionException(issues);
         }
             
     }
     
     /**
      * @param collator
      */
     private void analyseDuplicates(final ResourceNamesCollator collator) {
         addIssues(collator.getDuplicates(), ResourceDefinitionError.DUPLICATE);
     }
 
     /**
      * @param resources
      * @param error
      */
     private void addIssues(
             Collection<Pair<org.apache.creadur.whisker.model.WithinDirectory, Resource>> resources,
             ResourceDefinitionError error) {
         for (Pair<org.apache.creadur.whisker.model.WithinDirectory, Resource> duplicate: resources) {
             getIssues(error).add(new ResourceDescription(duplicate.getLeft().getName(), duplicate.getRight().getName()));
         }
     }
 
     private void analyseLicenses(final Directory directory,
             final ResourceNamesCollator collator) {
         analyseExtraLicenses(directory, collator);
         analyseMissingLicenses(directory, collator);
     }
 
     
     /**
      * @param directory
      * @param collator
      */
     private void analyseExtraLicenses(final Directory directory,
             final ResourceNamesCollator collator) {
         final Collection<String> actualResources = directory.getContents();
         for (final String resourceLicense: collator.getNames()) {
             if (actualResources.contains(resourceLicense)) {
                 // Fine
             } else {
                 getExtraLicenses().add(new ResourceDescription(directory.getName(), resourceLicense));
             }
         }
     }
     
     /**
      * @param directory
      * @param collator
      */
     private void analyseMissingLicenses(final Directory directory,
             final ResourceNamesCollator collator) {
         final Collection<String> licensedResources = collator.getNames();
         for (final String actualResource: directory.getContents()) {
             if (licensedResources.contains(actualResource)) {
                 // Fine
             } else {
                 getMissingLicenses().add(new ResourceDescription(directory.getName(), actualResource));
             }
         }
     }
 
 
     public Collection<ResourceDescription> getResourcesMissingSources() {
         return getIssues(ResourceDefinitionError.MISSING_SOURCE);
     }
 
     
     
     public Collection<ResourceDescription> getExtraLicenses() {
         return getIssues(ResourceDefinitionError.EXTRA_LICENSE);
     }
     
     public Collection<ResourceDescription> getMissingLicenses() {
         return getIssues(ResourceDefinitionError.MISSING_LICENSE);
     }
     
     /**
      * @return the duplicates
      */
     public Collection<ResourceDescription> getDuplicates() {
         return getIssues(ResourceDefinitionError.DUPLICATE);
     }
 
     public Collection<ResourceDescription> getIssues(ResourceDefinitionError ofType) {
         return issues.get(ofType);
     }
     
     /**
      * @see java.lang.Object#toString()
      */
     @Override
     public String toString() {
         return "LicenseAnalyst [directories=" + directories + "]";
     }
 }

1		/**
2		* Licensed to the Apache Software Foundation (ASF) under one
3		* or more contributor license agreements. See the NOTICE file
4		* distributed with this work for additional information
5		* regarding copyright ownership. The ASF licenses this file
6		* to you under the Apache License, Version 2.0 (the
7		* "License"); you may not use this file except in compliance
8		* with the License. You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing,
13		* software distributed under the License is distributed on an
14		* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15		* KIND, either express or implied. See the License for the
16		* specific language governing permissions and limitations
17		* under the License.
18		*/
19		package org.apache.creadur.whisker.app.analysis;
20
21		import java.util.Collection;
22		import java.util.HashMap;
23		import java.util.Map;
24		import java.util.TreeSet;
25
26
27		import org.apache.commons.lang3.tuple.Pair;
28		import org.apache.creadur.whisker.model.Resource;
29		import org.apache.creadur.whisker.model.ResourceNamesCollator;
30		import org.apache.creadur.whisker.model.Descriptor;
31		import org.apache.creadur.whisker.scan.Directory;
32
33		/**
34		*
35		*/
36		public class LicenseAnalyst {
37
38		/**
39		* @return
40		*/
41		private static Map<ResourceDefinitionError, Collection<ResourceDescription>> buildIssueMap() {
42	0	final Map<ResourceDefinitionError, Collection<ResourceDescription>> results = new HashMap<ResourceDefinitionError, Collection<ResourceDescription>>();
43	0	for (final ResourceDefinitionError error: ResourceDefinitionError.values()) {
44	0	initIssues(results, error);
45		}
46	0	return results;
47		}
48
49		/**
50		* @param results
51		* @param error
52		*/
53		private static void initIssues(
54		final Map<ResourceDefinitionError, Collection<ResourceDescription>> results,
55		ResourceDefinitionError error) {
56	0	results.put(error, new TreeSet<ResourceDescription>());
57	0	}
58
59
60		private final Collection<Directory> directories;
61		private final Map<ResourceDefinitionError, Collection<ResourceDescription>> issues;
62
63		public LicenseAnalyst() {
64	0	this(null);
65	0	}
66
67		/**
68		* @param work
69		* @param directories
70		*/
71		public LicenseAnalyst(Collection<Directory> directories) {
72	0	super();
73	0	this.directories = directories;
74	0	issues = buildIssueMap();
75	0	}
76
77		public LicenseAnalyst analyse(final Descriptor work) {
78	0	if (directories == null) {
79	0	final ResourceNamesCollator collator = new ResourceNamesCollator();
80	0	work.traverse(collator);
81	0	analyseDuplicates(collator);
82
83	0	final ResourceSourceAuditor sourceAuditor = new ResourceSourceAuditor();
84	0	work.traverse(sourceAuditor);
85	0	analyse(sourceAuditor);
86	0	} else {
87	0	for (final Directory directory: directories) {
88	0	final ResourceNamesCollator collator = new ResourceNamesCollator();
89	0	work.traverseDirectory(collator, directory.getName());
90	0	analyseLicenses(directory, collator);
91	0	analyseDuplicates(collator);
92
93	0	final ResourceSourceAuditor sourceAuditor = new ResourceSourceAuditor();
94	0	work.traverseDirectory(sourceAuditor, directory.getName());
95	0	analyse(sourceAuditor);
96	0	}
97		}
98	0	return this;
99		}
100
101		/**
102		* @param sourceAuditor
103		*/
104		private void analyse(ResourceSourceAuditor sourceAuditor) {
105	0	addIssues(sourceAuditor.getResourcesMissingSource(), ResourceDefinitionError.MISSING_SOURCE);
106	0	}
107
108		public boolean isValid() {
109	0	for (final ResourceDefinitionError error: ResourceDefinitionError.values()) {
110	0	if (!getIssues(error).isEmpty()) {
111	0	return false;
112		}
113		}
114	0	return true;
115		}
116
117		public Descriptor validate(final Descriptor work) throws ResourceDefinitionException {
118	0	analyse(work);
119	0	if (isValid()) {
120	0	return work;
121		} else {
122	0	throw new ResourceDefinitionException(issues);
123		}
124
125		}
126
127		/**
128		* @param collator
129		*/
130		private void analyseDuplicates(final ResourceNamesCollator collator) {
131	0	addIssues(collator.getDuplicates(), ResourceDefinitionError.DUPLICATE);
132	0	}
133
134		/**
135		* @param resources
136		* @param error
137		*/
138		private void addIssues(
139		Collection<Pair<org.apache.creadur.whisker.model.WithinDirectory, Resource>> resources,
140		ResourceDefinitionError error) {
141	0	for (Pair<org.apache.creadur.whisker.model.WithinDirectory, Resource> duplicate: resources) {
142	0	getIssues(error).add(new ResourceDescription(duplicate.getLeft().getName(), duplicate.getRight().getName()));
143		}
144	0	}
145
146		private void analyseLicenses(final Directory directory,
147		final ResourceNamesCollator collator) {
148	0	analyseExtraLicenses(directory, collator);
149	0	analyseMissingLicenses(directory, collator);
150	0	}
151
152
153		/**
154		* @param directory
155		* @param collator
156		*/
157		private void analyseExtraLicenses(final Directory directory,
158		final ResourceNamesCollator collator) {
159	0	final Collection<String> actualResources = directory.getContents();
160	0	for (final String resourceLicense: collator.getNames()) {
161	0	if (actualResources.contains(resourceLicense)) {
162		// Fine
163		} else {
164	0	getExtraLicenses().add(new ResourceDescription(directory.getName(), resourceLicense));
165		}
166		}
167	0	}
168
169		/**
170		* @param directory
171		* @param collator
172		*/
173		private void analyseMissingLicenses(final Directory directory,
174		final ResourceNamesCollator collator) {
175	0	final Collection<String> licensedResources = collator.getNames();
176	0	for (final String actualResource: directory.getContents()) {
177	0	if (licensedResources.contains(actualResource)) {
178		// Fine
179		} else {
180	0	getMissingLicenses().add(new ResourceDescription(directory.getName(), actualResource));
181		}
182		}
183	0	}
184
185
186		public Collection<ResourceDescription> getResourcesMissingSources() {
187	0	return getIssues(ResourceDefinitionError.MISSING_SOURCE);
188		}
189
190
191
192		public Collection<ResourceDescription> getExtraLicenses() {
193	0	return getIssues(ResourceDefinitionError.EXTRA_LICENSE);
194		}
195
196		public Collection<ResourceDescription> getMissingLicenses() {
197	0	return getIssues(ResourceDefinitionError.MISSING_LICENSE);
198		}
199
200		/**
201		* @return the duplicates
202		*/
203		public Collection<ResourceDescription> getDuplicates() {
204	0	return getIssues(ResourceDefinitionError.DUPLICATE);
205		}
206
207		public Collection<ResourceDescription> getIssues(ResourceDefinitionError ofType) {
208	0	return issues.get(ofType);
209		}
210
211		/**
212		* @see java.lang.Object#toString()
213		*/
214		@Override
215		public String toString() {
216	0	return "LicenseAnalyst [directories=" + directories + "]";
217		}
218		}