Changeset 14682

Timestamp:

07/15/10 12:53:38 (8 weeks ago)

Author:

dkhaywood

Message:

adding capability to have more than oe ClassSubstitutor? (needed, I think, for supporting other languages such as Scala); removed some duplication in JavaIntrospector?

Location:

framework/trunk

Files:

• applib/pom.xml (modified) (1 diff)
• core/metamodel/src/main/java/org/nakedobjects/metamodel/specloader/ReflectorConstants.java (modified) (1 diff)
• core/metamodel/src/main/java/org/nakedobjects/metamodel/specloader/classsubstitutor/ClassSubstitutorComposite.java (added)
• core/metamodel/src/main/java/org/nakedobjects/metamodel/specloader/internal/introspector/JavaIntrospector.java (modified) (6 diffs)
• core/metamodel/src/test/java/org/nakedobjects/metamodel/specloader (added)
• core/metamodel/src/test/java/org/nakedobjects/metamodel/specloader/classsubstitutor (added)
• core/metamodel/src/test/java/org/nakedobjects/metamodel/specloader/classsubstitutor/ClassSubstitutorComposite_lifecycle.java (added)
• core/runtime/src/main/java/org/nakedobjects/runtime/system/installers/JavaReflectorInstaller.java (modified) (4 diffs)
• pom.xml (modified) (1 diff)

framework/trunk/applib/pom.xml

@@ -26 +26 @@
         <build>
                 <plugins>
-                        <plugin>
-                                <groupId>org.apache.maven.plugins</groupId>
-                                <artifactId>maven-source-plugin</artifactId>
-                        </plugin>
-
                         <!-- this may be redundant because this module is now parented by trunk -->
                         <plugin>

framework/trunk/core/metamodel/src/main/java/org/nakedobjects/metamodel/specloader/ReflectorConstants.java

@@ -19 +19 @@
      * Key used to lookup implementation of {@link ClassSubstitutor} in {@link NakedObjectConfiguration}.
      */
-    public static final String CLASS_SUBSTITUTOR_CLASS_NAME = ConfigurationConstants.ROOT + "reflector.class-substitutor";
+    public static final String CLASS_SUBSTITUTOR_CLASS_NAME_LIST = ConfigurationConstants.ROOT + "reflector.class-substitutor";
     public static final String CLASS_SUBSTITUTOR_CLASS_NAME_DEFAULT = ClassSubstitutorIdentity.class.getName();
 

framework/trunk/core/metamodel/src/main/java/org/nakedobjects/metamodel/specloader/internal/introspector/JavaIntrospector.java

@@ -262 +262 @@
 
         // find the actions ...
-        final NakedObjectActionPeer[] actionPeers1 = findActionMethodPeers(MethodScope.OBJECT, true);
-        final NakedObjectActionPeer[] actionPeers2 = findActionMethodPeers(MethodScope.OBJECT, false);
-        final NakedObjectActionPeer[] actionPeers = new NakedObjectActionPeer[actionPeers1.length + actionPeers2.length];
-        System.arraycopy(actionPeers1, 0, actionPeers, 0, actionPeers1.length);
-        System.arraycopy(actionPeers2, 0, actionPeers, actionPeers1.length, actionPeers2.length);
+        MethodScope methodScope = MethodScope.OBJECT;
+                final NakedObjectActionPeer[] actionPeers = findActionMethodsPeers(methodScope);
 
 
@@ -284 +281 @@
 
         // find the class actions ...
-        final NakedObjectActionPeer[] findClassActionMethods1 = findActionMethodPeers(MethodScope.CLASS, true);
-        final NakedObjectActionPeer[] findClassActionMethods2 = findActionMethodPeers(MethodScope.CLASS, false);
-        final NakedObjectActionPeer[] findClassActionMethods = new NakedObjectActionPeer[findClassActionMethods1.length + findClassActionMethods2.length];
-        System.arraycopy(findClassActionMethods1, 0, findClassActionMethods, 0, findClassActionMethods1.length);
-        System.arraycopy(findClassActionMethods2, 0, findClassActionMethods, findClassActionMethods1.length, findClassActionMethods2.length);
+        MethodScope methodsScope2 = MethodScope.CLASS;
+                final NakedObjectActionPeer[] findClassActionMethods = findActionMethodsPeers(methodsScope2);
 
         // ... and the ordering of class actions
@@ -414 +408 @@
     // ////////////////////////////////////////////////////////////////////////////
 
+        private NakedObjectActionPeer[] findActionMethodsPeers(
+                        MethodScope methodScope) {
+                final NakedObjectActionPeer[] actionPeers1 = findActionMethodPeers(methodScope, true);
+        final NakedObjectActionPeer[] actionPeers2 = findActionMethodPeers(methodScope, false);
+        final NakedObjectActionPeer[] actionPeers = new NakedObjectActionPeer[actionPeers1.length + actionPeers2.length];
+        System.arraycopy(actionPeers1, 0, actionPeers, 0, actionPeers1.length);
+        System.arraycopy(actionPeers2, 0, actionPeers, actionPeers1.length, actionPeers2.length);
+                return actionPeers;
+        }
+
+
     private NakedObjectActionPeer[] findActionMethodPeers(final MethodScope methodScope, boolean skipRecognisedHelperMethod) {
         if(LOG.isDebugEnabled()) {
@@ -421 +426 @@
         final List<NakedObjectActionPeer> actionPeers = new ArrayList<NakedObjectActionPeer>();
 
-        eachMethod:
         for (int i = 0; i < methods.length; i++) {
             if (methods[i] == null) {
                 continue;
             }
-            final Method actionMethod = methods[i];
-            if (!MethodFinderUtils.inScope(methodScope, actionMethod)) {
-                continue;
-            }
-
-            List<Class<?>> typesToLoad = new ArrayList<Class<?>>();
-            getSpecificationTraverser().traverseTypes(actionMethod, typesToLoad);
-
-            boolean anyLoadedAsNull = reflector.loadSpecifications(typesToLoad);
-            if (anyLoadedAsNull) {
-                continue;
-            }
-            
-
-            // build/validate action parameters
-            // as for return type, if the reflector's class strategy says to skip any of the 
-            // action's parameter types, then just ignore this action altogether.
-            final Class<?>[] parameterTypes = actionMethod.getParameterTypes();
-            
-            // previously we wrapped primitives.  However, this prevents the lookup of
-            // actions during remote authorization calls (using Identifier class).
-            // ... should we remove ... ?
-            // final Class<?>[] parameterClasses = WrapperUtils.wrapAsNecessary(parameterTypes);
-            
-            final Class<?>[] parameterClasses = parameterTypes;
-            
-            final int numParameters = parameterClasses.length;
-            final JavaNakedObjectActionParamPeer[] actionParams = new JavaNakedObjectActionParamPeer[numParameters];
-
-            for (int j = 0; j < numParameters; j++) {
-                NakedObjectSpecification paramSpec = getSpecificationLoader().loadSpecification(parameterClasses[j]);
-                if (paramSpec == null) {
-                    continue eachMethod;
-                }
-                actionParams[j] = new JavaNakedObjectActionParamPeer(paramSpec);
-            }
-            
-
-            if (getFacetProcessor().recognizes(actionMethod)) {
-                if (actionMethod.getName().startsWith("set")) {
-                  continue;
-                }
-                if (skipRecognisedHelperMethod) {
-                    LOG.info("  skipping possible helper method " + actionMethod);
-                    continue;
-                }
-            }
-
-            if (LOG.isDebugEnabled()) {
-                LOG.debug("  identified action " + actionMethod);
-            }
-            methods[i] = null;
-
-
-            // build action
-            final String fullMethodName = actionMethod.getName();
-            final Identifier identifier = Identifier.actionIdentifier(className, fullMethodName, parameterTypes);
-            final JavaNakedObjectActionPeer action = new JavaNakedObjectActionPeer(identifier, actionParams);
-
-            // process facets on the action & parameters
-            getFacetProcessor()
-                    .process(type, actionMethod, new JavaIntrospectorMethodRemover(), action, NakedObjectFeatureType.ACTION);
-            for (int j = 0; j < actionParams.length; j++) {
-                getFacetProcessor().processParams(actionMethod, j, actionParams[j]);
-            }
-
-            actionPeers.add(action);
+            NakedObjectActionPeer actionPeer = findActionMethodPeer(methodScope, skipRecognisedHelperMethod, methods[i]);
+            if (actionPeer != null) {
+                methods[i] = null;
+                actionPeers.add(actionPeer);
+            }
         }
 
@@ -498 +440 @@
     }
 
+    private NakedObjectActionPeer findActionMethodPeer(final MethodScope methodScope, boolean skipRecognisedHelperMethod, final Method actionMethod) {
+
+        if (!representsAction(methodScope, skipRecognisedHelperMethod, actionMethod)) {
+                return null;
+        }
+
+        // build action
+        return createAction(actionMethod);
+    }
+
+        private NakedObjectActionPeer createAction(final Method actionMethod) {
+                final Class<?>[] parameterTypes = getParameterTypesFor(actionMethod);
+        final int numParameters = parameterTypes.length;
+        
+        final JavaNakedObjectActionParamPeer[] actionParams = new JavaNakedObjectActionParamPeer[numParameters];
+        for (int j = 0; j < numParameters; j++) {
+            NakedObjectSpecification paramSpec = getSpecificationLoader().loadSpecification(parameterTypes[j]);
+            if (paramSpec == null) {
+                return null;
+            }
+            actionParams[j] = new JavaNakedObjectActionParamPeer(paramSpec);
+        }
+
+        
+        final String fullMethodName = actionMethod.getName();
+        final Identifier identifier = Identifier.actionIdentifier(className, fullMethodName, parameterTypes);
+        final JavaNakedObjectActionPeer action = new JavaNakedObjectActionPeer(identifier, actionParams);
+
+        // process facets on the action & parameters
+        getFacetProcessor()
+                .process(type, actionMethod, new JavaIntrospectorMethodRemover(), action, NakedObjectFeatureType.ACTION);
+        for (int j = 0; j < actionParams.length; j++) {
+            getFacetProcessor().processParams(actionMethod, j, actionParams[j]);
+        }
+        
+        return action;
+        }
+
+    private boolean representsAction(final MethodScope methodScope, boolean skipRecognisedHelperMethod, final Method actionMethod) {
+
+        if (!MethodFinderUtils.inScope(methodScope, actionMethod)) {
+            return false;
+        }
+
+        List<Class<?>> typesToLoad = new ArrayList<Class<?>>();
+        getSpecificationTraverser().traverseTypes(actionMethod, typesToLoad);
+
+        boolean anyLoadedAsNull = reflector.loadSpecifications(typesToLoad);
+        if (anyLoadedAsNull) {
+                return false;
+        }
+
+        if (!loadParamSpecs(actionMethod)) {
+                return false;
+        }
+
+        if (getFacetProcessor().recognizes(actionMethod)) {
+            if (actionMethod.getName().startsWith("set")) {
+                return false;
+            }
+            if (skipRecognisedHelperMethod) {
+                LOG.info("  skipping possible helper method " + actionMethod);
+                return false;
+            }
+        }
+
+        if (LOG.isDebugEnabled()) {
+                LOG.debug("  identified action " + actionMethod);
+        }
+        
+        return true;
+    }
+
+        private boolean loadParamSpecs(final Method actionMethod) {
+                final Class<?>[] parameterTypes = getParameterTypesFor(actionMethod);
+        return loadParamSpecs(parameterTypes);
+        }
+
+        private Class<?>[] getParameterTypesFor(final Method actionMethod) {
+                
+                // build/validate action parameters
+        // as for return type, if the reflector's class strategy says to skip any of the 
+        // action's parameter types, then just ignore this action altogether.
+        final Class<?>[] parameterTypes = actionMethod.getParameterTypes();
+        
+        
+        // previously we wrapped primitives.  However, this prevents the lookup of
+        // actions during remote authorization calls (using Identifier class).
+        // ... should we remove ... ?
+        // final Class<?>[] parameterClasses = WrapperUtils.wrapAsNecessary(parameterTypes);
+                return parameterTypes;
+        }
+
+        private boolean loadParamSpecs(final Class<?>[] parameterTypes) {
+        final int numParameters = parameterTypes.length;
+        for (int j = 0; j < numParameters; j++) {
+            NakedObjectSpecification paramSpec = getSpecificationLoader().loadSpecification(parameterTypes[j]);
+            if (paramSpec == null) {
+                return false;
+            }
+        }
+                return true;
+        }
+    
         private NakedObjectActionPeer[] convertToArray(final List<NakedObjectActionPeer> actions) {
         return (NakedObjectActionPeer[]) actions.toArray(new NakedObjectActionPeer[] {});
@@ -706 +752 @@
     }
 
+
     
     // ////////////////////////////////////////////////////////////////////////////

framework/trunk/core/runtime/src/main/java/org/nakedobjects/runtime/system/installers/JavaReflectorInstaller.java

@@ -3 +3 @@
 import java.util.Collections;
 import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Set;
 
@@ -16 +17 @@
 import org.nakedobjects.metamodel.specloader.ReflectorConstants;
 import org.nakedobjects.metamodel.specloader.classsubstitutor.ClassSubstitutor;
+import org.nakedobjects.metamodel.specloader.classsubstitutor.ClassSubstitutorComposite;
 import org.nakedobjects.metamodel.specloader.collectiontyperegistry.CollectionTypeRegistry;
 import org.nakedobjects.metamodel.specloader.collectiontyperegistry.CollectionTypeRegistryDefault;
@@ -25 +27 @@
 import org.nakedobjects.runtime.installers.InstallerLookupAware;
 
+import com.google.common.collect.Lists;
+
 
 public class JavaReflectorInstaller extends InstallerAbstract implements NakedObjectReflectorInstaller, InstallerLookupAware {
@@ -79 +83 @@
      * <p>
      * By default, looks up implementation from provided {@link NakedObjectConfiguration} using
-     * {@link ReflectorConstants#CLASS_SUBSTITUTOR_CLASS_NAME}. If not specified, then defaults to
+     * {@link ReflectorConstants#CLASS_SUBSTITUTOR_CLASS_NAME_LIST}. If not specified, then defaults to
      * {@value ReflectorConstants#CLASS_SUBSTITUTOR_CLASS_NAME_DEFAULT}.
+     * 
+     * <p>
+     * 
      */
     protected ClassSubstitutor createClassSubstitutor(NakedObjectConfiguration configuration) {
-        final String configuredClassName = configuration.getString(ReflectorConstants.CLASS_SUBSTITUTOR_CLASS_NAME,
-                ReflectorConstants.CLASS_SUBSTITUTOR_CLASS_NAME_DEFAULT);
-        return InstanceFactory.createInstance(configuredClassName, ClassSubstitutor.class);
+        final String[] configuredClassNames = configuration
+                .getList(ReflectorConstants.CLASS_SUBSTITUTOR_CLASS_NAME_LIST);
+        if(configuredClassNames == null || configuredClassNames.length == 0) {
+                        return InstanceFactory.createInstance(ReflectorConstants.CLASS_SUBSTITUTOR_CLASS_NAME_DEFAULT, ClassSubstitutor.class);
+        }
+        List<ClassSubstitutor> substitutors = Lists.newArrayList();
+        for (String className : configuredClassNames) {
+                ClassSubstitutor substitutor = InstanceFactory.createInstance(className, ClassSubstitutor.class);
+                        substitutors.add(substitutor);
+                }
+        return substitutors.size() == 1? substitutors.get(0): new ClassSubstitutorComposite(substitutors);
     }
 

framework/trunk/pom.xml

@@ -106 +106 @@
     <profiles>
             <profile>
-                <id>skin</id>
+                <id>site</id>
             <modules>
                <module>site-skin</module>
+               <module>site-resources</module>
                 </modules>
             </profile>