slocks 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 61ae8a8e25f7e6aec74c585aa238882b34821bb2a274315dfdc4ffa79b89edee
+  data.tar.gz: 6268cd40385da4328fb3b1523a4b3f21cc33d699300c74a6f2cc4422f74d884c
+SHA512:
+  metadata.gz: 425ebb760ef81e84762c5f83e483cdf9e2b19615c4717efc3724e79803556a7f8dff3443abdcfab36647dea3ca86e761d22f6d6dc46ef1de261933f09fbc2a52
+  data.tar.gz: 4cb8df895f37394fef5375dbb8e0530315fe074408b129a55b5ec4e4bee854fe1c5e9923c6b2dbda2553cdc0502c95037162d701cdf6c267cfa580a1b3e68402

data/README.md

@@ -0,0 +1,386 @@
+# Slocks
+
+**Slocks** is a DSL & a Rails template handler for generating Slack [Block Kit](https://docs.slack.dev/block-kit/) surfaces.
+
+No implied warranty. Solid chance it won't work.
+
+## Why Slocks?
+I've lost too many hours of my life to 
+\*write\*→\*⌘C\*→\*⌘-Tab to Block Kit Builder\*→\*⌘V\*→"dammit"→\*⌘-Tab\*→\*rewrite\*→\*repeat\*.
+
+No more.
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'slocks'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Quick Start
+
+Create a template.
+
+```ruby
+# app/views/notifications/order_shipped.slack_blocks
+
+header "📦 Your order has shipped!"
+
+section "*Order ##{@order.id}* is on its way", markdown: true
+
+divider
+
+section "Tracking:",
+        fields: [
+          mrkdwn_text("*Carrier:* #{@order.carrier}"),
+          mrkdwn_text("*Tracking:* `#{@order.tracking_number}`")
+        ]
+
+actions [ button("Track Package", "track_#{@order.id}", style: "primary", url: @order.tracking_url) ]
+```
+
+Render it in your controller or service:
+
+```ruby
+class OrdersController < ApplicationController
+  def mark
+    @user = current_user
+    
+    payload = render_to_string(
+      template: 'notifications/welcome',
+      formats: [:slack_message]
+    )
+    
+    slack_client.chat_postMessage(
+      channel: @user.slack_id,
+      **JSON.parse(payload)
+    )
+  end
+end
+```
+
+## Blocks Reference
+
+### Layout Blocks
+
+#### Header
+```ruby
+header "🎉 Great news, Baltimore!"
+```
+
+#### Section
+```ruby
+# simple text
+section "hello world"
+
+# mrkdwn text
+section "to *bold*ly _italic_ize...", markdown: true
+
+# fields
+section "details:",
+  fields: [
+    mrkdwn_text("*computer:* over"),
+    mrkdwn_text("*virus:* VERY yes.")
+  ]
+
+# accessorizing a little (images, buttons, etc)
+section "click to continue",
+  accessory: button("click me, i dare you", "explode_action")
+```
+
+#### Divider
+```ruby
+divider
+```
+
+#### Context
+```ruby
+context [
+  mrkdwn_text("Last updated: #{time_ago_in_words(@updated_at)} ago"),
+  image_element("https://crouton.net/crouton.png", "icon")
+]
+```
+
+#### Actions
+(some these won't do anything unless you use them somewhere expecting accessories! it'd do you a lot of good to read Slack's Block Kit docs before you try anything...)
+
+```ruby
+actions [
+  button("Approve", "approve", style: "primary"),
+  button("Reject", "reject", style: "danger"),
+  button("More Info", "info")
+]
+```
+
+#### Image
+```ruby
+image "https://example.com/photo.jpg", "Photo description",
+  title: "Amazing Photo"
+```
+
+#### Input
+```ruby
+input "Your name",
+  plain_text_input("name_input", placeholder: "Enter your name")
+
+input "Choose an option",
+  select_menu("option_select",
+    placeholder: "Select one",
+    options: [
+      option("Option 1", "opt1"),
+      option("Option 2", "opt2")
+    ]
+  )
+```
+
+#### File
+```ruby
+file "F123ABC456", source: "remote"
+```
+
+#### Video
+```ruby
+video "How to use Slocks",
+  "https://example.com/video",
+  "https://example.com/thumbnail.jpg",
+  "https://example.com/video.mp4",
+  alt_text: "Tutorial video"
+```
+
+### Block Elements
+
+#### Buttons
+```ruby
+button("Click me", "action_id")
+button("Primary", "action", style: "primary")
+button("Danger", "delete", style: "danger")
+button("Link", "link", url: "https://example.com")
+```
+
+#### Select Menus
+```ruby
+# Static select
+select_menu("action_id",
+  placeholder: "Choose one",
+  options: [
+    option("Label 1", "value1"),
+    option("Label 2", "value2")
+  ]
+)
+
+# Multi-select
+multi_select_menu("action_id",
+  placeholder: "Choose multiple",
+  options: [...]
+)
+
+# User select
+users_select("user_action", placeholder: "Select a user")
+
+# Channel select
+channels_select("channel_action", placeholder: "Select a channel")
+
+# Conversation select
+conversations_select("convo_action", placeholder: "Select a conversation")
+```
+
+#### Inputs
+```ruby
+# Text input
+plain_text_input("action_id",
+  placeholder: "Type here...",
+  multiline: true
+)
+
+# Email input
+email_input("email_action", placeholder: "your@email.com")
+
+# URL input
+url_input("url_action", placeholder: "https://...")
+
+# Number input
+number_input("number_action",
+  is_decimal_allowed: true,
+  min_value: 0,
+  max_value: 100
+)
+```
+
+#### Date & Time Pickers
+```ruby
+date_picker("date_action", placeholder: "Select a date")
+time_picker("time_action", placeholder: "Select a time")
+datetime_picker("datetime_action")
+```
+
+#### Other Elements
+```ruby
+# Checkboxes
+checkboxes("check_action", [
+  option("Option 1", "val1"),
+  option("Option 2", "val2")
+])
+
+# Radio buttons
+radio_buttons("radio_action", [
+  option("Choice 1", "c1"),
+  option("Choice 2", "c2")
+])
+
+# Overflow menu
+overflow("overflow_action", [
+  option("Edit", "edit"),
+  option("Delete", "delete")
+])
+
+# File input
+file_input("file_action", filetypes: ["pdf", "doc"], max_files: 5)
+```
+
+### Composition Objects
+
+#### Text Objects
+```ruby
+mrkdwn_text("*Bold* and _italic_")
+plain_text("Plain text", emoji: true)
+```
+
+#### Option & Option Groups
+```ruby
+option("Display text", "value")
+option("With description", "val", description: "More details")
+
+option_group("Group label", [
+  option("Opt 1", "v1"),
+  option("Opt 2", "v2")
+])
+```
+
+#### Confirm Dialog
+```ruby
+confirm_dialog(
+  title: "Are you sure?",
+  text: "This action cannot be undone",
+  confirm: "Yes, delete it",
+  deny: "Cancel",
+  style: "danger"
+)
+```
+
+## Modals
+
+Create a modal template at `app/views/modals/feedback.slack_modal`:
+
+```ruby
+title "Send Feedback"
+submit "Submit"
+close "Cancel"
+callback "feedback_modal"
+
+section "How was your experience?", markdown: true
+
+input "Rating",
+  select_menu("rating",
+    placeholder: "Choose rating",
+    options: [
+      option("⭐⭐⭐⭐⭐ Excellent", "5"),
+      option("⭐⭐⭐⭐ Good", "4"),
+      option("⭐⭐⭐ Okay", "3"),
+      option("⭐⭐ Poor", "2"),
+      option("⭐ Bad", "1")
+    ]
+  )
+
+input "Comments",
+  plain_text_input("comments",
+    placeholder: "Tell us more...",
+    multiline: true
+  ),
+  optional: true
+```
+
+Render it:
+
+```ruby
+modal_json = render_to_string(
+  template: 'modals/feedback',
+  formats: [:slack_modal]
+)
+
+slack_client.views_open(
+  trigger_id: params[:trigger_id],
+  view: JSON.parse(modal_json)
+)
+```
+
+## Rails Helpers
+
+All Rails helpers work in templates:
+
+```ruby
+section "Order summary:",
+  fields: [
+    mrkdwn_text("*Items:* #{pluralize(@order.items.count, 'item')}"),
+    mrkdwn_text("*Total:* #{number_to_currency(@order.total)}"),
+    mrkdwn_text("*Ordered:* #{time_ago_in_words(@order.created_at)} ago")
+  ]
+```
+
+## Partials
+
+Render partials just like ERB:
+
+```ruby
+# app/views/orders/_order.slack_blocks
+section "*Order ##{@order.id}*",
+  fields: [
+    mrkdwn_text("*Status:* #{@order.status}"),
+    mrkdwn_text("*Total:* #{number_to_currency(@order.total)}")
+  ]
+
+# app/views/orders/summary.slack_blocks
+header "Your Orders"
+
+render @orders  # Renders _order.slack_blocks for each order
+```
+
+## Rich Text (Advanced)
+
+For rich text blocks with complex formatting:
+
+```ruby
+rich_text do
+  section do
+    text "Hello ", bold: true
+    text "world!", italic: true
+    emoji "wave"
+    link "https://example.com", text: "Click here"
+  end
+  
+  list(style: "bullet") do
+    text "First item"
+    text "Second item"
+  end
+end
+```
+
+## Contributing
+
+Bug reports are welcome, but pull requests are much _much_ welcomer.
+
+This repo lives on GitHub at https://github.com/24c02/slocks. Happy hacking!
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Credits
+
+built with <3️ by nora and various LLM-slop providers.
+
+heavily inspired by Akira Matsuda's fantastic [JB](https://github.com/amatsuda/jb/) gem.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/slocks/action_view_monkeys.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Slocks
+  module TemplateRenderer
+    module JSONizer
+      def render_template(_view, template, *)
+        rendered_template = super
+        if template.respond_to?(:handler) && [
+          Slocks::TemplateHandler, Slocks::ModalTemplateHandler, Slocks::TemplateHandlerDispatcher
+        ].include?(template.handler)
+          rendered_template.instance_variable_set :@body,
+                                                  rendered_template.body.to_json
+        end
+        rendered_template
+      end
+    end
+  end
+
+  class TemplateResult < SimpleDelegator
+    def to_s
+      __getobj__
+    end
+  end
+
+  module CollectionRendererExtension
+    private
+
+    def render_collection(_collection, _view, _path, template, _layout, _block)
+      obj = super
+      if template.respond_to?(:handler) && [Slocks::TemplateHandler, Slocks::ModalTemplateHandler, Slocks::TemplateHandlerDispatcher].include?(template.handler)
+        if obj.is_a?(ActionView::AbstractRenderer::RenderedCollection::EmptyCollection)
+          def obj.body = []
+        else
+          def obj.body = @rendered_templates.map(&:body)
+        end
+      end
+      obj
+    end
+  end
+
+  module PartialRendererExtension
+    private
+
+    def render_collection(_view, template)
+      obj = super
+      if template.respond_to?(:handler) && [Slocks::TemplateHandler, Slocks::ModalTemplateHandler, Slocks::TemplateHandlerDispatcher].include?(template.handler)
+        if obj.is_a?(ActionView::AbstractRenderer::RenderedCollection::EmptyCollection)
+          def obj.body = []
+        else
+          def obj.body = @rendered_templates.map(&:body)
+        end
+      end
+      obj
+    end
+  end
+end
+
+::ActionView::TemplateRenderer.prepend ::Slocks::TemplateRenderer::JSONizer
+begin
+  ::ActionView::CollectionRenderer.prepend ::Slocks::CollectionRendererExtension
+rescue NameError
+  ::ActionView::PartialRenderer.prepend ::Slocks::PartialRendererExtension
+end

data/lib/slocks/blocks_builder.rb

@@ -0,0 +1,531 @@
+# frozen_string_literal: true
+
+module Slocks
+  class BlocksBuilder
+    attr_reader :blocks
+
+    def initialize(context)
+      @context = context
+      @blocks = []
+    end
+
+    def header(text)
+      @blocks << {
+        type: "header",
+        text: {
+          type: "plain_text",
+          text: text
+        }
+      }
+    end
+
+    def section(text = nil, accessory: nil, fields: nil, markdown: false)
+      block = { type: "section" }
+
+      if text
+        block[:text] = {
+          type: markdown ? "mrkdwn" : "plain_text",
+          text: text
+        }
+      end
+
+      block[:accessory] = accessory if accessory
+      block[:fields] = fields if fields
+
+      @blocks << block
+    end
+
+    def simple_section(text)
+      section(text, markdown: true)
+    end
+
+    def divider
+      @blocks << { type: "divider" }
+    end
+
+    def context(elements)
+      @blocks << {
+        type: "context",
+        elements: elements
+      }
+    end
+
+    def context_actions(elements, block_id: nil)
+      @blocks << {
+        type: "context_actions",
+        elements:,
+        block_id:
+      }.compact
+    end
+
+    def actions(elements)
+      @blocks << {
+        type: "actions",
+        elements: elements
+      }
+    end
+
+    def image(image_url, alt_text, title: nil)
+      block = {
+        type: "image",
+        image_url: image_url,
+        alt_text: alt_text
+      }
+      block[:title] = { type: "plain_text", text: title } if title
+      @blocks << block
+    end
+
+    def input(label, element, optional: false, hint: nil, block_id: nil, dispatch_action: nil)
+      block = {
+        type: "input",
+        label: { type: "plain_text", text: label },
+        element: element
+      }
+      block[:block_id] = block_id if block_id
+      block[:optional] = optional if optional
+      block[:hint] = { type: "plain_text", text: hint } if hint
+      block[:dispatch_action] = dispatch_action if dispatch_action
+      @blocks << block
+    end
+
+    def file(external_id, source: "remote", block_id: nil)
+      block = {
+        type: "file",
+        external_id: external_id,
+        source: source
+      }
+      block[:block_id] = block_id if block_id
+      @blocks << block
+    end
+
+    def video(title, title_url, thumbnail_url, video_url, alt_text:, description: nil, author_name: nil,
+              provider_name: nil, provider_icon_url: nil, block_id: nil)
+      block = {
+        type: "video",
+        title: { type: "plain_text", text: title },
+        title_url:,
+        thumbnail_url:,
+        video_url:,
+        alt_text:,
+        description: description ? { type: "plain_text", text: description } : nil,
+        author_name:,
+        provider_name:,
+        provider_icon_url:,
+        block_id:
+      }.compact
+      @blocks << block
+    end
+
+    def rich_text(&block)
+      builder = RichTextBuilder.new
+      builder.instance_eval(&block) if block_given?
+      @blocks << {
+        type: "rich_text",
+        elements: builder.elements
+      }
+    end
+
+    def image_element(image_url, alt_text)
+      {
+        type: "image",
+        image_url: image_url,
+        alt_text: alt_text
+      }
+    end
+
+    def mrkdwn_text(text)
+      {
+        type: "mrkdwn",
+        text: text
+      }
+    end
+
+    def plain_text(text, emoji: true)
+      {
+        type: "plain_text",
+        text: text,
+        emoji: emoji
+      }
+    end
+
+    def button(text, action_id, value: nil, url: nil, style: nil, confirm: nil, accessibility_label: nil)
+      {
+        type: "button",
+        text: { type: "plain_text", text: text },
+        action_id:,
+        value:,
+        url:,
+        style:,
+        confirm:,
+        accessibility_label:
+      }.compact
+    end
+
+    def checkboxes(action_id, options, initial_options: nil, confirm: nil, focus_on_load: nil)
+      {
+        type: "checkboxes",
+        action_id:,
+        options:,
+        initial_options:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def date_picker(action_id, placeholder: nil, initial_date: nil, confirm: nil, focus_on_load: nil)
+      {
+        type: "datepicker",
+        action_id:,
+        placeholder: placeholder ? { type: "plain_text", text: placeholder } : nil,
+        initial_date:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def datetime_picker(action_id, initial_date_time: nil, confirm: nil, focus_on_load: nil)
+      {
+        type: "datetimepicker",
+        action_id:,
+        initial_date_time:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def time_picker(action_id, placeholder: nil, initial_time: nil, confirm: nil, focus_on_load: nil, timezone: nil)
+      {
+        type: "timepicker",
+        action_id:,
+        placeholder: placeholder ? { type: "plain_text", text: placeholder } : nil,
+        initial_time:,
+        confirm:,
+        focus_on_load:,
+        timezone:
+      }.compact
+    end
+
+    def plain_text_input(action_id, placeholder: nil, initial_value: nil, multiline: nil, min_length: nil,
+                         max_length: nil, dispatch_action_config: nil, focus_on_load: nil)
+      {
+        type: "plain_text_input",
+        action_id:,
+        placeholder: placeholder ? { type: "plain_text", text: placeholder } : nil,
+        initial_value:,
+        multiline:,
+        min_length:,
+        max_length:,
+        dispatch_action_config:,
+        focus_on_load:
+      }.compact
+    end
+
+    def email_input(action_id, placeholder: nil, initial_value: nil, dispatch_action_config: nil, focus_on_load: nil)
+      {
+        type: "email_text_input",
+        action_id:,
+        placeholder: placeholder ? { type: "plain_text", text: placeholder } : nil,
+        initial_value:,
+        dispatch_action_config:,
+        focus_on_load:
+      }.compact
+    end
+
+    def url_input(action_id, placeholder: nil, initial_value: nil, dispatch_action_config: nil, focus_on_load: nil)
+      {
+        type: "url_text_input",
+        action_id:,
+        placeholder: placeholder ? { type: "plain_text", text: placeholder } : nil,
+        initial_value:,
+        dispatch_action_config:,
+        focus_on_load:
+      }.compact
+    end
+
+    def number_input(action_id, is_decimal_allowed:, placeholder: nil, initial_value: nil, min_value: nil,
+                     max_value: nil, dispatch_action_config: nil, focus_on_load: nil)
+      {
+        type: "number_input",
+        action_id:,
+        is_decimal_allowed:,
+        placeholder: placeholder ? { type: "plain_text", text: placeholder } : nil,
+        initial_value:,
+        min_value:,
+        max_value:,
+        dispatch_action_config:,
+        focus_on_load:
+      }.compact
+    end
+
+    def radio_buttons(action_id, options, initial_option: nil, confirm: nil, focus_on_load: nil)
+      {
+        type: "radio_buttons",
+        action_id:,
+        options:,
+        initial_option:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def select_menu(action_id, placeholder:, options: nil, option_groups: nil, initial_option: nil, confirm: nil,
+                    focus_on_load: nil)
+      {
+        type: "static_select",
+        action_id:,
+        placeholder: { type: "plain_text", text: placeholder },
+        options:,
+        option_groups:,
+        initial_option:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def multi_select_menu(action_id, placeholder:, options: nil, option_groups: nil, initial_options: nil,
+                          max_selected_items: nil, confirm: nil, focus_on_load: nil)
+      {
+        type: "multi_static_select",
+        action_id:,
+        placeholder: { type: "plain_text", text: placeholder },
+        options:,
+        option_groups:,
+        initial_options:,
+        max_selected_items:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def users_select(action_id, placeholder:, initial_user: nil, confirm: nil, focus_on_load: nil)
+      {
+        type: "users_select",
+        action_id:,
+        placeholder: { type: "plain_text", text: placeholder },
+        initial_user:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def multi_users_select(action_id, placeholder:, initial_users: nil, max_selected_items: nil, confirm: nil,
+                           focus_on_load: nil)
+      {
+        type: "multi_users_select",
+        action_id:,
+        placeholder: { type: "plain_text", text: placeholder },
+        initial_users:,
+        max_selected_items:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def conversations_select(action_id, placeholder:, initial_conversation: nil, default_to_current_conversation: nil,
+                             filter: nil, confirm: nil, focus_on_load: nil, response_url_enabled: nil)
+      {
+        type: "conversations_select",
+        action_id:,
+        placeholder: { type: "plain_text", text: placeholder },
+        initial_conversation:,
+        default_to_current_conversation:,
+        filter:,
+        confirm:,
+        focus_on_load:,
+        response_url_enabled:
+      }.compact
+    end
+
+    def multi_conversations_select(action_id, placeholder:, initial_conversations: nil, max_selected_items: nil,
+                                   default_to_current_conversation: nil, filter: nil, confirm: nil, focus_on_load: nil)
+      {
+        type: "multi_conversations_select",
+        action_id:,
+        placeholder: { type: "plain_text", text: placeholder },
+        initial_conversations:,
+        max_selected_items:,
+        default_to_current_conversation:,
+        filter:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def channels_select(action_id, placeholder:, initial_channel: nil, confirm: nil, focus_on_load: nil,
+                        response_url_enabled: nil)
+      {
+        type: "channels_select",
+        action_id:,
+        placeholder: { type: "plain_text", text: placeholder },
+        initial_channel:,
+        confirm:,
+        focus_on_load:,
+        response_url_enabled:
+      }.compact
+    end
+
+    def multi_channels_select(action_id, placeholder:, initial_channels: nil, max_selected_items: nil, confirm: nil,
+                              focus_on_load: nil)
+      {
+        type: "multi_channels_select",
+        action_id:,
+        placeholder: { type: "plain_text", text: placeholder },
+        initial_channels:,
+        max_selected_items:,
+        confirm:,
+        focus_on_load:
+      }.compact
+    end
+
+    def overflow(action_id, options, confirm: nil)
+      {
+        type: "overflow",
+        action_id:,
+        options:,
+        confirm:
+      }.compact
+    end
+
+    def file_input(action_id, filetypes: nil, max_files: nil)
+      {
+        type: "file_input",
+        action_id:,
+        filetypes:,
+        max_files:
+      }.compact
+    end
+
+    def rich_text_input(action_id, placeholder: nil, initial_value: nil, dispatch_action_config: nil,
+                        focus_on_load: nil)
+      {
+        type: "rich_text_input",
+        action_id:,
+        placeholder: placeholder ? { type: "plain_text", text: placeholder } : nil,
+        initial_value:,
+        dispatch_action_config:,
+        focus_on_load:
+      }.compact
+    end
+
+    def workflow_button(text, workflow:, style: nil, accessibility_label: nil)
+      {
+        type: "workflow_button",
+        text: { type: "plain_text", text: text },
+        workflow:,
+        style:,
+        accessibility_label:
+      }.compact
+    end
+
+    def feedback_buttons(positive_text, positive_value, negative_text, negative_value, action_id: nil,
+                         positive_accessibility_label: nil, negative_accessibility_label: nil)
+      {
+        type: "feedback_buttons",
+        action_id:,
+        positive_button: {
+          text: { type: "plain_text", text: positive_text },
+          value: positive_value,
+          accessibility_label: positive_accessibility_label
+        }.compact,
+        negative_button: {
+          text: { type: "plain_text", text: negative_text },
+          value: negative_value,
+          accessibility_label: negative_accessibility_label
+        }.compact
+      }.compact
+    end
+
+    def icon_button(icon, text, action_id, value: nil, confirm: nil, accessibility_label: nil,
+                    visible_to_user_ids: nil)
+      {
+        type: "icon_button",
+        icon:,
+        text: { type: "plain_text", text: text },
+        action_id:,
+        value:,
+        confirm:,
+        accessibility_label:,
+        visible_to_user_ids:
+      }.compact
+    end
+
+    def option(text, value, description: nil, url: nil)
+      opt = {
+        text: { type: "plain_text", text: text },
+        value: value
+      }
+      opt[:description] = { type: "plain_text", text: description } if description
+      opt[:url] = url if url
+      opt
+    end
+
+    def option_group(label, options)
+      {
+        label: { type: "plain_text", text: label },
+        options: options
+      }
+    end
+
+    def confirm_dialog(title:, text:, confirm:, deny:, style: nil)
+      dialog = {
+        title: { type: "plain_text", text: title },
+        text: { type: "mrkdwn", text: text },
+        confirm: { type: "plain_text", text: confirm },
+        deny: { type: "plain_text", text: deny }
+      }
+      dialog[:style] = style if style
+      dialog
+    end
+
+    def dispatch_action_config(*trigger_actions_on)
+      {
+        trigger_actions_on: trigger_actions_on
+      }
+    end
+
+    def filter(include: nil, exclude_external_shared_channels: nil, exclude_bot_users: nil)
+      f = {}
+      f[:include] = include if include
+      f[:exclude_external_shared_channels] = exclude_external_shared_channels if exclude_external_shared_channels
+      f[:exclude_bot_users] = exclude_bot_users if exclude_bot_users
+      f
+    end
+
+    def render(partial, locals: {})
+      if partial.respond_to?(:to_ary)
+        partial.flat_map do |item|
+          render_partial_for_item(item, locals)
+        end
+      else
+        render_partial_for_item(partial, locals)
+      end
+    end
+
+    def method_missing(method, *args, **kwargs, &block)
+      if @context.respond_to?(method)
+        @context.public_send(method, *args, **kwargs, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      @context.respond_to?(method, include_private) || super
+    end
+
+    private
+
+    def render_partial_for_item(item, locals)
+      partial_name = item.class.name.underscore
+      partial_path = "#{partial_name.pluralize}/#{partial_name}"
+
+      result = @context.render(
+        partial: partial_path,
+        locals: locals.merge(partial_name.to_sym => item),
+        formats: [:slack_blocks]
+      )
+
+      JSON.parse(result)["blocks"] || []
+    end
+  end
+end

data/lib/slocks/modal_builder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Slocks
+  class ModalBuilder < BlocksBuilder
+    attr_reader :modal_title, :submit_text, :close_text, :callback_id
+
+    def title(text)
+      @modal_title = text
+    end
+
+    def submit(text)
+      @submit_text = text
+    end
+
+    def close(text)
+      @close_text = text
+    end
+
+    def callback(id)
+      @callback_id = id
+    end
+
+    def to_h
+      modal = {
+        type: "modal",
+        title: { type: "plain_text", text: @modal_title },
+        blocks: @blocks,
+        callback_id: @callback_id
+      }.compact
+      modal[:submit] = { type: "plain_text", text: @submit_text } if @submit_text
+      modal[:close] = { type: "plain_text", text: @close_text } if @close_text
+      modal
+    end
+  end
+end

data/lib/slocks/railtie.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "action_view"
+
+module Slocks
+  class Railtie < ::Rails::Railtie
+    initializer "slocks.register_template_handler" do
+      ActiveSupport.on_load(:action_view) do
+        require "slocks/action_view_monkeys"
+        require "slocks/template_handler"
+        
+        Mime::Type.register "application/json", :slack_message
+        Mime::Type.register "application/json", :slack_modal
+        
+        ActionView::Template.register_template_handler(:slocks, Slocks::TemplateHandlerDispatcher)
+      end
+    end
+  end
+end

data/lib/slocks/rich_text_builder.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Slocks
+  class RichTextBuilder
+    attr_reader :elements
+
+    def initialize
+      @elements = []
+    end
+
+    def section(&block)
+      section_builder = RichTextSectionBuilder.new
+      section_builder.instance_eval(&block) if block_given?
+      @elements << {
+        type: "rich_text_section",
+        elements: section_builder.elements
+      }
+    end
+
+    def list(style:, &block)
+      list_builder = RichTextSectionBuilder.new
+      list_builder.instance_eval(&block) if block_given?
+      @elements << {
+        type: "rich_text_list",
+        style: style,
+        elements: list_builder.elements
+      }
+    end
+
+    def preformatted(&block)
+      section_builder = RichTextSectionBuilder.new
+      section_builder.instance_eval(&block) if block_given?
+      @elements << {
+        type: "rich_text_preformatted",
+        elements: section_builder.elements
+      }
+    end
+
+    def quote(&block)
+      section_builder = RichTextSectionBuilder.new
+      section_builder.instance_eval(&block) if block_given?
+      @elements << {
+        type: "rich_text_quote",
+        elements: section_builder.elements
+      }
+    end
+  end
+
+  class RichTextSectionBuilder
+    attr_reader :elements
+
+    def initialize
+      @elements = []
+    end
+
+    def text(text, bold: nil, italic: nil, strike: nil, code: nil)
+      element = { type: "text", text: text }
+      style = {}
+      style[:bold] = true if bold
+      style[:italic] = true if italic
+      style[:strike] = true if strike
+      style[:code] = true if code
+      element[:style] = style unless style.empty?
+      @elements << element
+    end
+
+    def link(url, text: nil, unsafe: nil, style: nil)
+      element = { type: "link", url: url }
+      element[:text] = text if text
+      element[:unsafe] = unsafe if unsafe
+      element[:style] = style if style
+      @elements << element
+    end
+
+    def emoji(name)
+      @elements << { type: "emoji", name: name }
+    end
+
+    def channel(channel_id)
+      @elements << { type: "channel", channel_id: channel_id }
+    end
+
+    def user(user_id)
+      @elements << { type: "user", user_id: user_id }
+    end
+
+    def usergroup(usergroup_id)
+      @elements << { type: "usergroup", usergroup_id: usergroup_id }
+    end
+
+    def date(timestamp, format:, fallback: nil, link: nil)
+      element = { type: "date", timestamp: timestamp, format: format }
+      element[:fallback] = fallback if fallback
+      element[:link] = link if link
+      @elements << element
+    end
+
+    def broadcast(range:)
+      @elements << { type: "broadcast", range: range }
+    end
+  end
+end

data/lib/slocks/template_handler.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/class/attribute"
+
+module Slocks
+  class TemplateHandlerDispatcher
+    def self.call(template, source = nil)
+      case template.format&.to_sym
+      when :slack_modal
+        ModalTemplateHandler.call(template, source)
+      else
+        BlocksTemplateHandler.call(template, source)
+      end
+    end
+    
+    def self.default_format = :slack_message
+    def self.handles_encoding? = true
+    
+    def self.translate_location(spot, backtrace_location, source)
+      BlocksTemplateHandler.translate_location(spot, backtrace_location, source)
+    end
+  end
+
+  class BlocksTemplateHandler
+    class << self
+      def default_format = :slack_message
+
+      def preamble = <<~EOP
+
+
+        @__slocks_builder ||= Slocks::BlocksBuilder.new(self)
+        def method_missing(m, *a, **k, &b)
+          @__slocks_builder.respond_to?(m) ? @__slocks_builder.public_send(m, *a, **k, &b) : super
+        end
+      EOP
+
+      def call(template, source = nil)
+        source ||= template.source
+        <<~EOS
+          #{preamble}
+          #{source}
+          { blocks: @__slocks_builder.blocks }
+        EOS
+      end
+
+      def translate_location(spot, _backtrace_location, _source)
+        # eat your heart out rails-core
+        # this sucks but seems to work
+        plen = preamble.lines.size + 2
+        spot[:first_lineno] -= plen
+        spot[:last_lineno] -= plen
+        spot[:script_lines] = spot[:script_lines][plen..-4]
+        spot
+      end
+
+      def handles_encoding? = true
+    end
+  end
+
+  class ModalTemplateHandler < BlocksTemplateHandler
+    class << self
+      def default_format = :slack_modal
+
+      def call(template, source = nil)
+        source ||= template.source
+        <<~EOS
+          @__slocks_modal_builder ||= Slocks::ModalBuilder.new(self)
+          def method_missing(m, *a, **k, &b);
+             @__slocks_modal_builder.respond_to?(m) ? @__slocks_modal_builder.public_send(m, *a, **k, &b) : super;
+          end
+          #{source}
+          @__slocks_modal_builder.to_h
+        EOS
+      end
+    end
+  end
+  
+  TemplateHandler = BlocksTemplateHandler
+end

data/lib/slocks/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Slocks
+  VERSION = "0.1.0"
+end

data/lib/slocks.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "slocks/version"
+require_relative "slocks/rich_text_builder"
+require_relative "slocks/blocks_builder"
+require_relative "slocks/modal_builder"
+require_relative "slocks/template_handler"
+require_relative "slocks/railtie" if defined?(Rails::Railtie)
+
+module Slocks
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: slocks
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- 24c02
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: A Rails template handler that provides a clean DSL for building Slack
+  Block Kit blocks and modals
+email:
+- slocks@noras.email
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/slocks.rb
+- lib/slocks/action_view_monkeys.rb
+- lib/slocks/blocks_builder.rb
+- lib/slocks/modal_builder.rb
+- lib/slocks/railtie.rb
+- lib/slocks/rich_text_builder.rb
+- lib/slocks/template_handler.rb
+- lib/slocks/version.rb
+homepage: https://github.com/24c02/slocks
+licenses: []
+metadata:
+  homepage_uri: https://github.com/24c02/slocks
+  source_code_uri: https://github.com/24c02/slocks
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Rails template handler for Slack Block Kit
+test_files: []