phlexi-display 0.0.1 → 0.0.2

data/lib/phlexi/display/structure/field_builder.rb

@@ -14,26 +14,16 @@ module Phlexi
       # @attr_accessor [Object] value The value of the field.
       class FieldBuilder < Node
         include Phlex::Helpers
-        include FieldOptions::Associations
         include FieldOptions::Themes
-        include FieldOptions::Validators
-        include FieldOptions::Labels
-        include FieldOptions::Hints
-        include FieldOptions::Errors
+        include FieldOptions::Associations
+        include FieldOptions::Attachments
         include FieldOptions::InferredTypes
-        include FieldOptions::Collection
-        include FieldOptions::Placeholder
-        include FieldOptions::Required
-        include FieldOptions::Autofocus
-        include FieldOptions::Disabled
-        include FieldOptions::Readonly
-        include FieldOptions::Length
-        include FieldOptions::MinMax
-        include FieldOptions::Pattern
-        include FieldOptions::Multiple
-        include FieldOptions::Limit
-
-        attr_reader :dom, :options, :object, :input_attributes, :value
+        include FieldOptions::Labels
+        include FieldOptions::Placeholders
+        include FieldOptions::Description
+        # include FieldOptions::Hints
+
+        attr_reader :dom, :options, :object, :value
 
         # Initializes a new FieldBuilder instance.
         #
@@ -41,14 +31,12 @@ module Phlexi
         # @param parent [Structure::Namespace] The parent object.
         # @param object [Object, nil] The associated object.
         # @param value [Object] The initial value for the field.
-        # @param input_attributes [Hash] Default attributes to apply to input fields.
         # @param options [Hash] Additional options for the field.
-        def initialize(key, parent:, object: nil, value: NIL_VALUE, input_attributes: {}, **options)
+        def initialize(key, parent:, object: nil, value: NIL_VALUE, **options)
           super(key, parent: parent)
 
           @object = object
-          @value = determine_initial_value(value)
-          @input_attributes = input_attributes
+          @value = determine_value(value)
           @options = options
           @dom = Structure::DOM.new(field: self)
         end
@@ -61,175 +49,111 @@ module Phlexi
           create_component(Components::Label, :label, **attributes, &)
         end
 
-        # Creates an input tag for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the input.
-        # @return [Components::Input] The input component.
-        def input_tag(**attributes, &)
-          create_component(Components::Input, :input, **attributes, &)
-        end
-
-        def file_input_tag(**attributes, &)
-          create_component(Components::FileInput, :file, **attributes, &)
-        end
-
-        # Creates a checkbox tag for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the checkbox.
-        # @return [Components::Checkbox] The checkbox component.
-        def checkbox_tag(**attributes, &)
-          create_component(Components::Checkbox, :checkbox, **attributes, &)
-        end
-
-        # Creates collection checkboxes for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the collection checkboxes.
-        # @yield [block] The block to be executed for each checkbox.
-        # @return [Components::CollectionCheckboxes] The collection checkboxes component.
-        def collection_checkboxes_tag(**attributes, &)
-          create_component(Components::CollectionCheckboxes, :collection_checkboxes, **attributes, &)
-        end
-
-        # Creates a radio button tag for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the radio button.
-        # @return [Components::RadioButton] The radio button component.
-        def radio_button_tag(**attributes, &)
-          create_component(Components::RadioButton, :radio, **attributes, &)
-        end
-
-        # Creates collection radio buttons for the field.
+        # Creates a Placeholder tag for the field.
         #
-        # @param attributes [Hash] Additional attributes for the collection radio buttons.
-        # @yield [block] The block to be executed for each radio button.
-        # @return [Components::CollectionRadioButtons] The collection radio buttons component.
-        def collection_radio_buttons_tag(**attributes, &)
-          create_component(Components::CollectionRadioButtons, :collection_radio_buttons, **attributes, &)
+        # @param attributes [Hash] Additional attributes for the placeholder.
+        # @return [Components::Placeholder] The placeholder component.
+        def placeholder_tag(**attributes, &)
+          create_component(Components::Placeholder, :placeholder, **attributes, &)
         end
 
-        # Creates a textarea tag for the field.
+        # Creates a Description tag for the field.
         #
-        # @param attributes [Hash] Additional attributes for the textarea.
-        # @return [Components::Textarea] The textarea component.
-        def textarea_tag(**attributes, &)
-          create_component(Components::Textarea, :textarea, **attributes, &)
+        # @param attributes [Hash] Additional attributes for the description.
+        # @return [Components::Description] The description component.
+        def description_tag(**attributes, &)
+          create_component(Components::Description, :description, **attributes, &)
         end
 
-        # Creates a select tag for the field.
+        # Creates a string display tag for the field.
         #
-        # @param attributes [Hash] Additional attributes for the select.
-        # @return [Components::Select] The select component.
-        def select_tag(**attributes, &)
-          create_component(Phlex::UI::Select, :select, **attributes, &)
+        # @param attributes [Hash] Additional attributes for the string display.
+        # @return [Components::String] The string component.
+        def string_tag(**attributes, &)
+          create_component(Components::String, :string, **attributes, &)
         end
 
-        def input_array_tag(**attributes, &)
-          create_component(Components::InputArray, :array, **attributes, &)
-        end
+        # # Creates a text display tag for the field.
+        # #
+        # # @param attributes [Hash] Additional attributes for the text display.
+        # # @return [Components::Text] The text component.
+        # def text_tag(**attributes, &)
+        #   create_component(Components::Text, :text, **attributes, &)
+        # end
 
-        # Creates a hint tag for the field.
+        # Creates a number display tag for the field.
         #
-        # @param attributes [Hash] Additional attributes for the hint.
-        # @return [Components::Hint] The hint component.
-        def hint_tag(**attributes, &)
-          create_component(Components::Hint, :hint, **attributes, &)
+        # @param attributes [Hash] Additional attributes for the number display.
+        # @return [Components::Number] The number component.
+        def number_tag(**attributes, &)
+          create_component(Components::Number, :number, **attributes, &)
         end
 
-        # Creates an error tag for the field.
+        # Creates a datetime display for the field.
         #
-        # @param attributes [Hash] Additional attributes for the error.
-        # @return [Components::Error] The error component.
-        def error_tag(**attributes, &)
-          create_component(Components::Error, :error, **attributes, &)
-        end
-
-        # Creates a full error tag for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the full error.
-        # @return [Components::FullError] The full error component.
-        def full_error_tag(**attributes, &)
-          create_component(Components::FullError, :full_error, **attributes, &)
-        end
+        # @param attributes [Hash] Additional attributes for the datetime display.
+        # @return [Components::DateTime] The datetime component.
+        def datetime_tag(**attributes, &)
+          create_component(Components::DateTime, :datetime, **attributes, &)
+        end
+
+        # # Creates a boolean display tag for the field.
+        # #
+        # # @param attributes [Hash] Additional attributes for the boolean display.
+        # # @return [Components::Boolean] The boolean component.
+        # def boolean_tag(**attributes, &)
+        #   create_component(Components::Boolean, :boolean, **attributes, &)
+        # end
+
+        # # Creates an association display tag for the field.
+        # #
+        # # @param attributes [Hash] Additional attributes for the association display.
+        # # @return [Components::Association] The association component.
+        # def association_tag(**attributes, &)
+        #   create_component(Components::Association, :association, **attributes, &)
+        # end
+
+        # # Creates an attachment display tag for the field.
+        # #
+        # # @param attributes [Hash] Additional attributes for the attachment display.
+        # # @return [Components::Attachment] The attachment component.
+        # def attachment_tag(**attributes, &)
+        #   create_component(Components::Attachment, :attachment, **attributes, &)
+        # end
 
         # Wraps the field with additional markup.
         #
-        # @param inner [Hash] Attributes for the inner wrapper.
         # @param attributes [Hash] Additional attributes for the wrapper.
         # @yield [block] The block to be executed within the wrapper.
         # @return [Components::Wrapper] The wrapper component.
-        def wrapped(inner: {}, **attributes, &)
-          wrapper_class = attributes.delete(:class) || themed(attributes.delete(:theme) || :wrapper)
-          inner[:class] = inner.delete(:class) || themed(inner.delete(:theme) || :inner_wrapper)
-          Components::Wrapper.new(self, class: wrapper_class, inner: inner, **attributes, &)
+        def wrapped(**attributes, &)
+          create_component(Components::Wrapper, :wrapper, **attributes, &)
         end
 
-        # Creates a multi-value field collection.
+        # Creates a repeated field collection.
         #
-        # @param range [Integer, #to_a] The range of keys for each field. If an integer is passed, keys will begin from 1.
+        # @param range [#each] The collection of items to generate displays for.
         # @yield [block] The block to be executed for each item in the collection.
         # @return [FieldCollection] The field collection.
-        def multi(range = nil, &)
-          FieldCollection.new(field: self, range: range, &)
-        end
-
-        # Creates a submit button
-        #
-        # @param attributes [Hash] Additional attributes for the submit.
-        # @return [Components::SubmitButton] The submit button component.
-        def submit_button_tag(**attributes, &)
-          create_component(Components::SubmitButton, :submit_button, **attributes, &)
-        end
-
-        def extract_input(params)
-          raise "field##{dom.name} did not define an input component" unless @field_input_component
-
-          @field_input_component.extract_input(params)
+        def repeated(collection = [], &)
+          FieldCollection.new(field: self, collection:, &)
         end
 
         protected
 
         def create_component(component_class, theme_key, **attributes, &)
-          if component_class.include?(Phlexi::Display::Components::Concerns::HandlesInput)
-            raise "input component already defined: #{@field_input_component.inspect}" if @field_input_component
-
-            attributes = input_attributes.deep_merge(attributes)
-            @field_input_component = component_class.new(self, class: component_class_for(theme_key, attributes), **attributes, &)
-          else
-            component_class.new(self, class: component_class_for(theme_key, attributes), **attributes, &)
-          end
+          component_class.new(self, class: component_class_for(theme_key, attributes), **attributes, &)
         end
 
         def component_class_for(theme_key, attributes)
           attributes.delete(:class) || themed(attributes.key?(:theme) ? attributes.delete(:theme) : theme_key)
         end
 
-        def has_value?
-          value.present?
-        end
-
-        def determine_initial_value(value)
+        def determine_value(value)
           return value unless value == NIL_VALUE
 
-          determine_from_association || determine_value_from_object
-        end
-
-        def determine_value_from_object
           object.respond_to?(key) ? object.public_send(key) : nil
         end
-
-        def determine_from_association
-          return nil unless reflection.present?
-
-          value = object.public_send(key)
-          case reflection.macro
-          when :has_many, :has_and_belongs_to_many
-            value&.map { |v| v.public_send(reflection.klass.primary_key) }
-          when :belongs_to, :has_one
-            value&.public_send(reflection.klass.primary_key)
-          else
-            raise ArgumentError, "Unsupported association type: #{reflection.macro}"
-          end
-        end
       end
     end
   end

data/lib/phlexi/display/structure/field_collection.rb

@@ -16,36 +16,21 @@ module Phlexi
           end
 
           def field(**)
-            @field.class.new(key, input_attributes: @field.input_attributes, **, parent: @field).tap do |field|
+            @field.class.new(key, **, parent: @field).tap do |field|
               yield field if block_given?
             end
           end
-
-          def hidden_field_tag(value: "", force: false)
-            raise "Attempting to build hidden field on non-first field in a collection" unless index == 0 || force
-
-            @field.class
-              .new("hidden", parent: @field)
-              .input_tag(type: :hidden, value:)
-          end
         end
 
-        def initialize(field:, range:, &)
+        def initialize(field:, collection:, &)
           @field = field
-          @range = case range
-          when Range, Array
-            range
-          when Integer
-            1..range
-          else
-            range.to_a
-          end
+          @collection = collection
           each(&) if block_given?
         end
 
         def each(&)
-          @range.each.with_index do |key, index|
-            yield Builder.new(key, @field, index)
+          @collection.each.with_index do |item, index|
+            yield Builder.new(item, @field, index)
           end
         end
       end

data/lib/phlexi/display/structure/namespace.rb

@@ -3,13 +3,18 @@
 module Phlexi
   module Display
     module Structure
-      # A Namespace maps and object to values, but doesn't actually have a value itself. For
+      # A Namespace maps an object to values, but doesn't actually have a value itself. For
       # example, a `User` object or ActiveRecord model could be passed into the `:user` namespace.
-      # To access the values on a Namespace, the `field` can be called for single values.
       #
-      # Additionally, to access namespaces within a namespace, such as if a `User has_many :addresses` in
-      # ActiveRecord, the `namespace` method can be called which will return another Namespace object and
-      # set the current Namespace as the parent.
+      # To access single values on a Namespace, #field can be used.
+      #
+      # To access nested objects within a namespace, two methods are available:
+      #
+      # 1. #nest_one: Used for single nested objects, such as if a `User belongs_to :profile` in
+      #    ActiveRecord. This method returns another Namespace object.
+      #
+      # 2. #nest_many: Used for collections of nested objects, such as if a `User has_many :addresses` in
+      #    ActiveRecord. This method returns a NamespaceCollection object.
       class Namespace < Structure::Node
         include Enumerable
 
@@ -29,21 +34,17 @@ module Phlexi
           end
         end
 
-        def submit_button(key = nil, **attributes, &)
-          field(key || SecureRandom.hex).submit_button_tag(**attributes, &)
-        end
-
         # Creates a `Namespace` child instance with the parent set to the current instance, adds to
         # the `@children` Hash to ensure duplicate child namespaces aren't created, then calls the
         # method on the `@object` to get the child object to pass into that namespace.
         #
         # For example, if a `User#permission` returns a `Permission` object, we could map that to a
-        # form like this:
+        # display like this:
         #
         # ```ruby
-        # Superform :user, object: User.new do |form|
-        #   form.nest_one :permission do |permission|
-        #     form.field :role
+        # Phlexi::Display(user) do |display|
+        #   display.nest_one :profile do |profile|
+        #     render profile.field(:gender).text
         #   end
         # end
         # ```
@@ -56,13 +57,13 @@ module Phlexi
         # an enumerable or array of `Address` classes:
         #
         # ```ruby
-        # Phlexi::Display.new User.new do |form|
-        #   render form.field(:email).input_tag
-        #   render form.field(:name).input_tag
-        #   form.nest_many :addresses do |address|
-        #     render address.field(:street).input_tag
-        #     render address.field(:state).input_tag
-        #     render address.field(:zip).input_tag
+        # Phlexi::Display(user) do |display|
+        #   render display.field(:email).text
+        #   render display.field(:name).text
+        #   display.nest_many :addresses do |address|
+        #     render address.field(:street).text
+        #     render address.field(:state).text
+        #     render address.field(:zip).text
         #   end
         # end
         # ```
@@ -73,19 +74,6 @@ module Phlexi
           create_child(key, NamespaceCollection, collection:, &)
         end
 
-        def extract_input(params)
-          if params.is_a?(Array)
-            each_with_object({}) do |child, hash|
-              hash.merge! child.extract_input(params[0])
-            end
-          else
-            input = each_with_object({}) do |child, hash|
-              hash.merge! child.extract_input(params[key])
-            end
-            {key => input}
-          end
-        end
-
         # Iterates through the children of the current namespace, which could be `Namespace` or `Field`
         # objects.
         def each(&)
@@ -105,7 +93,7 @@ module Phlexi
           end
         end
 
-        # Creates a root Namespace, which is essentially a form.
+        # Creates a root Namespace
         def self.root(*, builder_klass:, **, &)
           new(*, parent: nil, builder_klass:, **, &)
         end

data/lib/phlexi/display/structure/namespace_collection.rb

@@ -16,14 +16,6 @@ module Phlexi
           each(&block)
         end
 
-        def extract_input(params)
-          namespace = build_namespace(0)
-          @block.call(namespace)
-
-          inputs = params[key].map { |param| namespace.extract_input([param]) }
-          {key => inputs}
-        end
-
         private
 
         def each(&)
@@ -32,7 +24,7 @@ module Phlexi
 
         # Builds and memoizes namespaces for the collection.
         #
-        # @return [Array<Hash>] An array of namespace hashes.
+        # @return [Array<Namespace>] An array of namespace objects.
         def namespaces
           @namespaces ||= @collection.map.with_index do |object, key|
             build_namespace(key, object: object)

data/lib/phlexi/display/structure/node.rb

@@ -3,13 +3,19 @@
 module Phlexi
   module Display
     module Structure
-      # Superclass for Namespace and Field classes. Not much to it other than it has a `name`
-      # and `parent` node attribute. Think of it as a tree.
+      # Superclass for Namespace and Field classes. Represents a node in the display tree structure.
+      #
+      # @attr_reader [Symbol] key The node's key
+      # @attr_reader [Node, nil] parent The node's parent in the tree structure
       class Node
         attr_reader :key, :parent
 
+        # Initializes a new Node instance.
+        #
+        # @param key [Symbol, String] The key for the node
+        # @param parent [Node, nil] The parent node
         def initialize(key, parent:)
-          @key = key.to_s.to_sym
+          @key = :"#{key}"
           @parent = parent
         end
       end

data/lib/phlexi/display/version.rb

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

data/lib/phlexi/display.rb

@@ -14,7 +14,6 @@ module Phlexi
         "dom" => "DOM"
       )
       loader.push_dir(File.expand_path("..", __dir__))
-      loader.ignore(File.expand_path("../generators", __dir__))
       loader.setup
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: phlexi-display
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Stefan Froelich
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-24 00:00:00.000000000 Z
+date: 2024-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phlex
@@ -186,43 +186,23 @@ files:
 - lib/phlexi/display.rb
 - lib/phlexi/display/base.rb
 - lib/phlexi/display/components/base.rb
-- lib/phlexi/display/components/checkbox.rb
-- lib/phlexi/display/components/collection_checkboxes.rb
-- lib/phlexi/display/components/collection_radio_buttons.rb
-- lib/phlexi/display/components/concerns/handles_array_input.rb
-- lib/phlexi/display/components/concerns/handles_input.rb
-- lib/phlexi/display/components/concerns/has_options.rb
-- lib/phlexi/display/components/concerns/submits_form.rb
-- lib/phlexi/display/components/error.rb
-- lib/phlexi/display/components/file_input.rb
-- lib/phlexi/display/components/full_error.rb
+- lib/phlexi/display/components/concerns/displays_value.rb
+- lib/phlexi/display/components/date_time.rb
+- lib/phlexi/display/components/description.rb
 - lib/phlexi/display/components/hint.rb
-- lib/phlexi/display/components/input.rb
-- lib/phlexi/display/components/input_array.rb
 - lib/phlexi/display/components/label.rb
-- lib/phlexi/display/components/radio_button.rb
-- lib/phlexi/display/components/select.rb
-- lib/phlexi/display/components/submit_button.rb
-- lib/phlexi/display/components/textarea.rb
+- lib/phlexi/display/components/number.rb
+- lib/phlexi/display/components/placeholder.rb
+- lib/phlexi/display/components/string.rb
 - lib/phlexi/display/components/wrapper.rb
 - lib/phlexi/display/field_options/associations.rb
-- lib/phlexi/display/field_options/autofocus.rb
-- lib/phlexi/display/field_options/collection.rb
-- lib/phlexi/display/field_options/disabled.rb
-- lib/phlexi/display/field_options/errors.rb
+- lib/phlexi/display/field_options/attachments.rb
+- lib/phlexi/display/field_options/description.rb
 - lib/phlexi/display/field_options/hints.rb
 - lib/phlexi/display/field_options/inferred_types.rb
 - lib/phlexi/display/field_options/labels.rb
-- lib/phlexi/display/field_options/length.rb
-- lib/phlexi/display/field_options/limit.rb
-- lib/phlexi/display/field_options/min_max.rb
-- lib/phlexi/display/field_options/multiple.rb
-- lib/phlexi/display/field_options/pattern.rb
-- lib/phlexi/display/field_options/placeholder.rb
-- lib/phlexi/display/field_options/readonly.rb
-- lib/phlexi/display/field_options/required.rb
+- lib/phlexi/display/field_options/placeholders.rb
 - lib/phlexi/display/field_options/themes.rb
-- lib/phlexi/display/field_options/validators.rb
 - lib/phlexi/display/option_mapper.rb
 - lib/phlexi/display/structure/dom.rb
 - lib/phlexi/display/structure/field_builder.rb

data/lib/phlexi/display/components/checkbox.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Phlexi
-  module Display
-    module Components
-      class Checkbox < Input
-        def view_template
-          input(type: :hidden, name: attributes[:name], value: @unchecked_value, autocomplete: "off", hidden: true) if include_hidden?
-          input(**attributes, value: @checked_value)
-        end
-
-        protected
-
-        def build_input_attributes
-          attributes[:type] = :checkbox
-          super
-
-          @include_hidden = attributes.delete(:include_hidden)
-          @checked_value = (attributes.key?(:checked_value) ? attributes.delete(:checked_value) : "1").to_s
-          @unchecked_value = (attributes.key?(:unchecked_value) ? attributes.delete(:unchecked_value) : "0").to_s
-
-          attributes[:value] = @checked_value
-          attributes[:checked] = attributes.fetch(:checked) { checked? }
-        end
-
-        def include_hidden?
-          @include_hidden != false
-        end
-
-        def checked?
-          return false if field.dom.value == @unchecked_value
-
-          if @checked_value == "1" # using default values
-            # handle nils, numbers and booleans
-            !["", "0", "false"].include?(field.dom.value)
-          else # custom value, so explicit match
-            field.dom.value == @checked_value
-          end
-        end
-
-        def normalize_input(...)
-          input_value = super
-          [@checked_value, @unchecked_value].include?(input_value) ? input_value : @unchecked_value
-        end
-      end
-    end
-  end
-end

data/lib/phlexi/display/components/collection_checkboxes.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Phlexi
-  module Display
-    module Components
-      class CollectionCheckboxes < Base
-        include Concerns::HandlesInput
-        include Concerns::HandlesArrayInput
-        include Concerns::HasOptions
-
-        def view_template
-          div(**attributes.slice(:id, :class)) do
-            field.multi(option_mapper.values) do |builder|
-              render builder.hidden_field_tag if builder.index == 0
-
-              field = builder.field(
-                label: option_mapper[builder.key],
-                # We set the attributes here so they are applied to all input components even if the user decides to use a block
-                input_attributes: {
-                  checked_value: builder.key,
-                  include_hidden: false,
-                  checked: selected?(builder.key)
-                }
-              )
-              if block_given?
-                yield field
-              else
-                render field.checkbox_tag
-                render field.label_tag
-              end
-            end
-          end
-        end
-
-        protected
-
-        def build_attributes
-          super
-          attributes[:multiple] = true
-        end
-      end
-    end
-  end
-end