block-kit 1.0.0

data/lib/block_kit/elements/number_input.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Elements
+    class NumberInput < Base
+      self.type = :number_input
+
+      include Concerns::Dispatchable
+      include Concerns::FocusableOnLoad
+      include Concerns::HasPlaceholder
+      include Concerns::PlainTextEmojiAssignment.new(:placeholder)
+
+      attribute :is_decimal_allowed, :boolean
+      attribute :min_value, :decimal
+      attribute :max_value, :decimal
+      attribute :initial_value, :decimal
+
+      validates :min_value, numericality: {less_than_or_equal_to: :max_value}, allow_nil: true, if: :max_value
+      validates :max_value, numericality: {greater_than_or_equal_to: :min_value}, allow_nil: true, if: :min_value
+      validates :initial_value, numericality: {greater_than_or_equal_to: :min_value}, allow_nil: true, if: :min_value
+      validates :initial_value, numericality: {less_than_or_equal_to: :max_value}, allow_nil: true, if: :max_value
+
+      fixes :initial_value, null_value: {error_types: [:greater_than_or_equal_to, :less_than_or_equal_to]}
+
+      def is_decimal_allowed?
+        !!is_decimal_allowed
+      end
+      alias_method :decimal_allowed?, :is_decimal_allowed?
+
+      def min_value
+        decimal_allowed? ? super : super&.to_i
+      end
+
+      def max_value
+        decimal_allowed? ? super : super&.to_i
+      end
+
+      def initial_value
+        decimal_allowed? ? super : super&.to_i
+      end
+
+      def as_json(*)
+        super.merge(
+          is_decimal_allowed: is_decimal_allowed,
+          initial_value: initial_value.respond_to?(:to_digits) ? initial_value.to_digits : initial_value&.to_i,
+          min_value: min_value.respond_to?(:to_digits) ? min_value.to_digits : min_value&.to_i,
+          max_value: max_value.respond_to?(:to_digits) ? max_value.to_digits : max_value&.to_i
+        ).compact
+      end
+    end
+  end
+end

data/lib/block_kit/elements/overflow.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Elements
+    class Overflow < Base
+      self.type = :overflow
+
+      MAX_OPTIONS = 5
+
+      include Concerns::Confirmable
+
+      attribute :options, Types::Array.of(Composition::OverflowOption)
+      validates :options, presence: true, length: {maximum: MAX_OPTIONS, message: "is too long (maximum is %{count} options)"}, "block_kit/validators/associated": true
+      fixes :options, truncate: {maximum: MAX_OPTIONS, dangerous: true}, associated: true
+
+      dsl_method :options, as: :option, required_fields: [:text, :value], yields: false
+
+      def as_json(*)
+        super.merge(options: options&.map(&:as_json))
+      end
+    end
+  end
+end

data/lib/block_kit/elements/plain_text_input.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/inclusion"
+require "uri"
+
+module BlockKit
+  module Elements
+    class PlainTextInput < Base
+      self.type = :plain_text_input
+
+      include Concerns::Dispatchable
+      include Concerns::FocusableOnLoad
+      include Concerns::HasPlaceholder
+      include Concerns::PlainTextEmojiAssignment.new(:placeholder)
+
+      attribute :initial_value, :string
+      attribute :min_length, :integer
+      attribute :max_length, :integer
+      attribute :multiline, :boolean
+
+      validates :min_length, presence: true, numericality: {only_integer: true}, allow_nil: true
+      validates :max_length, presence: true, numericality: {only_integer: true}, allow_nil: true
+      validate :min_and_max_lengths_are_valid
+
+      validates :initial_value, presence: true, length: {
+        minimum: ->(input) { input.min_length || 0 },
+        maximum: ->(input) { input.max_length || 3000 }
+      }, allow_nil: true
+
+      fixes :initial_value,
+        truncate: {maximum: ->(input) { input.max_length || 3000 }},
+        null_value: {error_types: [:blank, :too_short]}
+
+      def as_json(*)
+        super.merge(
+          initial_value: initial_value,
+          min_length: min_length,
+          max_length: max_length,
+          multiline: multiline
+        ).compact
+      end
+
+      private
+
+      # These validations are more complex than, say, the `number_input` validations due to
+      # the fact that `min_length` can be 0 but `max_length` must be at least 1.
+      def min_and_max_lengths_are_valid
+        if min_length && max_length
+          if min_length > max_length
+            errors.add(:min_length, "must be less than or equal to max_length")
+          elsif max_length < min_length
+            errors.add(:max_length, "must be greater than or equal to min_length")
+          end
+        end
+
+        if min_length && !min_length.in?(0..3000)
+          errors.add(:min_length, "must be in 0..3000")
+        end
+
+        if max_length && !max_length.in?(1..3000)
+          errors.add(:max_length, "must be in 1..3000")
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/elements/radio_buttons.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Elements
+    class RadioButtons < Base
+      self.type = :radio_buttons
+
+      include Concerns::Confirmable
+      include Concerns::HasOptions.new(limit: 10)
+      include Concerns::HasInitialOption
+      include Concerns::FocusableOnLoad
+    end
+  end
+end

data/lib/block_kit/elements/rich_text_input.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module BlockKit
+  module Elements
+    class RichTextInput < Base
+      self.type = :rich_text_input
+
+      include Concerns::Dispatchable
+      include Concerns::FocusableOnLoad
+      include Concerns::HasPlaceholder
+      include Concerns::PlainTextEmojiAssignment.new(:placeholder)
+
+      attribute :initial_value, Types::Generic.of_type(Layout::RichText)
+      validates :initial_value, "block_kit/validators/associated": true, allow_nil: true
+      fixes :initial_value, associated: true
+
+      dsl_method :initial_value
+
+      def as_json(*)
+        super.merge(initial_value: initial_value&.as_json).compact
+      end
+    end
+  end
+end

data/lib/block_kit/elements/select.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Elements
+    class Select < Base
+      include Concerns::Confirmable
+      include Concerns::FocusableOnLoad
+      include Concerns::HasPlaceholder
+      include Concerns::PlainTextEmojiAssignment.new(:placeholder)
+
+      def initialize(attributes = {})
+        raise NotImplementedError, "#{self.class} is an abstract class and can't be instantiated." if instance_of?(Select)
+
+        super
+      end
+    end
+  end
+end

data/lib/block_kit/elements/static_select.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Elements
+    class StaticSelect < Select
+      self.type = :static_select
+
+      include Concerns::HasOptionGroups.new(limit: 100, options_limit: 100)
+      include Concerns::HasInitialOption
+    end
+  end
+end

data/lib/block_kit/elements/time_picker.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Elements
+    class TimePicker < Base
+      self.type = :timepicker
+
+      include Concerns::Confirmable
+      include Concerns::FocusableOnLoad
+      include Concerns::HasPlaceholder
+      include Concerns::PlainTextEmojiAssignment.new(:placeholder)
+
+      attribute :initial_time, :time, precision: 0
+      attribute :timezone, :string
+
+      validate :timezone_is_valid
+      fixes :timezone, null_value: {error_types: [:blank, :invalid]}
+
+      def timezone
+        ActiveSupport::TimeZone[super] if super
+      end
+
+      def as_json(*)
+        super.merge(
+          initial_time: initial_time&.strftime("%H:%M"),
+          timezone: timezone&.name
+        ).compact
+      end
+
+      private
+
+      def timezone_is_valid
+        return if attributes["timezone"].nil?
+
+        if attributes["timezone"].blank?
+          errors.add(:timezone, :blank)
+        else
+          errors.add(:timezone, :invalid, message: "is not a valid timezone") unless ActiveSupport::TimeZone[attributes["timezone"]]
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/elements/url_text_input.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module BlockKit
+  module Elements
+    class URLTextInput < Base
+      self.type = :url_text_input
+
+      include Concerns::Dispatchable
+      include Concerns::FocusableOnLoad
+      include Concerns::HasPlaceholder
+      include Concerns::PlainTextEmojiAssignment.new(:placeholder)
+
+      attribute :initial_value, :string
+      validates :initial_value, presence: true, format: {with: URI::DEFAULT_PARSER.make_regexp, message: "is not a valid URI", allow_blank: true}, allow_nil: true
+      fixes :initial_value, null_value: {error_types: [:blank, :invalid]}
+
+      def as_json(*)
+        super.merge(initial_value: initial_value).compact
+      end
+    end
+  end
+end

data/lib/block_kit/elements/users_select.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Elements
+    class UsersSelect < Select
+      self.type = :users_select
+
+      attribute :initial_user, :string
+      validates :initial_user, presence: true, allow_nil: true
+      fixes :initial_user, null_value: {error_types: [:blank]}
+
+      def as_json(*)
+        super.merge(initial_user: initial_user).compact
+      end
+    end
+  end
+end

data/lib/block_kit/elements/workflow_button.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Elements
+    class WorkflowButton < BaseButton
+      self.type = :workflow_button
+
+      attribute :workflow, Types::Generic.of_type(Composition::Workflow)
+      validates :workflow, presence: true, "block_kit/validators/associated": true
+
+      dsl_method :workflow
+
+      def as_json(*)
+        super.merge(workflow: workflow&.as_json).compact
+      end
+    end
+  end
+end

data/lib/block_kit/elements.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Elements
+    autoload :Base, "block_kit/elements/base"
+    autoload :BaseButton, "block_kit/elements/base_button"
+    autoload :Select, "block_kit/elements/select"
+    autoload :MultiSelect, "block_kit/elements/multi_select"
+    autoload :NumberInput, "block_kit/elements/number_input"
+
+    autoload :Button, "block_kit/elements/button"
+    autoload :ChannelsSelect, "block_kit/elements/channels_select"
+    autoload :Checkboxes, "block_kit/elements/checkboxes"
+    autoload :ConversationsSelect, "block_kit/elements/conversations_select"
+    autoload :DatePicker, "block_kit/elements/date_picker"
+    autoload :DatetimePicker, "block_kit/elements/datetime_picker"
+    autoload :EmailTextInput, "block_kit/elements/email_text_input"
+    autoload :ExternalSelect, "block_kit/elements/external_select"
+    autoload :FileInput, "block_kit/elements/file_input"
+    autoload :Image, "block_kit/elements/image"
+    autoload :MultiChannelsSelect, "block_kit/elements/multi_channels_select"
+    autoload :MultiConversationsSelect, "block_kit/elements/multi_conversations_select"
+    autoload :MultiExternalSelect, "block_kit/elements/multi_external_select"
+    autoload :MultiStaticSelect, "block_kit/elements/multi_static_select"
+    autoload :MultiUsersSelect, "block_kit/elements/multi_users_select"
+    autoload :Overflow, "block_kit/elements/overflow"
+    autoload :PlainTextInput, "block_kit/elements/plain_text_input"
+    autoload :RadioButtons, "block_kit/elements/radio_buttons"
+    autoload :RichTextInput, "block_kit/elements/rich_text_input"
+    autoload :StaticSelect, "block_kit/elements/static_select"
+    autoload :TimePicker, "block_kit/elements/time_picker"
+    autoload :URLTextInput, "block_kit/elements/url_text_input"
+    autoload :UsersSelect, "block_kit/elements/users_select"
+    autoload :WorkflowButton, "block_kit/elements/workflow_button"
+  end
+end

data/lib/block_kit/fixers/associated.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Fixers
+    class Associated < Base
+      def fix(model, fixing_dangerously: false)
+        model.validate
+        errors = errors_for(model)
+
+        return unless errors.any?
+
+        associated = model.public_send(attribute)
+
+        if associated.is_a?(Enumerable)
+          error = errors.find { |e| e.type == :invalid }
+          return unless error
+
+          error.options[:invalid_values].each do |associated|
+            associated.fix_validation_errors(dangerous: fixing_dangerously)
+          end
+        else
+          associated&.fix_validation_errors(dangerous: fixing_dangerously)
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/fixers/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Fixers
+    class Base
+      include ActiveSupport::Callbacks
+
+      def initialize(attribute:, **options)
+        @attribute = attribute.to_sym
+        @dangerous = options.delete(:dangerous)
+      end
+
+      def fix(model, fixing_dangerously: false)
+        raise NotImplementedError, "#{self.class} must implement `fix'"
+      end
+
+      def dangerous?
+        !!@dangerous
+      end
+
+      private
+
+      attr_reader :attribute
+
+      def errors_for(model)
+        Array(model.errors.group_by_attribute[attribute])
+      end
+    end
+  end
+end

data/lib/block_kit/fixers/null_value.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/inclusion"
+
+module BlockKit
+  module Fixers
+    class NullValue < Base
+      def initialize(attribute:, **options)
+        super
+
+        @error_types = options.delete(:error_types) { [:blank] }
+      end
+
+      def fix(model, fixing_dangerously: false)
+        return if dangerous? && !fixing_dangerously
+
+        model.validate
+        errors = errors_for(model)
+
+        return unless errors.any? { |e| error_types.include?(e.type) }
+
+        value = model.attributes[attribute.to_s]
+
+        # First, check if the attribute is an array and if we have an `inclusion` error.
+        # If so, we'll remove invalid values from the array. If the new value is empty
+        # and this fixer is configured to handle `blank` errors, we'll nullify it.
+        if value.is_a?(Enumerable) && (error = errors.find { |e| e.type == :inclusion })
+          new_value = value - error.options[:invalid_values]
+          new_value = new_value.presence if error_types.include?(:blank)
+
+          model.assign_attributes(attribute => new_value)
+        else
+          model.assign_attributes(attribute => nil)
+        end
+      end
+
+      private
+
+      attr_reader :error_types
+    end
+  end
+end

data/lib/block_kit/fixers/truncate.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Fixers
+    class Truncate < Base
+      def initialize(attribute:, **options)
+        super
+
+        @maximum = options.delete(:maximum)
+        @omission = options.delete(:omission)
+      end
+
+      def fix(model, fixing_dangerously: false)
+        return if dangerous? && !fixing_dangerously
+
+        model.validate
+        errors = errors_for(model)
+
+        return unless errors.any? { |e| e.type == :too_long }
+
+        value = model.attributes[attribute.to_s]
+        maximum = @maximum.call(model) if @maximum.is_a?(Proc)
+        maximum ||= @maximum
+
+        new_value = if value.is_a?(Enumerable)
+          value.first(maximum)
+        else
+          value.truncate(maximum, omission: @omission)
+        end
+
+        model.assign_attributes(attribute => new_value)
+      end
+    end
+  end
+end

data/lib/block_kit/fixers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Fixers
+    autoload :Base, "block_kit/fixers/base"
+
+    autoload :Associated, "block_kit/fixers/associated"
+    autoload :NullValue, "block_kit/fixers/null_value"
+    autoload :Truncate, "block_kit/fixers/truncate"
+  end
+end

data/lib/block_kit/layout/actions.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Layout
+    class Actions < Base
+      self.type = :actions
+
+      MAX_ELEMENTS = 25
+      SUPPORTED_ELEMENTS = [
+        Elements::Button,
+        Elements::ChannelsSelect,
+        Elements::Checkboxes,
+        Elements::ConversationsSelect,
+        Elements::DatePicker,
+        Elements::DatetimePicker,
+        Elements::ExternalSelect,
+        Elements::MultiChannelsSelect,
+        Elements::MultiConversationsSelect,
+        Elements::MultiExternalSelect,
+        Elements::MultiStaticSelect,
+        Elements::MultiUsersSelect,
+        Elements::Overflow,
+        Elements::RadioButtons,
+        Elements::RichTextInput,
+        Elements::StaticSelect,
+        Elements::TimePicker,
+        Elements::UsersSelect,
+        Elements::WorkflowButton
+      ]
+
+      def initialize(attributes = {})
+        attributes = attributes.with_indifferent_access
+        attributes[:elements] ||= []
+
+        super
+      end
+
+      attribute :elements, Types::Array.of(Types::Blocks.new(*SUPPORTED_ELEMENTS))
+      validates :elements, presence: true, length: {maximum: MAX_ELEMENTS, message: "is too long (maximum is %{count} elements)"}, "block_kit/validators/associated": true
+      fixes :elements, truncate: {maximum: MAX_ELEMENTS, dangerous: true}, associated: true
+
+      dsl_method :elements, as: :button, type: Elements::Button, required_fields: [:text]
+      dsl_method :elements, as: :channels_select, type: Elements::ChannelsSelect
+      dsl_method :elements, as: :checkboxes, type: Elements::Checkboxes
+      dsl_method :elements, as: :conversations_select, type: Elements::ConversationsSelect
+      dsl_method :elements, as: :datepicker, type: Elements::DatePicker
+      dsl_method :elements, as: :datetimepicker, type: Elements::DatetimePicker
+      dsl_method :elements, as: :external_select, type: Elements::ExternalSelect
+      dsl_method :elements, as: :multi_channels_select, type: Elements::MultiChannelsSelect
+      dsl_method :elements, as: :multi_conversations_select, type: Elements::MultiConversationsSelect
+      dsl_method :elements, as: :multi_external_select, type: Elements::MultiExternalSelect
+      dsl_method :elements, as: :multi_static_select, type: Elements::MultiStaticSelect, mutually_exclusive_fields: [:options, :option_groups]
+      dsl_method :elements, as: :multi_users_select, type: Elements::MultiUsersSelect
+      dsl_method :elements, as: :overflow, type: Elements::Overflow
+      dsl_method :elements, as: :radio_buttons, type: Elements::RadioButtons
+      dsl_method :elements, as: :rich_text_input, type: Elements::RichTextInput
+      dsl_method :elements, as: :static_select, type: Elements::StaticSelect, mutually_exclusive_fields: [:options, :option_groups]
+      dsl_method :elements, as: :timepicker, type: Elements::TimePicker
+      dsl_method :elements, as: :users_select, type: Elements::UsersSelect
+      dsl_method :elements, 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 :datetime_picker, :datetimepicker
+      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 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/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Layout
+    class Base < BlockKit::Base
+      MAX_BLOCK_ID_LENGTH = 255
+
+      attribute :block_id, :string
+      validates :block_id, presence: true, length: {maximum: MAX_BLOCK_ID_LENGTH}, allow_nil: true
+      fixes :block_id, truncate: {maximum: MAX_BLOCK_ID_LENGTH, dangerous: true, omission: ""}, null_value: {error_types: [:blank]}
+
+      def initialize(attributes = {})
+        raise NotImplementedError, "#{self.class} is an abstract class and can't be instantiated." if instance_of?(Base)
+
+        super
+      end
+
+      def as_json(*)
+        super.merge(block_id: block_id).compact
+      end
+    end
+  end
+end

data/lib/block_kit/layout/context.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Layout
+    class Context < Base
+      self.type = :context
+
+      MAX_ELEMENTS = 10
+      SUPPORTED_ELEMENTS = [
+        Elements::Image,
+        Composition::Mrkdwn,
+        Composition::PlainText
+      ].freeze
+
+      attribute :elements, Types::Array.of(Types::Blocks.new(*SUPPORTED_ELEMENTS))
+      validates :elements, presence: true, length: {maximum: MAX_ELEMENTS, message: "is too long (maximum is %{count} elements)"}, "block_kit/validators/associated": true
+      fixes :elements, truncate: {maximum: MAX_ELEMENTS, dangerous: true}, associated: true
+
+      dsl_method :elements, as: :mrkdwn, type: Composition::Mrkdwn, required_fields: [:text], yields: false
+      dsl_method :elements, as: :plain_text, type: Composition::PlainText, required_fields: [:text], yields: false
+
+      def initialize(attributes = {})
+        attributes = attributes.with_indifferent_access
+        attributes[:elements] ||= []
+
+        super
+      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
+
+        append(Elements::Image.new(alt_text: alt_text, image_url: image_url, slack_file: slack_file))
+      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/divider.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Layout
+    class Divider < Base
+      self.type = :divider
+    end
+  end
+end