Added config file support, 100% coverage

Adds support for config files (.pyup.yml) and pushes test coverage to
100%.

Author: jayfk

.coveragerc

@@ -0,0 +1,3 @@
+[run]
+include = pyup/*
+omit = *migrations*, *tests*, pyup/cli.py

pyup/bot.py

@@ -1,16 +1,18 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import, print_function, unicode_literals
 import logging
+import yaml
 from .requirements import RequirementsBundle
 from .providers.github import Provider as GithubProvider
 from .errors import NoPermissionError, BranchExistsError
+from .config import Config
 
 logger = logging.getLogger(__name__)
 
 
 class Bot(object):
     def __init__(self, repo, user_token, bot_token=None,
-                 provider=GithubProvider, bundle=RequirementsBundle):
+                 provider=GithubProvider, bundle=RequirementsBundle, config=Config):
         self.bot_token = bot_token
         self.req_bundle = bundle()
         self.provider = provider(self.req_bundle)
@@ -23,8 +25,9 @@ def __init__(self, repo, user_token, bot_token=None,
         self._user_repo = None
         self._bot = None
         self._bot_repo = None
+        self.config = config()
 
-        self._pull_requests = None
+        self._fetched_prs = False
 
     @property
     def user_repo(self):
@@ -52,37 +55,54 @@ def bot_repo(self):
 
     @property
     def pull_requests(self):
-        if self._pull_requests is None:
-            self._pull_requests = [pr for pr in self.provider.iter_issues(
+        if not self._fetched_prs:
+            self.req_bundle.pull_requests = [pr for pr in self.provider.iter_issues(
                 repo=self.user_repo, creator=self.bot if self.bot_token else self.user)]
-        return self._pull_requests
+            self._fetched_prs = True
+        return self.req_bundle.pull_requests
 
-    def update(self, branch=None, initial=True, pin_unpinned=False, close_stale_prs=False):
-
-        default_branch = self.provider.get_default_branch(repo=self.user_repo)
-
-        if branch is None:
-            branch = default_branch
+    def get_repo_config(self, repo):
+        try:
+            content, _ = self.provider.get_file(repo, "/.pyup.yml", self.config.branch)
+            if content is not None:
+                return yaml.load(content)
+        except yaml.YAMLError:
+            logger.warning("Unable to parse config file /.pyup.yml", exc_info=True)
+        return None
 
-        self.get_all_requirements(branch=branch)
+    def configure(self, **kwargs):
+        # if the branch is not set, get the default branch
+        if kwargs.get("branch", False) in [None, False]:
+            self.config.branch = self.provider.get_default_branch(repo=self.user_repo)
+        # set the config for this update run
+        self.config.update(kwargs)
+        repo_config = self.get_repo_config(repo=self.user_repo)
+        if repo_config:
+            self.config.update(repo_config)
+
+    def update(self, **kwargs):
+        """
+        Main entrypoint to kick off an update run.
+        :param kwargs:
+        :return: RequirementsBundle
+        """
+        self.configure(**kwargs)
+        self.get_all_requirements()
         self.apply_updates(
-            branch,
-            initial=initial,
-            pin_unpinned=pin_unpinned,
-            close_stale_prs=close_stale_prs
+            initial=kwargs.get("initial", False),
         )
 
         return self.req_bundle
 
-    def apply_updates(self, branch, initial, pin_unpinned, close_stale_prs=False):
+    def apply_updates(self, initial):
 
         InitialUpdateClass = self.req_bundle.get_initial_update_class()
 
         if initial:
             # get the list of pending updates
             try:
                 _, _, _, updates = list(
-                    self.req_bundle.get_updates(initial=initial, pin_unpinned=pin_unpinned)
+                    self.req_bundle.get_updates(initial=initial, config=self.config)
                 )[0]
             except IndexError:
                 # need to catch the index error here in case the intial update is completely
@@ -107,13 +127,14 @@ def apply_updates(self, branch, initial, pin_unpinned, close_stale_prs=False):
             False
         )
 
-        for title, body, update_branch, updates in self.iter_updates(initial, pin_unpinned):
+        # todo: This block needs to be refactored
+        for title, body, update_branch, updates in self.iter_updates(initial):
             if initial_pr:
                 pull_request = initial_pr
             elif title not in [pr.title for pr in self.pull_requests]:
                 pull_request = self.commit_and_pull(
                     initial=initial,
-                    base_branch=branch,
+                    base_branch=self.config.branch,
                     new_branch=update_branch,
                     title=title,
                     body=body,
@@ -124,8 +145,8 @@ def apply_updates(self, branch, initial, pin_unpinned, close_stale_prs=False):
 
             for update in updates:
                 update.requirement.pull_request = pull_request
-                if close_stale_prs and pull_request and not initial:
-                    self.close_stale_prs(update, pull_request)
+                if self.config.close_prs and pull_request and not initial:
+                    self.close_stale_prs(update=update, pull_request=pull_request)
 
     def close_stale_prs(self, update, pull_request):
         """
@@ -138,8 +159,10 @@ def close_stale_prs(self, update, pull_request):
         :param update:
         :param pull_request:
         """
+        logger.info("Preparing to close stale PRs for {}".format(pull_request.title))
         if self.bot_token and pull_request.type != "initial":
             for pr in self.pull_requests:
+                logger.info("Checking PR {}".format(pr.title))
                 # check that, the pr is an update, is open, the titles are not equal and that
                 # the requirement matches
                 if pr.type == "update" and \
@@ -158,53 +181,75 @@ def close_stale_prs(self, update, pull_request):
                             comment="Closing this in favor of #{}".format(pull_request.number)
                         )
 
-    def commit_and_pull(self, initial, base_branch, new_branch, title, body, updates):
-
+    def create_branch(self, base_branch, new_branch, delete_empty=False):
+        """
+        Creates a new branch.
+        :param base_branch: string name of the base branch
+        :param new_branch: string name of the new branch
+        :param delete_empty: bool -- delete the branch if it is empty
+        :return: bool -- True if successfull
+        """
+        logger.info("Preparing to create branch {} from {}".format(new_branch, base_branch))
         try:
             # create new branch
             self.provider.create_branch(
                 base_branch=base_branch,
                 new_branch=new_branch,
                 repo=self.user_repo
             )
+            logger.info("Created branch {} from {}".format(new_branch, base_branch))
+            return True
         except BranchExistsError:
-            # instead of failing loud if the branch already exists, we are going to return
-            # None here and handle this case on a different layer.
-            return None
-
-        updated_files = {}
-        for update in self.iter_changes(initial, updates):
-            if update.requirement_file.path in updated_files:
-                sha = updated_files[update.requirement_file.path]["sha"]
-                content = updated_files[update.requirement_file.path]["content"]
-            else:
-                sha = update.requirement_file.sha
-                content = update.requirement_file.content
-            old_content = content
-            content = update.requirement.update_content(content)
-            if content != old_content:
-                new_sha = self.provider.create_commit(
-                    repo=self.user_repo,
-                    path=update.requirement_file.path,
-                    branch=new_branch,
-                    content=content,
-                    commit_message=update.commit_message,
-                    sha=sha,
-                    committer=self.bot if self.bot_token else self.user,
-                )
-                updated_files[update.requirement_file.path] = {"sha": new_sha, "content": content}
-            else:
-                logger.error("Empty commit at {repo}, unable to update {title}.".format(
-                    repo=self.user_repo.full_name, title=title)
-                )
+            logger.info("Branch {} exists.".format(new_branch))
+            # if the branch exists, is empty and delete_empty is set, delete it and call
+            # this function again
+            if delete_empty:
+                if self.provider.is_empty_branch(self.user_repo, base_branch, new_branch):
+                    self.provider.delete_branch(self.user_repo, new_branch)
+                    logger.info("Branch {} was empty and has been deleted".format(new_branch))
+                    return self.create_branch(base_branch, new_branch, delete_empty=False)
+                logger.info("Branch {} is not empty".format(new_branch))
+        return False
 
-        if updated_files:
-            return self.create_pull_request(
-                title=title,
-                body=body,
-                base_branch=base_branch,
-                new_branch=new_branch
-            )
+    def commit_and_pull(self, initial, base_branch, new_branch, title, body, updates):
+        logger.info("Preparing commit {}".format(title))
+        if self.create_branch(base_branch, new_branch, delete_empty=True):
+            updated_files = {}
+            for update in self.iter_changes(initial, updates):
+                if update.requirement_file.path in updated_files:
+                    sha = updated_files[update.requirement_file.path]["sha"]
+                    content = updated_files[update.requirement_file.path]["content"]
+                else:
+                    sha = update.requirement_file.sha
+                    content = update.requirement_file.content
+                old_content = content
+                content = update.requirement.update_content(content)
+                if content != old_content:
+                    new_sha = self.provider.create_commit(
+                        repo=self.user_repo,
+                        path=update.requirement_file.path,
+                        branch=new_branch,
+                        content=content,
+                        commit_message=update.commit_message,
+                        sha=sha,
+                        committer=self.bot if self.bot_token else self.user,
+                    )
+                    updated_files[update.requirement_file.path] = {"sha": new_sha,
+                                                                   "content": content}
+                else:
+                    logger.error("Empty commit at {repo}, unable to update {title}.".format(
+                        repo=self.user_repo.full_name, title=title)
+                    )
+
+            if updated_files:
+                pr = self.create_pull_request(
+                    title=title,
+                    body=body,
+                    base_branch=base_branch,
+                    new_branch=new_branch
+                )
+                self.pull_requests.append(pr)
+                return pr
         return None
 
     def create_issue(self, title, body):
@@ -242,33 +287,39 @@ def create_pull_request(self, title, body, base_branch, new_branch):
     def iter_git_tree(self, branch):
         return self.provider.iter_git_tree(branch=branch, repo=self.user_repo)
 
-    def iter_updates(self, initial, pin_unpinned):
-        return self.req_bundle.get_updates(initial=initial, pin_unpinned=pin_unpinned)
+    def iter_updates(self, initial):
+        return self.req_bundle.get_updates(initial=initial, config=self.config)
 
     def iter_changes(self, initial, updates):
         return iter(updates)
 
     # if this function gets updated, the gist at https://gist.github.com/jayfk/45862b05836701b49b01
     # needs to be updated too
-    def get_all_requirements(self, branch):
-        for file_type, path in self.iter_git_tree(branch):
-            if file_type == "blob":
-                if "requirements" in path:
-                    if path.endswith("txt") or path.endswith("pip"):
-                        self.add_requirement_file(path, branch)
+    def get_all_requirements(self):
+        if self.config.search:
+            logger.info("Searching requirement files")
+            for file_type, path in self.iter_git_tree(self.config.branch):
+                if file_type == "blob":
+                    if "requirements" in path:
+                        if path.endswith("txt") or path.endswith("pip"):
+                            self.add_requirement_file(path)
+        for req_file in self.config.requirements:
+            self.add_requirement_file(req_file.path)
 
     # if this function gets updated, the gist at https://gist.github.com/jayfk/c6509bbaf4429052ca3f
     # needs to be updated too
-    def add_requirement_file(self, path, branch):
+    def add_requirement_file(self, path):
+        logger.info("Adding requirement file at {}".format(path))
         if not self.req_bundle.has_file_in_path(path):
             req_file = self.provider.get_requirement_file(
-                path=path, repo=self.user_repo, branch=branch)
+                path=path, repo=self.user_repo, branch=self.config.branch)
             if req_file is not None:
                 self.req_bundle.append(req_file)
                 for other_file in req_file.other_files:
-                    self.add_requirement_file(other_file, branch)
+                    self.add_requirement_file(other_file)
 
 
 class DryBot(Bot):
-    def commit_and_pull(self, base_branch, new_branch, title, body, updates):  # pragma: no cover
+    def commit_and_pull(self, initial, base_branch, new_branch, title, body,
+                        updates):  # pragma: no cover
         return None

pyup/cli.py

@@ -18,7 +18,8 @@
 @click.option('--branch', help='', default=None)
 @click.option('--initial', help='', default=False, is_flag=True)
 @click.option('--pin', help='', default=True)
-def main(repo, user_token, bot_token, provider, dry, branch, initial, pin):
+@click.option('--close-prs', help='Tell the bot to close stale pull requests', default=True)
+def main(repo, user_token, bot_token, provider, dry, branch, initial, pin, close_prs):
 
     if provider == 'github':
         ProviderClass = GithubProvider
@@ -37,7 +38,7 @@ def main(repo, user_token, bot_token, provider, dry, branch, initial, pin):
         provider=ProviderClass
     )
 
-    bot.update(branch=branch, initial=initial, pin_unpinned=pin)
+    bot.update(branch=branch, initial=initial, pin=pin, close_prs=close_prs)
 
 if __name__ == '__main__':
     main()