slack_valid_block_kit 0.1.0

data/lib/slack_valid_block_kit/builder/method_generator.rb

@@ -0,0 +1,86 @@
+module SlackValidBlockKit
+  module Builder
+    module MethodGenerator
+      def self.generate(name, is_typed, required: [], optional: [])
+        args = required.map { |p| "#{p}:" } + optional.map { |p| "#{p}: nil" }
+        first_hash = is_typed ? "{ type: '#{name}' }" : "{}"
+        set_stmts = required.map { |p| "  hash[:#{p}] = #{p}" }
+        set_stmts += optional.map { |p| "  hash[:#{p}] = #{p} unless #{p}.nil?" }
+        <<~EOD
+          def #{name}(#{args.join(', ')})
+            hash = #{first_hash}
+          #{set_stmts.join("\n")}
+            hash
+          end
+        EOD
+      end
+
+      def self.generate_surfaces(indent_level = 0)
+        indent = "  " * indent_level
+        arr = []
+        arr << generate("modal", true, required: %w(title blocks), optional: %w(close submit private_metadata callback_id clear_on_close notify_on_close external_id submit_disabled))
+        arr << generate("home", true, required: %w(blocks), optional: %w(private_metadata callback_id external_id))
+        arr << generate("blocks", false, required: %w(blocks), optional: [])
+        indent + arr.join("\n#{indent}")
+      end
+
+      def self.generate_layouts(indent_level = 0)
+        indent = "  " * indent_level
+        arr = []
+        arr << generate("actions", true, required: %w(elements), optional: %w(block_id))
+        arr << generate("context", true, required: %w(elements), optional: %w(block_id))
+        arr << generate("divider", true, required: [], optional: %w(block_id))
+        arr << generate("file", true, required: %w(elements source), optional: %w(block_id))
+        arr << generate("header", true, required: %w(text), optional: %w(block_id))
+        arr << generate("image", true, required: %w(image_url alt_text), optional: %w(title block_id))
+        arr << generate("input", true, required: %w(label element), optional: %w(dispatch_action block_id hint optional))
+        arr << generate("section", true, required: [], optional: %w(text block_id fields accessory))
+
+        indent + arr.join("\n#{indent}")
+      end
+
+      def self.generate_elements(indent_level = 0)
+        indent = "  " * indent_level
+        arr = []
+        arr << generate("button", true, required: %w(text action_id), optional: %w(url value style confirm accessibility_label))
+        arr << generate("checkboxes", true, required: %w(action_id options), optional: %w(initial_options confirm focus_on_load))
+        arr << generate("datepicker", true, required: %w(action_id), optional: %w(placeholder initial_date confirm focus_on_load))
+        arr << generate("image", true, required: %w(image_url alt_text), optional: [])
+
+        arr << generate("multi_static_select", true, required: %w(placeholder action_id options), optional: %w(option_groups initial_options confirm max_selected_items focus_on_load))
+        arr << generate("multi_external_select", true, required: %w(placeholder action_id), optional: %w(min_query_length initial_options confirm max_selected_items focus_on_load))
+        arr << generate("multi_users_select", true, required: %w(placeholder action_id), optional: %w(initial_users confirm max_selected_items focus_on_load))
+        arr << generate("multi_conversations_select", true, required: %w(placeholder action_id), optional: %w(initial_conversations default_to_current_conversation confirm max_selected_items filter focus_on_load))
+        arr << generate("multi_channels_select", true, required: %w(placeholder action_id), optional: %w(initial_channels confirm max_selected_items focus_on_load))
+
+        arr << generate("overflow", true, required: %w(options action_id), optional: %w(confirm))
+        arr << generate("plain_text_input", true, required: %w(action_id), optional: %w(placeholder initial_value multiline min_length max_length dispatch_action_config focus_on_load))
+        arr << generate("radio_buttons", true, required: %w(options action_id), optional: %w(initial_option confirm focus_on_load))
+
+        arr << generate("static_select", true, required: %w(placeholder action_id options), optional: %w(option_groups initial_option confirm focus_on_load))
+        arr << generate("external_select", true, required: %w(placeholder action_id), optional: %w(min_query_length initial_option confirm focus_on_load))
+        arr << generate("users_select", true, required: %w(placeholder action_id), optional: %w(initial_user confirm focus_on_load))
+        arr << generate("conversations_select", true, required: %w(placeholder action_id), optional: %w(initial_conversation default_to_current_conversation confirm response_url_enabled filter focus_on_load))
+        arr << generate("channels_select", true, required: %w(placeholder action_id), optional: %w(initial_channel confirm response_url_enabled focus_on_load))
+
+        arr << generate("timepicker", true, required: %w(action_id), optional: %w(placeholder initial_time confirm focus_on_load))
+
+        indent + arr.join("\n#{indent}")
+      end
+
+      def self.generate_composition(indent_level = 0)
+        indent = "  " * indent_level
+        arr = []
+        arr << generate("plain_text", true, required: %w(text), optional: %w(emoji))
+        arr << generate("mrkdwn", true, required: %w(text), optional: %w(verbatim))
+        arr << generate("confirmation", false, required: %w(title text confirm deny), optional: %w(style))
+        arr << generate("option", false, required: %w(text value), optional: %w(description url))
+        arr << generate("option_group", false, required: %w(label options), optional: [])
+        arr << generate("dispatch_action_configuration", false, required: [], optional: %w(trigger_actions_on))
+        arr << generate("filter", false, required: [], optional: %w(include exclude_external_shared_channels exclude_bot_users))
+
+        indent + arr.join("\n#{indent}")
+      end
+    end
+  end
+end

data/lib/slack_valid_block_kit/builder/surfaces.rb

@@ -0,0 +1,35 @@
+module SlackValidBlockKit
+  module Builder
+    module Surfaces
+      def modal(title:, blocks:, close: nil, submit: nil, private_metadata: nil, callback_id: nil, clear_on_close: nil, notify_on_close: nil, external_id: nil, submit_disabled: nil)
+        hash = { type: 'modal' }
+        hash[:title] = title
+        hash[:blocks] = blocks
+        hash[:close] = close unless close.nil?
+        hash[:submit] = submit unless submit.nil?
+        hash[:private_metadata] = private_metadata unless private_metadata.nil?
+        hash[:callback_id] = callback_id unless callback_id.nil?
+        hash[:clear_on_close] = clear_on_close unless clear_on_close.nil?
+        hash[:notify_on_close] = notify_on_close unless notify_on_close.nil?
+        hash[:external_id] = external_id unless external_id.nil?
+        hash[:submit_disabled] = submit_disabled unless submit_disabled.nil?
+        hash
+      end
+
+      def home(blocks:, private_metadata: nil, callback_id: nil, external_id: nil)
+        hash = { type: 'home' }
+        hash[:blocks] = blocks
+        hash[:private_metadata] = private_metadata unless private_metadata.nil?
+        hash[:callback_id] = callback_id unless callback_id.nil?
+        hash[:external_id] = external_id unless external_id.nil?
+        hash
+      end
+
+      def blocks(blocks:)
+        hash = {}
+        hash[:blocks] = blocks
+        hash
+      end
+    end
+  end
+end

data/lib/slack_valid_block_kit/builder.rb

@@ -0,0 +1,15 @@
+require "slack_valid_block_kit/builder/compositions"
+require "slack_valid_block_kit/builder/elements"
+require "slack_valid_block_kit/builder/layouts"
+require "slack_valid_block_kit/builder/surfaces"
+
+module SlackValidBlockKit
+  module Builder
+    class Runner
+      include ::SlackValidBlockKit::Builder::Surfaces
+      include ::SlackValidBlockKit::Builder::Layouts
+      include ::SlackValidBlockKit::Builder::Elements
+      include ::SlackValidBlockKit::Builder::Compositions
+    end
+  end
+end

data/lib/slack_valid_block_kit/config.rb

@@ -0,0 +1,13 @@
+module SlackValidBlockKit
+  class Config
+    class << self
+      def skip_validation=(v)
+        @_skip_validation = v
+      end
+
+      def skip_validation
+        @_skip_validation
+      end
+    end
+  end
+end

data/lib/slack_valid_block_kit/validator/base.rb

@@ -0,0 +1,164 @@
+module SlackValidBlockKit::Validator
+  module Base
+    MULTI_SELECT_TYPES = %w(multi_static_select multi_external_select multi_users_select multi_conversations_select multi_channels_select)
+    SELECT_TYPES = %w(static_select external_select users_select conversations_select channels_select)
+    ACTION_ELEMENT_TYPES = %w(button overflow datepicker radio_buttons checkboxes timepicker) + SELECT_TYPES + MULTI_SELECT_TYPES
+    INPUT_ELEMENT_TYPES = %w(checkboxes datepicker plain_text_input radio_buttons timepicker) + SELECT_TYPES + MULTI_SELECT_TYPES
+    ALL_ELEMENT_TYPES = %w(button overflow datepicker radio_buttons checkboxes timepicker plain_text_input image) + SELECT_TYPES + MULTI_SELECT_TYPES
+    LAYOUT_BLOCKS_FOR_MODAL = %w(actions context divider header image input section)
+    LAYOUT_BLOCKS_FOR_HOME = LAYOUT_BLOCKS_FOR_MODAL
+    LAYOUT_BLOCKS_FOR_MESSAGE = LAYOUT_BLOCKS_FOR_MODAL + %w(file)
+
+    BLOCK_KIT_GROUPS = {
+      action_elements: ACTION_ELEMENT_TYPES,
+      input_elements: INPUT_ELEMENT_TYPES,
+      all_element_types: ALL_ELEMENT_TYPES,
+      plain_text: ["plain_text"],
+      text_objects: %w(plain_text mrkdwn),
+
+      image_or_text: %(plain_text mrkdwn image),
+
+      layout_blocks_for_modal: LAYOUT_BLOCKS_FOR_MODAL,
+      layout_blocks_for_home: LAYOUT_BLOCKS_FOR_HOME,
+      layout_blocks_for_message: LAYOUT_BLOCKS_FOR_MESSAGE,
+
+      modal: ["modal"],
+      top: %w(modal home blocks)
+    }
+
+    def validate(obj, path, types, options = nil)
+      return if obj.nil?
+      type = obj[:type]
+      return unless validate_for_types(type, "#{path}.type", types)
+      self.send("validate_#{type}", obj, "#{path}(#{type})", options)
+      errors_by_path
+    end
+
+    def validate_for(obj, path, clazz_type, required,  only: nil, max: nil, min: nil)
+      if obj.nil?
+        add_error(path, :required) if required
+        return
+      end
+
+      if blank?(obj)
+        add_error(path, :no_item)
+        return
+      end
+
+      if clazz_type == Array
+        if !obj.is_a?(Array)
+          add_error(path, :clazz_type, Array)
+        end
+      elsif clazz_type == :bool
+        if !obj.is_a?(TrueClass) && !obj.is_a?(FalseClass)
+          add_error(path, :clazz_type, :bool)
+        end
+      elsif clazz_type == :array_of_string
+        if !obj.is_a?(Array) || obj.reject { |v| v.class == String }.size > 0
+          add_error(path, :clazz_type, :array_of_string)
+        end
+      else
+        if !obj.is_a?(clazz_type)
+          add_error(path, :clazz_type, clazz_type)
+        end
+      end
+
+      if !only.nil?
+        if obj.is_a?(Array)
+          add_error(path, :only, only) if (obj - only).size > 0
+        else
+          add_error(path, :only, only) if !only.include?(obj)
+        end
+      end
+
+      if !max.nil?
+        if obj.is_a?(Numeric)
+          add_error(path, :max, max) if obj > max
+        else
+          add_error(path, :max_size, max) if obj.size > max
+        end
+      end
+
+      if !min.nil?
+        if obj.is_a?(Numeric)
+          add_error(path, :min, min) if obj < min
+        else
+          add_error(path, :min_size, min) if obj.size < min
+        end
+      end
+    end
+
+    def blank?(v)
+      v.nil? || (countable?(v) ? v.size.zero? : false)
+    end
+
+    def present?(v)
+      v.respond_to?(:size) ? !v.size.zero? : !v.nil?
+    end
+
+    def countable?(v)
+      v.is_a?(Array) || v.is_a?(Hash) || v.is_a?(String)
+    end
+
+    def validate_for_types(type, path, types)
+      if type.nil?
+        add_error(path, :required)
+        return false
+      end
+
+      return true if types.nil?
+
+      if !BLOCK_KIT_GROUPS[types].include?(type.to_s)
+        add_error(path, :invalid_type)
+        return false
+      end
+      true
+    end
+
+    def validate_for_properties(obj, path, properties)
+      other_properties = obj.keys - properties
+      if present?(other_properties)
+        add_error(path, :invalid_properties, other_properties)
+        false
+      else
+        true
+      end
+    end
+
+    def validate_for_block_id(block_id, path)
+      validate_for(block_id, path, String, false, max: 255)
+      unless block_id.nil?
+        path_by_block_id[block_id] ||= []
+        path_by_block_id[block_id] << path
+      end
+    end
+
+    def validate_for_action_id(action_id, path)
+      validate_for(action_id, path, String, true, max: 255)
+      unless action_id.nil?
+        path_by_action_id[action_id] ||= []
+        path_by_action_id[action_id] << path
+      end
+    end
+
+    def validate_for_plain_text(obj, path, required, size)
+      validate_for(obj, path, Hash, required)
+      validate(obj, path, :plain_text, { text_size: size })
+    end
+
+    def validate_for_text_objects(obj, path, required, size)
+      validate_for(obj, path, Hash, required)
+      validate(obj, path, :text_objects, { text_size: size }) if present?(obj)
+    end
+
+    def validate_for_focus_on_load(obj, path)
+      validate_for(obj, path, :bool, false)
+      focus_on_load_by_path[path] = true if obj
+    end
+
+    private def add_error(path, kind, option = nil)
+      errors_by_path[path] ||= []
+      errors_by_path[path] << ::SlackValidBlockKit::Validator::Error.new(kind, option)
+    end
+  end
+end

data/lib/slack_valid_block_kit/validator/composition.rb

@@ -0,0 +1,82 @@
+module SlackValidBlockKit::Validator
+  module Composition
+    PLAIN_TEXT_PROPERTIES = %i(type text emoji)
+    MRKDWN_PROPERTIES = %i(type text verbatim)
+    CONFIRMATION_PROPERTIES = %i(title text confirm deny style)
+    OPTION_PROPERTIES = %i(text value description)
+    OPTION_OF_OVERFLOW_PROPERTIES = %i(text value description url)
+    OPTION_GROUP_PROPERTIES = %i(label options)
+    FILTER_PROPERTIES = %i(include exclude_external_shared_channels exclude_bot_users)
+    DISPATCH_ACTION_CONFIGURATION_PROPERTIES = %i(trigger_actions_on)
+
+    def validate_plain_text(hash, path, options = nil)
+      validate_for_properties(hash, path, PLAIN_TEXT_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["plain_text"])
+      max = options && options[:text_size]
+      validate_for(hash[:text], "#{path}.text", String, true, max: max)
+      validate_for(hash[:emoji], "#{path}.emoji", :bool, false)
+    end
+
+    def validate_mrkdwn(hash, path, options = nil)
+      validate_for_properties(hash, path, MRKDWN_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["mrkdwn"])
+      max = options && options[:text_size]
+      validate_for(hash[:text], "#{path}.text", String, true, max: max)
+      validate_for(hash[:verbatim], "#{path}.verbatim", :bool, false)
+    end
+
+    def validate_confirmation(hash, path, options = nil)
+      validate_for_properties(hash, path, CONFIRMATION_PROPERTIES)
+
+      validate_for_plain_text(hash[:title], "#{path}.title", true, 100)
+      validate_for_text_objects(hash[:text], "#{path}.text", true, 300)
+      validate_for_plain_text(hash[:confirm], "#{path}.confirm", true, 30)
+      validate_for_plain_text(hash[:deny], "#{path}.deny", true, 30)
+
+      validate_for(hash[:style], "#{path}.style", String, false, only: %w(danger primary))
+    end
+
+    def validate_option(hash, path, options)
+      if options[:actoin_type] == "overflow"
+        validate_for_properties(hash, path, OPTION_OF_OVERFLOW_PROPERTIES)
+      else
+        validate_for_properties(hash, path, OPTION_PROPERTIES)
+      end
+
+      if options[:text_type] == :text_objects
+        validate_for_text_objects(hash[:text], "#{path}.text", true, 75)
+      else
+        validate_for_plain_text(hash[:text], "#{path}.text", true, 75)
+      end
+      validate_for(hash[:value], "#{path}.value", String, true, max: 75)
+      validate_for_plain_text(hash[:description], "#{path}.description", false, 75)
+      validate_for_plain_text(hash[:url], "#{path}.url", false, 3000)
+    end
+
+    def validate_option_group(hash, path, options = nil)
+      validate_for_properties(hash, path, OPTION_GROUP_PROPERTIES)
+
+      validate_for_plain_text(hash[:label], "#{path}.label", true, 75)
+      validate_for(hash[:options], "#{path}.options", Array, true, max: 100)
+      Array(hash[:options]).each_with_index do |v, i|
+        validate_option(v, "#{path}.options[#{i}]")
+      end
+    end
+
+    def validate_dispatch_action_config(hash, path, options = nil)
+      validate_for_properties(hash, path, DISPATCH_ACTION_CONFIGURATION_PROPERTIES)
+      validate_for(hash[:trigger_actions_on], "#{path}.trigger_actions_on", :array_of_string, false, only: %w(on_enter_pressed on_character_entered))
+    end
+
+    def validate_filter(hash, path, options = nil)
+      validate_for_properties(hash, path, FILTER_PROPERTIES)
+      validate_for(hash[:include], "#{path}.include", Array, false, only: %w(im mpim private public))
+      if hash[:include].is_a?(Array) && hash[:include].size == 0
+        add_error("#{path}.include", :empty)
+      end
+
+      validate_for(hash[:exclude_external_shared_channels], "#{path}.exclude_external_shared_channels", :bool, false)
+      validate_for(hash[:exclude_bot_users], "#{path}.exclude_bot_users", :bool, false)
+    end
+  end
+end

data/lib/slack_valid_block_kit/validator/element.rb

@@ -0,0 +1,128 @@
+module SlackValidBlockKit::Validator
+  module Element
+    BUTTON_PROPERTIES = %i(type text action_id url value style confirm accessibility_label)
+    CHECKBOXES_PROPERTIES = %i(type action_id options initial_options confirm focus_on_load)
+    DATEPICKER_PROPERTIES = %i(type action_id placeholder initial_date confirm focus_on_load)
+    IMAGE_PROPERTIES = %i(type image_url alt_text)
+
+    OVERFLOW_PROPERTIES = %i(type action_id options confirm)
+    PLAIN_TEXT_INPUT_PROPERTIES = %i(type action_id placeholder initial_value multiline min_length max_length dispatch_action_config focus_on_load)
+    RADIO_BUTTONS_PROPERTIES = %i(type action_id options initial_option confirm focus_on_load)
+    TIMEPICKER_PROPERTIES = %i(type action_id placeholder initial_time confirm focus_on_load)
+
+    def validate_button(hash, path, options = nil)
+      validate_for_properties(hash, path, BUTTON_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["button"])
+      validate_for_plain_text(hash[:text], "#{path}.text", true, 75)
+      validate_for_action_id(hash[:action_id], "#{path}.action_id")
+      validate_for(hash[:url], "#{path}.url", String, false, max: 3000)
+      validate_for(hash[:value], "#{path}.value", String, false, max: 2000)
+      validate_for(hash[:style], "#{path}.style", String, false, only: %w(primary danger))
+      validate_for(hash[:confirm], "#{path}.confirm", Hash, false)
+      validate_confirmation(hash[:confirm], "#{path}.confirm") unless hash[:confirm].nil?
+      validate_for(hash[:accessibility_label], "#{path}.accessibility_label", String, false, max: 75)
+    end
+
+    def validate_checkboxes(hash, path, options = nil)
+      validate_for_properties(hash, path, CHECKBOXES_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["checkboxes"])
+
+      validate_for(hash[:options], "#{path}.options", Array, true, max: 10)
+      options = Array(hash[:options])
+      options.each_with_index do |e, i|
+        validate_option(e, "#{path}.options[#{i}]", { text_type: :text_objects })
+      end
+      validate_for(hash[:initial_options], "#{path}.initial_options", Array, false, max: options.size, only: options)
+
+      validate_common_for_input(hash, path, options)
+    end
+
+    def validate_datepicker(hash, path, options = nil)
+      validate_for_properties(hash, path, DATEPICKER_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["datepicker"])
+
+      validate_for_plain_text(hash[:placeholder], "#{path}.placeholder", false, 150)
+      validate_for(hash[:initial_date], "#{path}.initial_date", String, false)
+
+      if hash[:initial_date].is_a?(String) && !hash[:initial_date] =~ /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[1-2]\d|3[0-1])$/
+        add_error("#{path}.initial_date", :invalid_format)
+      end
+
+      validate_common_for_input(hash, path, options)
+    end
+
+    def validate_image(hash, path, options = nil)
+      validate_for_properties(hash, path, IMAGE_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["image"])
+
+      validate_for(hash[:image_url], "#{path}.image_url", String, true)
+      validate_for(hash[:alt_text], "#{path}.alt_text", String, true)
+    end
+
+    def validate_overflow(hash, path, options = nil)
+      validate_for_properties(hash, path, OVERFLOW_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["overflow"])
+      validate_for_action_id(hash[:action_id], "#{path}.action_id")
+
+      validate_for(hash[:options], "#{path}.options", Array, true, max: 5, min: 2)
+      options = Array(hash[:options])
+      options.each_with_index do |e, i|
+        validate_option(e, "#{path}.options[#{i}]", { text_type: :text_objects })
+      end
+
+      validate_for(hash[:confirm], "#{path}.confirm", Hash, false)
+      validate_confirmation(hash[:confirm], "#{path}.confirm") unless hash[:confirm].nil?
+    end
+
+    def validate_plain_text_input(hash, path, options = nil)
+      validate_for_properties(hash, path, PLAIN_TEXT_INPUT_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["plain_text_input"])
+      validate_for_action_id(hash[:action_id], "#{path}.action_id")
+      validate_for_plain_text(hash[:placeholder], "#{path}.placeholder", false, 150)
+      validate_for(hash[:initial_value], "#{path}.initial_value", String, false)
+      validate_for(hash[:multiline], "#{path}.multiline", :bool, false)
+      validate_for(hash[:min_length], "#{path}.min_length", Integer, false, max: 3000)
+      validate_for(hash[:max_length], "#{path}.max_length", Integer, false)
+
+      validate_for(hash[:dispatch_action_config], "#{path}.dispatch_action_config", Hash, false)
+      validate_dispatch_action_config(hash[:dispatch_action_config], "#{path}.dispatch_action_config") unless hash[:dispatch_action_config].nil?
+
+      validate_for_focus_on_load(hash[:focus_on_load], "#{path}.focus_on_load")
+    end
+
+    def validate_radio_buttons(hash, path, options = nil)
+      validate_for_properties(hash, path, RADIO_BUTTONS_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["radio_buttons"])
+
+      validate_for(hash[:options], "#{path}.options", Array, true, max: 10)
+      options = Array(hash[:options])
+      options.each_with_index do |e, i|
+        validate_option(e, "#{path}.options[#{i}]", { text_type: :text_objects })
+      end
+      validate_for(hash[:initial_options], "#{path}.initial_options", Array, false, max: options.size, only: options)
+
+      validate_common_for_input(hash, path, options)
+    end
+
+    def validate_timepicker(hash, path, options = nil)
+      validate_for_properties(hash, path, TIMEPICKER_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["timepicker"])
+
+      validate_for_plain_text(hash[:placeholder], "#{path}.placeholder", false, 150)
+      validate_for(hash[:initial_time], "#{path}.initial_time", String, false)
+      if hash[:initial_time].is_a?(String) && !hash[:initial_time] =~ /^(0\d|1[0-2])-[0-5]\d$/
+        add_error("#{path}.initial_time", :invalid_format)
+      end
+
+      validate_common_for_input(hash, path, options)
+    end
+
+    private def validate_common_for_input(hash, path, options = nil)
+      validate_for_action_id(hash[:action_id], "#{path}.action_id")
+
+      validate_for(hash[:confirm], "#{path}.confirm", Hash, false)
+      validate_confirmation(hash[:confirm], "#{path}.confirm") unless hash[:confirm].nil?
+      validate_for_focus_on_load(hash[:focus_on_load], "#{path}.focus_on_load")
+    end
+  end
+end

data/lib/slack_valid_block_kit/validator/error.rb

@@ -0,0 +1,15 @@
+module SlackValidBlockKit::Validator
+  class Error
+    attr_reader :kind, :option
+    def initialize(kind, option = nil)
+      @kind = kind
+      @option = option
+    end
+
+    def self.messages(errors_by_path)
+      errors_by_path.map { |path, errors|
+        errors.map { |e| "#{path} : #{e.kind}" }
+      }.flatten
+    end
+  end
+end

data/lib/slack_valid_block_kit/validator/layout.rb

@@ -0,0 +1,92 @@
+module SlackValidBlockKit::Validator
+  module Layout
+    ACTION_PROPERTIES = %i(type elements block_id)
+    CONTEXT_PROPERTIES = %i(type elements block_id)
+    DIVIDER_PROPERTIES = %i(type block_id)
+    FILE_PROPERTIES = %i(type external_id source block_id)
+    HEADER_PROPERTIES = %i(type text block_id)
+    IMAGE_PROPERTIES = %i(type image_url alt_text title block_id)
+    INPUT_PROPERTIES = %i(type label element dispatch_action block_id hint optional)
+    SECTION_PROPERTIES = %i(type text block_id fields accessory)
+
+    def validate_actions(hash, path, options = nil)
+      validate_for_properties(hash, path, ACTION_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["actions"])
+      validate_for(hash[:elements], "#{path}.elements", Array, true, max: 25)
+      Array(hash[:elements]).each_with_index do |e, i|
+        validate(e, "#{path}.elements[#{i}]", :action_elements)
+      end
+      validate_for_block_id(hash[:block_id], "#{path}.block_id")
+    end
+
+    def validate_context(hash, path, options = nil)
+      validate_for_properties(hash, path, CONTEXT_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["context"])
+      validate_for(hash[:elements], "#{path}.elements", Array, true, max: 10)
+      Array(hash[:elements]).each_with_index do |e, i|
+        validate(e, "#{path}.elements[#{i}]", :image_or_text)
+      end
+      validate_for_block_id(hash[:block_id], "#{path}.block_id")
+    end
+
+    def validate_divider(hash, path, options = nil)
+      validate_for_properties(hash, path, DIVIDER_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["divider"])
+      validate_for_block_id(hash[:block_id], "#{path}.block_id")
+    end
+
+    def validate_file(hash, path, options = nil)
+      validate_for_properties(hash, path, FILE_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["file"])
+      validate_for(hash[:external_id], "#{path}.external_id", String, true)
+      validate_for(hash[:source], "#{path}.source", String, true, only: ["remote"])
+
+      validate_for_block_id(hash[:block_id], "#{path}.block_id")
+    end
+
+    def validate_header(hash, path, options = nil)
+      validate_for_properties(hash, path, HEADER_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["header"])
+      validate_for_plain_text(hash[:text], "#{path}.text", true, 150)
+      validate_for_block_id(hash[:block_id], "#{path}.block_id")
+    end
+
+    def validate_image(hash, path, options = nil)
+      validate_for_properties(hash, path, IMAGE_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["image"])
+      validate_for(hash[:image_url], "#{path}.image_url", String, true, max: 3000)
+      validate_for(hash[:alt_text], "#{path}.alt_text", String, true, max: 2000)
+      validate_for_plain_text(hash[:title], "#{path}.title", false, 2000)
+      validate_for_block_id(hash[:block_id], "#{path}.block_id")
+    end
+
+    def validate_input(hash, path, options = nil)
+      validate_for_properties(hash, path, INPUT_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["input"])
+      validate_for_plain_text(hash[:label], "#{path}.label", true, 2000)
+      validate_for(hash[:element], "#{path}.element", Hash, true)
+      validate(hash[:element], "#{path}.element", :input_elements)
+      validate_for(hash[:dispatch_action], "#{path}.dispatch_action", :bool, false)
+      validate_for_plain_text(hash[:hint], "#{path}.hint", false, 2000)
+      validate_for(hash[:optional], "#{path}.optional", :bool, false)
+
+      validate_for_block_id(hash[:block_id], "#{path}.block_id")
+    end
+
+    def validate_section(hash, path, options = nil)
+      validate_for_properties(hash, path, SECTION_PROPERTIES)
+      validate_for(hash[:type], "#{path}.type", String, true, only: ["section"])
+      validate_for_text_objects(hash[:text], "#{path}.text", false, 3000)
+      validate_for(hash[:fields], "#{path}.fields", Array, false, max: 10)
+      Array(hash[:fields]).each_with_index do |e, i|
+        validate_for_text_objects(e, "#{path}.fields[#{i}]", true, 2000)
+      end
+
+      if hash[:text].nil? && hash[:fields].nil?
+        add_error(path, :require_text_or_fields)
+      end
+      validate_for(hash[:accessory], "#{path}.accessory", Hash, false)
+      validate(hash[:accessory], "#{path}.accessory", :all_element_types)
+    end
+  end
+end