Merge with origin.

docs/docs/cli.md

@@ -116,6 +116,13 @@ the `--no-dev` option.
 poetry install --no-dev
 ```
 
+If you want to remove old dependencies no longer present in the lock file, use the
+`--remove-untracked` option.
+
+```bash
+poetry install --remove-untracked
+```
+
 You can also specify the extras you want installed
 by passing the `--E|--extras` option (See [Extras](#extras) for more info)
 

poetry/console/commands/install.py

@@ -20,9 +20,7 @@ class InstallCommand(EnvCommand):
             "(implicitly enables --verbose).",
         ),
         option(
-            "keep-untracked",
-            None,
-            "Does not remove packages not present in the lock file.",
+            "remove-untracked", None, "Removes packages not present in the lock file.",
         ),
         option(
             "extras",
@@ -63,7 +61,7 @@ def handle(self):
         installer.extras(extras)
         installer.dev_mode(not self.option("no-dev"))
         installer.dry_run(self.option("dry-run"))
-        installer.keep_untracked(self.option("keep-untracked"))
+        installer.remove_untracked(self.option("remove-untracked"))
         installer.verbose(self.option("verbose"))
 
         return_code = installer.run()

poetry/installation/installer.py

@@ -11,6 +11,7 @@
 from poetry.puzzle.operations import Uninstall
 from poetry.puzzle.operations import Update
 from poetry.puzzle.operations.operation import Operation
+from poetry.puzzle.provider import Provider
 from poetry.repositories import Pool
 from poetry.repositories import Repository
 from poetry.repositories.installed_repository import InstalledRepository
@@ -38,7 +39,7 @@ def __init__(
         self._pool = pool
 
         self._dry_run = False
-        self._keep_untracked = False
+        self._remove_untracked = False
         self._update = False
         self._verbose = False
         self._write_lock = True
@@ -83,13 +84,13 @@ def dry_run(self, dry_run=True):  # type: (bool) -> Installer
     def is_dry_run(self):  # type: () -> bool
         return self._dry_run
 
-    def keep_untracked(self, keep_untracked=True):  # type: (bool) -> Installer
-        self._keep_untracked = keep_untracked
+    def remove_untracked(self, remove_untracked=True):  # type: (bool) -> Installer
+        self._remove_untracked = remove_untracked
 
         return self
 
-    def is_keep_untracked(self):  # type: () -> bool
-        return self._keep_untracked
+    def is_remove_untracked(self):  # type: () -> bool
+        return self._remove_untracked
 
     def verbose(self, verbose=True):  # type: (bool) -> Installer
         self._verbose = verbose
@@ -205,6 +206,45 @@ def _do_install(self, local_repo):
             root = root.clone()
             del root.dev_requires[:]
 
+        with root.with_python_versions(
+            ".".join([str(i) for i in self._env.version_info[:3]])
+        ):
+            # We resolve again by only using the lock file
+            pool = Pool(ignore_repository_names=True)
+
+            # Making a new repo containing the packages
+            # newly resolved and the ones from the current lock file
+            repo = Repository()
+            for package in local_repo.packages + locked_repository.packages:
+                if not repo.has_package(package):
+                    repo.add_package(package)
+
+            pool.add_repository(repo)
+
+            # We whitelist all packages to be sure
+            # that the latest ones are picked up
+            whitelist = []
+            for pkg in locked_repository.packages:
+                whitelist.append(pkg.name)
+
+            solver = Solver(
+                root, pool, self._installed_repository, locked_repository, NullIO()
+            )
+
+            ops = solver.solve(use_latest=whitelist)
+
+        if self._remove_untracked:
+            locked_names = {locked.name for locked in locked_repository.packages}
+
+            for installed in self._installed_repository.packages:
+                if installed.name == self._package.name:
+                    continue
+                if installed.name in Provider.UNSAFE_PACKAGES:
+                    # Never remove pip, setuptools etc.
+                    continue
+                if installed.name not in locked_names:
+                    ops.append(Uninstall(installed))
+
         # We need to filter operations so that packages
         # not compatible with the current system,
         # or optional and not requested, are dropped
@@ -405,17 +445,6 @@ def _get_operations_from_lock(
 
             ops.append(op)
 
-        if not self._keep_untracked:
-            for installed in installed_repo.packages:
-                is_in_lock_file = False
-                for locked in locked_repository.packages:
-                    if locked.name == installed.name:
-                        is_in_lock_file = True
-                        break
-
-                if not is_in_lock_file:
-                    ops.append(Uninstall(installed))
-
         return ops
 
     def _filter_operations(

tests/installation/test_installer.py

@@ -295,6 +295,59 @@ def test_run_install_no_dev(installer, locker, repo, package, installed):
     assert len(removals) == 1
 
 
+def test_run_install_remove_untracked(installer, locker, repo, package, installed):
+    locker.locked(True)
+    locker.mock_lock_data(
+        {
+            "package": [
+                {
+                    "name": "a",
+                    "version": "1.0",
+                    "category": "main",
+                    "optional": False,
+                    "platform": "*",
+                    "python-versions": "*",
+                    "checksum": [],
+                }
+            ],
+            "metadata": {
+                "python-versions": "*",
+                "platform": "*",
+                "content-hash": "123456789",
+                "hashes": {"a": []},
+            },
+        }
+    )
+    package_a = get_package("a", "1.0")
+    package_b = get_package("b", "1.1")
+    package_c = get_package("c", "1.2")
+    package_pip = get_package("pip", "20.0.0")
+    repo.add_package(package_a)
+    repo.add_package(package_b)
+    repo.add_package(package_c)
+    repo.add_package(package_pip)
+
+    installed.add_package(package_a)
+    installed.add_package(package_b)
+    installed.add_package(package_c)
+    installed.add_package(package_pip)  # Always required and never removed.
+    installed.add_package(package)  # Root package never removed.
+
+    package.add_dependency("A", "~1.0")
+
+    installer.dev_mode(True).remove_untracked(True)
+    installer.run()
+
+    installs = installer.installer.installs
+    assert len(installs) == 0
+
+    updates = installer.installer.updates
+    assert len(updates) == 0
+
+    removals = installer.installer.removals
+    assert set(r.name for r in removals) == {"b", "c"}
+
+
 def test_run_whitelist_add(installer, locker, repo, package):
     locker.locked(True)
     locker.mock_lock_data(