# Deprecation Note

> [!IMPORTANT]
> This project has been deprecated and is no longer under active development.
>
> Use [Eclipse JKube](https://github.com/eclipse-jkube/jkube) instead.
>
> This project has been rebranded to https://github.com/eclipse-jkube/jkube.
>
> The Fabric8 Maven Plugin is no longer supported.
>
> All new features and support can be requested in the [Eclipse JKube](https://github.com/eclipse-jkube/jkube) project.

## fabric8-maven-plugin

[![Maven Central](https://maven-badges.herokuapp.com/maven-central/io.fabric8/fabric8-maven-plugin/badge.svg?style=flat)](https://maven-badges.herokuapp.com/maven-central/io.fabric8/fabric8-maven-plugin/)
[![Circle CI](https://circleci.com/gh/fabric8io/fabric8-maven-plugin/tree/master.svg?style=shield)](https://circleci.com/gh/fabric8io/fabric8-maven-plugin/tree/master)
[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=io.fabric8%3Afabric8-maven-plugin-build&metric=coverage)](https://sonarcloud.io/dashboard?id=io.fabric8%3Afabric8-maven-plugin-build)
[![Technical Debt](https://sonarcloud.io/api/project_badges/measure?project=io.fabric8%3Afabric8-maven-plugin-build&metric=sqale_index)](https://sonarcloud.io/dashboard?id=io.fabric8%3Afabric8-maven-plugin-build)
[![Dependency Status](https://dependencyci.com/github/fabric8io/fabric8-maven-plugin/badge)](https://dependencyci.com/github/fabric8io/fabric8-maven-plugin)

[![Watch the full asciicast](doc/sample-demo.gif)](https://asciinema.org/a/211595)

### Introduction
This Maven plugin is a one-stop-shop for building and deploying Java applications for Docker, Kubernetes and OpenShift. It brings your Java applications on to Kubernetes and OpenShift. It provides a tight integration into maven and benefits from the build configuration already provided. It focuses on three tasks:
+ Building Docker images
+ Creating OpenShift and Kubernetes resources
+ Deploy application on Kubernetes and OpenShift

### Usage
To enable fabric8 maven plugin on your project just add this to the plugins sections of your pom.xml:

```
      <plugin>
        <groupId>io.fabric8</groupId>
        <artifactId>fabric8-maven-plugin</artifactId>
        <version>${fmp.version}</version>
      </plugin>
```

Want to get started fast? Check out the [Blogpost for Getting Started with Fabric8 Maven Plugin](https://medium.com/@rohaan/using-fabric8-maven-plugin-to-handle-your-kubernetes-openshift-operations-b40f6d3ae63f).

The full documentation can be found in the [User Manual](http://maven.fabric8.io) [[PDF](https://fabric8io.github.io/fabric8-maven-plugin/fabric8-maven-plugin.pdf)]. It supports the following goals:

| Goal                                          | Description                           |
| --------------------------------------------- | ------------------------------------- |
| [`fabric8:resource`](https://fabric8io.github.io/fabric8-maven-plugin/#fabric8:resource) | Create Kubernetes and OpenShift resource descriptors |
| [`fabric8:build`](https://fabric8io.github.io/fabric8-maven-plugin/#fabric8:build) | Build Docker images |
| [`fabric8:push`](https://fabric8io.github.io/fabric8-maven-plugin/#fabric8:push) | Push Docker images to a registry  |
| [`fabric8:deploy`](https://fabric8io.github.io/fabric8-maven-plugin/#fabric8:deploy) | Deploy Kubernetes / OpenShift resource objects to a cluster  |
| [`fabric8:watch`](https://fabric8io.github.io/fabric8-maven-plugin/#fabric8:watch) | Watch for doing rebuilds and restarts |

### Features

* Includes [docker-maven-plugin](https://github.com/fabric8io/docker-maven-plugin) for dealing with Docker images and hence inherits its flexible and powerful configuration.
* Supports both Kubernetes and OpenShift descriptors
* OpenShift Docker builds with a binary source (as an alternative to a direct image build against a Docker daemon)
* Various configuration styles:
  * **Zero Configuration** for a quick ramp-up where opinionated defaults will be pre-selected.
  * **Inline Configuration** within the plugin configuration in an XML syntax.
  * **External Configuration** templates of the real deployment descriptors which are enriched by the plugin.
* Flexible customization:
  * **Generators** analyze the Maven build and generated automatic Docker image configurations for certain systems (spring-boot, plain java, karaf ...)
  * **Enrichers** extend the Kubernetes / OpenShift resource descriptors by extra information like SCM labels and can add default objects like Services.
  * Generators and Enrichers can be individually configured and combined into *profiles*

### OpenShift and Kubernetes Compatibility

:heavy_check_mark: : Supported, all available features can be used

:x: : Not supported at all

:large_blue_circle: : Supported, but not all features can be used

##### OpenShift

| FMP          | Openshift 4.2.0     | Openshift 4.1.0     | OpenShift 3.11.0    | OpenShift 3.10.0    | OpenShift 3.9.0    | OpenShift 3.7.0    | OpenShift 3.6.0    |
|--------------|---------------------|---------------------|---------------------|---------------------|--------------------|--------------------|--------------------|
| FMP 4.4.2    | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 4.3.1    | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 4.3.0    | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 4.2.0    | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 4.1.0    | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 4.0.0    | :large_blue_circle: | :large_blue_circle: | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 4.0.0-M1 | :large_blue_circle: | :large_blue_circle: | :large_blue_circle: | :large_blue_circle: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 4.0.0-M2 | :large_blue_circle: | :large_blue_circle: | :large_blue_circle: | :large_blue_circle: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.42   | :x:                 | :x:                 | :x:                 | :large_blue_circle: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.41   | :x:                 | :x:                 | :x:                 | :large_blue_circle: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.40   | :x:                 | :x:                 | :x:                 | :large_blue_circle: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.39   | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.38   | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.37   | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.35   | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.34   | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.33   | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.32   | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: |

##### Kubernetes

| FMP          | Kubernetes 1.15.3  | Kubernetes 1.14.2  | Kubernetes 1.12.0   | Kubernetes 1.11.0   | Kubernetes 1.10.0   | Kubernetes 1.9.0    | Kubernetes 1.8.0   | Kubernetes 1.7.0   | Kubernetes 1.6.0   | Kubernetes 1.5.1   | Kubernetes 1.4.0   |
|--------------|--------------------|--------------------|---------------------|---------------------|---------------------|---------------------|--------------------|--------------------|--------------------|--------------------|--------------------|
| FMP 4.4.2    | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:                | :x:                |
| FMP 4.3.1    | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:                | :x:                |
| FMP 4.3.0    | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:                | :x:                |
| FMP 4.2.0    | :x:                | :heavy_check_mark: | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:                | :x:                |
| FMP 4.1.0    | :x:                | :x:                | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:                | :x:                |
| FMP 4.0.0    | :x:                | :x:                | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:                | :x:                |
| FMP 4.0.0-M2 | :x:                | :x:                | :large_blue_circle: | :large_blue_circle: | :large_blue_circle: | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:                | :x:                |
| FMP 4.0.0-M1 | :x:                | :x:                | :large_blue_circle: | :large_blue_circle: | :large_blue_circle: | :heavy_check_mark:  | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x:                | :x:                |
| FMP 3.5.42   | :x:                | :x:                | :large_blue_circle: | :large_blue_circle: | :large_blue_circle: | :large_blue_circle: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.41   | :x:                | :x:                | :x:                 | :x:                 | :x:                 | :large_blue_circle: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.40   | :x:                | :x:                | :x:                 | :x:                 | :x:                 | :large_blue_circle: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.39   | :x:                | :x:                | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.38   | :x:                | :x:                | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.37   | :x:                | :x:                | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.35   | :x:                | :x:                | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.34   | :x:                | :x:                | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.33   | :x:                | :x:                | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
| FMP 3.5.32   | :x:                | :x:                | :x:                 | :x:                 | :x:                 | :x:                 | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |

### Documentation and Support

* [User Manual](http://maven.fabric8.io) [[PDF](https://fabric8io.github.io/fabric8-maven-plugin/fabric8-maven-plugin.pdf)]
* Examples are in the [samples](samples/) directory
* Many [fabric8 Quickstarts](https://github.com/fabric8-quickstarts) use this plugin and are good showcases, too.
* You'll find us in the [fabric8 community](http://fabric8.io/community/) and on IRC freenode in channel [#fabric8](https://webchat.freenode.net/?channels=fabric8) and we are happy to answer any questions.
* Contributions are highly appreciated and encouraged. Please send us Pull Requests.

### fabric8-maven-plugin 3 vs. 2

> This is a complete rewrite of the former fabric8-maven plugin. It does not share the same configuration syntax,
> but migration should be straight forward - please use the [fabric8:migrate goal from 2.x of the plugin](http://fabric8.io/guide/mavenFabric8Migrate.html).


[![Java CI with Maven](https://github.com/alibaba/jetcache/actions/workflows/maven.yml/badge.svg)](https://github.com/alibaba/jetcache/actions/workflows/maven.yml)
[![Coverage Status](https://coveralls.io/repos/github/alibaba/jetcache/badge.svg?branch=master)](https://coveralls.io/github/alibaba/jetcache?branch=master)
[![GitHub release](https://img.shields.io/github/release/alibaba/jetcache.svg)](https://github.com/alibaba/jetcache/releases)
[![License](https://img.shields.io/badge/license-Apache%202-4EB1BA.svg)](https://www.apache.org/licenses/LICENSE-2.0.html)
[![Project Map](https://sourcespy.com/shield.svg)](https://sourcespy.com/github/alibabajetcache/)

# Introduction
JetCache is a Java cache abstraction which provides uniform usage for different caching solutions.
It provides more powerful annotations than those in Spring Cache. The annotations in JetCache supports native TTL,
two level caching, and automatically refresh in distrubuted environments, also you can manipulate ```Cache``` instance by your code.
Currently, there are four implementations: ```RedisCache```, ```TairCache```(not open source on github), ```CaffeineCache``` (in memory) and a simple ```LinkedHashMapCache``` (in memory).
Full features of JetCache:
* Manipulate cache through uniform Cache API.
* Declarative method caching using annotations with TTL(Time To Live) and two level caching support
* Create & configure ```Cache``` instance with cache manager
* Automatically collect access statistics for ```Cache``` instance and method level cache
* The strategy of key generation and value serialization can be customized
* Cache key convertor supported: ```fastjson```/```fastjson2```/```jackson```; Value convertor supported: ```java```/```kryo```/```kryo5```
* Distributed cache auto refresh and distributed lock. (2.2+)
* Asynchronous access using Cache API (2.2+, with redis lettuce client)
* Invalidate local caches (in all JVM process) after updates (2.7+)
* Spring Boot support

requirements:
* JDK1.8
* Spring Framework4.0.8+ (optional, with annotation support)，jetcache 2.7 need 5.2.4+
* Spring Boot1.1.9+ (optional), jetcache 2.7 need 2.2.5+

Visit [docs](docs/EN/Readme.md) for more details.

# Getting started

## Method cache
Declare method cache using ```@Cached``` annotation.
```expire = 3600``` indicates that the elements will expire in 3600 seconds after being set.
JetCache automatically generates the cache key with all the parameters.
```java
public interface UserService {
    @Cached(expire = 3600, cacheType = CacheType.REMOTE)
    User getUserById(long userId);
}
```

Using ```key``` attribute to specify cache key using [SpEL](https://docs.spring.io/spring/docs/4.2.x/spring-framework-reference/html/expressions.html) script.
```java
public interface UserService {
    @Cached(name="userCache-", key="#userId", expire = 3600)
    User getUserById(long userId);

    @CacheUpdate(name="userCache-", key="#user.userId", value="#user")
    void updateUser(User user);

    @CacheInvalidate(name="userCache-", key="#userId")
    void deleteUser(long userId);
}
```
In order to use parameter name such as ```key="#userId"```, you javac compiler target must be 1.8 and above, and the ```-parameters``` should be set. Otherwise, use index to access parameters like ```key="args[0]"```

Auto refreshment:
```java
public interface SummaryService{
    @Cached(expire = 3600, cacheType = CacheType.REMOTE)
    @CacheRefresh(refresh = 1800, stopRefreshAfterLastAccess = 3600, timeUnit = TimeUnit.SECONDS)
    @CachePenetrationProtect
    BigDecimal summaryOfToday(long categoryId);
}
```
CachePenetrationProtect annotation indicates that the cache will be loaded synchronously in multi-thread environment.

## Cache API
Create a ```Cache``` instance with ```CacheManager```:

```java
@Autowired
private CacheManager cacheManager;
private Cache<String, UserDO> userCache;

@PostConstruct
public void init() {
    QuickConfig qc = QuickConfig.newBuilder("userCache")
        .expire(Duration.ofSeconds(100))
        .cacheType(CacheType.BOTH) // two level cache
        .localLimit(50)
        .syncLocal(true) // invalidate local cache in all jvm process after update
        .build();
    userCache = cacheManager.getOrCreateCache(qc);
}
```
The code above create a ```Cache``` instance. ```cacheType = CacheType.BOTH``` define a two level cache (a local in-memory-cache and a remote cache system) with local elements limited upper to 50(LRU based evict). You can use it like a map:
```java
UserDO user = userCache.get(12345L);
userCache.put(12345L, loadUserFromDataBase(12345L));
userCache.remove(12345L);

userCache.computeIfAbsent(1234567L, (key) -> loadUserFromDataBase(1234567L));
```

## Advanced API
Asynchronous API:
```java
CacheGetResult r = cache.GET(userId);
CompletionStage<ResultData> future = r.future();
future.thenRun(() -> {
    if(r.isSuccess()){
        System.out.println(r.getValue());
    }
});
```

Distributed lock:
```java
cache.tryLockAndRun("key", 60, TimeUnit.SECONDS, () -> heavyDatabaseOperation());
```

Read through and auto refresh:
```java
@Autowired
private CacheManager cacheManager;
private Cache<String, Long> orderSumCache;

@PostConstruct
public void init() {
    QuickConfig qc = QuickConfig.newBuilder("userCache")
        .expire(Duration.ofSeconds(3600))
        .loader(this::loadOrderSumFromDatabase)
        .refreshPolicy(RefreshPolicy.newPolicy(60, TimeUnit.SECONDS).stopRefreshAfterLastAccess(100, TimeUnit.SECONDS))
        .penetrationProtect(true)
        .build();
    orderSumCache = cacheManager.getOrCreateCache(qc);
}
```

## Configuration with Spring Boot

pom:
```xml
<dependency>
    <groupId>com.alicp.jetcache</groupId>
    <artifactId>jetcache-starter-redis</artifactId>
    <version>${jetcache.latest.version}</version>
</dependency>
```

App class:
```java
@SpringBootApplication
@EnableMethodCache(basePackages = "com.company.mypackage")
@EnableCreateCacheAnnotation // deprecated in jetcache 2.7, can be removed if @CreateCache is not used
public class MySpringBootApp {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApp.class);
    }
}
```

spring boot application.yml config:
```yaml
jetcache:
  statIntervalMinutes: 15
  areaInCacheName: false
  local:
    default:
      type: linkedhashmap #other choose：caffeine
      keyConvertor: fastjson2 #other choose：fastjson/jackson
      limit: 100
  remote:
    default:
      type: redis
      keyConvertor: fastjson2 #other choose：fastjson/jackson
      broadcastChannel: projectA
      valueEncoder: java #other choose：kryo/kryo5
      valueDecoder: java #other choose：kryo/kryo5
      poolConfig:
        minIdle: 5
        maxIdle: 20
        maxTotal: 50
      host: ${redis.host}
      port: ${redis.port}
```
> Visit [detail configuration](docs/EN/Config.md) for more instructions
## More docs
Visit [docs](docs/EN/Readme.md) for more details.

For upgrade see [changelog](https://github.com/alibaba/jetcache/wiki/Changelog) and [compatibility notes](docs/EN/Compatibility.md).


# README #

### ![Logo](docs/images/logo.png) ###

* Use Skin Composer to create skins for libGDX's Scene2D.UI!
* Version 58
* Live preview of all widgets with configurable options
* Specify tinted, tiled, and custom created Drawables right in the editor
* Includes BitmapFont editor and Image font generator like Shoebox
* Freetype support and custom serializer to generate fonts from Json
* Nine-Patch editor with batch functions for multiple images
* Integrated support for [TenPatch](https://github.com/raeleus/TenPatch) allowing for smart-resizing, animated UI's
* Include [TinyVG](https://github.com/lyze237/gdx-TinyVG) for SVG-like vector graphics and unlimited scaling
* Implement your own classes allowing for extended Skin functionality
* Create basic Scene2D layouts with Scene Composer
* Implements a rich text editor for [TextraTypist](https://github.com/tommyettinger/textratypist#textratypist) TypingLabel
* VisUI template and sample projects included

# [DOWNLOAD HERE](https://github.com/raeleus/skin-composer/releases) #

![Skins Preview](docs/images/skins-preview.png)

See more examples and sample code at [Ray3k](https://ray3k.wordpress.com/artwork/ "Free Scene2D UI Skins")

### Contact ###

* This project is maintained by Raymond "Raeleus" Buckley
* http://ray3k.wordpress.com
* raymond.ray3k (at) gmail.com

### Notes ###

Skin Composer now has a wiki: [start here](https://github.com/raeleus/skin-composer/wiki) to begin learning!

If you are unable to run the Windows installer, use the JAR version with JDK version 11 or higher.

To run Skin Composer on OSX, please see the [wiki](https://github.com/raeleus/skin-composer/wiki/Getting-Started-With-Mac "Getting Started With Mac") for details.

If you are unable to open file dialogs on your platform, try the commandline option -swingfd to switch to Swing dialogs.

Video tutorials are available on [YouTube](https://www.youtube.com/playlist?list=PLl-_-0fPSXFfHiRAFpmLCuQup10MUJwcA).

### Contributors and Forking ###

Skin Composer requires the Spine Runtime. The Spine Runtime requires a Spine license to redistribute. Please see the [Spine Editor License](http://esotericsoftware.com/spine-editor-license).

The installer/uninstaller depends on mt.exe (to give the executable admin rights) and WinRAR (to collect the files into a single executable EXE). You need to install the [WinRAR (x64)](https://www.rarlab.com/download.htm) and the [Windows 10 SDK](https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk/) with the options "Windows SDK Signing Tools for Desktop Apps" and "Windows SDK for UWP Managed Apps". Run the task ":installer:jpackageZip" on a Windows 10 host computer. The final distributable zip is created in /installer/build/winrar

If you have trouble compiling or running the app from source, try using JDK 13.

### License ###
MIT License

Copyright (c) 2024 Raymond Buckley

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


# hsweb4 基于spring-boot2,全响应式的后台管理框架

[![Codecov](https://codecov.io/gh/hs-web/hsweb-framework/branch/4.0.x/graph/badge.svg)](https://codecov.io/gh/hs-web/hsweb-framework/branch/master)
[![Build Status](https://api.travis-ci.com/hs-web/hsweb-framework.svg?branch=4.0.x)](https://travis-ci.com/hs-web/hsweb-framework)
[![License](https://img.shields.io/badge/license-Apache%202-4EB1BA.svg?style=flat-square)](https://www.apache.org/licenses/LICENSE-2.0.html)

# 功能,特性

- [x] 基于[r2dbc](https://github.com/r2dbc) ,[easy-orm](https://github.com/hs-web/hsweb-easy-orm/tree/4.0.x) 的通用响应式CRUD
    - [x] H2,Mysql,SqlServer,PostgreSQL
- [x] 响应式r2dbc事务控制
- [x] 响应式权限控制,以及权限信息获取
    - [x] RBAC权限控制
    - [x] 数据权限控制
    - [ ] 双因子验证
- [x] 多维度权限管理功能
- [x] 响应式缓存
- [ ] 非响应式支持(mvc,jdbc)
- [ ] 内置业务功能
    - [x] 权限管理
        - [x] 用户管理
        - [x] 权限设置
        - [x] 权限分配
    - [ ] 文件上传
        - [x] 静态文件上传
        - [ ] 文件秒传
    - [x] 数据字典

# 示例

https://github.com/zhou-hao/hsweb4-examples

## 应用场景

1. 完全开源的后台管理系统.
2. 模块化的后台管理系统.
3. 功能可拓展的后台管理系统.
4. 集成各种常用功能的后台管理系统.
5. 前后分离的后台管理系统.

注意:
项目主要基于`spring-boot`,`spring-webflux`. 在使用`hsweb`之前,你应该对 [project-reactor](https://projectreactor.io/) ,
[spring-boot](https://github.com/spring-projects/spring-boot) 有一定的了解.

项目模块太多?不要被吓到.我们不推荐将本项目直接`clone`后修改,运行.而是使用maven依赖的方式使用`hsweb`. 选择自己需要的模块进行依赖,正式版发布后,所有模块都将发布到maven中央仓库.

## 文档

各个模块的使用方式查看对应模块下的 `README.md`,在使用之前, 你可以先粗略浏览一下各个模块,对每个模块的作用有大致的了解.

## 核心技术选型

1. Java 8
2. Maven3
3. Spring Boot 2.x
4. Project Reactor 响应式编程框架
5. hsweb easy orm 对r2dbc的orm封装

## 模块简介

| 模块       |     说明     |
| ------------- |:----------:|
|[hsweb-authorization](hsweb-authorization)|    权限控制    |
|[hsweb-commons](hsweb-commons) |   基础通用功能   |
|[hsweb-concurrent](hsweb-concurrent)|  并发包,缓存,等  |
|[hsweb-core](hsweb-core)| 框架核心,基础工具类 |
|[hsweb-datasource](hsweb-datasource)|    数据源     |
|[hsweb-logging](hsweb-logging)|     日志     |
|[hsweb-starter](hsweb-starter)|   模块启动器    |
|[hsweb-system](hsweb-system)| **系统常用功能** |

## 核心特性

1. 响应式,首个基于spring-webflux,r2dbc,从头到位的响应式.
2. DSL风格,可拓展的通用curd,支持前端直接传参数,无需担心任何sql注入.

```java
  //where name = #{name}
  createQuery()
          .where("name",name)
          .fetch();

          //update s_user set name = #{user.name} where id = #{user.id}
          createUpdate()
          .set(user::getName)
          .where(user::getId)
          .execute();

```

3. 类JPA增删改

```java

@Table(name = "s_entity")
public class MyEntity {

    @Id
    private String id;

    @Column
    private String name;

    @Column
    private Long createTime;
}

```

直接注入即可实现增删改查

```java

@Autowire
private ReactiveRepository<MyEntity, String> repository;

```

2. 灵活的权限控制

```java

@PostMapping("/account")
@SaveAction
public Mono<String> addAccount(@RequestBody Mono<Account> account){
     return accountService.doSave(account);
}

```

## License

[Apache 2.0](https://github.com/spring-projects/spring-boot/blob/main/LICENSE.txt)

[![Stargazers over time](https://starchart.cc/hs-web/hsweb-framework.svg?variant=adaptive)](https://starchart.cc/hs-web/hsweb-framework)


# TLS-Attacker

![GitHub release (latest by date)](https://img.shields.io/github/v/release/tls-attacker/TLS-Attacker)
![licence](https://img.shields.io/badge/License-Apachev2-brightgreen.svg)
[![Build Status](https://hydrogen.cloud.nds.rub.de/buildStatus/icon.svg?job=TLS-Attacker)](https://hydrogen.cloud.nds.rub.de/job/TLS-Attacker/)

TLS-Attacker is a Java-based framework for analyzing TLS libraries. It is able to send arbitrary protocol messages in an arbitrary order to the TLS peer, and define their modifications using a provided interface. This gives the developer an opportunity to easily define a custom TLS protocol flow and test it against his TLS library.

**Please note:**  *TLS-Attacker is a research tool intended for TLS developers and pentesters. There is no GUI and no green/red lights.*

## Compiling and Running

In order to compile and use TLS-Attacker, you need to have Java and Maven installed. On Ubuntu you can install Maven by running:

```bash
$ sudo apt-get install maven
```

TLS-Attacker currently needs Java JDK 11 to run.

If you have the correct Java version you can run the maven command from the TLS-Attacker directory:

```bash
$ git clone https://github.com/tls-attacker/TLS-Attacker.git
$ cd TLS-Attacker
$ mvn clean install
```

Alternatively, if you are in a hurry, you can skip the tests by using:

```bash
$ mvn clean install -DskipTests=true
```

The resulting jar files are placed in the "apps" folder.

If you want to use this project as a dependency, you do not have to compile it yourself and can include it in your pom
.xml as follows.

```xml
<dependency>
    <groupId>de.rub.nds.tls.attacker</groupId>
    <artifactId>tls-attacker</artifactId>
    <version>5.2.1</version>
    <type>pom</type>
</dependency>
```

TLS-Attacker ships with demo applications which provide you easy access to TLS-Attacker functionality.

You can run TLS-Attacker as a client with the following command:

```bash
$ cd apps
$ java -jar TLS-Client.jar -connect [host:port]
```

or as a server with:

```bash
$ java -jar TLS-Server.jar -port [port]
```

TLS-Attacker also ships with some example attacks on TLS to show you how easy it is to implement an attack with TLS-Attacker.
You can run those examples with the following command:

```bash
$ java -jar Attacks.jar [Attack] -connect [host:port]
```

Although these example applications are very powerful in itself, TLS-Attacker unleashes its full potential when used as a programming library.

## Code Structure

TLS-Attacker consists of several (maven) projects:
- TLS-Client: The client example application
- TLS-Core: The protocol stack and heart of TLS-Attacker
- TLS-Mitm: A prototype for MitM workflows
- TLS-Server: The server example application
- TLS-Proxy: Use TLS-Attacker for SSLSockets
- TraceTool: Inspection and modification of TLS-Attacker workflow traces
- Transport: Transport utilities for lower layers
- Utils: A collection of utility classes

![TLS-Attacker design](https://github.com/tls-attacker/TLS-Attacker/blob/master/resources/figures/design.png)

You can find more information about these modules in the Wiki.

## Features

Currently, the following features are supported:
- SSL 3, TLS versions 1.0 (RFC-2246), 1.1 (RFC-4346), 1.2 (RFC-5246), and 1.3 (RFC-8446)
- SSL 2 (Partially supported)
- (EC)DH(E), RSA, PSK, SRP, GOST and ANON key exchange algorithms
- CBC, AEAD and Streamciphers (AES, CAMELLIA, DES, 3DES, IDEA, RC2, ARIA, GOST_28147_CNT_IMIT, RC4, SEED, NULL)
- ~300 Cipher suites, ~30 Extensions
- Client and Server
- HTTPS
- Workflows with more than two parties
- Lots of extensions
- Tokenbinding (EC) and Tokenbinding over HTTP
- Sockets
- TLS 1.3 0-RTT
- STARTTLS
- ...

## Usage

Here we present some very simple examples on using TLS-Attacker.

First, you need to start a TLS server (*please do not use public servers*). Please run the keygen.sh script if not done before. For example, you can use an OpenSSL test server:

```
$ cd TLS-Attacker/resources
$ openssl s_server -key rsa1024key.pem -cert rsa1024cert.pem
```

This command starts a TLS server on a port 4433.

If you want to connect to a server, you can use this command:

```bash
$ cd TLS-Attacker/apps
$ java -jar TLS-Client.jar -connect localhost:4433
```

*Note: If this Handshake fails, it is probably because you did not specify a concrete cipher suite. TLS-Attacker will not completely respect server selected cipher suites.*

You can use a different cipher suite, TLS version, or connect to a different port with the following parameters:

```bash
$ java -jar TLS-Client.jar -connect localhost:4433 -cipher TLS_RSA_WITH_AES_256_CBC_SHA -version TLS11
```

In case you are a more experienced developer, you can create your own TLS message flow by writing Java code. For example:

```java
Config config = Config.createConfig();
WorkflowTrace trace = new WorkflowTrace();
trace.addTlsAction(new SendAction(new ClientHelloMessage()));
trace.addTlsAction(new ReceiveAction(new ServerHelloMessage()));
State state = new State(config, trace);
DefaultWorkflowExecutor executor = new DefaultWorkflowExecutor(state);
executor.executeWorkflow();
```

TLS-Attacker uses the concept of WorkflowTraces to define a "TLS message flow". A WorkflowTrace consists of a list of actions which are then executed one after the other. Although for a typical "TLS message flow" only SendAction's and ReceiveAction's are needed, the framework does not stop here and implements a lot of different other actions which can be used to execute even more arbitrary message flows. A list of currently implemented actions with explanations can be found in the Wiki.

We know many of you hate Java. Therefore, you can also use an XML structure and run your customized TLS protocol from XML:

```xml
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<workflowTrace>
    <Send>
        <messages>
            <ClientHello>
                <extensions>
                    <ECPointFormat/>
                    <HeartbeatExtension/>
                    <EllipticCurves/>
                </extensions>
            </ClientHello>
        </messages>
    </Send>
    <Receive>
        <expectedMessages>
            <ServerHello>
                <extensions>
                    <ECPointFormat/>
                </extensions>
            </ServerHello>
            <Certificate/>
            <ServerHelloDone/>
        </expectedMessages>
    </Receive>
    <Send>
        <messages>
            <RSAClientKeyExchange>
                <computations/>
            </RSAClientKeyExchange>
            <ChangeCipherSpec/>
            <Finished/>
        </messages>
    </Send>
    <Receive>
        <expectedMessages>
            <ChangeCipherSpec/>
            <Finished/>
        </expectedMessages>
    </Receive>
</workflowTrace>
```

Given this XML structure is located in TLS-Attacker/apps/workflow.xml, you would just need to execute:

```bash
$ java -jar TLS-Client.jar -connect [host]:[port] -workflow_input workflow.xml
```

## Protocol-Attacker/Layer System

Originally designed to attack the TLS protocol, TLS-Attacker is capable of supporting arbitrary protocols. To this end, TLS-Attacker assigns a layer stack to each connection. This layer stack consists of the different protocol layers the user wants to utilize. With the layer stack, the user can add layers like DTLS, or HTTP (more are WIP) in an arbitrary order.

To send and receive arbitrary messages using a layer stack, the user can define configurations for each layer. These configurations specifiy which messages to send or receive. This also allows the user to specify the layer specific messages/data containers for each layer. For example, one could specify the TLS messages and records TLS-Attacker should send. TLS-Attacker would encapsulate the given TLS messages into the records automatically.

## Modifiable Variables

TLS-Attacker uses the concept of Modifiable Variables to allow runtime modifications to predefined Workflows. Modifiable variables allow one to set modifications to basic types after or before their values are actually set. When their actual values are determined and one tries to access the value via getters the original value will be returned in a modified form accordingly. More details on this concept can be found at https://github.com/tls-attacker/ModifiableVariable.

```java
ModifiableInteger i = new ModifiableInteger();
i.setOriginalValue(30);
i.setModification(new AddModification(20));
System.out.println(i.getValue());  // 50
```

In this example, we defined a new ModifiableInteger and set its value to 30. Next, we defined a new modification AddModification which simply returns a sum of two integers. We set its value to 20. If we execute the above program, the result 50 is printed.

We can of course use this concept by constructing our TLS workflows. Imagine you want to test a server for a heartbleed vulnerability. For this purpose, you need to increase the payload length in the heartbeat request. With TLS-Attacker, you can do this as follows:

```xml
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<workflowTrace>
    <Send>
        <messages>
            <ClientHello>
                <extensions>
                    <ECPointFormat/>
                    <HeartbeatExtension/>
                    <EllipticCurves/>
                </extensions>
            </ClientHello>
        </messages>
    </Send>
    <Receive>
        <expectedMessages>
            <ServerHello>
                <extensions>
                    <ECPointFormat/>
                </extensions>
            </ServerHello>
            <Certificate/>
            <ServerHelloDone/>
        </expectedMessages>
    </Receive>
    <Send>
        <messages>
            <RSAClientKeyExchange>
                <computations/>
            </RSAClientKeyExchange>
            <ChangeCipherSpec/>
            <Finished/>
        </messages>
    </Send>
    <Receive>
        <expectedMessages>
            <ChangeCipherSpec/>
            <Finished/>
        </expectedMessages>
    </Receive>
    <Send>
        <messages>
            <Heartbeat>
                <payloadLength>
                    <IntegerExplicitValueModification>
                        <explicitValue>20000</explicitValue>
                    </IntegerExplicitValueModification>
                </payloadLength>
            </Heartbeat>
        </messages>
    </Send>
    <Receive>
        <messages>
            <Heartbeat/>
        </messages>
    </Receive>
</workflowTrace>
```

As you can see, we explicitly increased the payload length of the heartbeat message by 20000.
If you run the attack against the vulnerable server (e.g., OpenSSL 1.0.1f), you should see a valid heartbeat response.

Further examples on attacks and further explanations on TLS-Attacker can be found in the wiki.

## Advanced Features

Some actions require context, or configuration to be executed correctly. For example, if TLS-Attacker tries to send a ClientHello message, it needs to know which values to
put into the message, e.g., which Cipher suites or which protocol version to use. TLS-Attacker draws this information
from a configuration file (default located in TLS-Core/src/main/resources/default_config.xml).
Values which are determined at runtime are stored in the TlsContext. When a value which is normally selected from the context is missing (because a message was not yet received), the default value from the Config is selected. You can specify your own configuration file from command line with the "-config" parameter. Note that if you do not explicitly define a default value in the config file, TLS-Attacker fills
this gap with hardcoded values (which are equal to the provided default config). More details on how to customize TLS-Attacker can be found in the wiki.

## Acknowledgements

The following people have contributed code to the TLS-Attacker project:
- Florian Pfützenreuter: DTLS 1.2
- Felix Lange: EAP-TLS
- Philip Riese: Server implementation, TLS Man-in-the-Middle prototype
- Christian Mainka: Design support and many implementation suggestions
- Matthias Terlinde: More TLS-Extensions
- Nurullah Erinola: TLS 1.3 Support
- Lucas Hartmann: TLS-MitM Workflows
- Florian Linsner: PSK, SRP
- Pierre Tilhaus: Code quality improvements
- Felix Kleine-Wilde: SSL 3 Support
- Marcel Maehren: 0-RTT Support
- Asli Yardim: STARTTLS
- Tim Reisach: GOST
- Paul Fiterau Brostean: DTLS reintegration
- Malte Poll: High precision timing measurements
- Mario Korth: Client Authentication Analysis
- Nils Hanke: OCSP
Additionally we would like to thank all the other people who have contributed code to the project.

Further contributions and pull requests are welcome.

## TLS-Attacker Projects

The basic concepts behind TLS-Attacker and several attacks are described in the following paper:
- Juraj Somorovsky. Systematic Fuzzing and Testing of TLS Libraries. ACM CCS'16. https://www.nds.rub.de/research/publications/systematic-fuzzing-and-testing-tls-libraries

TLS-Attacker was furthermore used in the following scientific papers and projects:
- Tibor Jager, Jörg Schwenk, Juraj Somorovsky. On the Security of TLS 1.3 and QUIC Against Weaknesses in PKCS#1 v1.5 Encryption. ACM CCS'15. https://www.nds.rub.de/research/publications/ccs15/
- Tibor Jager, Jörg Schwenk, Juraj Somorovsky. Practical Invalid Curve Attacks on TLS-ECDH. ESORICS'15. https://www.nds.rub.de/research/publications/ESORICS15/
- Quellcode-basierte Untersuchung von kryptographisch relevanten Aspekten der OpenSSL-Bibliothek. https://www.bsi.bund.de/DE/Publikationen/Studien/OpenSSL-Bibliothek/opensslbibliothek.html
- Entwicklung einer sicheren Kryptobibliothek. https://www.bsi.bund.de/DE/Themen/Kryptografie_Kryptotechnologie/Kryptografie/Kryptobibliothek/kryptobibliothek_node.html
- Yuan Xiao, Mengyuan Li, Sanchuan Chen, Yinqian Zhang. Stacco: Differentially Analyzing Side-Channel Traces for Detecting SSL/TLS Vulnerabilities in Secure Enclaves. CCS'17. http://web.cse.ohio-state.edu/~zhang.834/papers/ccs17a.pdf

If you have any research ideas or need support feel free to contact us on Twitter (@ic0nz1 , @jurajsomorovsky ) or at https://www.hackmanit.de/.

If TLS-Attacker helps you to find a bug in a TLS implementation, please acknowledge this tool. Thank you!


Zendesk Java Client
===================

This is a [Zendesk][zd] client implementation written in Java using AsyncHttpClient and Jackson.

[![Java CI with Maven](https://github.com/cloudbees-oss/zendesk-java-client/workflows/Java%20CI%20with%20Maven/badge.svg)](https://github.com/cloudbees-oss/zendesk-java-client/actions?query=workflow%3A%22Java+CI+with+Maven%22)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.cloudbees.thirdparty/zendesk-java-client/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.cloudbees.thirdparty/zendesk-java-client/)
[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=com.cloudbees.thirdparty%3Azendesk-java-client&metric=coverage)](https://sonarcloud.io/dashboard?id=com.cloudbees.thirdparty%3Azendesk-java-client)
[![Lines](https://sonarcloud.io/api/project_badges/measure?project=com.cloudbees.thirdparty%3Azendesk-java-client&metric=ncloc)](https://sonarcloud.io/dashboard?id=com.cloudbees.thirdparty%3Azendesk-java-client)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=com.cloudbees.thirdparty%3Azendesk-java-client&metric=alert_status)](https://sonarcloud.io/dashboard?id=com.cloudbees.thirdparty%3Azendesk-java-client)

Using the API
-------------

Start by creating a `Zendesk` instance

    Zendesk zd = new Zendesk.Builder("https://{{your domain}}.zendesk.com")
            .setUsername("...")
            .setToken("...") // or .setPassword("...")
            .build();

If you are behind a proxy, or want to otherwise control the lifecycle of the `AsyncHttpClient` instance
you should pass that through to the builder too. If you don't pass an `AsyncHttpClient` instance to the builder
it will create its own which will be closed by the `Zendesk.close()` method.

Where methods return paged data sets, an `Iterable` is returned that will lazy-fetch one page at a time until
all records have been fetched, so e.g.

    for (Ticket ticket: zd.getTickets()) {
        ...
    }

will iterate through *all* tickets. Most likely you will want to implement your own cut-off process to stop iterating
when you have got enough data.

Community
-------------

* [Users list](https://groups.google.com/forum/#!forum/zendesk-java-client-users)
* [GitHub discussions](https://github.com/cloudbees-oss/zendesk-java-client/discussions)

Status
------

Here is the status of the various API components:

* [Tickets](https://developer.zendesk.com/api-reference/ticketing/tickets/tickets/) ✓
* [Ticket Audits](https://developer.zendesk.com/api-reference/ticketing/tickets/ticket_audits/) ✓
* [Incremental Export](https://developer.zendesk.com/api-reference/ticketing/ticket-management/incremental_exports/) - Partial (tickets, users, organizations only)
* [Ticket Fields](https://developer.zendesk.com/api-reference/ticketing/tickets/ticket_fields/) ✓
* [Ticket Import](https://developer.zendesk.com/api-reference/ticketing/tickets/ticket_import/) ✓
* [Ticket Metrics](https://developer.zendesk.com/api-reference/ticketing/tickets/ticket_metrics/) ✓
* [Ticket Forms](https://developer.zendesk.com/api-reference/ticketing/tickets/ticket_forms/) *getTicketForm() and getTicketForms()*
* [Views](https://developer.zendesk.com/api-reference/ticketing/business-rules/views/)
* [Users](https://developer.zendesk.com/api-reference/ticketing/users/users/) ✓
    * [User Related Information](https://developer.zendesk.com/api-reference/ticketing/users/users/#show-user-related-information) ✓
* [User Fields](https://developer.zendesk.com/api-reference/ticketing/users/user_fields/) - Partial - List User Fields (`getUserField()`)
* [Requests](https://developer.zendesk.com/api-reference/ticketing/tickets/ticket-requests/) ✓
* [User Identities](https://developer.zendesk.com/api-reference/ticketing/users/user_identities/) ✓
* [Groups](https://developer.zendesk.com/api-reference/ticketing/groups/groups/) ✓
* [Group Membership](https://developer.zendesk.com/api-reference/ticketing/groups/group_memberships/) ✓
* [Custom Agent Roles](https://developer.zendesk.com/api-reference/ticketing/account-configuration/custom_roles/) ✓
* [Organizations](https://developer.zendesk.com/api-reference/ticketing/organizations/organizations/) ✓ *except for related info*
* [Search](https://developer.zendesk.com/api-reference/ticketing/ticket-management/search/) ✓ *except for topics and sort ordering*
* [Tags](https://developer.zendesk.com/api-reference/ticketing/ticket-management/tags/)
* [Forums](http://developer.zendesk.com/documentation/rest_api/forums.html) ✓
* [Forum Subscriptions](http://developer.zendesk.com/documentation/rest_api/forum_subscriptions.html)
* [Categories](http://developer.zendesk.com/documentation/rest_api/categories.html)
* [Topics](https://developer.zendesk.com/api-reference/help_center/help-center-api/topics/) ✓
* [Post Comments](https://developer.zendesk.com/api-reference/help_center/help-center-api/post_comments/)
* [Content Subscriptions](https://developer.zendesk.com/api-reference/help_center/help-center-api/content_subscriptions/)
* [Help Center Categories](https://developer.zendesk.com/rest_api/docs/help_center/categories) ✓
* [Help Center Sections](https://developer.zendesk.com/rest_api/docs/help_center/sections) ✓
* [Help Center Articles](https://developer.zendesk.com/api-reference/help_center/help-center-api/articles/) ✓
* [Help Center Translations](https://developer.zendesk.com/api-reference/help_center/help-center-api/translations/) - Partial (List Translations, Update Translation, Delete Translation)
* [Help Center Subscriptions](https://developer.zendesk.com/rest_api/docs/help_center/subscriptions)
* [Help Center Management Permission Groups](https://developer.zendesk.com/rest_api/docs/help_center/permission_groups)
* [Help Center User Segments](https://developer.zendesk.com/rest_api/docs/help_center/user_segments)
* [Topic Votes](https://developer.zendesk.com/api-reference/help_center/help-center-api/votes/)
* [Account Settings](https://developer.zendesk.com/api-reference/ticketing/account-configuration/account_settings/)
* [Activity Stream](https://developer.zendesk.com/api-reference/ticketing/tickets/activity_stream/)
* [Attachments](https://developer.zendesk.com/api-reference/ticketing/tickets/ticket-attachments/) ✓
* [Automations](https://developer.zendesk.com/api-reference/ticketing/business-rules/automations/) ✓
* [Job Statuses](https://developer.zendesk.com/api-reference/ticketing/ticket-management/job_statuses/) ✓
* [Locales](https://developer.zendesk.com/api-reference/ticketing/account-configuration/locales/) - Partial (List Locales)
* [Macros](https://developer.zendesk.com/api-reference/ticketing/business-rules/macros/) ✓ *except for restrictions*
* [Satisfaction Ratings](https://developer.zendesk.com/api-reference/ticketing/ticket-management/satisfaction_ratings/) ✓
* [Sharing Agreements](https://developer.zendesk.com/api-reference/ticketing/account-configuration/sharing_agreements/)
* [Suspended Tickets](https://developer.zendesk.com/api-reference/ticketing/tickets/suspended_tickets/)
* [Triggers](https://developer.zendesk.com/api-reference/ticketing/business-rules/triggers/) ✓

JDK Support
------

The current version of this project supports Java 11 and above.
It is built on Java 11 and Java 17.
The release is built using Java 11.

Latest version supporting Java 8: 0.24.3 (https://github.com/cloudbees-oss/zendesk-java-client/releases/tag/zendesk-java-client-0.24.3).

History
-------

* See [releases](https://github.com/cloudbees/zendesk-java-client/releases)

  [zd]: https://zendesk.com


= Revapi
:toc:

image:https://github.com/revapi/revapi/actions/workflows/build.yml/badge.svg[Build Status, link=https://github.com/revapi/revapi/actions/workflows/build.yml]
image:https://codecov.io/github/revapi/revapi/coverage.svg?branch=main[Code Coverage,link=https://codecov.io/github/revapi/revapi?branch=main]

https://revapi.org[Revapi] is a tool for API analysis and change tracking.

== Summary

While Revapi is designed to be extensible and in theory should support API checks in other languages
than Java (not just programming languages but anything that can be decomposed to a tree structure)
the only extension in existence today is the Java API checker.

The main distinguishing features of the Java API checker include:

* large number of https://revapi.org/revapi-java/differences.html[API checks]
** categorized by their influence on source, binary and "semantic" compatibility
* support for computing the API "surface" by tracking usages of types across the checked library
and also its dependencies (ability to report type "leakage" from deps)
* powerful filtering of elements to check and reclassification of found problems
* ability to filter by annotation presence
* Maven plugin automatically includes dependencies in the check

Other features:

* ability to judge the severity of changes based on semver rules (see
https://revapi.org/revapi-basic-features/versions.html[here])
* automatic updates of pom.xml or release.properties versions according to semver rules (see
https://revapi.org/revapi-maven-plugin/specifying-versions.html[here])
* pluggable reporting (standard output, maven site generation, https://revapi.org/revapi-reporter-text/index.html[FreeMarker templates], https://revapi.org/revapi-reporter-json/index.html[JSON], ...)

== Building

This is a maven project, so to build you simply:

 mvn install

== Usage

Revapi can be invoked in a couple of ways. It can be used as a standalone program,
as a maven plugin or it can also be embedded in your application and used as a library.

=== Standalone

https://revapi.org/revapi-site/downloads.html[Download] the standalone distribution zip and

 unzip revapi-XXX-standalone.zip
 cd revapi-XXX-standalone
 ./revapi.sh

Read the usage info and go.

=== Maven

[source,xml]
----
<build>
    <plugins>
        <plugin>
            <groupId>org.revapi</groupId>
            <artifactId>revapi-maven-plugin</artifactId>
            <version>...</version>
            <dependencies>
                <dependency>
                    <groupId>org.revapi</groupId>
                    <artifactId>revapi-java</artifactId>
                    <version>...</version>
                </dependency>
                <dependency>
                    <groupId>com.acme</groupId>
                    <artifactId>my-extension</artifactId>
                    <version>...</version>
                </dependency>
                ...
            </dependencies>
            <configuration>
                ...
            </configuration>
            <executions>
                <execution>
                    <id>api-check</id>
                    <goals><goal>check</goal></goals>
                    ...
                </execution>
                ...
            </executions>
        </plugin>
        ...
    </plugins>
    ...
</build>
----

=== Gradle

There is an external Gradle plugin available for Revapi, https://github.com/palantir/gradle-revapi.

=== Embedding

[source,java]
----
Revapi revapi = Revapi.builder().withAllExtensionsFromThreadContextClassLoader().build();

AnalysisContext analysisContext = AnalysisContext.builder()
    .withOldAPI(API.of(...))
    .withNewAPI(API.of(...))
    .withConfigurationFromJSON("json").build();

revapi.analyze(analysisContext);
----

== Extending Revapi

See the https://revapi.org/revapi/architecture.html[site] for more info.

== Getting in touch

Mastodon:: https://botsin.space/@revapi[+@revapi@botsin.space+]
Twitter:: https://twitter.com/revapi_org[@revapi_org]
Matrix:: #revapiorg:matrix.org
Mailing list:: https://groups.google.com/forum/#!forum/revapi[revapi@googlegroups.com]
Issues:: https://github.com/revapi/revapi/issues
Code:: https://github.com/revapi/


Read the docs: https://flightstats.github.io/hub/

![hub logo](./docs/images/HubLogoSmall.png)

# What is the Hub?

The hub is a distributed linked list.
The hub is a messaging system.
The hub is a long term data store.

## The hub is like a Key Value Store
* Stores each item at a unique key (url) (http://hub/channel/whatIs/2016/12/31/23/59/59/bhJ23I)
* Items are available for an arbitrarily long time
* Fault tolerant, easy to cluster
* Requires a quorum for a successful write

### with some differences
* Most KV stores allow mutations.  The hub does not.
* The hub imposes that all item keys always move forward in time
* The hub offers ordering guarantees to provide consistent answers to time based queries

## The hub is like a Messaging system
* Items are immutable
* Item keys always increase

### and some differences
* Most messaging systems do not let you access arbitrarily old items
* Many messaging systems are difficult to cluster
* Many messaging system require custom clients

### How to build hub:

Run ./gradlew build

The above command compiles the code, runs the unit tests and integration tests.~~~~

### How to run System tests:

From Local:

1) Setup hub:
    a) ./localDocker.sh (from root directory)
    b) docker run -p 80:80 hub:local

2) set base.url property in integration-hub.properties

3) Go to root of hub project source and run below command
   ./gradlew systemTest -i


# LostCities


# Spring REST Docs [![Build status][1]][2] [![Revved up by Develocity][24]][25]

## Overview

The primary goal of this project is to make it easy to document RESTful services by combining content that's been hand-written using [Asciidoctor][3] with auto-generated examples produced with the [Spring MVC Test][4] framework.
The result is intended to be an easy-to-read user guide, akin to [GitHub's API documentation][5] for example, rather than the fully automated, dense API documentation produced by tools like [Swagger][6].

For a broader introduction see the Documenting RESTful APIs presentation.
Both the [slides][7] and a [video recording][8] are available.

## Learning more

To learn more about Spring REST Docs, please consult the [reference documentation][9].

## Building from source

You will need Java 17 or later to build Spring REST Docs.
It is built using [Gradle][10]:

```
./gradlew build
```

## Contributing

Contributors to this project agree to uphold its [code of conduct][11].

There are several that you can contribute to Spring REST Docs:

 - Open a [pull request][12]. Please see the [contributor guidelines][13] for details
 - Ask and answer questions on Stack Overflow using the [`spring-restdocs`][15] tag
 - Chat with fellow users [on Gitter][16]

## Third-party extensions

| Name | Description |
| ---- | ----------- |
| [restdocs-wiremock][17] | Auto-generate WireMock stubs as part of documenting your RESTful API |
| [restdocsext-jersey][18] | Enables Spring REST Docs to be used with [Jersey's test framework][19] |
| [spring-auto-restdocs][20] | Uses introspection and Javadoc to automatically document request and response parameters |
| [restdocs-api-spec][21] | A Spring REST Docs extension that adds API specification support. It currently supports [OpenAPI 2][22] and [OpenAPI 3][23] |

## Licence

Spring REST Docs is open source software released under the [Apache 2.0 license][14].

[1]: https://ci.spring.io/api/v1/teams/spring-restdocs/pipelines/spring-restdocs-2.0.x/jobs/build/badge (Build status)
[2]: https://ci.spring.io/teams/spring-restdocs/pipelines/spring-restdocs-2.0.x?groups=build
[3]: https://asciidoctor.org
[4]: https://docs.spring.io/spring-framework/docs/4.1.x/spring-framework-reference/htmlsingle/#spring-mvc-test-framework
[5]: https://developer.github.com/v3/
[6]: https://swagger.io
[7]: https://speakerdeck.com/ankinson/documenting-restful-apis-webinar
[8]: https://www.youtube.com/watch?v=knH5ihPNiUs&feature=youtu.be
[9]: https://docs.spring.io/spring-restdocs/docs/
[10]: https://gradle.org
[11]: CODE_OF_CONDUCT.md
[12]: https://help.github.com/articles/using-pull-requests/
[13]: CONTRIBUTING.md
[14]: https://www.apache.org/licenses/LICENSE-2.0.html
[15]: https://stackoverflow.com/tags/spring-restdocs
[16]: https://gitter.im/spring-projects/spring-restdocs
[17]: https://github.com/ePages-de/restdocs-wiremock
[18]: https://github.com/RESTDocsEXT/restdocsext-jersey
[19]: https://jersey.java.net/documentation/latest/test-framework.html
[20]: https://github.com/ScaCap/spring-auto-restdocs
[21]: https://github.com/ePages-de/restdocs-api-spec
[22]: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md
[23]: https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md
[24]: https://img.shields.io/badge/Revved%20up%20by-Develocity-06A0CE?logo=Gradle&labelColor=02303A
[25]: https://ge.spring.io/scans?search.rootProjectNames=spring-restdocs


[![Jenkins](https://img.shields.io/jenkins/build?jobUrl=https://ci.blamejared.com/job/mezz/job/jei/job/1.20/&style=?style=plastic)](https://ci.blamejared.com/job/mezz/job/jei/job/1.20/) [![](http://cf.way2muchnoise.eu/full_jei_downloads.svg)](https://minecraft.curseforge.com/projects/jei) [![Discord](https://img.shields.io/discord/358816755646332941.svg?colorB=7289DA&logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHYAAABWAgMAAABnZYq0AAAACVBMVEUAAB38%2FPz%2F%2F%2F%2Bm8P%2F9AAAAAXRSTlMAQObYZgAAAAFiS0dEAIgFHUgAAAAJcEhZcwAACxMAAAsTAQCanBgAAAAHdElNRQfhBxwQJhxy2iqrAAABoElEQVRIx7WWzdGEIAyGgcMeKMESrMJ6rILZCiiBg4eYKr%2Fd1ZAfgXFm98sJfAyGNwno3G9sLucgYGpQ4OGVRxQTREMDZjF7ILSWjoiHo1n%2BE03Aw8p7CNY5IhkYd%2F%2F6MtO3f8BNhR1QWnarCH4tr6myl0cWgUVNcfMcXACP1hKrGMt8wcAyxide7Ymcgqale7hN6846uJCkQxw6GG7h2MH4Czz3cLqD1zHu0VOXMfZjHLoYvsdd0Q7ZvsOkafJ1P4QXxrWFd14wMc60h8JKCbyQvImzlFjyGoZTKzohwWR2UzSONHhYXBQOaKKsySsahwGGDnb%2FiYPJw22sCqzirSULYy1qtHhXGbtgrM0oagBV4XiTJok3GoLoDNH8ooTmBm7ZMsbpFzi2bgPGoXWXME6XT%2BRJ4GLddxJ4PpQy7tmfoU2HPN6cKg%2BledKHBKlF8oNSt5w5g5o8eXhu1IOlpl5kGerDxIVT%2BztzKepulD8utXqpChamkzzuo7xYGk%2FkpSYuviLXun5bzdRf0Krejzqyz7Z3p0I1v2d6HmA07dofmS48njAiuMgAAAAASUVORK5CYII%3D)](https://discord.gg/sCQcWU2)

# JustEnoughItems (JEI)
[JustEnoughItems](https://minecraft.curseforge.com/projects/jei) is an Item and Recipe viewing mod for Minecraft with a focus on stability, performance, and ease of use.

This means:
 * just items and recipes
 * clean API for developers
 * not a coremod – no dependencies other than Forge.

### [JEI Developer Wiki](https://github.com/mezz/JustEnoughItems/wiki)


[![title-banner](https://bluecolored.de/paste/BluemapBanner.png)](https://bluemap.bluecolored.de/)

create **3D**-maps of your Minecraft worlds and display them in your browser
**>> [DEMO MAP](https://bluecolored.de/bluemap) <<**

[![GitHub issues](https://img.shields.io/github/issues-raw/BlueMap-Minecraft/BlueMap)](https://github.com/orgs/BlueMap-Minecraft/projects/2)
[![GitHub all releases](https://img.shields.io/github/downloads/BlueMap-Minecraft/BlueMap/total)](https://github.com/BlueMap-Minecraft/BlueMap/releases)
[![GitHub release (latest by date)](https://img.shields.io/github/v/release/BlueMap-Minecraft/BlueMap)](https://github.com/BlueMap-Minecraft/BlueMap/releases/latest)
[![Discord](https://img.shields.io/discord/665868367416131594?label=discord)](https://discord.gg/zmkyJa3)

## What is BlueMap
BlueMap is a program that reads your Minecraft world files and generates not only a map, but also 3D-models of the whole surface.
With the web-app you then can look at those in your browser and basically view the world as if you were ingame!
Or just look at it from far away to get an overview.

[![screenshot](https://bluecolored.de/paste/BlueMapScreenshot.jpg?2)](https://bluecolored.de/bluemap)

BlueMap comes as a Spigot/Paper or Sponge Plugin, as a Fabric or Forge-Mod and you can also use BlueMap without any Server
from the Command-Line as a standalone tool.

If installed as a Plugin/Mod, BlueMap **renders asynchronously** to your MinecraftServer-Thread.
This means at no time it will block your server-thread directly.
So as long as your CPU is not fully utilized, your server should not be slowed down while BlueMap is rendering.

## Using BlueMap
You can download BlueMap from [here](https://github.com/BlueMap-Minecraft/BlueMap/releases).
Read the [installation instructions](https://bluemap.bluecolored.de/wiki/getting-started/Installation.html) to get started!

Here you can see how many servers are using BlueMap:

[![BlueMap Graph](https://metrics.bluecolored.de/bluemap/graph.php?1)](https://metrics.bluecolored.de/)

## Development
### Clone
If you have git installed, simply use the command `git clone --recursive https://github.com/BlueMap-Minecraft/BlueMap.git` to clone BlueMap.

### Build
In order to build BlueMap you simply need to run the `./gradlew clean build` command in BlueMap's root directory.
You can find the compiled JAR files in `./build/release`.

### Issues
You found a bug, have another issue?
First, make sure it's not on your end, if you are unsure you can always ask about it in our [Discord](https://bluecolo.red/map-discord).
If you are sure it's a bug on BlueMap's end, please create an issue [here](https://github.com/BlueMap-Minecraft/BlueMap/issues)!

### Contributing
You are welcome to contribute!
Just create a pull request with your changes :)

**If you want to have your changes merged, make sure they are complete, documented and well tested!**

Keep in mind that we have to maintain all new features and keep supporting them in the future.
This means we always can decide to not accept a PR for any reason.

## Links
**TODO-List:** https://github.com/orgs/BlueMap-Minecraft/projects/2
**Wiki:** https://bluecolo.red/map-wiki
**Discord:** https://bluecolo.red/map-discord
**Reddit:** https://www.reddit.com/r/BlueMap

---

[![JetBrainsLogo](https://bluecolored.de/paste/jetbrains-variant-4.svg)](https://www.jetbrains.com/?from=BlueMap)

Special thanks to [JetBrains](https://www.jetbrains.com/?from=BlueMap) for giving out an OpenSource-Licence for BlueMap development!


XMLUnit for Java 2.x
====================

[![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.xmlunit/xmlunit-core/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.xmlunit/xmlunit-core)

[![Build Status XMLUnit 2.x for Java](https://app.travis-ci.com/xmlunit/xmlunit.svg?branch=main)](https://app.travis-ci.com/github/xmlunit/xmlunit) [![Coverage Status](https://coveralls.io/repos/xmlunit/xmlunit/badge.svg)](https://coveralls.io/r/xmlunit/xmlunit)

XMLUnit is a library that supports testing XML output in several ways.

XMLUnit 2.x is a complete rewrite of XMLUnit and actually doesn't
share any code with XMLUnit for Java 1.x.

Some goals for XMLUnit 2.x:

* create .NET and Java versions that are compatible in design while
  trying to be idiomatic for each platform
* remove all static configuration (the old XMLUnit class setter methods)
* focus on the parts that are useful for testing
  - XPath
  - (Schema) validation
  - comparisons
* be independent of any test framework

XMLUnit 1.x is no longer maintained, you can still find the old forum over at
[sourceforge](https://sourceforge.net/projects/xmlunit/) and we still use the
sourceforge provided mailing list.

## Documentation

* [Developer Guide](https://github.com/xmlunit/xmlunit/wiki)
* [User's Guide](https://github.com/xmlunit/user-guide/wiki)

## Help Wanted!

If you are looking for something to work on, we've compiled a
[list](HELP_WANTED.md) of known issues.

Please see the [contributing guide](CONTRIBUTING.md) for details on
how to contribute.

## Latest Release

The latest releases are available as
[GitHub releases](https://github.com/xmlunit/xmlunit/releases) or via
[Maven Central](http://search.maven.org/#search|ga|1|org.xmlunit).

The core library is

```xml
<dependency>
  <groupId>org.xmlunit</groupId>
  <artifactId>xmlunit-core</artifactId>
  <version>x.y.z</version>
</dependency>
```

## SNAPSHOT builds

We are providing SNAPSHOT builds from
[Sonatypes OSS Nexus Repository](https://oss.sonatype.org/content/repositories/snapshots/org/xmlunit/),
you need to add

```xml
<repository>
  <id>snapshots-repo</id>
  <url>https://oss.sonatype.org/content/repositories/snapshots</url>
  <releases><enabled>false</enabled></releases>
  <snapshots><enabled>true</enabled></snapshots>
</repository>
```

to your Maven settings.

## Examples

These are some really small examples, more is available as part of the
[user guide](https://github.com/xmlunit/user-guide/wiki)

### Comparing Two Documents

```java
Source control = Input.fromFile("test-data/good.xml").build();
Source test = Input.fromByteArray(createTestDocument()).build();
DifferenceEngine diff = new DOMDifferenceEngine();
diff.addDifferenceListener(new ComparisonListener() {
        public void comparisonPerformed(Comparison comparison, ComparisonResult outcome) {
            Assert.fail("found a difference: " + comparison);
        }
    });
diff.compare(control, test);
```

or using the fluent builder API

```java
Diff d = DiffBuilder.compare(Input.fromFile("test-data/good.xml"))
             .withTest(createTestDocument()).build();
assert !d.hasDifferences();
```

or using Hamcrest with `CompareMatcher`

```java
import static org.xmlunit.matchers.CompareMatcher.isIdenticalTo;
...

assertThat(createTestDocument(), isIdenticalTo(Input.fromFile("test-data/good.xml")));
```

or using AssertJ with `XmlAssert` of the `xmlunit-assertj` module

```java

import static org.xmlunit.assertj.XmlAssert.assertThat;
...

assertThat(createTestDocument())
            .and(Input.fromFile("test-data/good.xml"))
            .areIdentical();
```

or using AssertJ with `XmlAssert` of the `xmlunit-assertj3` module

```java

import static org.xmlunit.assertj3.XmlAssert.assertThat;
...

assertThat(createTestDocument())
            .and(Input.fromFile("test-data/good.xml"))
            .areIdentical();
```

### Asserting an XPath Value

```java
Source source = Input.fromString("<foo>bar</foo>").build();
XPathEngine xpath = new JAXPXPathEngine();
Iterable<Node> allMatches = xpath.selectNodes("/foo", source);
assert allMatches.iterator().hasNext();
String content = xpath.evaluate("/foo/text()", source);
assert "bar".equals(content);
```

or using Hamcrest with `HasXPathMatcher`, `EvaluateXPathMatcher`

```java
assertThat("<foo>bar</foo>", HasXPathMatcher.hasXPath("/foo"));
assertThat("<foo>bar</foo>", EvaluateXPathMatcher.hasXPath("/foo/text()",
                                                           equalTo("bar")));
```

or using AssertJ with `XmlAssert` of the `xmlunit-assertj` module

```java

import static org.xmlunit.assertj.XmlAssert.assertThat;
...

assertThat("<foo>bar</foo>").hasXPath("/foo");
assertThat("<foo>bar</foo>").valueByXPath("/foo/text()").isEqualTo("bar");
```

or using AssertJ with `XmlAssert` of the `xmlunit-assertj3` module

```java

import static org.xmlunit.assertj3.XmlAssert.assertThat;
...

assertThat("<foo>bar</foo>").hasXPath("/foo");
assertThat("<foo>bar</foo>").valueByXPath("/foo/text()").isEqualTo("bar");
```

### Validating a Document Against an XML Schema

```java
Validator v = Validator.forLanguage(Languages.W3C_XML_SCHEMA_NS_URI);
v.setSchemaSources(Input.fromUri("http://example.com/some.xsd").build(),
                   Input.fromFile("local.xsd").build());
ValidationResult result = v.validateInstance(Input.fromDocument(createDocument()).build());
boolean valid = result.isValid();
Iterable<ValidationProblem> problems = result.getProblems();
```

or using Hamcrest with `ValidationMatcher`

```java
import static org.xmlunit.matchers.ValidationMatcher.valid;
...

assertThat(createDocument(), valid(Input.fromFile("local.xsd")));
```

or using AssertJ with `XmlAssert` of the `xmlunit-assertj` module

```java
import static org.xmlunit.assertj.XmlAssert.assertThat;
...

assertThat(createDocument()).isValidAgainst(Input.fromFile("local.xsd"));
```

or using AssertJ with `XmlAssert` of the `xmlunit-assertj3` module

```java
import static org.xmlunit.assertj3.XmlAssert.assertThat;
...

assertThat(createDocument()).isValidAgainst(Input.fromFile("local.xsd"));
```

## Requirements

Starting with version 2.8.0 XMLUnit requires Java 7, which has always
been the minimum requirement for the AssertJ module. All other modules
in versions 2.0.0 to 2.7.0 required Java 6. The `xmlunit-assertj3`
module requires Java 8 as does AssertJ 3.x itself.

The `core` library provides all functionality needed to test XML
output and hasn't got any dependencies.  It uses JUnit 4.x for its own
tests.

If you want to use `Input.fromJaxb` - i.e. you want to serialize plain Java objects to XML as input - then you may also
need to add a dependency on the JAXB implementation. For more details see the [User's
Guide](https://github.com/xmlunit/user-guide/wiki/JAXB).

The core library is complemented by Hamcrest 1.x matchers and AssertJ
assertions.  There also exists a `legacy` project that provides the
API of XMLUnit 1.x on top of the 2.x core library.

While the Hamcrest matchers are built against Hamcrest 1.x they are
supposed to work with Hamcrest 2.x as well.

Starting with XMLUnit 2.8.1 there are two different AssertJ modules,
`xmlunit-assertj` is the original implementation which is based on
AssertJ 2.x and also works for AssertJ 3.x but uses reflection to deal
with some changes in later versions of AssertJ. The `xmlunit-assertj3`
module requires at least AssertJ 3.18.1.

The `xmlunit-assertj` module depends on an internal package not
exported by AssertJ's OSGi module and thus doesn't work in an OSGi
context.

Another difference between the two AssertJ modules is the exception
thrown if a comparison fails. `xmlunit-assertj` will try to throw a
JUnit 4.x `ComparisonFailure` if the class is available and thus is
best suited for tests using JUnit 4.x. `xmlunit-assertj3` will try to
throw an [Open Test
Alliance](https://github.com/ota4j-team/opentest4j)
`AssertionFailedError` if the class is available and thus is better
suited for tests using JUnit 5.x.

## Checking out XMLUnit for Java

XMLUnit for Java uses a git submodule for test resources it shares
with XMLUnit.NET.  You can either clone this repository using `git
clone --recursive` or run `git submodule update --init` inside
your fresh working copy after cloning normally.

If you have checked out a working copy before we added the submodule,
you'll need to run `git submodule update --init` once.

## Building

XMLUnit for Java builds using Apache Maven 3.x, mainly you want to run

```sh
$ mvn install
```

in order to compile all modules and run the tests.


NeoHabitat.org: The Neoclassical Habitat Server Project
=======================================================

[![license](https://img.shields.io/github/license/mashape/apistatus.svg)](https://github.com/frandallfarmer/neohabitat/blob/master/LICENSE)
[![Twitter Follow](https://img.shields.io/twitter/follow/NeoHabitatProj.svg?style=social&label=Follow)](https://twitter.com/NeoHabitatProj)
[![Slack](https://img.shields.io/badge/slack-http%3A%2F%2Fslack.neohabitat.org-brightgreen)](http://slack.neohabitat.org/)

We're recreating [Habitat](https://en.wikipedia.org/wiki/Habitat_(video_game)), the world's first MMO, using modern technology.  We'd love it if you joined us!

Play Habitat Now!
-----------------

We maintain a demo server running the latest NeoHabitat code and you can connect to it at any time. There's often a few members of the regular crew hanging out there, so come say hey!

**Please note**: NeoHabitat is still in development, so there will likely be some instability. If you see anything weird, please [tell us about it in our Slack](http://slack.neohabitat.org/).

With all that out of the way, here's how to get started:

- If you want to use Habitat with a real C64, please switch over to [these instructions](https://github.com/frandallfarmer/neohabitat/blob/master/README-RealC64.md) for making disks and using modern connection hardware.

- You can also use our [web based client](http://habitat.themade.org) to connect via a browser. Just skip to **Step 2** below to learn how to get ingame.

### Step 1 - Download and Install either the Windows or OSX Habitat package (which comes with VICE, the C64 emulator)

**Windows**

- Download the [NeoHabitat installer](https://github.com/StuBlad/neohabitat-installer/releases/download/1.1/NeoHabitatInstaller1.1.exe)

- Run the installer.
 - Tested on Windows 11 Home v22H2 but it should be fine on older versions of Windows.

- Check the **Launch NeoHabitat** box at the end of the installation, or Double-click the **NeoHabitat** icon on your desktop or in the Start Menu.

- Go to Step 2!

**OS X**

- Download [Neohabitat.dmg](https://github.com/frandallfarmer/neohabitat-doc/blob/master/installers/Neohabitat.dmg?raw=true) and double-click on the DMG file.

- Drag the **NeoHabitat** application to the **Applications** folder.

- **Launch the NeoHabitat application** you dragged to **Applications**.

**Please Note**: OS X may inform you that this app comes from an unknown developer upon first launch. If this happens, **open System Preferences** and click **Security & Privacy**. From the following pane, click **Open Anyway** to launch the NeoHabitat application.

**Linux and \*BSD**

- Install VICE and `nc` (netcat) via your package manager
- Extract the Windows release of [Neohabitat.zip](https://github.com/frandallfarmer/neohabitat-doc/blob/master/installers/Neohabitat.zip?raw=true) to get the `.d64` files and `fliplist-C64.vfl`
- Run the VICE C64 emulator with these options set:
  `x64 -rsuser -rsuserdev 0 -rsdev1 '|nc 20.3.249.92 1986' -rsuserbaud 1200 -flipname fliplist-C64.vfl Habitat-Boot.d64`
- There is a bug in current versions of VICE which breaks this network support (https://sourceforge.net/p/vice-emu/bugs/1356). Versions including r38928 and earlier work.

### Step 2 - Login and play!

In a few moments, you'll be brought to the NeoHabitat splash screen:

![Neohabitat Splash Screen](https://raw.githubusercontent.com/frandallfarmer/neohabitat-doc/master/docs/images/neohabitat_splash.png)

Major thanks to **Gary Lake-Schaal** who developed our custom loader and built the original Habitat client from the original 1985 source!

At this point, **Press Enter** then enter your username:

![Neohabitat Login](https://raw.githubusercontent.com/frandallfarmer/neohabitat-doc/master/docs/images/launcher_login.png)

**Press Enter again**, then wait until the Habitat client loads and asks you to insert your imagery disk:

![Habitat Imagery Disk Step](https://raw.githubusercontent.com/frandallfarmer/neohabitat-doc/master/docs/images/habitat_imagery.png)

At this point, **Press Alt-n or ⌘-n**, then **Press Enter**.

If all goes well, you'll materialize in downtown Populopolis:

![Avatar In Populopolis](https://raw.githubusercontent.com/frandallfarmer/neohabitat-doc/master/docs/images/neohabitat_downtown.png)

### Step 3 - Learn How to Play

Welcome to NeoHabitat! There's a whole lot you can do here and thousands of exotic places to visit.

Before you go anywhere, **we highly recommend opening up our [Docent support software](http://habitat.themade.org)**. It's a browser based guide that'll help you navigate NeoHabitat, learn the controls and teach you about the history of the world. It's interactive and will update as you move around without you having to lift a finger.

If you are using the web based client mentioned earlier, the Docent support software is already active!

To learn about all the things you can do in more detail, read the [official Habitat manual](https://frandallfarmer.github.io/neohabitat-doc/docs/Avatar%20Handbook.html) from 1988.

Your default controls for NeoHabitat are mapped to the numpad and Right-CTRL.

* Right-Ctrl + Numpad 8 initiates the **"GO"** command
* Right-Ctrl + Numpad 2 initiates the **"DO"** comamnd
* Right-Ctrl + Numpad 6 initiates the **"GET"** command
* Right-Ctrl + Numpad 4 initiates the **"PUT"** command

There is also a [NeoHabitat Controls cheat sheet](https://github.com/StuBlad/neohabitat-installer/blob/master/Neohabitat/NeoHabitatControls.pdf) which tells you all of the keys you need to know.

For the most authentic experience, you'll also need to **hook up a joystick**, whether it's physical or virtual. To set one up, **open the Settings menu** then select **Joystick**. Habitat expects a joystick in **port #1**.

We have tested with various different gamepads that all work fine with Habitat. We have personally tested it with the Xbox 360 Wireless Controller for PC.

### Step 4 (Optional) - Controls

If you don't own a joystick and wish to change the controls to suit your needs then follow these steps:

- At the top of your VICE emulator, select "Settings"
- Hover your mouse over "Joystick Settings" and then select "Joystick Settings..." (Windows) or "Joystick" (OS X)
- A window should now popup saying "Joystick settings"
- For "Joystick #1", select "Keyset A"
- Click "Configure Keyset A" (Windows) or "Keyset" (OS X) and map the controls to whatever you like
- If you are running into issues, head on over to the #troubleshooting channel [on our Slack](http://slack.neohabitat.org)
- If you have a **localized keyboard** (e.g. German QWERTZ) you might not be able to find some essential keys, like ":". It might help if you change "Settings - Keyboard Settings - Active Keymap" from Symbolic to Positional, the keyboard will behave like a C64 keyboard.

Help!
-----

If you're having trouble getting NeoHabitat working, don't worry, we're here to help! Come [join our Slack](http://slack.neohabitat.org) and join our **#troubleshooting** room.

If you encounter a glitch whilst playing NeoHabitat, please check to see if it's been filed as an [issue](https://github.com/frandallfarmer/neohabitat/issues). If it hasn't, we'd appreciate it if you let us know what happened so we can investigate.

Developer Documentation
-----------------------

If you'd like to contribute to NeoHabitat, there are plenty of great opportunities! Come check our our extensive developer documentation:

  - [Getting Started for Developers](https://github.com/frandallfarmer/neohabitat-doc/blob/master/docs/getting_started.md)
  - [Developer Wiki](https://github.com/frandallfarmer/neohabitat/wiki/Developers-Documentation)

Have Fun!
---------

On behalf of the entire NeoHabitat Project, we hope that you have a great time, and we'll see you in-world!


# [OCR4all](https://github.com/OCR4all/OCR4all/)

![example workflow](https://github.com/OCR4all/OCR4all/actions/workflows/maven_build_verification.yml/badge.svg)

As suggested by the name one of the main goals of OCR4all is to allow basically any given user to independently perform OCR on a wide variety of historical printings and obtain high quality results with reasonable time expenditure. Therefore, **OCR4all is explicitly geared towards users with no technical background. If you are one of those users (or if you just want to use the tool and are not interested in the code), please go to the** [documentation website](https://www.ocr4all.org/) or the [getting started project where you will find test data](https://github.com/OCR4all/getting_started).

Please note that OCR4all current main focus is a **semi-automatic workflow** allowing users to perform OCR even on the earliest printed books, which is a very challenging task that often requires a significant amount of **manual interaction**, especially when almost perfect quality is desired.
Nevertheless, we are working towards increasing robustness and the degree of automation of the tool.
An important cornerstone for this is the recently agreed cooperation with the [OCR-D project](https://github.com/ocr-d) which focuses on the mass full-text recognition of historical materials.

This repository contains the code for the main interface and server of the OCR4all project,
while the repositories [OCR4all/docker_image](https://github.com/OCR4all/docker_image) and [OCR4all/docker_base_image](https://github.com/OCR4all/docker_base_image) are about the creation of a preconfigurated docker image.

For installing the complete project with a docker image, please follow the instructions [here](https://github.com/OCR4all/docker_image).

## Mailing List

OCR4all is under active development and consequently, frequent releases containing bug fixes and further functionality can be expected. In order to always be up to date, we highly recommend subscribing to our [mailing list](https://lists.uni-wuerzburg.de/mailman/listinfo/ocr4all) where we will always announce notable enhancements.

## Built With

* [Docker](https://www.docker.com) - Platform and Software Deployment
* [Maven](https://maven.apache.org/) - Dependency Management
* [Spring](https://spring.io/) - Java Framework
* [Materialize](http://materializecss.com/) - Front-end Framework
* [jQuery](https://jquery.com/) - JavaScript Library

## Included Projects

* [OCRopus](https://github.com/tmbdev/ocropy) - Collection of document analysis programs
* [Calamari](https://github.com/ChWick/calamari) - OCR Engine based on OCRopy and Kraken
* [LAREX](https://github.com/chreul/LAREX) - Layout analysis on early printed books

### Formerly included / inspired by

* [Kraken](https://github.com/mittagessen/kraken) - OCR engine for all the languages
* [nashi](https://github.com/andbue/nashi) - Some bits of javascript to transcribe scanned pages using PageXML

## Contact, Authors, and Helping Hands

* **Dr. Christian Reul** (*project lead*) - mail: christian.reul@uni-wuerzburg.de
* **Florian Langhanki** (*user support and guides*) - mail: florian.langhanki@uni-wuerzburg.de

### Developers

* **Dr. Herbert Baier Saip** (*lead*)
* **Maximilian Nöth** (*OCR4all, LAREX, and Calamari*)
* **Dr. Christoph Wick** (*Calamari*)
* **Andreas Büttner** (*Calamari and nashi*)
* **Kevin Chadbourne** (*LAREX*)
* **Yannik Herbst** (*distribution via VirtualBox*)
* **Björn Eyselein** (*Artifactory and distribution via Docker*)

### Miscellaneous

* **Raphaëlle Jung** (*guides and artwork*)
* **Dr. Uwe Springmann** (*ideas and feedback*)
* **Prof. Dr. Frank Puppe** (*ideas and feedback*)

### Former Project Members

* **Dennis Christ** (*OCR4all*)
* **Alexander Hartelt** (*OCR4all*)
* **Nico Balbach** (*OCR4all and LAREX*)
* **Christine Grundig** (*ideas and feedback*)
* **Maximilan Wehner** (*user support and guides*)
* ...

## Funding
* [DFG-funded Initiative "OCR-D" (Phase 2 and 3)](https://ocr-d.de/en/)
* [BMBF Project “Kallimachos“](http://www.kallimachos.de/)
* [Centre for Philology and Digitality (University of Würzburg)](https://www.uni-wuerzburg.de/zpd)
* [Chair of Artificial Intelligence (University of Würzburg)](https://www.informatik.uni-wuerzburg.de/en/is)

## Citing OCR4all

If you are using OCR4all please cite:

> Reul, C., Christ, D., Hartelt, A., Balbach, N., Wehner, M., Springmann, U., Wick, C., Grundig, Büttner, A., C., Puppe, F.: *OCR4all — An open-source tool providing a (semi-) automatic OCR workflow for historical printings* Applied Sciences **9**(22) (2019)

```
@article{reul2019ocr4all,
  title={OCR4all—An open-source tool providing a (semi-) automatic OCR workflow for historical printings},
  author={Reul, Christian and Christ, Dennis and Hartelt, Alexander and Balbach, Nico and Wehner, Maximilian and Springmann, Uwe and Wick, Christoph and Grundig, Christine and B{\"u}ttner, Andreas and Puppe, Frank},
  journal={Applied Sciences},
  volume={9},
  number={22},
  pages={4853},
  year={2019},
  publisher={Multidisciplinary Digital Publishing Institute}
}
```


# NULS2.0 Node Wallet Implemented in Java

NULS v2 is the main running program of NULS 2.0 nodes. It contains 3 microservice modules:
- nuls-cores
- nuls-cmd-client
- nuls-api
nuls-cores consists of 11 sub-modules:
https://github.com/nuls-io/nuls-v2/tree/master/module/nuls-cores/src/main/java/io/nuls

## Getting Started

Start a NULS node according to this boot.

### Download Release

Download URL: [RELEASES](https://github.com/nuls-io/nuls-v2/releases)

## Running NULS2.0

### Bootstrap

Execute the following command:

```
./start
```

### Check Status

It takes a certain amount of time to start. You can get the startup status with the following command:

```
./check-status
```

Note: The command will automatically end when all modules are started.

## Executables

| Command      | Command                                                      |
| ------------ | ------------------------------------------------------------ |
| start        | Start the program and start all NULS modules one after another. |
| shutdown     | Stop the program and stop all NULS modules one after another. |
| check-status | Check the running status of all modules; stop screen output when all modules are successfully started |
|              |                                                              |

## Docker Quick Start

Stay tuned. Join Discord to find out.

## Explorer

Explorer URL:  [https://nulscan.io/](https://nulscan.io/)

## ChainBox Tutorial

Please check the following documents：

[https://docs.nuls.io/NULS2.0/chainBoxGuide.html](https://docs.nuls.io/NULS2.0/chainBoxGuide.html)

## Modules Description

Please check the following documents:

[https://docs.nuls.io/Docs/c_module.html](https://docs.nuls.io/Docs/c_module.html)

Note: Some documents are in the process of being updated, so please understand if there are some inconsistencies.

## Contribute to NULS2.0
Click Star and Fork to start contributing improvements to NULS v2.
Hope more contributors can submit improvement suggestions and bug reports here.
Issues: https://github.com/nuls-io/nuls-v2/issues

# Welcome to NULS! #

NULS — Making It Easier To Innovate

## Introduction

NULS is a blockchain infrastructure that provides customizable services and is also a global open-source community blockchain project. NULS adopts micro-services to achieve a highly modular underlying architecture, using smart contracts and cross-chain technologies, combined with the ability of ChainBox to quickly build chains, reduce development costs, and accelerate blockchain business application landing.

## Contribute to NULS
We are committed to making blockchain technology simpler and our slogan is "NULS Making It Easier to Innovate".

Get to know NULS developers
https://nuls.io/developer

You are welcome to contribute to NULS! We sincerely invite developers with rich experience in the blockchain field to join the NULS technology community.
https://nuls.io/community

Documentation：https://docs.nuls.io

NULS Brand Assets: https://nuls.io/brand-assets

## License

NULS is released under the [MIT](http://opensource.org/licenses/MIT) license.
Modules added in the future may be release under different license, will specified in the module library path.

## Community

- Website: https://nuls.io
- Twitter: https://twitter.com/nuls
- Discord:https://discord.gg/aRCwbj47WN
- Telegram: https://t.me/Nulsio
- Medium: https://nuls.medium.com
- Forum: https://forum.nuls.io
- GitHub: https://github.com/nuls-io

####


# PowerAuth

[![Coverity Scan Build Status](https://scan.coverity.com/projects/16631/badge.svg)](https://scan.coverity.com/projects/wultra-powerauth-crypto)
[![Test with Maven](https://github.com/wultra/powerauth-crypto/actions/workflows/maven-test.yml/badge.svg)](https://github.com/wultra/powerauth-crypto/actions/workflows/maven-test.yml)
[![GitHub issues](https://img.shields.io/github/issues/wultra/powerauth-crypto.svg?maxAge=2592000)](https://github.com/wultra/powerauth-crypto/issues)
[![Maven Central](https://img.shields.io/maven-central/v/io.getlime.security/powerauth-java-crypto.svg?maxAge=2592000)](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22io.getlime.security%22)
[![Twitter](https://img.shields.io/badge/twitter-@wultra-blue.svg?style=flat)](http://twitter.com/wultra)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](./LICENSE.txt)

PowerAuth is a protocol for a key exchange and for subsequent request signing designed specifically for the purposes of applications with high security demands, such as banking applications or identity management applications. It defines all items that are required for a complete security solution: a used cryptography, a security scheme and standard RESTful API end-points.

A typical use-case for PowerAuth protocol would be assuring the security of a mobile banking application. User usually downloads a "blank" (non-personalized) mobile banking app from the mobile application market. Then, user activates (personalizes, using a key-exchange algorithm) the mobile banking using some application that is assumed secure, for example via the internet banking or via the branch kiosk system. Finally, user can use activated mobile banking application to create signed requests - to log in to mobile banking, send a payment, certify contracts, etc.

## Documentation

For the most recent documentation and tutorials, please visit [PowerAuth Crypto Documentation on GitHub](./docs/Readme.md) or visit [developers.wultra.com](https://developers.wultra.com/docs/develop/powerauth-crypto).

# License

All sources are licensed using Apache 2.0 license, you can use them with no restriction. If you are using PowerAuth, please let us know. We will be happy to share and promote your project.


Tablesaw
=======

[![Apache 2.0](https://img.shields.io/github/license/nebula-plugins/nebula-project-plugin.svg)](http://www.apache.org/licenses/LICENSE-2.0)
[![Build Status](https://travis-ci.org/jtablesaw/tablesaw.svg?branch=master)](https://travis-ci.org/jtablesaw/tablesaw)
[![Codacy Badge](https://app.codacy.com/project/badge/Grade/3ebd154b5253466b932cb17dda737293)](https://www.codacy.com/gh/jtablesaw/tablesaw/dashboard?utm_source=github.com&utm_medium=referral&utm_content=jtablesaw/tablesaw&utm_campaign=Badge_Grade)
[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=jtablesaw_tablesaw&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=jtablesaw_tablesaw)

### Overview

__Tablesaw__ is a dataframe and visualization library that supports loading, cleaning, transforming, filtering, and summarizing data. If you work with data in Java, it may save you time and effort. Tablesaw also supports descriptive statistics and can be used to prepare data for working with machine learning libraries like Smile, Tribuo, H20.ai, DL4J.

### Tablesaw features

#### Data processing & transformation
* Import data from RDBMS, Excel, CSV, TSV, JSON, HTML, or Fixed Width text files, whether they are local or remote (http, S3, etc.)
* Export data to CSV, JSON, HTML or Fixed Width files.
* Combine tables by appending or joining
* Add and remove columns or rows
* Sort, Group, Filter, Edit, Transpose, etc.
* Map/Reduce operations
* Handle missing values

#### Visualization

Tablesaw supports data visualization by providing a wrapper for the Plot.ly JavaScript plotting library. Here are a few examples of the new library in action.

| ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/box1.png) | ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/scatter_2_Yaxes.png) | ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/tornado.scatter.png) |
| ------------------------------------------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
| ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/bush_time_series2.png) | ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/hist_overlay.png) | ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/histogram2.png) |
| ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/histogram2d.png) | ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/pie.png) | ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/wine_bubble_3d.png) |
| ![](https://jtablesaw.github.io/tablesaw/userguide/images/eda/wine_bubble_with_groups.png) | ![](https://jtablesaw.github.io/tablesaw/userguide/images/eda/robberies_area.png) | ![](https://jtablesaw.github.io/tablesaw/userguide/images/ml/regression/wins%20by%20year.png) |
| ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/bush_heatmap1.png) | ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/tornado_bar_groups.png) | ![Tornadoes](https://jtablesaw.github.io/tablesaw/userguide/images/eda/ohlc1.png) |

#### Statistics

* Descriptive stats: mean, min, max, median, sum, product, standard deviation, variance, percentiles, geometric mean, skewness, kurtosis, etc.

### Getting started

Add tablesaw-core to your project. You can find the version number for the latest release in the [release notes](https://github.com/jtablesaw/tablesaw/releases):

```xml
<dependency>
    <groupId>tech.tablesaw</groupId>
    <artifactId>tablesaw-core</artifactId>
    <version>VERSION_NUMBER_GOES_HERE</version>
</dependency>
```

You may also add supporting projects:
- `tablesaw-beakerx` - for using Tablesaw inside [BeakerX](http://beakerx.com/)
- `tablesaw-excel` - for using Excel workbooks
- `tablesaw-html` - for using HTML
- `tablesaw-json` - for using JSON
- `tablesaw-jsplot` - for creating charts

External supporting projects - **outside of this organization**:
- [tablesaw-parquet](https://github.com/tlabs-data/tablesaw-parquet) - for using the [Apache Parquet](https://parquet.apache.org/) file format with Tablesaw ([report issue](https://github.com/tlabs-data/tablesaw-parquet/issues))

### Documentation and support

* Start here:  https://jtablesaw.github.io/tablesaw/gettingstarted
* Then see our documentation page: https://jtablesaw.github.io/tablesaw/ and the [Tablesaw User Guide](https://jtablesaw.github.io/tablesaw/userguide/toc).
* Ask questions, make suggestions, or tell us how you're using Tablesaw in the new GitHub [discussions forum](https://github.com/jtablesaw/tablesaw/discussions).
* Feature requests and bug reports can be made on the [issues tab](https://github.com/jtablesaw/tablesaw/issues).

### Integrations

#### Jupyter Notebooks

* We recommend trying Tablesaw inside [Jupyter notebooks](http://arogozhnikov.github.io/2016/09/10/jupyter-features.html), which lets you experiment with Tablesaw in a more interactive manner. Get started by [installing BeakerX](http://beakerx.com/documentation) and trying [the sample Tablesaw notebook](https://github.com/twosigma/beakerx/blob/master/doc/groovy/Tablesaw.ipynb)
* A second way to use Tablesaw inside [Jupyter notebooks](http://arogozhnikov.github.io/2016/09/10/jupyter-features.html) is with [IJava](https://github.com/SpencerPark/IJava), which has built-in support for Tablesaw. Gary Sharpe has written [an excellent tutorial](https://medium.com/@gmsharpe/java-jupyter-plotly-e1bbaa7f2be8) that shows you how to use Tablesaw plots. Gary has written a number of other tutorials that feature Tablesaw:
  * [Tidy Data with Java & Jupyter](https://medium.com/@gmsharpe/tidy-data-with-java-jupyter-b1e131b37ab0)
  * [Dataframes with Tablesaw — JSON](https://medium.com/@gmsharpe/dataframes-with-tablesaw-json-46dda9c8c217?source=your_stories_page----------------------------------------)
  * [Dataframes with Tablesaw — CSV Files](https://medium.com/@gmsharpe/importing-data-with-tablesaw-part-1-csv-files-3ac6f135cf6f?source=your_stories_page----------------------------------------)
* A third approach is to use [Google Colab](https://colab.research.google.com). Again, Gary Sharpe has an excellent tutorial:[Getting Started with Dataframes using Java and Google Colab](https://medium.com/@gmsharpe/getting-started-with-tablesaw-and-google-colab-65ef0cbe280c)

#### Other integrations

* Eclipse uses may find [etablesaw](https://github.com/hallvard/etablesaw) useful. It provides Eclipse integration aimed at turning Eclipse into a data workbench.
* You may utilize Tablesaw with many machine learning libraries. To see an example of using Tablesaw with [Smile](https://haifengl.github.io) check out [the sample Tablesaw Jupyter notebook](https://github.com/twosigma/beakerx/blob/master/doc/groovy/Tablesaw.ipynb)
* You may use [quandl4j-tablesaw](http://quandl4j.org) if you'd like to load financial and economic data from [Quandl](https://www.quandl.com) into Tablesaw. This is demonstrated in [the sample Tablesaw notebook](https://github.com/twosigma/beakerx/blob/master/doc/groovy/Tablesaw.ipynb) as well