phlexi-table 0.0.1 → 0.2.0

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

@@ -1,158 +0,0 @@
-# frozen_string_literal: true
-
-require "phlex"
-
-module Phlexi
-  module Table
-    module Structure
-      # FieldBuilder class is responsible for building display fields with various options and components.
-      #
-      # @attr_reader [Structure::DOM] dom The DOM structure for the field.
-      # @attr_reader [Hash] options Options for the field.
-      # @attr_reader [Object] object The object associated with the field.
-      # @attr_reader [Hash] attributes Attributes for the field.
-      # @attr_accessor [Object] value The value of the field.
-      class FieldBuilder < Node
-        include Phlex::Helpers
-        include FieldOptions::Themes
-        include FieldOptions::Associations
-        include FieldOptions::Attachments
-        include FieldOptions::InferredTypes
-        include FieldOptions::Labels
-        include FieldOptions::Placeholders
-        include FieldOptions::Description
-        # include FieldOptions::Hints
-
-        attr_reader :dom, :options, :object, :value
-
-        # Initializes a new FieldBuilder instance.
-        #
-        # @param key [Symbol, String] The key for the field.
-        # @param parent [Structure::Namespace] The parent object.
-        # @param object [Object, nil] The associated object.
-        # @param value [Object] The initial value for the field.
-        # @param options [Hash] Additional options for the field.
-        def initialize(key, parent:, object: nil, value: NIL_VALUE, **options)
-          super(key, parent: parent)
-
-          @object = object
-          @value = determine_value(value)
-          @options = options
-          @dom = Structure::DOM.new(field: self)
-        end
-
-        # Creates a label tag for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the label.
-        # @return [Components::Label] The label component.
-        def label_tag(**, &)
-          create_component(Components::Label, :label, **, &)
-        end
-
-        # Creates a Placeholder tag for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the placeholder.
-        # @return [Components::Placeholder] The placeholder component.
-        def placeholder_tag(**, &)
-          create_component(Components::Placeholder, :placeholder, **, &)
-        end
-
-        # Creates a Description tag for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the description.
-        # @return [Components::Description] The description component.
-        def description_tag(**, &)
-          create_component(Components::Description, :description, **, &)
-        end
-
-        # Creates a string display tag for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the string display.
-        # @return [Components::String] The string component.
-        def string_tag(**, &)
-          create_component(Components::String, :string, **, &)
-        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(**, &)
-        #   create_component(Components::Text, :text, **, &)
-        # end
-
-        # Creates a number display tag for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the number display.
-        # @return [Components::Number] The number component.
-        def number_tag(**, &)
-          create_component(Components::Number, :number, **, &)
-        end
-
-        # Creates a datetime display for the field.
-        #
-        # @param attributes [Hash] Additional attributes for the datetime display.
-        # @return [Components::DateTime] The datetime component.
-        def datetime_tag(**, &)
-          create_component(Components::DateTime, :datetime, **, &)
-        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(**, &)
-        #   create_component(Components::Boolean, :boolean, **, &)
-        # 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(**, &)
-        #   create_component(Components::Association, :association, **, &)
-        # 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(**, &)
-        #   create_component(Components::Attachment, :attachment, **, &)
-        # end
-
-        # Wraps the field with additional markup.
-        #
-        # @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(**, &)
-          create_component(Components::Wrapper, :wrapper, **, &)
-        end
-
-        # Creates a repeated field collection.
-        #
-        # @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 repeated(collection = [], &)
-          FieldCollection.new(field: self, collection:, &)
-        end
-
-        protected
-
-        def create_component(component_class, theme_key, **attributes, &)
-          theme_key = attributes.delete(:theme) || theme_key
-          attributes = mix({class: themed(theme_key)}, attributes) unless attributes.key?(:class!)
-          component_class.new(self, **attributes, &)
-        end
-
-        def determine_value(value)
-          return value unless value == NIL_VALUE
-
-          object.respond_to?(key) ? object.public_send(key) : nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Phlexi
-  module Table
-    module Structure
-      class FieldCollection
-        include Enumerable
-
-        class Builder
-          attr_reader :key, :index
-
-          def initialize(key, field, index)
-            @key = key.to_s
-            @field = field
-            @index = index
-          end
-
-          def field(**)
-            @field.class.new(key, **, parent: @field).tap do |field|
-              yield field if block_given?
-            end
-          end
-        end
-
-        def initialize(field:, collection:, &)
-          @field = field
-          @collection = collection
-          each(&) if block_given?
-        end
-
-        def each(&)
-          @collection.each.with_index do |item, index|
-            yield Builder.new(item, @field, index)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-module Phlexi
-  module Table
-    module Structure
-      # 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 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
-
-        attr_reader :builder_klass, :object
-
-        def initialize(key, parent:, builder_klass:, object: nil)
-          super(key, parent: parent)
-          @builder_klass = builder_klass
-          @object = object
-          @children = {}
-          yield self if block_given?
-        end
-
-        def field(key, **attributes)
-          create_child(key, attributes.delete(:builder_klass) || builder_klass, object: object, **attributes).tap do |field|
-            yield field if block_given?
-          end
-        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
-        # display like this:
-        #
-        # ```ruby
-        # Phlexi::Table(user) do |display|
-        #   display.nest_one :profile do |profile|
-        #     render profile.field(:gender).text
-        #   end
-        # end
-        # ```
-        def nest_one(key, object: nil, &)
-          object ||= object_value_for(key: key)
-          create_child(key, self.class, object:, builder_klass:, &)
-        end
-
-        # Wraps an array of objects in Namespace classes. For example, if `User#addresses` returns
-        # an enumerable or array of `Address` classes:
-        #
-        # ```ruby
-        # Phlexi::Table(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
-        # ```
-        # The object within the block is a `Namespace` object that maps each object within the enumerable
-        # to another `Namespace` or `Field`.
-        def nest_many(key, collection: nil, &)
-          collection ||= Array(object_value_for(key: key))
-          create_child(key, NamespaceCollection, collection:, &)
-        end
-
-        # Iterates through the children of the current namespace, which could be `Namespace` or `Field`
-        # objects.
-        def each(&)
-          @children.values.each(&)
-        end
-
-        def dom_id
-          @dom_id ||= begin
-            id = if object.nil?
-              nil
-            elsif object.class.respond_to?(:primary_key)
-              object.public_send(object.class.primary_key) || :new
-            elsif object.respond_to?(:id)
-              object.id || :new
-            end
-            [key, id].compact.join("_").underscore
-          end
-        end
-
-        # Creates a root Namespace
-        def self.root(*, builder_klass:, **, &)
-          new(*, parent: nil, builder_klass:, **, &)
-        end
-
-        protected
-
-        # Calls the corresponding method on the object for the `key` name, if it exists. For example
-        # if the `key` is `email` on `User`, this method would call `User#email` if the method is
-        # present.
-        #
-        # This method could be overwritten if the mapping between the `@object` and `key` name is not
-        # a method call. For example, a `Hash` would be accessed via `user[:email]` instead of `user.send(:email)`
-        def object_value_for(key:)
-          @object.send(key) if @object.respond_to? key
-        end
-
-        private
-
-        # Checks if the child exists. If it does then it returns that. If it doesn't, it will
-        # build the child.
-        def create_child(key, child_class, **kwargs, &block)
-          @children.fetch(key) { @children[key] = child_class.new(key, parent: self, **kwargs, &block) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Phlexi
-  module Table
-    module Structure
-      class NamespaceCollection < Node
-        include Enumerable
-
-        def initialize(key, parent:, collection: nil, &block)
-          raise ArgumentError, "block is required" unless block.present?
-
-          super(key, parent: parent)
-
-          @collection = collection
-          @block = block
-          each(&block)
-        end
-
-        private
-
-        def each(&)
-          namespaces.each(&)
-        end
-
-        # Builds and memoizes namespaces for the collection.
-        #
-        # @return [Array<Namespace>] An array of namespace objects.
-        def namespaces
-          @namespaces ||= @collection.map.with_index do |object, key|
-            build_namespace(key, object: object)
-          end
-        end
-
-        def build_namespace(index, **)
-          parent.class.new(index, parent: self, builder_klass: parent.builder_klass, **)
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Phlexi
-  module Table
-    module Structure
-      # 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}"
-          @parent = parent
-        end
-      end
-    end
-  end
-end