* Add Optional BeanParam support for JAXRS2Contract
* Fix Code Style
* Commit Build Code Format Changes
* Roll Back Removal of braces
* Make sure jaxrs1 dependencies not avaiable on jaxrs2
* Update JAXRS2ContractWithBeanParamSupportTest.java
* Always Use Enable BeanParam Support
* Roll Back Test Changes
---------
Co-authored-by: Marvin Froeder <velo@users.noreply.github.com>
* Copy-paste JAX-RS to new module to allow jakarta support
* Update README file
* Fix code formatting
* Move jakart module to java11 profile
* Add jakarta to overview map
* Reuse testing code between Jakarta and jaxrs modules
* Reuse testing code between Jakarta and jaxrs modules
* Release jakarta as part of java 11 flow
* Release jakarta as part of java 11 flow
Co-authored-by: Marvin Froeder <velo@users.noreply.github.com>
Co-authored-by: Marvin Froeder <velo.br@gmail.com>
* Add unit test illustrating #1217
* Make sure content-type is limited to a single value
Co-authored-by: Pierre de Soyres <pierre.de-soyres@eptica.com>
This change converts the Java11 module release into two steps:
1. run `mvn install` for just feign-java11 to ensure the dependent
projects exist in the local repo
2. run `mvn deploy` for `feign-java11`
The result should be that only the single module is deployed
* Correcting License Headers
Fixes#1156
Collection Format was encoding query string values unnecessarily
due to changes introduced in #1138 and #1139 that encode template
values before appending them to the query string.
In addition, `decodeSlash` flags that were accidentally removed,
have been restored in QueryTemplate.
* Restoring decodeSlash in QueryTemplate
* Correcting Readme with regards to decodeSlash usage
* Declarative contracts
* Actually using the data structure to read declaritve contracts
* Using declarative contract for jaxrs contracts
* Make possible for contracts to declare parameters as ignored
* Using predicate to decide if an AnnotationProcessor should be invoked
* Restore environment variable for GITHUB_TOKEN
Fixes bug where HeaderTemplate stored values in a HashSet which
caused the following issues:
* Header values could be written in wrong order
* Order was not stable between JVM instances
Fixes#1007
As part of 10.x, the `headers()` and `queries()` collections on the
`RequestTemplate` were made read only. The `JAXRSContract` was still
attempting to manipulate those directly. THis was missed due to a
use case not accounted for in the tests. I've added the appropriate
use case and corrected the usage of the template.
Closes#797Closes#798
JAXRSContract sets a single Content-Type value
This change allows headers to be cleared by passing a null
value for backwards compatibility.
Multiple Content-Type values are not valid because the body
that we send with any given request will only have a single
type.
Updated header entry assertion to be agnostic to header name
order.
* RequestTemplate.headers clear behavior matches that of query params
* Refactoring RequestTemplate to RFC6570
This change refactors `RequestTemplate` in an attempt to
adhere to the [RFC-6570 - URI Template](https://tools.ietf.org/html/rfc6570)
specification more closely. The reason for this is to
reduce the amount of inconsistency between `@Param`, `@QueryMap`,
`@Header`, `@HeaderMap`, and `@Body` template expansion.
First, `RequestTemplate` now delegates uri, header, query, and
body template parsing to `UriTemplate`, `HeaderTemplate`,
`QueryTemplate`, and `BodyTemplate` respectively. These components
are all variations on a `Template`.
`UriTemplate` adheres to RFC 6570 explicitly and supports Level 1
(Simple String) variable expansion. Unresolved variables are ignored
and removed from the uri. This includes query parameter pairs. All
literal and expanded variables are pct-encoded according to the Charset
provided in the `RequestTemplate`.
`HeaderTemplate` supports Level 1 (Simple String) variable expansion.
Unresolved variables are ignored. Empty headers are removed. No
encoding is performed.
`QueryTemplate` is a subset of a `UriTemplate` and reacts in the same
way. Unresolved pairs are ignored and not present on the final
template. All literals and expanded variables are pct-encoded
according to the Charset provided.
`BodyTemplate` supports Level 1 (Simple String) variable expansion.
Unresolved variables produce empty strings. Values are not encoded.
All remaining customizations, including custom encoders, collection format
expansion and charset encoding are still supportted and made backward
compatible.
Finally, a number of inconsistent methods on `RequestTemplate` have
been deprecated for public use and all deprecated usage throughout
the library has been replaced.
* FIXED unsupported jaxrs-2.1 annotations should not break entire interface, resolving #669
* UPDATED jaxrs: more defensive jaxrs2 support
* ADDED jsr311-api dependency to httpclient (as jsr311 is `provided` in feign-jaxrs now)
* UPDATED httpclient `jsr311-api` scope to test
UPDATED jaxrs readme
Before this change, apis that follow patterns across a service could
only be modeled by copy/paste/find/replace. Especially with a large
count, this is monotonous and error prone.
This change introduces support for base apis via single-inheritance
interfaces. Users ensure their target interface bind any type variables
and as a result have little effort to create boilerplate apis.
Ex.
```java
@Headers("Accept: application/json")
interface BaseApi<V> {
@RequestLine("GET /api/{key}")
V get(@Param("key") String);
@RequestLine("GET /api")
List<V> list();
@Headers("Content-Type: application/json")
@RequestLine("PUT /api/{key}")
void put(@Param("key") String, V value);
}
interface FooApi extends BaseApi<Foo> { }
interface BarApi extends BaseApi<Bar> { }
```
closes#133
Files had various formatting differences, as did pull requests. Rather than
create our own style, this inherits and requires the well documented Google
Java Style.
Feign has `MethodMetadata.bodyType()`, but never passed it to encoders.
Encoders that register type adapters need to do so based on the
interface desired as opposed to the implementation class. This change
breaks api compatibility for < 8.x, by requiring an additional arg
on `Encoder.encode`.
see https://github.com/square/retrofit/issues/713
Dagger 1.x and 2.x are incompatible. Rather than choose one over the
other, this change removes Dagger completely. Users can now choose any
injector, constructing Feign via its Builder.
This change also drops support for javax.inject.Named, which has
been replaced by feign.Param.
see #120
AssertJ has more powerful test assertions and does not run the risk of
interfering with the classpath of main code, such as guava does. This
removes guava from test and example code and adjusts using AssertJ in
some cases.
JUnit Rules, such as MockWebServerRule, reduce boilerplate setup present
in our tests. By migrating off TestNG, and onto rules, our tests become
more maintainable as JUnit is well understood.