Coverage Report

Coverage Report - org.apache.creadur.whisker.model.Descriptor

Classes in this File

Line Coverage

Branch Coverage

Complexity

Descriptor

72%

36/50

67%

19/28

1.45

 /**
  * 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.model;
 
 import java.util.Collection;
 import java.util.Map;
 import java.util.Set;
 
 /**
  * High level description of licensing qualities.
  */
 public class Descriptor {
 
     /** Principle license for main work. */
     private final License primaryLicense;
     /** Optional additional primary copyright notice*/
     private final String primaryCopyrightNotice;
     /** Individual or group with main responsible for main work. */
     private final String primaryOrganisationId;
     /** A NOTICE for the main work, for inclusion alongside the LICENSE. */
     private final String primaryNotice;
     /** License meta-data, indexed by id. */
     private final Map<String, License> licenses;
     /** Organisation meta-data, indexed by id */
     private final Map<String, Organisation> organisations;
     /** Notice meta-data, indexed by id. */
     private final Map<String, String> notices;
     /** Directories expected to be contained within the release. */
     private final Collection<WithinDirectory> contents;
 
 
     /**
      * Constructs a description of the expected licensing qualities of a
      * distribution, with no additional primary copyright notice.
      *
      * @param primaryLicense
      *            not null
      * @param primaryOrganisationId
      *            not null
      * @param primaryNotice
      *            possibly null
      * @param licenses
      *            not null, possibly empty
      * @param notices
      *            not null, possibly empty
      * @param organisations
      *            not null, possibly empty
      * @param contents
      *            not null, possibly empty
      */
     public Descriptor(final License primaryLicense,
             final String primaryOrganisationId,
             final String primaryNotice,
             final Map<String, License> licenses,
             final Map<String, String> notices,
             final Map<String, Organisation> organisations,
             final Collection<WithinDirectory> contents) {
         this(   primaryLicense,
                 null,
                 primaryOrganisationId,
                 primaryNotice,
                 licenses,
                 notices,
                 organisations,
                 contents);
     }
 
     /**
      * Constructs a description of the expected licensing qualities of a
      * distribution, with a primary additional copyright notice.
      *
      * @param primaryLicense
      *            not null
      * @param primaryCopyrightNotice
      *            optional primary copyright notice, possibly null
      *
      * @param primaryOrganisationId
      *            not null
      * @param primaryNotice
      *            possibly null
      * @param licenses
      *            not null, possibly empty
      * @param notices
      *            not null, possibly empty
      * @param organisations
      *            not null, possibly empty
      * @param contents
      *            not null, possibly empty
      */
     public Descriptor(final License primaryLicense,
             final String primaryCopyrightNotice,
             final String primaryOrganisationId,
             final String primaryNotice,
             final Map<String, License> licenses,
             final Map<String, String> notices,
             final Map<String, Organisation> organisations,
             final Collection<WithinDirectory> contents) {
         super();
         this.primaryLicense = primaryLicense;
         this.primaryCopyrightNotice = primaryCopyrightNotice;
         this.primaryOrganisationId = primaryOrganisationId;
         this.primaryNotice = primaryNotice;
         this.licenses = licenses;
         this.notices = notices;
         this.organisations = organisations;
         this.contents = contents;
     }
 
     /**
      * Gets an additional copyright notice needed
      * for some primary licenses.
      * @return optional primary copyright notice,
      * possibly null
      */
     public String getPrimaryCopyrightNotice() {
         return primaryCopyrightNotice;
     }
 
     /**
      * Is there a primary copyright notice?
      * @return true if a primary copyright notice
      * has been set, false otherwise
      */
     public boolean isPrimaryCopyrightNotice() {
         return primaryCopyrightNotice != null;
     }
 
     /**
      * Gets the principle NOTICE for the main work.
      *
      * @return the primaryNotice
      */
     public String getPrimaryNotice() {
         return this.primaryNotice;
     }
 
     /**
      * Collates NOTICE meta-data for resources.
      *
      * @return not null, possibly empty
      */
     public Map<String, Collection<Resource>> getResourceNotices() {
         final NoticeCollator collator = new NoticeCollator();
         traverse(collator);
         return collator.resourceNotices(this.notices);
     }
 
     /**
      * Gets the organisations described.
      * @return organisations indexed by id, not null
      */
     public Map<String, Organisation> getOrganisations() {
         return organisations;
     }
 
     /**
      * Collates NOTICE meta-data not linked to any resource.
      *
      * @return not null, possibly empty
      */
     public Set<String> getOtherNotices() {
         final NoticeCollator collator = new NoticeCollator();
         traverse(collator);
         return collator.notices(this.notices);
     }
 
     /**
      * Gets the license with the given id.
      *
      * @param id
      *            not null
      * @return the license with the given id, or null
      */
     public License license(final String id) {
         return this.licenses.get(id);
     }
 
     /**
      * Gets the principle license under which the work is licensed.
      *
      * @return the principle license, not null
      */
     public License getPrimaryLicense() {
         return this.primaryLicense;
     }
 
     /**
      * Gets the contents expected in the distribution.
      *
      * @return not null, possibly null
      */
     public Collection<WithinDirectory> getContents() {
         return this.contents;
     }
 
     /**
      * Is the given license the principle license for the main work?
      *
      * @param license
      *            not null
      * @return true when the given license is the primary license, not null
      */
     public boolean isPrimary(final License license) {
         return this.primaryLicense.equals(license);
     }
 
     /**
      * Is the given individual or group the principle organisation with
      * responsibility for the main work.
      *
      * @param byOrganisation
      *            not null
      * @return true when the given organisation is primary
      */
     public boolean isPrimary(final ByOrganisation byOrganisation) {
         return byOrganisation.getId().equals(this.primaryOrganisationId);
     }
 
     /**
      * Is this collection of resources expected to contain only material
      * licensed under the primary license by the
      * primary organisation with the primary copyright notice?
      *
      * @param contentElement
      *            not null
      * @return true when the contents are all licensed under the primary license
      *         by the primary organisation
      */
     public boolean isOnlyPrimary(final ContentElement contentElement) {
         final NoCopyrightNoticeVerifier verifier = new NoCopyrightNoticeVerifier();
         final LicenseAndOrganisationCollator collator = new LicenseAndOrganisationCollator();
         contentElement.accept(collator);
         contentElement.accept(verifier);
         return collator.isOnlyLicense(getPrimaryLicense())
                 && collator.isOnlyOrganisation(this.primaryOrganisationId)
                 && !verifier.isCopyrightNoticePresent();
     }
 
     /**
      * Traverses the content directories.
      *
      * @param visitor
      *            possibly null
      */
     public void traverse(final Visitor visitor) {
         for (final WithinDirectory directory : getContents()) {
             directory.accept(visitor);
         }
     }
 
     /**
      * Traverses the given directory.
      *
      * @param visitor
      *            possibly null
      * @param directoryName
      *            not null
      */
     public void traverseDirectory(final Visitor visitor,
             final String directoryName) {
         for (final WithinDirectory directory : getContents()) {
             if (directory.isNamed(directoryName)) {
                 directory.accept(visitor);
             }
         }
     }
 
     /**
      * Is a NOTICE document required?
      *
      * @return true when a NOTICE is required, false otherwise
      */
     public boolean isNoticeRequired() {
         return primaryNoticeExists() || resourceNoticesExist();
     }
 
     /**
      * Does any resource have a required notice?
      *
      * @return true when at least one required third party notice exists, false
      *         otherwise
      */
     public boolean resourceNoticesExist() {
         return !getResourceNotices().isEmpty();
     }
 
     /**
      * Does the work described have a primary notice?
      *
      * @return true unless the primary notice is null or whitespace
      */
     public boolean primaryNoticeExists() {
         return (this.primaryNotice != null)
                 && !"".equals(this.primaryNotice.trim());
     }
 
     /**
      * Is this the work of the primary organisation only?
      *
      * @return true when no third party resources are contained, false when
      *         third party resources exist. In particular, true when
      *         contents are empty.
      */
     public boolean isPrimaryOnly() {
         final boolean result;
         if (contents.size() > 0) {
             final LicenseAndOrganisationCollator collator = new LicenseAndOrganisationCollator();
             for (final WithinDirectory directory : contents) {
                 directory.accept(collator);
             }
             result = collator.isOnlyOrganisation(primaryOrganisationId);
         } else {
             result = true;
         }
         return result;
     }
 }

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.model;
20
21		import java.util.Collection;
22		import java.util.Map;
23		import java.util.Set;
24
25		/**
26		* High level description of licensing qualities.
27		*/
28		public class Descriptor {
29
30		/** Principle license for main work. */
31		private final License primaryLicense;
32		/** Optional additional primary copyright notice*/
33		private final String primaryCopyrightNotice;
34		/** Individual or group with main responsible for main work. */
35		private final String primaryOrganisationId;
36		/** A NOTICE for the main work, for inclusion alongside the LICENSE. */
37		private final String primaryNotice;
38		/** License meta-data, indexed by id. */
39		private final Map<String, License> licenses;
40		/** Organisation meta-data, indexed by id */
41		private final Map<String, Organisation> organisations;
42		/** Notice meta-data, indexed by id. */
43		private final Map<String, String> notices;
44		/** Directories expected to be contained within the release. */
45		private final Collection<WithinDirectory> contents;
46
47
48		/**
49		* Constructs a description of the expected licensing qualities of a
50		* distribution, with no additional primary copyright notice.
51		*
52		* @param primaryLicense
53		* not null
54		* @param primaryOrganisationId
55		* not null
56		* @param primaryNotice
57		* possibly null
58		* @param licenses
59		* not null, possibly empty
60		* @param notices
61		* not null, possibly empty
62		* @param organisations
63		* not null, possibly empty
64		* @param contents
65		* not null, possibly empty
66		*/
67		public Descriptor(final License primaryLicense,
68		final String primaryOrganisationId,
69		final String primaryNotice,
70		final Map<String, License> licenses,
71		final Map<String, String> notices,
72		final Map<String, Organisation> organisations,
73		final Collection<WithinDirectory> contents) {
74	24	this( primaryLicense,
75		null,
76		primaryOrganisationId,
77		primaryNotice,
78		licenses,
79		notices,
80		organisations,
81		contents);
82	24	}
83
84		/**
85		* Constructs a description of the expected licensing qualities of a
86		* distribution, with a primary additional copyright notice.
87		*
88		* @param primaryLicense
89		* not null
90		* @param primaryCopyrightNotice
91		* optional primary copyright notice, possibly null
92		*
93		* @param primaryOrganisationId
94		* not null
95		* @param primaryNotice
96		* possibly null
97		* @param licenses
98		* not null, possibly empty
99		* @param notices
100		* not null, possibly empty
101		* @param organisations
102		* not null, possibly empty
103		* @param contents
104		* not null, possibly empty
105		*/
106		public Descriptor(final License primaryLicense,
107		final String primaryCopyrightNotice,
108		final String primaryOrganisationId,
109		final String primaryNotice,
110		final Map<String, License> licenses,
111		final Map<String, String> notices,
112		final Map<String, Organisation> organisations,
113		final Collection<WithinDirectory> contents) {
114	32	super();
115	32	this.primaryLicense = primaryLicense;
116	32	this.primaryCopyrightNotice = primaryCopyrightNotice;
117	32	this.primaryOrganisationId = primaryOrganisationId;
118	32	this.primaryNotice = primaryNotice;
119	32	this.licenses = licenses;
120	32	this.notices = notices;
121	32	this.organisations = organisations;
122	32	this.contents = contents;
123	32	}
124
125		/**
126		* Gets an additional copyright notice needed
127		* for some primary licenses.
128		* @return optional primary copyright notice,
129		* possibly null
130		*/
131		public String getPrimaryCopyrightNotice() {
132	0	return primaryCopyrightNotice;
133		}
134
135		/**
136		* Is there a primary copyright notice?
137		* @return true if a primary copyright notice
138		* has been set, false otherwise
139		*/
140		public boolean isPrimaryCopyrightNotice() {
141	0	return primaryCopyrightNotice != null;
142		}
143
144		/**
145		* Gets the principle NOTICE for the main work.
146		*
147		* @return the primaryNotice
148		*/
149		public String getPrimaryNotice() {
150	0	return this.primaryNotice;
151		}
152
153		/**
154		* Collates NOTICE meta-data for resources.
155		*
156		* @return not null, possibly empty
157		*/
158		public Map<String, Collection<Resource>> getResourceNotices() {
159	18	final NoticeCollator collator = new NoticeCollator();
160	18	traverse(collator);
161	18	return collator.resourceNotices(this.notices);
162		}
163
164		/**
165		* Gets the organisations described.
166		* @return organisations indexed by id, not null
167		*/
168		public Map<String, Organisation> getOrganisations() {
169	0	return organisations;
170		}
171
172		/**
173		* Collates NOTICE meta-data not linked to any resource.
174		*
175		* @return not null, possibly empty
176		*/
177		public Set<String> getOtherNotices() {
178	0	final NoticeCollator collator = new NoticeCollator();
179	0	traverse(collator);
180	0	return collator.notices(this.notices);
181		}
182
183		/**
184		* Gets the license with the given id.
185		*
186		* @param id
187		* not null
188		* @return the license with the given id, or null
189		*/
190		public License license(final String id) {
191	0	return this.licenses.get(id);
192		}
193
194		/**
195		* Gets the principle license under which the work is licensed.
196		*
197		* @return the principle license, not null
198		*/
199		public License getPrimaryLicense() {
200	2	return this.primaryLicense;
201		}
202
203		/**
204		* Gets the contents expected in the distribution.
205		*
206		* @return not null, possibly null
207		*/
208		public Collection<WithinDirectory> getContents() {
209	18	return this.contents;
210		}
211
212		/**
213		* Is the given license the principle license for the main work?
214		*
215		* @param license
216		* not null
217		* @return true when the given license is the primary license, not null
218		*/
219		public boolean isPrimary(final License license) {
220	0	return this.primaryLicense.equals(license);
221		}
222
223		/**
224		* Is the given individual or group the principle organisation with
225		* responsibility for the main work.
226		*
227		* @param byOrganisation
228		* not null
229		* @return true when the given organisation is primary
230		*/
231		public boolean isPrimary(final ByOrganisation byOrganisation) {
232	0	return byOrganisation.getId().equals(this.primaryOrganisationId);
233		}
234
235		/**
236		* Is this collection of resources expected to contain only material
237		* licensed under the primary license by the
238		* primary organisation with the primary copyright notice?
239		*
240		* @param contentElement
241		* not null
242		* @return true when the contents are all licensed under the primary license
243		* by the primary organisation
244		*/
245		public boolean isOnlyPrimary(final ContentElement contentElement) {
246	2	final NoCopyrightNoticeVerifier verifier = new NoCopyrightNoticeVerifier();
247	2	final LicenseAndOrganisationCollator collator = new LicenseAndOrganisationCollator();
248	2	contentElement.accept(collator);
249	2	contentElement.accept(verifier);
250	2	return collator.isOnlyLicense(getPrimaryLicense())
251		&& collator.isOnlyOrganisation(this.primaryOrganisationId)
252		&& !verifier.isCopyrightNoticePresent();
253		}
254
255		/**
256		* Traverses the content directories.
257		*
258		* @param visitor
259		* possibly null
260		*/
261		public void traverse(final Visitor visitor) {
262	18	for (final WithinDirectory directory : getContents()) {
263	6	directory.accept(visitor);
264		}
265	18	}
266
267		/**
268		* Traverses the given directory.
269		*
270		* @param visitor
271		* possibly null
272		* @param directoryName
273		* not null
274		*/
275		public void traverseDirectory(final Visitor visitor,
276		final String directoryName) {
277	0	for (final WithinDirectory directory : getContents()) {
278	0	if (directory.isNamed(directoryName)) {
279	0	directory.accept(visitor);
280		}
281		}
282	0	}
283
284		/**
285		* Is a NOTICE document required?
286		*
287		* @return true when a NOTICE is required, false otherwise
288		*/
289		public boolean isNoticeRequired() {
290	24	return primaryNoticeExists() \|\| resourceNoticesExist();
291		}
292
293		/**
294		* Does any resource have a required notice?
295		*
296		* @return true when at least one required third party notice exists, false
297		* otherwise
298		*/
299		public boolean resourceNoticesExist() {
300	18	return !getResourceNotices().isEmpty();
301		}
302
303		/**
304		* Does the work described have a primary notice?
305		*
306		* @return true unless the primary notice is null or whitespace
307		*/
308		public boolean primaryNoticeExists() {
309	24	return (this.primaryNotice != null)
310		&& !"".equals(this.primaryNotice.trim());
311		}
312
313		/**
314		* Is this the work of the primary organisation only?
315		*
316		* @return true when no third party resources are contained, false when
317		* third party resources exist. In particular, true when
318		* contents are empty.
319		*/
320		public boolean isPrimaryOnly() {
321		final boolean result;
322	6	if (contents.size() > 0) {
323	4	final LicenseAndOrganisationCollator collator = new LicenseAndOrganisationCollator();
324	4	for (final WithinDirectory directory : contents) {
325	6	directory.accept(collator);
326		}
327	4	result = collator.isOnlyOrganisation(primaryOrganisationId);
328	4	} else {
329	2	result = true;
330		}
331	6	return result;
332		}
333		}