block-kit 1.0.0

data/lib/block_kit/composition/conversation_filter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    class ConversationFilter < Base
+      self.type = :conversation_filter
+
+      VALID_INCLUDES = [
+        IM = "im",
+        MPIM = "mpim",
+        PUBLIC = "public",
+        PRIVATE = "private"
+      ].freeze
+
+      attribute :include, Types::Set.of(:string)
+      attribute :exclude_external_shared_channels, :boolean
+      attribute :exclude_bot_users, :boolean
+
+      validates :include, presence: true, "block_kit/validators/array_inclusion": {in: VALID_INCLUDES, message: "contains invalid values: %{rejected_values}"}, allow_nil: true
+      fixes :include, null_value: {error_types: [:blank, :inclusion]}
+
+      VALID_INCLUDES.each do |value|
+        define_method(:"include_#{value}?") do
+          !!include&.member?(value)
+        end
+
+        define_method(:"include_#{value}!") do
+          self.include ||= []
+          self.include.add(value)
+        end
+      end
+
+      def as_json(*)
+        super().except(:type).merge(
+          include: include&.to_a,
+          exclude_external_shared_channels: exclude_external_shared_channels,
+          exclude_bot_users: exclude_bot_users
+        ).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition/dispatch_action_config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    class DispatchActionConfig < Base
+      self.type = :dispatch_action_config
+
+      VALID_TRIGGERS = [
+        ON_ENTER_PRESSED = "on_enter_pressed",
+        ON_CHARACTER_ENTERED = "on_character_entered"
+      ].freeze
+
+      attribute :trigger_actions_on, Types::Set.of(:string)
+      validates :trigger_actions_on, presence: true, "block_kit/validators/array_inclusion": {in: VALID_TRIGGERS}
+      fixes :trigger_actions_on, null_value: {error_types: [:inclusion]}
+
+      VALID_TRIGGERS.each do |value|
+        define_method(:"trigger_actions_on_#{value}?") do
+          !!trigger_actions_on&.member?(value)
+        end
+
+        define_method(:"trigger_actions_on_#{value}!") do
+          self.trigger_actions_on ||= []
+          self.trigger_actions_on.add(value)
+        end
+      end
+
+      def as_json(*)
+        super().except(:type).merge(trigger_actions_on: trigger_actions_on&.to_a).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition/input_parameter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    class InputParameter < Base
+      self.type = :input_parameter
+
+      attribute :name, :string
+      attribute :value, :string
+
+      validates :name, presence: true
+      validates :value, presence: true
+
+      def as_json(*)
+        super().except(:type).merge(name: name, value: value).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition/mrkdwn.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    class Mrkdwn < Text
+      self.type = :mrkdwn
+
+      attribute :verbatim, :boolean
+
+      def as_json(*)
+        super.merge(verbatim: verbatim).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition/option.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    class Option < Base
+      self.type = :option
+
+      MAX_TEXT_LENGTH = 75
+      MAX_VALUE_LENGTH = 150
+      MAX_DESCRIPTION_LENGTH = 75
+
+      plain_text_attribute :text
+      attribute :value, :string
+      plain_text_attribute :description
+      attribute :initial, :boolean
+
+      include Concerns::PlainTextEmojiAssignment.new(:text, :description)
+
+      validates :text, presence: true, length: {maximum: MAX_TEXT_LENGTH}
+      fixes :text, truncate: {maximum: MAX_TEXT_LENGTH}
+
+      validates :value, presence: true, length: {maximum: MAX_VALUE_LENGTH}
+      fixes :value, truncate: {maximum: MAX_VALUE_LENGTH, dangerous: true}
+
+      validates :description, presence: true, length: {maximum: MAX_DESCRIPTION_LENGTH}, allow_nil: true
+      fixes :description, truncate: {maximum: MAX_DESCRIPTION_LENGTH}, null_value: [:blank]
+
+      def initial?
+        !!initial
+      end
+
+      def as_json(*)
+        super().except(:type).merge(
+          text: text&.as_json,
+          value: value,
+          description: description&.as_json
+        ).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition/option_group.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    class OptionGroup < Base
+      self.type = :option_group
+
+      MAX_LABEL_LENGTH = 75
+      MAX_OPTIONS = 100
+
+      include Concerns::HasOptions.new(limit: MAX_OPTIONS)
+
+      plain_text_attribute :label
+      validates :label, presence: true, length: {maximum: MAX_LABEL_LENGTH}
+      fixes :label, truncate: {maximum: MAX_LABEL_LENGTH}
+
+      dsl_method :options, as: :option, required_fields: [:text, :value], yields: false
+
+      def as_json(*)
+        super().except(:type).merge(
+          label: label&.as_json,
+          options: options&.map(&:as_json)
+        ).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition/overflow_option.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module BlockKit
+  module Composition
+    class OverflowOption < Option
+      self.type = :overflow_option
+
+      MAX_URL_LENGTH = 3000
+
+      attribute :url, :string
+      validates :url, presence: true, format: {with: URI::DEFAULT_PARSER.make_regexp, message: "is not a valid URI", allow_blank: true}, length: {maximum: MAX_URL_LENGTH}, allow_nil: true
+      fixes :url, truncate: {maximum: MAX_URL_LENGTH, dangerous: true, omission: ""}, null_value: [:blank]
+
+      def as_json(*)
+        super.merge(url: url).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition/plain_text.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    class PlainText < Text
+      self.type = :plain_text
+
+      attribute :emoji, :boolean
+
+      def as_json(*)
+        super.merge(emoji: emoji).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition/slack_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module BlockKit
+  module Composition
+    class SlackFile < Base
+      self.type = :slack_file
+
+      MAX_URL_LENGTH = 3000
+
+      attribute :id, :string
+      attribute :url, :string
+
+      validates :id, presence: true, format: {with: /\AF[A-Z0-9]{8,}\z/, allow_blank: true}, allow_nil: true
+      fixes :id, null_value: [:blank]
+
+      validates :url, presence: true, length: {maximum: MAX_URL_LENGTH}, format: {with: URI::DEFAULT_PARSER.make_regexp(%w[http https]), message: "is not a valid URI", allow_blank: true}, allow_nil: true
+      fixes :url, null_value: [:blank]
+
+      validate :id_or_url_present
+
+      def as_json(*)
+        super().except(:type).merge(id: id, url: url).compact
+      end
+
+      private
+
+      def id_or_url_present
+        if (id.blank? && url.blank?) || (id.present? && url.present?)
+          errors.add(:base, "must have either an id or url, but not both")
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/composition/text.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    class Text < Base
+      MAX_LENGTH = 3000
+
+      attribute :text, :string
+      validates :text, presence: true, length: {maximum: MAX_LENGTH}
+      fixes :text, truncate: {maximum: MAX_LENGTH}
+
+      delegate :blank?, :present?, to: :text
+
+      def length
+        text&.length || 0
+      end
+
+      def truncate(*)
+        dup.tap do |copy|
+          copy.text = text.truncate(*)
+        end
+      end
+
+      def as_json(*)
+        super.merge(text: text)
+      end
+    end
+  end
+end

data/lib/block_kit/composition/trigger.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module BlockKit
+  module Composition
+    class Trigger < Base
+      self.type = :trigger
+
+      MAX_URL_LENGTH = 3000
+
+      attribute :url, :string
+      attribute :customizable_input_parameters, Types::Array.of(Composition::InputParameter)
+
+      validates :url, presence: true, length: {maximum: MAX_URL_LENGTH}, format: {with: URI::DEFAULT_PARSER.make_regexp(%w[http https]), message: "is not a valid URI", allow_blank: true}
+      validates :customizable_input_parameters, presence: true, "block_kit/validators/associated": true, allow_nil: true
+      fixes :customizable_input_parameters, null_value: [:blank]
+
+      dsl_method :customizable_input_parameters, as: :customizable_input_parameter, required_fields: [:name, :value], yields: false
+
+      alias_method :input_parameter, :customizable_input_parameter
+      alias_method :customizable_input_param, :customizable_input_parameter
+      alias_method :input_param, :customizable_input_parameter
+
+      def as_json(*)
+        super().except(:type).merge(
+          url: url,
+          customizable_input_parameters: customizable_input_parameters&.map(&:as_json)
+        ).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition/workflow.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    class Workflow < Base
+      self.type = :workflow
+
+      attribute :trigger, Types::Generic.of_type(Composition::Trigger)
+      validates :trigger, presence: true, "block_kit/validators/associated": true
+      fixes :trigger, associated: true
+
+      dsl_method :trigger
+
+      def as_json(*)
+        super().except(:type).merge(trigger: trigger&.as_json).compact
+      end
+    end
+  end
+end

data/lib/block_kit/composition.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Composition
+    autoload :ConfirmationDialog, "block_kit/composition/confirmation_dialog"
+    autoload :ConversationFilter, "block_kit/composition/conversation_filter"
+    autoload :DispatchActionConfig, "block_kit/composition/dispatch_action_config"
+    autoload :InputParameter, "block_kit/composition/input_parameter"
+    autoload :Mrkdwn, "block_kit/composition/mrkdwn"
+    autoload :OptionGroup, "block_kit/composition/option_group"
+    autoload :Option, "block_kit/composition/option"
+    autoload :OverflowOption, "block_kit/composition/overflow_option"
+    autoload :PlainText, "block_kit/composition/plain_text"
+    autoload :SlackFile, "block_kit/composition/slack_file"
+    autoload :Text, "block_kit/composition/text"
+    autoload :Trigger, "block_kit/composition/trigger"
+    autoload :Workflow, "block_kit/composition/workflow"
+  end
+end

data/lib/block_kit/concerns/confirmable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module Confirmable
+      extend ActiveSupport::Concern
+
+      included do
+        attribute :confirm, Types::Generic.of_type(Composition::ConfirmationDialog)
+        validates :confirm, "block_kit/validators/associated": true, allow_nil: true
+        fixes :confirm, associated: true
+
+        dsl_method :confirm, required_fields: [:title, :text, :confirm, :deny], yields: false
+      end
+
+      def as_json(*)
+        super.merge(confirm: confirm&.as_json).compact
+      end
+    end
+  end
+end

data/lib/block_kit/concerns/conversation_selection.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module ConversationSelection
+      extend ActiveSupport::Concern
+
+      included do
+        attribute :default_to_current_conversation, :boolean
+        attribute :filter, Types::Generic.of_type(Composition::ConversationFilter)
+
+        validates :filter, "block_kit/validators/associated": true, allow_nil: true
+        fixes :filter, associated: true
+
+        dsl_method :filter
+      end
+
+      def as_json(*)
+        super.merge(
+          default_to_current_conversation: default_to_current_conversation,
+          filter: filter&.as_json
+        ).compact
+      end
+    end
+  end
+end

data/lib/block_kit/concerns/dispatchable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module Dispatchable
+      extend ActiveSupport::Concern
+
+      included do
+        attribute :dispatch_action_config, Types::Generic.of_type(Composition::DispatchActionConfig)
+
+        validates :dispatch_action_config, presence: true, "block_kit/validators/associated": true, allow_nil: true
+        fixes :dispatch_action_config, associated: true
+
+        dsl_method :dispatch_action_config
+        alias_method :dispatch_action_configuration, :dispatch_action_config
+        alias_attribute :dispatch_action_configuration, :dispatch_action_config
+      end
+
+      def as_json(*)
+        super.merge(dispatch_action_config: dispatch_action_config&.as_json).compact
+      end
+    end
+  end
+end

data/lib/block_kit/concerns/dsl_generation.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module DSLGeneration
+      extend ActiveSupport::Concern
+
+      class_methods do
+        private
+
+        def dsl_method(attribute, as: nil, type: nil, required_fields: [], mutually_exclusive_fields: [], yields: true)
+          type ||= attribute_types[attribute.to_s]
+          type = Types::Generic.of_type(type) if type.is_a?(Class) && type < BlockKit::Base
+          raise ArgumentError, "attribute #{attribute} does not exist" if type.instance_of?(ActiveModel::Type::Value)
+
+          is_array_attribute = false
+
+          if type.instance_of?(Types::Array)
+            is_array_attribute = true
+            type = type.item_type
+          end
+
+          is_array_attribute ||= attribute_types[attribute.to_s].type == :array
+
+          fields = type.block_class.attribute_names.map(&:to_sym)
+          plain_text_fields = type.block_class.attribute_types.select { |_, v| v.respond_to?(:block_class) && v.block_class == Composition::PlainText }.keys.map(&:to_sym)
+
+          define_method(as || attribute) do |args = {}, &block|
+            args = args.symbolize_keys
+
+            # Return the existing attribute if no args or block are passed and we're not in a custom-named method
+            return super() if args.blank? && block.nil? && as.nil?
+
+            if (missing_required_fields = (required_fields - args.keys)) && missing_required_fields.any?
+              message = "missing keyword#{"s" if missing_required_fields.size > 1}: #{missing_required_fields.map(&:inspect).join(", ")}"
+              raise ArgumentError, message
+            end
+
+            unknown_fields = (args.keys - fields)
+            unknown_fields.delete(:emoji) if plain_text_fields.any?
+
+            if unknown_fields.any?
+              message = "unknown keyword#{"s" if unknown_fields.size > 1}: #{unknown_fields.map(&:inspect).join(", ")}"
+              raise ArgumentError, message
+            end
+
+            mutually_exclusive = mutually_exclusive_fields & args.keys
+            if mutually_exclusive.length > 1
+              message = "mutually exclusive keywords: #{mutually_exclusive.map(&:inspect).join(", ")}"
+              raise ArgumentError, message
+            end
+
+            new_value = if is_array_attribute
+              public_send(:"#{attribute}=", []) if public_send(attribute).nil?
+              public_send(attribute) << type.cast(args)
+              public_send(attribute).last
+            else
+              public_send(:"#{attribute}=", type.cast(args))
+              public_send(attribute)
+            end
+
+            plain_text_fields.each do |field|
+              next unless args.key?(field)
+
+              new_value.public_send(field).emoji = args[:emoji] if args.key?(:emoji)
+            end
+
+            block&.call(new_value) if yields
+
+            self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/concerns/external.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module External
+      extend ActiveSupport::Concern
+
+      included do
+        attribute :min_query_length, :integer
+        validates :min_query_length, presence: true, numericality: {only_integer: true, greater_than_or_equal_to: 0}, allow_nil: true
+        fixes :min_query_length, null_value: {error_types: [:greater_than_or_equal_to]}
+      end
+
+      def as_json(*)
+        super.merge(min_query_length: min_query_length).compact
+      end
+    end
+  end
+end

data/lib/block_kit/concerns/focusable_on_load.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module FocusableOnLoad
+      extend ActiveSupport::Concern
+
+      included do
+        attribute :focus_on_load, :boolean
+      end
+
+      def as_json(*)
+        super.merge(focus_on_load: focus_on_load).compact
+      end
+    end
+  end
+end

data/lib/block_kit/concerns/has_initial_option.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module HasInitialOption
+      def initial_option
+        all_options&.reverse&.find(&:initial?)
+      end
+
+      def as_json(*)
+        super.merge(initial_option: initial_option&.as_json).compact
+      end
+
+      private
+
+      def all_options
+        opts = Array(options)
+        opts += Array(option_groups).flat_map(&:options) if respond_to?(:option_groups)
+        opts
+      end
+    end
+  end
+end

data/lib/block_kit/concerns/has_initial_options.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module HasInitialOptions
+      def initial_options
+        all_options&.select(&:initial?)
+      end
+
+      def as_json(*)
+        super.merge(initial_options: initial_options&.map(&:as_json).presence).compact
+      end
+
+      private
+
+      def all_options
+        opts = Array(options)
+        opts += Array(option_groups).flat_map(&:options) if respond_to?(:option_groups)
+        opts
+      end
+    end
+  end
+end

data/lib/block_kit/concerns/has_option_groups.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module HasOptionGroups
+      def self.new(limit:, options_limit:)
+        Module.new do
+          extend ActiveSupport::Concern
+
+          included do
+            include HasOptions.new(limit: options_limit)
+
+            attribute :option_groups, Types::Array.of(Composition::OptionGroup)
+            validates :option_groups, length: {maximum: limit, message: "is too long (maximum is %{count} groups)"}, "block_kit/validators/associated": true
+            fixes :option_groups, truncate: {maximum: limit, dangerous: true}, associated: true
+
+            validate :options_or_option_groups
+
+            dsl_method :option_groups, as: :option_group, required_fields: [:label]
+          end
+
+          def as_json(*)
+            super.merge(option_groups: option_groups&.map(&:as_json)).compact
+          end
+
+          private
+
+          def options_or_option_groups
+            if (options.blank? && option_groups.blank?) || (options.present? && option_groups.present?)
+              errors.add(:base, "must have either options or option groups, not both")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/concerns/has_options.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Concerns
+    module HasOptions
+      def self.new(limit:)
+        Module.new do
+          extend ActiveSupport::Concern
+
+          included do
+            attribute :options, Types::Array.of(Composition::Option)
+            validates :options,
+              presence: {unless: ->(block) { block.respond_to?(:option_groups) }},
+              length: {maximum: limit, message: "is too long (maximum is %{count} options)"},
+              "block_kit/validators/associated": true
+            fixes :options, truncate: {maximum: limit, dangerous: true}, associated: true
+
+            dsl_method :options, as: :option, required_fields: [:text, :value], yields: false
+          end
+
+          def as_json(*)
+            super.merge(options: options&.map(&:as_json))
+          end
+        end
+      end
+    end
+  end
+end