Add :human_readable_name to Table and Field API responses

src/metabase/api/meta/db.clj

@@ -112,7 +112,8 @@
   "Get a list of all `Tables` in `Database`."
   [id]
   (read-check Database id)
-  (sel :many Table :db_id id :active true (order :name)))
+  (-> (sel :many Table :db_id id :active true (order :name))
+      (hydrate :human_readable_name)))
 
 (defendpoint GET "/:id/idfields"
   "Get a list of all primary key `Fields` for `Database`."

src/metabase/api/meta/table.clj

@@ -20,14 +20,13 @@
   "Get all `Tables`."
   []
   (-> (sel :many Table :active true (order :name :ASC))
-      (hydrate :db)
+      (hydrate :db :human_readable_name)
       ;; if for some reason a Table doesn't have rows set then set it to 0 so UI doesn't barf
       (#(map (fn [table]
                (cond-> table
                  (not (:rows table)) (assoc :rows 0)))
          %))))
 
-
 (defendpoint GET "/:id"
   "Get `Table` with ID."
   [id]
@@ -50,7 +49,8 @@
   "Get all `Fields` for `Table` with ID."
   [id]
   (read-check Table id)
-  (sel :many Field :table_id id, :active true, :field_type [not= "sensitive"], (order :name :ASC)))
+  (->> (sel :many Field :table_id id, :active true, :field_type [not= "sensitive"], (order :name :ASC))
+       (hydrate :human_readable_name)))
 
 (defendpoint GET "/:id/query_metadata"
   "Get metadata about a `Table` useful for running queries.

src/metabase/models/common.clj

 (ns metabase.models.common
-  (:require [metabase.api.common :refer [*current-user* *current-user-id* check]]
+  (:require [clojure.string :as s]
+            [metabase.api.common :refer [*current-user* *current-user-id* check]]
             [metabase.util :as u]))
 
 (def timezones
@@ -64,7 +65,21 @@
   Note that these delays depend upon the presence of `creator_id`, and `public_perms` fields in OBJ."
   [obj]
   (u/assoc* obj
-            :public-permissions-set (delay (public-permissions <>))
-            :user-permissions-set (delay (user-permissions <>))
-            :can_read (delay (user-can? :read <>))
-            :can_write (delay (user-can? :write <>))))
+    :public-permissions-set (delay (public-permissions <>))
+    :user-permissions-set   (delay (user-permissions <>))
+    :can_read               (delay (user-can? :read <>))
+    :can_write              (delay (user-can? :write <>))))
+
+
+(defn name->human-readable-name
+  "Convert a string NAME of some object like a `Table` or `Field` to one more friendly to humans.
+
+    (name->human-readable-name \"admin_users\") -> \"Admin Users\""
+  [^String n]
+  (when-let [n (some-> n
+                       (s/replace #"(?:-|_id)$" "")                                 ; strip off any trailing _id or -id suffix
+                       (s/split #"_|-"))]                                           ; explode string on underscores and hyphens
+    (->> (for [[first-letter & rest-letters :as part] n]                            ; for each part of the string,
+           (apply str (s/upper-case first-letter) (map s/lower-case rest-letters))) ; upcase the first char and downcase the rest
+         (interpose " ")                                                            ; add a space between each part
+         (apply str))))                                                             ; convert back to a single string

src/metabase/models/field.clj

@@ -2,7 +2,8 @@
   (:require [korma.core :refer :all]
             [metabase.api.common :refer [check]]
             [metabase.db :refer :all]
-            (metabase.models [database :refer [Database]]
+            (metabase.models [common :as common]
+                             [database :refer [Database]]
                              [field-values :refer [field-should-have-field-values? create-field-values create-field-values-if-needed]]
                              [hydrate :refer [hydrate]]
                              [foreign-key :refer [ForeignKey]])
@@ -91,11 +92,13 @@
 
 (defmethod post-select Field [_ {:keys [table_id] :as field}]
   (u/assoc* field
-            :table     (delay (sel :one 'metabase.models.table/Table :id table_id))
-            :db        (delay @(:db @(:table <>)))
-            :target    (delay (field->fk-field field))
-            :can_read  (delay @(:can_read @(:table <>)))
-            :can_write (delay @(:can_write @(:table <>)))))
+    :table               (delay (sel :one 'metabase.models.table/Table :id table_id))
+    :db                  (delay @(:db @(:table <>)))
+    :target              (delay (field->fk-field field))
+    :can_read            (delay @(:can_read @(:table <>)))
+    :can_write           (delay @(:can_write @(:table <>)))
+    :human_readable_name (when (name :field)
+                           (delay (common/name->human-readable-name (:name field))))))
 
 (defmethod pre-insert Field [_ field]
   (let [defaults {:active          true

src/metabase/models/table.clj

 (ns metabase.models.table
   (:require [korma.core :refer :all]
             [metabase.db :refer :all]
-            (metabase.models [database :as db]
+            (metabase.models [common :as common]
+                             [database :as db]
                              [field :refer [Field]]
                              [field-values :refer [FieldValues]])
             [metabase.util :as u]))
@@ -20,20 +21,22 @@
 ; also missing :active and :pk_field
 (defmethod post-select Table [_ {:keys [id db db_id description] :as table}]
   (u/assoc* table
-               :db           (or db (delay (sel :one db/Database :id db_id)))
-               :fields       (delay (sel :many Field :table_id id :active true (order :position :ASC) (order :name :ASC)))
-               :field_values (delay
-                               (let [field-ids (sel :many :field [Field :id]
-                                                    :table_id id
-                                                    :active true
-                                                    :field_type [not= "sensitive"]
-                                                    (order :position :asc)
-                                                    (order :name :asc))]
-                                 (sel :many :field->field [FieldValues :field_id :values] :field_id [in field-ids])))
-               :description  (u/jdbc-clob->str description)
-               :pk_field     (delay (:id (sel :one :fields [Field :id] :table_id id (where {:special_type "id"}))))
-               :can_read     (delay @(:can_read @(:db <>)))
-               :can_write    (delay @(:can_write @(:db <>)))))
+    :db                  (or db (delay (sel :one db/Database :id db_id)))
+    :fields              (delay (sel :many Field :table_id id :active true (order :position :ASC) (order :name :ASC)))
+    :field_values        (delay
+                          (let [field-ids (sel :many :field [Field :id]
+                                               :table_id id
+                                               :active true
+                                               :field_type [not= "sensitive"]
+                                               (order :position :asc)
+                                               (order :name :asc))]
+                            (sel :many :field->field [FieldValues :field_id :values] :field_id [in field-ids])))
+    :description         (u/jdbc-clob->str description)
+    :pk_field            (delay (:id (sel :one :fields [Field :id] :table_id id (where {:special_type "id"}))))
+    :can_read            (delay @(:can_read @(:db <>)))
+    :can_write           (delay @(:can_write @(:db <>)))
+    :human_readable_name (when (:name table)
+                           (delay (common/name->human-readable-name (:name table))))))
 
 
 (defmethod pre-cascade-delete Table [_ {:keys [id] :as table}]