* refactor: Update to use fasthttp.VisitHeaderParams
The implementation of forEachParameter was upstreamed to fasthttp, so
use that version instead of maintaining our own.
* refactor: use map for header params
The previous implementation of content negotiation used some difficult
to understand techniques in order to reduce allocations, potentially
hurting maintainability. The more natural approach for storing and
comparing unordered media-type parameters is to utilize maps. While the
resulting code still isn't as simple as it could be, it's a step closer.
To reduce allocations, we use a sync.Pool. This actually reduces in fewer
allocations than before at 3 or more parameters. The net result is nearly
identical performance for zero parameters, almost-as-good performance for
1-2 parameters, and better performance for 3+ parameters.
---------
Co-authored-by: Jason McNeil <sixcolors@mac.com>
* ci: explicitly disable tagalign
Tagalign requires awkward manual formatting and doesn't provide much
value for readability.
* ci: enable mirror linter
mirror warns against certain cases of useless conversion between string
and []byte.
* ci: enable perfsprint linter
This linter encourages replacing several functions from the fmt package
with faster alternatives. While fixing issues, I also added a few
exported error types rather than returning a naked errors.New().
* Update linter.yml
* Disable spancheck, fix some of the errors
* Fix ErrorAs, disable go-require from testifylint
* Remove extra space
* Fix all warnings from golangci-lint and revive unused params
* Refactor CopyContextToFiberContext
* Update adaptor.go
* 📚 Docs: Update version numbers for v3
* 📚 Docs: Update template docs to reflect changes in #2848
---------
Co-authored-by: Juan Calderon-Perez <835733+gaby@users.noreply.github.com>
inamedparam enforces that parameters in interface definitions be named.
This is important for clarity so that users and implementers can easily
understand the purpose of each parameter.
* Update listen.go (unform INFO prints at startip + cosmetics)
BEFORE:
```
_______ __
/ ____(_) /_ ___ _____
/ /_ / / __ \/ _ \/ ___/
/ __/ / / /_/ / __/ /
/_/ /_/_.___/\___/_/ v3.0.0-beta.1
--------------------------------------------------
INFO Server started on http://127.0.0.1:8003 (bound on host 0.0.0.0 and port 8003)
INFO Application name: TEST APP
INFO Total handlers count: 5
INFO Prefork: Disabled
INFO PID: 2342
INFO Total process count: 1
20:49:50 | 200 | 593.769µs | 123.123.123.123 | GET | /
```
AFTER:
```
_______ __
/ ____(_) /_ ___ _____
/ /_ / / __ \/ _ \/ ___/
/ __/ / / /_/ / __/ /
/_/ /_/_.___/\___/_/ v3.0.0-beta.1
--------------------------------------------------
INFO Server started on: http://127.0.0.1:8003 (bound on host 0.0.0.0 and port 8003)
INFO Application name: TEST APP
INFO Total handlers count: 5
INFO Prefork: Disabled
INFO PID: 2342
INFO Total process count: 1
20:49:50 | 200 | 593.769µs | 123.123.123.123 | GET | /
```
* fix spacer
* fix indentation for fiber version
* fix linting
* fix linting #2
* fix listen_test.go to match newly expected output.
* fix test again
---------
Co-authored-by: root <root@clicon.hosting-hotmann.de>
Co-authored-by: Martin <martin@hotmann.de>
chore!: Update CSRF and Limiter to remove repetitive names
The `exported` rule of revive warns to not repeat the package name in
method names. For example, prefer `csrf.FromCookie` over
`csrf.CsrfFromCookie`.
This is a breaking change for v3.
It appears that these issues will not be caught by the linter until the
`exported` rule is reenabled. This requires comments on all exported
symbols, which is a much broader effort.
While not all implementations of io.Write will be goroutine safe, the
vast majority of users of the logger middleware are likely to use
os.File, which does implement safe concurrent writes. If users require
locking, they can implement this on an as-needed basis. The risk of
having global locking is that a slow write can hold up the entire
server.
* Functions ctx.Body() and ctx.BodyRaw() respects immutability
* Tests for immutable request body
* Added b.ReportAllocs() & b.ResetTimer() in benchmarks of request body
* Add type-specific local value handling with generics in Ctx
Introduced a new function, Locals, that utilizes Go's generics to handle and retrieve type-specific local values within a request context. This enhancement provides more accurate data type control within the context. Included are tests for generic and custom struct use-cases to ensure the function performs as expected.
* Update documentation for Go generics in Locals method
Added documentation to explain the new version of the Locals method that uses Go's generics feature. This version allows for better control of data types when manipulating and retrieving local values within a request's context. Examples are provided, along with a caution on using correct data types to prevent a runtime panic.
* update ctx.md
* Correct indentation in API documentation
* Refactor Locals function and add new test case
* Refactor Locals function and add new test case
---------
Co-authored-by: Deza Farras Tsany <deza.ftsany@gmail.com>
* Add QueryParser method and tests
Introduced a new method, QueryParser, to parse query parameters from a given context into specified types: integer, boolean, float, and string. The method provides default values for empty or invalid keys. Corresponding tests for each type have also been added to validate the functionality.
* Refactor QueryParser and add string support
Refactored the existing QueryParser method in the code to simplify its structure. Instead of reflecting on types, it now uses explicit type checking. In addition to the existing support for integers, booleans, and floats, the QueryParser method now also supports string parsing. Corresponding tests for the updated method and new feature were added as well.
* Update example call in method comment
Updated the method call example in the comment for the Query function in the ctx.go file. Previously, it was incorrectly demonstrating a call to "QueryParser("wanna_cake", 1)", but this has been updated to correctly represent the method it is commenting, resulting in "Query("wanna_cake", 1)".
* Refactor Query function in ctx.go
The update introduces better type assertion handling in the Query function. A switch statement is now employed to determine the type of the value as opposed to the previous if clauses. In addition, a validation step has been added to ensure the context passed into the function is of the correct type.
* Refactor type handling in Query function
The Query function in ctx.go has been refactored for better and clearer type handling. The code now uses a 'QueryType' interface, replacing explicit string, bool, float, and int declarations. This change also improves the error message when a type assertion fails, making it more descriptive about the specific failure.
* Add type assertion check in ctx.go
Updated the code in ctx.go to add a type assertion check for all case statements. The function now checks if the returned value is of the expected type, and if not, it throws a panic with a description of the failed type assertion.
* Refactor Query function to support more data types
The Query function has been expanded to support a broader range of data types. This includes support for extracting query parameters as different types of integers (both signed and unsigned), strings, floats, and booleans from the request's URI. The function now includes comprehensive parsing capabilities that allow for improved handling of different data types.
* Refactor Query function documentation
The documentation for the Query function has been updated to emphasize its versatility in handling various data types. The changes also clarify how the function operates and demonstrates the usage and benefits of providing a defaultValue. The different variations of QueryBool, QueryFloat, and QueryInt were removed, as they are now encompassed by the enhanced Query function.
* Add benchmark tests for Query function
Benchmark tests have been added to evaluate the performance of the Query function for different data types. These tests will help in assessing the efficiency of the function when processing various queries. The addition of these benchmarks will aid in future optimizations and enhancements of the function.
* Update generic Query function signature
The signature of the generic Query function has been updated to accept different types of data as arguments. The change improves flexibility of the function by allowing it to handle different data types, effectively making it a versatile tool in processing various queries.
* Modify `ctx.Query()` calls in documentation
`ctx.Query()` calls in the ctx.md documentation file were updated to remove the `ctx.` prefix. This is consistent with the typical use cases and makes the code examples more clear and easy to understand.
* Refactored assertValueType function and improved query parameter documentation
Updated the assertValueType function to utilize the utils.UnsafeBytes method for byte conversion. Enhanced the documentation for query parameter types to offer clearer, more comprehensive explanations and examples, including QueryTypeInteger, QueryTypeFloat, and subcategories.
* Update Query method calls to use new fiber.Query syntax
In this commit, the conventional `c.Query()` calls across multiple middleware and document files are updated to use the new `fiber.Query` syntax. The changes align with the updated function signatures in Fiber library that provides type-specific querying. These enhancements contribute to the project's overall robustness and consistency.
* Add Query method to get query string parameters
* Replace 'utils.UnsafeBytes' with 'ctx.app.getBytes'
In the query method, the utils.UnsafeBytes function was replaced with the ctx.app.getBytes method. This change enhances the extraction of query string parameters by making it safer and more context-specific.
* Refactor parsing functions in query handlers
The parsing functions in query handlers have been refactored to simplify the process. Parsing code has been extracted into dedicated functions like 'parseIntWithDefault' and 'parseFloatWithDefault', and they now reside in a new utils file. This modularization improves readability and maintainability of the code. Additionally, documentation is updated to reflect the changes.
* Refactor parsing functions in ctx.go
The parsing functions have been restructured to enhance readability and reduce repetition in the ctx.go file. This was achieved by creating generalised parsing functions that handle defaults and ensure the correct value type is returned. As a result, various single-use parsing functions in the utils.go file have been removed.
* Refactor code to centralize parsing functions
In some cases, loop variables had to be reassigned to a local variable
to avoid concurrent access. This will no longer be needed when fiber's
minimum go version is bumped to 1.22, where each loop iteration gets its
own variable.
There was a test that used the default exponential backoff
configuration, causing the test to run for over 3 minutes. This test
does not increase coverage in a way that warrants the slowdown of CI,
and the default backoff time values are already verified by a separate
test.
nickajacks1
Juan Calderon-Perez
Giovanni Rivera
dependabot[bot]
RW
Martin Hotmann
Joey
Nicholas Jackson
Lino Gomez
Bruno
M. Efe Çetin
Andrey Kuvshinov
Muh Ihsan Nur
ACHMAD IRIANTO EKA PUTRA
naoki kuroda
Leo
Skillers3
Diego Parisi