block-kit 1.0.0

data/lib/block_kit/surfaces/modal.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module BlockKit
+  module Surfaces
+    class Modal < Base
+      self.type = :modal
+
+      MAX_TITLE_LENGTH = 24
+      MAX_BUTTON_LENGTH = 24
+      SUPPORTED_ELEMENTS = [
+        Elements::Button,
+        Elements::ChannelsSelect,
+        Elements::Checkboxes,
+        Elements::ConversationsSelect,
+        Elements::DatePicker,
+        Elements::DatetimePicker,
+        Elements::EmailTextInput,
+        Elements::ExternalSelect,
+        Elements::FileInput,
+        Elements::Image,
+        Elements::MultiChannelsSelect,
+        Elements::MultiConversationsSelect,
+        Elements::MultiExternalSelect,
+        Elements::MultiStaticSelect,
+        Elements::MultiUsersSelect,
+        Elements::NumberInput,
+        Elements::Overflow,
+        Elements::PlainTextInput,
+        Elements::RadioButtons,
+        Elements::RichTextInput,
+        Elements::StaticSelect,
+        Elements::TimePicker,
+        Elements::URLTextInput,
+        Elements::UsersSelect
+      ].freeze
+
+      plain_text_attribute :title
+      plain_text_attribute :close
+      plain_text_attribute :submit
+      attribute :clear_on_close, :boolean
+      attribute :notify_on_close, :boolean
+      attribute :submit_disabled, :boolean
+
+      validates :title, presence: true, length: {maximum: MAX_TITLE_LENGTH}
+      fixes :title, truncate: {maximum: MAX_TITLE_LENGTH}
+
+      validates :close, presence: true, length: {maximum: MAX_BUTTON_LENGTH}, allow_nil: true
+      fixes :close, truncate: {maximum: MAX_BUTTON_LENGTH}, null_value: {error_types: [:blank]}
+
+      validates :submit, presence: true, length: {maximum: MAX_BUTTON_LENGTH}, allow_nil: true
+      fixes :submit, truncate: {maximum: MAX_BUTTON_LENGTH}, null_value: {error_types: [:blank]}
+
+      def initialize(attributes = {})
+        attributes = attributes.with_indifferent_access
+        attributes[:blocks] ||= []
+
+        super
+      end
+
+      def as_json(*)
+        super.merge(
+          title: title&.as_json,
+          close: close&.as_json,
+          submit: submit&.as_json,
+          clear_on_close: clear_on_close,
+          notify_on_close: notify_on_close,
+          submit_disabled: submit_disabled
+        ).compact
+      end
+    end
+  end
+end

data/lib/block_kit/surfaces.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Surfaces
+    autoload :Base, "block_kit/surfaces/base"
+
+    autoload :Home, "block_kit/surfaces/home"
+    autoload :Message, "block_kit/surfaces/message"
+    autoload :Modal, "block_kit/surfaces/modal"
+  end
+end

data/lib/block_kit/typed_array.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module BlockKit
+  # Custom array class that maintains type constraints during mutation
+  class TypedArray < ::Array
+    attr_reader :item_type
+
+    def initialize(item_type, *args)
+      @item_type = item_type
+
+      # Array.new supports three different argument signatures:
+      #
+      # 1. Array.new(size = nil, object = nil): creates an array of the given size
+      #    filled with the given object
+      # 2. Array.new(array): creates a new array that is a copy of the given array
+      # 3. Array.new(size, &block): creates a new array of the given size, passing
+      #    each index to the block and using the block's return value to fill the array
+      #
+      # We need to handle all three cases, as they all result in filling the array.
+      # Calling `super(*)` and then `map!` does not work, as it does not end up
+      # modifying the array for some reason.
+      if args.size == 1 && args.first.is_a?(::Array)
+        super(args.first.map { |item| item_type.cast(item) }.compact)
+      elsif args.size == 2
+        super(args[0], item_type.cast(item)).compact!
+      elsif args.size == 1 && block_given?
+        super(args[0]) { |index| item_type.cast(yield(index)) }
+      end
+    end
+
+    # Override methods that modify the array to ensure type constraints
+    def <<(item)
+      super(item_type.cast(item)).tap(&:compact!)
+    end
+
+    def push(*items)
+      super(*items.map { |item| item_type.cast(item) }.compact)
+    end
+
+    def unshift(*items)
+      super(*items.map { |item| item_type.cast(item) }.compact)
+    end
+
+    def insert(index, *items)
+      super(index, *items.map { |item| item_type.cast(item) }.compact)
+    end
+
+    def []=(position, *args)
+      if args.length == 0
+        # array[1] = value
+        super(position, item_type.cast(position))
+      elsif args.length == 1
+        if position.is_a?(Range)
+          # array[1..3] = [x, y, z]
+          value = args[0]
+          if value.is_a?(::Array)
+            super(position, value.map { |item| item_type.cast(item) })
+          else
+            super(position, item_type.cast(value))
+          end
+        else
+          # array[1] = value
+          super(position, item_type.cast(args[0]))
+        end
+      else
+        # array[1, 2] = [x, y]
+        length, value = args
+        if value.is_a?(::Array)
+          super(position, length, value.map { |item| item_type.cast(item) })
+        else
+          super(position, length, item_type.cast(value))
+        end
+      end
+
+      compact!
+    end
+
+    def replace(other_array)
+      super(other_array.map { |item| item_type.cast(item) }.compact)
+    end
+
+    def fill(*args, &block)
+      if block_given?
+        # If a block is given, we need to intercept its results
+        modified_block = proc { |*block_args| item_type.cast(yield(*block_args)) }
+        super(*args, &modified_block)
+      elsif args.size > 0
+        # No block, so the last argument is the value to fill with
+        value = args.pop
+        super(*args, item_type.cast(value))
+      else
+        super
+      end
+    end
+
+    def map!(&block)
+      super { |item| item_type.cast(yield(item)) }.compact
+    end
+
+    def collect!(&block)
+      super { |item| item_type.cast(yield(item)) }.compact
+    end
+
+    def concat(other_array)
+      super(other_array.map { |item| item_type.cast(item) }).compact
+    end
+
+    # Note: methods that return new arrays (like `+`, `&`, `|`, etc.) are not
+    # overridden, as it's not necessary to enforce type constraints on the
+    # resulting array. If the resulting array is later assigned back to the
+    # attribute backing the original array, type constraints will be enforced
+    # at that time.
+  end
+end

data/lib/block_kit/typed_set.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module BlockKit
+  # Custom array class that maintains type constraints during mutation
+  class TypedSet < Set
+    attr_reader :item_type
+
+    def initialize(item_type, enum = nil)
+      # Only support scalar item types for now
+      unless item_type.respond_to?(:type) && !item_type.type.start_with?("block_kit_")
+        raise ArgumentError, "Only scalar item types are supported"
+      end
+
+      @item_type = item_type
+
+      super(enum&.map { |item| item_type.cast(item) }&.compact)
+    end
+
+    # Override methods that modify the set to ensure type constraints.
+    def add(item)
+      super(item_type.cast(item)).tap(&:compact!)
+    end
+    alias_method :<<, :add
+
+    def replace(other)
+      super(other.map { |item| item_type.cast(item) }.compact)
+    end
+
+    def map!(&block)
+      super { |item| item_type.cast(yield(item)) }.compact
+    end
+
+    def collect!(&block)
+      super { |item| item_type.cast(yield(item)) }.compact
+    end
+
+    def merge(other)
+      super(other.map { |item| item_type.cast(item) }).compact
+    end
+
+    def &(other)
+      n = self.class.new(item_type)
+      if other.is_a?(Set)
+        each { |item| n.add(item) if other.include?(item) }
+      else
+        do_with_enum(other) { |item| n.add(item) if include?(item) }
+      end
+
+      n.compact
+    end
+    alias_method :intersection, :&
+
+    def compact!
+      delete(nil) { return nil }
+      self
+    end
+
+    def compact
+      dup.tap(&:compact!)
+    end
+
+    def inspect
+      super.tap { |str| str.sub!("Set", "TypedSet[#{item_type.type}]") }
+    end
+
+    private
+
+    def do_with_enum(enum, &block)
+      if enum.respond_to?(:each_entry)
+        enum.each_entry(&block) if block
+      elsif enum.respond_to?(:each)
+        enum.each(&block) if block
+      else
+        raise ArgumentError, "value must be enumerable"
+      end
+    end
+  end
+end

data/lib/block_kit/types/array.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module BlockKit
+  module Types
+    # Allows declaring ActiveModel attributes that are arrays of specific types,
+    # powered by an internal TypedArray class that enforces type constraints on
+    # array elements any time the array is modified.
+    class Array < ActiveModel::Type::Value
+      attr_reader :item_type
+
+      def self.of(item_type)
+        new(item_type)
+      end
+
+      def initialize(item_type)
+        item_type = ActiveModel::Type.lookup(item_type) if item_type.is_a?(Symbol)
+        item_type = Types::Generic.of_type(item_type) if item_type.is_a?(Class) && item_type < BlockKit::Base
+
+        @item_type = item_type
+      end
+
+      def type
+        :array
+      end
+
+      def cast(value)
+        return nil if value.nil?
+
+        TypedArray.new(item_type, Array(value))
+      end
+
+      def serialize(value)
+        return nil if value.nil?
+
+        cast(value)
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        cast(raw_old_value) != cast(new_value)
+      end
+    end
+  end
+end

data/lib/block_kit/types/blocks.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module BlockKit
+  module Types
+    # Provides a way to generate an ActiveModel type for multiple block types.
+    class Blocks < ActiveModel::Type::Value
+      attr_reader :block_classes, :block_types
+
+      def initialize(*block_classes)
+        @block_classes = block_classes
+        @block_types = block_classes.map { |block_class| Types::Generic.of_type(block_class) }
+      end
+
+      def type
+        :block_kit_block
+      end
+
+      def cast(value)
+        case value
+        when *@block_classes
+          value
+        when Hash
+          value = value.with_indifferent_access
+          type_name = value[:type]&.to_sym
+
+          matching_type = @block_types.find do |type_class|
+            type_class.respond_to?(:type) && type_class.type == :"block_kit_#{type_name}"
+          end
+
+          matching_type&.cast(value)
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/types/generic.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module BlockKit
+  module Types
+    # Provides a way to generate generic ActiveModel types for individual block types.
+    # Most block types can simply be cast from an object of the same type or a Hash with
+    # the object's attributes.
+    class Generic < ActiveModel::Type::Value
+      class_attribute :instances, default: {}
+
+      def self.new(block_class)
+        instances[block_class] ||= super
+      end
+
+      class << self
+        alias_method :of_type, :new
+      end
+
+      # These block types have special casting logic.
+      instances[Composition::Text] = Text.instance
+      instances[Composition::PlainText] = PlainText.instance
+      instances[Composition::Mrkdwn] = Mrkdwn.instance
+      instances[Composition::Option] = Option.instance
+      instances[Composition::OverflowOption] = OverflowOption.instance
+
+      attr_reader :type, :block_class
+
+      def initialize(block_class)
+        @block_class = block_class
+        @type = :"block_kit_#{block_class.type}"
+      end
+
+      def cast(value)
+        case value
+        when block_class
+          value
+        when Hash
+          block_class.new(**value.with_indifferent_access.slice(*block_class.attribute_names).symbolize_keys)
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/types/option.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_model"
+require "singleton"
+
+module BlockKit
+  module Types
+    class Option < ActiveModel::Type::Value
+      def block_class = Composition::Option
+
+      include Singleton
+
+      def type
+        :block_kit_option
+      end
+
+      def cast(value)
+        case value
+        when Composition::OverflowOption
+          block_class.new(text: value.text, value: value.value)
+        when block_class
+          value
+        when Hash
+          block_class.new(**value.with_indifferent_access.slice(*block_class.attribute_names).symbolize_keys)
+        end
+      end
+    end
+
+    class OverflowOption < Option
+      def block_class = Composition::OverflowOption
+
+      def type
+        :block_kit_overflow_option
+      end
+
+      def cast(value)
+        case value
+        when block_class
+          value
+        when Composition::Option
+          block_class.new(text: value.text, value: value.value)
+        when Hash
+          block_class.new(**value.with_indifferent_access.slice(*block_class.attribute_names).symbolize_keys)
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/types/set.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_model"
+
+module BlockKit
+  module Types
+    # Allows declaring ActiveModel attributes that are Sets of specific types,
+    # powered by an internal TypedSet class that enforces type constraints on
+    # set members any time the set is modified or any time set operations are
+    # performed against other collections.
+    class Set < Array
+      attr_reader :item_type
+
+      def type
+        :set
+      end
+
+      def cast(value)
+        return nil if value.nil?
+
+        TypedSet.new(item_type, Array(value))
+      end
+
+      def serialize(value)
+        return nil if value.nil?
+
+        cast(value)
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        cast(raw_old_value) != cast(new_value)
+      end
+    end
+  end
+end

data/lib/block_kit/types/text.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "active_model"
+require "singleton"
+
+module BlockKit
+  module Types
+    class Text < ActiveModel::Type::Value
+      include Singleton
+
+      def type
+        :block_kit_text
+      end
+
+      def cast(value)
+        case value
+        when Composition::PlainText, Composition::Mrkdwn, NilClass
+          value
+        when Hash
+          # Check for a `:type` key, otherwise prefer Mrkdwn over PlainText except
+          # in the explicit case where only the `:text` and `:emoji` keys are provided
+          type = value[:type]&.to_sym
+          if type == :mrkdwn
+            Mrkdwn.instance.cast(value)
+          elsif type == :plain_text
+            PlainText.instance.cast(value)
+          elsif value.key?(:verbatim) || !value.key?(:emoji)
+            Mrkdwn.instance.cast(value)
+          else
+            PlainText.instance.cast(value)
+          end
+        else
+          Mrkdwn.instance.cast(value)
+        end
+      end
+    end
+
+    class PlainText < Text
+      def block_class = Composition::PlainText
+
+      def type
+        :block_kit_plain_text
+      end
+
+      def cast(value)
+        case value
+        when block_class, NilClass
+          value
+        when Composition::Mrkdwn
+          block_class.new(text: value.text)
+        when Hash
+          block_class.new(**value.with_indifferent_access.slice(*block_class.attribute_names).symbolize_keys)
+        else
+          block_class.new(text: value)
+        end
+      end
+    end
+
+    class Mrkdwn < Text
+      def block_class = Composition::Mrkdwn
+
+      def type
+        :block_kit_mrkdwn
+      end
+
+      def cast(value)
+        case value
+        when block_class, NilClass
+          value
+        when Composition::PlainText
+          block_class.new(text: value.text)
+        when Hash
+          block_class.new(**value.with_indifferent_access.slice(*block_class.attribute_names).symbolize_keys)
+        else
+          block_class.new(text: value)
+        end
+      end
+    end
+  end
+end

data/lib/block_kit/types.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module BlockKit
+  module Types
+    autoload :Generic, "block_kit/types/generic"
+    autoload :Blocks, "block_kit/types/blocks"
+
+    autoload :Array, "block_kit/types/array"
+    autoload :Mrkdwn, "block_kit/types/text"
+    autoload :NumberInput, "block_kit/types/number_input"
+    autoload :Option, "block_kit/types/option"
+    autoload :OverflowOption, "block_kit/types/option"
+    autoload :PlainText, "block_kit/types/text"
+    autoload :Set, "block_kit/types/set"
+    autoload :Text, "block_kit/types/text"
+  end
+end

data/lib/block_kit/validators/array_inclusion_validator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# Source: https://github.com/sciencehistory/kithe/blob/master/app/validators/array_inclusion_validator.rb
+#
+# Like the default Rails inclusion validator, but the built-in Rails
+# validator won't work on an _array_ of things.
+#
+# So if you have an array of primitive values, you can use this to
+# validate that all elements of the array are in the inclusion list.
+#
+# Or that all the elements of the array are whatever you want,
+# by supplying a proc that returns false for bad values.
+#
+# Empty arrays are always allowed, add a presence validator if you don't
+# want to allow them, eg `validates :genre, presence: true, array_inclusion: { in: whatever }`
+#
+# @example
+#    class Work < Kithe::Work
+#      attr_json :genre, :string, array: true
+#      validates :genre, array_inclusion: { in: ALLOWED_GENRES  }
+#      validates :genre, array_inclusion: { proc: ->(val) { val =~ /\d+/ } }
+#      #...
+#
+# Custom message can interpolate `rejected_values` value. (Should also work for i18n)
+#
+# Note: There isn't currently a great way to show primitive array validation errors on
+# a form for an invalid edit, the validation error can only be shown as if for the entire
+# array field, not the individual invalid edit. You might consider modelling as a compound
+# Model with only one attribute instead of as a primitive.
+#
+# @example
+#     validates :genre, array_inclusion: { in: ALLOWED_GENRES, message: "option %{rejected_values} not allowed"  }
+module BlockKit
+  module Validators
+    class ArrayInclusionValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        values = Array(value) || []
+        not_allowed_values = []
+
+        if options[:in]
+          not_allowed_values.concat(values - options[:in])
+        end
+
+        if options[:proc]
+          not_allowed_values.concat(values.find_all { |v| !options[:proc].call(v) })
+        end
+
+        unless not_allowed_values.blank?
+          formatted_rejected = not_allowed_values.uniq.collect(&:inspect).join(",")
+          record.errors.add(attribute, :inclusion, **options.except(:in).merge!(rejected_values: formatted_rejected, value: value, invalid_values: not_allowed_values))
+        end
+      end
+    end
+  end
+end