Fix typos (#813)

Author: deining

CHANGELOG.md

@@ -322,7 +322,7 @@ Require Go 1.22+
 
 ### Features
 
-Introducting [gcustom](https://onsi.github.io/gomega/#gcustom-a-convenient-mechanism-for-buildling-custom-matchers) - a convenient mechanism for building custom matchers.
+Introducing [gcustom](https://onsi.github.io/gomega/#gcustom-a-convenient-mechanism-for-buildling-custom-matchers) - a convenient mechanism for building custom matchers.
 
 This is an RC release for `gcustom`.  The external API may be tweaked in response to feedback however it is expected to remain mostly stable.
 
@@ -461,7 +461,7 @@ These improvements are all documented in [Gomega's docs](https://onsi.github.io/
 - Fix max number of samples in experiments on non-64-bit systems. (#528) [1c84497]
 - Remove dependency on ginkgo v1.16.4 (#530) [4dea8d5]
 - Fix for Go 1.18 (#532) [56d2a29]
-- Document precendence of timeouts (#533) [b607941]
+- Document precedence of timeouts (#533) [b607941]
 
 ## 1.18.1
 
@@ -478,7 +478,7 @@ These improvements are all documented in [Gomega's docs](https://onsi.github.io/
 ## Fixes
 - Gomega now uses ioutil for Go 1.15 and lower (#492) - official support is only for the most recent two major versions of Go but this will unblock users who need to stay on older unsupported versions of Go. [c29c1c0]
 
-## Maintenace
+## Maintenance
 - Remove Travis workflow (#491) [72e6040]
 - Upgrade to Ginkgo 2.0.0 GA [f383637]
 - chore: fix description of HaveField matcher (#487) [2b4b2c0]
@@ -726,7 +726,7 @@ Improvements:
 
 - Added `BeSent` which attempts to send a value down a channel and fails if the attempt blocks.  Can be paired with `Eventually` to safely send a value down a channel with a timeout.
 - `Ω`, `Expect`, `Eventually`, and `Consistently` now immediately `panic` if there is no registered fail handler.  This is always a mistake that can hide failing tests.
-- `Receive()` no longer errors when passed a closed channel, it's perfectly fine to attempt to read from a closed channel so Ω(c).Should(Receive()) always fails and Ω(c).ShoudlNot(Receive()) always passes with a closed channel.
+- `Receive()` no longer errors when passed a closed channel, it's perfectly fine to attempt to read from a closed channel so Ω(c).Should(Receive()) always fails and Ω(c).ShouldNot(Receive()) always passes with a closed channel.
 - Added `HavePrefix` and `HaveSuffix` matchers.
 - `ghttp` can now handle concurrent requests.
 - Added `Succeed` which allows one to write `Ω(MyFunction()).Should(Succeed())`.
@@ -736,7 +736,7 @@ Improvements:
 - `ghttp` servers can take an `io.Writer`.  `ghttp` will write a line to the writer when each request arrives.
 - Added `WithTransform` matcher to allow munging input data before feeding into the relevant matcher
 - Added boolean `And`, `Or`, and `Not` matchers to allow creating composite matchers
-- Added `gbytes.TimeoutCloser`, `gbytes.TimeoutReader`, and `gbytes.TimeoutWriter` - these are convenience wrappers that timeout if the underlying Closer/Reader/Writer does not return within the alloted time.
+- Added `gbytes.TimeoutCloser`, `gbytes.TimeoutReader`, and `gbytes.TimeoutWriter` - these are convenience wrappers that timeout if the underlying Closer/Reader/Writer does not return within the allotted time.
 - Added `gbytes.BufferReader` - this constructs a `gbytes.Buffer` that asynchronously reads the passed-in `io.Reader` into its buffer.
 
 Bug Fixes:
@@ -781,7 +781,7 @@ New Matchers:
 
 Updated Matchers:
 
-- `Receive` matcher can take a matcher as an argument and passes only if the channel under test receives an objet that satisfies the passed-in matcher.
+- `Receive` matcher can take a matcher as an argument and passes only if the channel under test receives an object that satisfies the passed-in matcher.
 - Matchers that implement `MatchMayChangeInTheFuture(actual interface{}) bool` can inform `Eventually` and/or `Consistently` when a match has no chance of changing status in the future.  For example, `Receive` returns `false` when a channel is closed.
 
 Misc:

docs/index.md

@@ -3405,7 +3405,7 @@ Describe("server performance", func() {
         baseline := cache.Load("performance regression test", 1)
         if baseline == nil {
             // this is the first run, let's store a baseline
-            cache.Save("performacne regression test", 1, experiment)
+            cache.Save("performance regression test", 1, experiment)
         } else {
             for _, m := range []string{"fetching one", "listing"} {
                 baselineStats := baseline.GetStats(m)

format/format.go

@@ -57,7 +57,7 @@ var Indent = "    "
 
 var longFormThreshold = 20
 
-// GomegaStringer allows for custom formating of objects for gomega.
+// GomegaStringer allows for custom formatting of objects for gomega.
 type GomegaStringer interface {
 	// GomegaString will be used to custom format an object.
 	// It does not follow UseStringerRepresentation value and will always be called regardless.

format/format_test.go

@@ -165,13 +165,13 @@ var _ = Describe("Format", func() {
 				Expect(Message(3, "to be three.")).Should(Equal("Expected\n    <int>: 3\nto be three."))
 			})
 
-			It("should print out an indented formatted representation of the value and the message, and trucate it when too long", func() {
+			It("should print out an indented formatted representation of the value and the message, and truncate it when too long", func() {
 				tooLong := strings.Repeat("s", MaxLength+1)
 				tooLongResult := strings.Repeat("s", MaxLength) + "...\n" + truncateHelpText
 				Expect(Message(tooLong, "to be truncated")).Should(Equal("Expected\n    <string>: " + tooLongResult + "\nto be truncated"))
 			})
 
-			It("should print out an indented formatted representation of the value and the message, and not trucate it when MaxLength = 0", func() {
+			It("should print out an indented formatted representation of the value and the message, and not truncate it when MaxLength = 0", func() {
 				MaxLength = 0
 				tooLong := strings.Repeat("s", MaxLength+1)
 				Expect(Message(tooLong, "to be truncated")).Should(Equal("Expected\n    <string>: " + tooLong + "\nto be truncated"))

gcustom/make_matcher.go

@@ -191,7 +191,7 @@ func (c CustomGomegaMatcher) WithTemplate(templ string, data ...any) CustomGomeg
 /*
 WithPrecompiledTemplate returns a CustomGomegaMatcher configured to use the passed-in template.  The template should be precompiled with gcustom.ParseTemplate().
 
-As with WithTemplate() you can provide a single pice of additional data as an optional argument.  This is accessed in the template via {{.Data}}
+As with WithTemplate() you can provide a single piece of additional data as an optional argument.  This is accessed in the template via {{.Data}}
 */
 func (c CustomGomegaMatcher) WithPrecompiledTemplate(templ *template.Template, data ...any) CustomGomegaMatcher {
 	c.templateMessage = templ

gexec/session_test.go

@@ -330,7 +330,7 @@ var _ = Describe("Session", func() {
 					errWriter = io.Discard
 				})
 
-				It("executes succesfuly", func() {
+				It("executes successfully", func() {
 					Eventually(session).Should(Exit())
 				})
 			})
@@ -391,7 +391,7 @@ var _ = Describe("Session", func() {
 					errWriter = io.Discard
 				})
 
-				It("executes succesfuly", func() {
+				It("executes successfully", func() {
 					Eventually(session).Should(Exit())
 				})
 			})

ghttp/handlers.go

@@ -251,7 +251,7 @@ func (g GHTTPWithGomega) RespondWith(statusCode int, body interface{}, optionalH
 /*
 RespondWithPtr returns a handler that responds to a request with the specified status code and body
 
-Unlike RespondWith, you pass RepondWithPtr a pointer to the status code and body allowing different tests
+Unlike RespondWith, you pass RespondWithPtr a pointer to the status code and body allowing different tests
 to share the same setup but specify different status codes and bodies.
 
 Also, RespondWithPtr can be given an optional http.Header.  The headers defined therein will be added to the response headers.

ghttp/test_server_test.go

@@ -78,7 +78,7 @@ var _ = Describe("TestServer", func() {
 		})
 	})
 
-	Describe("closing server mulitple times", func() {
+	Describe("closing server multiple times", func() {
 		It("should not fail", func() {
 			s.Close()
 			Expect(s.Close).ShouldNot(Panic())

gmeasure/cache.go

@@ -106,50 +106,50 @@ func (cache ExperimentCache) Clear() error {
 }
 
 /*
-Load fetches an experiment from the cache.  Lookup occurs by name.  Load requires that the version numer in the cache is equal to or greater than the passed-in version.
+Load fetches an experiment from the cache.  Lookup occurs by name.  Load requires that the version number in the cache is equal to or greater than the passed-in version.
 
 If an experiment with corresponding name and version >= the passed-in version is found, it is unmarshaled and returned.
 
 If no experiment is found, or the cached version is smaller than the passed-in version, Load will return nil.
 
 When paired with Ginkgo you can cache experiments and prevent potentially expensive recomputation with this pattern:
 
-	const EXPERIMENT_VERSION = 1 //bump this to bust the cache and recompute _all_ experiments
-
-    Describe("some experiments", func() {
-    	var cache gmeasure.ExperimentCache
-    	var experiment *gmeasure.Experiment
-
-    	BeforeEach(func() {
-    		cache = gmeasure.NewExperimentCache("./gmeasure-cache")
-    		name := CurrentSpecReport().LeafNodeText
-    		experiment = cache.Load(name, EXPERIMENT_VERSION)
-    		if experiment != nil {
-    			AddReportEntry(experiment)
-    			Skip("cached")
-    		}
-    		experiment = gmeasure.NewExperiment(name)
-			AddReportEntry(experiment)
-    	})
-
-    	It("foo runtime", func() {
-    		experiment.SampleDuration("runtime", func() {
-    			//do stuff
-    		}, gmeasure.SamplingConfig{N:100})
-    	})
-
-    	It("bar runtime", func() {
-    		experiment.SampleDuration("runtime", func() {
-    			//do stuff
-    		}, gmeasure.SamplingConfig{N:100})
-    	})
-
-    	AfterEach(func() {
-    		if !CurrentSpecReport().State.Is(types.SpecStateSkipped) {
-	    		cache.Save(experiment.Name, EXPERIMENT_VERSION, experiment)
-	    	}
-    	})
-    })
+		const EXPERIMENT_VERSION = 1 //bump this to bust the cache and recompute _all_ experiments
+
+	    Describe("some experiments", func() {
+	    	var cache gmeasure.ExperimentCache
+	    	var experiment *gmeasure.Experiment
+
+	    	BeforeEach(func() {
+	    		cache = gmeasure.NewExperimentCache("./gmeasure-cache")
+	    		name := CurrentSpecReport().LeafNodeText
+	    		experiment = cache.Load(name, EXPERIMENT_VERSION)
+	    		if experiment != nil {
+	    			AddReportEntry(experiment)
+	    			Skip("cached")
+	    		}
+	    		experiment = gmeasure.NewExperiment(name)
+				AddReportEntry(experiment)
+	    	})
+
+	    	It("foo runtime", func() {
+	    		experiment.SampleDuration("runtime", func() {
+	    			//do stuff
+	    		}, gmeasure.SamplingConfig{N:100})
+	    	})
+
+	    	It("bar runtime", func() {
+	    		experiment.SampleDuration("runtime", func() {
+	    			//do stuff
+	    		}, gmeasure.SamplingConfig{N:100})
+	    	})
+
+	    	AfterEach(func() {
+	    		if !CurrentSpecReport().State.Is(types.SpecStateSkipped) {
+		    		cache.Save(experiment.Name, EXPERIMENT_VERSION, experiment)
+		    	}
+	    	})
+	    })
 */
 func (cache ExperimentCache) Load(name string, version int) *Experiment {
 	path := filepath.Join(cache.Path, cache.hashOf(name)+CACHE_EXT)

gmeasure/cache_test.go

@@ -77,7 +77,7 @@ var _ = Describe("Cache", func() {
 			Ω(cache.Clear()).Should(Succeed())
 		})
 
-		It("returs nil when loading a non-existing experiment", func() {
+		It("returns nil when loading a non-existing experiment", func() {
 			Ω(cache.Load("floop", 17)).Should(BeNil())
 		})
 	})

gmeasure/experiment.go

@@ -22,9 +22,9 @@ Once measurements are complete, an Experiment can generate a comprehensive repor
 
 Users can also access and analyze the resulting Measurements directly.  Use Experiment.Get(NAME) to fetch the Measurement named NAME.  This returned struct will have fields containing
 all the data points and annotations recorded by the experiment.  You can subsequently fetch the Measurement.Stats() to get a Stats struct that contains basic statistical information about the
-Measurement (min, max, median, mean, standard deviation).  You can order these Stats objects using RankStats() to identify best/worst performers across multpile experiments or measurements.
+Measurement (min, max, median, mean, standard deviation).  You can order these Stats objects using RankStats() to identify best/worst performers across multiple experiments or measurements.
 
-gmeasure also supports caching Experiments via an ExperimentCache.  The cache supports storing and retreiving experiments by name and version.  This allows you to rerun code without
+gmeasure also supports caching Experiments via an ExperimentCache.  The cache supports storing and retrieving experiments by name and version.  This allows you to rerun code without
 repeating expensive experiments that may not have changed (which can be controlled by the cache version number).  It also enables you to compare new experiment runs with older runs to detect
 variations in performance/behavior.
 
@@ -66,8 +66,8 @@ type SamplingConfig struct {
 
 // The Units decorator allows you to specify units (an arbitrary string) when recording values.  It is ignored when recording durations.
 //
-//     e := gmeasure.NewExperiment("My Experiment")
-//     e.RecordValue("length", 3.141, gmeasure.Units("inches"))
+//	e := gmeasure.NewExperiment("My Experiment")
+//	e.RecordValue("length", 3.141, gmeasure.Units("inches"))
 //
 // Units are only set the first time a value of a given name is recorded.  In the example above any subsequent calls to e.RecordValue("length", X) will maintain the "inches" units even if a new set of Units("UNIT") are passed in later.
 type Units string
@@ -76,9 +76,9 @@ type Units string
 //
 // For example:
 //
-//     e := gmeasure.NewExperiment("My Experiment")
-//     e.RecordValue("length", 3.141, gmeasure.Annotation("bob"))
-//     e.RecordValue("length", 2.71, gmeasure.Annotation("jane"))
+//	e := gmeasure.NewExperiment("My Experiment")
+//	e.RecordValue("length", 3.141, gmeasure.Annotation("bob"))
+//	e.RecordValue("length", 2.71, gmeasure.Annotation("jane"))
 //
 // ...will result in a Measurement named "length" that records two values )[3.141, 2.71]) annotation with (["bob", "jane"])
 type Annotation string
@@ -88,11 +88,11 @@ type Annotation string
 //
 // For example:
 //
-//     e := gmeasure.NewExperiment("My Experiment")
-//     e.RecordValue("length", 3.141, gmeasure.Style("{{blue}}{{bold}}"))
-//     e.RecordValue("length", 2.71)
-//     e.RecordDuration("cooking time", 3 * time.Second, gmeasure.Style("{{red}}{{underline}}"))
-//     e.RecordDuration("cooking time", 2 * time.Second)
+//	e := gmeasure.NewExperiment("My Experiment")
+//	e.RecordValue("length", 3.141, gmeasure.Style("{{blue}}{{bold}}"))
+//	e.RecordValue("length", 2.71)
+//	e.RecordDuration("cooking time", 3 * time.Second, gmeasure.Style("{{red}}{{underline}}"))
+//	e.RecordDuration("cooking time", 2 * time.Second)
 //
 // will emit a report with blue bold entries for the length measurement and red underlined entries for the cooking time measurement.
 //
@@ -112,11 +112,11 @@ type PrecisionBundle struct {
 //
 // For example:
 //
-//     e := gmeasure.NewExperiment("My Experiment")
-//     e.RecordValue("length", 3.141, gmeasure.Precision(2))
-//     e.RecordValue("length", 2.71)
-//     e.RecordDuration("cooking time", 3214 * time.Millisecond, gmeasure.Precision(100*time.Millisecond))
-//     e.RecordDuration("cooking time", 2623 * time.Millisecond)
+//	e := gmeasure.NewExperiment("My Experiment")
+//	e.RecordValue("length", 3.141, gmeasure.Precision(2))
+//	e.RecordValue("length", 2.71)
+//	e.RecordDuration("cooking time", 3214 * time.Millisecond, gmeasure.Precision(100*time.Millisecond))
+//	e.RecordDuration("cooking time", 2623 * time.Millisecond)
 func Precision(p interface{}) PrecisionBundle {
 	out := DefaultPrecisionBundle
 	switch reflect.TypeOf(p) {
@@ -308,7 +308,7 @@ The resulting durations are recorded on a Duration Measurement with the passed-i
 
 The callback is given a zero-based index that increments by one between samples.  The callback must return an Annotation - this annotation is attached to the measured duration.
 
-The Sampling is configured via the passed-in SamplingConfig
+# The Sampling is configured via the passed-in SamplingConfig
 
 SampleAnnotatedDuration supports the Style() and Precision() decorations.
 */
@@ -395,7 +395,7 @@ SampleAnnotatedValue samples the passed-in callback and records the return value
 
 The callback is given a zero-based index that increments by one between samples.  The callback must return a float64 and an Annotation - the annotation is attached to the recorded value.
 
-The Sampling is configured via the passed-in SamplingConfig
+# The Sampling is configured via the passed-in SamplingConfig
 
 SampleValue supports the Style(), Units(), and Precision() decorations.
 */

gmeasure/experiment_test.go

@@ -298,7 +298,7 @@ var _ = Describe("Experiment", func() {
 			}).Should(PanicWith("invalid precision type, must be time.Duration or int"))
 		})
 
-		It("panics if an unrecognized argumnet is passed in", func() {
+		It("panics if an unrecognized argument is passed in", func() {
 			Ω(func() {
 				e.RecordValue("sprockets", 2, "boom")
 			}).Should(PanicWith(`unrecognized argument "boom"`))

gmeasure/rank.go

@@ -34,7 +34,7 @@ func (s *RankingCriteria) UnmarshalJSON(b []byte) error {
 func (s RankingCriteria) MarshalJSON() ([]byte, error) { return rcEnumSupport.MarshJSON(uint(s)) }
 
 /*
-Ranking ranks a set of Stats by a specified RankingCritera.  Use RankStats to create a Ranking.
+Ranking ranks a set of Stats by a specified RankingCriteria.  Use RankStats to create a Ranking.
 
 When using Ginkgo, you can register Rankings as Report Entries via AddReportEntry.  This will emit a formatted table representing the Stats in rank-order when Ginkgo generates the report.
 */

gmeasure/stats.go

@@ -75,7 +75,7 @@ type Stats struct {
 	// If Type is StatTypeValue then PrecisionBundle.ValueFormat is used to format any values before presentation
 	PrecisionBundle PrecisionBundle
 
-	// N represents the total number of data points in the Meassurement from which this Stat is derived
+	// N represents the total number of data points in the Measurement from which this Stat is derived
 	N int
 
 	// If Type is StatTypeValue, ValueBundle will be populated with float64s representing this Stat's statistics
@@ -97,7 +97,7 @@ func (s Stats) String() string {
 // ValueFor returns the float64 value for a particular Stat.  You should only use this if the Stats has Type StatsTypeValue
 // For example:
 //
-//    median := experiment.GetStats("length").ValueFor(gmeasure.StatMedian)
+//	median := experiment.GetStats("length").ValueFor(gmeasure.StatMedian)
 //
 // will return the median data point for the "length" Measurement.
 func (s Stats) ValueFor(stat Stat) float64 {
@@ -107,7 +107,7 @@ func (s Stats) ValueFor(stat Stat) float64 {
 // DurationFor returns the time.Duration for a particular Stat.  You should only use this if the Stats has Type StatsTypeDuration
 // For example:
 //
-//    mean := experiment.GetStats("runtime").ValueFor(gmeasure.StatMean)
+//	mean := experiment.GetStats("runtime").ValueFor(gmeasure.StatMean)
 //
 // will return the mean duration for the "runtime" Measurement.
 func (s Stats) DurationFor(stat Stat) time.Duration {

gomega_dsl.go

@@ -319,19 +319,19 @@ you an also use Eventually().WithContext(ctx) to pass in the context.  Passed-in
 		Eventually(client.FetchCount).WithContext(ctx).WithArguments("/users").Should(BeNumerically(">=", 17))
 	}, SpecTimeout(time.Second))
 
-Either way the context pasesd to Eventually is also passed to the underlying function.  Now, when Ginkgo cancels the context both the FetchCount client and Gomega will be informed and can exit.
+Either way the context passed to Eventually is also passed to the underlying function.  Now, when Ginkgo cancels the context both the FetchCount client and Gomega will be informed and can exit.
 
 By default, when a context is passed to Eventually *without* an explicit timeout, Gomega will rely solely on the context's cancellation to determine when to stop polling.  If you want to specify a timeout in addition to the context you can do so using the .WithTimeout() method.  For example:
 
 	Eventually(client.FetchCount).WithContext(ctx).WithTimeout(10*time.Second).Should(BeNumerically(">=", 17))
 
-now either the context cacnellation or the timeout will cause Eventually to stop polling.
+now either the context cancellation or the timeout will cause Eventually to stop polling.
 
 If, instead, you would like to opt out of this behavior and have Gomega's default timeouts govern Eventuallys that take a context you can call:
 
 	EnforceDefaultTimeoutsWhenUsingContexts()
 
-in the DSL (or on a Gomega instance).  Now all calls to Eventually that take a context will fail if eitehr the context is cancelled or the default timeout elapses.
+in the DSL (or on a Gomega instance).  Now all calls to Eventually that take a context will fail if either the context is cancelled or the default timeout elapses.
 
 **Category 3: Making assertions _in_ the function passed into Eventually**
 
@@ -441,7 +441,7 @@ func ConsistentlyWithOffset(offset int, actualOrCtx interface{}, args ...interfa
 }
 
 /*
-StopTrying can be used to signal to Eventually and Consistentlythat they should abort and stop trying.  This always results in a failure of the assertion - and the failure message is the content of the StopTrying signal.
+StopTrying can be used to signal to Eventually and Consistently that they should abort and stop trying.  This always results in a failure of the assertion - and the failure message is the content of the StopTrying signal.
 
 You can send the StopTrying signal by either returning StopTrying("message") as an error from your passed-in function _or_ by calling StopTrying("message").Now() to trigger a panic and end execution.
 

gstruct/elements.go

@@ -14,56 +14,59 @@ import (
 	"github.com/onsi/gomega/types"
 )
 
-//MatchAllElements succeeds if every element of a slice matches the element matcher it maps to
-//through the id function, and every element matcher is matched.
-//    idFn := func(element interface{}) string {
-//        return fmt.Sprintf("%v", element)
-//    }
+// MatchAllElements succeeds if every element of a slice matches the element matcher it maps to
+// through the id function, and every element matcher is matched.
 //
-//    Expect([]string{"a", "b"}).To(MatchAllElements(idFn, Elements{
-//        "a": Equal("a"),
-//        "b": Equal("b"),
-//    }))
+//	idFn := func(element interface{}) string {
+//	    return fmt.Sprintf("%v", element)
+//	}
+//
+//	Expect([]string{"a", "b"}).To(MatchAllElements(idFn, Elements{
+//	    "a": Equal("a"),
+//	    "b": Equal("b"),
+//	}))
 func MatchAllElements(identifier Identifier, elements Elements) types.GomegaMatcher {
 	return &ElementsMatcher{
 		Identifier: identifier,
 		Elements:   elements,
 	}
 }
 
-//MatchAllElementsWithIndex succeeds if every element of a slice matches the element matcher it maps to
-//through the id with index function, and every element matcher is matched.
-//    idFn := func(index int, element interface{}) string {
-//        return strconv.Itoa(index)
-//    }
+// MatchAllElementsWithIndex succeeds if every element of a slice matches the element matcher it maps to
+// through the id with index function, and every element matcher is matched.
+//
+//	idFn := func(index int, element interface{}) string {
+//	    return strconv.Itoa(index)
+//	}
 //
-//    Expect([]string{"a", "b"}).To(MatchAllElements(idFn, Elements{
-//        "0": Equal("a"),
-//        "1": Equal("b"),
-//    }))
+//	Expect([]string{"a", "b"}).To(MatchAllElements(idFn, Elements{
+//	    "0": Equal("a"),
+//	    "1": Equal("b"),
+//	}))
 func MatchAllElementsWithIndex(identifier IdentifierWithIndex, elements Elements) types.GomegaMatcher {
 	return &ElementsMatcher{
 		Identifier: identifier,
 		Elements:   elements,
 	}
 }
 
-//MatchElements succeeds if each element of a slice matches the element matcher it maps to
-//through the id function. It can ignore extra elements and/or missing elements.
-//    idFn := func(element interface{}) string {
-//        return fmt.Sprintf("%v", element)
-//    }
+// MatchElements succeeds if each element of a slice matches the element matcher it maps to
+// through the id function. It can ignore extra elements and/or missing elements.
 //
-//    Expect([]string{"a", "b", "c"}).To(MatchElements(idFn, IgnoreExtras, Elements{
-//        "a": Equal("a"),
-//        "b": Equal("b"),
-//    }))
-//    Expect([]string{"a", "c"}).To(MatchElements(idFn, IgnoreMissing, Elements{
-//        "a": Equal("a"),
-//        "b": Equal("b"),
-//        "c": Equal("c"),
-//        "d": Equal("d"),
-//    }))
+//	idFn := func(element interface{}) string {
+//	    return fmt.Sprintf("%v", element)
+//	}
+//
+//	Expect([]string{"a", "b", "c"}).To(MatchElements(idFn, IgnoreExtras, Elements{
+//	    "a": Equal("a"),
+//	    "b": Equal("b"),
+//	}))
+//	Expect([]string{"a", "c"}).To(MatchElements(idFn, IgnoreMissing, Elements{
+//	    "a": Equal("a"),
+//	    "b": Equal("b"),
+//	    "c": Equal("c"),
+//	    "d": Equal("d"),
+//	}))
 func MatchElements(identifier Identifier, options Options, elements Elements) types.GomegaMatcher {
 	return &ElementsMatcher{
 		Identifier:      identifier,
@@ -74,22 +77,23 @@ func MatchElements(identifier Identifier, options Options, elements Elements) ty
 	}
 }
 
-//MatchElementsWithIndex succeeds if each element of a slice matches the element matcher it maps to
-//through the id with index function. It can ignore extra elements and/or missing elements.
-//    idFn := func(index int, element interface{}) string {
-//        return strconv.Itoa(index)
-//    }
+// MatchElementsWithIndex succeeds if each element of a slice matches the element matcher it maps to
+// through the id with index function. It can ignore extra elements and/or missing elements.
+//
+//	idFn := func(index int, element interface{}) string {
+//	    return strconv.Itoa(index)
+//	}
 //
-//    Expect([]string{"a", "b", "c"}).To(MatchElements(idFn, IgnoreExtras, Elements{
-//        "0": Equal("a"),
-//        "1": Equal("b"),
-//    }))
-//    Expect([]string{"a", "c"}).To(MatchElements(idFn, IgnoreMissing, Elements{
-//        "0": Equal("a"),
-//        "1": Equal("b"),
-//        "2": Equal("c"),
-//        "3": Equal("d"),
-//    }))
+//	Expect([]string{"a", "b", "c"}).To(MatchElements(idFn, IgnoreExtras, Elements{
+//	    "0": Equal("a"),
+//	    "1": Equal("b"),
+//	}))
+//	Expect([]string{"a", "c"}).To(MatchElements(idFn, IgnoreMissing, Elements{
+//	    "0": Equal("a"),
+//	    "1": Equal("b"),
+//	    "2": Equal("c"),
+//	    "3": Equal("d"),
+//	}))
 func MatchElementsWithIndex(identifier IdentifierWithIndex, options Options, elements Elements) types.GomegaMatcher {
 	return &ElementsMatcher{
 		Identifier:      identifier,
@@ -126,7 +130,7 @@ type Elements map[string]types.GomegaMatcher
 // Function for identifying (mapping) elements.
 type Identifier func(element interface{}) string
 
-// Calls the underlying fucntion with the provided params.
+// Calls the underlying function with the provided params.
 // Identifier drops the index.
 func (i Identifier) WithIndexAndElement(index int, element interface{}) string {
 	return i(element)
@@ -135,13 +139,13 @@ func (i Identifier) WithIndexAndElement(index int, element interface{}) string {
 // Uses the index and element to generate an element name
 type IdentifierWithIndex func(index int, element interface{}) string
 
-// Calls the underlying fucntion with the provided params.
+// Calls the underlying function with the provided params.
 // IdentifierWithIndex uses the index.
 func (i IdentifierWithIndex) WithIndexAndElement(index int, element interface{}) string {
 	return i(index, element)
 }
 
-// Interface for identifing the element
+// Interface for identifying the element
 type Identify interface {
 	WithIndexAndElement(i int, element interface{}) string
 }

gstruct/types.go

@@ -1,6 +1,6 @@
 package gstruct
 
-//Options is the type for options passed to some matchers.
+// Options is the type for options passed to some matchers.
 type Options int
 
 const (
@@ -9,7 +9,7 @@ const (
 	//IgnoreMissing tells the matcher to ignore missing elements or fields, rather than triggering a failure.
 	IgnoreMissing
 	//AllowDuplicates tells the matcher to permit multiple members of the slice to produce the same ID when
-	//considered by the indentifier function. All members that map to a given key must still match successfully
+	//considered by the identifier function. All members that map to a given key must still match successfully
 	//with the matcher that is provided for that key.
 	AllowDuplicates
 )

internal/async_assertion.go

@@ -224,7 +224,7 @@ func (assertion *AsyncAssertion) argumentMismatchError(t reflect.Type, numProvid
 	if numProvided == 1 {
 		have = "has"
 	}
-	return fmt.Errorf(`The function passed to %s has signature %s takes %d arguments but %d %s been provided.  Please use %s().WithArguments() to pass the corect set of arguments.
+	return fmt.Errorf(`The function passed to %s has signature %s takes %d arguments but %d %s been provided.  Please use %s().WithArguments() to pass the correct set of arguments.
 
 You can learn more at https://onsi.github.io/gomega/#eventually
 `, assertion.asyncType, t, t.NumIn(), numProvided, have, assertion.asyncType)

internal/async_assertion_test.go

@@ -803,7 +803,7 @@ var _ = Describe("Asynchronous Assertions", func() {
 					Ω(ig.FailureMessage).Should(ContainSubstring("Expected\n    <bool>: false\nto be true"))
 				})
 
-				It("shows the state of the last match if there was a non-failing funciton at some point", func() {
+				It("shows the state of the last match if there was a non-failing function at some point", func() {
 					counter := 0
 					_, file, line, _ := runtime.Caller(0)
 					ig.G.Eventually(func(g Gomega) int {
@@ -917,7 +917,7 @@ var _ = Describe("Asynchronous Assertions", func() {
 					Ω(ig.FailureMessage).ShouldNot(ContainSubstring("bloop"))
 				})
 
-				It("returns the first failed assertion as an error and should satisy ShouldNot(Succeed) eventually", func() {
+				It("returns the first failed assertion as an error and should satisfy ShouldNot(Succeed) eventually", func() {
 					counter := 0
 					ig.G.Eventually(func(g Gomega) {
 						counter += 1
@@ -967,7 +967,7 @@ var _ = Describe("Asynchronous Assertions", func() {
 					Ω(counter).Should(Equal(3))
 				})
 
-				It("returns the first failed assertion as an error and should satisy ShouldNot(Succeed) consistently if an error always occur", func() {
+				It("returns the first failed assertion as an error and should satisfy ShouldNot(Succeed) consistently if an error always occur", func() {
 					counter := 0
 					ig.G.Consistently(func(g Gomega) {
 						counter += 1
@@ -1033,7 +1033,7 @@ var _ = Describe("Asynchronous Assertions", func() {
 				})
 			})
 
-			Context("with a Gomega arugment as well", func() {
+			Context("with a Gomega argument as well", func() {
 				It("can also forward arguments alongside a Gomega", func() {
 					Eventually(func(g Gomega, a int, b int) {
 						g.Expect(a).To(Equal(b))
@@ -1044,7 +1044,7 @@ var _ = Describe("Asynchronous Assertions", func() {
 				})
 			})
 
-			Context("with a context arugment as well", func() {
+			Context("with a context argument as well", func() {
 				It("can also forward arguments alongside a context", func() {
 					ctx := context.WithValue(context.Background(), "key", "value")
 					Eventually(func(ctx context.Context, animal string) string {
@@ -1053,7 +1053,7 @@ var _ = Describe("Asynchronous Assertions", func() {
 				})
 			})
 
-			Context("with Gomega and context arugments", func() {
+			Context("with Gomega and context arguments", func() {
 				It("forwards arguments alongside both", func() {
 					ctx := context.WithValue(context.Background(), "key", "I have")
 					f := func(g Gomega, ctx context.Context, count int, zoo ...string) {
@@ -1082,27 +1082,27 @@ var _ = Describe("Asynchronous Assertions", func() {
 					ig.G.Eventually(func(a int) string {
 						return ""
 					}).Should(Equal("foo"))
-					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(int) string takes 1 arguments but 0 have been provided.  Please use Eventually().WithArguments() to pass the corect set of arguments."))
+					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(int) string takes 1 arguments but 0 have been provided.  Please use Eventually().WithArguments() to pass the correct set of arguments."))
 
 					ig.G.Eventually(func(a int, b int) string {
 						return ""
 					}).WithArguments(1).Should(Equal("foo"))
-					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(int, int) string takes 2 arguments but 1 has been provided.  Please use Eventually().WithArguments() to pass the corect set of arguments."))
+					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(int, int) string takes 2 arguments but 1 has been provided.  Please use Eventually().WithArguments() to pass the correct set of arguments."))
 
 					ig.G.Eventually(func(a int, b int) string {
 						return ""
 					}).WithArguments(1, 2, 3).Should(Equal("foo"))
-					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(int, int) string takes 2 arguments but 3 have been provided.  Please use Eventually().WithArguments() to pass the corect set of arguments."))
+					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(int, int) string takes 2 arguments but 3 have been provided.  Please use Eventually().WithArguments() to pass the correct set of arguments."))
 
 					ig.G.Eventually(func(g Gomega, a int, b int) string {
 						return ""
 					}).WithArguments(1, 2, 3).Should(Equal("foo"))
-					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(types.Gomega, int, int) string takes 3 arguments but 4 have been provided.  Please use Eventually().WithArguments() to pass the corect set of arguments."))
+					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(types.Gomega, int, int) string takes 3 arguments but 4 have been provided.  Please use Eventually().WithArguments() to pass the correct set of arguments."))
 
 					ig.G.Eventually(func(a int, b int, c ...int) string {
 						return ""
 					}).WithArguments(1).Should(Equal("foo"))
-					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(int, int, ...int) string takes 3 arguments but 1 has been provided.  Please use Eventually().WithArguments() to pass the corect set of arguments."))
+					Ω(ig.FailureMessage).Should(ContainSubstring("The function passed to Eventually has signature func(int, int, ...int) string takes 3 arguments but 1 has been provided.  Please use Eventually().WithArguments() to pass the correct set of arguments."))
 
 				})
 			})

internal/gomega.go

@@ -78,7 +78,7 @@ func (g *Gomega) makeAsyncAssertion(asyncAssertionType AsyncAssertionType, offse
 	actual := actualOrCtx
 	startingIndex := 0
 	if _, isCtx := actualOrCtx.(context.Context); isCtx && len(args) > 0 {
-		// the first argument is a context, we should accept it as the context _only if_ it is **not** the only argumnent **and** the second argument is not a parseable duration
+		// the first argument is a context, we should accept it as the context _only if_ it is **not** the only argument **and** the second argument is not a parseable duration
 		// this is due to an unfortunate ambiguity in early version of Gomega in which multi-type durations are allowed after the actual
 		if _, err := toDuration(args[0]); err != nil {
 			ctx = actualOrCtx.(context.Context)

internal/internal_suite_test.go

@@ -60,7 +60,7 @@ func (matcher SpecMatcher) Match(actual interface{}) (bool, error) {
 	case ERR_MATCH:
 		return false, TEST_MATCHER_ERR
 	}
-	return false, fmt.Errorf("unkown actual %v", actual)
+	return false, fmt.Errorf("unknown actual %v", actual)
 }
 
 func (matcher SpecMatcher) FailureMessage(actual interface{}) string {
@@ -75,7 +75,7 @@ func SpecMatch() SpecMatcher {
 	return SpecMatcher{}
 }
 
-//FakeGomegaTestingT
+// FakeGomegaTestingT
 type FakeGomegaTestingT struct {
 	CalledHelper bool
 	CalledFatalf string

matchers.go

@@ -202,7 +202,7 @@ func BeClosed() types.GomegaMatcher {
 //	Expect(myThing.IsValid()).Should(BeTrue())
 //
 // Finally, if you want to match the received object as well as get the actual received value into a variable, so you can reason further about the value received,
-// you can pass a pointer to a variable of the approriate type first, and second a matcher:
+// you can pass a pointer to a variable of the appropriate type first, and second a matcher:
 //
 //	var myThing thing
 //	Eventually(thingChan).Should(Receive(&myThing, ContainSubstring("bar")))
@@ -395,7 +395,7 @@ func ConsistOf(elements ...interface{}) types.GomegaMatcher {
 	}
 }
 
-// HaveExactElements succeeds if actual contains elements that precisely match the elemets passed into the matcher. The ordering of the elements does matter.
+// HaveExactElements succeeds if actual contains elements that precisely match the elements passed into the matcher. The ordering of the elements does matter.
 // By default HaveExactElements() uses Equal() to match the elements, however custom matchers can be passed in instead.  Here are some examples:
 //
 //	Expect([]string{"Foo", "FooBar"}).Should(HaveExactElements("Foo", "FooBar"))
@@ -692,7 +692,7 @@ func WithTransform(transform interface{}, matcher types.GomegaMatcher) types.Gom
 }
 
 // Satisfy matches the actual value against the `predicate` function.
-// The given predicate must be a function of one paramter that returns bool.
+// The given predicate must be a function of one parameter that returns bool.
 //
 //	var isEven = func(i int) bool { return i%2 == 0 }
 //	Expect(2).To(Satisfy(isEven))

matchers/be_comparable_to_matcher_test.go

@@ -145,8 +145,8 @@ var _ = Describe("BeComparableTo", func() {
 
 				Expect(matcherWithEqual.FailureMessage(actual)).To(BeEquivalentTo("Expected object to be comparable, diff: "))
 
-				expectedDiffernt := structWithUnexportedFields{unexported: "xxx", Exported: "other value"}
-				matcherWithDifference := BeComparableTo(expectedDiffernt, cmpopts.IgnoreUnexported(structWithUnexportedFields{}))
+				expectedDifferent := structWithUnexportedFields{unexported: "xxx", Exported: "other value"}
+				matcherWithDifference := BeComparableTo(expectedDifferent, cmpopts.IgnoreUnexported(structWithUnexportedFields{}))
 				Expect(matcherWithDifference.FailureMessage(actual)).To(ContainSubstring("1 ignored field"))
 				Expect(matcherWithDifference.FailureMessage(actual)).To(ContainSubstring("Exported: \"other value\""))
 				Expect(matcherWithDifference.FailureMessage(actual)).To(ContainSubstring("Exported: \"exported field value\""))

matchers/be_identical_to_test.go

@@ -30,7 +30,7 @@ var _ = Describe("BeIdenticalTo", func() {
 		Expect(5).ShouldNot(BeIdenticalTo(3))
 	})
 
-	It("should treat primtives as identical", func() {
+	It("should treat primitives as identical", func() {
 		Expect("5").Should(BeIdenticalTo("5"))
 		Expect("5").ShouldNot(BeIdenticalTo("55"))
 

matchers/be_numerically_matcher_test.go

@@ -120,7 +120,7 @@ var _ = Describe("BeNumerically", func() {
 				})
 
 				Context("and there is a precision parameter", func() {
-					It("should use precision paramter", func() {
+					It("should use precision parameter", func() {
 						Expect(5).Should(BeNumerically("~", 6, 2))
 						Expect(5).ShouldNot(BeNumerically("~", 8, 2))
 						Expect(uint(5)).Should(BeNumerically("~", 6, 1))

matchers/be_temporally_matcher_test.go

@@ -67,7 +67,7 @@ var _ = Describe("BeTemporally", func() {
 				BeforeEach(func() {
 					t2 = t0.Add(3 * time.Second)
 				})
-				It("should use precision paramter", func() {
+				It("should use precision parameter", func() {
 					d := 2 * time.Second
 					Expect(t0).Should(BeTemporally("~", t0, d))
 					Expect(t0).Should(BeTemporally("~", t1, d))

matchers/contain_element_matcher.go

@@ -251,7 +251,7 @@ func (matcher *ContainElementMatcher) Match(actual interface{}) (success bool, e
 	}
 
 	// pick up any findings the test is interested in as it specified a non-nil
-	// result reference. However, the expection always is that there are at
+	// result reference. However, the expectation always is that there are at
 	// least one or multiple findings. So, if a result is expected, but we had
 	// no findings, then this is an error.
 	findings := getFindings()

matchers/contain_element_matcher_test.go

@@ -52,7 +52,7 @@ var _ = Describe("ContainElement", func() {
 		})
 
 		When("passed a correctly typed nil", func() {
-			It("should operate succesfully on the passed in value", func() {
+			It("should operate successfully on the passed in value", func() {
 				var nilSlice []int
 				Expect(nilSlice).ShouldNot(ContainElement(1))
 
@@ -309,7 +309,7 @@ var _ = Describe("ContainElement", func() {
 			})
 
 			When("passed a correctly typed nil", func() {
-				It("should operate succesfully on the passed in value", func() {
+				It("should operate successfully on the passed in value", func() {
 					var nilIter func(func(string) bool)
 					Expect(nilIter).ShouldNot(ContainElement(1))
 

matchers/contain_substring_matcher_test.go

@@ -21,7 +21,7 @@ var _ = Describe("ContainSubstringMatcher", func() {
 	})
 
 	When("actual is a stringer", func() {
-		It("should call the stringer and match agains the returned string", func() {
+		It("should call the stringer and match against the returned string", func() {
 			Expect(&myStringer{a: "Abc3"}).Should(ContainSubstring("bc3"))
 		})
 	})

matchers/have_cap_matcher_test.go

@@ -27,7 +27,7 @@ var _ = Describe("HaveCap", func() {
 	})
 
 	When("passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
+		It("should operate successfully on the passed in value", func() {
 			var nilSlice []int
 			Expect(nilSlice).Should(HaveCap(0))
 

matchers/have_key_matcher_test.go

@@ -40,7 +40,7 @@ var _ = Describe("HaveKey", func() {
 	})
 
 	When("passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
+		It("should operate successfully on the passed in value", func() {
 			var nilMap map[int]string
 			Expect(nilMap).ShouldNot(HaveKey("foo"))
 		})
@@ -89,7 +89,7 @@ var _ = Describe("HaveKey", func() {
 		})
 
 		When("passed a correctly typed nil", func() {
-			It("should operate succesfully on the passed in value", func() {
+			It("should operate successfully on the passed in value", func() {
 				var nilIter2 func(func(string, int) bool)
 				Expect(nilIter2).ShouldNot(HaveKey("foo"))
 			})

matchers/have_key_with_value_matcher_test.go

@@ -43,7 +43,7 @@ var _ = Describe("HaveKeyWithValue", func() {
 	})
 
 	When("passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
+		It("should operate successfully on the passed in value", func() {
 			var nilMap map[int]string
 			Expect(nilMap).ShouldNot(HaveKeyWithValue("foo", "bar"))
 		})
@@ -104,7 +104,7 @@ var _ = Describe("HaveKeyWithValue", func() {
 		})
 
 		When("passed a correctly typed nil", func() {
-			It("should operate succesfully on the passed in value", func() {
+			It("should operate successfully on the passed in value", func() {
 				var nilIter2 func(func(string, int) bool)
 				Expect(nilIter2).ShouldNot(HaveKeyWithValue("foo", 0))
 			})

matchers/have_len_matcher_test.go

@@ -32,7 +32,7 @@ var _ = Describe("HaveLen", func() {
 	})
 
 	When("passed a correctly typed nil", func() {
-		It("should operate succesfully on the passed in value", func() {
+		It("should operate successfully on the passed in value", func() {
 			var nilSlice []int
 			Expect(nilSlice).Should(HaveLen(0))
 
@@ -71,7 +71,7 @@ var _ = Describe("HaveLen", func() {
 		})
 
 		When("passed a correctly typed nil", func() {
-			It("should operate succesfully on the passed in value", func() {
+			It("should operate successfully on the passed in value", func() {
 				var nilIter func(func(string) bool)
 				Expect(nilIter).Should(HaveLen(0))
 

matchers/match_regexp_matcher_test.go

@@ -15,7 +15,7 @@ var _ = Describe("MatchRegexp", func() {
 	})
 
 	When("actual is a stringer", func() {
-		It("should call the stringer and match agains the returned string", func() {
+		It("should call the stringer and match against the returned string", func() {
 			Expect(&myStringer{a: "Abc3"}).Should(MatchRegexp(`[A-Z][a-z]+\d`))
 		})
 	})

matchers/receive_matcher_test.go

@@ -289,7 +289,7 @@ var _ = Describe("ReceiveMatcher", func() {
 		})
 	})
 
-	When("acutal is a non-channel", func() {
+	When("actual is a non-channel", func() {
 		It("should error", func() {
 			var nilChannel chan bool
 

types/types.go

@@ -13,7 +13,7 @@ type GomegaTestingT interface {
 	Fatalf(format string, args ...interface{})
 }
 
-// Gomega represents an object that can perform synchronous and assynchronous assertions with Gomega matchers
+// Gomega represents an object that can perform synchronous and asynchronous assertions with Gomega matchers
 type Gomega interface {
 	Ω(actual interface{}, extra ...interface{}) Assertion
 	Expect(actual interface{}, extra ...interface{}) Assertion