block-kit 1.0.0

data/lib/block_kit/layout/rich_text.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Layout
+    class RichText < Base
+      self.type = :rich_text
+
+      autoload :Elements, "block_kit/layout/rich_text/elements"
+      autoload :List, "block_kit/layout/rich_text/list"
+      autoload :Preformatted, "block_kit/layout/rich_text/preformatted"
+      autoload :Quote, "block_kit/layout/rich_text/quote"
+      autoload :Section, "block_kit/layout/rich_text/section"
+
+      SUPPORTED_ELEMENTS = [
+        RichText::List,
+        RichText::Preformatted,
+        RichText::Quote,
+        RichText::Section
+      ].freeze
+
+      attribute :elements, Types::Array.of(Types::Blocks.new(*SUPPORTED_ELEMENTS))
+      validates :elements, presence: true, "block_kit/validators/associated": true
+      fixes :elements, associated: true
+
+      dsl_method :elements, as: :list, type: RichText::List
+      dsl_method :elements, as: :preformatted, type: RichText::Preformatted
+      dsl_method :elements, as: :quote, type: RichText::Quote
+      dsl_method :elements, as: :section, type: RichText::Section
+
+      alias_method :rich_text_list, :list
+      alias_method :rich_text_preformatted, :preformatted
+      alias_method :rich_text_quote, :quote
+      alias_method :rich_text_section, :section
+
+      def initialize(attributes = {})
+        attributes = attributes.with_indifferent_access
+        attributes[:elements] ||= []
+
+        super
+      end
+
+      def append(element)
+        elements << element
+
+        self
+      end
+
+      def as_json(*)
+        super.merge(elements: elements&.map(&:as_json)).compact
+      end
+    end
+  end
+end

data/lib/block_kit/layout/section.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Layout
+    class Section < Base
+      self.type = :section
+
+      MAX_TEXT_LENGTH = 3000
+      MAX_FIELDS = 10
+      MAX_FIELD_TEXT_LENGTH = 2000
+      SUPPORTED_ELEMENTS = [
+        Elements::Button,
+        Elements::ChannelsSelect,
+        Elements::Checkboxes,
+        Elements::ConversationsSelect,
+        Elements::DatePicker,
+        Elements::ExternalSelect,
+        Elements::Image,
+        Elements::MultiChannelsSelect,
+        Elements::MultiConversationsSelect,
+        Elements::MultiExternalSelect,
+        Elements::MultiStaticSelect,
+        Elements::MultiUsersSelect,
+        Elements::Overflow,
+        Elements::RadioButtons,
+        Elements::StaticSelect,
+        Elements::TimePicker,
+        Elements::UsersSelect,
+        Elements::WorkflowButton
+      ].freeze
+
+      attribute :text, Types::Generic.of_type(Composition::Text)
+      attribute :fields, Types::Array.of(Composition::Text)
+      attribute :accessory, Types::Blocks.new(*SUPPORTED_ELEMENTS)
+      attribute :expand, :boolean
+
+      validates :text, length: {maximum: MAX_TEXT_LENGTH}, presence: {allow_nil: true}
+      fixes :text, truncate: {maximum: MAX_TEXT_LENGTH}
+
+      validates :fields, length: {maximum: MAX_FIELDS, message: "is too long (maximum is %{count} fields)"}, presence: {allow_nil: true}
+      fixes :fields, truncate: {maximum: MAX_FIELDS}
+      fix :truncate_long_fields
+      fix :remove_blank_fields
+
+      validates :accessory, "block_kit/validators/associated": true
+      fixes :accessory, associated: true
+
+      validate :has_text_or_fields
+      validate :fields_are_valid
+
+      def expand?
+        !!expand
+      end
+
+      dsl_method :text, as: :mrkdwn, type: Composition::Mrkdwn, required_fields: [:text], yields: false
+      dsl_method :text, as: :plain_text, type: Composition::PlainText, required_fields: [:text], yields: false
+      dsl_method :fields, as: :mrkdwn_field, type: Composition::Mrkdwn, required_fields: [:text], yields: false
+      dsl_method :fields, as: :plain_text_field, type: Composition::PlainText, required_fields: [:text], yields: false
+      dsl_method :accessory, as: :button, type: Elements::Button, required_fields: [:text]
+      dsl_method :accessory, as: :channels_select, type: Elements::ChannelsSelect
+      dsl_method :accessory, as: :checkboxes, type: Elements::Checkboxes
+      dsl_method :accessory, as: :conversations_select, type: Elements::ConversationsSelect
+      dsl_method :accessory, as: :datepicker, type: Elements::DatePicker
+      dsl_method :accessory, as: :external_select, type: Elements::ExternalSelect
+      dsl_method :accessory, as: :multi_channels_select, type: Elements::MultiChannelsSelect
+      dsl_method :accessory, as: :multi_conversations_select, type: Elements::MultiConversationsSelect
+      dsl_method :accessory, as: :multi_external_select, type: Elements::MultiExternalSelect
+      dsl_method :accessory, as: :multi_static_select, type: Elements::MultiStaticSelect, mutually_exclusive_fields: [:options, :option_groups]
+      dsl_method :accessory, as: :multi_users_select, type: Elements::MultiUsersSelect
+      dsl_method :accessory, as: :overflow, type: Elements::Overflow
+      dsl_method :accessory, as: :radio_buttons, type: Elements::RadioButtons
+      dsl_method :accessory, as: :static_select, type: Elements::StaticSelect, mutually_exclusive_fields: [:options, :option_groups]
+      dsl_method :accessory, as: :timepicker, type: Elements::TimePicker
+      dsl_method :accessory, as: :users_select, type: Elements::UsersSelect
+      dsl_method :accessory, as: :workflow_button, type: Elements::WorkflowButton, required_fields: [:text]
+
+      alias_method :channel_select, :channels_select
+      alias_method :conversation_select, :conversations_select
+      alias_method :date_picker, :datepicker
+      alias_method :multi_channel_select, :multi_channels_select
+      alias_method :multi_conversation_select, :multi_conversations_select
+      alias_method :multi_user_select, :multi_users_select
+      alias_method :overflow_menu, :overflow
+      alias_method :time_picker, :timepicker
+      alias_method :user_select, :users_select
+
+      def field(text:, type: :mrkdwn, verbatim: nil, emoji: nil)
+        case type.to_sym
+        when :mrkdwn
+          mrkdwn_field(text: text, verbatim: verbatim)
+        when :plain_text
+          plain_text_field(text: text, emoji: emoji)
+        else
+          raise ArgumentError, "Invalid field type: #{type} (must be mrkdwn or plain_text)"
+        end
+      end
+
+      def image(alt_text:, image_url: nil, slack_file: nil)
+        if (image_url.nil? && slack_file.nil?) || (image_url && slack_file)
+          raise ArgumentError, "Must provide either image_url or slack_file, but not both."
+        end
+
+        self.accessory = Elements::Image.new(alt_text: alt_text, image_url: image_url, slack_file: slack_file)
+
+        self
+      end
+
+      def as_json(*)
+        super.merge(
+          text: text&.as_json,
+          fields: fields&.map(&:as_json),
+          accessory: accessory&.as_json,
+          expand: expand
+        ).compact
+      end
+
+      private
+
+      # Pure ActiveModel validations get a little too complicated with this combo, as
+      # we need to not only make sure at least one of these two is present, but that
+      # neither is _blank_. It's easier to just do this in a custom validation and
+      # keep the individual validations focused on presence while allowing nil.
+      def has_text_or_fields
+        if text.blank? && fields.blank?
+          errors.add(:base, "must have either text or fields")
+        end
+      end
+
+      def fields_are_valid
+        fields&.each_with_index do |field, i|
+          if field.length > MAX_FIELD_TEXT_LENGTH
+            errors.add("fields[#{i}]", "is invalid: text is too long (maximum is #{MAX_FIELD_TEXT_LENGTH} characters)")
+          elsif field.blank?
+            errors.add("fields[#{i}]", "is invalid: text can't be blank")
+          end
+        end
+      end
+
+      def truncate_long_fields
+        Array(fields).select { |field| field.length > MAX_FIELD_TEXT_LENGTH }.each do |field|
+          field.text = field.text.truncate(MAX_FIELD_TEXT_LENGTH)
+        end
+      end
+
+      def remove_blank_fields
+        Array(fields).select(&:blank?).each do |field|
+          fields.delete(field)
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/layout/video.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module BlockKit
+  module Layout
+    class Video < Base
+      self.type = :video
+
+      MAX_ALT_TEXT_LENGTH = 2000
+      MAX_AUTHOR_NAME_LENGTH = 50
+      MAX_DESCRIPTION_LENGTH = 200
+      MAX_URL_LENGTH = 3000
+      MAX_PROVIDER_NAME_LENGTH = 50
+      MAX_TITLE_LENGTH = 200
+
+      attribute :alt_text, :string
+      attribute :author_name, :string
+      plain_text_attribute :description
+      attribute :provider_icon_url, :string
+      attribute :provider_name, :string
+      plain_text_attribute :title
+      attribute :title_url, :string
+      attribute :thumbnail_url, :string
+      attribute :video_url, :string
+
+      include Concerns::PlainTextEmojiAssignment.new(:description, :title)
+
+      validates :alt_text, presence: true, length: {maximum: MAX_ALT_TEXT_LENGTH}
+      fixes :alt_text, truncate: {maximum: MAX_ALT_TEXT_LENGTH}
+
+      validates :author_name, presence: true, length: {maximum: MAX_AUTHOR_NAME_LENGTH}, allow_nil: true
+      fixes :author_name, truncate: {maximum: MAX_AUTHOR_NAME_LENGTH}, null_value: {error_types: [:blank]}
+
+      validates :description, presence: true, length: {maximum: MAX_DESCRIPTION_LENGTH}, allow_nil: true
+      fixes :description, truncate: {maximum: MAX_DESCRIPTION_LENGTH}, null_value: {error_types: [:blank]}
+
+      validates :provider_icon_url, presence: true, length: {maximum: MAX_URL_LENGTH}, format: {with: URI::DEFAULT_PARSER.make_regexp(%w[https http]), message: "is not a valid URI"}, allow_nil: true
+      fixes :provider_icon_url, truncate: {maximum: MAX_URL_LENGTH, dangerous: true, omission: ""}, null_value: {error_types: [:blank]}
+
+      validates :provider_name, presence: true, length: {maximum: MAX_PROVIDER_NAME_LENGTH}, allow_nil: true
+      fixes :provider_name, truncate: {maximum: MAX_PROVIDER_NAME_LENGTH}, null_value: {error_types: [:blank]}
+
+      validates :title, presence: true, length: {maximum: MAX_TITLE_LENGTH}
+      fixes :title, truncate: {maximum: MAX_TITLE_LENGTH}
+
+      validates :title_url, presence: true, length: {maximum: MAX_URL_LENGTH}, format: {with: URI::DEFAULT_PARSER.make_regexp(%w[https]), message: "is not a valid HTTPS URI"}, allow_nil: true
+      fixes :title_url, truncate: {maximum: MAX_URL_LENGTH, dangerous: true, omission: ""}, null_value: {error_types: [:blank]}
+
+      validates :thumbnail_url, presence: true, length: {maximum: MAX_URL_LENGTH}, format: {with: URI::DEFAULT_PARSER.make_regexp(%w[https http]), message: "is not a valid URI"}
+      fixes :thumbnail_url, truncate: {maximum: MAX_URL_LENGTH, dangerous: true, omission: ""}
+
+      validates :video_url, presence: true, length: {maximum: MAX_URL_LENGTH}, format: {with: URI::DEFAULT_PARSER.make_regexp(%w[https]), message: "is not a valid HTTPS URI"}
+      fixes :video_url, truncate: {maximum: MAX_URL_LENGTH, dangerous: true, omission: ""}
+
+      def as_json(*)
+        super.merge(
+          alt_text: alt_text,
+          author_name: author_name,
+          description: description&.as_json,
+          provider_icon_url: provider_icon_url,
+          provider_name: provider_name,
+          title: title&.as_json,
+          title_url: title_url,
+          thumbnail_url: thumbnail_url,
+          video_url: video_url
+        ).compact
+      end
+    end
+  end
+end

data/lib/block_kit/layout.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Layout
+    autoload :Base, "block_kit/layout/base"
+
+    autoload :Actions, "block_kit/layout/actions"
+    autoload :Context, "block_kit/layout/context"
+    autoload :Divider, "block_kit/layout/divider"
+    autoload :File, "block_kit/layout/file"
+    autoload :Header, "block_kit/layout/header"
+    autoload :Image, "block_kit/layout/image"
+    autoload :Input, "block_kit/layout/input"
+    autoload :Markdown, "block_kit/layout/markdown"
+    autoload :RichText, "block_kit/layout/rich_text"
+    autoload :Section, "block_kit/layout/section"
+    autoload :Video, "block_kit/layout/video"
+
+    def self.all
+      @all ||= [
+        Actions,
+        Context,
+        Divider,
+        File,
+        Header,
+        Image,
+        Input,
+        Markdown,
+        RichText,
+        Section,
+        Video
+      ].freeze
+    end
+  end
+end

data/lib/block_kit/surfaces/base.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module BlockKit
+  module Surfaces
+    class Base < BlockKit::Base
+      self.type = :surface
+
+      MAX_BLOCKS = 100
+      SUPPORTED_BLOCKS = [
+        Layout::Actions,
+        Layout::Context,
+        Layout::Divider,
+        Layout::Header,
+        Layout::Image,
+        Layout::Input,
+        Layout::RichText,
+        Layout::Section,
+        Layout::Video
+      ]
+
+      attribute :blocks, Types::Array.of(Types::Blocks.new(*SUPPORTED_BLOCKS))
+      attribute :private_metadata, :string
+      attribute :callback_id, :string
+      attribute :external_id, :string
+
+      validates :blocks, presence: true, length: {maximum: MAX_BLOCKS, message: "is too long (maximum is %{count} blocks)"}, "block_kit/validators/associated": true
+      validate :no_unsupported_elements
+      fix :remove_unsupported_elements, dangerous: true
+      fixes :blocks, truncate: {maximum: MAX_BLOCKS, dangerous: true}, associated: true
+
+      validates :private_metadata, length: {maximum: 3000}, allow_nil: true
+      validates :callback_id, length: {maximum: 255}, allow_nil: true
+      validates :external_id, length: {maximum: 255}, allow_nil: true
+      validate :only_one_element_focuses_on_load
+      fix :unset_focus_on_load_on_all_elements
+
+      dsl_method :blocks, as: :actions, type: Layout::Actions
+      dsl_method :blocks, as: :context, type: Layout::Context
+      dsl_method :blocks, as: :divider, type: Layout::Divider, yields: false
+      dsl_method :blocks, as: :header, type: Layout::Header, required_fields: [:text], yields: false
+      dsl_method :blocks, as: :input, type: Layout::Input
+      dsl_method :blocks, as: :rich_text, type: Layout::RichText
+      dsl_method :blocks, as: :section, type: Layout::Section
+      dsl_method :blocks, as: :video, type: Layout::Video, required_fields: [:alt_text, :title, :thumbnail_url, :video_url], yields: false
+
+      def initialize(attributes = {})
+        raise NotImplementedError, "#{self.class} is an abstract class and can't be instantiated." if instance_of?(Base)
+
+        super
+      end
+
+      def image(alt_text:, image_url: nil, slack_file: nil, title: nil, emoji: nil, block_id: nil)
+        if (image_url.nil? && slack_file.nil?) || (image_url && slack_file)
+          raise ArgumentError, "Must provide either image_url or slack_file, but not both."
+        end
+
+        append(Layout::Image.new(image_url: image_url, slack_file: slack_file, alt_text: alt_text, title: title, block_id: block_id, emoji: emoji))
+      end
+
+      # Overridden to return `self`, allowing chaining.
+      def append(block)
+        blocks << block
+
+        self
+      end
+
+      def as_json(*)
+        super.merge(
+          blocks: blocks&.map(&:as_json),
+          private_metadata: private_metadata,
+          callback_id: callback_id,
+          external_id: external_id
+        ).compact
+      end
+
+      private
+
+      def no_unsupported_elements
+        unsupported_elements = unsupported_elements_by_path
+        return if unsupported_elements.empty?
+
+        errors.add(:blocks, "contains unsupported elements")
+
+        unsupported_elements.each do |path, element|
+          errors.add(path, "is invalid: #{element.class.type} is not a supported element for this surface")
+        end
+      end
+
+      # Crawls through deeply nested blocks, looking for blocks that impelement the
+      # BlockKit::Concerns::FocusableOnLoad concern, and ensures that only one of them
+      # has `focus_on_load` set to true.
+      def only_one_element_focuses_on_load
+        focusable_blocks = focused_blocks_by_path
+
+        if focusable_blocks.size > 1
+          errors.add(:blocks, "can't have more than one element with focus_on_load set to true")
+
+          focusable_blocks.each do |path, element|
+            errors.add(path, "is invalid: can't set focus_on_load when other elements have set focus_on_load")
+          end
+        end
+      end
+
+      def unsupported_elements_by_path
+        unsupported_elements = {}
+
+        blocks.each_with_index do |block, index|
+          # Context block elements are globally supported, so we don't need to check them.
+          case block
+          when Layout::Actions
+            block.elements.each_with_index do |element, element_index|
+              unless self.class::SUPPORTED_ELEMENTS.include?(element.class)
+                unsupported_elements["blocks[#{index}].elements[#{element_index}]"] = element
+              end
+            end
+          when Layout::Input
+            if block.element.present? && !self.class::SUPPORTED_ELEMENTS.include?(block.element.class)
+              unsupported_elements["blocks[#{index}].element"] = block.element
+            end
+          when Layout::Section
+            if block.accessory.present? && !self.class::SUPPORTED_ELEMENTS.include?(block.accessory.class)
+              unsupported_elements["blocks[#{index}].accessory"] = block.accessory
+            end
+          end
+        end
+
+        unsupported_elements
+      end
+
+      def focused_blocks_by_path
+        focused_blocks = {}
+
+        blocks.each_with_index do |block, i|
+          case block
+          when Layout::Actions
+            block.elements.each_with_index do |element, ei|
+              if element.respond_to?(:focus_on_load) && element.focus_on_load
+                focused_blocks["blocks[#{i}].elements[#{ei}]"] = element
+              end
+            end
+          when Layout::Input
+            focused_blocks["blocks[#{i}].element"] = block.element if block.element.respond_to?(:focus_on_load) && block.element.focus_on_load
+          when Layout::Section
+            focused_blocks["blocks[#{i}].accessory"] = block.accessory if block.accessory.respond_to?(:focus_on_load) && block.accessory.focus_on_load
+          end
+        end
+
+        focused_blocks
+      end
+
+      def remove_unsupported_elements
+        blocks.each do |block|
+          case block
+          when Layout::Actions
+            block.elements.delete_if { |element| !self.class::SUPPORTED_ELEMENTS.include?(element.class) }
+          when Layout::Input
+            block.element = nil unless self.class::SUPPORTED_ELEMENTS.include?(block.element.class)
+          when Layout::Section
+            block.accessory = nil unless self.class::SUPPORTED_ELEMENTS.include?(block.accessory.class)
+          end
+        end
+      end
+
+      def unset_focus_on_load_on_all_elements
+        focused_blocks_by_path.values.each do |element|
+          element.focus_on_load = false if element.respond_to?(:focus_on_load)
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/surfaces/home.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module BlockKit
+  module Surfaces
+    class Home < Base
+      self.type = :home
+
+      SUPPORTED_ELEMENTS = [
+        Elements::Button,
+        Elements::ChannelsSelect,
+        Elements::Checkboxes,
+        Elements::ConversationsSelect,
+        Elements::DatePicker,
+        Elements::ExternalSelect,
+        Elements::Image,
+        Elements::MultiChannelsSelect,
+        Elements::MultiConversationsSelect,
+        Elements::MultiExternalSelect,
+        Elements::MultiStaticSelect,
+        Elements::MultiUsersSelect,
+        Elements::Overflow,
+        Elements::PlainTextInput,
+        Elements::RadioButtons,
+        Elements::RichTextInput,
+        Elements::StaticSelect,
+        Elements::TimePicker,
+        Elements::UsersSelect
+      ].freeze
+
+      def initialize(attributes = {})
+        attributes = attributes.with_indifferent_access
+        attributes[:blocks] ||= []
+
+        super
+      end
+    end
+  end
+end

data/lib/block_kit/surfaces/message.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module BlockKit
+  module Surfaces
+    class Message < BlockKit::Base
+      self.type = :message
+
+      MAX_BLOCKS = 50
+      SUPPORTED_ELEMENTS = [
+        Elements::Button,
+        Elements::ChannelsSelect,
+        Elements::Checkboxes,
+        Elements::ConversationsSelect,
+        Elements::DatePicker,
+        Elements::DatetimePicker,
+        Elements::ExternalSelect,
+        Elements::Image,
+        Elements::MultiChannelsSelect,
+        Elements::MultiConversationsSelect,
+        Elements::MultiExternalSelect,
+        Elements::MultiStaticSelect,
+        Elements::MultiUsersSelect,
+        Elements::Overflow,
+        Elements::PlainTextInput,
+        Elements::RadioButtons,
+        Elements::StaticSelect,
+        Elements::TimePicker,
+        Elements::UsersSelect,
+        Elements::WorkflowButton
+      ].freeze
+
+      attribute :text, :string
+      attribute :blocks, Types::Array.of(Types::Blocks.new(*Layout.all))
+      attribute :thread_ts, :string
+      attribute :mrkdwn, :boolean
+
+      validates :text, presence: true
+      validates :blocks, length: {maximum: MAX_BLOCKS, message: "is too long (maximum is %{count} blocks)"}, "block_kit/validators/associated": true
+      validate :no_unsupported_elements
+      fix :remove_unsupported_elements, dangerous: true
+      fixes :blocks, truncate: {maximum: MAX_BLOCKS, dangerous: true}, associated: true
+
+      dsl_method :blocks, as: :actions, type: Layout::Actions
+      dsl_method :blocks, as: :context, type: Layout::Context
+      dsl_method :blocks, as: :divider, type: Layout::Divider, yields: false
+      dsl_method :blocks, as: :file, type: Layout::File, required_fields: [:external_id], yields: false
+      dsl_method :blocks, as: :header, type: Layout::Header, required_fields: [:text], yields: false
+      dsl_method :blocks, as: :input, type: Layout::Input
+      dsl_method :blocks, as: :markdown, type: Layout::Markdown, required_fields: [:text], yields: false
+      dsl_method :blocks, as: :rich_text, type: Layout::RichText
+      dsl_method :blocks, as: :section, type: Layout::Section
+      dsl_method :blocks, as: :video, type: Layout::Video, required_fields: [:alt_text, :title, :thumbnail_url, :video_url], yields: false
+
+      def initialize(attributes = {})
+        attributes = attributes.with_indifferent_access
+        attributes[:blocks] ||= []
+
+        super
+      end
+
+      def image(alt_text:, image_url: nil, slack_file: nil, title: nil, emoji: nil, block_id: nil)
+        if (image_url.nil? && slack_file.nil?) || (image_url && slack_file)
+          raise ArgumentError, "Must provide either image_url or slack_file, but not both."
+        end
+
+        append(Layout::Image.new(image_url: image_url, slack_file: slack_file, alt_text: alt_text, title: title, block_id: block_id, emoji: emoji))
+      end
+
+      # Overridden to return `self`, allowing chaining.
+      def append(block)
+        blocks << block
+
+        self
+      end
+
+      def as_json(*)
+        super().except(:type).merge(
+          text: text,
+          blocks: blocks&.map(&:as_json),
+          thread_ts: thread_ts,
+          mrkdwn: mrkdwn
+        ).compact
+      end
+
+      private
+
+      def no_unsupported_elements
+        unsupported_elements = unsupported_elements_by_path
+        return if unsupported_elements.empty?
+
+        errors.add(:blocks, "contains unsupported elements")
+
+        unsupported_elements.each do |path, element|
+          errors.add(path, "is invalid: #{element.class.type} is not a supported element for this surface")
+        end
+      end
+
+      def unsupported_elements_by_path
+        unsupported_elements = {}
+
+        blocks.each_with_index do |block, index|
+          # Context block elements are globally supported, so we don't need to check them.
+          case block
+          when Layout::Actions
+            block.elements.each_with_index do |element, element_index|
+              unless SUPPORTED_ELEMENTS.include?(element.class)
+                unsupported_elements["blocks[#{index}].elements[#{element_index}]"] = element
+              end
+            end
+          when Layout::Input
+            if block.element.present? && !SUPPORTED_ELEMENTS.include?(block.element.class)
+              unsupported_elements["blocks[#{index}].element"] = block.element
+            end
+          when Layout::Section
+            if block.accessory.present? && !SUPPORTED_ELEMENTS.include?(block.accessory.class)
+              unsupported_elements["blocks[#{index}].accessory"] = block.accessory
+            end
+          end
+        end
+
+        unsupported_elements
+      end
+
+      def remove_unsupported_elements
+        blocks.each do |block|
+          case block
+          when Layout::Actions
+            block.elements.delete_if { |element| !SUPPORTED_ELEMENTS.include?(element.class) }
+          when Layout::Input
+            block.element = nil unless SUPPORTED_ELEMENTS.include?(block.element.class)
+          when Layout::Section
+            block.accessory = nil unless SUPPORTED_ELEMENTS.include?(block.accessory.class)
+          end
+        end
+      end
+    end
+  end
+end