From d1fa8e5125d2191b60a4e4c8b467f08bbee36705 Mon Sep 17 00:00:00 2001 From: John Bampton Date: Tue, 21 Apr 2026 07:46:55 +1000 Subject: [PATCH] misc: fix typos General spelling clean up --- .build/psake/private/Test-ModuleVersion.ps1 | 2 +- .github/linters/codespell.txt | 27 ------------------- .../Compound/Hyphenation/hyphenation.dtd | 2 +- .../Analysis/Core/StopFilterFactory.cs | 2 +- .../Analysis/Util/FilteringTokenFilter.cs | 2 +- .../Support/Sax/Ext/EntityResolver2.cs | 2 +- .../SimpleText/SimpleTextSegmentInfoWriter.cs | 2 +- src/Lucene.Net.Facet/DrillSidewaysScorer.cs | 2 +- .../Taxonomy/WriterCache/NameIntCacheLRU.cs | 2 +- .../Highlight/GradientFormatter.cs | 2 +- .../Highlight/SimpleFragmenter.cs | 2 +- src/Lucene.Net.Replicator/Revision.cs | 2 +- .../Suggest/Analyzing/FreeTextSuggester.cs | 2 +- .../Search/ShardSearchingTestBase.cs | 6 ++--- .../Support/ApiScanTestBase.cs | 4 +-- .../Util/LuceneTestCase.SetUpFixture.cs | 2 +- src/Lucene.Net/Document/FieldType.cs | 2 +- src/Lucene.Net/Index/IndexWriter.cs | 2 +- src/Lucene.Net/Search/Spans/SpanOrQuery.cs | 2 +- src/Lucene.Net/Store/FSDirectory.cs | 2 +- src/Lucene.Net/Store/LockStressTest.cs | 2 +- src/Lucene.Net/Store/SimpleFSLockFactory.cs | 2 +- .../Exceptions/ClassNotFoundException.cs | 2 +- .../Support/Threading/ReentrantLock.cs | 8 +++--- .../Threading/UninterruptableMonitor.cs | 12 ++++----- .../Util/Packed/MonotonicBlockPackedWriter.cs | 2 +- .../SourceCode/SourceCodeExporter.cs | 2 +- .../partials/title.tmpl.partial | 2 +- .../release-notes/version-4.8.0-beta00017.md | 2 +- 29 files changed, 39 insertions(+), 66 deletions(-) diff --git a/.build/psake/private/Test-ModuleVersion.ps1 b/.build/psake/private/Test-ModuleVersion.ps1 index c1c9fb5038..caf181c7b8 100644 --- a/.build/psake/private/Test-ModuleVersion.ps1 +++ b/.build/psake/private/Test-ModuleVersion.ps1 @@ -24,7 +24,7 @@ should be accepted. .PARAMETER lessThanVersion The upper bound of the version that will be accepted. This comparison should - be exlusive. Meaning an input version that is less than only, not equal to + be exclusive. Meaning an input version that is less than only, not equal to this version, will be accepted. .INPUTS A $currentVersion of type [System.Version] or a convertable string. diff --git a/.github/linters/codespell.txt b/.github/linters/codespell.txt index 964d90f171..9cb48d2a09 100644 --- a/.github/linters/codespell.txt +++ b/.github/linters/codespell.txt @@ -35,33 +35,22 @@ analyer andd ane anothers -appraently appropropriate apprpriate aquire -aquired arbitarily arent arguents assemblie -atempt ative atleast atmost -attibute -attibutes -attirbute autor -availble avarage avove bale becaus -begining bellow -betweeen -betwen -beween bloc blockin boostrap @@ -69,10 +58,8 @@ brunch bu bufferin calender -callibrate cant capela -captial categorie celle celles @@ -107,7 +94,6 @@ corelate corespondent correcty corse -couldnt countr covert cunt @@ -133,35 +119,22 @@ doen doens't doesnt dum -duplcate ect ede -elemnts eles elipses -elminate -embeded empress endcodes ende ened entend -enviornment equest -esnure -essentually euclidian everytime -exaclty -excepetion -exeception execeptions -exlusive exmaple explicitely explicity -explict -explictly faild failue fallow diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/hyphenation.dtd b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/hyphenation.dtd index 083c2bd8e8..c42a6b1bd3 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/hyphenation.dtd +++ b/src/Lucene.Net.Analysis.Common/Analysis/Compound/Hyphenation/hyphenation.dtd @@ -54,7 +54,7 @@ diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Core/StopFilterFactory.cs b/src/Lucene.Net.Analysis.Common/Analysis/Core/StopFilterFactory.cs index cd7e8a1446..f781e71519 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/Core/StopFilterFactory.cs +++ b/src/Lucene.Net.Analysis.Common/Analysis/Core/StopFilterFactory.cs @@ -56,7 +56,7 @@ namespace Lucene.Net.Analysis.Core /// /// wordset - This is the default format, which supports one word per /// line (including any intra-word whitespace) and allows whole line comments - /// begining with the "#" character. Blank lines are ignored. See + /// beginning with the "#" character. Blank lines are ignored. See /// for details. /// /// snowball - This format allows for multiple words specified on each diff --git a/src/Lucene.Net.Analysis.Common/Analysis/Util/FilteringTokenFilter.cs b/src/Lucene.Net.Analysis.Common/Analysis/Util/FilteringTokenFilter.cs index 365fe5e173..d99636dbae 100644 --- a/src/Lucene.Net.Analysis.Common/Analysis/Util/FilteringTokenFilter.cs +++ b/src/Lucene.Net.Analysis.Common/Analysis/Util/FilteringTokenFilter.cs @@ -145,7 +145,7 @@ public override void Reset() /// token is incremented. /// // LUCENENET NOTE: Intentionally made this a setter method instead of a property - // because it is obsolete and there is no way to add the attibute to the setter but not + // because it is obsolete and there is no way to add the attribute to the setter but not // the getter of a property. Since it is obsolete, this method will eventually be removed // anyway. [Obsolete("enablePositionIncrements=false is not supported anymore as of Lucene 4.4")] diff --git a/src/Lucene.Net.Benchmark/Support/Sax/Ext/EntityResolver2.cs b/src/Lucene.Net.Benchmark/Support/Sax/Ext/EntityResolver2.cs index 1a58b36c90..b8c2cab051 100644 --- a/src/Lucene.Net.Benchmark/Support/Sax/Ext/EntityResolver2.cs +++ b/src/Lucene.Net.Benchmark/Support/Sax/Ext/EntityResolver2.cs @@ -95,7 +95,7 @@ public interface IEntityResolver2 : IEntityResolver /// other reasons adopt a "no DTDs" policy. /// Non - validation motives include forcing documents to include DTDs so /// that attributes are handled consistently. - /// For example, an XPath processor needs to know which attibutes have + /// For example, an XPath processor needs to know which attributes have /// type "ID" before it can process a widely used type of reference. /// /// Warning: Returning an external subset modifies diff --git a/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoWriter.cs b/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoWriter.cs index 276154391c..a721f7a021 100644 --- a/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoWriter.cs +++ b/src/Lucene.Net.Codecs/SimpleText/SimpleTextSegmentInfoWriter.cs @@ -121,7 +121,7 @@ public override void Write(Directory dir, SegmentInfo si, FieldInfos fis, IOCont } catch (Exception t) when (t.IsThrowable()) { - //Esnure we throw original exeception + //Ensure we throw original exception } } else diff --git a/src/Lucene.Net.Facet/DrillSidewaysScorer.cs b/src/Lucene.Net.Facet/DrillSidewaysScorer.cs index 2484f4647e..c4cbf7e692 100644 --- a/src/Lucene.Net.Facet/DrillSidewaysScorer.cs +++ b/src/Lucene.Net.Facet/DrillSidewaysScorer.cs @@ -227,7 +227,7 @@ private void DoQueryFirstScoring(ICollector collector, DocIdSetIterator[] disis, // TODO: for the "non-costly Bits" we really should // have passed them down as acceptDocs, but - // unfortunately we cannot distinguish today betwen + // unfortunately we cannot distinguish today between // "bits() is so costly that you should apply it last" // from "bits() is so cheap that you should apply it // everywhere down low" diff --git a/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs b/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs index 9ebe1104f5..3431dfb68e 100644 --- a/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs +++ b/src/Lucene.Net.Facet/Taxonomy/WriterCache/NameIntCacheLRU.cs @@ -90,7 +90,7 @@ public interface INameInt32CacheLru } - // LUCENENET specific - defined interface so we can share public and internal members betwen cache + // LUCENENET specific - defined interface so we can share public and internal members between cache // instances. internal interface IInternalNameInt32CacheLru : INameInt32CacheLru { diff --git a/src/Lucene.Net.Highlighter/Highlight/GradientFormatter.cs b/src/Lucene.Net.Highlighter/Highlight/GradientFormatter.cs index ab80bfeccc..a122179bd2 100644 --- a/src/Lucene.Net.Highlighter/Highlight/GradientFormatter.cs +++ b/src/Lucene.Net.Highlighter/Highlight/GradientFormatter.cs @@ -38,7 +38,7 @@ public class GradientFormatter : IFormatter /// Sets the color range for the IDF scores /// /// The score (and above) displayed as maxColor (See - /// which can be used to callibrate scoring scale) + /// which can be used to calibrate scoring scale) /// /// /// The hex color used for representing IDF scores of zero eg diff --git a/src/Lucene.Net.Highlighter/Highlight/SimpleFragmenter.cs b/src/Lucene.Net.Highlighter/Highlight/SimpleFragmenter.cs index 84e5a1afd2..6ae17a2e41 100644 --- a/src/Lucene.Net.Highlighter/Highlight/SimpleFragmenter.cs +++ b/src/Lucene.Net.Highlighter/Highlight/SimpleFragmenter.cs @@ -37,7 +37,7 @@ public SimpleFragmenter() : this(DEFAULT_FRAGMENT_SIZE) { } public SimpleFragmenter(int fragmentSize) { // LUCENENET NOTE: Must not set the property directly - // in case the user decides to override it and produce an excepetion. + // in case the user decides to override it and produce an exception. // Therefore, an auto-implemented property is unacceptable. this.fragmentSize = fragmentSize; } diff --git a/src/Lucene.Net.Replicator/Revision.cs b/src/Lucene.Net.Replicator/Revision.cs index ba353c3366..e35a12b15c 100644 --- a/src/Lucene.Net.Replicator/Revision.cs +++ b/src/Lucene.Net.Replicator/Revision.cs @@ -28,7 +28,7 @@ namespace Lucene.Net.Replicator /// revision will contain files from a single source. However, some applications /// may require to treat a collection of indexes as a single entity so that the /// files from all sources are replicated together, to guarantee consistency - /// beween them. For example, an application which indexes facets will need to + /// between them. For example, an application which indexes facets will need to /// replicate both the search and taxonomy indexes together, to guarantee that /// they match at the client side. /// diff --git a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs index 06abd304db..5033143586 100644 --- a/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs +++ b/src/Lucene.Net.Suggest/Suggest/Analyzing/FreeTextSuggester.cs @@ -542,7 +542,7 @@ public virtual IList DoLookup(string key, } // Carefully fill last tokens with _ tokens; - // ShingleFilter appraently won't emit "only hole" + // ShingleFilter apparently won't emit "only hole" // tokens: int endPosInc = posIncAtt.PositionIncrement; diff --git a/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs b/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs index b0352d2c71..15308133b8 100644 --- a/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs +++ b/src/Lucene.Net.TestFramework/Search/ShardSearchingTestBase.cs @@ -457,7 +457,7 @@ public override TopDocs Search(Query query, int numHits, CancellationToken cance if (nodeID == MyNodeID) { // My node; run using local shard searcher we - // already aquired: + // already acquired: shardHits[nodeID] = LocalSearch(query, numHits, cancellationToken); } else @@ -521,7 +521,7 @@ public override TopDocs SearchAfter(ScoreDoc after, Query query, int numHits, Ca if (nodeID == MyNodeID) { // My node; run using local shard searcher we - // already aquired: + // already acquired: shardHits[nodeID] = LocalSearchAfter(shardAfter, query, numHits, cancellationToken); } else @@ -549,7 +549,7 @@ public override TopFieldDocs Search(Query query, int numHits, Sort sort, Cancell if (nodeID == MyNodeID) { // My node; run using local shard searcher we - // already aquired: + // already acquired: shardHits[nodeID] = LocalSearch(query, numHits, sort, cancellationToken); } else diff --git a/src/Lucene.Net.TestFramework/Support/ApiScanTestBase.cs b/src/Lucene.Net.TestFramework/Support/ApiScanTestBase.cs index 6f2d68e491..0fd502cdfd 100644 --- a/src/Lucene.Net.TestFramework/Support/ApiScanTestBase.cs +++ b/src/Lucene.Net.TestFramework/Support/ApiScanTestBase.cs @@ -56,7 +56,7 @@ public abstract class ApiScanTestBase : LuceneTestCase private static readonly Regex MethodParameterName = new Regex("^[a-z](?:[a-zA-Z0-9_]*[a-zA-Z0-9])?$", RegexOptions.Compiled); /// - /// Interfaces must begin with "I" followed by another captial letter. Note this includes a + /// Interfaces must begin with "I" followed by another capital letter. Note this includes a /// fix for generic interface names, that end with `{number}. /// private static readonly Regex InterfaceName = new Regex("^I[A-Z][a-zA-Z0-9_]*(?:`\\d+)?$", RegexOptions.Compiled); @@ -201,7 +201,7 @@ public virtual void TestClassNames(Type typeFromTargetAssembly) Assert.IsFalse(names.Any(), names.Count() + " invalid class names detected. " + "Class names must be Pascal case, but may not follow the interface naming " + - "convention of captial 'I' followed by another capital letter."); + "convention of capital 'I' followed by another capital letter."); } //[Test, LuceneNetSpecific] diff --git a/src/Lucene.Net.TestFramework/Support/Util/LuceneTestCase.SetUpFixture.cs b/src/Lucene.Net.TestFramework/Support/Util/LuceneTestCase.SetUpFixture.cs index b1d706a900..f54c5e979f 100644 --- a/src/Lucene.Net.TestFramework/Support/Util/LuceneTestCase.SetUpFixture.cs +++ b/src/Lucene.Net.TestFramework/Support/Util/LuceneTestCase.SetUpFixture.cs @@ -60,7 +60,7 @@ private static LuceneTestFrameworkInitializer Initialize(Test setUpFixture, Test // Allow the factories to be instantiated first. We do this to allow a // dependency injection step, which can only be done once. No random context - // is availble here because we need to load the SystemProperties setup here before + // is available here because we need to load the SystemProperties setup here before // we can read them. initializer.DoInitialize(); diff --git a/src/Lucene.Net/Document/FieldType.cs b/src/Lucene.Net/Document/FieldType.cs index 19804295d6..8b6c698443 100644 --- a/src/Lucene.Net/Document/FieldType.cs +++ b/src/Lucene.Net/Document/FieldType.cs @@ -320,7 +320,7 @@ public override sealed string ToString() if (indexOptions != IndexOptions.DOCS_AND_FREQS_AND_POSITIONS) { result.Append(",indexOptions="); - // LUCENENET: duplcate what would happen if you print a null indexOptions in Java + // LUCENENET: duplicate what would happen if you print a null indexOptions in Java result.Append(indexOptions != IndexOptions.NONE ? indexOptions.ToString() : string.Empty); } if (numericType != NumericType.NONE) diff --git a/src/Lucene.Net/Index/IndexWriter.cs b/src/Lucene.Net/Index/IndexWriter.cs index 9b5fac722d..abf0efc1ba 100644 --- a/src/Lucene.Net/Index/IndexWriter.cs +++ b/src/Lucene.Net/Index/IndexWriter.cs @@ -2615,7 +2615,7 @@ private bool UpdatePendingMerges(MergeTrigger trigger, int maxNumSegments) MergePolicy.MergeSpecification spec; if (maxNumSegments != UNBOUNDED_MAX_MERGE_SEGMENTS) { - if (Debugging.AssertsEnabled) Debugging.Assert(trigger == MergeTrigger.EXPLICIT || trigger == MergeTrigger.MERGE_FINISHED, "Expected EXPLICT or MERGE_FINISHED as trigger even with maxNumSegments set but was: {0}", trigger); + if (Debugging.AssertsEnabled) Debugging.Assert(trigger == MergeTrigger.EXPLICIT || trigger == MergeTrigger.MERGE_FINISHED, "Expected EXPLICIT or MERGE_FINISHED as trigger even with maxNumSegments set but was: {0}", trigger); spec = mergePolicy.FindForcedMerges(segmentInfos, maxNumSegments, segmentsToMerge); newMergesFound = spec != null; if (newMergesFound) diff --git a/src/Lucene.Net/Search/Spans/SpanOrQuery.cs b/src/Lucene.Net/Search/Spans/SpanOrQuery.cs index ed4f153b14..fdbd2c62db 100644 --- a/src/Lucene.Net/Search/Spans/SpanOrQuery.cs +++ b/src/Lucene.Net/Search/Spans/SpanOrQuery.cs @@ -169,7 +169,7 @@ public override bool Equals(object o) public override int GetHashCode() { - //If this doesn't work, hash all elemnts together instead. This version was used to reduce time complexity + //If this doesn't work, hash all elements together instead. This version was used to reduce time complexity int h = clauses.GetHashCode(); h ^= (h << 10) | (h >>> 23); h ^= J2N.BitConversion.SingleToRawInt32Bits(Boost); diff --git a/src/Lucene.Net/Store/FSDirectory.cs b/src/Lucene.Net/Store/FSDirectory.cs index 32f2abe578..0164e44fc7 100644 --- a/src/Lucene.Net/Store/FSDirectory.cs +++ b/src/Lucene.Net/Store/FSDirectory.cs @@ -498,7 +498,7 @@ public int ReadChunkSize /// Writes output with /// // LUCENENET specific: Since FileStream does its own buffering, this class was refactored - // to do all checksum operations as well as writing to the FileStream. By doing this we elminate + // to do all checksum operations as well as writing to the FileStream. By doing this we eliminate // the extra set of buffers that were only creating unnecessary memory allocations and copy operations. protected class FSIndexOutput : BufferedIndexOutput { diff --git a/src/Lucene.Net/Store/LockStressTest.cs b/src/Lucene.Net/Store/LockStressTest.cs index 8bd4a32761..e281e47223 100644 --- a/src/Lucene.Net/Store/LockStressTest.cs +++ b/src/Lucene.Net/Store/LockStressTest.cs @@ -70,7 +70,7 @@ public static void Main(string[] args) // " verifierPort = port that LockVerifyServer is listening on\n" + // " lockFactoryClassName = primary LockFactory class that we will use\n" + // " lockDirName = path to the lock directory (only set for Simple/NativeFSLockFactory\n" + - // " sleepTimeMS = milliseconds to pause betweeen each lock obtain/release\n" + + // " sleepTimeMS = milliseconds to pause between each lock obtain/release\n" + // " count = number of locking tries\n" + // "\n" + // "You should run multiple instances of this process, each with its own\n" + diff --git a/src/Lucene.Net/Store/SimpleFSLockFactory.cs b/src/Lucene.Net/Store/SimpleFSLockFactory.cs index 66a73ee102..3d4ebd35ea 100644 --- a/src/Lucene.Net/Store/SimpleFSLockFactory.cs +++ b/src/Lucene.Net/Store/SimpleFSLockFactory.cs @@ -149,7 +149,7 @@ public override bool Obtain() catch (Exception e) // LUCENENET: Some of the exceptions that can happen are not IOException, so we catch everything { // On Windows, on concurrent createNewFile, the 2nd process gets "access denied". - // In that case, the lock was not aquired successfully, so return false. + // In that case, the lock was not acquired successfully, so return false. // We record the failure reason here; the obtain with timeout (usually the // one calling us) will use this as "root cause" if it fails to get the lock. FailureReason = e; diff --git a/src/Lucene.Net/Support/ExceptionHandling/Exceptions/ClassNotFoundException.cs b/src/Lucene.Net/Support/ExceptionHandling/Exceptions/ClassNotFoundException.cs index e7f8e0890d..b70c4f334c 100644 --- a/src/Lucene.Net/Support/ExceptionHandling/Exceptions/ClassNotFoundException.cs +++ b/src/Lucene.Net/Support/ExceptionHandling/Exceptions/ClassNotFoundException.cs @@ -43,7 +43,7 @@ namespace Lucene /// may throw if a static initializer fails, but usually returns null if /// the type is not resolved. So, for compatibility the logic should be adjusted to treat null like a /// in Java. If the method is expected to throw - /// when the type cannot be resolved, then we must explictly throw it when returns null. + /// when the type cannot be resolved, then we must explicitly throw it when returns null. /// // LUCENENET: It is no longer good practice to use binary serialization. // See: https://github.com/dotnet/corefx/issues/23584#issuecomment-325724568 diff --git a/src/Lucene.Net/Support/Threading/ReentrantLock.cs b/src/Lucene.Net/Support/Threading/ReentrantLock.cs index 4e1fc20dd4..cf1531f9c5 100644 --- a/src/Lucene.Net/Support/Threading/ReentrantLock.cs +++ b/src/Lucene.Net/Support/Threading/ReentrantLock.cs @@ -24,11 +24,11 @@ namespace Lucene.Net.Support.Threading /// /// A lock that uses an unfair locking strategy, similar to how it works in Java. This lock is unfair - /// in that it will aquire the lock even if there are any threads waiting on . + /// in that it will acquire the lock even if there are any threads waiting on . /// /// This implementation also does not use FIFO order when waiting on . Each queued thread will continue /// to acquire the lock continually, but yield between each iteration. So, any waiting thread could be next to - /// aquire the lock. This differs from how it works in Java, but the overhead of fixing this behavior with a queue + /// acquire the lock. This differs from how it works in Java, but the overhead of fixing this behavior with a queue /// is probably not worth the cost. /// internal class ReentrantLock @@ -36,7 +36,7 @@ internal class ReentrantLock private readonly object _lock = new object(); /// - /// Tries to aquire the lock. If the lock is not available, the thread will block + /// Tries to acquire the lock. If the lock is not available, the thread will block /// until it can obtain the lock. /// /// FIFO order is not respected on waiting locks. Also, threads that are waiting @@ -79,7 +79,7 @@ public void Unlock() } /// - /// Tries to aquire the lock and immediately returns a boolean value indicating + /// Tries to acquire the lock and immediately returns a boolean value indicating /// whether the lock was obtained. /// /// Threads that call and are diff --git a/src/Lucene.Net/Support/Threading/UninterruptableMonitor.cs b/src/Lucene.Net/Support/Threading/UninterruptableMonitor.cs index ddcaf2a772..29b82ab731 100644 --- a/src/Lucene.Net/Support/Threading/UninterruptableMonitor.cs +++ b/src/Lucene.Net/Support/Threading/UninterruptableMonitor.cs @@ -23,13 +23,13 @@ namespace Lucene.Net.Support.Threading /// /// A drop-in replacement for that doesn't throw - /// when entering locks, but defers the excepetion until a wait or sleep occurs. This is to mimic the behavior in Java, + /// when entering locks, but defers the exception until a wait or sleep occurs. This is to mimic the behavior in Java, /// which does not throw when entering a lock. /// /// NOTE: this is just a best effort. The BCL and other libraries we depend /// on don't take such measures, so any call to an API that we don't own could result /// in a if it attempts to - /// aquire a lock. It is not practical to put a try/catch block around every 3rd party + /// acquire a lock. It is not practical to put a try/catch block around every 3rd party /// API call that attempts to lock. As such, Lucene.NET does not support /// and using it is discouraged. /// See https://github.com/apache/lucenenet/issues/526. @@ -47,13 +47,13 @@ internal static class UninterruptableMonitor /// synchronized keyword in Java, which never throws when the current /// thread is in an interrupted state. It allows us to catch /// in a specific part - /// of the application, rather than allowing it to be thrown anywhere we atempt + /// of the application, rather than allowing it to be thrown anywhere we attempt /// to lock. /// /// NOTE: this is just a best effort. The BCL and other libraries we depend /// on don't take such measures, so any call to an API that we don't own could result /// in a if it attempts to - /// aquire a lock. It is not practical to put a try/catch block around every 3rd party + /// acquire a lock. It is not practical to put a try/catch block around every 3rd party /// API call that attempts to lock. As such, Lucene.NET does not support /// and using it is discouraged. /// See https://github.com/apache/lucenenet/issues/526. @@ -99,13 +99,13 @@ public static void Enter(object obj, ref bool lockTaken) /// synchronized keyword in Java, which never throws when the current /// thread is in an interrupted state. It allows us to catch /// in a specific part - /// of the application, rather than allowing it to be thrown anywhere we atempt + /// of the application, rather than allowing it to be thrown anywhere we attempt /// to lock. /// /// NOTE: this is just a best effort. The BCL and other libraries we depend /// on don't take such measures, so any call to an API that we don't own could result /// in a if it attempts to - /// aquire a lock. It is not practical to put a try/catch block around every 3rd party + /// acquire a lock. It is not practical to put a try/catch block around every 3rd party /// API call that attempts to lock. As such, Lucene.NET does not support /// and using it is discouraged. /// See https://github.com/apache/lucenenet/issues/526. diff --git a/src/Lucene.Net/Util/Packed/MonotonicBlockPackedWriter.cs b/src/Lucene.Net/Util/Packed/MonotonicBlockPackedWriter.cs index 25c7250a36..65b878c7ea 100644 --- a/src/Lucene.Net/Util/Packed/MonotonicBlockPackedWriter.cs +++ b/src/Lucene.Net/Util/Packed/MonotonicBlockPackedWriter.cs @@ -48,7 +48,7 @@ namespace Lucene.Net.Util.Packed /// are the /// zigzag-encoded /// packed () deltas from the expected value (computed from - /// the function) using exaclty BitsPerValue bits per value + /// the function) using exactly BitsPerValue bits per value /// /// /// @lucene.internal diff --git a/src/dotnet/tools/lucene-cli/SourceCode/SourceCodeExporter.cs b/src/dotnet/tools/lucene-cli/SourceCode/SourceCodeExporter.cs index 8997acb072..3dae9ae705 100644 --- a/src/dotnet/tools/lucene-cli/SourceCode/SourceCodeExporter.cs +++ b/src/dotnet/tools/lucene-cli/SourceCode/SourceCodeExporter.cs @@ -32,7 +32,7 @@ public class SourceCodeExporter /// /// Reads the provided source code from the - /// embeded resources within this assembly + /// embedded resources within this assembly /// and writes them out to the . /// /// An of files to export. diff --git a/websites/apidocs/Templates/DefaultTemplateNoAssets/partials/title.tmpl.partial b/websites/apidocs/Templates/DefaultTemplateNoAssets/partials/title.tmpl.partial index 86d295b5e4..71cb547028 100644 --- a/websites/apidocs/Templates/DefaultTemplateNoAssets/partials/title.tmpl.partial +++ b/websites/apidocs/Templates/DefaultTemplateNoAssets/partials/title.tmpl.partial @@ -36,7 +36,7 @@ Event {{name.0.value}} Operator {{name.0.value}} {{/inOperator}} {{#inEii}} -Explict Interface Implementation {{name.0.value}} +Explicit Interface Implementation {{name.0.value}} {{/inEii}} {{#inPackage}} Package {{name.0.value}} diff --git a/websites/site/release-notes/version-4.8.0-beta00017.md b/websites/site/release-notes/version-4.8.0-beta00017.md index 844faaa89a..402fcfbd30 100644 --- a/websites/site/release-notes/version-4.8.0-beta00017.md +++ b/websites/site/release-notes/version-4.8.0-beta00017.md @@ -11,7 +11,7 @@ version: 4.8.0-beta00017 > > [J2N 2.1](https://github.com/NightOwl888/J2N/releases/tag/v2.1.0) and [ICU4N 60.1.0-alpha.436](https://github.com/NightOwl888/ICU4N/releases/tag/v60.1.0-alpha.436) have had major updates which will lay the groundwork for supporting System.Memory types in Lucene.NET, but those updates will be included in a later release. However, both libraries have had a significant reduction in the number of heap allocations used across their codebases and those improvements have a direct impact on how Lucene.NET performs. > -> We are including .NET Core support for Lucene.Net.OpenNLP for the first time using the IKVM `MavenRefernence` feature. The IKVM distribution is quite large and due to disk space limitations of our CI enviornment we had to reference an older version of both IKVM and IKVM.Maven.Sdk. These package references may be upgraded by end users to use a newer version without any risk of breaking changes. +> We are including .NET Core support for Lucene.Net.OpenNLP for the first time using the IKVM `MavenRefernence` feature. The IKVM distribution is quite large and due to disk space limitations of our CI environment we had to reference an older version of both IKVM and IKVM.Maven.Sdk. These package references may be upgraded by end users to use a newer version without any risk of breaking changes. ## Change Log