Clean up spotbugs

Author: bitwiseman

src/main/java/org/kohsuke/github/GHCommitFileIterable.java

@@ -23,7 +23,7 @@ private static PaginatedEndpoint<GHCommitFilesPage, File> createEndpointIterable
         PaginatedEndpoint<GHCommitFilesPage, File> iterable;
         if (files != null && files.length < GH_FILE_LIMIT_PER_COMMIT_PAGE) {
             // create a page iterator that only provides one page
-            iterable = PaginatedEndpoint.ofSingleton(new GHCommitFilesPage(files));
+            iterable = PaginatedEndpoint.ofSinglePage(new GHCommitFilesPage(files), GHCommit.File.class);
         } else {
             GitHubRequest request = owner.root()
                     .createRequest()

src/main/java/org/kohsuke/github/GHCompare.java

@@ -261,6 +261,7 @@ public URL getHtmlUrl() {
     }
 
     @Override
+    @SuppressFBWarnings(value = { "EI_EXPOSE_REP" }, justification = "Expected behavior")
     public GHCompare.Commit[] getItems() {
         return commits;
     }
@@ -345,7 +346,7 @@ public PagedIterable<Commit> listCommits() {
                     .withPageSize(10);
         } else {
             // if not using paginated commits, adapt the returned commits array
-            return new PagedIterable<>(PaginatedEndpoint.ofSingleton(this.commits));
+            return new PagedIterable<>(PaginatedEndpoint.ofSinglePage(this.commits, Commit.class));
         }
     }
 

src/main/java/org/kohsuke/github/PagedIterable.java

@@ -6,7 +6,6 @@
 
 import javax.annotation.Nonnull;
 
-// TODO: Auto-generated Javadoc
 /**
  * {@link Iterable} that returns {@link PagedIterator}. {@link PagedIterable} is thread-safe but {@link PagedIterator}
  * is not. Any one instance of {@link PagedIterator} should only be called from a single thread.
@@ -19,6 +18,11 @@ public class PagedIterable<T> implements Iterable<T> {
 
     private final PaginatedEndpoint<?, T> paginatedEndpoint;
 
+    @Deprecated
+    public PagedIterable() {
+        this(null);
+    }
+
     /**
      * Instantiates a new git hub page contents iterable.
      */
@@ -50,11 +54,27 @@ public Set<T> toSet() throws IOException {
         return paginatedEndpoint.toSet();
     }
 
-    public PagedIterable<T> withPageSize(int i) {
-        paginatedEndpoint.withPageSize(i);
+    /**
+     * Sets the pagination size.
+     *
+     * <p>
+     * When set to non-zero, each API call will retrieve this many entries.
+     *
+     * @param size
+     *            the size
+     * @return the paged iterable
+     */
+    public PagedIterable<T> withPageSize(int size) {
+        paginatedEndpoint.withPageSize(size);
         return this;
     }
 
+    @Nonnull
+    @Deprecated
+    protected T[] toArray(final PagedIterator<T> iterator) throws IOException {
+        return paginatedEndpoint.toArray();
+    }
+
     GitHubResponse<T[]> toResponse() throws IOException {
         return paginatedEndpoint.toResponse();
     }

src/main/java/org/kohsuke/github/PagedIterator.java

@@ -1,5 +1,7 @@
 package org.kohsuke.github;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
 import java.util.Iterator;
 import java.util.List;
 
@@ -19,15 +21,19 @@
  */
 public class PagedIterator<T> implements Iterator<T> {
 
-    private final PaginatedEndpointItems<?, T> endpointIterator;
+    private final PaginatedEndpointItems<T> endpointIterator;
+
+    @Deprecated
+    @SuppressFBWarnings(value = { "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD" }, justification = "No longer used")
+    protected Iterator<T[]> base = null;
 
     /**
      * Instantiates a new paged iterator.
      *
      * @param endpointIterator
      *            the base
      */
-    PagedIterator(PaginatedEndpointItems<?, T> endpointIterator) {
+    PagedIterator(PaginatedEndpointItems<T> endpointIterator) {
         this.endpointIterator = endpointIterator;
     }
 
@@ -49,4 +55,8 @@ public T next() {
     public List<T> nextPage() {
         return endpointIterator.nextPage();
     }
+
+    @Deprecated
+    protected void wrapUp(T[] page) {
+    }
 }

src/main/java/org/kohsuke/github/PagedSearchIterable.java

@@ -2,6 +2,8 @@
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 
+import java.util.Iterator;
+
 // TODO: Auto-generated Javadoc
 /**
  * {@link PagedIterable} enhanced to report search result specific information.
@@ -45,4 +47,21 @@ public boolean isIncomplete() {
         // populate();
         return paginatedEndpoint.pages().peek().incompleteResults;
     }
+
+    /**
+     * With page size.
+     *
+     * @param size
+     *            the size
+     * @return the paged search iterable
+     */
+    @Override
+    public PagedSearchIterable<T> withPageSize(int size) {
+        return (PagedSearchIterable<T>) super.withPageSize(size);
+    }
+
+    @Deprecated
+    protected Iterator<T[]> adapt(final Iterator<? extends SearchResult<T>> base) {
+        return null;
+    }
 }

src/main/java/org/kohsuke/github/PaginatedEndpoint.java

@@ -1,5 +1,6 @@
 package org.kohsuke.github;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.IOException;
@@ -22,20 +23,20 @@
  */
 class PaginatedEndpoint<Page extends GitHubPage<Item>, Item> implements Iterable<Item> {
 
-    private static class ArrayIterable<I> extends PaginatedEndpoint<GitHubPage<I>, I> {
+    private static class ArrayIterable<I> extends PaginatedEndpoint<GitHubArrayPage<I>, I> {
 
-        private class ArrayIterator extends PaginatedEndpointPages<GitHubPage<I>, I> {
+        private class ArrayIterator extends PaginatedEndpointPages<GitHubArrayPage<I>, I> {
 
             ArrayIterator(GitHubClient client,
-                    Class<GitHubPage<I>> pageType,
+                    Class<GitHubArrayPage<I>> pageType,
                     GitHubRequest request,
                     int pageSize,
                     Consumer<I> itemInitializer) {
                 super(client, pageType, request, pageSize, itemInitializer);
             }
 
             @Override
-            @NotNull protected GitHubResponse<GitHubPage<I>> sendNextRequest() throws IOException {
+            @NotNull protected GitHubResponse<GitHubArrayPage<I>> sendNextRequest() throws IOException {
                 GitHubResponse<I[]> response = client.sendRequest(nextRequest,
                         (connectorResponse) -> GitHubResponse.parseBody(connectorResponse, receiverType));
                 return new GitHubResponse<>(response, new GitHubArrayPage<>(response.body()));
@@ -48,32 +49,31 @@ private class ArrayIterator extends PaginatedEndpointPages<GitHubPage<I>, I> {
         private ArrayIterable(GitHubClient client,
                 GitHubRequest request,
                 Class<I[]> receiverType,
+                Class<I> itemType,
                 Consumer<I> itemInitializer) {
-            super(client,
-                    request,
-                    GitHubArrayPage.getArrayPageClass(receiverType),
-                    (Class<I>) receiverType.getComponentType(),
-                    itemInitializer);
+            super(client, request, GitHubArrayPage.getArrayPageClass(itemType), itemType, itemInitializer);
             this.receiverType = receiverType;
         }
 
-        @NotNull @Override
-        public PaginatedEndpointPages<GitHubPage<I>, I> pages() {
+        @Nonnull
+        @Override
+        public PaginatedEndpointPages<GitHubArrayPage<I>, I> pages() {
             return new ArrayIterator(client, pageType, request, pageSize, itemInitializer);
         }
     }
 
     /**
-     * Represents the result of a search.
+     * Represents a page of results
      *
      * @author Kohsuke Kawaguchi
      * @param <I>
      *            the generic type
      */
     private static class GitHubArrayPage<I> implements GitHubPage<I> {
 
-        private static <P extends GitHubPage<I>, I> Class<P> getArrayPageClass(Class<I[]> receiverType) {
-            return (Class<P>) new GitHubArrayPage<>(receiverType).getClass();
+        @SuppressFBWarnings(value = { "DM_NEW_FOR_GETCLASS" }, justification = "BUG?")
+        private static <P extends GitHubPage<I>, I> Class<P> getArrayPageClass(Class<I> itemType) {
+            return (Class<P>) new GitHubArrayPage<>(itemType).getClass();
         }
 
         private final I[] items;
@@ -82,35 +82,48 @@ public GitHubArrayPage(I[] items) {
             this.items = items;
         }
 
-        private GitHubArrayPage(Class<I[]> receiverType) {
-            this.items = (I[]) Array.newInstance(receiverType.getComponentType(), 0);
+        private GitHubArrayPage(Class<I> itemType) {
+            this.items = null;
         }
 
         public I[] getItems() {
             return items;
         }
     }
 
-    static <I> PaginatedEndpoint<GitHubPage<I>, I> ofArrayEndpoint(GitHubClient client,
+    private static class SinglePage<P extends GitHubPage<I>, I> extends PaginatedEndpoint<P, I> {
+        private final P page;
+
+        SinglePage(P page, Class<I> itemType) {
+            super(null, null, (Class<P>) page.getClass(), itemType, null);
+            this.page = page;
+        }
+
+        @Nonnull
+        @Override
+        public PaginatedEndpointPages<P, I> pages() {
+            return PaginatedEndpointPages.ofSinglePage(pageType, page);
+        }
+
+    }
+
+    static <I> PaginatedEndpoint<GitHubArrayPage<I>, I> ofArrayEndpoint(GitHubClient client,
             GitHubRequest request,
             Class<I[]> receiverType,
             Consumer<I> itemInitializer) {
-        return new ArrayIterable<>(client, request, receiverType, itemInitializer);
+        return new ArrayIterable<I>(client,
+                request,
+                (Class<I[]>) receiverType,
+                (Class<I>) receiverType.getComponentType(),
+                itemInitializer);
     }
 
-    static <I> PaginatedEndpoint<GitHubPage<I>, I> ofSingleton(I[] array) {
-        return ofSingleton(new GitHubArrayPage<>(array));
+    static <I> PaginatedEndpoint<GitHubArrayPage<I>, I> ofSinglePage(I[] array, Class<I> itemType) {
+        return ofSinglePage(new GitHubArrayPage<>(array), itemType);
     }
 
-    static <P extends GitHubPage<I>, I> PaginatedEndpoint<P, I> ofSingleton(P page) {
-        Class<I> itemType = (Class<I>) page.getItems().getClass().getComponentType();
-        return new PaginatedEndpoint<>(null, null, (Class<P>) page.getClass(), itemType, null) {
-            @Nonnull
-            @Override
-            public PaginatedEndpointPages<P, I> pages() {
-                return PaginatedEndpointPages.ofSingleton(page);
-            }
-        };
+    static <P extends GitHubPage<I>, I> PaginatedEndpoint<P, I> ofSinglePage(P page, Class<I> itemType) {
+        return new SinglePage<>(page, itemType);
     }
 
     protected final GitHubClient client;
@@ -151,9 +164,10 @@ public PaginatedEndpointPages<P, I> pages() {
     }
 
     @Nonnull
-    public final PaginatedEndpointItems<Page, Item> items() {
+    public final PaginatedEndpointItems<Item> items() {
         return new PaginatedEndpointItems<>(this.pages());
     }
+
     @Nonnull
     @Override
     public final Iterator<Item> iterator() {

src/main/java/org/kohsuke/github/PaginatedEndpointItems.java

@@ -5,7 +5,7 @@
 /**
  * This class is not thread-safe. Any one instance should only be called from a single thread.
  */
-class PaginatedEndpointItems<Page extends GitHubPage<Item>, Item> implements Iterator<Item> {
+class PaginatedEndpointItems<Item> implements Iterator<Item> {
 
     /**
      * Current batch of items. Each time {@link #next()} is called the next item in this array will be returned. After
@@ -14,7 +14,7 @@ class PaginatedEndpointItems<Page extends GitHubPage<Item>, Item> implements Ite
      *
      * @see #fetchNext() {@link #fetchNext()} for details on how this field is used.
      */
-    private Page currentPage;
+    private GitHubPage<Item> currentPage;
 
     /**
      * The index of the next item on the page, the item that will be returned when {@link #next()} is called.
@@ -23,9 +23,9 @@ class PaginatedEndpointItems<Page extends GitHubPage<Item>, Item> implements Ite
      */
     private int nextItemIndex;
 
-    private final PaginatedEndpointPages<Page, Item> pageIterator;
+    private final PaginatedEndpointPages<? extends GitHubPage<Item>, Item> pageIterator;
 
-    PaginatedEndpointItems(PaginatedEndpointPages<Page, Item> pageIterator) {
+    PaginatedEndpointItems(PaginatedEndpointPages<? extends GitHubPage<Item>, Item> pageIterator) {
         this.pageIterator = pageIterator;
     }
 

src/main/java/org/kohsuke/github/PaginatedEndpointPages.java

@@ -26,8 +26,9 @@
  */
 class PaginatedEndpointPages<P extends GitHubPage<Item>, Item> implements java.util.Iterator<P> {
 
-    static <P extends GitHubPage<Item>, Item> PaginatedEndpointPages<P, Item> ofSingleton(final P page) {
-        return new PaginatedEndpointPages<>(page);
+    static <P extends GitHubPage<Item>, Item> PaginatedEndpointPages<P, Item> ofSinglePage(Class<P> pageType,
+            final P page) {
+        return new PaginatedEndpointPages<>(pageType, page);
     }
     /**
      * When done iterating over pages, it is on rare occasions useful to be able to get information from the final
@@ -57,8 +58,8 @@ static <P extends GitHubPage<Item>, Item> PaginatedEndpointPages<P, Item> ofSing
 
     protected final Class<P> pageType;
 
-    private PaginatedEndpointPages(P page) {
-        this(null, (Class<P>) page.getClass(), null, 0, null);
+    private PaginatedEndpointPages(Class<P> pageType, P page) {
+        this(null, pageType, null, 0, null);
         this.next = page;
     }
 
@@ -75,9 +76,10 @@ private PaginatedEndpointPages(P page) {
             request = builder.build();
         }
 
-        if (request != null && !"GET".equals(request.method())) {
-            throw new IllegalArgumentException("Request method \"GET\" is required for page iterator.");
-        }
+        // if (request != null && !"GET".equals(request.method())) {
+        // throw new IllegalArgumentException("Request method \"GET\" is required for page iterator.");
+        // }
+        // assert (request == null || "GET".equals(request.method()));
 
         this.client = client;
         this.nextRequest = request;

src/main/java/org/kohsuke/github/Requester.java

@@ -225,5 +225,4 @@ public <R> PagedIterable<R> toIterable(Class<R[]> receiverType, Consumer<R> item
         GitHubRequest request = build();
         return new PagedIterable<>(PaginatedEndpoint.ofArrayEndpoint(client, request, receiverType, itemInitializer));
     }
-
 }