Fixed driver not passing golint

Author: dancannon

CHANGELOG.md

@@ -21,6 +21,8 @@ In an attempt to make this library more "idiomatic" some functions have been ren
  - Renamed `Js` to `JS`
  - Renamed `Json` to `JSON`
  - Renamed `Http` to `HTTP`
+ - Renamed `GeoJson` to `GeoJSON`
+ - Renamed `ToGeoJson` to `ToGeoJSON`
 
 ## v0.7.2 - 2015-05-05
 ### Added

query_geospatial.go

@@ -4,7 +4,7 @@ import (
 	p "github.com/dancannon/gorethink/ql2"
 )
 
-// CircleOpts describes the optional arguments for a Circle operation
+// CircleOpts contains the optional arguments for the Circle term.
 type CircleOpts struct {
 	NumVertices interface{} `gorethink:"num_vertices,omitempty"`
 	GeoSystem   interface{} `gorethink:"geo_system,omitempty"`
@@ -28,7 +28,7 @@ func Circle(point, radius interface{}, optArgs ...CircleOpts) Term {
 	return constructRootTerm("Circle", p.Term_CIRCLE, []interface{}{point, radius}, opts)
 }
 
-// DistanceOpts describes the optional arguments for a Distance operation
+// DistanceOpts contains the optional arguments for the Distance term.
 type DistanceOpts struct {
 	GeoSystem interface{} `gorethink:"geo_system,omitempty"`
 	Unit      interface{} `gorethink:"unit,omitempty"`
@@ -67,17 +67,17 @@ func (t Term) Fill() Term {
 	return constructMethodTerm(t, "Fill", p.Term_FILL, []interface{}{}, map[string]interface{}{})
 }
 
-// Geojson converts a GeoJSON object to a ReQL geometry object.
-func Geojson(args ...interface{}) Term {
-	return constructRootTerm("Geojson", p.Term_GEOJSON, args, map[string]interface{}{})
+// GeoJSON converts a GeoJSON object to a ReQL geometry object.
+func GeoJSON(args ...interface{}) Term {
+	return constructRootTerm("GeoJSON", p.Term_GEOJSON, args, map[string]interface{}{})
 }
 
-// ToGeojson converts a ReQL geometry object to a GeoJSON object.
-func (t Term) ToGeojson(args ...interface{}) Term {
-	return constructMethodTerm(t, "ToGeojson", p.Term_TO_GEOJSON, args, map[string]interface{}{})
+// ToGeoJSON converts a ReQL geometry object to a GeoJSON object.
+func (t Term) ToGeoJSON(args ...interface{}) Term {
+	return constructMethodTerm(t, "ToGeoJSON", p.Term_TO_GEOJSON, args, map[string]interface{}{})
 }
 
-// GetIntersectingOpts describes the optional arguments for a GetIntersecting operation
+// GetIntersectingOpts contains the optional arguments for the GetIntersecting term.
 type GetIntersectingOpts struct {
 	Index interface{} `gorethink:"index,omitempty"`
 }
@@ -97,7 +97,7 @@ func (t Term) GetIntersecting(args interface{}, optArgs ...GetIntersectingOpts)
 	return constructMethodTerm(t, "GetIntersecting", p.Term_GET_INTERSECTING, []interface{}{args}, opts)
 }
 
-// GetIntersectingOpts describes the optional arguments for a GetIntersecting operation
+// GetNearestOpts contains the optional arguments for the GetNearest term.
 type GetNearestOpts struct {
 	Index      interface{} `gorethink:"index,omitempty"`
 	MaxResults interface{} `gorethink:"max_results,omitempty"`

query_join.go

@@ -4,7 +4,7 @@ import (
 	p "github.com/dancannon/gorethink/ql2"
 )
 
-// Returns the inner product of two sequences (e.g. a table, a filter result)
+// InnerJoin returns the inner product of two sequences (e.g. a table, a filter result)
 // filtered by the predicate. The query compares each row of the left sequence
 // with each row of the right sequence to find all pairs of rows which satisfy
 // the predicate. When the predicate is satisfied, each matched pair of rows
@@ -13,12 +13,13 @@ func (t Term) InnerJoin(args ...interface{}) Term {
 	return constructMethodTerm(t, "InnerJoin", p.Term_INNER_JOIN, args, map[string]interface{}{})
 }
 
-// Computes a left outer join by retaining each row in the left table even if no
-// match was found in the right table.
+// OuterJoin computes a left outer join by retaining each row in the left table even
+// if no match was found in the right table.
 func (t Term) OuterJoin(args ...interface{}) Term {
 	return constructMethodTerm(t, "OuterJoin", p.Term_OUTER_JOIN, args, map[string]interface{}{})
 }
 
+// EqJoinOpts contains the optional arguments for the EqJoin term.
 type EqJoinOpts struct {
 	Index interface{} `gorethink:"index,omitempty"`
 }
@@ -27,7 +28,7 @@ func (o *EqJoinOpts) toMap() map[string]interface{} {
 	return optArgsToMap(o)
 }
 
-// An efficient join that looks up elements in the right table by primary key.
+// EqJoin is an efficient join that looks up elements in the right table by primary key.
 //
 // Optional arguments: "index" (string - name of the index to use in right table instead of the primary key)
 func (t Term) EqJoin(left, right interface{}, optArgs ...EqJoinOpts) Term {
@@ -38,7 +39,7 @@ func (t Term) EqJoin(left, right interface{}, optArgs ...EqJoinOpts) Term {
 	return constructMethodTerm(t, "EqJoin", p.Term_EQ_JOIN, []interface{}{funcWrap(left), right}, opts)
 }
 
-// Used to 'zip' up the result of a join by merging the 'right' fields into 'left'
+// Zip is used to 'zip' up the result of a join by merging the 'right' fields into 'left'
 // fields of each member of the sequence.
 func (t Term) Zip(args ...interface{}) Term {
 	return constructMethodTerm(t, "Zip", p.Term_ZIP, args, map[string]interface{}{})

query_manipulation.go

@@ -4,108 +4,110 @@ import (
 	p "github.com/dancannon/gorethink/ql2"
 )
 
-// Returns the currently visited document.
+// Row returns the currently visited document.
 var Row = constructRootTerm("Doc", p.Term_IMPLICIT_VAR, []interface{}{}, map[string]interface{}{})
 
+// Literal replaces an object in a field instead of merging it with an existing
+// object in a merge or update operation.
 func Literal(args ...interface{}) Term {
 	return constructRootTerm("Literal", p.Term_LITERAL, args, map[string]interface{}{})
 }
 
-// Get a single field from an object. If called on a sequence, gets that field
+// Field gets a single field from an object. If called on a sequence, gets that field
 // from every object in the sequence, skipping objects that lack it.
 func (t Term) Field(args ...interface{}) Term {
 	return constructMethodTerm(t, "Field", p.Term_GET_FIELD, args, map[string]interface{}{})
 }
 
-// Test if an object has all of the specified fields. An object has a field if
+// HasFields tests if an object has all of the specified fields. An object has a field if
 // it has the specified key and that key maps to a non-null value. For instance,
 //  the object `{'a':1,'b':2,'c':null}` has the fields `a` and `b`.
 func (t Term) HasFields(args ...interface{}) Term {
 	return constructMethodTerm(t, "HasFields", p.Term_HAS_FIELDS, args, map[string]interface{}{})
 }
 
-// Plucks out one or more attributes from either an object or a sequence of
+// Pluck plucks out one or more attributes from either an object or a sequence of
 // objects (projection).
 func (t Term) Pluck(args ...interface{}) Term {
 	return constructMethodTerm(t, "Pluck", p.Term_PLUCK, args, map[string]interface{}{})
 }
 
-// The opposite of pluck; takes an object or a sequence of objects, and returns
+// Without is the opposite of pluck; takes an object or a sequence of objects, and returns
 // them with the specified paths removed.
 func (t Term) Without(args ...interface{}) Term {
 	return constructMethodTerm(t, "Without", p.Term_WITHOUT, args, map[string]interface{}{})
 }
 
-// Merge two objects together to construct a new object with properties from both.
+// Merge merges two objects together to construct a new object with properties from both.
 // Gives preference to attributes from other when there is a conflict.
 func (t Term) Merge(args ...interface{}) Term {
 	return constructMethodTerm(t, "Merge", p.Term_MERGE, funcWrapArgs(args), map[string]interface{}{})
 }
 
-// Append a value to an array.
+// Append appends a value to an array.
 func (t Term) Append(args ...interface{}) Term {
 	return constructMethodTerm(t, "Append", p.Term_APPEND, args, map[string]interface{}{})
 }
 
-// Prepend a value to an array.
+// Prepend prepends a value to an array.
 func (t Term) Prepend(args ...interface{}) Term {
 	return constructMethodTerm(t, "Prepend", p.Term_PREPEND, args, map[string]interface{}{})
 }
 
-// Remove the elements of one array from another array.
+// Difference removes the elements of one array from another array.
 func (t Term) Difference(args ...interface{}) Term {
 	return constructMethodTerm(t, "Difference", p.Term_DIFFERENCE, args, map[string]interface{}{})
 }
 
-// Add a value to an array and return it as a set (an array with distinct values).
+// SetInsert adds a value to an array and return it as a set (an array with distinct values).
 func (t Term) SetInsert(args ...interface{}) Term {
 	return constructMethodTerm(t, "SetInsert", p.Term_SET_INSERT, args, map[string]interface{}{})
 }
 
-// Add a several values to an array and return it as a set (an array with
+// SetUnion adds several values to an array and return it as a set (an array with
 // distinct values).
 func (t Term) SetUnion(args ...interface{}) Term {
 	return constructMethodTerm(t, "SetUnion", p.Term_SET_UNION, args, map[string]interface{}{})
 }
 
-// Intersect two arrays returning values that occur in both of them as a set (an
-// array with distinct values).
+// SetIntersection calculates the intersection of two arrays returning values that
+// occur in both of them as a set (an array with distinct values).
 func (t Term) SetIntersection(args ...interface{}) Term {
 	return constructMethodTerm(t, "SetIntersection", p.Term_SET_INTERSECTION, args, map[string]interface{}{})
 }
 
-// Remove the elements of one array from another and return them as a set (an
+// SetDifference removes the elements of one array from another and return them as a set (an
 // array with distinct values).
 func (t Term) SetDifference(args ...interface{}) Term {
 	return constructMethodTerm(t, "SetDifference", p.Term_SET_DIFFERENCE, args, map[string]interface{}{})
 }
 
-// Insert a value in to an array at a given index. Returns the modified array.
+// InsertAt inserts a value in to an array at a given index. Returns the modified array.
 func (t Term) InsertAt(args ...interface{}) Term {
 	return constructMethodTerm(t, "InsertAt", p.Term_INSERT_AT, args, map[string]interface{}{})
 }
 
-// Insert several values in to an array at a given index. Returns the modified array.
+// SpliceAt inserts several values in to an array at a given index. Returns the modified array.
 func (t Term) SpliceAt(args ...interface{}) Term {
 	return constructMethodTerm(t, "SpliceAt", p.Term_SPLICE_AT, args, map[string]interface{}{})
 }
 
-// Remove an element from an array at a given index. Returns the modified array.
+// DeleteAt removes an element from an array at a given index. Returns the modified array.
 func (t Term) DeleteAt(args ...interface{}) Term {
 	return constructMethodTerm(t, "DeleteAt", p.Term_DELETE_AT, args, map[string]interface{}{})
 }
 
-// Change a value in an array at a given index. Returns the modified array.
+// ChangeAt changes a value in an array at a given index. Returns the modified array.
 func (t Term) ChangeAt(args ...interface{}) Term {
 	return constructMethodTerm(t, "ChangeAt", p.Term_CHANGE_AT, args, map[string]interface{}{})
 }
 
-// Return an array containing all of the object's keys.
+// Keys returns an array containing all of the object's keys.
 func (t Term) Keys(args ...interface{}) Term {
 	return constructMethodTerm(t, "Keys", p.Term_KEYS, args, map[string]interface{}{})
 }
 
-// Creates an object from a list of key-value pairs, where the keys must be strings.
+// Object creates an object from a list of key-value pairs, where the keys must be strings.
 func Object(args ...interface{}) Term {
 	return constructRootTerm("Object", p.Term_OBJECT, args, map[string]interface{}{})
 }

query_math.go

@@ -151,6 +151,7 @@ func Not(args ...interface{}) Term {
 	return constructRootTerm("Not", p.Term_NOT, args, map[string]interface{}{})
 }
 
+// RandomOpts contains the optional arguments for the Random term.
 type RandomOpts struct {
 	Float interface{} `gorethink:"float,omitempty"`
 }
@@ -159,8 +160,8 @@ func (o *RandomOpts) toMap() map[string]interface{} {
 	return optArgsToMap(o)
 }
 
-// Generate a random number between the given bounds. If no arguments are
-// given, the result will be a floating-point number in the range [0,1).
+// Random generates a random number between the given bounds. If no arguments
+// are given, the result will be a floating-point number in the range [0,1).
 //
 // When passing a single argument, r.random(x), the result will be in the
 // range [0,x), and when passing two arguments, r.random(x,y), the range is

query_select.go

@@ -9,6 +9,7 @@ func DB(args ...interface{}) Term {
 	return constructRootTerm("DB", p.Term_DB, args, map[string]interface{}{})
 }
 
+// TableOpts contains the optional arguments for the Table term
 type TableOpts struct {
 	UseOutdated      interface{} `gorethink:"use_outdated,omitempty"`
 	IdentifierFormat interface{} `gorethink:"identifier_format,omitempty"`
@@ -18,11 +19,16 @@ func (o *TableOpts) toMap() map[string]interface{} {
 	return optArgsToMap(o)
 }
 
-// Select all documents in a table. This command can be chained with other
-// commands to do further processing on the data.
+// Table selects all documents in a table. This command can be chained with
+// other commands to do further processing on the data.
 //
-// Optional arguments (see http://www.rethinkdb.com/api/#js:selecting_data-table for more information):
-// "use_outdated" (boolean - defaults to false)
+// There are two optional arguments.
+//   - useOutdated: if true, this allows potentially out-of-date data to be
+//     returned, with potentially faster reads. It also allows you to perform reads
+//     from a secondary replica if a primary has failed. Default false.
+//   - identifierFormat: possible values are name and uuid, with a default of name.
+//     If set to uuid, then system tables will refer to servers, databases and tables
+//     by UUID rather than name. (This only has an effect when used with system tables.)
 func Table(name interface{}, optArgs ...TableOpts) Term {
 	opts := map[string]interface{}{}
 	if len(optArgs) >= 1 {
@@ -31,11 +37,16 @@ func Table(name interface{}, optArgs ...TableOpts) Term {
 	return constructRootTerm("Table", p.Term_TABLE, []interface{}{name}, opts)
 }
 
-// Select all documents in a table. This command can be chained with other
-// commands to do further processing on the data.
+// Table selects all documents in a table. This command can be chained with
+// other commands to do further processing on the data.
 //
-// Optional arguments (see http://www.rethinkdb.com/api/#js:selecting_data-table for more information):
-// "use_outdated" (boolean - defaults to false)
+// There are two optional arguments.
+//   - useOutdated: if true, this allows potentially out-of-date data to be
+//     returned, with potentially faster reads. It also allows you to perform reads
+//     from a secondary replica if a primary has failed. Default false.
+//   - identifierFormat: possible values are name and uuid, with a default of name.
+//     If set to uuid, then system tables will refer to servers, databases and tables
+//     by UUID rather than name. (This only has an effect when used with system tables.)
 func (t Term) Table(name interface{}, optArgs ...TableOpts) Term {
 	opts := map[string]interface{}{}
 	if len(optArgs) >= 1 {
@@ -44,21 +55,23 @@ func (t Term) Table(name interface{}, optArgs ...TableOpts) Term {
 	return constructMethodTerm(t, "Table", p.Term_TABLE, []interface{}{name}, opts)
 }
 
-// Get a document by primary key. If nothing was found, RethinkDB will return a nil value.
+// Get gets a document by primary key. If nothing was found, RethinkDB will return a nil value.
 func (t Term) Get(args ...interface{}) Term {
 	return constructMethodTerm(t, "Get", p.Term_GET, args, map[string]interface{}{})
 }
 
-// Get all documents where the given value matches the value of the primary index.
+// GetAll gets all documents where the given value matches the value of the primary index.
 func (t Term) GetAll(keys ...interface{}) Term {
 	return constructMethodTerm(t, "GetAll", p.Term_GET_ALL, keys, map[string]interface{}{})
 }
 
-// Get all documents where the given value matches the value of the requested index.
+// GetAllByIndex gets all documents where the given value matches the value of
+// the requested index.
 func (t Term) GetAllByIndex(index interface{}, keys ...interface{}) Term {
 	return constructMethodTerm(t, "GetAll", p.Term_GET_ALL, keys, map[string]interface{}{"index": index})
 }
 
+// BetweenOpts contains the optional arguments for the Between term
 type BetweenOpts struct {
 	Index      interface{} `gorethink:"index,omitempty"`
 	LeftBound  interface{} `gorethink:"left_bound,omitempty"`
@@ -69,13 +82,18 @@ func (o *BetweenOpts) toMap() map[string]interface{} {
 	return optArgsToMap(o)
 }
 
-// Get all documents between two keys. Accepts three optional arguments: `index`,
-// `left_bound`, and `right_bound`. If `index` is set to the name of a secondary
-// index, `between` will return all documents where that index's value is in the
-// specified range (it uses the primary key by default). `left_bound` or
-// `right_bound` may be set to `open` or `closed` to indicate whether or not to
-// include that endpoint of the range (by default, `left_bound` is closed and
-// `right_bound` is open).
+// Between gets all documents between two keys. Accepts three optional arguments:
+// index, leftBound, and rightBound. If index is set to the name of a secondary
+// index, between will return all documents where that index’s value is in the
+// specified range (it uses the primary key by default). leftBound or rightBound
+// may be set to open or closed to indicate whether or not to include that endpoint
+// of the range (by default, leftBound is closed and rightBound is open).
+//
+// You may also use the special constants r.minval and r.maxval for boundaries,
+// which represent “less than any index key” and “more than any index key”
+// respectively. For instance, if you use r.minval as the lower key, then between
+// will return all documents whose primary keys (or indexes) are less than the
+// specified upper key.
 func (t Term) Between(lowerKey, upperKey interface{}, optArgs ...BetweenOpts) Term {
 	opts := map[string]interface{}{}
 	if len(optArgs) >= 1 {
@@ -84,6 +102,7 @@ func (t Term) Between(lowerKey, upperKey interface{}, optArgs ...BetweenOpts) Te
 	return constructMethodTerm(t, "Between", p.Term_BETWEEN, []interface{}{lowerKey, upperKey}, opts)
 }
 
+// FilterOpts contains the optional arguments for the Filter term
 type FilterOpts struct {
 	Default interface{} `gorethink:"default,omitempty"`
 }
@@ -92,7 +111,7 @@ func (o *FilterOpts) toMap() map[string]interface{} {
 	return optArgsToMap(o)
 }
 
-// Get all the documents for which the given predicate is true.
+// Filter gets all the documents for which the given predicate is true.
 //
 // Filter can be called on a sequence, selection, or a field containing an array
 // of elements. The return type is the same as the type on which the function was