slack-block-kit 0.1.0

data/lib/slack/block_kit/composition_objects/filter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    module CompositionObjects
+      class Filter
+        using Refinements::HashCompact
+        attr_reader :include, :exclude_external_shared_channels, :exclude_bot_users
+
+        def self.[](hash)
+          new.tap do |object|
+            hash[:include].each(&object.include.method(:<<))
+            object.exclude_external_shared_channels! if hash[:exclude_external_shared_channels]
+            object.exclude_bot_users! if hash[:exclude_bot_users]
+          end
+        end
+
+        def initialize
+          @include = TypeRestrictedArray.new(String)
+        end
+
+        def exclude_external_shared_channels!
+          @exclude_external_shared_channels = true
+        end
+
+        def exclude_bot_users!
+          @exclude_bot_users = true
+        end
+
+        def to_h
+          { include: self.include,
+            exclude_external_shared_channels: exclude_external_shared_channels,
+            exclude_bot_users: exclude_bot_users }.compact
+        end
+      end
+    end
+  end
+end

data/lib/slack/block_kit/composition_objects/option.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    module CompositionObjects
+      class Option
+        using Refinements::HashCompact
+        attr_reader :text, :value, :description, :url
+
+        def self.[](hash)
+          new.tap do |object|
+            object.text = hash.fetch(:text)
+            object.value = hash.fetch(:value)
+            object.description = hash[:description] if hash.key?(:description)
+            object.url = hash[:url] if hash.key?(:url)
+          end
+        end
+
+        def text=(obj)
+          raise TypeError, 'text must be a Text Object' unless obj.is_a?(Text)
+          raise RangeError, 'text is max 75 characters' unless obj.text.size <= 75
+
+          @text = obj
+        end
+
+        def value=(obj)
+          raise TypeError, 'value must be a string' unless obj.respond_to?(:to_str)
+          raise RangeError, 'value is max 75 characters' unless obj.size <= 75
+
+          @value = obj.to_s
+        end
+
+        def description=(obj)
+          raise TypeError, 'description must be a Text Object' unless obj.is_a?(Text)
+          raise TypeError, 'description must be plain_text' unless obj.type == :plain_text
+          raise RangeError, 'description is max 75 characters' unless obj.text.size <= 75
+
+          @description = obj
+        end
+
+        def url=(obj)
+          raise TypeError, 'url must be a string' unless url.respond_to?(:to_str)
+          raise RangeError, 'url is max 3000 characters' unless url.size <= 3000
+
+          @url = url.to_s
+        end
+
+        def to_h
+          { text: text.to_h,
+            value: value,
+            description: description&.to_h,
+            url: url }.compact
+        end
+      end
+    end
+  end
+end

data/lib/slack/block_kit/composition_objects/option_group.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    module CompositionObjects
+      class OptionGroup
+        attr_reader :label, :options
+
+        def self.[](hash)
+          new.tap do |object|
+            object.label = hash.fetch(:label)
+            hash[:options].each(&object.options.method(:<<))
+          end
+        end
+
+        def initialize
+          @options = TypeRestrictedArray.new(Option)
+        end
+
+        def label=(obj)
+          raise TypeError, 'label must be a Text Object' unless obj.is_a?(Text)
+          raise RangeError, 'label is max 75 characters' unless obj.text.size <= 75
+
+          @label = obj
+        end
+
+        def to_h
+          { label: label.to_h,
+            options: options.map(&:to_h) }
+        end
+      end
+    end
+  end
+end

data/lib/slack/block_kit/composition_objects/text.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    module CompositionObjects
+      class Text
+        using Refinements::HashCompact
+        attr_reader :type, :text, :emoji, :verbatim
+
+        PLAINTEXT = :plain_text
+        MRKDWN = :mrkdwn
+        NEWLINE = "\n"
+
+        def self.[](hash)
+          new.tap do |object|
+            object.type = hash.keys.find { |key| [PLAINTEXT, MRKDWN].include?(key) }
+            raise ArgumentError, 'type must be `plain_text` or `mrkdwn`' unless object.type
+
+            object.text = hash[object.type]
+            object.emoji! if hash[:emoji]
+            object.verbatim! if hash[:verbatim]
+          end
+        end
+
+        def empty?
+          text&.empty?
+        end
+
+        def emoji!
+          @emoji = true
+        end
+
+        def verbatim!
+          @verbatim = true
+        end
+
+        def type=(type)
+          unless [PLAINTEXT, MRKDWN].include?(type.to_sym)
+            raise ArgumentError, 'type must be `plain_text` or `mrkdwn`'
+          end
+
+          @type = type.to_sym
+        end
+
+        def text=(text)
+          text = text.join(NEWLINE) if text.is_a?(Array)
+          raise TypeError, 'text must be a string' unless text.respond_to?(:to_str)
+
+          @text = text.to_s
+        end
+
+        def to_h
+          { type: type,
+            text: text,
+            emoji: emoji,
+            verbatim: verbatim }.compact
+        end
+      end
+    end
+  end
+end

data/lib/slack/block_kit/element.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    class Element
+      attr_reader :action_id
+
+      def self.populate(hash, object)
+        object.action_id = hash[:action_id] if hash.key?(:action_id)
+        raise ArgumentError, "invalid #{name}" unless object.valid?
+      end
+
+      def self.[](hash)
+        new.tap { |obj| populate(hash, obj) }
+      end
+
+      def action_id=(obj)
+        raise TypeError, 'action_id must be a string' unless action_id.respond_to?(:to_str)
+        raise RangeError, 'action_id must be max 255 characters' unless action_id.size <= 255
+
+        @action_id = obj.to_s
+      end
+
+      def type
+        @type ||= self.class.name
+          .split('::')
+          .last.chomp('Element')
+          .gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      end
+
+      def valid?
+        true
+      end
+
+      def to_h
+        { type: type,
+          action_id: action_id }
+      end
+    end
+  end
+end

data/lib/slack/block_kit/element/button_element.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    class Element
+      class ButtonElement < Element
+        using Refinements::HashCompact
+        attr_reader :text, :style
+        attr_accessor :value
+
+        def self.populate(hash, object)
+          object.text = hash.fetch(:text)
+          object.action_id = hash.fetch(:action_id) if hash[:action_id]
+          object.style = hash.fetch(:style) if hash[:style]
+          object.value = hash.fetch(:value) if hash[:value]
+
+          super(hash, object)
+        end
+
+        def valid?
+          !@text.empty?
+        end
+
+        def text=(obj)
+          raise TypeError, 'text must be a Text Object' unless obj.is_a?(CompositionObjects::Text)
+
+          @text = obj
+        end
+
+        def style=(obj)
+          unless %i( default primary danger ).include?(obj.to_sym)
+            raise ArgumentError, 'style may only be default, primary, or danger'
+          end
+
+          @style = obj.to_sym
+        end
+
+        def to_h
+          super.merge(
+            text: text.to_h,
+            style: style,
+            value: value
+          ).compact
+        end
+      end
+    end
+  end
+end

data/lib/slack/block_kit/element/channels_select_element.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    class Element
+      class ChannelsSelectElement < SelectElement
+        using Refinements::HashCompact
+        attr_reader :initial_channel, :response_url_enabled
+        attr_writer :initial_channel
+
+        def self.populate(hash, object)
+          object.initial_channel = hash[:initial_channel] if hash.key?(:initial_channel)
+          object.response_url_enabled! if hash.key?(:response_url_enabled)
+
+          super(hash, object)
+        end
+
+        def response_url_enabled!
+          @response_url_enabled = true
+        end
+
+        def to_h
+          super.merge(
+            initial_channel: initial_channel,
+            response_url_enabled: response_url_enabled
+          ).compact
+        end
+      end
+    end
+  end
+end

data/lib/slack/block_kit/element/conversations_select_element.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    class Element
+      class ConversationsSelectElement < SelectElement
+        using Refinements::HashCompact
+        attr_reader :initial_conversation, :response_url_enabled, :filter
+        attr_writer :initial_conversation
+
+        def self.populate(hash, object)
+          if hash.key?(:initial_conversation)
+            object.initial_conversation = hash[:initial_conversation]
+          end
+          object.response_url_enabled! if hash.key?(:response_url_enabled)
+          object.filter = hash[:filter] if hash.key?(:filter)
+
+          super(hash, object)
+        end
+
+        def response_url_enabled!
+          @response_url_enabled = true
+        end
+
+        def filter=(obj)
+          unless obj.is_a?(CompositionObjects::Filter)
+            raise TypeError, 'confirm must be a Filter Object'
+          end
+
+          @filter = obj
+        end
+
+        def to_h
+          super.merge(
+            initial_conversation: initial_conversation,
+            response_url_enabled: response_url_enabled,
+            filter: filter&.to_h
+          ).compact
+        end
+      end
+    end
+  end
+end

data/lib/slack/block_kit/element/date_picker_element.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    class Element
+      class DatePickerElement < Element
+        using Refinements::HashCompact
+        attr_reader :initial_date, :placeholder, :confirm
+
+        def self.populate(hash, object)
+          object.placeholder = hash.fetch(:placeholder) if hash[:placeholder]
+          object.confirm = hash.fetch(:confirm) if hash[:confirm]
+          object.initial_date = hash.fetch(:initial_date) if hash[:initial_date]
+
+          super(hash, object)
+        end
+
+        def type
+          'datepicker'
+        end
+
+        def placeholder=(obj)
+          raise TypeError, 'placeholder must be a Text Object' unless obj.is_a?(CompositionObjects::Text)
+          raise TypeError, 'placeholder must be plain_text' unless obj.type == :plain_text
+          raise RangeError, 'placeholder is max 150 characters' unless obj.text.size <= 150
+
+          @placeholder = obj
+        end
+
+        def confirm=(obj)
+          unless obj.is_a?(CompositionObjects::ConfirmationDialog)
+            raise TypeError, 'confirm must be a ConfirmationDialog Object'
+          end
+
+          @confirm = obj
+        end
+
+        def initial_date=(date)
+          date = date.strftime('%Y-%m-%d') if date.is_a?(Time)
+          raise TypeError, 'initial_date must be a string' unless date.respond_to?(:to_str)
+          raise TypeError, 'initial_date must be YYYY-MM-DD' unless date.match?(/\d{4}-\d{2}-\d{2}/)
+
+          @initial_date = date.to_s
+        end
+
+        def to_h
+          super.merge(
+            initial_date: initial_date,
+            placeholder: placeholder&.to_h,
+            confirm: confirm&.to_h
+          ).compact
+        end
+      end
+    end
+  end
+end

data/lib/slack/block_kit/element/external_select_element.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Slack
+  module BlockKit
+    class Element
+      class ExternalSelectElement < SelectElement
+        using Refinements::HashCompact
+        attr_reader :initial_option, :min_query_length
+
+        def self.populate(hash, object)
+          object.initial_option = hash[:initial_option] if hash.key?(:initial_option)
+          object.min_query_length = hash[:min_query_length] if hash.key?(:min_query_length)
+
+          super(hash, object)
+        end
+
+        def initial_option=(obj)
+          raise TypeError, 'initial_option must be a Option Object' unless obj.is_a?(CompositionObjects::Option)
+
+          @initial_option = obj
+        end
+
+        def min_query_length=(length)
+          raise TypeError, 'min_query_length must be an integer' unless length.respond_to?(:to_int)
+
+          @min_query_length = length.to_i
+        end
+
+        def to_h
+          super.merge(
+            initial_option: initial_option&.to_h,
+            min_query_length: min_query_length || 3
+          ).compact
+        end
+      end
+    end
+  end
+end