phlexi-table 0.0.1 → 0.0.2

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      module Concerns
+        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
+          end
+
+          def data_cell_attributes(object)
+            attributes = @attributes.dup
+            case type
+            when :name, :selection
+              attributes["scope"] = "row"
+            end
+            attributes[:class] = tokens(
+              attributes[:class],
+              themed(:"align_#{alignment}"),
+              themed(:"#{type}_column")
+            )
+            attributes
+          end
+
+          private
+
+          def selection_cell_class
+            self.class::SelectionCell
+          end
+
+          def data_cell_class
+            self.class::DataCell
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      module Concerns
+        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
+          end
+
+          def header_cell_attributes
+            attributes = @attributes.dup
+            attributes[:id] = "#{dom_id}_header_cell"
+            attributes[:class] = tokens(
+              attributes[:class],
+              themed(:"align_#{alignment}"),
+              themed(:"#{type}_column")
+            )
+            attributes
+          end
+
+          def colspan = 1
+
+          protected
+
+          def sort_params
+            options[:sort_params]
+          end
+
+          private
+
+          def header_cell_class
+            self.class::HeaderCell
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      module Concerns
+        module GroupsColumns
+          extend ActiveSupport::Concern
+
+          included do
+            attr_reader :columns
+          end
+
+          def initialize(*, **, &)
+            super(*, **)
+
+            @columns = {}
+            yield self if block_given?
+          end
+
+          def column(key, **, &)
+            add_column(parent.column_class.new(key, self, **, &))
+          end
+
+          private
+
+          def add_column(column)
+            raise ArgumentError, "Column '#{column.key}' already exists" if @columns.key?(column.key) || parent.columns.key?(column.key)
+
+            @columns[column.key] = column
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      module Options
+        module Alignment
+          def alignment(alignment = nil)
+            if alignment.nil?
+              options[:alignment] = options.fetch(:alignment) { calculate_alignment }
+            else
+              options[:alignment] = alignment
+              self
+            end
+          end
+
+          private
+
+          def calculate_alignment
+            case type
+            when :integer, :float, :decimal
+              :end
+            else
+              :start
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,23 @@
+# 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/labels.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module Components
+      module Options
+        module Labels
+          def label(label = nil)
+            if label.nil?
+              options[:label] = options.fetch(:label) { calculate_label }
+            else
+              options[:label] = label
+              self
+            end
+          end
+
+          private
+
+          def calculate_label
+            if sample.class.respond_to?(:human_attribute_name)
+              sample.class.human_attribute_name(key.to_s, {base: sample})
+            else
+              key.to_s.humanize
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# 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

data/lib/phlexi/table/html.rb

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

data/lib/phlexi/table/table_options/captions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Table
+    module TableOptions
+      module Captions
+        def table_caption(caption = nil)
+          if caption.nil?
+            options[:caption]
+          else
+            options[:caption] = caption
+            self
+          end
+        end
+
+        def has_table_caption?
+          table_caption.present?
+        end
+      end
+    end
+  end
+end

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

@@ -2,9 +2,9 @@
 
 module Phlexi
   module Table
-    module FieldOptions
-      module Description
-        def description(description = nil)
+    module TableOptions
+      module Descriptions
+        def table_description(description = nil)
           if description.nil?
             options[:description]
           else
@@ -13,8 +13,8 @@ module Phlexi
           end
         end
 
-        def has_description?
-          description.present?
+        def has_table_description?
+          table_description.present?
         end
       end
     end

data/lib/phlexi/table/theme.rb

@@ -0,0 +1,29 @@
+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
+      end
+    end
+  end
+end

data/lib/phlexi/table/version.rb

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

data/lib/phlexi/table/wrapped_object.rb

@@ -0,0 +1,20 @@
+module Phlexi
+  module Table
+    class WrappedObject
+      attr_reader :unwrapped
+
+      def initialize(object, index:)
+        @unwrapped = object
+        @index = index
+      end
+
+      def id
+        value_of(:id) || index
+      end
+
+      def value_of(key)
+        @unwrapped.try(key)
+      end
+    end
+  end
+end

data/lib/phlexi/table.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "zeitwerk"
-require "phlex"
 require "active_support/core_ext/object/blank"
 
 module Phlexi
@@ -9,16 +8,15 @@ module Phlexi
     Loader = Zeitwerk::Loader.new.tap do |loader|
       loader.tag = File.basename(__FILE__, ".rb")
       loader.inflector.inflect(
-        "phlexi-display" => "Phlexi",
+        "phlexi-table" => "Phlexi",
         "phlexi" => "Phlexi",
-        "dom" => "DOM"
+        "html" => "HTML"
       )
+      loader.ignore("#{__dir__}/table/field_options copy")
       loader.push_dir(File.expand_path("..", __dir__))
       loader.setup
     end
 
-    COMPONENT_BASE = (defined?(::ApplicationComponent) ? ::ApplicationComponent : Phlex::HTML)
-
     NIL_VALUE = :__i_phlexi_display_nil_value_i__
 
     class Error < StandardError; end