Removed old show instances, renamed some files Philippus#1279

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/ExistsApi.scala

@@ -1,7 +1,7 @@
 package com.sksamuel.elastic4s
 
 trait ExistsApi {
-  def exists(id: String, index: Index, `type`: String): ExistsDefinition = ExistsDefinition(id, index, `type`)
+  def exists(id: String, index: Index, `type`: String): ExistsRequest = ExistsRequest(id, index, `type`)
 }
 
-case class ExistsDefinition(id: String, index: Index, `type`: String)
+case class ExistsRequest(id: String, index: Index, `type`: String)

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/CreateIndex.scala

@@ -7,20 +7,20 @@ import com.sksamuel.exts.OptionImplicits._
 
 import scala.concurrent.duration._
 
-case class IndexAliasDefinition(name: String, filter: Option[Query] = None, routing: Option[String] = None)
+case class IndexAliasRequest(name: String, filter: Option[Query] = None, routing: Option[String] = None)
 
 case class CreateIndexRequest(name: String,
                               analysis: Option[AnalysisDefinition] = None,
                               mappings: Seq[MappingDefinition] = Nil,
                               rawSource: Option[String] = None,
                               waitForActiveShards: Option[Int] = None,
-                              aliases: Set[IndexAliasDefinition] = Set.empty,
+                              aliases: Set[IndexAliasRequest] = Set.empty,
                               settings: IndexSettings = new IndexSettings) {
 
-  def alias(name: String): CreateIndexRequest = alias(IndexAliasDefinition(name, None))
+  def alias(name: String): CreateIndexRequest = alias(IndexAliasRequest(name, None))
   def alias(name: String, filter: Query): CreateIndexRequest =
-    alias(IndexAliasDefinition(name, Option(filter)))
-  def alias(definition: IndexAliasDefinition): CreateIndexRequest = copy(aliases = aliases + definition)
+    alias(IndexAliasRequest(name, Option(filter)))
+  def alias(definition: IndexAliasRequest): CreateIndexRequest = copy(aliases = aliases + definition)
 
   def singleShard(): CreateIndexRequest   = shards(1)
   def singleReplica(): CreateIndexRequest = replicas(1)

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/CreateIndexTemplateRequest.scala

@@ -10,7 +10,7 @@ case class TemplateAlias(name: String, filter: Option[Query] = None, routing: Op
   def routing(routing: String): TemplateAlias = copy(routing = routing.some)
 }
 
-case class IndexTemplateExistsDefinition()
+case class IndexTemplateExistsRequest()
 
 case class CreateIndexTemplateRequest(name: String,
                                       pattern: String,

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/DeleteIndexApi.scala

@@ -1,6 +1,6 @@
 package com.sksamuel.elastic4s.indexes
 
 trait DeleteIndexApi {
-  def deleteIndex(indexes: String*): DeleteIndex          = deleteIndex(indexes)
-  def deleteIndex(indexes: Iterable[String]): DeleteIndex = DeleteIndex(indexes.toSeq)
+  def deleteIndex(indexes: String*): DeleteIndexRequest          = deleteIndex(indexes)
+  def deleteIndex(indexes: Iterable[String]): DeleteIndexRequest = DeleteIndexRequest(indexes.toSeq)
 }

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/DeleteIndexRequest.scala

@@ -0,0 +1,3 @@
+package com.sksamuel.elastic4s.indexes
+
+case class DeleteIndexRequest(indexes: Seq[String])

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/GetIndexRequest.scala

@@ -0,0 +1,3 @@
+package com.sksamuel.elastic4s.indexes
+
+case class GetIndexRequest(index: String)

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/IndexApi.scala

@@ -14,6 +14,6 @@ trait IndexApi {
 
   def index(kv: (String, String)): IndexRequest = IndexRequest(IndexAndType(kv._1, kv._2))
 
-  def getIndex(index: String, others: String*): GetIndex = getIndex(index +: others)
-  def getIndex(indexes: Seq[String]): GetIndex           = GetIndex(indexes.mkString(","))
+  def getIndex(index: String, others: String*): GetIndexRequest = getIndex(index +: others)
+  def getIndex(indexes: Seq[String]): GetIndexRequest           = GetIndexRequest(indexes.mkString(","))
 }

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/PutMappingBuilderFn.scala

@@ -1,11 +1,11 @@
 package com.sksamuel.elastic4s.indexes
 
 import com.sksamuel.elastic4s.json.{XContentBuilder, XContentFactory}
-import com.sksamuel.elastic4s.mappings.{MappingBuilderFn, PutMappingDefinition}
+import com.sksamuel.elastic4s.mappings.{MappingBuilderFn, PutMappingRequest}
 
 object PutMappingBuilderFn {
 
-  def apply(pm: PutMappingDefinition): XContentBuilder =
+  def apply(pm: PutMappingRequest): XContentBuilder =
     pm.rawSource match {
       case None         => MappingBuilderFn.build(pm)
       case Some(source) => XContentFactory.parse(source)

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/admin/ForceMergeApi.scala

@@ -4,6 +4,6 @@ import scala.language.implicitConversions
 
 trait ForceMergeApi {
 
-  def forceMerge(first: String, rest: String*): ForceMergeDefinition = forceMerge(first +: rest)
-  def forceMerge(indexes: Iterable[String]): ForceMergeDefinition    = ForceMergeDefinition(indexes.toSeq)
+  def forceMerge(first: String, rest: String*): ForceMergeRequest = forceMerge(first +: rest)
+  def forceMerge(indexes: Iterable[String]): ForceMergeRequest    = ForceMergeRequest(indexes.toSeq)
 }

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/admin/ForceMergeRequest.scala

@@ -0,0 +1,18 @@
+package com.sksamuel.elastic4s.indexes.admin
+
+import com.sksamuel.exts.OptionImplicits._
+
+case class ForceMergeRequest(indexes: Seq[String],
+                             flush: Option[Boolean] = None,
+                             maxSegments: Option[Int] = None,
+                             onlyExpungeDeletes: Option[Boolean] = None) {
+
+  def flush(flush: Boolean): ForceMergeRequest         = copy(flush = flush.some)
+  def maxSegments(maxSegments: Int): ForceMergeRequest = copy(maxSegments = maxSegments.some)
+
+  /**
+    * Should the optimization only expunge deletes from the index, without full optimization.
+    * Defaults to full optimization (<tt>false</tt>).
+    */
+  def onlyExpungeDeletes(expunge: Boolean): ForceMergeRequest = copy(onlyExpungeDeletes = expunge.some)
+}

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/indexes/admin/IndexRecoveryApi.scala

@@ -3,13 +3,13 @@ package com.sksamuel.elastic4s.indexes.admin
 import com.sksamuel.exts.OptionImplicits._
 
 trait IndexRecoveryApi {
-  def recoverIndex(first: String, rest: String*): IndexRecoveryDefinition = recoverIndex(first +: rest)
-  def recoverIndex(indexes: Iterable[String]): IndexRecoveryDefinition    = IndexRecoveryDefinition(indexes.toSeq)
+  def recoverIndex(first: String, rest: String*): IndexRecoveryRequest = recoverIndex(first +: rest)
+  def recoverIndex(indexes: Iterable[String]): IndexRecoveryRequest    = IndexRecoveryRequest(indexes.toSeq)
 }
 
-case class IndexRecoveryDefinition(indices: Seq[String],
-                                   activeOnly: Option[Boolean] = None,
-                                   detailed: Option[Boolean] = None) {
-  def activeOnly(boolean: Boolean): IndexRecoveryDefinition = copy(activeOnly = boolean.some)
-  def detailed(boolean: Boolean): IndexRecoveryDefinition   = copy(detailed = boolean.some)
+case class IndexRecoveryRequest(indices: Seq[String],
+                                activeOnly: Option[Boolean] = None,
+                                detailed: Option[Boolean] = None) {
+  def activeOnly(boolean: Boolean): IndexRecoveryRequest = copy(activeOnly = boolean.some)
+  def detailed(boolean: Boolean): IndexRecoveryRequest   = copy(detailed = boolean.some)
 }

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/mappings/CommonFieldBuilder.scala

@@ -17,8 +17,8 @@ object CommonFieldBuilder {
 
     if (field.fields.nonEmpty) {
       field match {
-        case _: NestedFieldDefinition => builder.startObject("properties")
-        case _: ObjectFieldDefinition => builder.startObject("properties")
+        case _: NestedField => builder.startObject("properties")
+        case _: ObjectField => builder.startObject("properties")
         case _                        => builder.startObject("fields")
       }
       field.fields.foreach { subfield =>
@@ -53,7 +53,7 @@ object FieldBuilderFn {
   def apply(field: FieldDefinition): XContentBuilder = {
     val builder = CommonFieldBuilder(field)
     field match {
-      case basic: BasicFieldDefinition =>
+      case basic: BasicField =>
         basic.ignoreAbove.foreach(builder.field("ignore_above", _))
         basic.ignoreMalformed.foreach(builder.field("ignore_malformed", _))
         basic.indexOptions.foreach(builder.field("index_options", _))
@@ -62,7 +62,7 @@ object FieldBuilderFn {
         basic.format.foreach(builder.field("format", _))
         basic.similarity.foreach(builder.field("similarity", _))
 
-      case comp: CompletionFieldDefinition =>
+      case comp: CompletionField =>
         comp.preservePositionIncrements.foreach(builder.field("preserve_position_increments", _))
         comp.preserveSeparators.foreach(builder.field("preserve_separators", _))
         comp.ignores.ignoreAbove.foreach(builder.field("ignore_above", _))
@@ -83,7 +83,7 @@ object FieldBuilderFn {
           builder.endArray()
         }
 
-      case geo: GeoshapeFieldDefinition =>
+      case geo: GeoshapeField =>
         geo.geoFields.tree.foreach(builder.field("tree", _))
         geo.geoFields.precision.foreach(builder.field("precision", _))
         geo.geoFields.treeLevels.foreach(builder.field("tree_levels", _))
@@ -95,35 +95,35 @@ object FieldBuilderFn {
         geo.format.foreach(builder.field("format", _))
         geo.ignoreMalformed.foreach(builder.field("ignore_malformed", _))
 
-      case join: JoinFieldDefinition =>
+      case join: JoinField =>
         builder.startObject("relations")
         join.relations.foreach {
           case (parent, child) =>
             builder.field(parent, child)
         }
         builder.endObject()
 
-      case obj: ObjectFieldDefinition =>
+      case obj: ObjectField =>
         obj.dynamic.foreach(builder.field("dynamic", _))
 
-      case nested: NestedFieldDefinition =>
+      case nested: NestedField =>
         nested.dynamic.foreach(builder.field("dynamic", _))
 
-      case text: TextFieldDefinition =>
+      case text: TextField =>
         text.eagerGlobalOrdinals.foreach(builder.field("eager_global_ordinals", _))
         text.positionIncrementGap.foreach(builder.field("position_increment_gap", _))
         text.fielddata.foreach(builder.field("fielddata", _))
         text.maxInputLength.foreach(builder.field("max_input_length", _))
         text.ignoreAbove.foreach(builder.field("ignore_above", _))
         text.similarity.foreach(builder.field("similarity", _))
 
-      case keyword: KeywordFieldDefinition =>
+      case keyword: KeywordField =>
         keyword.eagerGlobalOrdinals.foreach(builder.field("eager_global_ordinals", _))
         keyword.ignoreAbove.foreach(builder.field("ignore_above", _))
         keyword.similarity.foreach(builder.field("similarity", _))
         keyword.indexOptions.foreach(builder.field("index_options", _))
 
-      case range: RangeFieldDefinition =>
+      case range: RangeField =>
         range.ignoreAbove.foreach(builder.field("ignore_above", _))
         range.ignoreMalformed.foreach(builder.field("ignore_malformed", _))
         range.indexOptions.foreach(builder.field("index_options", _))

elastic4s-core/src/main/scala/com/sksamuel/elastic4s/mappings/CompletionFieldDefinition.scala → elastic4s-core/src/main/scala/com/sksamuel/elastic4s/mappings/CompletionField.scala

@@ -10,31 +10,31 @@ case class Ignores(ignoreAbove: Option[Int] = None, ignoreMalformed: Option[Bool
 
 case class Nulls(nullable: Option[Boolean] = None, nullValue: Option[Any] = None)
 
-case class CompletionFieldDefinition(name: String,
-                                     analysis: Analysis = Analysis(),
-                                     boost: Option[Double] = None,
-                                     coerce: Option[Boolean] = None,
-                                     copyTo: Seq[String] = Nil,
-                                     docValues: Option[Boolean] = None,
-                                     enabled: Option[Boolean] = None,
-                                     fields: Seq[FieldDefinition] = Nil,
-                                     fielddataFrequencyFilter: Option[FielddataFrequencyFilter] = None,
-                                     includeInAll: Option[Boolean] = None,
-                                     ignores: Ignores = Ignores(),
-                                     index: Option[String] = None,
-                                     indexOptions: Option[String] = None,
-                                     maxInputLength: Option[Int] = None,
-                                     norms: Option[Boolean] = None,
-                                     nulls: Nulls = Nulls(),
-                                     preserveSeparators: Option[Boolean] = None,
-                                     preservePositionIncrements: Option[Boolean] = None,
-                                     similarity: Option[String] = None,
-                                     store: Option[Boolean] = None,
-                                     termVector: Option[String] = None,
-                                     contexts: Seq[ContextField] = Nil)
+case class CompletionField(name: String,
+                           analysis: Analysis = Analysis(),
+                           boost: Option[Double] = None,
+                           coerce: Option[Boolean] = None,
+                           copyTo: Seq[String] = Nil,
+                           docValues: Option[Boolean] = None,
+                           enabled: Option[Boolean] = None,
+                           fields: Seq[FieldDefinition] = Nil,
+                           fielddataFrequencyFilter: Option[FielddataFrequencyFilter] = None,
+                           includeInAll: Option[Boolean] = None,
+                           ignores: Ignores = Ignores(),
+                           index: Option[String] = None,
+                           indexOptions: Option[String] = None,
+                           maxInputLength: Option[Int] = None,
+                           norms: Option[Boolean] = None,
+                           nulls: Nulls = Nulls(),
+                           preserveSeparators: Option[Boolean] = None,
+                           preservePositionIncrements: Option[Boolean] = None,
+                           similarity: Option[String] = None,
+                           store: Option[Boolean] = None,
+                           termVector: Option[String] = None,
+                           contexts: Seq[ContextField] = Nil)
     extends FieldDefinition {
 
-  type T = CompletionFieldDefinition
+  type T = CompletionField
   override def `type` = "completion"
 
   override def analyzer(analyzer: String): T       = copy(analysis = analysis.copy(analyzer = analyzer.some))
@@ -72,8 +72,8 @@ case class CompletionFieldDefinition(name: String,
   def preservePositionIncrements(preserve: Boolean): T = copy(preservePositionIncrements = preserve.some)
   def maxInputLength(maxInputLength: Int): T           = copy(maxInputLength = maxInputLength.some)
 
-  def contexts(first: ContextField, rest: ContextField*): CompletionFieldDefinition = contexts(first +: rest)
-  def contexts(contexts: Iterable[ContextField]): CompletionFieldDefinition         = copy(contexts = this.contexts ++ contexts)
+  def contexts(first: ContextField, rest: ContextField*): CompletionField = contexts(first +: rest)
+  def contexts(contexts: Iterable[ContextField]): CompletionField         = copy(contexts = this.contexts ++ contexts)
 }
 
 case class ContextField(name: String, `type`: String, path: Option[String] = None, precision: Option[Int] = None) {