Coverage Report

Coverage Report - org.apache.creadur.whisker.app.Whisker

Classes in this File

Line Coverage

Branch Coverage

Complexity

Whisker

14%

6/41

0/7

1.409

Whisker$1

0/1

N/A

1.409

 /**
  * 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;
 
 import static org.apache.creadur.whisker.app.LicenseConfiguration.*;
 import static org.apache.creadur.whisker.app.ConfigurationBuilder.*;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Collection;
 
 import org.apache.creadur.whisker.app.analysis.LicenseAnalyst;
 import org.apache.creadur.whisker.fromxml.JDomBuilder;
 import org.apache.creadur.whisker.model.Descriptor;
 import org.apache.creadur.whisker.scan.Directory;
 import org.apache.creadur.whisker.scan.FromFileSystem;
 
 
 /**
  * High level application, configured as a bean.
  */
 public class Whisker {
 
     /** Operation to be performed. */
     private Act act;
     /** The source on which the operation is to be performed. */
     private String source;
     /** The meta-data. */
     private StreamableResource licenseDescriptor;
     /** Pluggable report writer. */
     private ResultWriterFactory writerFactory;
     /** Pluggable templating. */
     private AbstractEngine engine;
     /** Configuration options for license rendering */
     private LicenseConfiguration licenseConfiguration = DEFAULT_LICENSE_CONFIGURATION;
 
     /**
      * Gets the configuration options for license rendering.
      * @return not null
      */
     public LicenseConfiguration getLicenseConfiguration() {
         return licenseConfiguration;
     }
 
     /**
      * Sets the configuration options for license rendering.
      * @param licenseConfiguration not null
      * @return this, not null
      */
     public Whisker setLicenseConfiguration(final LicenseConfiguration licenseConfiguration) {
         this.licenseConfiguration = notNull(licenseConfiguration);
         return this;
     }
 
     /**
      * Gets the factory that builds product {@link Writer}s.
      * @return factory
      */
     public final ResultWriterFactory getWriterFactory() {
         return writerFactory;
     }
 
     /**
      * Sets the factory that builds product {@link Writer}s.
      * @param writerFactory not null
      * @return this, not null
      */
     public final Whisker setWriterFactory(final ResultWriterFactory writerFactory) {
         this.writerFactory = writerFactory;
         return this;
     }
 
     /**
      * Gets the reporting engine.
      * @return not null
      */
     public final AbstractEngine getEngine() {
         return engine;
     }
 
     /**
      * Sets the reporting engine.
      * @param engine not null
      * @return this, not null
      */
     public final Whisker setEngine(final AbstractEngine engine) {
         this.engine = engine;
         return this;
     }
 
     /**
      * Gets the source on which the operation will be performed.
      * @return the base, not null
      */
     public final String getSource() {
         return source;
     }
 
     /**
      * Sets the source
      * @param source the base to set
      * @return this, not null
      */
     public final Whisker setSource(final String source) {
         this.source = source;
         return this;
     }
 
     /**
      * @return the licenseDescriptor
      */
     public final StreamableResource getLicenseDescriptor() {
         return licenseDescriptor;
     }
 
     /**
      * Sets meta-data describing the source licensing.
      * @param licenseDescriptor the licenseDescriptor to set
      * @return this, not null
      */
     public final Whisker setLicenseDescriptor(StreamableResource licenseDescriptor) {
         this.licenseDescriptor = licenseDescriptor;
         return this;
     }
 
     /**
      * Gets the operation to be performed.
      * @return the act
      */
     public final Act getAct() {
         return act;
     }
 
     /**
      * Sets the operation to be performed.
      * @param act the act to set
      * @return this, not null
      */
     public final Whisker setAct(Act act) {
         this.act = act;
         return this;
     }
 
     /**
      * Performs the operation set.
      * @return this, not null
      * @throws Exception when the operation fails
      */
     public Whisker act() throws Exception {
         switch (act) {
             case REPORT:
                 return report();
             case AUDIT:
                 return validate();
             case SKELETON:
                 return skeleton();
             case GENERATE:
             default:
                 return generate();
         }
     }
 
     /**
      * Creates a template to help create meta-data.
      * @throws Exception when the report creation fails
      * @return this, not null
      */
     private Whisker skeleton() throws Exception {
         engine.skeleton(directories(), getWriterFactory(), configuration());
         return this;
     }
 
     /**
      * Builds a populated configuration.
      * @return not null
      */
     public Configuration configuration() {
         return aConfiguration().with(licenseConfiguration).build();
     }
 
     /**
      * Writes a report on the directories in the source.
      * @return this, not null
      * @throws Exception when the report creation fails
      */
     private Whisker report() throws Exception {
         engine.report(directories(), getWriterFactory(), configuration());
         return this;
     }
 
     /**
      * Generates legal documentation.
      * @return this, not null
      * @throws Exception when the generation fails
      */
     private Whisker generate() throws Exception {
         engine.generate(new LicenseAnalyst().validate(load(getLicenseDescriptor())), getWriterFactory(), configuration());
         return this;
     }
 
     /**
      * Writes a validation report.
      * @return this, not null
      * @throws Exception when the validation fails
      */
     private Whisker validate() throws Exception {
         engine.validate(new LicenseAnalyst(directories()).analyse(load(getLicenseDescriptor())), getWriterFactory(), configuration());
         return this;
     }
 
     /**
      * Describes the directories within the source.
      * @return not null
      * @throws IOException when reading the source fails
      */
     private Collection<Directory> directories() throws IOException {
         return new FromFileSystem().withBase(getSource());
     }
 
     /**
      * Describes the state suitable for logging.
      * @return something suitable for logging
      */
     @Override
     public String toString() {
         return "Whisker [act=" + act + ", base=" + source
                 + ", licenseDescriptor=" + licenseDescriptor + "]";
     }
 
 
     /**
      * Opens a resource as a stream.
      * @param resource not null
      * @return not null
      * @throws IOException
      */
     private InputStream resourceAsStream(final StreamableResource resource) throws IOException {
         return resource.open();
     }
 
 
     /**
      * Reads meta-data from the given source.
      * @param resource not null
      * @return not null
      * @throws Exception when meta-data cannot be loaded
      */
     private Descriptor load(final StreamableResource resource) throws Exception {
         final InputStream resourceAsStream = resourceAsStream(resource);
         if (resourceAsStream == null) {
             throw new IllegalArgumentException("Cannot load " + resource);
         }
         return new JDomBuilder().build(resourceAsStream);
     }
 }

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;
20
21		import static org.apache.creadur.whisker.app.LicenseConfiguration.*;
22		import static org.apache.creadur.whisker.app.ConfigurationBuilder.*;
23
24		import java.io.IOException;
25		import java.io.InputStream;
26		import java.util.Collection;
27
28		import org.apache.creadur.whisker.app.analysis.LicenseAnalyst;
29		import org.apache.creadur.whisker.fromxml.JDomBuilder;
30		import org.apache.creadur.whisker.model.Descriptor;
31		import org.apache.creadur.whisker.scan.Directory;
32		import org.apache.creadur.whisker.scan.FromFileSystem;
33
34
35		/**
36		* High level application, configured as a bean.
37		*/
38	6	public class Whisker {
39
40		/** Operation to be performed. */
41		private Act act;
42		/** The source on which the operation is to be performed. */
43		private String source;
44		/** The meta-data. */
45		private StreamableResource licenseDescriptor;
46		/** Pluggable report writer. */
47		private ResultWriterFactory writerFactory;
48		/** Pluggable templating. */
49		private AbstractEngine engine;
50		/** Configuration options for license rendering */
51	6	private LicenseConfiguration licenseConfiguration = DEFAULT_LICENSE_CONFIGURATION;
52
53		/**
54		* Gets the configuration options for license rendering.
55		* @return not null
56		*/
57		public LicenseConfiguration getLicenseConfiguration() {
58	2	return licenseConfiguration;
59		}
60
61		/**
62		* Sets the configuration options for license rendering.
63		* @param licenseConfiguration not null
64		* @return this, not null
65		*/
66		public Whisker setLicenseConfiguration(final LicenseConfiguration licenseConfiguration) {
67	6	this.licenseConfiguration = notNull(licenseConfiguration);
68	6	return this;
69		}
70
71		/**
72		* Gets the factory that builds product {@link Writer}s.
73		* @return factory
74		*/
75		public final ResultWriterFactory getWriterFactory() {
76	0	return writerFactory;
77		}
78
79		/**
80		* Sets the factory that builds product {@link Writer}s.
81		* @param writerFactory not null
82		* @return this, not null
83		*/
84		public final Whisker setWriterFactory(final ResultWriterFactory writerFactory) {
85	0	this.writerFactory = writerFactory;
86	0	return this;
87		}
88
89		/**
90		* Gets the reporting engine.
91		* @return not null
92		*/
93		public final AbstractEngine getEngine() {
94	0	return engine;
95		}
96
97		/**
98		* Sets the reporting engine.
99		* @param engine not null
100		* @return this, not null
101		*/
102		public final Whisker setEngine(final AbstractEngine engine) {
103	0	this.engine = engine;
104	0	return this;
105		}
106
107		/**
108		* Gets the source on which the operation will be performed.
109		* @return the base, not null
110		*/
111		public final String getSource() {
112	0	return source;
113		}
114
115		/**
116		* Sets the source
117		* @param source the base to set
118		* @return this, not null
119		*/
120		public final Whisker setSource(final String source) {
121	0	this.source = source;
122	0	return this;
123		}
124
125		/**
126		* @return the licenseDescriptor
127		*/
128		public final StreamableResource getLicenseDescriptor() {
129	0	return licenseDescriptor;
130		}
131
132		/**
133		* Sets meta-data describing the source licensing.
134		* @param licenseDescriptor the licenseDescriptor to set
135		* @return this, not null
136		*/
137		public final Whisker setLicenseDescriptor(StreamableResource licenseDescriptor) {
138	0	this.licenseDescriptor = licenseDescriptor;
139	0	return this;
140		}
141
142		/**
143		* Gets the operation to be performed.
144		* @return the act
145		*/
146		public final Act getAct() {
147	0	return act;
148		}
149
150		/**
151		* Sets the operation to be performed.
152		* @param act the act to set
153		* @return this, not null
154		*/
155		public final Whisker setAct(Act act) {
156	0	this.act = act;
157	0	return this;
158		}
159
160		/**
161		* Performs the operation set.
162		* @return this, not null
163		* @throws Exception when the operation fails
164		*/
165		public Whisker act() throws Exception {
166	0	switch (act) {
167		case REPORT:
168	0	return report();
169		case AUDIT:
170	0	return validate();
171		case SKELETON:
172	0	return skeleton();
173		case GENERATE:
174		default:
175	0	return generate();
176		}
177		}
178
179		/**
180		* Creates a template to help create meta-data.
181		* @throws Exception when the report creation fails
182		* @return this, not null
183		*/
184		private Whisker skeleton() throws Exception {
185	0	engine.skeleton(directories(), getWriterFactory(), configuration());
186	0	return this;
187		}
188
189		/**
190		* Builds a populated configuration.
191		* @return not null
192		*/
193		public Configuration configuration() {
194	4	return aConfiguration().with(licenseConfiguration).build();
195		}
196
197		/**
198		* Writes a report on the directories in the source.
199		* @return this, not null
200		* @throws Exception when the report creation fails
201		*/
202		private Whisker report() throws Exception {
203	0	engine.report(directories(), getWriterFactory(), configuration());
204	0	return this;
205		}
206
207		/**
208		* Generates legal documentation.
209		* @return this, not null
210		* @throws Exception when the generation fails
211		*/
212		private Whisker generate() throws Exception {
213	0	engine.generate(new LicenseAnalyst().validate(load(getLicenseDescriptor())), getWriterFactory(), configuration());
214	0	return this;
215		}
216
217		/**
218		* Writes a validation report.
219		* @return this, not null
220		* @throws Exception when the validation fails
221		*/
222		private Whisker validate() throws Exception {
223	0	engine.validate(new LicenseAnalyst(directories()).analyse(load(getLicenseDescriptor())), getWriterFactory(), configuration());
224	0	return this;
225		}
226
227		/**
228		* Describes the directories within the source.
229		* @return not null
230		* @throws IOException when reading the source fails
231		*/
232		private Collection<Directory> directories() throws IOException {
233	0	return new FromFileSystem().withBase(getSource());
234		}
235
236		/**
237		* Describes the state suitable for logging.
238		* @return something suitable for logging
239		*/
240		@Override
241		public String toString() {
242	0	return "Whisker [act=" + act + ", base=" + source
243		+ ", licenseDescriptor=" + licenseDescriptor + "]";
244		}
245
246
247		/**
248		* Opens a resource as a stream.
249		* @param resource not null
250		* @return not null
251		* @throws IOException
252		*/
253		private InputStream resourceAsStream(final StreamableResource resource) throws IOException {
254	0	return resource.open();
255		}
256
257
258		/**
259		* Reads meta-data from the given source.
260		* @param resource not null
261		* @return not null
262		* @throws Exception when meta-data cannot be loaded
263		*/
264		private Descriptor load(final StreamableResource resource) throws Exception {
265	0	final InputStream resourceAsStream = resourceAsStream(resource);
266	0	if (resourceAsStream == null) {
267	0	throw new IllegalArgumentException("Cannot load " + resource);
268		}
269	0	return new JDomBuilder().build(resourceAsStream);
270		}
271		}