Iterator class refactor

Set up GitHub Actions

.circleci_turned_off/config.yml

@@ -54,24 +54,33 @@ jobs:
       - restore_cache:
           key: jars-{{ checksum "build.gradle" }}-{{ checksum  "app/build.gradle" }}
       - run:
-          command: sudo echo $GPG_KEY_CONTENTS | base64 -d > /secret.gpg
+          name: Build Library
+          command: ./gradlew :treedatastructure:assembleRelease
+      - run:
+          name: Export key
+          command: |
+            mkdir treedatastructure/maven
+            echo ${GPG_KEY_CONTENTS} | base64 -d --ignore-garbage > treedatastructure/maven/secret.gpg
       - run:
           name: Staging
-          command: ./gradlew treedatastructure:publishReleasePublicationToSonatypeRepository
+          command: ./gradlew :treedatastructure:publishReleasePublicationToSonatypeRepository
+      - run:
+          name: Release Library
+          command: ./gradlew closeAndReleaseRepository
 
 workflows:
   version: 2.1
   build-and-deploy:
     jobs:
-      - build
+      - build:
+          filters:  # required since `deploy` has tag filters AND requires `build`
+            tags:
+              only: /.*/
       - deploy:
           requires:
             - build
           filters:
             tags:
-              only:
-                - /.*/
+              only: /v[0-9]{1,3}\.[0-9]{1,3}\.?[0-9]{0,3}/
             branches:
-              only:
-                - release
-                - master
+              ignore: /.*/

.github/workflows/build.yml

@@ -0,0 +1,24 @@
+name: Build
+
+on: pull_request
+
+jobs:
+  build:
+    name: Check project build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v2
+        with:
+          distribution: adopt
+          java-version: 11
+
+        # Builds the release artifacts of the library
+      - name: Build
+        run: ./gradlew assemble
+
+        # Generates other artifacts (javadocJar is optional)
+      - name: Source jar and dokka
+        run: ./gradlew androidSourcesJar javadocJar

.github/workflows/publish.yml

@@ -0,0 +1,38 @@
+name: Publish
+
+on:
+  release:
+    # We'll run this workflow when a new GitHub release is created
+    types: [released]
+
+jobs:
+  publish:
+    name: Release build and publish
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v2
+        with:
+          distribution: adopt
+          java-version: 11
+
+        # Builds the release artifacts of the library
+      - name: Release build
+        run: ./gradlew :treedatastructure:assembleRelease
+
+        # Generates other artifacts (javadocJar is optional)
+      - name: Source jar and dokka
+        run: ./gradlew androidSourcesJar javadocJar
+
+        # Runs upload, and then closes & releases the repository
+      - name: Publish to MavenCentral
+        run: ./gradlew publishReleasePublicationToSonatypeRepository --max-workers 1 closeAndReleaseSonatypeStagingRepository
+        env:
+          OSSRH_USERNAME: ${{ secrets.OSSRH_USERNAME }}
+          OSSRH_PASSWORD: ${{ secrets.OSSRH_PASSWORD }}
+          SIGNING_KEY_ID: ${{ secrets.SIGNING_KEY_ID }}
+          SIGNING_PASSWORD: ${{ secrets.SIGNING_PASSWORD }}
+          SIGNING_KEY: ${{ secrets.SIGNING_KEY }}
+          SONATYPE_STAGING_PROFILE_ID: ${{ secrets.SONATYPE_STAGING_PROFILE_ID }}

.github/workflows/test.yml

@@ -0,0 +1,23 @@
+name: Test
+
+on:
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    name: Run unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v2
+        with:
+          distribution: adopt
+          java-version: 11
+
+        # Builds the release artifacts of the library
+      - name: Test
+        run: ./gradlew test

.gitignore

@@ -12,3 +12,7 @@
 /captures
 .externalNativeBuild
 .cxx
+/.idea/.name
+/.idea/compiler.xml
+/.idea/jarRepositories.xml
+/.idea/deploymentTargetDropDown.xml

.idea/gradle.xml

@@ -1,10 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
   <component name="GradleSettings">
     <option name="linkedExternalProjectsSettings">
       <GradleProjectSettings>
+        <option name="testRunner" value="GRADLE" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleJvm" value="11 (2)" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
@@ -13,7 +16,6 @@
           </set>
         </option>
         <option name="resolveModulePerSourceSet" value="false" />
-        <option name="testRunner" value="PLATFORM" />
       </GradleProjectSettings>
     </option>
   </component>

.idea/misc.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_7" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="1.8" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/build/classes" />
   </component>
   <component name="ProjectType">

.idea/runConfigurations.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RunConfigurationProducerService">
-    <option name="ignoredProducers">
-      <set>
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.AllInPackageGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestClassGradleConfigurationProducer" />
-        <option value="org.jetbrains.plugins.gradle.execution.test.runner.TestMethodGradleConfigurationProducer" />
-      </set>
-    </option>
-  </component>
-</project>

README.md

@@ -1,47 +1,73 @@
 # Tree (Data Structure)
 [![maven](https://img.shields.io/maven-central/v/com.github.adriankuta/tree-structure?style=plastic)](https://mvnrepository.com/artifact/com.github.adriankuta/tree-structure)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue?style=plastic)](https://github.com/AdrianKuta/Design-Patterns-Kotlin/blob/master/LICENSE)
-[![CircleCI](https://img.shields.io/circleci/build/github/AdrianKuta/Tree-Data-Structure/master?label=CircleCI&style=plastic)](https://circleci.com/gh/AdrianKuta/Tree-Data-Structure)
+[![License: MIT](https://img.shields.io/github/license/AdrianKuta/Tree-Data-Structure?style=plastic)](https://github.com/AdrianKuta/Design-Patterns-Kotlin/blob/master/LICENSE)
+[![Publish](https://github.com/AdrianKuta/Tree-Data-Structure/actions/workflows/publish.yml/badge.svg)](https://github.com/AdrianKuta/Tree-Data-Structure/actions/workflows/publish.yml)
 
-Simple implementation to store object in tree structure. Method `toString()` is overrided to provide nice tree view in logs.
+Simple implementation to store object in tree structure.
 
 ## Usage
 
+**Kotlin**
 ```kotlin
-val root = TreeNode<String>("Root")
-val beveragesNode = TreeNode<String>("Beverages")
-val curdNode = TreeNode<String>("Curd")
-root.addChild(beveragesNode)
-root.addChild(curdNode)
+val root = TreeNode("World")
+val northA = TreeNode("North America")
+val europe = TreeNode("Europe")
+root.addChild(northA)
+root.addChild(europe)
 
-val teaNode = TreeNode<String>("tea")
-val coffeeNode = TreeNode<String>("coffee")
-val milkShakeNode = TreeNode<String>("Milk Shake")
-beveragesNode.addChild(teaNode)
-beveragesNode.addChild(coffeeNode)
-beveragesNode.addChild(milkShakeNode)
+val usa = TreeNode("USA")
+northA.addChild(usa)
 
-val gingerTeaNode = TreeNode<String>("ginger tea")
-val normalTeaNode = TreeNode<String>("normal tea")
-teaNode.addChild(gingerTeaNode)
-teaNode.addChild(normalTeaNode)
+val poland = TreeNode("Poland")
+val france = TreeNode("France")
+europe.addChild(poland)
+europe.addChild(france)
+println(root.prettyString())
+```
 
-val yogurtNode = TreeNode<String>("yogurt")
-val lassiNode = TreeNode<String>("lassi")
-curdNode.addChild(yogurtNode)
-curdNode.addChild(lassiNode)
+**Pretty Kotlin**
 
-println(root)
-System.out.println("Remove: ${curdNode.value}")
-root.removeChild(curdNode)
-System.out.println("Remove: ${gingerTeaNode.value}")
-root.removeChild(gingerTeaNode)
-println(root)
+```kotlin
+val root =
+    tree("World") {
+        child("North America") {
+            child("USA")
+        }
+        child("Europe") {
+            child("Poland")
+            child("Germany")
+        }
+    }
+```
+
+**Java**
+```java
+TreeNode<String> root = new TreeNode<>("World");
+TreeNode<String> northA = new TreeNode<>("North America");
+TreeNode<String> europe = new TreeNode<>("Europe");
+root.addChild(northA);
+root.addChild(europe);
+
+TreeNode<String> usa = new TreeNode<>("USA");
+northA.addChild(usa);
+
+TreeNode<String> poland = new TreeNode<>("Poland");
+TreeNode<String> france = new TreeNode<>("France");
+europe.addChild(poland);
+europe.addChild(france);
+System.out.println(root.prettyString());
 ```
 
 *Output:*
 
-<img src="https://github.com/AdrianKuta/Tree-Collection/blob/master/images/console_output.png" width=400>
+```
+World
+├── North America
+│   └── USA
+└── Europe
+    ├── Poland
+    └── France
+```
 
 
 ## Download

_config.yml

@@ -0,0 +1,3 @@
+theme: jekyll-theme-minimal
+title: Tree Data Structure
+logo: images/console_output.png

app/build.gradle

@@ -1,16 +1,13 @@
 apply plugin: 'com.android.application'
-
 apply plugin: 'kotlin-android'
 
-apply plugin: 'kotlin-android-extensions'
-
 android {
-    compileSdkVersion 29
-    buildToolsVersion "29.0.2"
+    compileSdkVersion 31
+    buildToolsVersion "31.0.0"
     defaultConfig {
         applicationId "com.github.adriankuta.treedatastructure"
         minSdkVersion 15
-        targetSdkVersion 29
+        targetSdkVersion 31
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
@@ -25,11 +22,12 @@ android {
 
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
-    implementation 'androidx.appcompat:appcompat:1.0.2'
-    implementation 'androidx.core:core-ktx:1.0.2'
-    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
-    testImplementation 'junit:junit:4.12'
-    androidTestImplementation 'androidx.test.ext:junit:1.1.0'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+    implementation 'androidx.appcompat:appcompat:1.3.1'
+    implementation 'androidx.core:core-ktx:1.6.0'
+    implementation 'androidx.constraintlayout:constraintlayout:2.1.0'
+    implementation 'com.github.adriankuta:tree-structure:1.2.3'
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
 }

app/src/main/AndroidManifest.xml

@@ -9,7 +9,8 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/AppTheme">
-        <activity android:name=".MainActivity">
+        <activity android:name=".MainActivity"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
 

app/src/main/java/com/github/adriankuta/treedatastructure/MainActivity.kt

@@ -2,11 +2,28 @@ package com.github.adriankuta.treedatastructure
 
 import androidx.appcompat.app.AppCompatActivity
 import android.os.Bundle
+import android.util.Log
+import com.github.adriankuta.datastructure.tree.tree
 
 class MainActivity : AppCompatActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         setContentView(R.layout.activity_main)
+
+        val root =
+            tree("World") {
+                child("North America") {
+                    child("USA") {
+                        child("LA")
+                        child("New York")
+                    }
+                }
+                child("Europe") {
+                    child("Poland")
+                    child("Germany")
+                }
+            }
+        Log.d("DEBUG_TAG", root.prettyString())
     }
 }

build.gradle

@@ -1,31 +1,32 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 
 buildscript {
-    ext.kotlin_version = '1.3.61'
+    ext.kotlin_version = '1.5.30'
     repositories {
         google()
-        jcenter()
-
+        mavenCentral()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.5.3'
+        classpath 'com.android.tools.build:gradle:7.0.2'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "io.codearte.gradle.nexus:gradle-nexus-staging-plugin:0.21.2"
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
     }
 }
 
+plugins {
+    id("io.github.gradle-nexus.publish-plugin") version "1.1.0"
+    id("org.jetbrains.dokka") version "1.5.0"
+}
+
 allprojects {
     repositories {
         google()
-        jcenter()
-
+        mavenCentral()
     }
 }
 
 task clean(type: Delete) {
     delete rootProject.buildDir
 }
-
-apply plugin: 'io.codearte.nexus-staging'
+apply from: "${rootDir}/scripts/publish-root.gradle"

gradle/wrapper/gradle-wrapper.properties

@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-5.4.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.0.2-all.zip

scripts/publish-mavencentral.gradle

@@ -1,122 +0,0 @@
-task androidSourcesJar(type: Jar) {
-    archiveClassifier.set("sources")
-    from android.sourceSets.main.java.source
-}
-
-artifacts {
-    archives androidSourcesJar
-}
-
-apply plugin: 'maven-publish'
-apply plugin: 'signing'
-
-group = PUBLISH_GROUP_ID
-version = PUBLISH_VERSION
-
-ext["signing.keyId"] = ''
-ext["signing.password"] = ''
-ext["signing.secretKeyRingFile"] = ''
-ext["ossrhUsername"] = ''
-ext["ossrhPassword"] = ''
-
-File secretPropsFile = project.rootProject.file('local.properties')
-if (secretPropsFile.exists()) {
-    println "Found secret props file, loading props"
-    Properties p = new Properties()
-    p.load(new FileInputStream(secretPropsFile))
-    p.each { name, value ->
-        ext[name] = value
-    }
-} else {
-    println "No props file, loading env vars"
-    ext["signing.keyId"] = System.getenv('SIGNING_KEY_ID')
-    ext["signing.password"] = System.getenv('SIGNING_PASSWORD')
-    ext["signing.secretKeyRingFile"] = System.getenv('SIGNING_SECRET_KEY_RING_FILE')
-    ext["ossrhUsername"] = System.getenv('OSSRH_USERNAME')
-    ext["ossrhPassword"] = System.getenv('OSSRH_PASSWORD')
-}
-
-nexusStaging {
-    packageGroup = PUBLISH_GROUP_ID
-    stagingProfileId = '2097bad464f778'
-    username = ossrhUsername
-    password = ossrhPassword
-}
-
-publishing {
-    publications {
-        release(MavenPublication) {
-            // The coordinates of the library, being set from variables that
-            // we'll set up in a moment
-            groupId PUBLISH_GROUP_ID
-            artifactId PUBLISH_ARTIFACT_ID
-            version PUBLISH_VERSION
-
-            // Two artifacts, the `aar` and the sources
-            artifact("$buildDir/outputs/aar/${project.getName()}-release.aar")
-            artifact androidSourcesJar
-
-            // Self-explanatory metadata for the most part
-            pom {
-                name = PUBLISH_ARTIFACT_ID
-                description = 'Simple implementation to store object in tree structure.'
-                // If your project has a dedicated site, use its URL here
-                url = 'https://github.com/AdrianKuta/Tree-Data-Structure'
-                licenses {
-                    license {
-                        name = 'MIT License'
-                        url = 'https://www.mit.edu/~amini/LICENSE.md'
-                    }
-                }
-                developers {
-                    developer {
-                        name = 'Adrian Kuta'
-                        email = 'adrian.kuta93@gmail.com'
-                    }
-                }
-                // Version control info, if you're using GitHub, follow the format as seen here
-                scm {
-                    connection = 'scm:git:github.com/AdrianKuta/Tree-Data-Structure.git'
-                    developerConnection = 'scm:git:ssh://github.com/AdrianKuta/Tree-Data-Structure.git'
-                    url = 'https://github.com/AdrianKuta/Tree-Data-Structure/tree/master'
-                }
-                // A slightly hacky fix so that your POM will include any transitive dependencies
-                // that your library builds upon
-                withXml {
-                    def dependenciesNode = asNode().appendNode('dependencies')
-
-                    project.configurations.implementation.allDependencies.each {
-                        def dependencyNode = dependenciesNode.appendNode('dependency')
-                        dependencyNode.appendNode('groupId', it.group)
-                        dependencyNode.appendNode('artifactId', it.name)
-                        dependencyNode.appendNode('version', it.version)
-                    }
-                }
-            }
-        }
-    }
-    repositories {
-        // The repository to publish to, Sonatype/MavenCentral
-        maven {
-            // This is an arbitrary name, you may also use "mavencentral" or
-            // any other name that's descriptive for you
-            name = "sonatype"
-
-            def releasesRepoUrl = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
-            def snapshotsRepoUrl = "https://oss.sonatype.org/content/repositories/snapshots/"
-            // You only need this if you want to publish snapshots, otherwise just set the URL
-            // to the release repo directly
-            url = version.endsWith('SNAPSHOT') ? snapshotsRepoUrl : releasesRepoUrl
-
-            // The username and password we've fetched earlier
-            credentials {
-                username ossrhUsername
-                password ossrhPassword
-            }
-        }
-    }
-}
-
-signing {
-    sign publishing.publications
-}

scripts/publish-module.gradle

@@ -0,0 +1,86 @@
+apply plugin: 'maven-publish'
+apply plugin: 'signing'
+apply plugin: 'org.jetbrains.dokka'
+
+task androidSourcesJar(type: Jar) {
+    archiveClassifier.set('sources')
+    if (project.plugins.findPlugin("com.android.library")) {
+        from android.sourceSets.main.java.srcDirs
+        from android.sourceSets.main.kotlin.srcDirs
+    } else {
+        from sourceSets.main.java.srcDirs
+        from sourceSets.main.kotlin.srcDirs
+    }
+}
+
+tasks.withType(dokkaHtmlPartial.getClass()).configureEach {
+    pluginsMapConfiguration.set(
+            ["org.jetbrains.dokka.base.DokkaBase": """{ "separateInheritedMembers": true}"""]
+    )
+}
+
+task javadocJar(type: Jar, dependsOn: dokkaJavadoc) {
+    archiveClassifier.set('javadoc')
+    from dokkaJavadoc.outputDirectory
+}
+
+artifacts {
+    archives androidSourcesJar
+    archives javadocJar
+}
+
+group = PUBLISH_GROUP_ID
+version = PUBLISH_VERSION
+
+afterEvaluate {
+    publishing {
+        publications {
+            release(MavenPublication) {
+                groupId PUBLISH_GROUP_ID
+                artifactId PUBLISH_ARTIFACT_ID
+                version PUBLISH_VERSION
+                if (project.plugins.findPlugin("com.android.library")) {
+                    from components.release
+                } else {
+                    from components.java
+                }
+
+                artifact androidSourcesJar
+                artifact javadocJar
+
+                pom {
+                    name = PUBLISH_ARTIFACT_ID
+                    description = 'Simple implementation to store object in tree structure.'
+                    url = 'https://github.com/AdrianKuta/Tree-Data-Structure'
+                    licenses {
+                        license {
+                            name = 'MIT License'
+                            url = 'https://www.mit.edu/~amini/LICENSE.md'
+                        }
+                    }
+                    developers {
+                        developer {
+                            name = 'Adrian Kuta'
+                            email = 'adrian.kuta93@gmail.com'
+                        }
+                    }
+                    // Version control info, if you're using GitHub, follow the format as seen here
+                    scm {
+                        connection = 'scm:git:github.com/AdrianKuta/Tree-Data-Structure.git'
+                        developerConnection = 'scm:git:ssh://github.com/AdrianKuta/Tree-Data-Structure.git'
+                        url = 'https://github.com/AdrianKuta/Tree-Data-Structure/tree/master'
+                    }
+                }
+            }
+        }
+    }
+}
+
+signing {
+    useInMemoryPgpKeys(
+            rootProject.ext["signing.keyId"],
+            rootProject.ext["signing.key"],
+            rootProject.ext["signing.password"],
+    )
+    sign publishing.publications
+}

scripts/publish-root.gradle

@@ -0,0 +1,43 @@
+// Create variables with empty default values
+ext["ossrhUsername"] = ''
+ext["ossrhPassword"] = ''
+ext["sonatypeStagingProfileId"] = ''
+ext["signing.keyId"] = ''
+ext["signing.password"] = ''
+ext["signing.key"] = ''
+ext["snapshot"] = ''
+
+File secretPropsFile = project.rootProject.file('local.properties')
+if (secretPropsFile.exists()) {
+    // Read local.properties file first if it exists
+    Properties p = new Properties()
+    new FileInputStream(secretPropsFile).withCloseable { is -> p.load(is) }
+    p.each { name, value -> ext[name] = value }
+} else {
+    // Use system environment variables
+    ext["ossrhUsername"] = System.getenv('OSSRH_USERNAME')
+    ext["ossrhPassword"] = System.getenv('OSSRH_PASSWORD')
+    ext["sonatypeStagingProfileId"] = System.getenv('SONATYPE_STAGING_PROFILE_ID')
+    ext["signing.keyId"] = System.getenv('SIGNING_KEY_ID')
+    ext["signing.password"] = System.getenv('SIGNING_PASSWORD')
+    ext["signing.key"] = System.getenv('SIGNING_KEY')
+    ext["snapshot"] = System.getenv('SNAPSHOT')
+}
+
+//if (snapshot) {
+//    ext["rootVersionName"] = Configuration.snapshotVersionName
+//} else {
+//    ext["rootVersionName"] = Configuration.versionName
+//}
+
+// Set up Sonatype repository
+nexusPublishing {
+    repositories {
+        sonatype {
+            stagingProfileId = sonatypeStagingProfileId
+            username = ossrhUsername
+            password = ossrhPassword
+            //version = rootVersionName
+        }
+    }
+}

treedatastructure/build.gradle

@@ -1,17 +1,19 @@
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
-apply plugin: 'kotlin-android-extensions'
+
+afterEvaluate {
+    generateReleaseBuildConfig.enabled = false
+}
+
 android {
-    compileSdkVersion 29
-    buildToolsVersion "29.0.2"
+    compileSdkVersion 31
+    buildToolsVersion "31.0.0"
 
 
     defaultConfig {
         minSdkVersion 15
-        targetSdkVersion 29
-        versionCode 1
-        versionName "1.0.3"
-
+        targetSdkVersion 31
+        versionName "2.0.3"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         consumerProguardFiles 'consumer-rules.pro'
     }
@@ -26,13 +28,12 @@ android {
 }
 
 dependencies {
-    implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
-    implementation 'androidx.appcompat:appcompat:1.1.0'
-    implementation 'androidx.core:core-ktx:1.1.0'
-    testImplementation 'junit:junit:4.12'
-    androidTestImplementation 'androidx.test.ext:junit:1.1.1'
-    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'
+    implementation 'androidx.appcompat:appcompat:1.3.1'
+    implementation 'androidx.core:core-ktx:1.6.0'
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
 }
 
 ext {
@@ -41,4 +42,4 @@ ext {
     PUBLISH_VERSION = android.defaultConfig.versionName
 }
 
-apply from: "${rootProject.projectDir}/scripts/publish-mavencentral.gradle"
+apply from: "${rootProject.projectDir}/scripts/publish-module.gradle"

treedatastructure/src/main/AndroidManifest.xml

@@ -1,2 +1 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.github.adriankuta.datastructure.tree" />
+<manifest package="com.github.adriankuta.datastructure.tree" />

treedatastructure/src/main/java/com/github/adriankuta/datastructure/tree/ChildDeclarationInterface.kt

@@ -0,0 +1,22 @@
+package com.github.adriankuta.datastructure.tree
+
+interface ChildDeclarationInterface<T> {
+
+    /**
+     * This method is used to easily create child in node.
+     * ```
+     * val root = tree("World") {
+     *     child("North America") {
+     *         child("USA")
+     *     }
+     *     child("Europe") {
+     *         child("Poland")
+     *         child("Germany")
+     *     }
+     * }
+     * ```
+     * @return New created TreeNode.
+     */
+    @JvmSynthetic
+    fun child(value: T, childDeclaration: ChildDeclaration<T>? = null): TreeNode<T>
+}

treedatastructure/src/main/java/com/github/adriankuta/datastructure/tree/PreOrderTreeIterator.kt

@@ -0,0 +1,42 @@
+package com.github.adriankuta.datastructure.tree
+
+import java.util.*
+
+/**
+ * Tree is iterated by using `Pre-order Traversal Algorithm"
+ *  1. Check if the current node is empty or null.
+ *  2. Display the data part of the root (or current node).
+ *  3. Traverse the left subtree by recursively calling the pre-order function.
+ *  4. Traverse the right subtree by recursively calling the pre-order function.
+ * ```
+ * E.g.
+ *                    1
+ *                  / | \
+ *                 /  |   \
+ *               2    3     4
+ *              / \       / | \
+ *             5    6    7  8  9
+ *            /   / | \
+ *           10  11 12 13
+ *
+ * Output: 1 2 5 10 6 11 12 13 3 4 7 8 9
+ * ```
+ */
+class PreOrderTreeIterator<T>(root: TreeNode<T>) : Iterator<TreeNode<T>> {
+
+    private val stack = Stack<TreeNode<T>>()
+
+    init {
+        stack.push(root)
+    }
+
+    override fun hasNext(): Boolean = !stack.empty()
+
+    override fun next(): TreeNode<T> {
+        val node = stack.pop()
+        node.children
+            .asReversed()
+            .forEach { stack.push(it) }
+        return node
+    }
+}

treedatastructure/src/main/java/com/github/adriankuta/datastructure/tree/TreeNode.kt

@@ -1,46 +1,102 @@
 package com.github.adriankuta.datastructure.tree
 
-class TreeNode<T>(val value: T) {
+open class TreeNode<T>(val value: T) : Iterable<TreeNode<T>>, ChildDeclarationInterface<T> {
 
-    private var parent: TreeNode<T>? = null
-    private val children = mutableListOf<TreeNode<T>>()
+    private var _parent: TreeNode<T>? = null
+    /**
+     * The converse notion of a child, an immediate ancestor.
+     */
+    val parent: TreeNode<T>?
+        get() = _parent
 
+    private val _children = mutableListOf<TreeNode<T>>()
+    /**
+     * A group of nodes with the same parent.
+     */
+    val children: List<TreeNode<T>>
+        get() = _children
+
+    /**
+     * Add new child to current node or root.
+     *
+     * @param child A node which will be directly connected to current node.
+     */
     fun addChild(child: TreeNode<T>) {
-        child.parent = this
-        children += child
+        child._parent = this
+        _children.add(child)
     }
 
+    @JvmSynthetic
+    override fun child(value: T, childDeclaration: ChildDeclaration<T>?): TreeNode<T> {
+        val newChild = TreeNode(value)
+        if(childDeclaration != null)
+            newChild.childDeclaration()
+        _children.add(newChild)
+        return newChild
+    }
+
+    /**
+     * Removes a single instance of the specified node from this tree, if it is present.
+     *
+     * @return `true` if the node has been successfully removed; `false` if it was not present in the tree.
+     */
     fun removeChild(child: TreeNode<T>): Boolean {
-        if (children.isEmpty()) {
-            return false
+        println(child.value)
+        val removed = child._parent?._children?.remove(child)
+        child._parent = null
+        return removed ?: false
     }
 
-        val nestedChildRemoved = children.map {
-            it.removeChild(child)
-        }.reduce { acc, b -> acc or b }
-
-        return children.remove(child) or nestedChildRemoved
-    }
-
-    fun getParent(): TreeNode<T>? = parent
-
-    fun getChildren(): List<TreeNode<T>> = children
-
-    fun size(): Int {
-        if (children.isEmpty())
+    /**
+     * This function go through tree and counts children. Root element is not counted.
+     * @return All child and nested child count.
+     */
+    fun nodeCount(): Int {
+        if (_children.isEmpty())
             return 0
-        return children.size +
-                children.sumBy { it.size() }
-
+        return _children.size +
+                _children.sumOf { it.nodeCount() }
     }
 
-    fun depth(): Int {
-
-        val childrenMaxDepth = children.map { it.depth() }.max() ?: 0
+    /**
+     * @return The number of edges on the longest path between current node and a descendant leaf.
+     */
+    fun height(): Int {
+        val childrenMaxDepth = _children.map { it.height() }
+            .maxOrNull()
+            ?: -1 // -1 because this method counts nodes, and edges are always one less then nodes.
         return childrenMaxDepth + 1
     }
 
+    /**
+     * Distance is the number of edges along the shortest path between two nodes.
+     * @return The distance between current node and the root.
+     */
+    fun depth(): Int {
+        var depth = 0
+        var tempParent = parent
+
+        while (tempParent != null) {
+            depth++
+            tempParent = tempParent.parent
+        }
+        return depth
+    }
+
+    /**
+     * Remove all children from root and every node in tree.
+     */
+    fun clear() {
+        _parent = null
+        _children.forEach { it.clear() }
+        _children.clear()
+    }
+
     override fun toString(): String {
+        return value.toString()
+    }
+
+    fun prettyString(): String {
         val stringBuilder = StringBuilder()
         print(stringBuilder, "", "")
         return stringBuilder.toString()
@@ -50,14 +106,36 @@ class TreeNode<T>(val value: T) {
         stringBuilder.append(prefix)
         stringBuilder.append(value)
         stringBuilder.append('\n')
-        val childIterator = children.iterator()
+        val childIterator = _children.iterator()
         while (childIterator.hasNext()) {
             val node = childIterator.next()
-            if(childIterator.hasNext()) {
+            if (childIterator.hasNext()) {
                 node.print(stringBuilder, "$childrenPrefix├── ", "$childrenPrefix│   ")
             } else {
                 node.print(stringBuilder, "$childrenPrefix└── ", "$childrenPrefix    ")
             }
         }
     }
+
+    /**
+     * Tree is iterated by using `Pre-order Traversal Algorithm"
+     *  1. Check if the current node is empty or null.
+     *  2. Display the data part of the root (or current node).
+     *  3. Traverse the left subtree by recursively calling the pre-order function.
+     *  4. Traverse the right subtree by recursively calling the pre-order function.
+     * ```
+     * E.g.
+     *                    1
+     *                  / | \
+     *                 /  |   \
+     *               2    3     4
+     *              / \       / | \
+     *             5    6    7  8  9
+     *            /   / | \
+     *           10  11 12 13
+     *
+     * Output: 1 2 5 10 6 11 12 13 3 4 7 8 9
+     * ```
+     */
+    override fun iterator(): Iterator<TreeNode<T>> = PreOrderTreeIterator(this)
 }

treedatastructure/src/main/java/com/github/adriankuta/datastructure/tree/TreeNodeExt.kt

@@ -0,0 +1,18 @@
+package com.github.adriankuta.datastructure.tree
+
+typealias ChildDeclaration<T> = ChildDeclarationInterface<T>.() -> Unit
+
+/**
+ * This method can be used to initialize new tree.
+ * ```
+ * val root = tree("World") { ... }
+ * ```
+ * @param root Root element of new tree.
+ * @see [ChildDeclarationInterface.child]
+ */
+@JvmSynthetic
+inline fun<reified T> tree(root: T, childDeclaration: ChildDeclaration<T>): TreeNode<T> {
+    val treeNode = TreeNode(root)
+    treeNode.childDeclaration()
+    return treeNode
+}

treedatastructure/src/main/res/values/strings.xml

@@ -1,3 +0,0 @@
-<resources>
-    <string name="app_name">Tree Data Structure</string>
-</resources>

treedatastructure/src/test/java/com/github/adriankuta/datastructure/tree/TreeNodeTest.kt

@@ -0,0 +1,144 @@
+package com.github.adriankuta.datastructure.tree
+
+import org.hamcrest.CoreMatchers.`is`
+import org.hamcrest.CoreMatchers.nullValue
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertThat
+import org.junit.Test
+
+class TreeNodeTest {
+
+    @Test
+    fun removeNodeTest() {
+        val root = TreeNode("Root")
+        val beveragesNode = TreeNode("Beverages")
+        val curdNode = TreeNode("Curd")
+        root.addChild(beveragesNode)
+        root.addChild(curdNode)
+
+        val teaNode = TreeNode("tea")
+        val coffeeNode = TreeNode("coffee")
+        val milkShakeNode = TreeNode("Milk Shake")
+        beveragesNode.addChild(teaNode)
+        beveragesNode.addChild(coffeeNode)
+        beveragesNode.addChild(milkShakeNode)
+
+        val gingerTeaNode = TreeNode("ginger tea")
+        val normalTeaNode = TreeNode("normal tea")
+        teaNode.addChild(gingerTeaNode)
+        teaNode.addChild(normalTeaNode)
+
+        val yogurtNode = TreeNode("yogurt")
+        val lassiNode = TreeNode("lassi")
+        curdNode.addChild(yogurtNode)
+        curdNode.addChild(lassiNode)
+
+        assertEquals(
+            "Root\n" +
+                    "├── Beverages\n" +
+                    "│   ├── tea\n" +
+                    "│   │   ├── ginger tea\n" +
+                    "│   │   └── normal tea\n" +
+                    "│   ├── coffee\n" +
+                    "│   └── Milk Shake\n" +
+                    "└── Curd\n" +
+                    "    ├── yogurt\n" +
+                    "    └── lassi\n",
+            root.prettyString()
+        )
+
+        println("Remove: ${curdNode.value}")
+        root.removeChild(curdNode)
+        println("Remove: ${gingerTeaNode.value}")
+        root.removeChild(gingerTeaNode)
+        assertEquals(
+            "Root\n" +
+                    "└── Beverages\n" +
+                    "    ├── tea\n" +
+                    "    │   └── normal tea\n" +
+                    "    ├── coffee\n" +
+                    "    └── Milk Shake\n",
+            root.prettyString()
+        )
+    }
+
+    @Test
+    fun clearTest() {
+        val root = TreeNode("Root")
+        val beveragesNode = TreeNode("Beverages")
+        val curdNode = TreeNode("Curd")
+        root.addChild(beveragesNode)
+        root.addChild(curdNode)
+
+        val teaNode = TreeNode("tea")
+        val coffeeNode = TreeNode("coffee")
+        val milkShakeNode = TreeNode("Milk Shake")
+        beveragesNode.addChild(teaNode)
+        beveragesNode.addChild(coffeeNode)
+        beveragesNode.addChild(milkShakeNode)
+
+        val gingerTeaNode = TreeNode("ginger tea")
+        val normalTeaNode = TreeNode("normal tea")
+        teaNode.addChild(gingerTeaNode)
+        teaNode.addChild(normalTeaNode)
+
+        val yogurtNode = TreeNode("yogurt")
+        val lassiNode = TreeNode("lassi")
+        curdNode.addChild(yogurtNode)
+        curdNode.addChild(lassiNode)
+
+        println(root.toString())
+        println(curdNode.height())
+
+        root.clear()
+        assertThat(root.children, `is`(emptyList()))
+        assertThat(beveragesNode.children, `is`(emptyList()))
+        assertThat(curdNode.children, `is`(emptyList()))
+        assertThat(teaNode.children, `is`(emptyList()))
+        assertThat(coffeeNode.children, `is`(emptyList()))
+        assertThat(milkShakeNode.children, `is`(emptyList()))
+        assertThat(gingerTeaNode.children, `is`(emptyList()))
+        assertThat(normalTeaNode.children, `is`(emptyList()))
+        assertThat(yogurtNode.children, `is`(emptyList()))
+        assertThat(lassiNode.children, `is`(emptyList()))
+
+        assertThat(root.parent, `is`(nullValue()))
+        assertThat(beveragesNode.parent, `is`(nullValue()))
+        assertThat(curdNode.parent, `is`(nullValue()))
+        assertThat(teaNode.parent, `is`(nullValue()))
+        assertThat(coffeeNode.parent, `is`(nullValue()))
+        assertThat(milkShakeNode.parent, `is`(nullValue()))
+        assertThat(gingerTeaNode.parent, `is`(nullValue()))
+        assertThat(normalTeaNode.parent, `is`(nullValue()))
+        assertThat(yogurtNode.parent, `is`(nullValue()))
+        assertThat(lassiNode.parent, `is`(nullValue()))
+    }
+
+    @Test
+    fun kotlinExtTest() {
+        val root = TreeNode("World")
+        val northA = TreeNode("North America")
+        val europe = TreeNode("Europe")
+        root.addChild(northA)
+        root.addChild(europe)
+
+        val usa = TreeNode("USA")
+        northA.addChild(usa)
+
+        val poland = TreeNode("Poland")
+        val france = TreeNode("France")
+        europe.addChild(poland)
+        europe.addChild(france)
+
+        val rootExt = tree("World") {
+            child("North America") {
+                child("USA")
+            }
+            child("Europe") {
+                child("Poland")
+                child("France")
+            }
+        }
+        assertEquals(root.prettyString(), rootExt.prettyString())
+    }
+}