phlexi-table 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a2fc89d8ce811c592ca3a145af7ce3c91171d767404ec497a117a609e26c2f6a
-  data.tar.gz: 72d3289f57300d9f05a717cc9745d223971c0c143a9245e6e8a54c0ed5b6303c
+  metadata.gz: ea441f5dc6bff0752e14011507ba3274026a46f8900de536f7b1d253fff45c44
+  data.tar.gz: 05dd06af33197b2f8847d2bfab878340cf23d28d9c824b53382497343ae1de13
 SHA512:
-  metadata.gz: 5aab0ea7be94c1f55a554b10b21710d2e4c6dd98ad0f9e1e1671660a03327e569163acaad34ae6ba1f57f7f5f0759ff58d73e553d366f64d939e4ecea9b53bed
-  data.tar.gz: 8132fba9adc5135022108759ff28ba5cd568ee818e307ce5fc0f36c11f19715b170af523fb4c90856ee718f2c29415fba8b7a281dc4125e365042f9ce54972fa
+  metadata.gz: 5db97df1ef5cf3131212ee6ce6a9b043dffd5d97f68e783ceca071b95cbedbb3a7a57086d82d0285cd100714e6aa0994001615f99768a56154cd4296df2eac75
+  data.tar.gz: 48935e08c5e0dfb4b9fb110ebe7a14cffc5d3a73930a0ad7779e89fbe3579c4a19ebe72062deaac07df84b8a47fe73351ee7a0e8555bdadf79c01e02ba72d9df

data/lib/phlexi/table/base.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "phlex"
-# require "phlexi-display"
-
 module Phlexi
   module Table
     # Base class for creating customizable table components
@@ -31,15 +28,19 @@ module Phlexi
     # @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
+      include Phlexi::Table::Options::Captions
+      include Phlexi::Table::Options::Descriptions
 
-      class Column < Phlexi::Table::Components::Column; end
+      class DataColumn < Phlexi::Table::Components::DataColumn; end
 
-      class ColumnGroup < Phlexi::Table::Components::ColumnGroup; end
+      class SelectionColumn < Phlexi::Table::Components::SelectionColumn; end
 
       class ActionsColumn < Phlexi::Table::Components::ActionsColumn; end
 
+      class ColumnGroup < Phlexi::Table::Components::ColumnGroup; end
+
+      class Display < Phlexi::Display::Base; end
+
       attr_reader :key, :collection, :columns, :options
 
       # Initialize a new table component
@@ -50,35 +51,55 @@ module Phlexi
       # @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 = Array(collection)
+        raise ArgumentError, "Collection cannot be empty" if @collection.empty?
 
-        @collection = collection
         @columns = {}
         @options = options
         initialize_key
       end
 
+      def around_template
+        original_template = Phlexi::Display::Theme.instance
+        Phlexi::Display::Theme.instance = Phlexi::Table::DisplayTheme.instance
+        super
+      ensure
+        Phlexi::Display::Theme.instance = original_template
+      end
+
+      def before_template
+        super
+        table_template
+      end
+
       def view_template
         render_table
       end
 
       def table_template
+        # implement this in subclasses to define the column template
       end
 
-      def column(key, **options, &)
-        if options[:as] == :selection
-          selection_column(key, self, **options, &)
-        else
+      # 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
 
-          add_column(column_class.new(key, self, **options, &))
-        end
+      def column(key, **, &)
+        add_column(column_class.new(key, self, **, &))
       end
 
       def selection_column(key, **, &)
         raise "Selection column already added" if @has_selection_column
 
         @has_selection_column = true
-        add_column(column_class.new(key, self, **, as: :selection, &))
+        add_column(selection_column_class.new(key, self, **, &))
       end
 
       def column_group(key, **, &)
@@ -97,29 +118,32 @@ module Phlexi
         collection[0]
       end
 
+      def wrapped_sample
+        @wrapped_sample ||= WrappedObject.new(sample, index: -1, display_class: self.class::Display)
+      end
+
       def dom_id
         key
       end
 
       def column_class
-        self.class::Column
+        self.class::DataColumn
       end
 
-      def column_group_class
-        self.class::ColumnGroup
+      def selection_column_class
+        self.class::SelectionColumn
       end
 
       def actions_column_class
         self.class::ActionsColumn
       end
 
-      protected
-
-      def before_template
-        super
-        table_template
+      def column_group_class
+        self.class::ColumnGroup
       end
 
+      protected
+
       # Render the complete table structure
       #
       # @return [void]
@@ -190,28 +214,28 @@ module Phlexi
       # @return [void]
       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)
+          collection.each_with_index do |object, index|
+            wrapped_object = WrappedObject.new(object, index:, display_class: self.class::Display)
+            render_table_body_row(wrapped_object)
           end
         end
       end
 
       # Render a table body row
       #
-      # @param item [Object] The current item from the collection
+      # @param wrapped_object [Object] The current item from the collection
       # @return [void]
-      def render_table_body_row(object)
-        tr(**table_body_row_attributes(object)) do
+      def render_table_body_row(wrapped_object)
+        tr(**table_body_row_attributes(wrapped_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) }
+                td(**table_data_cell_attributes(wrapped_object, column)) { render column.data_cell(wrapped_object) }
               end
             elsif column.is_a?(actions_column_class)
-              td(**table_data_cell_attributes(object, column)) { column.render_actions(object.unwrapped) }
+              td(**table_data_cell_attributes(wrapped_object, column)) { column.render_actions(wrapped_object) }
             else
-              td(**table_data_cell_attributes(object, column)) { render column.data_cell(object) }
+              td(**table_data_cell_attributes(wrapped_object, column)) { render column.data_cell(wrapped_object) }
             end
           end
         end
@@ -325,27 +349,27 @@ module Phlexi
 
       # Get the attributes for a table body row element
       #
-      # @param item [Object] The current item from the collection
+      # @param wrapped_object [Object] The current item from the collection
       # @return [Hash] The body row attributes
-      def table_body_row_attributes(item)
+      def table_body_row_attributes(wrapped_object)
         {
-          id: "#{dom_id}_table_row_#{item.id}",
+          id: "#{dom_id}_table_row_#{wrapped_object.identifier}",
           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 wrapped_object [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)
+      def table_data_cell_attributes(wrapped_object, column)
         mix(
           {
-            id: "#{dom_id}_table_row_#{item.id}_#{column.key}",
+            id: "#{dom_id}_table_row_#{wrapped_object.identifier}_#{column.key}",
             class: tokens("phlexi_table_data_cell", themed(:body_cell))
           },
-          column.data_cell_attributes(item)
+          column.data_cell_attributes(wrapped_object)
         )
       end
 
@@ -359,17 +383,6 @@ module Phlexi
         }
       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

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "phlex"
-
 module Phlexi
   module Table
     module Components
@@ -33,11 +31,7 @@ module Phlexi
         end
 
         def data_cell_attributes(object)
-          attributes = @attributes.dup
-          attributes[:class] = tokens(
-            themed(:actions_row_cell)
-          )
-          attributes
+          @attributes
         end
 
         def type = "actions"

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

@@ -1,16 +1,15 @@
 # frozen_string_literal: true
 
-require "phlex"
-
 module Phlexi
   module Table
     module Components
       class Base
         include Phlex::Helpers
+        include Phlexi::Table::HTML::Behaviour
 
         attr_reader :key, :parent, :options
 
-        delegate :sample, to: :parent
+        delegate :sample, :wrapped_sample, to: :parent
 
         def initialize(key, parent, **options)
           @key = key
@@ -34,8 +33,8 @@ module Phlexi
           }
         end
 
-        def themed(component)
-          Phlexi::Table::Theme.instance.resolve_theme(component)
+        def type
+          options[:as] || wrapped_sample.field(key).inferred_field_type
         end
       end
     end

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

@@ -1,23 +1,13 @@
 # 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

data/lib/phlexi/table/components/concerns/displays_data.rb

@@ -7,41 +7,12 @@ module Phlexi
         module DisplaysData
           extend ActiveSupport::Concern
 
-          class DataCell < Phlexi::Table::HTML
-            def initialize(value)
-              @value = value
-            end
-
-            def view_template
-              plain @value.to_s
-            end
-          end
-
-          class SelectionCell < Phlexi::Table::HTML
-            def initialize(value)
-              @value = value
-            end
-
-            def view_template
-              input(type: :checkbox, value: @value, class: themed(:selection_checkbox))
-            end
-          end
-
-          def data_cell(object)
-            case type
-            when :selection
-              selection_cell_class.new(object.value_of(key))
-            else
-              data_cell_class.new(object.value_of(key))
-            end
+          def data_cell(wrapped_object)
+            raise NotImplementedError, "#{self.class} must implement #data_cell"
           end
 
-          def data_cell_attributes(object)
+          def data_cell_attributes(wrapped_object)
             attributes = @attributes.dup
-            case type
-            when :name, :selection
-              attributes["scope"] = "row"
-            end
             attributes[:class] = tokens(
               attributes[:class],
               themed(:"align_#{alignment}"),
@@ -49,16 +20,6 @@ module Phlexi
             )
             attributes
           end
-
-          private
-
-          def selection_cell_class
-            self.class::SelectionCell
-          end
-
-          def data_cell_class
-            self.class::DataCell
-          end
         end
       end
     end

data/lib/phlexi/table/components/concerns/displays_header.rb

@@ -7,80 +7,8 @@ module Phlexi
         module DisplaysHeader
           extend ActiveSupport::Concern
 
-          class HeaderCell < Phlexi::Table::HTML
-            def initialize(value, sort_params:)
-              @value = value
-              @sort_params = sort_params
-            end
-
-            def view_template
-              div(class: "flex items-center") do
-                if !@sort_params
-                  plain @value.to_s
-                  next
-                end
-
-                a(class: "flex items-center", href: @sort_params[:url]) do
-                  plain @value.to_s
-
-                  sort_icon = Phlexi::Table::Theme.instance.resolve_theme(:sort_icon)
-                  sort_icon_active = Phlexi::Table::Theme.instance.resolve_theme(:sort_icon_active)
-
-                  span(class: "ml-1.5") {
-                    svg(
-                      class: tokens(sort_icon, -> { @sort_params[:direction] != "DESC" } => sort_icon_active),
-                      aria_hidden: "true",
-                      xmlns: "http://www.w3.org/2000/svg",
-                      fill: "none",
-                      viewbox: "0 0 10 6"
-                    ) do |s|
-                      s.path(
-                        stroke: "currentColor",
-                        stroke_linecap: "round",
-                        stroke_linejoin: "round",
-                        stroke_width: "2",
-                        d: "M9 5 5 1 1 5"
-                      )
-                    end
-                    svg(
-                      class: tokens(sort_icon, -> { @sort_params[:direction] != "ASC" } => sort_icon_active),
-                      aria_hidden: "true",
-                      xmlns: "http://www.w3.org/2000/svg",
-                      fill: "none",
-                      viewbox: "0 0 10 6"
-                    ) do |s|
-                      s.path(
-                        stroke: "currentColor",
-                        stroke_linecap: "round",
-                        stroke_linejoin: "round",
-                        stroke_width: "2",
-                        d: "M1 1 5 5 9 1"
-                      )
-                    end
-                  }
-                end
-
-                next if @sort_params[:position].nil?
-
-                sort_index_clear_link = Phlexi::Table::Theme.instance.resolve_theme(:sort_index_clear_link)
-                sort_index_clear_link_text = Phlexi::Table::Theme.instance.resolve_theme(:sort_index_clear_link_text)
-                sort_index_clear_link_icon = Phlexi::Table::Theme.instance.resolve_theme(:sort_index_clear_link_icon)
-
-                a(href: @sort_params[:reset_url], title: "Clear sort", class: sort_index_clear_link) {
-                  span(class: sort_index_clear_link_text) { (@sort_params[:position] + 1).to_s }
-                  span(class: sort_index_clear_link_icon) { "✕" }
-                }
-              end
-            end
-          end
-
           def header_cell
-            case type
-            when :selection
-              selection_cell_class.new(nil)
-            else
-              header_cell_class.new(label, sort_params:)
-            end
+            HeaderCell.new(label)
           end
 
           def header_cell_attributes
@@ -95,18 +23,6 @@ module Phlexi
           end
 
           def colspan = 1
-
-          protected
-
-          def sort_params
-            options[:sort_params]
-          end
-
-          private
-
-          def header_cell_class
-            self.class::HeaderCell
-          end
         end
       end
     end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      class DataColumn < Column
+        def initialize(*, **, &block)
+          super(*, **)
+          @block = block
+        end
+
+        def header_cell
+          SortableHeaderCell.new(label, sort_params:)
+        end
+
+        def data_cell(wrapped_object)
+          if @block
+            @block.call(wrapped_object, key)
+          else
+            field = wrapped_object.field(key)
+            field.send(:"#{field.inferred_field_component}_tag")
+          end
+        end
+
+        protected
+
+        def sort_params
+          options[:sort_params]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      class HeaderCell < Phlexi::Table::HTML
+        def initialize(value)
+          @value = value
+        end
+
+        def view_template
+          div(class: themed(:header_cell_content_wrapper)) do
+            plain @value.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/table/components/options/alignment.rb

@@ -7,9 +7,9 @@ module Phlexi
         module Alignment
           def alignment(alignment = nil)
             if alignment.nil?
-              options[:alignment] = options.fetch(:alignment) { calculate_alignment }
+              options[:align] = options.fetch(:align) { calculate_alignment }
             else
-              options[:alignment] = alignment
+              options[:align] = alignment
               self
             end
           end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      class SelectionCell < Phlexi::Table::HTML
+        def initialize(value)
+          @value = value
+        end
+
+        def view_template
+          input(type: :checkbox, value: @value, class: themed(:selection_checkbox))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      class SelectionColumn < Column
+        def header_cell
+          SelectionCell.new("all")
+        end
+
+        def data_cell(wrapped_object)
+          SelectionCell.new(wrapped_object.field(key).dom.value)
+        end
+
+        def data_cell_attributes(wrapped_object)
+          {scope: :row}.merge(super)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      class SortableHeaderCell < HeaderCell
+        def initialize(value, sort_params:)
+          @value = value
+          @sort_params = sort_params
+        end
+
+        def view_template
+          div(class: themed(:header_cell_content_wrapper)) do
+            if !@sort_params
+              plain @value.to_s
+              next
+            end
+
+            a(class: themed(:header_cell_sort_wrapper), href: @sort_params[:url]) do
+              plain @value.to_s
+
+              sort_icon = themed(:sort_icon)
+              sort_icon_active = themed(:sort_icon_active)
+
+              span(class: themed(:header_cell_sort_indicator)) {
+                svg(
+                  class: tokens(sort_icon, -> { @sort_params[:direction] != "DESC" } => sort_icon_active),
+                  aria_hidden: "true",
+                  xmlns: "http://www.w3.org/2000/svg",
+                  fill: "none",
+                  viewbox: "0 0 10 6"
+                ) do |s|
+                  s.path(
+                    stroke: "currentColor",
+                    stroke_linecap: "round",
+                    stroke_linejoin: "round",
+                    stroke_width: "2",
+                    d: "M9 5 5 1 1 5"
+                  )
+                end
+                svg(
+                  class: tokens(sort_icon, -> { @sort_params[:direction] != "ASC" } => sort_icon_active),
+                  aria_hidden: "true",
+                  xmlns: "http://www.w3.org/2000/svg",
+                  fill: "none",
+                  viewbox: "0 0 10 6"
+                ) do |s|
+                  s.path(
+                    stroke: "currentColor",
+                    stroke_linecap: "round",
+                    stroke_linejoin: "round",
+                    stroke_width: "2",
+                    d: "M1 1 5 5 9 1"
+                  )
+                end
+              }
+            end
+
+            next if @sort_params[:position].nil?
+
+            sort_index_clear_link = themed(:sort_index_clear_link)
+            sort_index_clear_link_text = themed(:sort_index_clear_link_text)
+            sort_index_clear_link_icon = themed(:sort_index_clear_link_icon)
+
+            a(href: @sort_params[:reset_url], title: "Clear sort", class: sort_index_clear_link) {
+              span(class: sort_index_clear_link_text) { (@sort_params[:position] + 1).to_s }
+              span(class: sort_index_clear_link_icon) { "✕" }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/table/display_theme.rb

@@ -0,0 +1,6 @@
+module Phlexi
+  module Table
+    class DisplayTheme < Phlexi::Display::Theme
+    end
+  end
+end

data/lib/phlexi/table/html.rb

@@ -1,13 +1,15 @@
-require "phlex"
-
 module Phlexi
   module Table
     class HTML < (defined?(::ApplicationComponent) ? ::ApplicationComponent : Phlex::HTML)
-      protected
+      module Behaviour
+        protected
 
-      def themed(component)
-        Phlexi::Table::Theme.instance.resolve_theme(component)
+        def themed(component)
+          Phlexi::Table::Theme.instance.resolve_theme(component)
+        end
       end
+
+      include Behaviour
     end
   end
 end

data/lib/phlexi/table/{table_options → options}/captions.rb

@@ -2,7 +2,7 @@
 
 module Phlexi
   module Table
-    module TableOptions
+    module Options
       module Captions
         def table_caption(caption = nil)
           if caption.nil?

data/lib/phlexi/table/{table_options → options}/descriptions.rb

@@ -2,7 +2,7 @@
 
 module Phlexi
   module Table
-    module TableOptions
+    module Options
       module Descriptions
         def table_description(description = nil)
           if description.nil?

data/lib/phlexi/table/theme.rb

@@ -1,28 +1,24 @@
 module Phlexi
   module Table
-    class Theme
-      include Phlexi::Field::Theme
-
-      DEFAULT_THEME = {
-        wrapper: nil,
-        base: nil,
-        caption: nil,
-        description: nil,
-        header: nil,
-        header_grouping_row: :header_row,
-        header_grouping_cell: :header_row_cell,
-        header_row: nil,
-        header_cell: nil,
-        body_row: nil,
-        body_cell: nil,
-        name_column: nil,
-        align_end: nil,
-        selection_checkbox: nil,
-        actions_row_cell: nil
-      }.freeze
-
-      def theme
-        DEFAULT_THEME
+    class Theme < Phlexi::Field::Theme
+      def self.theme
+        {
+          wrapper: nil,
+          base: nil,
+          caption: nil,
+          description: nil,
+          header: nil,
+          header_grouping_row: :header_row,
+          header_grouping_cell: :header_row_cell,
+          header_row: nil,
+          header_cell: nil,
+          body_row: nil,
+          body_cell: nil,
+          name_column: nil,
+          align_start: nil,
+          align_end: nil,
+          selection_checkbox: nil
+        }.freeze
       end
     end
   end

data/lib/phlexi/table/version.rb

@@ -2,6 +2,6 @@
 
 module Phlexi
   module Table
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/lib/phlexi/table/wrapped_object.rb

@@ -1,20 +1,27 @@
 module Phlexi
   module Table
     class WrappedObject
-      attr_reader :unwrapped
+      attr_reader :unwrapped, :index
 
-      def initialize(object, index:)
+      delegate :field, to: :as_display
+
+      def initialize(object, index:, display_class:)
         @unwrapped = object
         @index = index
+        @display_class = display_class
       end
 
-      def id
-        value_of(:id) || index
+      def identifier
+        @identifier ||= Phlexi::Field.object_primary_key(unwrapped) || (index + 1)
       end
 
       def value_of(key)
         @unwrapped.try(key)
       end
+
+      def as_display
+        @as_display ||= @display_class.new(unwrapped)
+      end
     end
   end
 end

data/lib/phlexi/table.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require "zeitwerk"
+require "phlex"
+require "phlexi-field"
+require "phlexi-display"
 require "active_support/core_ext/object/blank"
 
 module Phlexi
@@ -17,8 +20,6 @@ module Phlexi
       loader.setup
     end
 
-    NIL_VALUE = :__i_phlexi_display_nil_value_i__
-
     class Error < StandardError; end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phlexi-table
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Stefan Froelich
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-08 00:00:00.000000000 Z
+date: 2024-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phlex
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: phlexi-display
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -206,14 +220,17 @@ files:
 - lib/phlexi/table/components/concerns/displays_data.rb
 - lib/phlexi/table/components/concerns/displays_header.rb
 - lib/phlexi/table/components/concerns/groups_columns.rb
+- lib/phlexi/table/components/data_column.rb
+- lib/phlexi/table/components/header_cell.rb
 - lib/phlexi/table/components/options/alignment.rb
-- lib/phlexi/table/components/options/associations.rb
-- lib/phlexi/table/components/options/attachments.rb
 - lib/phlexi/table/components/options/labels.rb
-- lib/phlexi/table/components/options/types.rb
+- lib/phlexi/table/components/selection_cell.rb
+- lib/phlexi/table/components/selection_column.rb
+- lib/phlexi/table/components/sortable_header_cell.rb
+- lib/phlexi/table/display_theme.rb
 - lib/phlexi/table/html.rb
-- lib/phlexi/table/table_options/captions.rb
-- lib/phlexi/table/table_options/descriptions.rb
+- lib/phlexi/table/options/captions.rb
+- lib/phlexi/table/options/descriptions.rb
 - lib/phlexi/table/theme.rb
 - lib/phlexi/table/version.rb
 - lib/phlexi/table/wrapped_object.rb

data/lib/phlexi/table/components/options/associations.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Phlexi
-  module Table
-    module Components
-      module Options
-        module Associations
-          protected
-
-          def association_reflection
-            @association_reflection ||= find_association_reflection
-          end
-
-          def find_association_reflection
-            if sample.class.respond_to?(:reflect_on_association)
-              sample.class.reflect_on_association(key)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/phlexi/table/components/options/attachments.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Phlexi
-  module Table
-    module Components
-      module Options
-        module Attachments
-          protected
-
-          def attachment_reflection
-            @attachment_reflection ||= find_attachment_reflection
-          end
-
-          def find_attachment_reflection
-            if sample.class.respond_to?(:reflect_on_attachment)
-              sample.class.reflect_on_attachment(key)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/phlexi/table/components/options/types.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-require "bigdecimal"
-
-module Phlexi
-  module Table
-    module Components
-      module Options
-        module Types
-          def type(type = nil)
-            if type.nil?
-              options[:as] = options.fetch(:as) { inferred_db_type }
-            else
-              options[:as] = type
-              self
-            end
-          end
-
-          def inferred_db_type
-            @inferred_db_type ||= infer_db_type
-          end
-
-          def inferred_display_component
-            @inferred_display_component ||= infer_display_component
-          end
-
-          private
-
-          def infer_display_component
-            case type
-            when :string, :text
-              infer_string_display_type(key)
-            when :integer, :float, :decimal
-              :number
-            when :date, :datetime, :time
-              :date
-            when :boolean
-              :boolean
-            when :json, :jsonb, :hstore
-              :code
-            else
-              if association_reflection
-                :association
-              elsif attachment_reflection
-                :attachment
-              else
-                :text
-              end
-            end
-          end
-
-          def infer_db_type
-            if sample.class.respond_to?(:columns_hash)
-              # ActiveRecord model
-              column = sample.class.columns_hash[key.to_s]
-              return column.type if column
-            end
-
-            if sample.class.respond_to?(:attribute_types)
-              # ActiveModel::Attributes
-              custom_type = sample.class.attribute_types[key.to_s]
-              return custom_type.type if custom_type&.type
-            end
-
-            # Check if sample responds to the key
-            if sample.respond_to?(key)
-              # Fallback to inferring type from the value
-              return infer_db_type_from_value(sample.send(key))
-            end
-
-            # Default to string if we can't determine the type
-            :string
-          end
-
-          def infer_db_type_from_value(value)
-            case value
-            when Integer
-              :integer
-            when Float
-              :float
-            when BigDecimal
-              :decimal
-            when TrueClass, FalseClass
-              :boolean
-            when Date
-              :date
-            when Time, DateTime
-              :datetime
-            when Hash
-              :json
-            else
-              :string
-            end
-          end
-
-          def infer_string_display_type(key)
-            key = key.to_s.downcase
-
-            return :password if is_password_field?
-
-            custom_type = custom_string_display_type(key)
-            return custom_type if custom_type
-
-            :text
-          end
-
-          def custom_string_display_type(key)
-            custom_mappings = {
-              /url$|^link|^site/ => :url,
-              /^email/ => :email,
-              /phone|tel(ephone)?/ => :phone,
-              /^time/ => :time,
-              /^date/ => :date,
-              /^number|_count$|_amount$/ => :number,
-              /^color/ => :color
-            }
-
-            custom_mappings.each do |pattern, type|
-              return type if key.match?(pattern)
-            end
-
-            nil
-          end
-
-          def is_password_field?
-            key = self.key.to_s.downcase
-
-            exact_matches = ["password"]
-            prefixes = ["encrypted_"]
-            suffixes = ["_password", "_digest", "_hash"]
-
-            exact_matches.include?(key) ||
-              prefixes.any? { |prefix| key.start_with?(prefix) } ||
-              suffixes.any? { |suffix| key.end_with?(suffix) }
-          end
-        end
-      end
-    end
-  end
-end