docs: renaming **jcdb** -> **jacodb**

Author: lehvolk

README.md

@@ -1,10 +1,10 @@
-[![ci status](https://github.com/UnitTestBot/jcdb/actions/workflows/build-and-test.yml/badge.svg)](https://github.com/UnitTestBot/jcdb/actions/workflows/build-and-test.yml)
+[![ci status](https://github.com/UnitTestBot/jacodb/actions/workflows/build-and-test.yml/badge.svg)](https://github.com/UnitTestBot/jacodb/actions/workflows/build-and-test.yml)
 
 ## Overview
 
-`JCDB` is a pure Java library that allows you to get information about Java bytecode outside the JVM process and to store it in a database. While Java `Reflection` makes it possible to inspect code at runtime, `JCDB` does the same for bytecode stored in a file system.
+`JacoDB` is a pure Java library that allows you to get information about Java bytecode outside the JVM process and to store it in a database. While Java `Reflection` makes it possible to inspect code at runtime, `JacoDB` does the same for bytecode stored in a file system.
 
-`JCDB` uses [ASM](https://asm.ow2.io/) framework for reading and parsing java bytecode.
+`JacoDB` uses [ASM](https://asm.ow2.io/) framework for reading and parsing java bytecode.
 
 Information about classes, hierarchies, annotations, methods, fields, and their usages is stored in SQLite database — either in-memory or persistent. Persisted data can be reused between restarts. Accessing the persistent storage from multiple processes simultaneously is not supported.
 
@@ -27,7 +27,7 @@ suspend fun findNormalDistribution(): Any {
     val commonsMath32 = File("commons-math3-3.2.jar")
     val commonsMath36 = File("commons-math3-3.6.1.jar")
     val buildDir = File("my-project/build/classes/java/main")
-    val database = jcdb {
+    val database = jacodb {
         useProcessJRE()
         persistent("/tmp/compilation-db/${System.currentTimeMillis()}") // persist data
     }
@@ -55,7 +55,7 @@ Note: the `body` method returns `null` if the to-be-processed JAR-file was chang
 The database can watch for file system changes in the background and refresh the JAR-files explicitly:
 
 ```kotlin
-    val database = jcdb {
+    val database = jacodb {
         watchFileSystemChanges = true
         useProcessJRE()
         load(listOf(lib1, buildDir)) 
@@ -98,7 +98,7 @@ The instances of `JcClassOrInterface`, `JcMethod`, and `JcClasspath` are thread-
 `JcClasspath` represents an independent snapshot of classes, which cannot be modified since it is created. Removing or modifying library files does not affect `JcClasspath` instance structure. The `JcClasspath#close` method releases all snapshots and cleans up the persisted data if some libraries are outdated.
 
 ```kotlin
-    val database = jcdb {
+    val database = jacodb {
         watchFileSystemChanges()
         useProcessJavaRuntime()
         load(listOf(lib1, buildDir))
@@ -114,20 +114,20 @@ The instances of `JcClassOrInterface`, `JcMethod`, and `JcClasspath` are thread-
 If there is a request for a `JcClasspath` instance containing the libraries, which haven't been indexed yet, the indexing process is triggered and the new instance of the `JcClasspath` set is returned. 
 
 ```kotlin
-    val database = jcdb {
+    val database = jacodb {
         load(listOf(lib1))
         persistent()
     }
 
     val cp = database.classpath(buildDir) // database will automatically process buildDir
 ```
 
-`JCDB` is thread-safe. If one requests `JcClasspath` instance while loading JAR-files from another thread, 
+`JacoDB` is thread-safe. If one requests `JcClasspath` instance while loading JAR-files from another thread, 
 `JcClasspath` can represent only a consistent state of the JAR-files being loaded. It is the completely loaded 
 JAR-file that appears in `JcClasspath`. Please note: there is no guarantee that all the JAR-files, submitted for loading, will be actually loaded.
 
 ```kotlin
-    val db = jcdb {
+    val db = jacodb {
         persistent()
     }
 
@@ -149,7 +149,7 @@ Bytecode loading consists of two steps:
 * retrieving information about the class names from the JAR-files or build directories
 * reading **classes** bytecode from the JAR-files or build directories and processing it (persisting data, setting up `JcFeature` implementations, etc.)
 
-`JCDB` or `JcClasspath` instances are returned right after the first step is performed. You retrieve the final representation of **classes** during the second step. It is possible that the `.class` files undergo changes at some moment between the first step and the second, and **classes** representation is affected accordingly.
+`JacoDB` or `JcClasspath` instances are returned right after the first step is performed. You retrieve the final representation of **classes** during the second step. It is possible that the `.class` files undergo changes at some moment between the first step and the second, and **classes** representation is affected accordingly.
 
 Benchmarks results and comparison with Soot is [here](./benchmarks.md).
 

api.md

@@ -1,6 +1,6 @@
 ## Settings
 
-JCDBSettings is used for creating instance of `JCDB` instance.
+JacoDBSettings is used for creating instance of `JacoDB` instance.
 
 #### `useJavaRuntime(file)`
 
@@ -52,15 +52,15 @@ Which features jcdb will use
 
 ## Database
 
-`JCDB` instance created based on settings. If instance is not needed yet then `close` method should be called.
+`JacoDB` instance created based on settings. If instance is not needed yet then `close` method should be called.
 
 #### Properties
 
 | property       | type                         | description                                                    |
 |----------------|------------------------------|----------------------------------------------------------------|
 | locations      | List of `JcByteCodeLocation` | List of locations processed by database                        |
 | persistence    | `JCDBPersistence`            | persistence which brings ability to read/write to database     |
-| runtimeVersion | `JavaRuntimeVersion`         | version of java runtime which is used for this `jcdb` instance |
+| runtimeVersion | `JavaRuntimeVersion`         | version of java runtime which is used for this `JacoDB` instance |
 
 
 #### `classpath(dirOrJars)`
@@ -74,19 +74,19 @@ Creates classpath instances
 
 #### `refresh()`
 
-Refreshes state of `jcdb` instance and state of file systen. Should be called to clean up jars/folders that loaded versions are out of data and which are not used by any classpaths created by `jcdb` instance
+Refreshes state of `JacoDB` instance and state of file systen. Should be called to clean up jars/folders that loaded versions are out of data and which are not used by any classpaths created by `JacoDB` instance
 
 #### `rebuildFeatures()`
 
-Rebuild indexes for features installed in `jcdb`
+Rebuild indexes for features installed in `JacoDB`
 
 #### `awaitBackgroundJobs()`
 
 Await background jobs
 
 #### `close()`
 
-Is used to clean up resources used by `jcdb` instance
+Is used to clean up resources used by `JacoDB` instance
 
 ## Classpath
 
@@ -98,7 +98,7 @@ Is used to clean up resources used by `jcdb` instance
 | property  | type                          | description                             |
 |-----------|-------------------------------|-----------------------------------------|
 | locations | List of `JcByteCodeLocation`  | List of locations attached to classpath |
-| db        | `JCDB`                        | database instance                       |
+| db        | `JacoDB`                        | database instance                       |
 
 
 findClassOrNull(name: String): JcClassOrInterface?
@@ -337,7 +337,7 @@ return new indexer for specific location
 
 | property | type                 | description                     |
 |----------|----------------------|---------------------------------|
-| jcdb     | `JCDB`               | database                        |
+| jcdb     | `JacoDB`             | database                        |
 | location | `RegisteredLocation` | location that should be indexed |
 
 #### `query(classpath, request)`
@@ -356,7 +356,7 @@ Indexer of bytecode.
 
 #### `index(node)`
 
-Called for each ClassNode processed by `jcdb`. **Bytecode locations are processed in parallel. There is no strict order of processing locations.** 
+Called for each ClassNode processed by `JacoDB`. **Bytecode locations are processed in parallel. There is no strict order of processing locations.** 
 
 | property | type        | description                             |
 |----------|-------------|-----------------------------------------|
@@ -398,11 +398,11 @@ Finds all methods in Classpath that override specified method
 find classes that implements `java.lang.Runnable`:
 
 ```kotlin
-    val jcdb = jcdb {
+    val db = jacodb {
         loadByteCode(allClasspath) // all classpath for current process
         installFeatures(InMemoryHierarchy) // without that line memory footprint will be low as well as performance
     }
-    val classpath = jcdb.classpath(allClasspath)
+    val classpath = db.classpath(allClasspath)
     val extension = classpath.hierarchyExtension()
     extension.findSubClasses("java.lang.Runnable", allHierarchy = true) // all classes that implements `Runnable`
 
@@ -446,11 +446,11 @@ Finds all methods that instantiate instance of specified class
 
 find usages of 
 ```kotlin
-    val jcdb = jcdb {
+    val db = jacodb {
         loadByteCode(allClasspath) // all classpath of current process
         installFeatures(Usages, InMemoryHierarchy) // without that line memory footprint will be low as well as performance
     }
-    val classpath = jcdb.classpath(allClasspath)
+    val classpath = db.classpath(allClasspath)
     val extension = classpath.usagesExtension()
 
     val runMethod = classpath.findClassOrNull("java.lang.Runnable")!!.declaredMethods.first() // find run method

benchmarks.md

@@ -10,21 +10,21 @@
 Benchmark runs across different scopes of java bytecode with following meanings:
 - runtime - only java runtime without any additional dependencies
 - runtime + guava - java runtime with one jar for guava 
-- runtime + project classpath - java runtime with all visible dependencies of `jcdb` project
+- runtime + project classpath - java runtime with all visible dependencies of `JacoDB` project
 - runtime + Idea community - java runtime with all visible dependencies of `IDEA community` project
 
-`JCDB` benchmarks also include scheme when `Usages` feature is installed 
+`JacoDB` benchmarks also include scheme when `Usages` feature is installed 
 
-### JCDB
+### JacoDB
 
 ```ssh
-./gradlew jcdbBenchmark
+./gradlew jacodbBenchmark
 ```
 
 
 | Benchmark                                                                                                                                 | Repeats  | Avg time per operation  | 
 |-------------------------------------------------------------------------------------------------------------------------------------------|----------|-------------------------|
-| [runtime](../blob/main/jcdb-core/src/test/kotlin/org/utbot/jcdb/impl/performance/JcdbBenchmarks.kt#L36)                                   | 5        | 741 ms                  |
+| [runtime](../blob/main/jacodb-core/src/test/kotlin/org/utbot/jacodb/impl/performance/JcdbBenchmarks.kt#L36)                               | 5        | 741 ms                  |
 | [runtime + guava](../blob/main/jcdb-core/src/test/kotlin/org/utbot/jcdb/impl/performance/JcdbBenchmarks.kt#L76)                           | 5        | 740 ms                  |
 | [runtime + project dependencies](../blob/main/jcdb-core/src/test/kotlin/org/utbot/jcdb/impl/performance/JcdbBenchmarks.kt#L55)            | 5        | 1034 ms                 |
 | [runtime + IDEA community dependecies](../blob/main/jcdb-core/src/test/kotlin/org/utbot/jcdb/impl/performance/JcdbBenchmarks.kt#L97)      | 5        | 2324 ms                 |

build.gradle

@@ -1,4 +1,4 @@
-group 'org.utbot.jcdb'
+group 'org.utbot.jacodb'
 
 if (project.hasProperty('semVer')) {
     project.version = project.semVer

design.md

@@ -9,7 +9,7 @@ These are basic requirements for database implementation:
 * bytecode processing and analyzing (starting with Java 1.8)
 * an ability to update bytecode from the given location while keeping the processed data intact
 * an ability to persist data on a disk and to reuse it after restarting the application
-* fast start-up: `JCDB` should balance between returning instance as soon as possible and querying data from database in the fastest way
+* fast start-up: `JacoDB` should balance between returning instance as soon as possible and querying data from database in the fastest way
 
 ## API basics
 
@@ -184,6 +184,6 @@ All `JcFeature` extensions should be added at database start-up — it is imposs
 
 ## Hooks
 
-One can extend `JCDB` with hooks. Hook is an environment extension which allows for implementing the remote API or calling the specific code during the database lifecycle.
+One can extend `JacoDB` with hooks. Hook is an environment extension which allows for implementing the remote API or calling the specific code during the database lifecycle.
 
 Hook is called twice: when the database is created and initialized properly and when it is closed.

gradle.properties

@@ -7,4 +7,4 @@ kmetadata_version=0.5.0
 asm_version=9.3
 jooq_version=3.14.16
 intellij_community_url=https://download-cdn.jetbrains.com/idea/ideaIC-2022.2.3.win.zip
-#database_location=d:\\work\\jcdb\\jcdb.db
+#database_location=d:\\work\\jacodb\\jcdb.db

jc-features.md

@@ -1,19 +1,19 @@
 ## Overview
 
 Feature is an interface which provide ability to store and query additional information based on bytecode. Feature can
-be installed only when instance of `JCDB` is created.
+be installed only when instance of `JacoDB` is created.
 
 ```kotlin
-    val db = jcdb {
-    useProcessJRE()
-    persistent("/tmp/compilation-db/${System.currentTimeMillis()}") // persist data
-    installFeatures(Usages, InMemoryHierarchy)
-}
+    val db = jacodb {
+        useProcessJRE()
+        persistent("/tmp/compilation-db/${System.currentTimeMillis()}") // persist data
+        installFeatures(Usages, InMemoryHierarchy)
+    }
 ```
 
 ### `InMemoryHierarchy` feature
 
-By default `JCDB` stores information about class hierarchy in sql database (table `ClassHierarchies` with columns:
+By default `JacoDB` stores information about class hierarchy in sql database (table `ClassHierarchies` with columns:
 class_id, super_id, is_interface).
 This brings ability to retrieve whole hierarchy for particular class with recursive sql query. Recursive queries are
 quite common and quite slow.
@@ -31,18 +31,18 @@ Brings ability to find out places where methods and fields are used.
 It's recommended to install `InMemoryHierarchy` for performance purposes
 
 ```kotlin
-    val db = jcdb {
-    useProcessJRE()
-    load(allClasspath)
-    persistent("/tmp/compilation-db/${System.currentTimeMillis()}") // persist data
-    installFeatures(Usages, InMemoryHierarchy)
-}
-val method = run // java.lang.Runnable#run method
-val field = field // java.lang.String#value field
-
-val cp = db.classpath(allClasspath)
-cp.findUsages(method) // sequence of methods which calls `method`
-cp.findUsages(field, FieldUsageMode.READ) // sequence of fields which reads `field` value
+    val db = jacodb {
+        useProcessJRE()
+        load(allClasspath)
+        persistent("/tmp/compilation-db/${System.currentTimeMillis()}") // persist data
+        installFeatures(Usages, InMemoryHierarchy)
+    }
+    val method = run // java.lang.Runnable#run method
+    val field = field // java.lang.String#value field
+    
+    val cp = db.classpath(allClasspath)
+    cp.findUsages(method) // sequence of methods which calls `method`
+    cp.findUsages(field, FieldUsageMode.READ) // sequence of fields which reads `field` value
 ```
 
 `Usages` indexer goes through all instructions and collect method calls or fields access and store it into table:

jcdb-http/Dockerfile

@@ -12,4 +12,4 @@ RUN apt-get update && \
 
 COPY ${JAR_FILE} .
 
-ENTRYPOINT ["java","-jar","jcdb-http-demo.jar", "--api-prefix=/jcdb-demo" ]
+ENTRYPOINT ["java","-jar","jacodb-http-demo.jar", "--api-prefix=/jacodb-demo" ]

jcdb-http/build.gradle

@@ -22,7 +22,7 @@ dependencies {
 
 }
 
-def demoAppJar = "jcdb-http-demo.jar"
+def demoAppJar = "jacodb-http-demo.jar"
 
 bootJar {
     archiveName= demoAppJar