Download JAR files tagged by public with all dependencies

This is the tonic look-and-feel packaged to be distributed with the SQuirreLSQL client. This pluggable look and feel is a free substitute for the default native look and feel of Swing, 'Metal', distributed under the GNU Lesser General Public License. Metal lacks both in usability and aesthetics. It contains considerable graphical noise, distracting the user from the key elements of the GUI. Tonic, on the other hand, tries to provide a clean, balanced look and an improved feel. Tonic is available free of charge both for commercial and non-commercial applications. It lends a professional touch and a very tidy and clean interface to your Swing based applications.

A tool to help visualise API differences between two different versions of a project. Jardiff takes two jar files and outputs all the public API changes as xml, html or plain text. Currently this is command line driven, though we are working on an ant plugin. It requires java 1.4 to run. <h2>Background</h2> At OSjava, we were using a shell script to work out API differences between our release versions. This unfortunately doesn't scale very well to larger projects, the main reason for jardiff was to do the same in a much shorter time (From memory it was taking minutes to get the API diff from two fairly small jars). In it's current state, jardiff can generate the api differences between rt.jar for java 1.4 and java 1.5 in under 20 seconds, so it should scale to even the largest of projects.

Javonet allows you to reference and use modules or packages written in (Java/Kotlin/Groovy/Clojure, C#/VB.NET, Ruby, Perl, Python, JavaScript/TypeScript) like they were created in your technology. It works on Linux/Windows and MacOS for applications created in JVM, CLR/Netcore, Perl, Python, Ruby, NodeJS, C++ or GoLang and gives you unparalleled freedom and flexibility with native performance in building your mixed-technologies products. Let it be accessing best AI or cryptography libraries, devices SDKs, legacy client modules, internal custom packages or anything from public repositories available on NPM, Nuget, PyPI, Maven/Gradle, RubyGems or GitHub. Get free from programming languages barriers today! For more information check out our guides at https://www.javonet.com/guides/v2/

# geokey K Dimensional Z-Order curve utils. [](https://travis-ci.org/markrileybot/geokey) [](https://coveralls.io/github/markrileybot/geokey?branch=master) [](https://maven-badges.herokuapp.com/maven-central/io.github.markrileybot/geokey) ## Building ./gradlew build ## Gradle dependency See https://search.maven.org/artifact/io.github.markrileybot/geokey/ ## Using ### Use built in keys to make geohashes ```java import org.geokey.GeoKey; // Make a geo hash key String key = new GeoKey().setLatitude(48.669).setLongitude(-4.329).toString(); // "gbsuv7ztqzpts82uzfwq5e1bp" // parse a geo hash key GeoKey gk = new GeoKey("gbsuv7ztqzpts82uzfwq5e1bp"); ``` ### Make a special purpose K-Dimensional key ```java public class GeoTimeKey extends KDKey { private static final KDKeySpec spec = new KDKeySpec.Builder() .addDim(-180, 180, 1) .addDim(-90, 90, 1) .addDim(0, 1L << 62, 1) .setAlphabet(Alphabet.GEO_TIME_HASH) .build(); public GeoTimeKey() { super(spec); } public GeoTimeKey(String s) { super(spec, s); } public GeoTimeKey(byte[] s) { super(spec, s); } public GeoTimeKey setLatitude(double latitude) { set(1, latitude); return this; } public double getLatitude() { return super.get(1); } public GeoTimeKey setLongitude(double longitude) { set(0, longitude); return this; } public double getLongitude() { return super.get(0); } public GeoTimeKey setTime(long time) { set(2, time); return this; } public long getTime() { return (long) get(2); } } ```

ThreadFix is a software vulnerability aggregation and management system that reduces the time it takes to fix software vulnerabilities. ThreadFix imports the results from dynamic, static and manual testing to provide a centralized view of software security defects across development teams and applications. The system allows companies to correlate testing results and streamline software remediation efforts by simplifying feeds to software issue trackers. By auto generating application firewall rules, this tool allows organizations to continue remediation work uninterrupted. ThreadFix empowers managers with vulnerability trending reports that show progress over time, giving them justification for their efforts. ThreadFix is developed and maintained by Denim Group, Ltd (http://www.denimgroup.com) For information about commercial support and other services, contact Denim Group about ThreadFix http://www.denimgroup.com/threadfix/ The ASTAM Correlator is a branch of the public Community Edition of the ThreadFix software. This branch is maintained by Secure Decisions (http://www.securedecisions.com), a Division of Applied Visions, Inc (http://www.avi.com).

Tool used to generate the preferred class information for downloadable JAR files in the form of a META-INF/PREFERRED.LIST required for use by the {@link net.jini.loader.pref.PreferredClassLoader}. The list is generated by examining the dependencies of classes contained within a target JAR file and zero or more additional supporting JAR files. Through various command-line options, a set of "root" classes are identified as belonging to a public API. These root classes provide the starting point for recursively computing a dependency graph, finding all of the classes referenced in the public API of the root classes, finding all of the classes referenced in turn by the public API of those classes, and so on, until no new classes are found. The results of the dependency analysis are combined with the preferred list information in the additional supporting JAR files to compute a preferred list having the smallest number of entries that describes the preferred state of the classes and resources contained in all of the JAR files. The output of the tool is a new version of the target JAR file containing the generated preferred list, and/or a copy of the list printed to System.out.

This is a specialized version of the Clirr Maven Plugin. It adds capabilities for excluding specific error types, as well as separating code into three, rather than two, subgroups: Internal code (no checks) Externally invoked code (Annotated with an "externally invoked" annotation, same as Externally implemented, but adding methods to interfaces and abstract classes is allowed) Externally implemented code (Assumed default. Full backwards compatibility required *unless* an interface is annotated with a defined adaptor annotation, in which case full backwards compatibility is required for the adaptor class, but the rules of @ExternallyInvoked apply to the interface itself) Clirr is a tool that checks Java libraries for binary and source compatibility with older releases. Basically you give it two sets of jar files and Clirr dumps out a list of changes in the public API. The clirr-maven-plugin can be configured to break the build, if it detects incompatible api changes. In a continuous integration process, the clirr-maven-plugin can automatically prevent accidental introduction of binary or source compatibility problems. Additionally, the plugin can generate a report as part of the generated site.

This is the brand new, re-written from scratch plugin for ANTLR v3. Previous valiant efforts all suffered from being unable to modify the ANTLR Tool itself to provide support not just for Maven oriented things but any other tool that might wish to invoke ANTLR without resorting to the command line interface. Rather than try to shoe-horn new code into the existing Mojo (in fact I think that by incorporating a patch supplied by someone I ended up with tow versions of the Mojo, I elected to rewrite everything from scratch, including the documentation, so that we might end up with a perfect Mojo that can do everything that ANTLR v3 supports such as imported grammar processing, proper support for library directories and locating token files from generated sources, and so on. In the end I decided to also change the the ANTLR Tool.java code so that it would be the provider of all the things that a build tool needs, rather than delegating things to 5 different tools. So, things like dependencies, dependency sorting, option tracking, generating sources and so on are all folded back in to ANTLR's Tool.java code, where they belong, and they now provide a public interface to anyone that might want to interface with them. One other goal of this rewrite was to completely document the whole thing to death. Hence even this pom has more comments than funcitonal elements, in case I get run over by a bus or fall off a cliff while skiing. Jim Idle - March 2009

# Pact Spring/JUnit5 Support This module extends the base [Pact JUnit5 module](../pact-jvm-provider-junit5). See that for more details. For writing Spring Pact verification tests with JUnit 5, there is an JUnit 5 Invocation Context Provider that you can use with the `@TestTemplate` annotation. This will generate a test for each interaction found for the pact files for the provider. To use it, add the `@Provider` and `@ExtendWith(SpringExtension.class)` and one of the pact source annotations to your test class (as per a JUnit 5 test), then add a method annotated with `@TestTemplate` and `@ExtendWith(PactVerificationSpringProvider.class)` that takes a `PactVerificationContext` parameter. You will need to call `verifyInteraction()` on the context parameter in your test template method. For example: ```java @ExtendWith(SpringExtension.class) @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT) @Provider(&quot;Animal Profile Service&quot;) @PactBroker public class ContractVerificationTest { @TestTemplate @ExtendWith(PactVerificationSpringProvider.class) void pactVerificationTestTemplate(PactVerificationContext context) { context.verifyInteraction(); } } ``` You will now be able to setup all the required properties using the Spring context, e.g. creating an application YAML file in the test resources: ```yaml pactbroker: host: your.broker.host auth: username: broker-user password: broker.password ``` You can also run pact tests against `MockMvc` without need to spin up the whole application context which takes time and often requires more additional setup (e.g. database). In order to run lightweight tests just use `@WebMvcTest` from Spring and `MockMvcTestTarget` as a test target before each test. For example: ```java @WebMvcTest @Provider(&quot;myAwesomeService&quot;) @PactBroker class ContractVerificationTest { @Autowired private MockMvc mockMvc; @TestTemplate @ExtendWith(PactVerificationInvocationContextProvider.class) void pactVerificationTestTemplate(PactVerificationContext context) { context.verifyInteraction(); } @BeforeEach void before(PactVerificationContext context) { context.setTarget(new MockMvcTestTarget(mockMvc)); } } ``` You can also use `MockMvcTestTarget` for tests without spring context by providing the controllers manually. For example: ```java @Provider(&quot;myAwesomeService&quot;) @PactFolder(&quot;pacts&quot;) class MockMvcTestTargetStandaloneMockMvcTestJava { @TestTemplate @ExtendWith(PactVerificationInvocationContextProvider.class) void pactVerificationTestTemplate(PactVerificationContext context) { context.verifyInteraction(); } @BeforeEach void before(PactVerificationContext context) { MockMvcTestTarget testTarget = new MockMvcTestTarget(); testTarget.setControllers(new DataResource()); context.setTarget(testTarget); } @RestController static class DataResource { @GetMapping(&quot;/data&quot;) @ResponseStatus(HttpStatus.NO_CONTENT) void getData(@RequestParam(&quot;ticketId&quot;) String ticketId) { } } } ``` **Important:** Since `@WebMvcTest` starts only Spring MVC components you can&apos;t use `PactVerificationSpringProvider` and need to fallback to `PactVerificationInvocationContextProvider`

# Pact Junit 5 Extension ## Overview For writing Pact verification tests with JUnit 5, there is an JUnit 5 Invocation Context Provider that you can use with the `@TestTemplate` annotation. This will generate a test for each interaction found for the pact files for the provider. To use it, add the `@Provider` and one of the pact source annotations to your test class (as per a JUnit 4 test), then add a method annotated with `@TestTemplate` and `@ExtendWith(PactVerificationInvocationContextProvider.class)` that takes a `PactVerificationContext` parameter. You will need to call `verifyInteraction()` on the context parameter in your test template method. For example: ```java @Provider(&quot;myAwesomeService&quot;) @PactFolder(&quot;pacts&quot;) public class ContractVerificationTest { @TestTemplate @ExtendWith(PactVerificationInvocationContextProvider.class) void pactVerificationTestTemplate(PactVerificationContext context) { context.verifyInteraction(); } } ``` For details on the provider and pact source annotations, refer to the [Pact junit runner](../pact-jvm-provider-junit/README.md) docs. ## Test target You can set the test target (the object that defines the target of the test, which should point to your provider) on the `PactVerificationContext`, but you need to do this in a before test method (annotated with `@BeforeEach`). There are three different test targets you can use: `HttpTestTarget`, `HttpsTestTarget` and `AmpqTestTarget`. For example: ```java @BeforeEach void before(PactVerificationContext context) { context.setTarget(HttpTestTarget.fromUrl(new URL(myProviderUrl))); // or something like // context.setTarget(new HttpTestTarget(&quot;localhost&quot;, myProviderPort, &quot;/&quot;)); } ``` ## Provider State Methods Provider State Methods work in the same way as with JUnit 4 tests, refer to the [Pact junit runner](../pact-jvm-provider-junit/README.md) docs. ## Modifying the requests before they are sent **Important Note:** You should only use this feature for things that can not be persisted in the pact file. By modifying the request, you are potentially modifying the contract from the consumer tests! Sometimes you may need to add things to the requests that can&apos;t be persisted in a pact file. Examples of these would be authentication tokens, which have a small life span. The Http and Https test targets support injecting the request that will executed into the test template method. You can then add things to the request before calling the `verifyInteraction()` method. For example to add a header: ```java @TestTemplate @ExtendWith(PactVerificationInvocationContextProvider.class) void testTemplate(PactVerificationContext context, HttpRequest request) { // This will add a header to the request request.addHeader(&quot;X-Auth-Token&quot;, &quot;1234&quot;); context.verifyInteraction(); } ``` ## Objects that can be injected into the test methods You can inject the following objects into your test methods (just like the `PactVerificationContext`). They will be null if injected before the supported phase. | Object | Can be injected from phase | Description | | ------ | --------------- | ----------- | | PactVerificationContext | @BeforeEach | The context to use to execute the interaction test | | Pact | any | The Pact model for the test | | Interaction | any | The Interaction model for the test | | HttpRequest | @TestTemplate | The request that is going to be executed (only for HTTP and HTTPS targets) | | ProviderVerifier | @TestTemplate | The verifier instance that is used to verify the interaction |