remove dependencies from code-assert-core

Author: nidi3

README.md

@@ -322,7 +322,7 @@ If it does so, these standard checks will be executed:
 [//]: # (codeTest)
 ```java
 //extend CodeAssertTest if you still use JUnit 4
-public class CodeTest extends CodeAssertJunit5Test {
+public class CodeTest extends CodeAssertCoreJunit5Test {
 
     private static final AnalyzerConfig CONFIG = AnalyzerConfig.maven().main();
 
@@ -340,27 +340,6 @@ public class CodeTest extends CodeAssertJunit5Test {
         final DependencyRules rules = denyAll().withExternals("java.*").withRelativeRules(new MyProject());
         return new DependencyAnalyzer(CONFIG).rules(rules).analyze();
     }
-
-    @Override
-    protected FindBugsResult analyzeFindBugs() {
-        final BugCollector bugCollector = new BugCollector().just(
-                In.classes("*Exception").ignore("SE_BAD_FIELD"));
-        return new FindBugsAnalyzer(CONFIG, bugCollector).analyze();
-    }
-
-    @Override
-    protected CheckstyleResult analyzeCheckstyle() {
-        final StyleEventCollector bugCollector = new StyleEventCollector().just(
-                In.everywhere().ignore("javadoc.missing"));
-        return new CheckstyleAnalyzer(CONFIG, StyleChecks.google(), bugCollector).analyze();
-    }
-
-    @Override
-    protected PmdResult analyzePmd() {
-        final PmdViolationCollector collector = new PmdViolationCollector().just(
-                In.everywhere().ignore("MethodArgumentCouldBeFinal"));
-        return new PmdAnalyzer(CONFIG, collector).withRulesets(basic(), braces()).analyze();
-    }
 }
 ```
 [//]: # (end)

code-assert-core/pom.xml

@@ -88,11 +88,6 @@
             <artifactId>hamcrest-core</artifactId>
             <version>1.3</version>
         </dependency>
-        <dependency>
-            <groupId>commons-io</groupId>
-            <artifactId>commons-io</artifactId>
-            <version>2.7</version>
-        </dependency>
 
         <dependency>
             <groupId>junit</groupId>
@@ -110,15 +105,6 @@
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
         </dependency>
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>jcl-over-slf4j</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>org.slf4j</groupId>
-            <artifactId>jul-to-slf4j</artifactId>
-        </dependency>
-
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-simple</artifactId>

code-assert-core/src/main/java/guru/nidi/codeassert/AnalyzerResult.java

@@ -15,16 +15,9 @@
  */
 package guru.nidi.codeassert;
 
-import org.slf4j.bridge.SLF4JBridgeHandler;
-
 import java.util.List;
 
 public class AnalyzerResult<T> {
-    static {
-        SLF4JBridgeHandler.removeHandlersForRootLogger();
-        SLF4JBridgeHandler.install();
-    }
-
     private final Analyzer<T> analyzer;
     private final T findings;
     private final List<String> unusedActions;

code-assert-core/src/main/java/guru/nidi/codeassert/model/ClassFileParser.java

@@ -15,7 +15,7 @@
  */
 package guru.nidi.codeassert.model;
 
-import org.apache.commons.io.input.CountingInputStream;
+import guru.nidi.codeassert.util.CountingInputStream;
 
 import java.io.*;
 import java.util.ArrayList;

code-assert-core/src/main/java/guru/nidi/codeassert/util/CountingInputStream.java

@@ -0,0 +1,144 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package guru.nidi.codeassert.util;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+/**
+ * A decorating input stream that counts the number of bytes that have passed
+ * through the stream so far.
+ * <p>
+ * A typical use case would be during debugging, to ensure that data is being
+ * read as expected.
+ */
+public class CountingInputStream extends ProxyInputStream {
+
+    /**
+     * The count of bytes that have passed.
+     */
+    private long count;
+
+    /**
+     * Constructs a new CountingInputStream.
+     *
+     * @param in the InputStream to delegate to
+     */
+    public CountingInputStream(final InputStream in) {
+        super(in);
+    }
+
+    //-----------------------------------------------------------------------
+
+    /**
+     * Skips the stream over the specified number of bytes, adding the skipped
+     * amount to the count.
+     *
+     * @param length the number of bytes to skip
+     * @return the actual number of bytes skipped
+     * @throws IOException if an I/O error occurs
+     * @see java.io.InputStream#skip(long)
+     */
+    @Override
+    public synchronized long skip(final long length) throws IOException {
+        final long skip = super.skip(length);
+        this.count += skip;
+        return skip;
+    }
+
+    /**
+     * Adds the number of read bytes to the count.
+     *
+     * @param n number of bytes read, or -1 if no more bytes are available
+     * @since 2.0
+     */
+    @Override
+    protected synchronized void afterRead(final int n) {
+        if (n != EOF) {
+            this.count += n;
+        }
+    }
+
+    //-----------------------------------------------------------------------
+
+    /**
+     * The number of bytes that have passed through this stream.
+     * <p>
+     * NOTE: From v1.3 this method throws an ArithmeticException if the
+     * count is greater than can be expressed by an <code>int</code>.
+     * See {@link #getByteCount()} for a method using a <code>long</code>.
+     *
+     * @return the number of bytes accumulated
+     * @throws ArithmeticException if the byte count is too large
+     */
+    public int getCount() {
+        final long result = getByteCount();
+        if (result > Integer.MAX_VALUE) {
+            throw new ArithmeticException("The byte count " + result + " is too large to be converted to an int");
+        }
+        return (int) result;
+    }
+
+    /**
+     * Set the byte count back to 0.
+     * <p>
+     * NOTE: From v1.3 this method throws an ArithmeticException if the
+     * count is greater than can be expressed by an <code>int</code>.
+     * See {@link #resetByteCount()} for a method using a <code>long</code>.
+     *
+     * @return the count previous to resetting
+     * @throws ArithmeticException if the byte count is too large
+     */
+    public int resetCount() {
+        final long result = resetByteCount();
+        if (result > Integer.MAX_VALUE) {
+            throw new ArithmeticException("The byte count " + result + " is too large to be converted to an int");
+        }
+        return (int) result;
+    }
+
+    /**
+     * The number of bytes that have passed through this stream.
+     * <p>
+     * NOTE: This method is an alternative for <code>getCount()</code>
+     * and was added because that method returns an integer which will
+     * result in incorrect count for files over 2GB.
+     *
+     * @return the number of bytes accumulated
+     * @since 1.3
+     */
+    public synchronized long getByteCount() {
+        return this.count;
+    }
+
+    /**
+     * Set the byte count back to 0.
+     * <p>
+     * NOTE: This method is an alternative for <code>resetCount()</code>
+     * and was added because that method returns an integer which will
+     * result in incorrect count for files over 2GB.
+     *
+     * @return the count previous to resetting
+     * @since 1.3
+     */
+    public synchronized long resetByteCount() {
+        final long tmp = this.count;
+        this.count = 0;
+        return tmp;
+    }
+
+}