phlexi-table 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e05e322aef835f61e4d9c75e678c54ed3abd96675b7eaedb7db6b8138f826450
-  data.tar.gz: 3d2e8b90865ab5e8e5b5b405046277a51177508187f3fde2d708612bed01dc6f
+  metadata.gz: a2fc89d8ce811c592ca3a145af7ce3c91171d767404ec497a117a609e26c2f6a
+  data.tar.gz: 72d3289f57300d9f05a717cc9745d223971c0c143a9245e6e8a54c0ed5b6303c
 SHA512:
-  metadata.gz: e9e99ffd0dff1b5e92cdc779c8cd3fd5dee46e20094916e50eeec337c1af2b88fd0b9fa637dd56f54ad3a12381e0d2b2434747d536a4bb5fff928d08ccd6dd1f
-  data.tar.gz: 4f97e0de92ea6e09b17d7e09c6d242ee968638c6d4766991515aa54d3e738a51219190ca4d1fd944205b06b627eb9c3a2b0e7125adf5cb22eda839f14a5c7668
+  metadata.gz: 5aab0ea7be94c1f55a554b10b21710d2e4c6dd98ad0f9e1e1671660a03327e569163acaad34ae6ba1f57f7f5f0759ff58d73e553d366f64d939e4ecea9b53bed
+  data.tar.gz: 8132fba9adc5135022108759ff28ba5cd568ee818e307ce5fc0f36c11f19715b170af523fb4c90856ee718f2c29415fba8b7a281dc4125e365042f9ce54972fa

data/lib/phlexi/table/base.rb

@@ -1,118 +1,387 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module/delegation"
-require "active_support/core_ext/string/inflections"
+require "phlex"
+# require "phlexi-display"
 
 module Phlexi
   module Table
-    # A display component for rendering flexible and customizable data views.
+    # Base class for creating customizable table components
     #
     # @example Basic usage
-    #   Phlexi::Table.new(user) do |d|
-    #     render d.field(:name).text
-    #     render d.field(:email).text
+    #   class UsersTable < Phlexi::Table::Base
+    #     def table_template
+    #       table_caption "Caption"
+    #       table_description "Description"
+    #       selection_column :id
+    #       column :name
+    #       column :a_sorted_column, sort_params: {url: "url", reset_url: "reset_url", position: "multisort position", direction: "ASC|DESC"}
+    #       column_group :a_grouped_column do |g|
+    #         g.column :sub_col1
+    #         g.column :sub_col2
+    #       end
+    #       actions do |user|
+    #         link_to "Edit", edit_user_path(user)
+    #       end
+    #     end
     #   end
     #
-    # @attr_reader [Symbol] key The display's key, derived from the record or explicitly set
-    # @attr_reader [ActiveModel::Model, nil] object The display's associated object
-    class Base < COMPONENT_BASE
-      class Namespace < Structure::Namespace; end
-
-      class FieldBuilder < Structure::FieldBuilder; end
-
-      attr_reader :key, :object
-
-      delegate :field, :nest_one, :nest_many, to: :@namespace
-
-      # Initializes a new Table instance.
-      #
-      # @param record [ActiveModel::Model, Symbol, String] The display's associated record or key
-      # @param attributes [Hash] Additional HTML attributes for the display container
-      # @param options [Hash] Additional options for display configuration
-      # @option options [String] :class CSS classes for the display
-      # @option options [Class] :namespace_klass Custom namespace class
-      # @option options [Class] :builder_klass Custom field builder class
-      def initialize(record, attributes: {}, **options)
-        @display_class = options.delete(:class)
-        @attributes = attributes
-        @namespace_klass = options.delete(:namespace_klass) || default_namespace_klass
-        @builder_klass = options.delete(:builder_klass) || default_builder_klass
+    #   render UsersTable.new(User.all)
+    #
+    # @attr_reader [Enumerable] collection The collection of items to display in the table
+    # @attr_reader [Hash] columns The columns defined for the table
+    class Base < Phlexi::Table::HTML
+      include Phlex::DeferredRender
+      include Phlexi::Table::TableOptions::Captions
+      include Phlexi::Table::TableOptions::Descriptions
+
+      class Column < Phlexi::Table::Components::Column; end
+
+      class ColumnGroup < Phlexi::Table::Components::ColumnGroup; end
+
+      class ActionsColumn < Phlexi::Table::Components::ActionsColumn; end
+
+      attr_reader :key, :collection, :columns, :options
+
+      # Initialize a new table component
+      #
+      # @param collection [Enumerable] The collection of items to display
+      # @param options [Hash] Additional options for customizing the table
+      # @option options [String] :id The ID attribute for the table
+      # @option options [String] :class The CSS class(es) for the table
+      # @raise [ArgumentError] If the collection is empty
+      def initialize(collection, **options)
+        raise ArgumentError, "Collection cannot be empty" if collection.empty?
+
+        @collection = collection
+        @columns = {}
         @options = options
+        initialize_key
+      end
+
+      def view_template
+        render_table
+      end
+
+      def table_template
+      end
+
+      def column(key, **options, &)
+        if options[:as] == :selection
+          selection_column(key, self, **options, &)
+        else
+
+          add_column(column_class.new(key, self, **options, &))
+        end
+      end
+
+      def selection_column(key, **, &)
+        raise "Selection column already added" if @has_selection_column
 
-        initialize_object_and_key(record)
-        initialize_namespace
+        @has_selection_column = true
+        add_column(column_class.new(key, self, **, as: :selection, &))
       end
 
-      # Renders the display template.
+      def column_group(key, **, &)
+        @has_grouped_columns = true
+        add_column(column_group_class.new(key, self, **, &))
+      end
+
+      def actions(**, &)
+        raise "Action column already added" if @has_action_column
+
+        @has_action_column = true
+        add_column(actions_column_class.new(:phlexi_table_actions, self, label: "Actions", **, &))
+      end
+
+      def sample
+        collection[0]
+      end
+
+      def dom_id
+        key
+      end
+
+      def column_class
+        self.class::Column
+      end
+
+      def column_group_class
+        self.class::ColumnGroup
+      end
+
+      def actions_column_class
+        self.class::ActionsColumn
+      end
+
+      protected
+
+      def before_template
+        super
+        table_template
+      end
+
+      # Render the complete table structure
       #
       # @return [void]
-      def view_template
-        display_template
+      def render_table
+        div(**table_wrapper_attributes) {
+          table(**table_attributes) do
+            render_table_caption
+            render_table_header
+            render_table_body
+            render_table_footer
+          end
+        }
       end
 
-      # Executes the display's content block.
-      # Override this in subclasses to define a static display.
+      # Render the table caption
       #
       # @return [void]
-      def display_template
-        instance_exec(&@_content_block) if @_content_block
+      def render_table_caption
+        return unless has_table_caption? || has_table_description?
+
+        caption(**table_caption_attributes) {
+          plain table_caption if has_table_caption?
+          if has_table_description?
+            p(**table_description_attributes) {
+              table_description
+            }
+          end
+        }
       end
 
-      protected
+      # Render the table header
+      #
+      # @return [void]
+      def render_table_header
+        thead(**table_header_attributes) do
+          if @has_grouped_columns
+            tr(**table_header_grouping_row_attributes) do
+              blanks = 0
+              columns.each_value do |column|
+                if column.is_a?(Phlexi::Table::Components::Concerns::GroupsColumns)
+                  th(**table_header_grouping_cell_attributes(blanks)) {} if blanks > 0
+                  th(id: column.dom_id, **table_header_grouping_cell_attributes(column.colspan)) { column.label }
+                  blanks = 0
+                else
+                  blanks += 1
+                end
+              end
+              th(**table_header_grouping_cell_attributes(blanks)) { whitespace } if blanks > 0
+            end
+          end
 
-      attr_reader :options, :attributes, :namespace_klass, :builder_klass
+          tr(**table_header_row_attributes) do
+            columns.each_value do |column|
+              if column.is_a?(Phlexi::Table::Components::Concerns::GroupsColumns)
+                column.columns.each_value do |column|
+                  th(**table_header_cell_attributes(column)) { render column.header_cell }
+                end
+              else
+                th(**table_header_cell_attributes(column)) { render column.header_cell }
+              end
+            end
+          end
+        end
+      end
 
-      # Initializes the object and key based on the given record.
+      # Render the table body
       #
-      # @param record [ActiveModel::Model, Symbol, String] The display's associated record or key
       # @return [void]
-      def initialize_object_and_key(record)
-        @key = options.delete(:key) || options.delete(:as)
+      def render_table_body
+        tbody(**table_body_attributes) do
+          collection.each_with_index do |item, index|
+            object = WrappedObject.new(item, index:)
+            render_table_body_row(object)
+          end
+        end
+      end
 
-        case record
-        when String, Symbol
-          @object = nil
-          @key = record
-        else
-          @object = record
-          @key = if @key.nil? && object.respond_to?(:model_name) && object.model_name.respond_to?(:param_key) && object.model_name.param_key.present?
-            object.model_name.param_key
-          else
-            :object
+      # Render a table body row
+      #
+      # @param item [Object] The current item from the collection
+      # @return [void]
+      def render_table_body_row(object)
+        tr(**table_body_row_attributes(object)) do
+          columns.each_value do |column|
+            if column.is_a?(Phlexi::Table::Components::Concerns::GroupsColumns)
+              column.columns.each_value do |column|
+                td(**table_data_cell_attributes(object, column)) { render column.data_cell(object) }
+              end
+            elsif column.is_a?(actions_column_class)
+              td(**table_data_cell_attributes(object, column)) { column.render_actions(object.unwrapped) }
+            else
+              td(**table_data_cell_attributes(object, column)) { render column.data_cell(object) }
+            end
           end
         end
-        @key = @key.to_sym
       end
 
-      # Initializes the namespace for the display.
+      # Render the table footer
       #
       # @return [void]
-      def initialize_namespace
-        @namespace = namespace_klass.root(key, object: object, builder_klass: builder_klass)
+      def render_table_footer
+        # tfoot(**table_footer_attributes) do
+        #   # Implement footer content if needed
+        # end
+      end
+
+      private
+
+      def table_wrapper_attributes
+        {
+          id: @options[:id] || "#{dom_id}_table_wrapper",
+          class: tokens("phlexi_table_wrapper", themed(:wrapper))
+        }
       end
-      # Retrieves the display's CSS classes.
+
+      # Get the attributes for the table element
       #
-      # @return [String] The display's CSS classes
-      attr_reader :display_class
+      # @return [Hash] The table attributes
+      def table_attributes
+        {
+          id: @options[:id] || "#{dom_id}_table",
+          class: tokens("phlexi_table", themed(:base), @options[:class])
+        }
+      end
 
-      # Generates the display attributes hash.
+      # Get the attributes for the table caption element
       #
-      # @return [Hash] The display attributes
-      def display_attributes
-        mix({
-          id: @namespace.dom_id,
-          class: display_class
-        }, attributes)
+      # @return [Hash] The caption attributes
+      def table_caption_attributes
+        {
+          id: "#{dom_id}_table_caption",
+          class: tokens("phlexi_table_caption", themed(:caption))
+        }
       end
 
-      private
+      # Get the attributes for the table description
+      #
+      # @return [Hash] The description attributes
+      def table_description_attributes
+        {
+          id: "#{dom_id}_table_description",
+          class: tokens("phlexi_table_description", themed(:description))
+        }
+      end
+
+      # Get the attributes for the table header element
+      #
+      # @return [Hash] The header attributes
+      def table_header_attributes
+        {
+          id: "#{dom_id}_table_header",
+          class: tokens("phlexi_table_header", themed(:header))
+        }
+      end
+
+      def table_header_grouping_row_attributes
+        {
+          id: "#{dom_id}_table_header_grouping_row",
+          class: tokens("phlexi_table_header_grouping_row", themed(:header_grouping_row))
+        }
+      end
+
+      def table_header_grouping_cell_attributes(colspan)
+        {
+          colspan:,
+          class: tokens("phlexi_table_header_grouping_cell", themed(:header_grouping_cell))
+        }
+      end
+
+      # Get the attributes for the table header row element
+      #
+      # @return [Hash] The header row attributes
+      def table_header_row_attributes
+        {
+          id: "#{dom_id}_table_header_row",
+          class: tokens("phlexi_table_header_row", themed(:header_row))
+        }
+      end
 
-      def default_namespace_klass
-        self.class::Namespace
+      # Get the attributes for a table header cell element
+      #
+      # @param column [Columns::Base] The column object
+      # @return [Hash] The header cell attributes
+      def table_header_cell_attributes(column)
+        mix(
+          {
+            scope: "col",
+            class: tokens("phlexi_table_header_cell", themed(:header_cell))
+          },
+          column.header_cell_attributes
+        )
       end
 
-      def default_builder_klass
-        self.class::FieldBuilder
+      # Get the attributes for the table body element
+      #
+      # @return [Hash] The body attributes
+      def table_body_attributes
+        {
+          id: "#{dom_id}_table_body",
+          class: tokens("phlexi_table_body", themed(:body))
+        }
+      end
+
+      # Get the attributes for a table body row element
+      #
+      # @param item [Object] The current item from the collection
+      # @return [Hash] The body row attributes
+      def table_body_row_attributes(item)
+        {
+          id: "#{dom_id}_table_row_#{item.id}",
+          class: tokens("phlexi_table_body_row", themed(:body_row))
+        }
+      end
+
+      # Get the attributes for a table body cell element
+      #
+      # @param item [Object] The current item from the collection
+      # @param column [Columns::Base] The column object
+      # @return [Hash] The body cell attributes
+      def table_data_cell_attributes(item, column)
+        mix(
+          {
+            id: "#{dom_id}_table_row_#{item.id}_#{column.key}",
+            class: tokens("phlexi_table_data_cell", themed(:body_cell))
+          },
+          column.data_cell_attributes(item)
+        )
+      end
+
+      # Get the attributes for the table footer element
+      #
+      # @return [Hash] The footer attributes
+      def table_footer_attributes
+        {
+          id: "#{dom_id}_table_footer",
+          class: tokens("phlexi_table_footer", themed(:footer))
+        }
+      end
+
+      # Add a column to the table
+      #
+      # @param column [Columns::Base] The column object to add
+      # @return [void]
+      # @raise [ArgumentError] If a column with the same key already exists
+      def add_column(column)
+        raise ArgumentError, "Column '#{column.key}' already exists" if @columns.key?(column.key)
+
+        @columns[column.key] = column
+      end
+
+      def initialize_key
+        # always pop these keys
+        # add support for `as` to make it more rails friendly
+        @key = options.delete(:key) || options.delete(:as)
+        if @key.nil?
+          @key = if sample.respond_to?(:model_name) && sample.model_name.respond_to?(:param_key) && sample.model_name.param_key.present?
+            sample.model_name.plural.underscore
+          else
+            sample.class.name.demodulize.pluralize.underscore
+          end
+        end
+        @key = @key.to_sym
       end
     end
   end

data/lib/phlexi/table/components/actions_column.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "phlex"
+
+module Phlexi
+  module Table
+    module Components
+      class ActionsColumn < Base
+        include Phlexi::Table::Components::Concerns::DisplaysHeader
+
+        def initialize(*, **, &block)
+          raise ArgumentError, "block is required" unless block.present?
+
+          super(*, **)
+          @block = block
+        end
+
+        def label(label = nil)
+          if label.nil?
+            options[:label]
+          else
+            options[:label] = label
+            self
+          end
+        end
+
+        def render_actions(object)
+          @block.call(object)
+        end
+
+        def dom_id
+          "#{super}_actions_cell"
+        end
+
+        def data_cell_attributes(object)
+          attributes = @attributes.dup
+          attributes[:class] = tokens(
+            themed(:actions_row_cell)
+          )
+          attributes
+        end
+
+        def type = "actions"
+
+        def alignment = nil
+      end
+    end
+  end
+end

data/lib/phlexi/table/components/base.rb

@@ -1,36 +1,41 @@
 # frozen_string_literal: true
 
+require "phlex"
+
 module Phlexi
   module Table
     module Components
-      class Base < COMPONENT_BASE
-        attr_reader :field, :attributes
+      class Base
+        include Phlex::Helpers
+
+        attr_reader :key, :parent, :options
+
+        delegate :sample, to: :parent
 
-        def initialize(field, **attributes)
-          @field = field
-          @attributes = attributes
+        def initialize(key, parent, **options)
+          @key = key
+          @parent = parent
+          @options = options
 
           build_attributes
-          append_attribute_classes
         end
 
-        protected
-
-        def build_attributes
-          attributes.fetch(:id) { attributes[:id] = "#{field.dom.id}_#{component_name}" }
+        def dom_id
+          "#{parent.dom_id}_#{key}"
         end
 
-        def append_attribute_classes
-          return if attributes[:class] == false
+        private
 
-          attributes[:class] = tokens(
-            component_name,
-            attributes[:class]
-          )
+        def build_attributes
+          @attributes = {
+            class: tokens(
+              type
+            )
+          }
         end
 
-        def component_name
-          @component_name ||= self.class.name.demodulize.underscore
+        def themed(component)
+          Phlexi::Table::Theme.instance.resolve_theme(component)
         end
       end
     end

data/lib/phlexi/table/components/column.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "phlex"
+
+module Phlexi
+  module Table
+    module Components
+      class Column < Base
+        include Phlexi::Table::Components::Options::Types
+        include Phlexi::Table::Components::Options::Labels
+        include Phlexi::Table::Components::Options::Alignment
+        include Phlexi::Table::Components::Options::Attachments
+        include Phlexi::Table::Components::Options::Associations
+        include Phlexi::Table::Components::Concerns::DisplaysHeader
+        include Phlexi::Table::Components::Concerns::DisplaysData
+
+        def initialize(*, **, &block)
+          super(*, **)
+          @block = block
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/table/components/column_group.rb

@@ -0,0 +1,23 @@
+module Phlexi
+  module Table
+    module Components
+      class ColumnGroup < Base
+        include Phlexi::Table::Components::Options::Labels
+        include Phlexi::Table::Components::Concerns::DisplaysHeader
+        include Phlexi::Table::Components::Concerns::GroupsColumns
+
+        def colspan
+          @columns.size
+        end
+
+        def dom_id
+          "#{super}_header_grouping_cell"
+        end
+
+        def type = "column_group"
+
+        def alignment = nil
+      end
+    end
+  end
+end