##### Coverage Report - org.jbehave.core.configuration.groovy.GroovyAnnotationBuilder

Classes in this File | Line Coverage | Branch Coverage | Complexity
GroovyAnnotationBuilder |
77% | 21/27
62% | 5/8
| 2.5;2.5

1 |  |
     package org.jbehave.core.configuration.groovy;
2 |  |
3 |  |
     import groovy.lang.GroovyClassLoader;
4 |  |
5 |  |
     import org.jbehave.core.annotations.groovy.UsingGroovy;
6 |  |
     import org.jbehave.core.configuration.AnnotationBuilder;
7 |  |
     import org.jbehave.core.configuration.AnnotationMonitor;
8 |  |
     import org.jbehave.core.configuration.AnnotationRequired;
9 |  |
     import org.jbehave.core.configuration.Configuration;
10 |  |
     import org.jbehave.core.steps.CompositeStepsFactory;
11 |  |
     import org.jbehave.core.steps.InjectableStepsFactory;
12 |  |
     import org.jbehave.core.steps.groovy.GroovyStepsFactory;
13 |  |
14 |  |
     /**
15 |  |
      * Extends {@link AnnotationBuilder} using Groovy-based resources if
16 |  |
      * {@link UsingGroovy} annotation is present.
17 |  |
      *
18 |  |
      * @author Mauro Talevi
19 |  |
      */
20 |  |
     public class GroovyAnnotationBuilder extends AnnotationBuilder {
21 |  |
22 |  |
         private GroovyContext context;
23 |  |
24 |  |
         public GroovyAnnotationBuilder(Class<?> annotatedClass) {
25 | 4 |
             super(annotatedClass);
26 | 4 |
         }
27 |  |
28 |  |
         public GroovyAnnotationBuilder(Class<?> annotatedClass, AnnotationMonitor annotationMonitor) {
29 | 0 |
             super(annotatedClass, annotationMonitor);
30 | 0 |
         }
31 |  |
32 |  |
         @SuppressWarnings("unchecked")
33 |  |
         @Override
34 |  |
         public Configuration buildConfiguration() throws AnnotationRequired {
35 | 3 |
             if (annotationFinder().isAnnotationPresent(UsingGroovy.class)) {
36 | 2 |
                 Class<GroovyClassLoader> classLoaderClass = annotationFinder().getAnnotatedValue(UsingGroovy.class,
37 |  |
                         Class.class, "classLoader");
38 | 2 |
                 Class<GroovyResourceFinder> resourceFinderClass = annotationFinder().getAnnotatedValue(UsingGroovy.class,
39 |  |
                         Class.class, "resourceFinder");
40 |  |
                 try {
41 | 2 |
                     GroovyClassLoader classLoader = super.instanceOf(classLoaderClass, classLoaderClass);
42 | 2 |
                     GroovyResourceFinder resourceFinder = super.instanceOf(resourceFinderClass, resourceFinderClass);
43 | 2 |
                     context = createGroovyContext(classLoader, resourceFinder);
44 | 0 |
                 } catch (Exception e) {
45 | 0 |
                     annotationMonitor().elementCreationFailed(GroovyContext.class, e);
46 | 2 |
                 }
47 | 2 |
             } else {
48 | 1 |
                 annotationMonitor().annotationNotFound(UsingGroovy.class, annotatedClass());
49 |  |
             }
50 | 3 |
             return super.buildConfiguration();
51 |  |
         }
52 |  |
53 |  |
         @Override
54 |  |
         public InjectableStepsFactory buildStepsFactory(Configuration configuration) {
55 | 1 |
             InjectableStepsFactory factoryUsingSteps = super.buildStepsFactory(configuration);
56 | 1 |
             if (context != null) {
57 | 1 |
                 return new CompositeStepsFactory(new GroovyStepsFactory(configuration, context), factoryUsingSteps);
58 |  |
             }
59 | 0 |
             return factoryUsingSteps;
60 |  |
         }
61 |  |
62 |  |
         @Override
63 |  |
         protected <T, V extends T> T instanceOf(Class<T> type, Class<V> ofClass) {
64 | 38 |
             if (context != null) {
65 |  |
                 try {
66 | 38 |
                     return context.getInstanceOfType(type);
67 | 38 |
                 } catch (Exception e) {
68 |  |
                     // default to super class
69 |  |
                 }
70 |  |
             }
71 | 38 |
             return super.instanceOf(type, ofClass);
72 |  |
         }
73 |  |
74 |  |
         protected GroovyContext createGroovyContext(GroovyClassLoader classLoader, GroovyResourceFinder resourceFinder) {
75 | 2 |
             if (context != null) {
76 | 0 |
                 return context;
77 |  |
             }
78 | 2 |
             return new GroovyContext(classLoader, resourceFinder);
79 |  |
         }
80 |  |
81 |  |
     }