You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@struts.apache.org by lu...@apache.org on 2015/06/17 23:09:47 UTC
[47/57] [partial] struts git commit: Merges xwork packages into struts
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorListHolder.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorListHolder.java b/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorListHolder.java
new file mode 100644
index 0000000..4323116
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorListHolder.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.entities;
+
+import java.util.List;
+
+/**
+ * InterceptorListHolder
+ *
+ * @author Jason Carreira
+ * Created Jun 1, 2003 1:02:48 AM
+ */
+public interface InterceptorListHolder {
+
+ InterceptorListHolder addInterceptor(InterceptorMapping interceptor);
+
+ InterceptorListHolder addInterceptors(List<InterceptorMapping> interceptors);
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorLocator.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorLocator.java b/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorLocator.java
new file mode 100644
index 0000000..aa74960
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorLocator.java
@@ -0,0 +1,14 @@
+package com.opensymphony.xwork2.config.entities;
+
+/**
+ * Defines an object that can be used to retrieve interceptor configuration
+ */
+public interface InterceptorLocator {
+
+ /**
+ * Gets an interceptor configuration object.
+ * @param name The interceptor or interceptor stack name
+ * @return Either an {@link InterceptorConfig} or {@link InterceptorStackConfig} object
+ */
+ Object getInterceptorConfig(String name);
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorMapping.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorMapping.java b/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorMapping.java
new file mode 100644
index 0000000..846575e
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorMapping.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.entities;
+
+import com.opensymphony.xwork2.interceptor.Interceptor;
+
+import java.io.Serializable;
+
+/**
+ * <code>InterceptorMapping</code>
+ *
+ * @author <a href="mailto:hermanns@aixcept.de">Rainer Hermanns</a>
+ * @version $Id$
+ */
+public class InterceptorMapping implements Serializable {
+
+ private String name;
+ private Interceptor interceptor;
+
+ public InterceptorMapping(String name, Interceptor interceptor) {
+ this.name = name;
+ this.interceptor = interceptor;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public Interceptor getInterceptor() {
+ return interceptor;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ final InterceptorMapping that = (InterceptorMapping) o;
+
+ if (name != null ? !name.equals(that.name) : that.name != null) return false;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result;
+ result = (name != null ? name.hashCode() : 0);
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "InterceptorMapping: [" + name + "] => [" + interceptor.getClass().getName() + ']';
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorStackConfig.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorStackConfig.java b/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorStackConfig.java
new file mode 100644
index 0000000..b9e2f78
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/InterceptorStackConfig.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.entities;
+
+import com.opensymphony.xwork2.util.location.Located;
+import com.opensymphony.xwork2.util.location.Location;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+
+/**
+ * Configuration for InterceptorStack.
+ * <p/>
+ * In the xml configuration file this is defined as the <code>interceptor-stack</code> tag.
+ *
+ * @author Mike
+ * @author Rainer Hermanns
+ */
+public class InterceptorStackConfig extends Located implements Serializable {
+
+ private static final long serialVersionUID = 2897260918170270343L;
+
+ /**
+ * A list of InterceptorMapping object
+ */
+ protected List<InterceptorMapping> interceptors;
+ protected String name;
+
+ /**
+ * Creates an InterceptorStackConfig object.
+ */
+ protected InterceptorStackConfig() {
+ this.interceptors = new ArrayList<InterceptorMapping>();
+ }
+
+ /**
+ * Creates an InterceptorStackConfig object with a particular <code>name</code>.
+ *
+ * @param name
+ */
+ protected InterceptorStackConfig(InterceptorStackConfig orig) {
+ this.name = orig.name;
+ this.interceptors = new ArrayList<>(orig.interceptors);
+ this.location = orig.location;
+ }
+
+
+ /**
+ * Returns a <code>Collection</code> of InterceptorMapping objects.
+ *
+ * @return
+ */
+ public Collection<InterceptorMapping> getInterceptors() {
+ return interceptors;
+ }
+
+ /**
+ * Get the name of this interceptor stack configuration.
+ *
+ * @return String
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * An InterceptorStackConfig object is equals with <code>o</code> only if
+ * <ul>
+ * <li>o is an InterceptorStackConfig object</li>
+ * <li>both names are equals</li>
+ * <li>all of their <code>InterceptorMapping</code>s are equals</li>
+ * </ul>
+ */
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+
+ if (!(o instanceof InterceptorStackConfig)) {
+ return false;
+ }
+
+ final InterceptorStackConfig interceptorStackConfig = (InterceptorStackConfig) o;
+
+ if ((interceptors != null) ? (!interceptors.equals(interceptorStackConfig.interceptors)) : (interceptorStackConfig.interceptors != null)) {
+ return false;
+ }
+
+ if ((name != null) ? (!name.equals(interceptorStackConfig.name)) : (interceptorStackConfig.name != null)) {
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Generate hashcode based on <code>InterceptorStackConfig</code>'s name and its
+ * <code>InterceptorMapping</code>s.
+ */
+ @Override
+ public int hashCode() {
+ int result;
+ result = ((name != null) ? name.hashCode() : 0);
+ result = (29 * result) + ((interceptors != null) ? interceptors.hashCode() : 0);
+
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "InterceptorStackConfig: [" + name + "] contains " + interceptors;
+ }
+
+ /**
+ * The builder for this object. An instance of this object is the only way to construct a new instance. The
+ * purpose is to enforce the immutability of the object. The methods are structured in a way to support chaining.
+ * After setting any values you need, call the {@link #build()} method to create the object.
+ */
+ public static class Builder implements InterceptorListHolder {
+ protected InterceptorStackConfig target;
+
+ public Builder(String name) {
+ target = new InterceptorStackConfig();
+ target.name = name;
+ }
+
+ public Builder name(String name) {
+ target.name = name;
+ return this;
+ }
+
+ /**
+ * Add an <code>InterceptorMapping</code> object.
+ */
+ public Builder addInterceptor(InterceptorMapping interceptor) {
+ target.interceptors.add(interceptor);
+ return this;
+ }
+
+ /**
+ * Add a List of <code>InterceptorMapping</code> objects.
+ */
+ public Builder addInterceptors(List<InterceptorMapping> interceptors) {
+ target.interceptors.addAll(interceptors);
+ return this;
+ }
+
+ public Builder location(Location loc) {
+ target.location = loc;
+ return this;
+ }
+
+ public InterceptorStackConfig build() {
+ embalmTarget();
+ InterceptorStackConfig result = target;
+ target = new InterceptorStackConfig(target);
+ return result;
+ }
+
+ protected void embalmTarget() {
+ target.interceptors = Collections.unmodifiableList(target.interceptors);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/PackageConfig.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/PackageConfig.java b/core/src/main/java/com/opensymphony/xwork2/config/entities/PackageConfig.java
new file mode 100644
index 0000000..d4a3c5c
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/PackageConfig.java
@@ -0,0 +1,615 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.entities;
+
+import com.opensymphony.xwork2.util.location.Located;
+import com.opensymphony.xwork2.util.location.Location;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.Serializable;
+import java.util.*;
+
+
+/**
+ * Configuration for Package.
+ * <p/>
+ * In the xml configuration file this is defined as the <code>package</code> tag.
+ *
+ * @author Rainer Hermanns
+ * @version $Revision$
+ */
+public class PackageConfig extends Located implements Comparable, Serializable, InterceptorLocator {
+
+ private static final Logger LOG = LogManager.getLogger(PackageConfig.class);
+
+ protected Map<String, ActionConfig> actionConfigs;
+ protected Map<String, ResultConfig> globalResultConfigs;
+ protected Map<String, Object> interceptorConfigs;
+ protected Map<String, ResultTypeConfig> resultTypeConfigs;
+ protected List<ExceptionMappingConfig> globalExceptionMappingConfigs;
+ protected List<PackageConfig> parents;
+ protected String defaultInterceptorRef;
+ protected String defaultActionRef;
+ protected String defaultResultType;
+ protected String defaultClassRef;
+ protected String name;
+ protected String namespace = "";
+ protected boolean isAbstract = false;
+ protected boolean needsRefresh;
+
+ protected PackageConfig(String name) {
+ this.name = name;
+ actionConfigs = new LinkedHashMap<>();
+ globalResultConfigs = new LinkedHashMap<>();
+ interceptorConfigs = new LinkedHashMap<>();
+ resultTypeConfigs = new LinkedHashMap<>();
+ globalExceptionMappingConfigs = new ArrayList<>();
+ parents = new ArrayList<>();
+ }
+
+ protected PackageConfig(PackageConfig orig) {
+ this.defaultInterceptorRef = orig.defaultInterceptorRef;
+ this.defaultActionRef = orig.defaultActionRef;
+ this.defaultResultType = orig.defaultResultType;
+ this.defaultClassRef = orig.defaultClassRef;
+ this.name = orig.name;
+ this.namespace = orig.namespace;
+ this.isAbstract = orig.isAbstract;
+ this.needsRefresh = orig.needsRefresh;
+ this.actionConfigs = new LinkedHashMap<>(orig.actionConfigs);
+ this.globalResultConfigs = new LinkedHashMap<>(orig.globalResultConfigs);
+ this.interceptorConfigs = new LinkedHashMap<>(orig.interceptorConfigs);
+ this.resultTypeConfigs = new LinkedHashMap<>(orig.resultTypeConfigs);
+ this.globalExceptionMappingConfigs = new ArrayList<>(orig.globalExceptionMappingConfigs);
+ this.parents = new ArrayList<>(orig.parents);
+ this.location = orig.location;
+ }
+
+ public boolean isAbstract() {
+ return isAbstract;
+ }
+
+ public Map<String, ActionConfig> getActionConfigs() {
+ return actionConfigs;
+ }
+
+ /**
+ * returns the Map of all the ActionConfigs available in the current package.
+ * ActionConfigs defined in ancestor packages will be included in this Map.
+ *
+ * @return a Map of ActionConfig Objects with the action name as the key
+ * @see ActionConfig
+ */
+ public Map<String, ActionConfig> getAllActionConfigs() {
+ Map<String, ActionConfig> retMap = new LinkedHashMap<>();
+
+ if (!parents.isEmpty()) {
+ for (PackageConfig parent : parents) {
+ retMap.putAll(parent.getAllActionConfigs());
+ }
+ }
+
+ retMap.putAll(getActionConfigs());
+
+ return retMap;
+ }
+
+ /**
+ * returns the Map of all the global ResultConfigs available in the current package.
+ * Global ResultConfigs defined in ancestor packages will be included in this Map.
+ *
+ * @return a Map of Result Objects with the result name as the key
+ * @see ResultConfig
+ */
+ public Map<String, ResultConfig> getAllGlobalResults() {
+ Map<String, ResultConfig> retMap = new LinkedHashMap<>();
+
+ if (!parents.isEmpty()) {
+ for (PackageConfig parentConfig : parents) {
+ retMap.putAll(parentConfig.getAllGlobalResults());
+ }
+ }
+
+ retMap.putAll(getGlobalResultConfigs());
+
+ return retMap;
+ }
+
+ /**
+ * returns the Map of all InterceptorConfigs and InterceptorStackConfigs available in the current package.
+ * InterceptorConfigs defined in ancestor packages will be included in this Map.
+ *
+ * @return a Map of InterceptorConfig and InterceptorStackConfig Objects with the ref-name as the key
+ * @see InterceptorConfig
+ * @see InterceptorStackConfig
+ */
+ public Map<String, Object> getAllInterceptorConfigs() {
+ Map<String, Object> retMap = new LinkedHashMap<>();
+
+ if (!parents.isEmpty()) {
+ for (PackageConfig parentContext : parents) {
+ retMap.putAll(parentContext.getAllInterceptorConfigs());
+ }
+ }
+
+ retMap.putAll(getInterceptorConfigs());
+
+ return retMap;
+ }
+
+ /**
+ * returns the Map of all the ResultTypeConfigs available in the current package.
+ * ResultTypeConfigs defined in ancestor packages will be included in this Map.
+ *
+ * @return a Map of ResultTypeConfig Objects with the result type name as the key
+ * @see ResultTypeConfig
+ */
+ public Map<String, ResultTypeConfig> getAllResultTypeConfigs() {
+ Map<String, ResultTypeConfig> retMap = new LinkedHashMap<>();
+
+ if (!parents.isEmpty()) {
+ for (PackageConfig parentContext : parents) {
+ retMap.putAll(parentContext.getAllResultTypeConfigs());
+ }
+ }
+
+ retMap.putAll(getResultTypeConfigs());
+
+ return retMap;
+ }
+
+ /**
+ * returns the List of all the ExceptionMappingConfigs available in the current package.
+ * ExceptionMappingConfigs defined in ancestor packages will be included in this list.
+ *
+ * @return a List of ExceptionMappingConfigs Objects with the result type name as the key
+ * @see ExceptionMappingConfig
+ */
+ public List<ExceptionMappingConfig> getAllExceptionMappingConfigs() {
+ List<ExceptionMappingConfig> allExceptionMappings = new ArrayList<>();
+
+ if (!parents.isEmpty()) {
+ for (PackageConfig parentContext : parents) {
+ allExceptionMappings.addAll(parentContext.getAllExceptionMappingConfigs());
+ }
+ }
+
+ allExceptionMappings.addAll(getGlobalExceptionMappingConfigs());
+
+ return allExceptionMappings;
+ }
+
+
+ public String getDefaultInterceptorRef() {
+ return defaultInterceptorRef;
+ }
+
+ public String getDefaultActionRef() {
+ return defaultActionRef;
+ }
+
+ public String getDefaultClassRef() {
+ if ((defaultClassRef == null) && !parents.isEmpty()) {
+ for (PackageConfig parent : parents) {
+ String parentDefault = parent.getDefaultClassRef();
+ if (parentDefault != null) {
+ return parentDefault;
+ }
+ }
+ }
+ return defaultClassRef;
+ }
+
+ /**
+ * Returns the default result type for this package.
+ */
+ public String getDefaultResultType() {
+ return defaultResultType;
+ }
+
+ /**
+ * gets the default interceptor-ref name. If this is not set on this PackageConfig, it searches the parent
+ * PackageConfigs in order until it finds one.
+ */
+ public String getFullDefaultInterceptorRef() {
+ if ((defaultInterceptorRef == null) && !parents.isEmpty()) {
+ for (PackageConfig parent : parents) {
+ String parentDefault = parent.getFullDefaultInterceptorRef();
+
+ if (parentDefault != null) {
+ return parentDefault;
+ }
+ }
+ }
+
+ return defaultInterceptorRef;
+ }
+
+ /**
+ * gets the default action-ref name. If this is not set on this PackageConfig, it searches the parent
+ * PackageConfigs in order until it finds one.
+ */
+ public String getFullDefaultActionRef() {
+ if ((defaultActionRef == null) && !parents.isEmpty()) {
+ for (PackageConfig parent : parents) {
+ String parentDefault = parent.getFullDefaultActionRef();
+
+ if (parentDefault != null) {
+ return parentDefault;
+ }
+ }
+ }
+ return defaultActionRef;
+ }
+
+ /**
+ * Returns the default result type for this package.
+ * <p/>
+ * If there is no default result type, but this package has parents - we will try to
+ * look up the default result type of a parent.
+ */
+ public String getFullDefaultResultType() {
+ if ((defaultResultType == null) && !parents.isEmpty()) {
+ for (PackageConfig parent : parents) {
+ String parentDefault = parent.getFullDefaultResultType();
+
+ if (parentDefault != null) {
+ return parentDefault;
+ }
+ }
+ }
+
+ return defaultResultType;
+ }
+
+ /**
+ * gets the global ResultConfigs local to this package
+ *
+ * @return a Map of ResultConfig objects keyed by result name
+ * @see ResultConfig
+ */
+ public Map<String, ResultConfig> getGlobalResultConfigs() {
+ return globalResultConfigs;
+ }
+
+ /**
+ * gets the InterceptorConfigs and InterceptorStackConfigs local to this package
+ *
+ * @return a Map of InterceptorConfig and InterceptorStackConfig objects keyed by ref-name
+ * @see InterceptorConfig
+ * @see InterceptorStackConfig
+ */
+ public Map<String, Object> getInterceptorConfigs() {
+ return interceptorConfigs;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public String getNamespace() {
+ return namespace;
+ }
+
+ public List<PackageConfig> getParents() {
+ return new ArrayList<>(parents);
+ }
+
+ /**
+ * gets the ResultTypeConfigs local to this package
+ *
+ * @return a Map of ResultTypeConfig objects keyed by result name
+ * @see ResultTypeConfig
+ */
+ public Map<String, ResultTypeConfig> getResultTypeConfigs() {
+ return resultTypeConfigs;
+ }
+
+
+ public boolean isNeedsRefresh() {
+ return needsRefresh;
+ }
+
+ /**
+ * gets the ExceptionMappingConfigs local to this package
+ *
+ * @return a Map of ExceptionMappingConfig objects keyed by result name
+ * @see ExceptionMappingConfig
+ */
+ public List<ExceptionMappingConfig> getGlobalExceptionMappingConfigs() {
+ return globalExceptionMappingConfigs;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+
+ if (!(o instanceof PackageConfig)) {
+ return false;
+ }
+
+ final PackageConfig packageConfig = (PackageConfig) o;
+
+ if (isAbstract != packageConfig.isAbstract) {
+ return false;
+ }
+
+ if ((actionConfigs != null) ? (!actionConfigs.equals(packageConfig.actionConfigs)) : (packageConfig.actionConfigs != null)) {
+ return false;
+ }
+
+ if ((defaultResultType != null) ? (!defaultResultType.equals(packageConfig.defaultResultType)) : (packageConfig.defaultResultType != null)) {
+ return false;
+ }
+
+ if ((defaultClassRef != null) ? (!defaultClassRef.equals(packageConfig.defaultClassRef)) : (packageConfig.defaultClassRef != null)) {
+ return false;
+ }
+
+ if ((globalResultConfigs != null) ? (!globalResultConfigs.equals(packageConfig.globalResultConfigs)) : (packageConfig.globalResultConfigs != null)) {
+ return false;
+ }
+
+ if ((interceptorConfigs != null) ? (!interceptorConfigs.equals(packageConfig.interceptorConfigs)) : (packageConfig.interceptorConfigs != null)) {
+ return false;
+ }
+
+ if ((name != null) ? (!name.equals(packageConfig.name)) : (packageConfig.name != null)) {
+ return false;
+ }
+
+ if ((namespace != null) ? (!namespace.equals(packageConfig.namespace)) : (packageConfig.namespace != null)) {
+ return false;
+ }
+
+ if ((parents != null) ? (!parents.equals(packageConfig.parents)) : (packageConfig.parents != null)) {
+ return false;
+ }
+
+ if ((resultTypeConfigs != null) ? (!resultTypeConfigs.equals(packageConfig.resultTypeConfigs)) : (packageConfig.resultTypeConfigs != null)) {
+ return false;
+ }
+
+ if ((globalExceptionMappingConfigs != null) ? (!globalExceptionMappingConfigs.equals(packageConfig.globalExceptionMappingConfigs)) : (packageConfig.globalExceptionMappingConfigs != null)) {
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result;
+ result = ((name != null) ? name.hashCode() : 0);
+ result = (29 * result) + ((parents != null) ? parents.hashCode() : 0);
+ result = (29 * result) + ((actionConfigs != null) ? actionConfigs.hashCode() : 0);
+ result = (29 * result) + ((globalResultConfigs != null) ? globalResultConfigs.hashCode() : 0);
+ result = (29 * result) + ((interceptorConfigs != null) ? interceptorConfigs.hashCode() : 0);
+ result = (29 * result) + ((resultTypeConfigs != null) ? resultTypeConfigs.hashCode() : 0);
+ result = (29 * result) + ((globalExceptionMappingConfigs != null) ? globalExceptionMappingConfigs.hashCode() : 0);
+ result = (29 * result) + ((defaultResultType != null) ? defaultResultType.hashCode() : 0);
+ result = (29 * result) + ((defaultClassRef != null) ? defaultClassRef.hashCode() : 0);
+ result = (29 * result) + ((namespace != null) ? namespace.hashCode() : 0);
+ result = (29 * result) + (isAbstract ? 1 : 0);
+
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "PackageConfig: [" + name + "] for namespace [" + namespace + "] with parents [" + parents + "]";
+ }
+
+ public int compareTo(Object o) {
+ PackageConfig other = (PackageConfig) o;
+ String full = namespace + "!" + name;
+ String otherFull = other.namespace + "!" + other.name;
+
+ // note, this isn't perfect (could come from different parents), but it is "good enough"
+ return full.compareTo(otherFull);
+ }
+
+ public Object getInterceptorConfig(String name) {
+ return getAllInterceptorConfigs().get(name);
+ }
+
+ /**
+ * The builder for this object. An instance of this object is the only way to construct a new instance. The
+ * purpose is to enforce the immutability of the object. The methods are structured in a way to support chaining.
+ * After setting any values you need, call the {@link #build()} method to create the object.
+ */
+ public static class Builder implements InterceptorLocator {
+
+ protected PackageConfig target;
+ private boolean strictDMI;
+
+ public Builder(String name) {
+ target = new PackageConfig(name);
+ }
+
+ public Builder(PackageConfig config) {
+ target = new PackageConfig(config);
+ }
+
+ public Builder name(String name) {
+ target.name = name;
+ return this;
+ }
+
+ public Builder isAbstract(boolean isAbstract) {
+ target.isAbstract = isAbstract;
+ return this;
+ }
+
+ public Builder defaultInterceptorRef(String name) {
+ target.defaultInterceptorRef = name;
+ return this;
+ }
+
+ public Builder defaultActionRef(String name) {
+ target.defaultActionRef = name;
+ return this;
+ }
+
+ public Builder defaultClassRef(String defaultClassRef) {
+ target.defaultClassRef = defaultClassRef;
+ return this;
+ }
+
+ /**
+ * sets the default Result type for this package
+ *
+ * @param defaultResultType
+ */
+ public Builder defaultResultType(String defaultResultType) {
+ target.defaultResultType = defaultResultType;
+ return this;
+ }
+
+ public Builder namespace(String namespace) {
+ if (namespace == null) {
+ target.namespace = "";
+ } else {
+ target.namespace = namespace;
+ }
+ return this;
+ }
+
+ public Builder needsRefresh(boolean needsRefresh) {
+ target.needsRefresh = needsRefresh;
+ return this;
+ }
+
+ public Builder addActionConfig(String name, ActionConfig action) {
+ target.actionConfigs.put(name, action);
+ return this;
+ }
+
+ public Builder addParents(List<PackageConfig> parents) {
+ for (PackageConfig config : parents) {
+ addParent(config);
+ }
+ return this;
+ }
+
+ public Builder addGlobalResultConfig(ResultConfig resultConfig) {
+ target.globalResultConfigs.put(resultConfig.getName(), resultConfig);
+ return this;
+ }
+
+ public Builder addGlobalResultConfigs(Map<String, ResultConfig> resultConfigs) {
+ target.globalResultConfigs.putAll(resultConfigs);
+ return this;
+ }
+
+ public Builder addExceptionMappingConfig(ExceptionMappingConfig exceptionMappingConfig) {
+ target.globalExceptionMappingConfigs.add(exceptionMappingConfig);
+ return this;
+ }
+
+ public Builder addGlobalExceptionMappingConfigs(List<ExceptionMappingConfig> exceptionMappingConfigs) {
+ target.globalExceptionMappingConfigs.addAll(exceptionMappingConfigs);
+ return this;
+ }
+
+ public Builder addInterceptorConfig(InterceptorConfig config) {
+ target.interceptorConfigs.put(config.getName(), config);
+ return this;
+ }
+
+ public Builder addInterceptorStackConfig(InterceptorStackConfig config) {
+ target.interceptorConfigs.put(config.getName(), config);
+ return this;
+ }
+
+ public Builder addParent(PackageConfig parent) {
+ target.parents.add(0, parent);
+ return this;
+ }
+
+ public Builder addResultTypeConfig(ResultTypeConfig config) {
+ target.resultTypeConfigs.put(config.getName(), config);
+ return this;
+ }
+
+ public Builder location(Location loc) {
+ target.location = loc;
+ return this;
+ }
+
+ public boolean isNeedsRefresh() {
+ return target.needsRefresh;
+ }
+
+ public String getDefaultClassRef() {
+ return target.defaultClassRef;
+ }
+
+ public String getName() {
+ return target.name;
+ }
+
+ public String getNamespace() {
+ return target.namespace;
+ }
+
+ public String getFullDefaultResultType() {
+ return target.getFullDefaultResultType();
+ }
+
+ public ResultTypeConfig getResultType(String type) {
+ return target.getAllResultTypeConfigs().get(type);
+ }
+
+ public Object getInterceptorConfig(String name) {
+ return target.getAllInterceptorConfigs().get(name);
+ }
+
+ public Builder strictMethodInvocation(boolean strict) {
+ strictDMI = strict;
+ return this;
+ }
+
+ public boolean isStrictMethodInvocation() {
+ return strictDMI;
+ }
+
+ public PackageConfig build() {
+ embalmTarget();
+ PackageConfig result = target;
+ target = new PackageConfig(result);
+ return result;
+ }
+
+ protected void embalmTarget() {
+ target.actionConfigs = Collections.unmodifiableMap(target.actionConfigs);
+ target.globalResultConfigs = Collections.unmodifiableMap(target.globalResultConfigs);
+ target.interceptorConfigs = Collections.unmodifiableMap(target.interceptorConfigs);
+ target.resultTypeConfigs = Collections.unmodifiableMap(target.resultTypeConfigs);
+ target.globalExceptionMappingConfigs = Collections.unmodifiableList(target.globalExceptionMappingConfigs);
+ target.parents = Collections.unmodifiableList(target.parents);
+ }
+
+ @Override
+ public String toString() {
+ return "[BUILDER] " + target.toString();
+ }
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/Parameterizable.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/Parameterizable.java b/core/src/main/java/com/opensymphony/xwork2/config/entities/Parameterizable.java
new file mode 100644
index 0000000..42b6cb3
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/Parameterizable.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.entities;
+
+import java.util.Map;
+
+/**
+ * <!-- START SNIPPET: javadoc -->
+ * <p/>
+ * Actions implementing Parameterizable will receive a map of the static parameters defined in the action
+ * configuration.
+ * <p/>
+ * <p/> The {@link com.opensymphony.xwork2.interceptor.StaticParametersInterceptor} must be in the action's interceptor
+ * queue for this to work.
+ * <p/>
+ * <!-- END SNIPPET: javadoc -->
+ *
+ * @author Jason Carreira
+ */
+public interface Parameterizable {
+
+ public void addParam(String name, String value);
+
+ void setParams(Map<String, String> params);
+
+ Map<String, String> getParams();
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/ResultConfig.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/ResultConfig.java b/core/src/main/java/com/opensymphony/xwork2/config/entities/ResultConfig.java
new file mode 100644
index 0000000..b9ed588
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/ResultConfig.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.entities;
+
+import com.opensymphony.xwork2.util.location.Located;
+import com.opensymphony.xwork2.util.location.Location;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+
+/**
+ * Configuration for Result.
+ * <p/>
+ * In the xml configuration file this is defined as the <code>result</code> tag.
+ *
+ * @author Mike
+ */
+public class ResultConfig extends Located implements Serializable {
+
+ protected Map<String,String> params;
+ protected String className;
+ protected String name;
+
+ protected ResultConfig(String name, String className) {
+ this.name = name;
+ this.className = className;
+ params = new LinkedHashMap<>();
+ }
+
+ protected ResultConfig(ResultConfig orig) {
+ this.params = orig.params;
+ this.name = orig.name;
+ this.className = orig.className;
+ this.location = orig.location;
+ }
+
+ public String getClassName() {
+ return className;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public Map<String,String> getParams() {
+ return params;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+
+ if (!(o instanceof ResultConfig)) {
+ return false;
+ }
+
+ final ResultConfig resultConfig = (ResultConfig) o;
+
+ if ((className != null) ? (!className.equals(resultConfig.className)) : (resultConfig.className != null)) {
+ return false;
+ }
+
+ if ((name != null) ? (!name.equals(resultConfig.name)) : (resultConfig.name != null)) {
+ return false;
+ }
+
+ if ((params != null) ? (!params.equals(resultConfig.params)) : (resultConfig.params != null)) {
+ return false;
+ }
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result;
+ result = ((name != null) ? name.hashCode() : 0);
+ result = (29 * result) + ((className != null) ? className.hashCode() : 0);
+ result = (29 * result) + ((params != null) ? params.hashCode() : 0);
+
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "ResultConfig: [" + name + "] => [" + className + "] with params " + params;
+ }
+
+ /**
+ * The builder for this object. An instance of this object is the only way to construct a new instance. The
+ * purpose is to enforce the immutability of the object. The methods are structured in a way to support chaining.
+ * After setting any values you need, call the {@link #build()} method to create the object.
+ */
+ public static final class Builder {
+ protected ResultConfig target;
+
+ public Builder(String name, String className) {
+ target = new ResultConfig(name, className);
+ }
+
+ public Builder(ResultConfig orig) {
+ target = new ResultConfig(orig);
+ }
+
+ public Builder name(String name) {
+ target.name = name;
+ return this;
+ }
+
+ public Builder className(String name) {
+ target.className = name;
+ return this;
+ }
+
+ public Builder addParam(String name, String value) {
+ target.params.put(name, value);
+ return this;
+ }
+
+ public Builder addParams(Map<String,String> params) {
+ target.params.putAll(params);
+ return this;
+ }
+
+ public Builder location(Location loc) {
+ target.location = loc;
+ return this;
+ }
+
+ public ResultConfig build() {
+ embalmTarget();
+ ResultConfig result = target;
+ target = new ResultConfig(target);
+ return result;
+ }
+
+ protected void embalmTarget() {
+ target.params = Collections.unmodifiableMap(target.params);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/ResultTypeConfig.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/ResultTypeConfig.java b/core/src/main/java/com/opensymphony/xwork2/config/entities/ResultTypeConfig.java
new file mode 100644
index 0000000..96ff4ff
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/ResultTypeConfig.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.entities;
+
+import com.opensymphony.xwork2.util.location.Located;
+import com.opensymphony.xwork2.util.location.Location;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+
+/**
+ * Configuration class for result types.
+ * <p/>
+ * In the xml configuration file this is defined as the <code>result-type</code> tag.
+ *
+ * @author Mike
+ * @author Rainer Hermanns
+ * @author Neo
+ */
+public class ResultTypeConfig extends Located implements Serializable {
+
+ protected String className;
+ protected String name;
+ protected String defaultResultParam;
+ protected Map<String,String> params;
+
+ protected ResultTypeConfig(String name, String className) {
+ this.name = name;
+ this.className = className;
+ params = new LinkedHashMap<>();
+ }
+
+ protected ResultTypeConfig(ResultTypeConfig orig) {
+ this.name = orig.name;
+ this.className = orig.className;
+ this.defaultResultParam = orig.defaultResultParam;
+ this.params = orig.params;
+ this.location = orig.location;
+ }
+
+ public void setDefaultResultParam(String defaultResultParam) {
+ this.defaultResultParam = defaultResultParam;
+ }
+
+ public String getDefaultResultParam() {
+ return this.defaultResultParam;
+ }
+
+ /**
+ * @deprecated Since 2.1, use {@link #getClassName()} instead
+ */
+ @Deprecated public String getClazz() {
+ return className;
+ }
+
+ public String getClassName() {
+ return className;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public Map<String,String> getParams() {
+ return this.params;
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (o == null || getClass() != o.getClass()) return false;
+
+ final ResultTypeConfig that = (ResultTypeConfig) o;
+
+ if (className != null ? !className.equals(that.className) : that.className != null) return false;
+ if (name != null ? !name.equals(that.name) : that.name != null) return false;
+ if (params != null ? !params.equals(that.params) : that.params != null) return false;
+
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int result;
+ result = (className != null ? className.hashCode() : 0);
+ result = 29 * result + (name != null ? name.hashCode() : 0);
+ result = 29 * result + (params != null ? params.hashCode() : 0);
+ return result;
+ }
+
+ @Override
+ public String toString() {
+ return "ResultTypeConfig: [" + name + "] => [" + className + "] " +
+ "with defaultParam [" + defaultResultParam + "] with params " + params;
+ }
+
+ /**
+ * The builder for this object. An instance of this object is the only way to construct a new instance. The
+ * purpose is to enforce the immutability of the object. The methods are structured in a way to support chaining.
+ * After setting any values you need, call the {@link #build()} method to create the object.
+ */
+ public static final class Builder {
+ protected ResultTypeConfig target;
+
+ public Builder(String name, String className) {
+ target = new ResultTypeConfig(name, className);
+ }
+
+ public Builder(ResultTypeConfig orig) {
+ target = new ResultTypeConfig(orig);
+ }
+
+ public Builder name(String name) {
+ target.name = name;
+ return this;
+ }
+
+ public Builder className(String name) {
+ target.className = name;
+ return this;
+ }
+
+ public Builder addParam(String name, String value) {
+ target.params.put(name, value);
+ return this;
+ }
+
+ public Builder addParams(Map<String,String> params) {
+ target.params.putAll(params);
+ return this;
+ }
+
+ public Builder defaultResultParam(String defaultResultParam) {
+ target.defaultResultParam = defaultResultParam;
+ return this;
+ }
+
+ public Builder location(Location loc) {
+ target.location = loc;
+ return this;
+ }
+
+ public ResultTypeConfig build() {
+ embalmTarget();
+ ResultTypeConfig result = target;
+ target = new ResultTypeConfig(target);
+ return result;
+ }
+
+ protected void embalmTarget() {
+ target.params = Collections.unmodifiableMap(target.params);
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/UnknownHandlerConfig.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/UnknownHandlerConfig.java b/core/src/main/java/com/opensymphony/xwork2/config/entities/UnknownHandlerConfig.java
new file mode 100644
index 0000000..3d6692f
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/UnknownHandlerConfig.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.entities;
+
+import com.opensymphony.xwork2.util.location.Located;
+import com.opensymphony.xwork2.util.location.Location;
+
+public class UnknownHandlerConfig extends Located {
+
+ private String name;
+
+ public UnknownHandlerConfig(String name, Location location) {
+ this.name = name;
+ this.location = location;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ @Override
+ public String toString() {
+ return "UnknownHandlerConfig: [" + name + "]";
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/entities/package.html
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/entities/package.html b/core/src/main/java/com/opensymphony/xwork2/config/entities/package.html
new file mode 100644
index 0000000..d05a357
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/entities/package.html
@@ -0,0 +1,18 @@
+<body>
+
+<p>
+Configuration entity classes. All objects ending in "Config" are immutable and must be constructed using
+their inner "Builder" class. For example, a PackageConfig object can be created via:
+</p>
+<pre>
+ PackageConfig config = new PackageConfig.Builder("myPackage").build();
+</pre>
+<p>
+ The methods on the builder object are chainable to support constructions like this:
+</p>
+<pre>
+ ResultConfig config = new ResultConfig.Builder("success", "myapp.MyResult")
+ .addParam("location", "/foo.jsp")
+ .build();
+</pre>
+</body>
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java b/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java
new file mode 100644
index 0000000..5deb7cb
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/impl/AbstractMatcher.java
@@ -0,0 +1,267 @@
+/*
+ * $Id$
+ *
+ * Copyright 2003,2004 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.impl;
+
+import com.opensymphony.xwork2.util.PatternMatcher;
+import org.apache.commons.lang3.math.NumberUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.Serializable;
+import java.util.*;
+
+/**
+ * <p> Matches patterns against pre-compiled wildcard expressions pulled from
+ * target objects. It uses the wildcard matcher from the Apache Cocoon
+ * project. Patterns will be matched in the order they were added. The first
+ * match wins, so more specific patterns should be defined before less specific
+ * patterns.
+ *
+ * @since 2.1
+ */
+public abstract class AbstractMatcher<E> implements Serializable {
+ /**
+ * <p> The logging instance </p>
+ */
+ private static final Logger log = LogManager.getLogger(AbstractMatcher.class);
+
+ /**
+ * <p> Handles all wildcard pattern matching. </p>
+ */
+ PatternMatcher<Object> wildcard;
+
+ /**
+ * <p> The compiled patterns and their associated target objects </p>
+ */
+ List<Mapping<E>> compiledPatterns = new ArrayList<>();
+ ;
+
+ public AbstractMatcher(PatternMatcher<?> helper) {
+ this.wildcard = (PatternMatcher<Object>) helper;
+ }
+
+ /**
+ * <p>
+ * Finds and precompiles the wildcard patterns. Patterns will be evaluated
+ * in the order they were added. Only patterns that actually contain a
+ * wildcard will be compiled.
+ * </p>
+ *
+ * <p>
+ * Patterns can optionally be matched "loosely". When the end of the pattern
+ * matches \*[^*]\*$ (wildcard, no wildcard, wildcard), if the pattern
+ * fails, it is also matched as if the last two characters didn't exist. The
+ * goal is to support the legacy "*!*" syntax, where the "!*" is optional.
+ * </p>
+ *
+ * @param name The pattern
+ * @param target The object to associate with the pattern
+ * @param looseMatch
+ * To loosely match wildcards or not
+ */
+ public void addPattern(String name, E target, boolean looseMatch) {
+
+ Object pattern;
+
+ if (!wildcard.isLiteral(name)) {
+ if (looseMatch && (name.length() > 0) && (name.charAt(0) == '/')) {
+ name = name.substring(1);
+ }
+
+ log.debug("Compiling pattern '{}'", name);
+
+ pattern = wildcard.compilePattern(name);
+ compiledPatterns.add(new Mapping<E>(name, pattern, target));
+
+ if (looseMatch) {
+ int lastStar = name.lastIndexOf('*');
+ if (lastStar > 1 && lastStar == name.length() - 1) {
+ if (name.charAt(lastStar - 1) != '*') {
+ pattern = wildcard.compilePattern(name.substring(0, lastStar - 1));
+ compiledPatterns.add(new Mapping<E>(name, pattern, target));
+ }
+ }
+ }
+ }
+ }
+
+ public void freeze() {
+ compiledPatterns = Collections.unmodifiableList(new ArrayList<Mapping<E>>());
+ }
+
+ /**
+ * <p> Matches the path against the compiled wildcard patterns. </p>
+ *
+ * @param potentialMatch The portion of the request URI for selecting a config.
+ * @return The action config if matched, else null
+ */
+ public E match(String potentialMatch) {
+ E config = null;
+
+ if (compiledPatterns.size() > 0) {
+ log.debug("Attempting to match '{}' to a wildcard pattern, {} available", potentialMatch, compiledPatterns.size());
+
+ Map<String,String> vars = new LinkedHashMap<String,String>();
+ for (Mapping<E> m : compiledPatterns) {
+ if (wildcard.match(vars, potentialMatch, m.getPattern())) {
+ log.debug("Value matches pattern '{}'", m.getOriginalPattern());
+ config = convert(potentialMatch, m.getTarget(), vars);
+ break;
+ }
+ }
+ }
+
+ return config;
+ }
+
+ /**
+ * <p> Clones the target object and its children, replacing various
+ * properties with the values of the wildcard-matched strings. </p>
+ *
+ * @param path The requested path
+ * @param orig The original object
+ * @param vars A Map of wildcard-matched strings
+ * @return A cloned object with appropriate properties replaced with
+ * wildcard-matched values
+ */
+ protected abstract E convert(String path, E orig, Map<String, String> vars);
+
+ /**
+ * <p> Replaces parameter values
+ * </p>
+ *
+ * @param orig The original parameters with placeholder values
+ * @param vars A Map of wildcard-matched strings
+ */
+ protected Map<String,String> replaceParameters(Map<String, String> orig, Map<String,String> vars) {
+ Map<String, String> map = new LinkedHashMap<>();
+
+ //this will set the group index references, like {1}
+ for (String key : orig.keySet()) {
+ map.put(key, convertParam(orig.get(key), vars));
+ }
+
+ //the values map will contain entries like name->"Lex Luthor" and 1->"Lex Luthor"
+ //now add the non-numeric values
+ for (String key: vars.keySet()) {
+ if (!NumberUtils.isNumber(key)) {
+ map.put(key, vars.get(key));
+ }
+ }
+
+ return map;
+ }
+
+ /**
+ * <p> Inserts into a value wildcard-matched strings where specified
+ * with the {x} syntax. If a wildcard-matched value isn't found, the
+ * replacement token is turned into an empty string.
+ * </p>
+ *
+ * @param val The value to convert
+ * @param vars A Map of wildcard-matched strings
+ * @return The new value
+ */
+ protected String convertParam(String val, Map<String, String> vars) {
+ if (val == null) {
+ return null;
+ }
+
+ int len = val.length();
+ StringBuilder ret = new StringBuilder();
+ char c;
+ String varVal;
+ for (int x=0; x<len; x++) {
+ c = val.charAt(x);
+ if (x < len - 2 &&
+ c == '{' && '}' == val.charAt(x+2)) {
+ varVal = (String)vars.get(String.valueOf(val.charAt(x + 1)));
+ if (varVal != null) {
+ ret.append(varVal);
+ }
+ x += 2;
+ } else {
+ ret.append(c);
+ }
+ }
+
+ return ret.toString();
+ }
+
+ /**
+ * <p> Stores a compiled wildcard pattern and the object it came
+ * from. </p>
+ */
+ private static class Mapping<E> implements Serializable {
+ /**
+ * <p> The original pattern. </p>
+ */
+ private String original;
+
+
+ /**
+ * <p> The compiled pattern. </p>
+ */
+ private Object pattern;
+
+ /**
+ * <p> The original object. </p>
+ */
+ private E config;
+
+ /**
+ * <p> Contructs a read-only Mapping instance. </p>
+ *
+ * @param original The original pattern
+ * @param pattern The compiled pattern
+ * @param config The original object
+ */
+ public Mapping(String original, Object pattern, E config) {
+ this.original = original;
+ this.pattern = pattern;
+ this.config = config;
+ }
+
+ /**
+ * <p> Gets the compiled wildcard pattern. </p>
+ *
+ * @return The compiled pattern
+ */
+ public Object getPattern() {
+ return this.pattern;
+ }
+
+ /**
+ * <p> Gets the object that contains the pattern. </p>
+ *
+ * @return The associated object
+ */
+ public E getTarget() {
+ return this.config;
+ }
+
+ /**
+ * <p> Gets the original wildcard pattern. </p>
+ *
+ * @return The original pattern
+ */
+ public String getOriginalPattern() {
+ return this.original;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcher.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcher.java b/core/src/main/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcher.java
new file mode 100644
index 0000000..e282c1a
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/impl/ActionConfigMatcher.java
@@ -0,0 +1,152 @@
+/*
+ * $Id$
+ *
+ * Copyright 2003,2004 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.impl;
+
+import com.opensymphony.xwork2.config.entities.ActionConfig;
+import com.opensymphony.xwork2.config.entities.ExceptionMappingConfig;
+import com.opensymphony.xwork2.config.entities.ResultConfig;
+import com.opensymphony.xwork2.util.PatternMatcher;
+import com.opensymphony.xwork2.util.WildcardHelper;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * <p> Matches paths against pre-compiled wildcard expressions pulled from
+ * action configs. It uses the wildcard matcher from the Apache Cocoon
+ * project. Patterns will be matched in the order they exist in the
+ * config file. The first match wins, so more specific patterns should be
+ * defined before less specific patterns.
+ */
+public class ActionConfigMatcher extends AbstractMatcher<ActionConfig> implements Serializable {
+
+ /**
+ * <p> Finds and precompiles the wildcard patterns from the ActionConfig
+ * "path" attributes. ActionConfig's will be evaluated in the order they
+ * exist in the config file. Only paths that actually contain a
+ * wildcard will be compiled. Patterns will matched strictly.</p>
+ *
+ * @param configs An array of ActionConfig's to process
+ * @deprecated Since 2.1, use {@link #ActionConfigMatcher(PatternMatcher, Map, boolean)} instead
+ */
+ @Deprecated public ActionConfigMatcher(Map<String, ActionConfig> configs) {
+ this(configs, false);
+ }
+
+ /**
+ * <p> Finds and precompiles the wildcard patterns from the ActionConfig
+ * "path" attributes. ActionConfig's will be evaluated in the order they
+ * exist in the config file. Only paths that actually contain a
+ * wildcard will be compiled. </p>
+ *
+ * <p>Patterns can optionally be matched "loosely". When
+ * the end of the pattern matches \*[^*]\*$ (wildcard, no wildcard,
+ * wildcard), if the pattern fails, it is also matched as if the
+ * last two characters didn't exist. The goal is to support the
+ * legacy "*!*" syntax, where the "!*" is optional.</p>
+ *
+ * @param configs An array of ActionConfig's to process
+ * @param looseMatch To loosely match wildcards or not
+ * @deprecated Since 2.1, use {@link #ActionConfigMatcher(PatternMatcher, Map, boolean)} instead
+ */
+ @Deprecated public ActionConfigMatcher(Map<String, ActionConfig> configs,
+ boolean looseMatch) {
+
+ this(new WildcardHelper(), configs, looseMatch);
+ }
+
+ /**
+ * <p> Finds and precompiles the wildcard patterns from the ActionConfig
+ * "path" attributes. ActionConfig's will be evaluated in the order they
+ * exist in the config file. Only paths that actually contain a
+ * wildcard will be compiled. </p>
+ *
+ * <p>Patterns can optionally be matched "loosely". When
+ * the end of the pattern matches \*[^*]\*$ (wildcard, no wildcard,
+ * wildcard), if the pattern fails, it is also matched as if the
+ * last two characters didn't exist. The goal is to support the
+ * legacy "*!*" syntax, where the "!*" is optional.</p>
+ *
+ * @param configs An array of ActionConfig's to process
+ * @param looseMatch To loosely match wildcards or not
+ */
+ public ActionConfigMatcher(PatternMatcher<?> patternMatcher,
+ Map<String, ActionConfig> configs,
+ boolean looseMatch) {
+ super(patternMatcher);
+ for (String name : configs.keySet()) {
+ addPattern(name, configs.get(name), looseMatch);
+ }
+ }
+
+ /**
+ * <p> Clones the ActionConfig and its children, replacing various
+ * properties with the values of the wildcard-matched strings. </p>
+ *
+ * @param path The requested path
+ * @param orig The original ActionConfig
+ * @param vars A Map of wildcard-matched strings
+ * @return A cloned ActionConfig with appropriate properties replaced with
+ * wildcard-matched values
+ */
+ @Override public ActionConfig convert(String path, ActionConfig orig,
+ Map<String, String> vars) {
+
+ String methodName = convertParam(orig.getMethodName(), vars);
+ if (!orig.isAllowedMethod(methodName)) {
+ return null;
+ }
+
+ String className = convertParam(orig.getClassName(), vars);
+ String pkgName = convertParam(orig.getPackageName(), vars);
+
+ Map<String,String> params = replaceParameters(orig.getParams(), vars);
+
+ Map<String, ResultConfig> results = new LinkedHashMap<>();
+ for (String name : orig.getResults().keySet()) {
+ ResultConfig result = orig.getResults().get(name);
+ name = convertParam(name, vars);
+ ResultConfig r = new ResultConfig.Builder(name, convertParam(result.getClassName(), vars))
+ .addParams(replaceParameters(result.getParams(), vars))
+ .build();
+ results.put(name, r);
+ }
+
+ List<ExceptionMappingConfig> exs = new ArrayList<ExceptionMappingConfig>();
+ for (ExceptionMappingConfig ex : orig.getExceptionMappings()) {
+ String name = convertParam(ex.getName(), vars);
+ String exClassName = convertParam(ex.getExceptionClassName(), vars);
+ String exResult = convertParam(ex.getResult(), vars);
+ Map<String,String> exParams = replaceParameters(ex.getParams(), vars);
+ ExceptionMappingConfig e = new ExceptionMappingConfig.Builder(name, exClassName, exResult).addParams(exParams).build();
+ exs.add(e);
+ }
+
+ return new ActionConfig.Builder(pkgName, orig.getName(), className)
+ .methodName(methodName)
+ .addParams(params)
+ .addResultConfigs(results)
+ .addInterceptors(orig.getInterceptors())
+ .addExceptionMappings(exs)
+ .location(orig.getLocation())
+ .build();
+ }
+}
http://git-wip-us.apache.org/repos/asf/struts/blob/31af5842/core/src/main/java/com/opensymphony/xwork2/config/impl/DefaultConfiguration.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/com/opensymphony/xwork2/config/impl/DefaultConfiguration.java b/core/src/main/java/com/opensymphony/xwork2/config/impl/DefaultConfiguration.java
new file mode 100644
index 0000000..7d5e5cc
--- /dev/null
+++ b/core/src/main/java/com/opensymphony/xwork2/config/impl/DefaultConfiguration.java
@@ -0,0 +1,514 @@
+/*
+ * Copyright 2002-2006,2009 The Apache Software Foundation.
+ *
+ * Licensed 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 com.opensymphony.xwork2.config.impl;
+
+import com.opensymphony.xwork2.*;
+import com.opensymphony.xwork2.config.*;
+import com.opensymphony.xwork2.config.entities.*;
+import com.opensymphony.xwork2.config.providers.InterceptorBuilder;
+import com.opensymphony.xwork2.conversion.*;
+import com.opensymphony.xwork2.conversion.impl.*;
+import com.opensymphony.xwork2.factory.*;
+import com.opensymphony.xwork2.inject.*;
+import com.opensymphony.xwork2.ognl.OgnlReflectionProvider;
+import com.opensymphony.xwork2.ognl.OgnlUtil;
+import com.opensymphony.xwork2.ognl.OgnlValueStackFactory;
+import com.opensymphony.xwork2.ognl.accessor.CompoundRootAccessor;
+import com.opensymphony.xwork2.util.*;
+import com.opensymphony.xwork2.util.fs.DefaultFileManager;
+import com.opensymphony.xwork2.util.fs.DefaultFileManagerFactory;
+import com.opensymphony.xwork2.util.location.LocatableProperties;
+import com.opensymphony.xwork2.util.reflection.ReflectionProvider;
+import ognl.PropertyAccessor;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.*;
+
+
+/**
+ * DefaultConfiguration
+ *
+ * @author Jason Carreira
+ * Created Feb 24, 2003 7:38:06 AM
+ */
+public class DefaultConfiguration implements Configuration {
+
+ protected static final Logger LOG = LogManager.getLogger(DefaultConfiguration.class);
+
+
+ // Programmatic Action Configurations
+ protected Map<String, PackageConfig> packageContexts = new LinkedHashMap<>();
+ protected RuntimeConfiguration runtimeConfiguration;
+ protected Container container;
+ protected String defaultFrameworkBeanName;
+ protected Set<String> loadedFileNames = new TreeSet<>();
+ protected List<UnknownHandlerConfig> unknownHandlerStack;
+
+
+ ObjectFactory objectFactory;
+
+ public DefaultConfiguration() {
+ this("xwork");
+ }
+
+ public DefaultConfiguration(String defaultBeanName) {
+ this.defaultFrameworkBeanName = defaultBeanName;
+ }
+
+
+ public PackageConfig getPackageConfig(String name) {
+ return packageContexts.get(name);
+ }
+
+ public List<UnknownHandlerConfig> getUnknownHandlerStack() {
+ return unknownHandlerStack;
+ }
+
+ public void setUnknownHandlerStack(List<UnknownHandlerConfig> unknownHandlerStack) {
+ this.unknownHandlerStack = unknownHandlerStack;
+ }
+
+ public Set<String> getPackageConfigNames() {
+ return packageContexts.keySet();
+ }
+
+ public Map<String, PackageConfig> getPackageConfigs() {
+ return packageContexts;
+ }
+
+ public Set<String> getLoadedFileNames() {
+ return loadedFileNames;
+ }
+
+ public RuntimeConfiguration getRuntimeConfiguration() {
+ return runtimeConfiguration;
+ }
+
+ /**
+ * @return the container
+ */
+ public Container getContainer() {
+ return container;
+ }
+
+ public void addPackageConfig(String name, PackageConfig packageContext) {
+ PackageConfig check = packageContexts.get(name);
+ if (check != null) {
+ if (check.getLocation() != null && packageContext.getLocation() != null
+ && check.getLocation().equals(packageContext.getLocation())) {
+ LOG.debug("The package name '{}' is already been loaded by the same location and could be removed: {}",
+ name, packageContext.getLocation());
+ } else {
+ throw new ConfigurationException("The package name '" + name
+ + "' at location "+packageContext.getLocation()
+ + " is already been used by another package at location " + check.getLocation(),
+ packageContext);
+ }
+ }
+ packageContexts.put(name, packageContext);
+ }
+
+ public PackageConfig removePackageConfig(String packageName) {
+ return packageContexts.remove(packageName);
+ }
+
+ /**
+ * Allows the configuration to clean up any resources used
+ */
+ public void destroy() {
+ packageContexts.clear();
+ loadedFileNames.clear();
+ }
+
+ public void rebuildRuntimeConfiguration() {
+ runtimeConfiguration = buildRuntimeConfiguration();
+ }
+
+ /**
+ * Calls the ConfigurationProviderFactory.getConfig() to tell it to reload the configuration and then calls
+ * buildRuntimeConfiguration().
+ *
+ * @throws ConfigurationException
+ */
+ public synchronized void reload(List<ConfigurationProvider> providers) throws ConfigurationException {
+
+ // Silly copy necessary due to lack of ability to cast generic lists
+ List<ContainerProvider> contProviders = new ArrayList<>();
+ contProviders.addAll(providers);
+
+ reloadContainer(contProviders);
+ }
+
+ /**
+ * Calls the ConfigurationProviderFactory.getConfig() to tell it to reload the configuration and then calls
+ * buildRuntimeConfiguration().
+ *
+ * @throws ConfigurationException
+ */
+ public synchronized List<PackageProvider> reloadContainer(List<ContainerProvider> providers) throws ConfigurationException {
+ packageContexts.clear();
+ loadedFileNames.clear();
+ List<PackageProvider> packageProviders = new ArrayList<>();
+
+ ContainerProperties props = new ContainerProperties();
+ ContainerBuilder builder = new ContainerBuilder();
+ Container bootstrap = createBootstrapContainer(providers);
+ for (final ContainerProvider containerProvider : providers)
+ {
+ bootstrap.inject(containerProvider);
+ containerProvider.init(this);
+ containerProvider.register(builder, props);
+ }
+ props.setConstants(builder);
+
+ builder.factory(Configuration.class, new Factory<Configuration>() {
+ public Configuration create(Context context) throws Exception {
+ return DefaultConfiguration.this;
+ }
+ });
+
+ ActionContext oldContext = ActionContext.getContext();
+ try {
+ // Set the bootstrap container for the purposes of factory creation
+
+ setContext(bootstrap);
+ container = builder.create(false);
+ setContext(container);
+ objectFactory = container.getInstance(ObjectFactory.class);
+
+ // Process the configuration providers first
+ for (final ContainerProvider containerProvider : providers)
+ {
+ if (containerProvider instanceof PackageProvider) {
+ container.inject(containerProvider);
+ ((PackageProvider)containerProvider).loadPackages();
+ packageProviders.add((PackageProvider)containerProvider);
+ }
+ }
+
+ // Then process any package providers from the plugins
+ Set<String> packageProviderNames = container.getInstanceNames(PackageProvider.class);
+ for (String name : packageProviderNames) {
+ PackageProvider provider = container.getInstance(PackageProvider.class, name);
+ provider.init(this);
+ provider.loadPackages();
+ packageProviders.add(provider);
+ }
+
+ rebuildRuntimeConfiguration();
+ } finally {
+ if (oldContext == null) {
+ ActionContext.setContext(null);
+ }
+ }
+ return packageProviders;
+ }
+
+ protected ActionContext setContext(Container cont) {
+ ActionContext context = ActionContext.getContext();
+ if (context == null) {
+ ValueStack vs = cont.getInstance(ValueStackFactory.class).createValueStack();
+ context = new ActionContext(vs.getContext());
+ ActionContext.setContext(context);
+ }
+ return context;
+ }
+
+ protected Container createBootstrapContainer(List<ContainerProvider> providers) {
+ ContainerBuilder builder = new ContainerBuilder();
+ boolean fmFactoryRegistered = false;
+ for (ContainerProvider provider : providers) {
+ if (provider instanceof FileManagerProvider) {
+ provider.register(builder, null);
+ }
+ if (provider instanceof FileManagerFactoryProvider) {
+ provider.register(builder, null);
+ fmFactoryRegistered = true;
+ }
+ }
+ builder.factory(ObjectFactory.class, Scope.SINGLETON);
+ builder.factory(ActionFactory.class, DefaultActionFactory.class, Scope.SINGLETON);
+ builder.factory(ResultFactory.class, DefaultResultFactory.class, Scope.SINGLETON);
+ builder.factory(InterceptorFactory.class, DefaultInterceptorFactory.class, Scope.SINGLETON);
+ builder.factory(com.opensymphony.xwork2.factory.ValidatorFactory.class, com.opensymphony.xwork2.factory.DefaultValidatorFactory.class, Scope.SINGLETON);
+ builder.factory(ConverterFactory.class, DefaultConverterFactory.class, Scope.SINGLETON);
+ builder.factory(UnknownHandlerFactory.class, DefaultUnknownHandlerFactory.class, Scope.SINGLETON);
+
+ builder.factory(FileManager.class, "system", DefaultFileManager.class, Scope.SINGLETON);
+ if (!fmFactoryRegistered) {
+ builder.factory(FileManagerFactory.class, DefaultFileManagerFactory.class, Scope.SINGLETON);
+ }
+ builder.factory(ReflectionProvider.class, OgnlReflectionProvider.class, Scope.SINGLETON);
+ builder.factory(ValueStackFactory.class, OgnlValueStackFactory.class, Scope.SINGLETON);
+
+ builder.factory(XWorkConverter.class, Scope.SINGLETON);
+ builder.factory(ConversionPropertiesProcessor.class, DefaultConversionPropertiesProcessor.class, Scope.SINGLETON);
+ builder.factory(ConversionFileProcessor.class, DefaultConversionFileProcessor.class, Scope.SINGLETON);
+ builder.factory(ConversionAnnotationProcessor.class, DefaultConversionAnnotationProcessor.class, Scope.SINGLETON);
+ builder.factory(TypeConverterCreator.class, DefaultTypeConverterCreator.class, Scope.SINGLETON);
+ builder.factory(TypeConverterHolder.class, DefaultTypeConverterHolder.class, Scope.SINGLETON);
+
+ builder.factory(XWorkBasicConverter.class, Scope.SINGLETON);
+ builder.factory(TypeConverter.class, XWorkConstants.COLLECTION_CONVERTER, CollectionConverter.class, Scope.SINGLETON);
+ builder.factory(TypeConverter.class, XWorkConstants.ARRAY_CONVERTER, ArrayConverter.class, Scope.SINGLETON);
+ builder.factory(TypeConverter.class, XWorkConstants.DATE_CONVERTER, DateConverter.class, Scope.SINGLETON);
+ builder.factory(TypeConverter.class, XWorkConstants.NUMBER_CONVERTER, NumberConverter.class, Scope.SINGLETON);
+ builder.factory(TypeConverter.class, XWorkConstants.STRING_CONVERTER, StringConverter.class, Scope.SINGLETON);
+
+ builder.factory(TextParser.class, OgnlTextParser.class, Scope.SINGLETON);
+ builder.factory(TextProvider.class, "system", DefaultTextProvider.class, Scope.SINGLETON);
+
+ builder.factory(ObjectTypeDeterminer.class, DefaultObjectTypeDeterminer.class, Scope.SINGLETON);
+ builder.factory(PropertyAccessor.class, CompoundRoot.class.getName(), CompoundRootAccessor.class, Scope.SINGLETON);
+ builder.factory(OgnlUtil.class, Scope.SINGLETON);
+
+ builder.constant(XWorkConstants.DEV_MODE, "false");
+ builder.constant(XWorkConstants.LOG_MISSING_PROPERTIES, "false");
+ builder.constant(XWorkConstants.ENABLE_OGNL_EVAL_EXPRESSION, "false");
+ builder.constant(XWorkConstants.ENABLE_OGNL_EXPRESSION_CACHE, "true");
+ builder.constant(XWorkConstants.RELOAD_XML_CONFIGURATION, "false");
+
+ return builder.create(true);
+ }
+
+ /**
+ * This builds the internal runtime configuration used by Xwork for finding and configuring Actions from the
+ * programmatic configuration data structures. All of the old runtime configuration will be discarded and rebuilt.
+ *
+ * <p>
+ * It basically flattens the data structures to make the information easier to access. It will take
+ * an {@link ActionConfig} and combine its data with all inherited dast. For example, if the {@link ActionConfig}
+ * is in a package that contains a global result and it also contains a result, the resulting {@link ActionConfig}
+ * will have two results.
+ */
+ protected synchronized RuntimeConfiguration buildRuntimeConfiguration() throws ConfigurationException {
+ Map<String, Map<String, ActionConfig>> namespaceActionConfigs = new LinkedHashMap<>();
+ Map<String, String> namespaceConfigs = new LinkedHashMap<>();
+
+ for (PackageConfig packageConfig : packageContexts.values()) {
+
+ if (!packageConfig.isAbstract()) {
+ String namespace = packageConfig.getNamespace();
+ Map<String, ActionConfig> configs = namespaceActionConfigs.get(namespace);
+
+ if (configs == null) {
+ configs = new LinkedHashMap<>();
+ }
+
+ Map<String, ActionConfig> actionConfigs = packageConfig.getAllActionConfigs();
+
+ for (Object o : actionConfigs.keySet()) {
+ String actionName = (String) o;
+ ActionConfig baseConfig = actionConfigs.get(actionName);
+ configs.put(actionName, buildFullActionConfig(packageConfig, baseConfig));
+ }
+
+ namespaceActionConfigs.put(namespace, configs);
+ if (packageConfig.getFullDefaultActionRef() != null) {
+ namespaceConfigs.put(namespace, packageConfig.getFullDefaultActionRef());
+ }
+ }
+ }
+
+ PatternMatcher<int[]> matcher = container.getInstance(PatternMatcher.class);
+ return new RuntimeConfigurationImpl(Collections.unmodifiableMap(namespaceActionConfigs),
+ Collections.unmodifiableMap(namespaceConfigs), matcher);
+ }
+
+ private void setDefaultResults(Map<String, ResultConfig> results, PackageConfig packageContext) {
+ String defaultResult = packageContext.getFullDefaultResultType();
+
+ for (Map.Entry<String, ResultConfig> entry : results.entrySet()) {
+
+ if (entry.getValue() == null) {
+ ResultTypeConfig resultTypeConfig = packageContext.getAllResultTypeConfigs().get(defaultResult);
+ entry.setValue(new ResultConfig.Builder(null, resultTypeConfig.getClassName()).build());
+ }
+ }
+ }
+
+ /**
+ * Builds the full runtime actionconfig with all of the defaults and inheritance
+ *
+ * @param packageContext the PackageConfig which holds the base config we're building from
+ * @param baseConfig the ActionConfig which holds only the configuration specific to itself, without the defaults
+ * and inheritance
+ * @return a full ActionConfig for runtime configuration with all of the inherited and default params
+ * @throws com.opensymphony.xwork2.config.ConfigurationException
+ *
+ */
+ private ActionConfig buildFullActionConfig(PackageConfig packageContext, ActionConfig baseConfig) throws ConfigurationException {
+ Map<String, String> params = new TreeMap<>(baseConfig.getParams());
+ Map<String, ResultConfig> results = new TreeMap<>();
+
+ if (!baseConfig.getPackageName().equals(packageContext.getName()) && packageContexts.containsKey(baseConfig.getPackageName())) {
+ results.putAll(packageContexts.get(baseConfig.getPackageName()).getAllGlobalResults());
+ } else {
+ results.putAll(packageContext.getAllGlobalResults());
+ }
+
+ results.putAll(baseConfig.getResults());
+
+ setDefaultResults(results, packageContext);
+
+ List<InterceptorMapping> interceptors = new ArrayList<>(baseConfig.getInterceptors());
+
+ if (interceptors.size() <= 0) {
+ String defaultInterceptorRefName = packageContext.getFullDefaultInterceptorRef();
+
+ if (defaultInterceptorRefName != null) {
+ interceptors.addAll(InterceptorBuilder.constructInterceptorReference(new PackageConfig.Builder(packageContext), defaultInterceptorRefName,
+ new LinkedHashMap<String, String>(), packageContext.getLocation(), objectFactory));
+ }
+ }
+
+ return new ActionConfig.Builder(baseConfig)
+ .addParams(params)
+ .addResultConfigs(results)
+ .defaultClassName(packageContext.getDefaultClassRef()) // fill in default if non class has been provided
+ .interceptors(interceptors)
+ .addExceptionMappings(packageContext.getAllExceptionMappingConfigs())
+ .build();
+ }
+
+
+ private static class RuntimeConfigurationImpl implements RuntimeConfiguration {
+
+ private Map<String, Map<String, ActionConfig>> namespaceActionConfigs;
+ private Map<String, ActionConfigMatcher> namespaceActionConfigMatchers;
+ private NamespaceMatcher namespaceMatcher;
+ private Map<String, String> namespaceConfigs;
+
+ public RuntimeConfigurationImpl(Map<String, Map<String, ActionConfig>> namespaceActionConfigs,
+ Map<String, String> namespaceConfigs,
+ PatternMatcher<int[]> matcher) {
+ this.namespaceActionConfigs = namespaceActionConfigs;
+ this.namespaceConfigs = namespaceConfigs;
+
+ this.namespaceActionConfigMatchers = new LinkedHashMap<>();
+ this.namespaceMatcher = new NamespaceMatcher(matcher, namespaceActionConfigs.keySet());
+
+ for (String ns : namespaceActionConfigs.keySet()) {
+ namespaceActionConfigMatchers.put(ns, new ActionConfigMatcher(matcher, namespaceActionConfigs.get(ns), true));
+ }
+ }
+
+
+ /**
+ * Gets the configuration information for an action name, or returns null if the
+ * name is not recognized.
+ *
+ * @param name the name of the action
+ * @param namespace the namespace for the action or null for the empty namespace, ""
+ * @return the configuration information for action requested
+ */
+ public ActionConfig getActionConfig(String namespace, String name) {
+ ActionConfig config = findActionConfigInNamespace(namespace, name);
+
+ // try wildcarded namespaces
+ if (config == null) {
+ NamespaceMatch match = namespaceMatcher.match(namespace);
+ if (match != null) {
+ config = findActionConfigInNamespace(match.getPattern(), name);
+
+ // If config found, place all the matches found in the namespace processing in the action's parameters
+ if (config != null) {
+ config = new ActionConfig.Builder(config)
+ .addParams(match.getVariables())
+ .build();
+ }
+ }
+ }
+
+ // fail over to empty namespace
+ if (config == null && StringUtils.isNotBlank(namespace)) {
+ config = findActionConfigInNamespace("", name);
+ }
+
+
+ return config;
+ }
+
+ private ActionConfig findActionConfigInNamespace(String namespace, String name) {
+ ActionConfig config = null;
+ if (namespace == null) {
+ namespace = "";
+ }
+ Map<String, ActionConfig> actions = namespaceActionConfigs.get(namespace);
+ if (actions != null) {
+ config = actions.get(name);
+ // Check wildcards
+ if (config == null) {
+ config = namespaceActionConfigMatchers.get(namespace).match(name);
+ // fail over to default action
+ if (config == null) {
+ String defaultActionRef = namespaceConfigs.get(namespace);
+ if (defaultActionRef != null) {
+ config = actions.get(defaultActionRef);
+ }
+ }
+ }
+ }
+ return config;
+ }
+
+ /**
+ * Gets the configuration settings for every action.
+ *
+ * @return a Map of namespace - > Map of ActionConfig objects, with the key being the action name
+ */
+ public Map<String, Map<String, ActionConfig>> getActionConfigs() {
+ return namespaceActionConfigs;
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder buff = new StringBuilder("RuntimeConfiguration - actions are\n");
+
+ for (String namespace : namespaceActionConfigs.keySet()) {
+ Map<String, ActionConfig> actionConfigs = namespaceActionConfigs.get(namespace);
+
+ for (String s : actionConfigs.keySet()) {
+ buff.append(namespace).append("/").append(s).append("\n");
+ }
+ }
+
+ return buff.toString();
+ }
+ }
+
+ class ContainerProperties extends LocatableProperties {
+ private static final long serialVersionUID = -7320625750836896089L;
+
+ @Override
+ public Object setProperty(String key, String value) {
+ String oldValue = getProperty(key);
+ if (LOG.isInfoEnabled() && oldValue != null && !oldValue.equals(value) && !defaultFrameworkBeanName.equals(oldValue)) {
+ LOG.info("Overriding property {} - old value: {} new value: {}", key, oldValue, value);
+ }
+ return super.setProperty(key, value);
+ }
+
+ public void setConstants(ContainerBuilder builder) {
+ for (Object keyobj : keySet()) {
+ String key = (String)keyobj;
+ builder.factory(String.class, key, new LocatableConstantFactory<>(getProperty(key), getPropertyLocation(key)));
+ }
+ }
+ }
+}