Remove duplicate documentation

Remove README files that have been since been migrated to the reference
documentation. Also updated remaining markdown files to asciidoctor to
save having a mix of different formats.

Fixed spring-projectsgh-503

Author: Phillip Webb

CONTRIBUTING.md CONTRIBUTING.adoc

@@ -1,58 +1,68 @@
-# Contributing to Spring Boot
+= Contributing to Spring Boot
 
 Spring Boot is released under the non-restrictive Apache 2.0 license. If you would like
 to contribute something, or simply want to hack on the code this document should help
 you get started.
 
-## Sign the Contributor License Agreement
-
+== Sign the Contributor License Agreement
 Before we accept a non-trivial patch or pull request we will need you to sign the
-[contributor's agreement](https://support.springsource.com/spring_committer_signup).
-Signing the contributor's agreement does not grant anyone commit rights to the main repository, but it does mean that we
-can accept your contributions, and you will get an author credit if we do.  Active contributors might be asked to join
-the core team, and given the ability to merge pull requests.
-
-## Code Conventions and Housekeeping
-
-None of these is essential for a pull request, but they will all help.  They can also be added after the original pull
-request but before a merge.
-
-* Use the Spring Framework code format conventions. Import `eclipse-code-formatter.xml` from the `eclipse` folder of the project
-  if you are using Eclipse. If using IntelliJ, copy `spring-intellij-code-style.xml` to `~/.IntelliJIdea*/config/codestyles`
-  and select spring-intellij-code-style from Settings -> Code Styles.
-* Make sure all new .java files to have a simple Javadoc class comment with at least an @author tag identifying you, and
-  preferably at least a paragraph on what the class is for.
-* Add the ASF license header comment to all new .java files (copy from existing files in the project)
-* Add yourself as an @author to the .java files that you modify substantially (more than cosmetic changes).
+https://support.springsource.com/spring_committer_signup[contributor's agreement].
+Signing the contributor's agreement does not grant anyone commit rights to the main
+repository, but it does mean that we can accept your contributions, and you will get an
+author credit if we do.  Active contributors might be asked to join the core team, and
+given the ability to merge pull requests.
+
+== Code Conventions and Housekeeping
+None of these is essential for a pull request, but they will all help.  They can also be
+added after the original pull request but before a merge.
+
+* Use the Spring Framework code format conventions. Import `eclipse-code-formatter.xml`
+  from the `eclipse` folder of the project if you are using Eclipse. If using IntelliJ,
+  copy `spring-intellij-code-style.xml` to `~/.IntelliJIdea*/config/codestyles` and select
+  spring-intellij-code-style from Settings -> Code Styles.
+* Make sure all new `.java` files to have a simple Javadoc class comment with at least an
+  `@author` tag identifying you, and preferably at least a paragraph on what the class is
+  for.
+* Add the ASF license header comment to all new `.java` files (copy from existing files
+  in the project)
+* Add yourself as an `@author` to the .java files that you modify substantially (more
+  than cosmetic changes).
 * Add some Javadocs and, if you change the namespace, some XSD doc elements.
-* A few unit tests would help a lot as well - someone has to do it.
-* If no-one else is using your branch, please rebase it against the current master (or other target branch in the main project).
+* A few unit tests would help a lot as well -- someone has to do it.
+* If no-one else is using your branch, please rebase it against the current master (or
+  other target branch in the main project).
 
-## Working with the code
+== Working with the code
 If you don't have an IDE preference we would recommend that you use
-[Spring Tools Suite](http://www.springsource.com/developer/sts) or
-[Eclipse](http://eclipse.org) when working with the code. We use the
-[m2eclipe](http://eclipse.org/m2e/) eclipse plugin for maven support. Other IDEs
-and tools should also work without issue.
+http://www.springsource.com/developer/sts[Spring Tools Suite] or
+http://eclipse.org[Eclipse] when working with the code. We use the
+http://eclipse.org/m2e/[m2eclipe] eclipse plugin for maven support. Other IDEs and tools
+should also work without issue.
 
-### Building from source
+=== Building from source
 To build the source you will need to install
-[Apache Maven](http://maven.apache.org/run-maven/index.html) v3.0 or above.
+http://maven.apache.org/run-maven/index.html[Apache Maven] v3.0 or above.
 
-#### Default build
+==== Default build
 The project can be built from the root directory using the standard maven command:
 
+[indent=0]
+----
 	$ mvn clean install
+----
 
-> **NOTE:** You may need to increase the amount of memory available to Maven by setting
-> a `MAVEN_OPTS` environment variable with the value `-Xmx512m -XX:MaxPermSize=128m`
+NOTE: You may need to increase the amount of memory available to Maven by setting
+a `MAVEN_OPTS` environment variable with the value `-Xmx512m -XX:MaxPermSize=128m`
 
 If you are rebuilding often, you might also want to skip the tests until you are ready
 to submit a pull request:
 
+[indent=0]
+----
 	$ mvn clean install -DskipTests
+----
 
-#### Full Build
+==== Full Build
 Multi-module Maven builds cannot directly include maven plugins that are part of the
 reactor unless they have previously been built. Unfortunately this restriction causes
 some compilations for Spring Boot as we include a maven plugin and use it within the
@@ -71,24 +81,30 @@ can be referenced during the full build. It also generates a `settings.xml` file
 enables a `snapshot`, `milestone` or `release` profiles based on the version being
 build. To prepare the build, from the root directory use:
 
+[indent=0]
+----
 	$ mvn -P snapshot,prepare install
+----
 
-> **NOTE:** You may notice that preparing the build also changes the
-> `spring-boot-starter-parent` POM. This is required for our release process to work
-> correctly.
+NOTE: You may notice that preparing the build also changes the
+`spring-boot-starter-parent` POM. This is required for our release process to work
+correctly.
 
 2) Run the full build
 
 Once the build has been prepared, you can run a full build using the following commands:
 
+[indent=0]
+----
 	$ cd spring-boot-full-build
 	$ mvn -s ../settings.xml -P full clean install
+----
 
 We generate more artifacts when running the full build (such as Javadoc jars), so you
 may find the process a little slower than the standard build.
 
-### Importing into eclipse with m2eclipse
-We recommend the [m2eclipe](http://eclipse.org/m2e/) eclipse plugin when working with
+=== Importing into eclipse with m2eclipse
+We recommend the http://eclipse.org/m2e/[m2eclipe] eclipse plugin when working with
 eclipse. If you don't already have m2eclipse installed it is available from the "eclipse
 marketplace".
 
@@ -98,30 +114,33 @@ work with m2eclipse, we provide an additional eclipse plugin that you can instal
 * Select `Install new software` from the `help` menu
 * Click `Add...` to add a new repository
 * Click the `Archive...` button
-* Select `org.eclipse.m2e.maveneclipse.site-0.0.1-SNAPSHOT-site.zip`
-  from the `eclipse` folder in this checkout
+* Select `org.eclipse.m2e.maveneclipse.site-0.0.1-SNAPSHOT-site.zip` from the `eclipse`
+  folder in this checkout
 * Install "Maven Integration for the maven-eclipse-plugin"
 
-_NOTE: This plugin is optional. Projects can be imported without the plugin, your code
+NOTE: This plugin is optional. Projects can be imported without the plugin, your code
 changes just won't be automatically formatted._
 
 With the requisite eclipse plugins installed you can select
 `import existing maven projects` from the `file` menu to import the code. You will
 need to import the root `spring-boot` pom and the `spring-boot-samples` pom separately.
 
-### Importing into eclipse without m2eclipse
+=== Importing into eclipse without m2eclipse
 If you prefer not to use m2eclipse you can generate eclipse project meta-data using the
 following command:
 
+[indent=0]
+----
 	$ mvn eclipse:eclipse
+----
 
 The generated eclipse projects can be imported by selecting `import existing projects`
 from the `file` menu.
 
-### Importing into other IDEs
+=== Importing into other IDEs
 Maven is well supported by most Java IDEs. Refer to you vendor documentation.
 
-### Integration tests
+== Integration tests
 The sample application are used as integration tests during the build (when you
 `mvn install`). Due to the fact that they make use of the `spring-boot-maven-plugin`
 they cannot be called directly, and so instead are launched via the

README.adoc

@@ -0,0 +1,214 @@
+= Spring Boot image:https://travis-ci.org/spring-projects/spring-boot.png?branch=master["Build Status", link="https://travis-ci.org/spring-projects/spring-boot"]
+:docs: http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference
+
+Spring Boot makes it easy to create Spring-powered, production-grade applications and
+services with absolute minimum fuss. It takes an opinionated view of the Spring platform
+so that new and existing users can quickly get to the bits they need.
+
+You can use Spring Boot to create stand-alone Java applications that can be started using
+`java -jar` or more traditional WAR deployments. We also provide a command line tool
+that runs spring scripts.
+
+Our primary goals are:
+
+* Provide a radically faster and widely accessible getting started experience for all
+Spring development
+* Be opinionated out of the box, but get out of the way quickly as requirements start to
+diverge from the defaults
+* Provide a range of non-functional features that are common to large classes of projects
+(e.g. embedded servers, security, metrics, health checks, externalized configuration)
+* Absolutely no code generation and no requirement for XML configuration
+
+
+
+== Installation and Getting Started
+The {docs}/htmlsingle/[reference documentation] includes detailed
+{docs}/htmlsingle/#getting-started-installing-spring-boot[installation instructions]
+as well as a comprehensive {docs}/htmlsingle/#getting-started-first-application[``getting
+started''] guide. Documentation is published in {docs}/htmlsingle/[HTML],
+{docs}/pdf/spring-boot-reference.pdf[PDF] and {docs}/epub/spring-boot-reference.epub[EPUB]
+formats.
+
+Here is a quick teaser of a Spring Boot application:
+
+[source,java,indent=0]
+----
+	import org.springframework.boot.*;
+	import org.springframework.boot.autoconfigure.*;
+	import org.springframework.stereotype.*;
+	import org.springframework.web.bind.annotation.*;
+
+	@Controller
+	@EnableAutoConfiguration
+	public class Example {
+
+		@RequestMapping("/")
+		@ResponseBody
+		String home() {
+			return "Hello World!";
+		}
+
+		public static void main(String[] args) throws Exception {
+			SpringApplication.run(Example.class, args);
+		}
+
+	}
+----
+
+
+
+== Getting help
+Having trouble with Spring Boot, We'd like to help!
+
+* Check the {docs}/htmlsingle/[reference documentation], especially the
+  {docs}/htmlsingle/#howto[How-to's] -- they provide solutions to the most common
+  questions.
+* Learn the Spring basics -- Spring Boot is builds on many other Spring projects, check
+  the http://spring.io[spring.io] web-site for a wealth of reference documentation. If
+  you are just starting out with Spring, try one of the http://spring.io/guides[guides].
+* Ask a questions - we monitor http://stackoverflow.com[stackoverflow.com] for questions
+  tagged with http://stackoverflow.com/tags/spring-boot[`spring-boot`].
+* Report bugs with Spring Boot at https://github.com/spring-projects/spring-boot/issues.
+
+
+
+== Building from Source
+You don't need to build from source to use Spring Boot (binaries in
+http://repo.spring.io[repo.spring.io], but if you want to try out the latest and greatest,
+Spring Boot can be http://maven.apache.org/run-maven/index.html[built with maven]
+v3.0.5 or above.
+
+[indent=0]
+----
+	$ mvn clean install
+----
+
+NOTE: You may need to increase the amount of memory available to Maven by setting
+a `MAVEN_OPTS` environment variable with the value `-Xmx512m -XX:MaxPermSize=128m`
+
+_Also see link:CONTRIBUTING.adoc[CONTRIBUTING.adoc] if you wish to submit pull requests,
+and in particular please fill out the
+https://support.springsource.com/spring_committer_signup[Contributor's Agreement]
+before your first change however trivial. (Or if you filed such an agreement already for
+another project just mention that in your pull request.)_
+
+
+
+== Modules
+There are a number of modules in Spring Boot, here is a quick overview:
+
+
+
+=== spring-boot
+The main library providing features that support the other parts of Spring Boot,
+these include:
+
+* The `SpringApplication` class, providing static convenience methods that make it easy
+to write a stand-alone Spring Application. Its sole job is to create and refresh an
+appropriate Spring `ApplicationContext`
+* Embedded web applications with a choice of container (Tomcat or Jetty for now)
+* First class externalized configuration support
+* Convenience `ApplicationContext` initializers, including support for sensible logging
+defaults
+
+
+
+=== spring-boot-autoconfigure
+Spring Boot can configure large parts of common applications based on the content
+of their classpath. A single `@EnableAutoConfiguration` annotation triggers
+auto-configuration of the Spring context.
+
+Auto-configuration attempts to deduce which beans a user might need. For example, If
+`HSQLDB` is on the classpath, and the user has not configured any database connections,
+then they probably want an in-memory database to be defined. Auto-configuration will
+always back away as the user starts to define their own beans.
+
+
+
+=== spring-boot-starters
+Starters are a set of convenient dependency descriptors that you can include in
+your application. You get a one-stop-shop for all the Spring and related technology
+that you need without having to hunt through sample code and copy paste loads of
+dependency descriptors. For example, if you want to get started using Spring and JPA for
+database access just include the `spring-boot-starter-data-jpa` dependency in your
+project, and you are good to go.
+
+
+
+=== spring-boot-cli
+The Spring command line application compiles and runs Groovy source, making it super
+easy to write the absolute minimum of code to get an application running. Spring CLI
+can also watch files, automatically recompiling and restarting when they change.
+
+
+
+=== spring-boot-actuator
+Spring Boot Actuator provides additional auto-configuration to decorate your application
+with features that make it instantly deployable and supportable in production.  For
+instance if you are writing a JSON web service then it will provide a server, security,
+logging, externalized configuration, management endpoints, an audit abstraction, and
+more. If you want to switch off the built in features, or extend or replace them, it
+makes that really easy as well.
+
+
+
+=== spring-boot-loader
+Spring Boot Loader provides the secret sauce that allows you to build a single jar file
+that can be launched using `java -jar`. Generally you will not need to use
+`spring-boot-loader` directly, but instead work with the
+link:spring-boot-tools/spring-boot-gradle-plugin[Gradle] or
+link:spring-boot-tools/spring-boot-maven-plugin[Maven] plugin.
+
+
+
+== Samples
+Groovy samples for use with the command line application are available in
+link:spring-boot-cli/samples[spring-boot-cli/samples]. To run the CLI samples type
+`spring run <sample>.groovy` from samples directory.
+
+Java samples are available in link:spring-boot-samples[spring-boot-samples] and should
+be built with maven and run by invoking `java -jar target/<sample>.jar`. The following
+java samples are provided:
+
+* link:spring-boot-samples/spring-boot-sample-simple[spring-boot-sample-simple]
+  -- A simple command line application
+* link:spring-boot-samples/spring-boot-sample-tomcat[spring-boot-sample-tomcat]
+  --  Embedded Tomcat
+* link:spring-boot-samples/spring-boot-sample-jetty[spring-boot-sample-jetty]
+  -- Embedded Jetty
+* link:spring-boot-samples/spring-boot-sample-actuator[spring-boot-sample-actuator]
+  -- Simple REST service with production features
+* link:spring-boot-samples/spring-boot-sample-actuator-ui[spring-boot-sample-actuator-ui]
+  -- A web UI example with production features
+* link:spring-boot-samples/spring-boot-sample-web-ui[spring-boot-sample-web-ui]
+  -- A thymeleaf web application
+* link:spring-boot-samples/spring-boot-sample-web-static[spring-boot-sample-web-static]
+  -- A web application service static files
+* link:spring-boot-samples/spring-boot-sample-batch[spring-boot-sample-batch]
+  -- Define and run a Batch job in a few lines of code
+* link:spring-boot-samples/spring-boot-sample-data-jpa[spring-boot-sample-data-jpa]
+  -- Spring Data JPA + Hibernate + HSQLDB
+* link:spring-boot-samples/spring-boot-sample-integration[spring-boot-sample-integration]
+  -- A spring integration application
+* link:spring-boot-samples/spring-boot-sample-profile[spring-boot-sample-profile]
+  -- example showing Spring's `@profile` support
+* link:spring-boot-samples/spring-boot-sample-traditional[spring-boot-sample-traditional]
+  -- shows more traditional WAR packaging  (but also executable using `java -jar`)
+* link:spring-boot-samples/spring-boot-sample-xml[spring-boot-sample-xml]
+  -- Example show how Spring Boot can be mixed with traditional XML configuration (we
+  generally recommend using Java `@Configuration` whenever possible)
+
+
+
+== Guides
+The http://spring.io/[spring.io] site contains several guides that show how to use Spring
+Boot step-by-step:
+
+* http://spring.io/guides/gs/spring-boot/[Building an Application with Spring Boot] is a
+  very basic guide that shows you how to create a simple application, run it and add some
+  management services.
+* http://spring.io/guides/gs/actuator-service/[Building a RESTful Web Service with Spring
+  Boot Actuator] is a guide to creating a REST web service and also shows how the server
+  can be configured.
+* http://spring.io/guides/gs/convert-jar-to-war/[Converting a Spring Boot JAR Application
+  to a WAR] shows you how to run applications in a web server as a WAR file.