Merge branch '3.1.x' into 3.2.x

jameskleeh · jameskleeh · commit 589fa0fa925f · 2016-10-24T11:46:43.000-04:00
diff --git a/grails-plugin-gsp/src/main/groovy/org/grails/plugins/web/taglib/FormTagLib.groovy b/grails-plugin-gsp/src/main/groovy/org/grails/plugins/web/taglib/FormTagLib.groovy
@@ -1071,7 +1071,7 @@ class FormTagLib implements ApplicationContextAware, InitializingBean, TagLibrar
             }
         }
         keyValue = processFormFieldValueIfNecessary(selectName, "${keyValue}","option")
-        writer << "value=\"${keyValue}\" "
+        writer << "value=\"${keyValue.toString().encodeAsHTML()}\" "
 
         if(dataAttrsMap) {
             dataAttrsMap.each {key, val->
diff --git a/grails-shell/src/main/groovy/org/grails/cli/GrailsCli.groovy b/grails-shell/src/main/groovy/org/grails/cli/GrailsCli.groovy
@@ -674,7 +674,7 @@ class GrailsCli {
     @Canonical
     public static class ExecutionContextImpl implements ExecutionContext {
         CommandLine commandLine
-        @Delegate(excludes = 'getConsole') ProjectContext projectContext
+        @Delegate(excludes = ['getConsole', 'getBaseDir']) ProjectContext projectContext
         GrailsConsole console = GrailsConsole.getInstance()
 
         ExecutionContextImpl(CodeGenConfig config) {
@@ -706,6 +706,11 @@ class GrailsCli {
                 }
             }
         }
+
+        @Override
+        File getBaseDir() {
+            this.projectContext?.baseDir ?: new File(".")
+        }
     }
     
     @Canonical
diff --git a/grails-shell/src/main/groovy/org/grails/cli/profile/commands/CreateAppCommand.groovy b/grails-shell/src/main/groovy/org/grails/cli/profile/commands/CreateAppCommand.groovy
@@ -27,15 +27,20 @@ import org.eclipse.aether.graph.Dependency
 import org.grails.build.logging.GrailsConsoleAntBuilder
 import org.grails.build.parsing.CommandLine
 import org.grails.cli.GrailsCli
-import org.grails.cli.profile.*
+import org.grails.cli.profile.CommandDescription
+import org.grails.cli.profile.ExecutionContext
+import org.grails.cli.profile.Feature
+import org.grails.cli.profile.Profile
+import org.grails.cli.profile.ProfileRepository
+import org.grails.cli.profile.ProfileRepositoryAware
 import org.grails.io.support.FileSystemResource
 import org.grails.io.support.Resource
-
 import java.nio.file.FileVisitResult
 import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.SimpleFileVisitor
 import java.nio.file.attribute.BasicFileAttributes
+import java.nio.file.Paths
 
 /**
  * Command for creating Grails applications
@@ -60,6 +65,7 @@ class CreateAppCommand extends ArgumentCompletingCommand implements ProfileRepos
     Map<String, String> variables = [:]
     String appname
     String groupname
+    String defaultpackagename
     File targetDirectory
     List<String> binaryFileExtensions = ['png','gif','jpg','jpeg','ico','icns','pdf','zip','jar','class']
 
@@ -202,38 +208,28 @@ class CreateAppCommand extends ArgumentCompletingCommand implements ProfileRepos
         files
     }
 
-    @Override
-    boolean handle(ExecutionContext executionContext) {
-        if(profileRepository == null) throw new IllegalStateException("Property 'profileRepository' must be set")
-
+    boolean handle(CreateAppCommandObject cmd) {
+        if (profileRepository == null) throw new IllegalStateException("Property 'profileRepository' must be set")
 
-        def mainCommandLine = executionContext.commandLine
-        def profileName = evaluateProfileName(mainCommandLine)
-
-        List<String> validFlags = [INPLACE_FLAG, PROFILE_FLAG, FEATURES_FLAG]
-        mainCommandLine.undeclaredOptions.each { String key, Object value ->
-            if (!validFlags.contains(key)) {
-                List possibleSolutions = validFlags.findAll { it.substring(0, 2) == key.substring(0, 2) }
-                StringBuilder warning = new StringBuilder("Unrecognized flag: ${key}.")
-                if (possibleSolutions) {
-                    warning.append(" Possible solutions: ")
-                    warning.append(possibleSolutions.join(", "))
-                }
-                GrailsConsole.instance.warn(warning.toString())
-            }
-        }
+        String profileName = cmd.profileName
 
         Profile profileInstance = profileRepository.getProfile(profileName)
-        if( !validateProfile(profileInstance, profileName, executionContext)) {
+        if (!validateProfile(profileInstance, profileName)) {
             return false
         }
-        List<Feature> features = evaluateFeatures(profileInstance, mainCommandLine).toList()
-        if(profileInstance) {
 
-            if( !initializeVariables(profileInstance, mainCommandLine) ) {
+        List<Feature> features = evaluateFeatures(profileInstance, cmd.features).toList()
+
+        if (profileInstance) {
+            if (!initializeGroupAndName(cmd.appName, cmd.inplace)) {
                 return false
             }
-            File projectTargetDirectory = mainCommandLine.hasOption('inplace') || GrailsCli.isInteractiveModeActive() ? new File(".").canonicalFile : new File(appname)
+
+            initializeVariables(cmd.appName, defaultpackagename, profileName, cmd.grailsVersion)
+
+            Path appFullDirectory = Paths.get(cmd.baseDir.path, appname)
+
+            File projectTargetDirectory = cmd.inplace ? new File(".").canonicalFile : appFullDirectory.toAbsolutePath().normalize().toFile()
 
             def profiles = profileRepository.getProfileAndDependencies(profileInstance)
 
@@ -285,11 +281,11 @@ class CreateAppCommand extends ArgumentCompletingCommand implements ProfileRepos
             }
 
             replaceBuildTokens(profileName, profileInstance, features, projectTargetDirectory)
-            executionContext.console.addStatus(
-                "${name == 'create-plugin' ? 'Plugin' : 'Application'} created at $projectTargetDirectory.absolutePath"
+            cmd.console.addStatus(
+                "${name == 'create-plugin' ? 'Plugin' : 'Application'} created at ${projectTargetDirectory.absolutePath}"
             )
             if (profileInstance.instructions) {
-                executionContext.console.addStatus(profileInstance.instructions)
+                cmd.console.addStatus(profileInstance.instructions)
             }
             GrailsCli.tiggerAppLoad()
             return true
@@ -300,15 +296,53 @@ class CreateAppCommand extends ArgumentCompletingCommand implements ProfileRepos
         }
     }
 
-    protected boolean validateProfile(Profile profileInstance, String profileName, ExecutionContext executionContext) {
+    @Override
+    boolean handle(ExecutionContext executionContext) {
+        CommandLine commandLine = executionContext.commandLine
+
+        String profileName = evaluateProfileName(commandLine)
+
+        List<String> validFlags = [INPLACE_FLAG, PROFILE_FLAG, FEATURES_FLAG]
+        commandLine.undeclaredOptions.each { String key, Object value ->
+            if (!validFlags.contains(key)) {
+                List possibleSolutions = validFlags.findAll { it.substring(0, 2) == key.substring(0, 2) }
+                StringBuilder warning = new StringBuilder("Unrecognized flag: ${key}.")
+                if (possibleSolutions) {
+                    warning.append(" Possible solutions: ")
+                    warning.append(possibleSolutions.join(", "))
+                }
+                executionContext.console.warn(warning.toString())
+            }
+        }
+
+        boolean inPlace = commandLine.hasOption('inplace') || GrailsCli.isInteractiveModeActive()
+        String appName = commandLine.remainingArgs ? commandLine.remainingArgs[0] : ""
+
+        List<String> features = commandLine.optionValue("features")?.toString()?.split(',')?.toList()
+
+        CreateAppCommandObject cmd = new CreateAppCommandObject(
+            appName: appName,
+            baseDir: executionContext.baseDir,
+            profileName: profileName,
+            grailsVersion: Environment.getPackage().getImplementationVersion() ?: GRAILS_VERSION_FALLBACK_IN_IDE_ENVIRONMENTS_FOR_RUNNING_TESTS,
+            features: features,
+            inplace: inPlace,
+            console: executionContext.console
+        )
+
+        return this.handle(cmd)
+    }
+
+    protected boolean validateProfile(Profile profileInstance, String profileName) {
         if (profileInstance == null) {
-            executionContext.console.error("Profile not found for name [$profileName]")
+            GrailsConsole.instance.error("Profile not found for name [$profileName]")
             return false
         }
         return true
     }
 
     private Map<URL, File> unzippedDirectories = new LinkedHashMap<URL, File>()
+
     @CompileDynamic
     protected File unzipProfile(AntBuilder ant, Resource location) {
 
@@ -411,15 +445,15 @@ class CreateAppCommand extends ArgumentCompletingCommand implements ProfileRepos
         mainCommandLine.optionValue('profile')?.toString() ?: getDefaultProfile()
     }
 
-    protected Iterable<Feature> evaluateFeatures(Profile profile, CommandLine commandLine) {
-        String[] requestedFeatures = commandLine.optionValue("features")?.toString()?.split(',')
-        if(requestedFeatures) {
-            List<String> requestedFeaturesList = requestedFeatures.toList()
+    protected Iterable<Feature> evaluateFeatures(Profile profile, List<String> requestedFeatures) {
+        if (requestedFeatures) {
             List<String> allFeatureNames = profile.features*.name
-            List<String> validFeatureNames = requestedFeaturesList.intersect(allFeatureNames)
-            requestedFeaturesList.removeAll(allFeatureNames)
-            requestedFeaturesList.each { String invalidFeature ->
-                List possibleSolutions = allFeatureNames.findAll { it.substring(0, 2) == invalidFeature.substring(0, 2) }
+            List<String> validFeatureNames = requestedFeatures.intersect(allFeatureNames)
+            requestedFeatures.removeAll(allFeatureNames)
+            requestedFeatures.each { String invalidFeature ->
+                List possibleSolutions = allFeatureNames.findAll {
+                    it.substring(0, 2) == invalidFeature.substring(0, 2)
+                }
                 StringBuilder warning = new StringBuilder("Feature ${invalidFeature} does not exist in the profile ${profile.name}!")
                 if (possibleSolutions) {
                     warning.append(" Possible solutions: ")
@@ -463,49 +497,45 @@ class CreateAppCommand extends ArgumentCompletingCommand implements ProfileRepos
             setTo.text = createNewApplicationYml(previousApplicationYml, newApplicationYml)
         }
     }
-    
-    protected boolean initializeVariables(Profile profile, CommandLine commandLine) {
-        String defaultPackage
-
-        def args = commandLine.getRemainingArgs()
-        boolean inPlace = commandLine.hasOption('inplace') || GrailsCli.isInteractiveModeActive()
 
-        if(!args && !inPlace) {
+    protected boolean initializeGroupAndName(String appName, boolean inplace) {
+        if (!appName && !inplace) {
             GrailsConsole.getInstance().error("Specify an application name or use --inplace to create an application in the current directory")
             return false
         }
-        String groupAndAppName = args ? args[0] : null
-        if(inPlace) {
+        String groupAndAppName = appName
+        if(inplace) {
             appname = new File(".").canonicalFile.name
             if(!groupAndAppName) {
                 groupAndAppName = appname
             }
         }
-        
+
         if(!groupAndAppName) {
             GrailsConsole.getInstance().error("Specify an application name or use --inplace to create an application in the current directory")
             return false
         }
 
         try {
-            defaultPackage = establishGroupAndAppName(groupAndAppName)
+            defaultpackagename = establishGroupAndAppName(groupAndAppName)
         } catch (IllegalArgumentException e ) {
             GrailsConsole.instance.error(e.message)
             return false
         }
+    }
 
-
+    private void initializeVariables(String appname, String defaultPackage, String profileName, String grailsVersion) {
         variables.APPNAME = appname
 
         variables['grails.codegen.defaultPackage'] = defaultPackage
-        variables['grails.codegen.defaultPackage.path']  = defaultPackage.replace('.', '/')
+        variables['grails.codegen.defaultPackage.path'] = defaultPackage.replace('.', '/')
 
         def projectClassName = GrailsNameUtils.getNameFromScript(appname)
         variables['grails.codegen.projectClassName'] = projectClassName
         variables['grails.codegen.projectNaturalName'] = GrailsNameUtils.getNaturalName(projectClassName)
         variables['grails.codegen.projectName'] = GrailsNameUtils.getScriptName(projectClassName)
-        variables['grails.profile'] = profile.name
-        variables['grails.version'] = Environment.getPackage().getImplementationVersion() ?: GRAILS_VERSION_FALLBACK_IN_IDE_ENVIRONMENTS_FOR_RUNNING_TESTS
+        variables['grails.profile'] = profileName
+        variables['grails.version'] = grailsVersion
         variables['grails.app.name'] = appname
         variables['grails.app.group'] = groupname
     }
@@ -526,7 +556,7 @@ class CreateAppCommand extends ArgumentCompletingCommand implements ProfileRepos
     }
 
     private String createValidPackageName() {
-        String defaultPackage = appname.split(/[-]+/).collect { String token -> (token.toLowerCase().toCharArray().findAll  { char ch -> Character.isJavaIdentifierPart(ch) } as char[]) as String }.join('.')
+        String defaultPackage = appname.split(/[-]+/).collect { String token -> (token.toLowerCase().toCharArray().findAll { char ch -> Character.isJavaIdentifierPart(ch) } as char[]) as String }.join('.')
         if(!GrailsNameUtils.isValidJavaPackage(defaultPackage)) {
             throw new IllegalArgumentException("Cannot create a valid package name for [$appname]. Please specify a name that is also a valid Java package.")
         }
@@ -635,4 +665,14 @@ class CreateAppCommand extends ArgumentCompletingCommand implements ProfileRepos
 
         return v ? "${artifact.groupId}:${artifact.artifactId}:${v}" : "${artifact.groupId}:${artifact.artifactId}"
     }
+
+    static class CreateAppCommandObject {
+        String appName
+        File baseDir
+        String profileName
+        String grailsVersion
+        List<String> features
+        boolean inplace = false
+        GrailsConsole console
+    }
 }
diff --git a/grails-shell/src/main/groovy/org/grails/cli/profile/commands/CreatePluginCommand.groovy b/grails-shell/src/main/groovy/org/grails/cli/profile/commands/CreatePluginCommand.groovy
@@ -17,11 +17,8 @@
 package org.grails.cli.profile.commands
 
 import groovy.transform.CompileStatic
-import org.grails.build.parsing.CommandLine
 import org.grails.cli.profile.ExecutionContext
 import org.grails.cli.profile.Profile
-
-
 /**
  * A command for creating a plugin
  *
@@ -50,16 +47,14 @@ class CreatePluginCommand extends CreateAppCommand {
     @Override
     protected String getDefaultProfile() { "web-plugin" }
 
-    @Override
     protected boolean validateProfile(Profile profileInstance, String profileName, ExecutionContext executionContext) {
-
         def pluginProfile = profileInstance.extends.find() { Profile parent -> parent.name == 'plugin' }
         if(profileName != 'plugin' && pluginProfile == null) {
             executionContext.console.error("No valid plugin profile found for name [$profileName]")
             return false
         }
         else {
-            return super.validateProfile(profileInstance, profileName, executionContext)
+            return super.validateProfile(profileInstance, profileName)
         }
     }
 }
diff --git a/grails-shell/src/test/groovy/org/grails/cli/profile/commands/CreateAppCommandSpec.groovy b/grails-shell/src/test/groovy/org/grails/cli/profile/commands/CreateAppCommandSpec.groovy
@@ -1,14 +1,11 @@
 package org.grails.cli.profile.commands
 
 import grails.build.logging.GrailsConsole
-import org.grails.build.parsing.CommandLine
-import org.grails.build.parsing.DefaultCommandLine
 import org.grails.cli.profile.Feature
 import org.grails.cli.profile.Profile
 import org.spockframework.util.StringMessagePrintStream
 import spock.lang.Shared
 import spock.lang.Specification
-
 /**
  * Created by Jim on 7/18/2016.
  */
@@ -39,10 +36,9 @@ class CreateAppCommandSpec extends Specification {
             2 * getFeatures() >> [bar]
             1 * getRequiredFeatures() >> []
         }
-        CommandLine commandLine = new DefaultCommandLine().parseNew(["create-app", "foo", "-features=foo,bar"] as String[])
 
         when:
-        Iterable<Feature> features = new CreateAppCommand().evaluateFeatures(profile, commandLine)
+        Iterable<Feature> features = new CreateAppCommand().evaluateFeatures(profile, ['foo', 'bar'])
 
         then:
         features.size() == 1
@@ -63,10 +59,9 @@ class CreateAppCommandSpec extends Specification {
             2 * getFeatures() >> [foo, bar]
             1 * getRequiredFeatures() >> []
         }
-        CommandLine commandLine = new DefaultCommandLine().parseNew(["create-app", "foo", "-features=foo,bar"] as String[])
 
         when:
-        Iterable<Feature> features = new CreateAppCommand().evaluateFeatures(profile, commandLine)
+        Iterable<Feature> features = new CreateAppCommand().evaluateFeatures(profile, ['foo', 'bar'])
 
         then:
         features.size() == 2
@@ -85,11 +80,9 @@ class CreateAppCommandSpec extends Specification {
             2 * getFeatures() >> [bar]
             1 * getRequiredFeatures() >> []
         }
-        CommandLine commandLine = new DefaultCommandLine().parseNew(["create-app", "foo", "-features=mongo"] as String[])
 
         when:
-        Iterable<Feature> features = new CreateAppCommand().evaluateFeatures(profile, commandLine)
-
+        Iterable<Feature> features = new CreateAppCommand().evaluateFeatures(profile, ['mongo'])
 
         then:
         features.size() == 0
diff --git a/grails-test-suite-web/src/test/groovy/org/grails/web/taglib/SelectTagTests.groovy b/grails-test-suite-web/src/test/groovy/org/grails/web/taglib/SelectTagTests.groovy
@@ -22,6 +22,14 @@ class SelectTagTests extends AbstractGrailsTagTests {
         assertTrue "should have HTML escaped attributes", result.startsWith('<select id="bar&quot; /&gt;&lt;script&gt;alert(&quot;gotcha&quot;)&lt;/script&gt;.genre" name="bar&quot; /&gt;&lt;script&gt;alert(&quot;gotcha&quot;)&lt;/script&gt;.genre" >')
     }
 
+    void testSelectTagEscapingValue() {
+        def template = '<g:select id="genre" name="genre" from="${values}" />'
+        def result = applyTemplate(template, [values: ["\"></option></select><script>alert('hi')</script>"]])
+
+        println result
+        assertTrue "should have HTML escaped values", result.contains('<option value="&quot;&gt;&lt;/option&gt;&lt;/select&gt;&lt;script&gt;alert(&#39;hi&#39;)&lt;/script&gt;" >&quot;&gt;&lt;/option&gt;&lt;/select&gt;&lt;script&gt;alert(&#39;hi&#39;)&lt;/script&gt;</option>')
+    }
+
     void testSelectUsesExpressionForDisable() {
         def template = '<g:set var="flag" value="${true}"/><g:select disabled="${flag}" name="foo" id="foo" from="[1,2,3]" />'
         assertOutputContains('disabled="disabled"', template)
diff --git a/grails-validation/src/main/groovy/org/grails/validation/GrailsDomainClassValidator.java b/grails-validation/src/main/groovy/org/grails/validation/GrailsDomainClassValidator.java

Original file line number	Diff line number	Diff line change
`@@ -1071,7 +1071,7 @@ class FormTagLib implements ApplicationContextAware, InitializingBean, TagLibrar`
`1071`	`1071`	`}`
`1072`	`1072`	`}`
`1073`	`1073`	`keyValue = processFormFieldValueIfNecessary(selectName, "${keyValue}","option")`
`1074`		`- writer << "value=\"${keyValue}\" "`
	`1074`	`+ writer << "value=\"${keyValue.toString().encodeAsHTML()}\" "`
`1075`	`1075`
`1076`	`1076`	`if(dataAttrsMap) {`
`1077`	`1077`	`dataAttrsMap.each {key, val->`
Original file line number	Diff line number	Diff line change
`@@ -674,7 +674,7 @@ class GrailsCli {`
`674`	`674`	`@Canonical`
`675`	`675`	`public static class ExecutionContextImpl implements ExecutionContext {`
`676`	`676`	`CommandLine commandLine`
`677`		`- @Delegate(excludes = 'getConsole') ProjectContext projectContext`
	`677`	`+ @Delegate(excludes = ['getConsole', 'getBaseDir']) ProjectContext projectContext`
`678`	`678`	`GrailsConsole console = GrailsConsole.getInstance()`
`679`	`679`
`680`	`680`	`ExecutionContextImpl(CodeGenConfig config) {`
`@@ -706,6 +706,11 @@ class GrailsCli {`
`706`	`706`	`}`
`707`	`707`	`}`
`708`	`708`	`}`
	`709`	`+`
	`710`	`+ @Override`
	`711`	`+ File getBaseDir() {`
	`712`	`+ this.projectContext?.baseDir ?: new File(".")`
	`713`	`+ }`
`709`	`714`	`}`
`710`	`715`
`711`	`716`	`@Canonical`
Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,8 @@`
`17`	`17`	`package org.grails.cli.profile.commands`
`18`	`18`
`19`	`19`	`import groovy.transform.CompileStatic`
`20`		`-import org.grails.build.parsing.CommandLine`
`21`	`20`	`import org.grails.cli.profile.ExecutionContext`
`22`	`21`	`import org.grails.cli.profile.Profile`
`23`		`-`
`24`		`-`
`25`	`22`	`/**`
`26`	`23`	`* A command for creating a plugin`
`27`	`24`	`*`
`@@ -50,16 +47,14 @@ class CreatePluginCommand extends CreateAppCommand {`
`50`	`47`	`@Override`
`51`	`48`	`protected String getDefaultProfile() { "web-plugin" }`
`52`	`49`
`53`		`- @Override`
`54`	`50`	`protected boolean validateProfile(Profile profileInstance, String profileName, ExecutionContext executionContext) {`
`55`		`-`
`56`	`51`	`def pluginProfile = profileInstance.extends.find() { Profile parent -> parent.name == 'plugin' }`
`57`	`52`	`if(profileName != 'plugin' && pluginProfile == null) {`
`58`	`53`	`executionContext.console.error("No valid plugin profile found for name [$profileName]")`
`59`	`54`	`return false`
`60`	`55`	`}`
`61`	`56`	`else {`
`62`		`- return super.validateProfile(profileInstance, profileName, executionContext)`
	`57`	`+ return super.validateProfile(profileInstance, profileName)`
`63`	`58`	`}`
`64`	`59`	`}`
`65`	`60`	`}`