mensa 0.6.18 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9bbb252521ea00a7d6197e9ae12208d121ec069652b45b729095609a596bda2
-  data.tar.gz: 92345f45e5b1336f1e101c2c64d9736c58637cb9792c333cc21f4620dadabf94
+  metadata.gz: 064c836f400dd147fc8fde3fb1f38a49f7bd447c44e6d7493c055cd6dede6b19
+  data.tar.gz: b6fdbbdce0951fb43fdfd8f574cf6888ebe1c9f4e369752f4a497de85ca8b8f4
 SHA512:
-  metadata.gz: 2b97589e71ee52505369eb9cac3af5e49672c8af62d076d2f17465ea76b2c556ca2c5adbede3af5ad850db502bd47271e031c96a5292eb2ef191818e24e60435
-  data.tar.gz: ba31a706fa85f69d30a1b4bfcb17d2c6674df561daf8379341b3f7dc31d21bd10ecc94fc36192f0f2302e602556898c72d9b3d203e330f2a60494c3741b004f2
+  metadata.gz: f96aca8ee7039304c3292456e0be10722faba2eecac2ba41030f632317998bbf0d1e4d3f649f5a46d675a4d06268dae07d216e536b80294c4990c805160df0b3
+  data.tar.gz: f629a69b4a6177d8aedc58f931fa00d328af953dca50cfd80c282989c40fd2434e2e655b5c1f55611568f893d016b5467b16c2925e8fff293b977be9f53d36fc

data/.gitignore

@@ -6,7 +6,7 @@
 /tmp/
 /test/dummy/db/*.sqlite3
 /test/dummy/db/*.sqlite3-*
-/test/dummy/log/*.log
+/test/dummy/log/*
 /test/dummy/storage/
 /test/dummy/app/assets/builds/
 /test/dummy/tmp/

data/.shipkit.yml

@@ -1,2 +1,2 @@
 ---
-previous_version: 0.6.17
+previous_version: 0.6.19

data/CHANGELOG.md

@@ -1,6 +1,32 @@
 # Changelog
 
-## Unreleased
+## 0.7.0
+
+- Filters only offer the operators that work for the column's type in SQL,
+  picking one no longer raises. `matches`/`does_not_match` (`LIKE`) are only
+  offered for string, text, citext and untyped attribute columns, so boolean,
+  float, decimal, uuid, time and other columns no longer get them.
+  `gt`/`gteq`/`lt`/`lteq` are only offered for number, date and time columns,
+  so boolean, uuid and text columns no longer get them. json/jsonb columns only
+  get `is_empty`/`isnt_empty` (and jsonb `is_duplicate`). Host apps no longer
+  need to patch `Mensa::Filter#operators` or list `operators` per column to
+  avoid these. An explicit `operators` list is used as given.
+- Time columns use a time input, and a filter value that isn't a time matches
+  nothing instead of raising.
+- The verifier warns when an `attribute` has no `type` but its SQL isn't text,
+  e.g. a boolean `EXISTS (...)`, and says which `type` to add.
+- Columns a `column_order` doesn't list are kept and shown after the listed
+  ones, instead of being dropped. Browser state or views saved before a column
+  was added no longer hide that column (also from the column customizer),
+  ignore filters and sorting on it, or leave its attribute unselected.
+- The verifier checks column order and visibility: a reversed order, an order
+  that lists only one column (like state saved before columns were added),
+  hiding each column and hiding all of them, each rendered and exported.
+- The verifier creates a custom view like a user saving the table's state
+  would, without saving it, and validates, replays and exports it.
+- The verifier confirms when it found no N+1 queries.
+
+## 0.6.19
 
 - `Mensa::Verifier` checks a table against the database: scope, column SQL,
   sorting, rendering, filters, search, CSV export, grouping/aggregates and
@@ -8,6 +34,18 @@
   or from tests after `require "mensa/testing"` with
   `assert_mensa_table_valid` or `be_a_valid_mensa_table`. Set defaults for
   its context with `config.verifier_context`.
+- The verifier samples records from the first and last page and records with
+  empty values, tries filters with invalid input, checks search, filters, sorting
+  and grouping together, and warns about N+1 queries (with a fix) and slow
+  queries. `strict: true` / `STRICT=1` makes warnings fail.
+  `config.verifier_context` can return an array to verify tables in several
+  contexts, `config.verifier_slow_query` sets when a query is slow.
+- Columns without SQL (only a `render` block or a `method`, no `attribute` or
+  database column) are no longer sortable or filterable by default, sorting or
+  filtering on them produced invalid SQL. Use `sortable true` for a column whose
+  name is an alias the scope selects, or a filter `scope` to filter it.
+- Filters with a value their column's type can't hold (e.g. "abc" for a number,
+  or an invalid date or uuid) match nothing instead of raising a database error.
 - `Mensa::ExportJob.write_csv(io, table, rows)` writes a table's CSV export and
   `Mensa::ExportJob#generate_file(export)` generates an export's file without
   saving it.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mensa (0.6.17)
+    mensa (0.6.19)
       csv
       importmap-rails
       pagy (>= 43)

data/README.md

@@ -118,11 +118,49 @@ You can show your tables on the page using the following:
 Custom views are views not defined by the developer (SystemViews) but by the end-user by adding/removing filters.
 When you enable these, they are stored in the database and can be used across sessions, by the user who created them.
 
+### Sortable and filterable columns
+
+Sorting and filtering happen in SQL, so whether a column can be sorted or filtered
+depends on whether it has SQL: a database column of the model, or an `attribute`.
+
+- **Columns with SQL** are sortable and filterable by default. Turn that off with
+  `sortable false` or `filter false`.
+- **Columns without SQL**, which only show something with a `render` block or a
+  `method`, are *not* sortable or filterable by default. Their headers have no sort
+  link, they aren't offered in the filter menu, and sorting or filtering on them
+  from a URL or saved state is ignored.
+
+```ruby
+column(:email)                      # sortable and filterable
+column(:customer_name) do           # sortable and filterable, it has SQL
+  attribute "customers.name"
+end
+column(:avatar) do                  # render only: not sortable, not filterable
+  render do
+    html { |user| image_tag(user.avatar_url) }
+  end
+end
+```
+
+To make a column without SQL filterable, give its filter a `scope` (see "Custom
+filter scopes" below). Add `sortable true` only when its name can be sorted on in
+SQL, e.g. an alias your table's `scope` selects:
+
+```ruby
+column(:orders_count) do
+  sortable true # ORDER BY orders_count, selected in the scope below
+end
+
+scope { User.left_joins(:orders).group(:id).select("users.*, COUNT(orders.id) AS orders_count") }
+```
+
+Better still, give such a column an `attribute`, so it's sortable and filterable.
+
 ### Filters
 
-Add `filter` to a column to let users filter on it. By default Mensa compares the
-column's attribute with the chosen value, using operators that fit the column type.
-The filter block takes these options:
+Columns with SQL are filterable (see above). Use `filter` to configure how. By
+default Mensa compares the column's attribute with the chosen value, using
+operators that fit the column type. The filter block takes these options:
 
 ```ruby
 column(:role) do
@@ -137,7 +175,31 @@ end
 ```
 
 The operators are `is`, `isnt`, `matches`, `does_not_match`, `gt`, `gteq`, `lt`,
-`lteq`, `is_duplicate`, `is_current`, `is_empty` and `isnt_empty`.
+`lteq`, `is_duplicate`, `is_current`, `is_empty` and `isnt_empty`. Without an
+`operators` list, a column gets the ones that work for its type in SQL:
+
+| Column type | Operators besides `is_duplicate`, `is_empty` and `isnt_empty` |
+|---|---|
+| string, text, citext, or an `attribute` without `type` | `is`, `isnt`, `matches`, `does_not_match` |
+| integer, float, decimal, time | `is`, `isnt`, `gt`, `gteq`, `lt`, `lteq` |
+| date, datetime | `gt`, `gteq`, `lt`, `lteq` |
+| boolean, uuid, enums and other types | `is`, `isnt` |
+| jsonb, json | none (json also has no `is_duplicate`) |
+
+`matches` and `does_not_match` are left out when the filter has a `collection`, and
+`is_current` is only offered when `Current` has a method named after the column.
+
+Mensa reads the type from the database column. Give an `attribute` that isn't text a
+`type`, otherwise it's treated as text and gets the text operators:
+
+```ruby
+column(:has_orders) do
+  attribute "EXISTS (SELECT 1 FROM orders WHERE orders.user_id = users.id)"
+  type :boolean
+end
+```
+
+An `operators` list is used as given, also when it lists operators the type can't run.
 
 #### Custom filter scopes
 
@@ -325,15 +387,18 @@ If you're just using cron, you can add the following to your crontab:
 `Mensa::Verifier` checks that everything a table configures works against your
 real database, using the same code paths as requests do:
 
-- **Loads**: the table builds, its SQL builds and the first two pages load. A default
-  `order` or `column_order` naming an unknown column fails.
+- **Loads**: the table builds, its SQL builds and the first and last pages load. A
+  default `order` or `column_order` naming an unknown column fails. Records are
+  sampled for the checks below: some from the first and the last page, and one with
+  an empty value for each column, which often breaks render blocks.
 - **Columns**: every column (internal ones too) can be selected and, when sortable,
-  sorted both ways. Its html and csv renders run for a few records. Columns hidden
-  by a `visible` lambda are reported as skipped.
+  sorted both ways. Its html and csv renders run for the sampled records, and a
+  failure names the record. Columns hidden by a `visible` lambda are reported as
+  skipped.
 - **Filters**: every filterable column is applied with each of its operators, using
   the first values of its `collection` or a value that fits the column's type, and
-  the filter pill's text is built. `is_current` is skipped when `Current` has no
-  value for the column.
+  with input the column's type can't hold (e.g. "not a number"). The filter pill's
+  text is built. `is_current` is skipped when `Current` has no value for the column.
 - **Search**: basic and fuzzy search (when `pg_trgm` is enabled) for a word taken
   from the records.
 - **Rendering**: the `table` helper as your views call it, the rows and filter pills
@@ -341,11 +406,36 @@ real database, using the same code paths as requests do:
 - **Exports**: `Mensa::ExportJob` generates the first page of the export, also for
   each view and as a password protected zip. It needs the expected headers
   (skipped for `exportable false`).
+- **Column order and visibility**: the columns shown, rendered and exported in a
+  reversed order, with an order that lists only one column (like browser state or a
+  view saved before the other columns were added, which must still show them all),
+  with each column hidden and with all of them hidden.
+- **Combined**: search, a filter on every column, sorting on every column and
+  grouping with aggregates, all at once.
 - **Grouping**: every groupable column and every aggregate, rendered with their
   group headers. A `group_by` or `aggregates` naming a column that doesn't allow
   it fails, because Mensa would silently ignore it.
 - **Views**: system views load, render and only refer to existing columns. With
-  custom views enabled, saved views load too.
+  custom views enabled, saved views load too, and a custom view is created like a
+  user saving the table's state would (search, filters, sorting, column order, a
+  hidden column and grouping), then validated, replayed and exported. It's never
+  saved, and needs a user to own it (`user:`).
+
+It also warns, without failing:
+
+- **N+1 queries**: a query that a render block, the row link or a row action runs for
+  each record. The warning shows the query and how to avoid it for the association
+  it loads, e.g. preload it with `includes` (and `internal :customer_id`, since Mensa
+  only selects the table's columns), select the value in SQL with `attribute`, or
+  count in SQL. When none is found, the report confirms it under Rendering, e.g.
+  `✓ N+1 queries: none in 18 renders of 7 sampled records`. It needs at least two
+  records to tell.
+- **Untyped attributes**: an `attribute` without `type` whose SQL isn't text, e.g. a
+  boolean `EXISTS (...)`. The warning names the `type` to add.
+- **Slow queries**: queries that take `config.verifier_slow_query` seconds (1.0 by
+  default) or more.
+
+Pass `strict: true` (or `STRICT=1` to rake) to make warnings fail.
 
 Each check runs on its own, so one failure doesn't hide the others. Everything runs
 in a read-only transaction that is rolled back, with small limits, so it is safe to
@@ -390,20 +480,24 @@ params. Give the verifier that context:
 - `context: {organization: org}` sets any other `Current` attributes.
 - `params: {customer_id: 1}` sets the table's params (see "Table params").
 - A block is called with the verifier before the checks, for any other setup.
+- `label: "admin"` names the context in the report.
 
 Html render blocks run in a view context of your `ApplicationController` (see
 `config.base_controller`), so url helpers and your helpers work.
 
 From rake, set `USER_ID=` (finds a `User`), `ACCOUNT_ID=` (finds an `Account`) and
 `PARAMS='{"customer_id":1}'` (JSON), or configure defaults for every table in
-your initializer. The options you pass yourself override these defaults:
+your initializer. The options you pass yourself override these defaults. Return an array of them to
+verify every table once for each, e.g. as different kinds of users:
 
 ```ruby
 Mensa.setup do |config|
   config.verifier_context = ->(table_class) {
-    options = {user: User.find_by!(email: "admin@example.com")}
-    options[:params] = {customer_id: Customer.first.id} if table_class == CustomerUsersTable
-    options
+    params = {customer_id: Customer.first.id} if table_class == CustomerUsersTable
+    [
+      {label: "admin", user: User.find_by!(email: "admin@example.com"), params: params},
+      {label: "customer", user: User.find_by!(email: "customer@example.com"), params: params}
+    ]
   }
 end
 ```

data/app/components/mensa/row_action/component.html.erb

@@ -6,4 +6,5 @@
     <% else %>
       <%= action.title %>
     <% end %>
-  <% end %>
+  <% end %>
+<% end %>

data/app/tables/mensa/base.rb

@@ -38,18 +38,16 @@ module Mensa
       order = order&.map(&:to_sym)
       return order if order.nil?
 
-      # Internal columns are never shown in the column customizer UI, so they
-      # are absent from any URL-supplied column_order. Always append them so
-      # that columns and selected_scope include their attributes.
       all_keys = (config[:columns]&.keys || []).map(&:to_sym)
-      # A column_order can come from browser state saved for different params
-      # (with different columns), so drop names that aren't columns here.
-      if all_keys.any?
-        order &= all_keys
-        order = all_keys if order.empty?
-      end
-      internal_keys = all_keys.select { |key| config.dig(:columns, key, :internal) }
-      (order | internal_keys)
+      return order if all_keys.empty?
+
+      # A column_order can come from browser state or a view saved for
+      # different params, or before columns were added, so drop names that
+      # aren't columns here and append the columns it doesn't list. Internal
+      # columns are never in it, as the column customizer doesn't show them.
+      # Appending keeps every column in columns and selected_scope, so no
+      # column disappears and their filters and attributes keep working.
+      (order & all_keys) | all_keys
     end
 
     # Returns all columns
@@ -110,7 +108,9 @@ module Mensa
     def active_filters
       (config[:filters] || {}).filter_map do |column_name, filter_config|
         col = column(column_name)
-        next unless col
+        # Columns without SQL can only be filtered with a custom scope, skip
+        # filters on them, e.g. from browser state saved earlier
+        next if col.nil? || !(col.sql? || col.filter?)
 
         definition = config.dig(:columns, col.name, :filter)
         definition = {} unless definition.is_a?(Hash)

data/app/tables/mensa/column.rb

@@ -14,7 +14,6 @@ module Mensa
       @table = table
     end
 
-    config_reader :sortable?
     config_reader :sanitize?
     config_reader :visible?
     config_reader :internal?
@@ -96,9 +95,25 @@ module Mensa
       aggregates.any?
     end
 
-    # Returns true if the column supports filtering
+    # Whether the column has SQL (an attribute or a database column). Columns
+    # without, e.g. only a render block or a method, can't be sorted or
+    # filtered in SQL.
+    def sql?
+      attribute_for_condition.present?
+    end
+
+    # Columns with SQL are sortable unless `sortable false`, others only with
+    # an explicit `sortable true`
+    def sortable?
+      config[:sortable].nil? ? sql? : !!config[:sortable]
+    end
+
+    # Returns true if the column supports filtering: columns with SQL unless
+    # `filter false`, others only with a filter that has its own scope
     def filter?
-      config[:filter] != false
+      return false if config[:filter] == false
+
+      sql? || (config[:filter].is_a?(Hash) && config[:filter][:scope].present?)
     end
 
     def filter

data/app/tables/mensa/config/column_dsl.rb

@@ -4,7 +4,8 @@ module Mensa::Config
   class ColumnDsl
     include DslLogic
 
-    option :sortable, default: true
+    # Defaults to whether the column has SQL, see Mensa::Column#sortable?
+    option :sortable
     option :sanitize, default: true
     # Allows for sql-parts too
     #

data/app/tables/mensa/filter.rb

@@ -14,6 +14,15 @@ module Mensa
     config_reader :multiple
     config_reader :having?
 
+    # Types that LIKE works on, nil is an attribute without a type
+    TEXT_TYPES = [:string, :text, :citext, nil].freeze
+    # Types with a meaningful order, for gt, gteq, lt and lteq
+    RANGE_TYPES = %i[integer bigint float decimal money date datetime timestamp timestamptz time interval].freeze
+    # Types where an exact match on a value is of little use
+    POINT_IN_TIME_TYPES = %i[date datetime timestamp timestamptz].freeze
+    # Types that can't be compared with a value the user types
+    STRUCTURED_TYPES = %i[json jsonb].freeze
+
     class << self
       def OPERATORS
         [
@@ -86,6 +95,9 @@ module Mensa
 
         # Nothing selected in a multi-select means no filter
         return record_scope if value.is_a?(Array) && value.compact_blank.empty?
+        # A value the database can't compare with the column, e.g. "abc" for
+        # a number, matches nothing instead of raising
+        return record_scope.none if operator_with_value? && invalid_value?
 
         query, hash = query_and_hash_for_operator
         record_scope = (having? ? record_scope.having(query, hash) : record_scope.where(query, hash)) if query.present?
@@ -99,10 +111,15 @@ module Mensa
         operators = operators.select { |op| config[:operators].include?(op[0]) }
       else
         operators.delete_if { |op| op[0] == :is_current } unless Current.method_defined?(column.name, false)
+        type = column.type
         operators.delete_if { |op| [:matches, :does_not_match].include?(op[0]) } if collection.present?
-        operators.delete_if { |op| [:matches, :does_not_match].include?(op[0]) } if column.type == :integer || column.type == :date || column.type == :datetime
-        operators.delete_if { |op| [:is, :isnt].include?(op[0]) } if column.type == :date || column.type == :datetime
-        operators.delete_if { |op| [:gt, :lt, :gteq, :lteq].include?(op[0]) } if column.type == :string || column.type.blank?
+        # Only these operators work for the column's type in SQL, the others
+        # raise, e.g. LIKE on a boolean
+        operators.delete_if { |op| [:matches, :does_not_match].include?(op[0]) } unless TEXT_TYPES.include?(type)
+        operators.delete_if { |op| [:gt, :lt, :gteq, :lteq].include?(op[0]) } unless RANGE_TYPES.include?(type)
+        operators.delete_if { |op| [:is, :isnt].include?(op[0]) } if POINT_IN_TIME_TYPES.include?(type) || STRUCTURED_TYPES.include?(type)
+        # json has no equality, so duplicates can't be grouped
+        operators.delete_if { |op| op[0] == :is_duplicate } if type == :json
       end
       operators
     end
@@ -159,6 +176,8 @@ module Mensa
         "date"
       when :datetime
         "datetime-local"
+      when :time
+        "time"
       else
         "text"
       end
@@ -224,6 +243,30 @@ module Mensa
         .where("#{column_sql} IN (#{duplicate_values_scope.to_sql})")
     end
 
+    UUID_FORMAT = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/
+
+    # Whether a value can't be read as the column's type. Values are sent to
+    # the database as they are, this only catches the ones it would reject.
+    def invalid_value?
+      Array(value).compact_blank.any? { |entry| !valid_for_type?(entry) }
+    end
+
+    def valid_for_type?(entry)
+      return true unless entry.is_a?(String)
+
+      case column.type
+      when :integer, :bigint then entry.strip.match?(/\A[+-]?\d+\z/)
+      when :decimal, :float then entry.strip.match?(/\A[+-]?(\d+\.?\d*|\.\d+)\z/)
+      when :date then Date.parse(entry).present?
+      when :datetime, :timestamp, :timestamptz then Time.zone.parse(entry).present?
+      when :time then entry.strip.match?(/\A\d{1,2}:\d{2}(:\d{2}(\.\d+)?)?\z/)
+      when :uuid then entry.strip.match?(UUID_FORMAT)
+      else true
+      end
+    rescue ArgumentError, RangeError
+      false
+    end
+
     # Aggregates are only known per group, so the duplicate values come from
     # a subquery of the grouped rows and are compared in the HAVING
     def apply_duplicate_having_filter(record_scope, base_scope, column_sql)

data/app/tables/mensa/scope.rb

@@ -129,6 +129,9 @@ module Mensa
         # Skip orders on unknown names, e.g. from browser state saved for
         # different params.
         next unless col || model_attribute?(k)
+        # Columns without SQL can't be sorted on, unless they're explicitly
+        # sortable, e.g. on an alias the scope selects
+        next if col && !col.sql? && !col.sortable?
         next unless %w[asc desc].include?(v)
 
         attribute = col&.attribute_for_condition || k

data/lib/mensa/configuration.rb

@@ -146,10 +146,13 @@ module Mensa
     option :search, default: :basic
     # Default options for Mensa::Verifier (and so `rails mensa:verify`), called
     # with the table class. Return a hash with any of user:, account:,
-    # context: (Current attributes) and params:, e.g.
+    # context: (Current attributes), params: and label:, or an array of them
+    # to verify the table in each of those contexts, e.g.
     #
     #   config.verifier_context = ->(table_class) { {user: User.find_by!(email: "admin@example.com")} }
     option :verifier_context, default: nil
+    # Mensa::Verifier warns about queries that take this many seconds or more
+    option :verifier_slow_query, default: 1.0
 
     def initialize
       set_defaults!

data/lib/mensa/testing.rb

@@ -8,19 +8,20 @@ module Mensa
   #   assert_mensa_table_valid UsersTable, user: users(:admin)        # Minitest
   #   expect(UsersTable).to be_a_valid_mensa_table(user: admin)        # RSpec
   #
-  # Both take the verifier's options (user:, account:, context:, params:)
-  # and fail with its report.
+  # Both take the verifier's options (user:, account:, context:, params:,
+  # strict:), verify the table in every context of
+  # Mensa.config.verifier_context and fail with the reports.
   module Testing
     module Assertions
       def assert_mensa_table_valid(table, message = nil, **options, &setup)
-        result = Mensa::Verifier.new(table, **options, &setup).call
-        assert result.success?, -> { [message, result.to_s].compact.join("\n\n") }
-        result
+        results = Mensa::Verifier.verify(table, **options, &setup)
+        assert results.all?(&:success?), -> { [message, *results.reject(&:success?).map(&:to_s)].compact.join("\n\n") }
+        results
       end
     end
 
     class ValidTableMatcher
-      attr_reader :result
+      attr_reader :results
 
       def initialize(**options, &setup)
         @options = options
@@ -28,16 +29,16 @@ module Mensa
       end
 
       def matches?(table)
-        @result = Mensa::Verifier.new(table, **@options, &@setup).call
-        @result.success?
+        @results = Mensa::Verifier.verify(table, **@options, &@setup)
+        @results.all?(&:success?)
       end
 
       def failure_message
-        result.to_s
+        results.reject(&:success?).join("\n\n")
       end
 
       def failure_message_when_negated
-        "expected #{result.table_class} not to be a valid Mensa table, but all its checks passed"
+        "expected #{results.first.table_class} not to be a valid Mensa table, but all its checks passed"
       end
 
       def description

data/lib/mensa/verifier/result.rb

@@ -5,7 +5,8 @@ module Mensa
     # One verified aspect of a table, e.g. sorting a column descending.
     #
     # +section+ groups checks in the report (:loads, :columns, :filters, ...),
-    # +subject+ is the column, filter or view it relates to.
+    # +subject+ is the column, filter or view it relates to. Warnings (N+1
+    # queries, slow queries) don't fail the table unless it's verified strict.
     Check = Struct.new(:section, :subject, :name, :status, :message, :sql, :error) do
       def passed?
         status == :passed
@@ -19,6 +20,10 @@ module Mensa
         status == :skipped
       end
 
+      def warning?
+        status == :warning
+      end
+
       def label
         [subject, name].compact.join(": ")
       end
@@ -31,17 +36,22 @@ module Mensa
         filters: "Filters",
         search: "Search",
         render: "Rendering",
+        layout: "Column order and visibility",
+        combined: "Combined",
         exports: "Exports",
         grouping: "Grouping",
         views: "Views"
       }.freeze
 
-      SYMBOLS = {passed: "✓", failed: "✗", skipped: "-"}.freeze
+      SYMBOLS = {passed: "✓", failed: "✗", skipped: "-", warning: "!"}.freeze
 
-      attr_reader :table_class, :checks
+      attr_reader :table_class, :checks, :label
 
-      def initialize(table_class)
+      # +label+ names the context it was verified in, e.g. "user: User#1"
+      def initialize(table_class, strict: false, label: nil)
         @table_class = table_class
+        @strict = strict
+        @label = label
         @checks = []
       end
 
@@ -50,8 +60,12 @@ module Mensa
         table_class.is_a?(Class) && table_class < Mensa::Base
       end
 
+      def strict?
+        @strict
+      end
+
       def success?
-        failures.empty?
+        failures.empty? && (!strict? || warnings.empty?)
       end
 
       def failures
@@ -66,20 +80,28 @@ module Mensa
         checks.select(&:skipped?)
       end
 
+      def warnings
+        checks.select(&:warning?)
+      end
+
       def summary
-        "#{passes.size} passed, #{failures.size} failed, #{skips.size} skipped"
+        "#{passes.size} passed, #{failures.size} failed, #{skips.size} skipped, #{warnings.size} #{"warning".pluralize(warnings.size)}"
+      end
+
+      def title
+        [table_class.name || table_class.to_s, ("(#{label})" if label)].compact.join(" ")
       end
 
       def to_s
-        return "#{table_class}\n  - skipped: #{checks.first&.message}" unless mensa_table?
+        return "#{title}\n  - skipped: #{checks.first&.message}" unless mensa_table?
 
-        lines = [(table_class.name || table_class).to_s]
+        lines = [title]
 
         checks.group_by(&:section).each do |section, section_checks|
           lines << "  #{SECTIONS.fetch(section, section.to_s.humanize)}"
           section_checks.each do |check|
             lines << "    #{SYMBOLS[check.status]} #{check.label}#{" (skipped: #{check.message})" if check.skipped?}"
-            next unless check.failed?
+            next unless check.failed? || check.warning?
 
             check.message.to_s.each_line { |line| lines << "        #{line.chomp}" }
             lines << "        SQL: #{check.sql}" if check.sql.present?
@@ -87,13 +109,13 @@ module Mensa
         end
 
         lines << ""
-        lines << "#{success? ? "OK" : "FAILED"}: #{summary}"
+        lines << "#{success? ? "OK" : "FAILED"}: #{summary}#{" (strict: warnings fail)" if strict? && warnings.any?}"
         lines.join("\n")
       end
       alias_method :report, :to_s
 
       def inspect
-        "#<#{self.class.name} #{table_class} #{summary}>"
+        "#<#{self.class.name} #{title} #{summary}>"
       end
     end
   end