Merge remote-tracking branch 'upstream/master' into hide-graph-from-percy

Author: carols10cents

mirage/fixtures/crates.js

@@ -1,5 +1,28 @@
 /* eslint-disable quotes */
 export default [
+  {
+    badges: [
+      {
+        badge_type: 'maintenance',
+        attributes: {
+          status: 'actively-developed',
+        },
+      },
+    ],
+    created_at: '2014-11-23T09:01:21Z',
+    description: 'A Kinetic protocol library written in Rust',
+    documentation: 'https://icorderi.github.io/kinetic-rust/doc/kinetic/',
+    downloads: 225,
+    recent_downloads: 125,
+    homepage: 'https://icorderi.github.io/icorderi/kinetic-rust',
+    id: 'kinetic-rust',
+    keywords: ['Protocol', 'Kinetic', 'Storage'],
+    max_version: '0.0.16',
+    name: 'kinetic-rust',
+    repository: 'https://github.com/icorderi/kinetic-rust/',
+    updated_at: '2015-04-21T00:15:49Z',
+    versions: null,
+  },
   {
     badges: [
       {
@@ -201,29 +224,6 @@ export default [
     updated_at: '2015-11-11T00:10:43Z',
     versions: null,
   },
-  {
-    badges: [
-      {
-        badge_type: 'maintenance',
-        attributes: {
-          status: 'actively-developed',
-        },
-      },
-    ],
-    created_at: '2014-11-23T09:01:21Z',
-    description: 'A Kinetic protocol library written in Rust',
-    documentation: 'https://icorderi.github.io/kinetic-rust/doc/kinetic/',
-    downloads: 225,
-    recent_downloads: 125,
-    homepage: 'https://icorderi.github.io/icorderi/kinetic-rust',
-    id: 'kinetic-rust',
-    keywords: ['Protocol', 'Kinetic', 'Storage'],
-    max_version: '0.0.16',
-    name: 'kinetic-rust',
-    repository: 'https://github.com/icorderi/kinetic-rust/',
-    updated_at: '2015-04-21T00:15:49Z',
-    versions: null,
-  },
   {
     created_at: '2014-11-29T17:51:55Z',
     description: 'Rustless is a REST-like API micro-framework for Rust.',

package-lock.json

@@ -35,7 +35,7 @@
     "broccoli-asset-rev": "^3.0.0",
     "ember-a11y-testing": "^2.0.0",
     "ember-auto-import": "^1.5.3",
-    "ember-cli": "~3.14.0",
+    "ember-cli": "~3.15.0",
     "ember-cli-app-version": "^3.1.3",
     "ember-cli-babel": "^7.13.2",
     "ember-cli-clipboard": "^0.9.0",
@@ -44,20 +44,19 @@
     "ember-cli-dependency-lint": "^1.1.3",
     "ember-cli-fastboot": "^2.2.1",
     "ember-cli-htmlbars": "^4.2.0",
-    "ember-cli-htmlbars-inline-precompile": "^1.0.2",
     "ember-cli-inject-live-reload": "1.6.1",
     "ember-cli-meta-tags": "^5.3.0",
-    "ember-cli-mirage": "^0.4.7",
+    "ember-cli-mirage": "^1.1.6",
     "ember-cli-moment-shim": "^3.7.1",
     "ember-cli-sass": "^10.0.1",
     "ember-cli-sri": "2.1.1",
     "ember-cli-uglify": "^3.0.0",
     "ember-component-attributes": "^0.1.3",
     "ember-concurrency": "^1.1.3",
-    "ember-data": "~2.18.2",
+    "ember-data": "~3.15.0",
     "ember-disable-prototype-extensions": "^1.1.3",
     "ember-exam": "^4.0.9",
-    "ember-export-application-global": "^2.0.0",
+    "ember-export-application-global": "^2.0.1",
     "ember-fetch": "^7.0.0",
     "ember-keyboard": "^5.0.0",
     "ember-load-initializers": "^2.1.1",
@@ -68,26 +67,26 @@
     "ember-promise-helpers": "^1.0.9",
     "ember-qunit": "^4.6.0",
     "ember-resolver": "^7.0.0",
-    "ember-router-scroll": "^0.4.0",
-    "ember-source": "~3.1.0",
-    "ember-svg-jar": "^1.1.1",
+    "ember-router-scroll": "^1.3.3",
     "ember-template-lint": "^1.12.1",
-    "ember-test-selectors": "^0.3.7",
+    "ember-source": "~3.15.0",
+    "ember-svg-jar": "^2.2.3",
+    "ember-test-selectors": "^3.0.0",
     "ember-web-app": "^2.2.0",
     "emberx-select": "^3.1.1",
     "eslint": "^6.3.0",
     "eslint-config-prettier": "^6.7.0",
     "eslint-plugin-ember": "^7.7.2",
     "eslint-plugin-prettier": "^3.1.2",
     "faker": "^4.1.0",
-    "loader.js": "^4.5.1",
-    "normalize.css": "^7.0.0",
+    "loader.js": "^4.7.0",
+    "normalize.css": "^8.0.1",
     "nyc": "^14.1.1",
-    "prettier": "^1.13.4",
+    "prettier": "^1.19.1",
     "qunit-dom": "^0.9.2",
     "sass": "^1.23.0-module.beta.1",
     "semver": "^6.3.0",
-    "timekeeper": "^2.1.0"
+    "timekeeper": "^2.2.0"
   },
   "engines": {
     "node": "^12.9.1",

package.json

@@ -7,7 +7,7 @@
 use crate::controllers::frontend_prelude::*;
 use crate::models::{
     Category, Crate, CrateCategory, CrateKeyword, CrateVersions, Keyword, RecentCrateDownloads,
-    User, Version,
+    User, Version, VersionOwnerAction,
 };
 use crate::schema::*;
 use crate::views::{
@@ -105,13 +105,26 @@ pub fn show(req: &mut dyn Request) -> AppResult<Response> {
     let conn = req.db_conn()?;
     let krate = Crate::by_name(name).first::<Crate>(&*conn)?;
 
-    let mut versions_and_publishers: Vec<(Version, Option<User>)> = krate
+    let mut versions_and_publishers = krate
         .all_versions()
         .left_outer_join(users::table)
         .select((versions::all_columns, users::all_columns.nullable()))
-        .load(&*conn)?;
+        .load::<(Version, Option<User>)>(&*conn)?;
     versions_and_publishers.sort_by(|a, b| b.0.num.cmp(&a.0.num));
-    let ids = versions_and_publishers.iter().map(|v| v.0.id).collect();
+    let versions = versions_and_publishers
+        .iter()
+        .map(|(v, _)| v)
+        .cloned()
+        .collect::<Vec<_>>();
+    let versions_publishers_and_audit_actions = versions_and_publishers
+        .into_iter()
+        .zip(VersionOwnerAction::for_versions(&conn, &versions)?.into_iter())
+        .map(|((v, pb), aas)| (v, pb, aas))
+        .collect::<Vec<_>>();
+    let ids = versions_publishers_and_audit_actions
+        .iter()
+        .map(|v| v.0.id)
+        .collect();
 
     let kws = CrateKeyword::belonging_to(&krate)
         .inner_join(keywords::table)
@@ -149,9 +162,9 @@ pub fn show(req: &mut dyn Request) -> AppResult<Response> {
             false,
             recent_downloads,
         ),
-        versions: versions_and_publishers
+        versions: versions_publishers_and_audit_actions
             .into_iter()
-            .map(|(v, pb)| v.encodable(&krate.name, pb))
+            .map(|(v, pb, aas)| v.encodable(&krate.name, pb, aas))
             .collect(),
         keywords: kws.into_iter().map(Keyword::encodable).collect(),
         categories: cats.into_iter().map(Category::encodable).collect(),
@@ -193,9 +206,15 @@ pub fn versions(req: &mut dyn Request) -> AppResult<Response> {
         .select((versions::all_columns, users::all_columns.nullable()))
         .load(&*conn)?;
     versions_and_publishers.sort_by(|a, b| b.0.num.cmp(&a.0.num));
+    let versions = versions_and_publishers
+        .iter()
+        .map(|(v, _)| v)
+        .cloned()
+        .collect::<Vec<_>>();
     let versions = versions_and_publishers
         .into_iter()
-        .map(|(v, pb)| v.encodable(crate_name, pb))
+        .zip(VersionOwnerAction::for_versions(&conn, &versions)?.into_iter())
+        .map(|((v, pb), aas)| v.encodable(crate_name, pb, aas))
         .collect();
 
     #[derive(Serialize)]
@@ -220,7 +239,7 @@ pub fn reverse_dependencies(req: &mut dyn Request) -> AppResult<Response> {
 
     let version_ids: Vec<i32> = rev_deps.iter().map(|dep| dep.version_id).collect();
 
-    let versions = versions::table
+    let versions_and_publishers = versions::table
         .filter(versions::id.eq(any(version_ids)))
         .inner_join(crates::table)
         .left_outer_join(users::table)
@@ -229,9 +248,18 @@ pub fn reverse_dependencies(req: &mut dyn Request) -> AppResult<Response> {
             crates::name,
             users::all_columns.nullable(),
         ))
-        .load::<(Version, String, Option<User>)>(&*conn)?
+        .load::<(Version, String, Option<User>)>(&*conn)?;
+    let versions = versions_and_publishers
+        .iter()
+        .map(|(v, _, _)| v)
+        .cloned()
+        .collect::<Vec<_>>();
+    let versions = versions_and_publishers
         .into_iter()
-        .map(|(version, krate_name, user)| version.encodable(&krate_name, user))
+        .zip(VersionOwnerAction::for_versions(&conn, &versions)?.into_iter())
+        .map(|((version, krate_name, published_by), actions)| {
+            version.encodable(&krate_name, published_by, actions)
+        })
         .collect();
 
     #[derive(Serialize)]

src/controllers/krate/metadata.rs

@@ -6,7 +6,9 @@ use crate::controllers::helpers::*;
 use crate::email;
 use crate::util::errors::AppError;
 
-use crate::models::{CrateOwner, Email, Follow, NewEmail, OwnerKind, User, Version};
+use crate::models::{
+    CrateOwner, Email, Follow, NewEmail, OwnerKind, User, Version, VersionOwnerAction,
+};
 use crate::schema::{crate_owners, crates, emails, follows, users, versions};
 use crate::views::{EncodableMe, EncodableVersion, OwnedCrate};
 
@@ -79,12 +81,19 @@ pub fn updates(req: &mut dyn Request) -> AppResult<Response> {
         ))
         .paginate(&req.query())?
         .load::<(Version, String, Option<User>)>(&*conn)?;
-
     let more = data.next_page_params().is_some();
+    let versions = data.iter().map(|(v, _, _)| v).cloned().collect::<Vec<_>>();
+    let data = data
+        .into_iter()
+        .zip(VersionOwnerAction::for_versions(&conn, &versions)?.into_iter())
+        .map(|((v, cn, pb), voas)| (v, cn, pb, voas))
+        .collect::<Vec<_>>();
 
     let versions = data
         .into_iter()
-        .map(|(version, crate_name, published_by)| version.encodable(&crate_name, published_by))
+        .map(|(version, crate_name, published_by, actions)| {
+            version.encodable(&crate_name, published_by, actions)
+        })
         .collect();
 
     #[derive(Serialize)]
@@ -233,7 +242,7 @@ pub fn update_email_notifications(req: &mut dyn Request) -> AppResult<Response>
     let user = req.user()?;
     let conn = req.db_conn()?;
 
-    // Build inserts from existing crates beloning to the current user
+    // Build inserts from existing crates belonging to the current user
     let to_insert = CrateOwner::by_owner_kind(OwnerKind::User)
         .filter(owner_id.eq(user.id))
         .select((crate_id, owner_id, owner_kind, email_notifications))

src/controllers/user/me.rs

@@ -7,7 +7,7 @@
 
 use crate::controllers::frontend_prelude::*;
 
-use crate::models::{Crate, User, Version};
+use crate::models::{Crate, User, Version, VersionOwnerAction};
 use crate::schema::*;
 use crate::views::EncodableVersion;
 
@@ -22,7 +22,7 @@ pub fn index(req: &mut dyn Request) -> AppResult<Response> {
         .filter_map(|(ref a, ref b)| if *a == "ids[]" { b.parse().ok() } else { None })
         .collect::<Vec<i32>>();
 
-    let versions = versions::table
+    let versions_and_publishers = versions::table
         .inner_join(crates::table)
         .left_outer_join(users::table)
         .select((
@@ -31,9 +31,18 @@ pub fn index(req: &mut dyn Request) -> AppResult<Response> {
             users::all_columns.nullable(),
         ))
         .filter(versions::id.eq(any(ids)))
-        .load::<(Version, String, Option<User>)>(&*conn)?
+        .load::<(Version, String, Option<User>)>(&*conn)?;
+    let versions = versions_and_publishers
+        .iter()
+        .map(|(v, _, _)| v)
+        .cloned()
+        .collect::<Vec<_>>();
+    let versions = versions_and_publishers
         .into_iter()
-        .map(|(version, crate_name, published_by)| version.encodable(&crate_name, published_by))
+        .zip(VersionOwnerAction::for_versions(&conn, &versions)?.into_iter())
+        .map(|((version, crate_name, published_by), actions)| {
+            version.encodable(&crate_name, published_by, actions)
+        })
         .collect();
 
     #[derive(Serialize)]
@@ -60,12 +69,13 @@ pub fn show_by_id(req: &mut dyn Request) -> AppResult<Response> {
             users::all_columns.nullable(),
         ))
         .first(&*conn)?;
+    let audit_actions = VersionOwnerAction::by_version(&conn, &version)?;
 
     #[derive(Serialize)]
     struct R {
         version: EncodableVersion,
     }
     Ok(req.json(&R {
-        version: version.encodable(&krate.name, published_by),
+        version: version.encodable(&krate.name, published_by, audit_actions),
     }))
 }

src/controllers/version/deprecated.rs

@@ -6,6 +6,7 @@
 
 use crate::controllers::frontend_prelude::*;
 
+use crate::models::VersionOwnerAction;
 use crate::schema::*;
 use crate::views::{EncodableDependency, EncodablePublicUser, EncodableVersion};
 
@@ -70,12 +71,13 @@ pub fn show(req: &mut dyn Request) -> AppResult<Response> {
     let (version, krate) = version_and_crate(req)?;
     let conn = req.db_conn()?;
     let published_by = version.published_by(&conn);
+    let actions = VersionOwnerAction::by_version(&conn, &version)?;
 
     #[derive(Serialize)]
     struct R {
         version: EncodableVersion,
     }
     Ok(req.json(&R {
-        version: version.encodable(&krate.name, published_by),
+        version: version.encodable(&krate.name, published_by, actions),
     }))
 }