terrazzo 0.5.2 → 0.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c8d1fb21a6af1c708437891c1e3216a2749fb682513c40c4c583a950e92750f5
-  data.tar.gz: 47a449b824bf9f5a2cf00e7619aa5d008526f7b8d764258022a3d3ff43109c58
+  metadata.gz: 100223520cc1a1dbedef6413a2ba4e1b45691f4773abddd9ee27d123e735c64d
+  data.tar.gz: eeee21e64365ca82bc7c6f11c2f80dd813b2960d96e1e3aa80839fd7acb2b2cf
 SHA512:
-  metadata.gz: e3970087e358e8ef4988ff18d3dff5c9a28de0253f5358afb0b54aeada98878ac16ad2b1f85a057e0c101bea47a74d6c79a63c259781571cc1b7d95327712bf8
-  data.tar.gz: c85f00757f7f54a86fa37d7f9509e109f672cf074eb9e88370132e74d5ccbc1e4bf0345c9410e396f85770a9b936658f5f637554e94bf7a7de46fc379c901e23
+  metadata.gz: f44edde4138e7348cfaa6abd5c790c8d295f40ed57fd7391c6e1af6a97a2f334bf73e147e4322e37138b5a72ef4743be7c0346448defef4c8d0becaf1daf8d17
+  data.tar.gz: 344144b82879ebe42857dbf048b9737e429fba63d06a06aa5ef5b2aa1ff3accef8633efb11c12835fca3a384ef06b162cf5c78892db4ffbc8e046598b2eaf311

data/app/controllers/terrazzo/application_controller.rb

@@ -44,7 +44,10 @@ module Terrazzo
 
     def show
       @resource = find_resource(params[:id])
-      @page = Terrazzo::Page::Show.new(dashboard, @resource)
+      @page = Terrazzo::Page::Show.new(
+        dashboard, @resource,
+        has_many_params: Terrazzo::HasManyPagination.extract(params)
+      )
     end
 
     def new

data/app/helpers/terrazzo/collection_actions_helper.rb

@@ -9,6 +9,21 @@ module Terrazzo
       end
     end
 
+    def has_many_pagination_paths(field, resource)
+      param_key = Terrazzo::HasManyPagination.param_key(field.attribute)
+      base = request.query_parameters.merge(
+        only_path: true,
+        controller: controller_path,
+        action: :show,
+        id: resource.to_param,
+        format: nil
+      )
+      {
+        prevPagePath: (field.current_page > 1 ? url_for(base.merge(param_key => field.current_page - 1)) : nil),
+        nextPagePath: (field.current_page < field.total_pages ? url_for(base.merge(param_key => field.current_page + 1)) : nil)
+      }
+    end
+
     private
 
     def default_collection_item_actions(resource)

data/app/views/terrazzo/application/_index_base.json.props

@@ -60,12 +60,12 @@ json.pagination do
   if @resources.next_page
     json.nextPagePath url_for(
       _page: @resources.next_page,
+      per_page: params[:per_page],
       search: @search_term,
       order: params[:order],
       direction: params[:direction],
       filter: @active_filter,
       filter_value: @filter_value,
-      props_at: "data.pagination",
       only_path: true
     )
   else
@@ -74,12 +74,12 @@ json.pagination do
   if @resources.prev_page
     json.prevPagePath url_for(
       _page: @resources.prev_page,
+      per_page: params[:per_page],
       search: @search_term,
       order: params[:order],
       direction: params[:direction],
       filter: @active_filter,
       filter_value: @filter_value,
-      props_at: "data.pagination",
       only_path: true
     )
   else

data/app/views/terrazzo/application/_show_base.json.props

@@ -9,12 +9,15 @@ show_field_json = ->(json, field) do
 
   if field.class.associative? && field.data.present?
     if field.is_a?(Terrazzo::Field::HasMany)
-      json.itemShowPaths(field.data.each_with_object({}) do |record, paths|
-        paths[record.id.to_s] = polymorphic_path([namespace, record]) rescue nil
-      end)
-      json.collectionItemActions(field.data.each_with_object({}) do |record, hash|
-        hash[record.id.to_s] = collection_item_actions(record)
+      render_actions = field.options.fetch(:render_actions, true)
+
+      json.hasManyRowExtras(field.page_records.each_with_object({}) do |record, hash|
+        extras = { showPath: (polymorphic_path([namespace, record]) rescue nil) }
+        extras[:collectionItemActions] = collection_item_actions(record) if render_actions
+        hash[record.id.to_s] = extras
       end)
+
+      json.paginationPaths has_many_pagination_paths(field, @resource)
     else
       json.showPath polymorphic_path([namespace, field.data]) rescue nil
     end

data/lib/generators/terrazzo/views/templates/fields/has_many/ShowField.jsx

@@ -1,85 +1,36 @@
-import React, { useState, useContext } from "react";
-import { NavigationContext } from "@thoughtbot/superglue";
+import React, { useState } from "react";
 
-import {
-  Table,
-  TableHeader,
-  TableBody,
-  TableRow,
-  TableHead,
-  TableCell,
-} from "terrazzo/ui";
+import { ResourceTable } from "terrazzo/components";
 import { Badge } from "terrazzo/ui";
 import { Button } from "terrazzo/ui";
-import { CollectionItemActions } from "terrazzo/components";
-import { FieldRenderer } from "../FieldRenderer";
 
-export function ShowField({ value, itemShowPaths, collectionItemActions }) {
+export function ShowField({ value, hasManyRowExtras, options }) {
   if (!value) return <span className="text-muted-foreground">None</span>;
 
-  const { items, headers, total, initialLimit } = value;
+  const { rows, headers, total, initialLimit, items } = value;
   const [expanded, setExpanded] = useState(false);
-  const { visit } = useContext(NavigationContext);
 
-  if (!items || items.length === 0) {
-    return <span className="text-muted-foreground">None</span>;
-  }
+  // Table mode: collection_attributes specified
+  if (headers && rows) {
+    if (rows.length === 0) {
+      return <span className="text-muted-foreground">None</span>;
+    }
 
-  const pathFor = (id) => itemShowPaths?.[String(id)];
-  const hasMore = initialLimit && initialLimit > 0 && total > initialLimit;
-  const visibleItems = expanded || !hasMore ? items : items.slice(0, initialLimit);
+    const hasMore = initialLimit && initialLimit > 0 && total > initialLimit;
+    const visibleRows = expanded || !hasMore ? rows : rows.slice(0, initialLimit);
 
-  const handleRowClick = (e, showPath) => {
-    if (!showPath) return;
-    if (e.target.closest("a, button, form")) return;
-    if (window.getSelection().toString()) return;
-    visit(showPath, {});
-  };
+    const enrichedRows = visibleRows.map((row) => {
+      const extras = hasManyRowExtras?.[String(row.id)] || {};
+      return {
+        ...row,
+        showPath: extras.showPath,
+        collectionItemActions: extras.collectionItemActions,
+      };
+    });
 
-  // Table mode: collection_attributes specified
-  if (headers) {
     return (
       <div>
-        <div className="rounded-md border">
-          <Table>
-            <TableHeader>
-              <TableRow>
-                {headers.map((header) =>
-                  <TableHead key={header.attribute}>{header.label}</TableHead>
-                )}
-                {collectionItemActions && <TableHead></TableHead>}
-              </TableRow>
-            </TableHeader>
-            <TableBody>
-              {visibleItems.map((item) => {
-                const showPath = pathFor(item.id);
-                return (
-                  <TableRow
-                    key={item.id}
-                    className={showPath ? "cursor-pointer" : ""}
-                    onClick={(e) => handleRowClick(e, showPath)}>
-                    {item.columns.map((col, colIndex) =>
-                      <TableCell key={col.attribute}>
-                        {showPath && colIndex === 0 ? (
-                          <a href={showPath} data-sg-visit className="hover:underline">
-                            <FieldRenderer mode="index" {...col} />
-                          </a>
-                        ) : (
-                          <FieldRenderer mode="index" {...col} />
-                        )}
-                      </TableCell>
-                    )}
-                    {collectionItemActions && (
-                      <TableCell>
-                        <CollectionItemActions actions={collectionItemActions?.[String(item.id)]} />
-                      </TableCell>
-                    )}
-                  </TableRow>
-                );
-              })}
-            </TableBody>
-          </Table>
-        </div>
+        <ResourceTable headers={headers} rows={enrichedRows} showActions={options?.renderActions !== false} />
         {hasMore && (
           <Button
             variant="link"
@@ -93,12 +44,19 @@ export function ShowField({ value, itemShowPaths, collectionItemActions }) {
     );
   }
 
-  // Simple list mode
+  // Simple list mode (no collection_attributes)
+  if (!items || items.length === 0) {
+    return <span className="text-muted-foreground">None</span>;
+  }
+
+  const hasMore = initialLimit && initialLimit > 0 && total > initialLimit;
+  const visibleItems = expanded || !hasMore ? items : items.slice(0, initialLimit);
+
   return (
     <div>
       <div className="flex flex-wrap items-center gap-1.5">
         {visibleItems.map((item) => {
-          const showPath = pathFor(item.id);
+          const showPath = hasManyRowExtras?.[String(item.id)]?.showPath;
           return showPath ? (
             <a key={item.id} href={showPath} data-sg-visit>
               <Badge variant="secondary" className="cursor-pointer">{item.display}</Badge>

data/lib/generators/terrazzo/views/templates/pages/_collection.jsx

@@ -1,55 +1,11 @@
-import React, { useContext } from "react";
-import { NavigationContext } from "@thoughtbot/superglue";
+import React from "react";
 
-import { SortableHeader, CollectionItemActions } from "terrazzo/components";
-import { FieldRenderer } from "terrazzo/fields";
-import { Table, TableHeader, TableBody, TableRow, TableHead, TableCell } from "terrazzo/ui";
+import { ResourceTable } from "terrazzo/components";
 
 export function AdminCollection({ table }) {
-  const { visit } = useContext(NavigationContext);
-
-  const handleRowClick = (e, showPath) => {
-    if (!showPath) return;
-    if (e.target.closest("a, button, form")) return;
-    if (window.getSelection().toString()) return;
-    visit(showPath, {});
-  };
-
   return (
-    <div className="overflow-x-auto rounded-md border">
-      <Table>
-        <TableHeader>
-          <TableRow>
-            {table.headers.map((header) =>
-            <SortableHeader key={header.attribute} {...header} />
-            )}
-            <TableHead className="w-[120px]">Actions</TableHead>
-          </TableRow>
-        </TableHeader>
-        <TableBody>
-          {table.rows.map((row) =>
-          <TableRow
-            key={row.id}
-            className={row.showPath ? "cursor-pointer" : ""}
-            onClick={(e) => handleRowClick(e, row.showPath)}>
-              {row.cells.map((cell) =>
-            <TableCell key={cell.attribute}>
-                  {cell.showPath ? (
-                    <a href={cell.showPath} data-sg-visit className="hover:underline">
-                      <FieldRenderer mode="index" {...cell} />
-                    </a>
-                  ) : (
-                    <FieldRenderer mode="index" {...cell} />
-                  )}
-                </TableCell>
-            )}
-              <TableCell>
-                <CollectionItemActions actions={row.collectionItemActions} />
-              </TableCell>
-            </TableRow>
-          )}
-        </TableBody>
-      </Table>
+    <div className="overflow-x-auto">
+      <ResourceTable headers={table.headers} rows={table.rows} />
     </div>
   );
 }

data/lib/terrazzo/engine.rb

@@ -2,6 +2,14 @@ module Terrazzo
   class Engine < ::Rails::Engine
     isolate_namespace Terrazzo
 
+    initializer "terrazzo.props_searcher_partial" do
+      Props::Searcher.class_eval do
+        def partial!(**options)
+          @context.render options
+        end
+      end
+    end
+
     initializer "terrazzo.i18n" do
       Terrazzo::Engine.root.glob("config/locales/**/*.yml").each do |locale|
         I18n.load_path << locale unless I18n.load_path.include?(locale)

data/lib/terrazzo/field/has_many.rb

@@ -20,8 +20,14 @@ module Terrazzo
       end
 
       def serializable_options(page = nil)
-        return {} unless page == :form && resource
-        { resourceOptions: resource_options }
+        opts = {}
+        if page == :form && resource
+          opts[:resourceOptions] = resource_options
+        end
+        if options.key?(:render_actions)
+          opts[:renderActions] = options[:render_actions]
+        end
+        opts
       end
 
       class << self
@@ -30,7 +36,7 @@ module Terrazzo
         end
 
         def default_options
-          { limit: 5 }
+          {}
         end
 
         def permitted_attribute(attr, _options = {})
@@ -38,22 +44,53 @@ module Terrazzo
         end
       end
 
+      def per_page
+        (options[:per_page] || options[:limit] || 5).to_i
+      end
+
+      def current_page
+        p = options[:_page].to_i
+        p < 1 ? 1 : p
+      end
+
+      def total_count
+        paginated.total_count
+      end
+
+      def total_pages
+        [paginated.total_pages, 1].max
+      end
+
+      def page_records
+        paginated.to_a
+      end
+
       private
 
+      def paginated
+        @paginated ||= begin
+          scope = apply_sorting(data)
+          scope = Kaminari.paginate_array(scope.to_a) unless scope.respond_to?(:page)
+          scope.page(current_page).per(per_page)
+        end
+      end
+
       def serialize_show_value
-        limit = options.fetch(:limit, 5)
-        records = apply_sorting(data)
-        all_records = records.to_a
-        total = all_records.size
         col_attrs = options[:collection_attributes] || resolve_default_collection_attributes
 
+        meta = {
+          total: total_count,
+          perPage: per_page,
+          currentPage: current_page,
+          totalPages: total_pages,
+        }
+
         if col_attrs
-          serialize_with_collection_attributes(all_records, col_attrs, total, limit)
+          { **serialize_with_collection_attributes(page_records, col_attrs), **meta }
         else
           {
-            items: all_records.map { |r| { id: r.id.to_s, display: display_name(r) } },
-            total: total,
-            initialLimit: limit
+            items: page_records.map { |r| { id: r.id.to_s, display: display_name(r) } },
+            **meta,
           }
         end
       end
@@ -65,15 +102,15 @@ module Terrazzo
         nil
       end
 
-      def serialize_with_collection_attributes(records, col_attrs, total, limit)
+      def serialize_with_collection_attributes(records, col_attrs)
         dashboard_class = find_associated_dashboard
 
         headers = col_attrs.map do |attr|
           { attribute: attr.to_s, label: attr.to_s.humanize }
         end
 
-        items = records.map do |record|
-          columns = col_attrs.map do |attr|
+        rows = records.map do |record|
+          cells = col_attrs.map do |attr|
             field = dashboard_class.new.attribute_type_for(attr).new(attr, nil, :index, resource: record)
             {
               attribute: attr.to_s,
@@ -81,15 +118,10 @@ module Terrazzo
               value: field.serialize_value(:index)
             }
           end
-          { id: record.id.to_s, columns: columns }
+          { id: record.id.to_s, cells: cells }
         end
 
-        {
-          headers: headers,
-          items: items,
-          total: total,
-          initialLimit: limit
-        }
+        { headers: headers, rows: rows }
       end
 
       def resource_options

data/lib/terrazzo/has_many_pagination.rb

@@ -0,0 +1,24 @@
+module Terrazzo
+  module HasManyPagination
+    PARAM_PREFIX = "hm_".freeze
+    PARAM_SUFFIX = "_page".freeze
+
+    module_function
+
+    def extract(params)
+      result = {}
+      params.each do |key, value|
+        key_s = key.to_s
+        next unless key_s.start_with?(PARAM_PREFIX) && key_s.end_with?(PARAM_SUFFIX)
+        attr = key_s[PARAM_PREFIX.length...-PARAM_SUFFIX.length]
+        next if attr.empty?
+        result[attr.to_sym] = { _page: value.to_i }
+      end
+      result
+    end
+
+    def param_key(attribute)
+      "#{PARAM_PREFIX}#{attribute}#{PARAM_SUFFIX}"
+    end
+  end
+end

data/lib/terrazzo/page/show.rb

@@ -3,9 +3,10 @@ module Terrazzo
     class Show < Base
       attr_reader :resource
 
-      def initialize(dashboard, resource)
+      def initialize(dashboard, resource, has_many_params: {})
         super(dashboard, resource.class)
         @resource = resource
+        @has_many_params = has_many_params || {}
       end
 
       def page_title
@@ -20,24 +21,29 @@ module Terrazzo
       def attributes
         attrs = dashboard.show_page_attributes
         dashboard.flatten_attributes(attrs).map do |attr|
-          dashboard.attribute_type_for(attr).new(attr, nil, :show, resource: resource)
+          build_field(attr, :show)
         end
       end
 
       private
 
+      def build_field(attr, mode)
+        extra = @has_many_params[attr.to_sym] || {}
+        dashboard.attribute_type_for(attr).new(attr, nil, mode, resource: resource, options: extra)
+      end
+
       def normalize_groups(attrs, mode)
         if attrs.is_a?(Hash)
           attrs.map do |group_name, fields|
             {
               name: group_name,
-              fields: fields.map { |attr| dashboard.attribute_type_for(attr).new(attr, nil, mode, resource: resource) }
+              fields: fields.map { |attr| build_field(attr, mode) }
             }
           end
         else
           [{
             name: "",
-            fields: attrs.map { |attr| dashboard.attribute_type_for(attr).new(attr, nil, mode, resource: resource) }
+            fields: attrs.map { |attr| build_field(attr, mode) }
           }]
         end
       end

data/lib/terrazzo/version.rb

@@ -1,3 +1,3 @@
 module Terrazzo
-  VERSION = "0.5.2"
+  VERSION = "0.5.4"
 end

data/lib/terrazzo.rb

@@ -13,6 +13,7 @@ module Terrazzo
   autoload :Filter, "terrazzo/filter"
   autoload :Namespace, "terrazzo/namespace"
   autoload :GeneratorHelpers, "terrazzo/generator_helpers"
+  autoload :HasManyPagination, "terrazzo/has_many_pagination"
   autoload :UsesSuperglue, "terrazzo/uses_superglue"
 
   module Field

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: terrazzo
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.4
 platform: ruby
 authors:
 - Terrazzo Contributors
@@ -273,6 +273,7 @@ files:
 - lib/terrazzo/field/url.rb
 - lib/terrazzo/filter.rb
 - lib/terrazzo/generator_helpers.rb
+- lib/terrazzo/has_many_pagination.rb
 - lib/terrazzo/namespace.rb
 - lib/terrazzo/namespace/resource.rb
 - lib/terrazzo/not_authorized_error.rb