slack_line 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 61c279b95b271ef984af73457248e82ab75a576aa46820bd59cacd8c8f6c8042
+  data.tar.gz: 57bc942d244ef3b45d95344ff0ab5bffb4412bc840016d2bf8e55450e1600742
+SHA512:
+  metadata.gz: 8dd4210ffac87ab836e38902287098458dc0368d785f22c4a70221cc949cef70a219c0a96ed2adb37098d634e1c98899d1b59719cf41cfd7a248fe4259b12956
+  data.tar.gz: 20e53e6fa522453b25513f4ddfb503b74a7e1f31153837d7fb1dacfe9c89db19b4e5a2b29839ed24d5ef999da6b8fb16bed94a2fd09c76825afa41a997c29af5

data/.github/workflows/linters.yml

@@ -0,0 +1,33 @@
+name: Linters
+
+on: [push]
+
+jobs:
+  Linting:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.3
+
+      - name: Cache gems
+        uses: actions/cache@v3
+        with: path: vendor/bundle
+        key: ${{ runner.os }}-linters-${{ hashFiles('Gemfile.lock') }}
+        restore-keys:
+          ${{ runner.os }}-linters-
+
+      - name: Install gems
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Run StandardRB
+        run: bundle exec standardrb
+
+      - name: Run Rubocop (complexity checks)
+        run: bundle exec rubocop --parallel
+
+      - name: Run Markdownlint
+        run: bundle exec mdl .

data/.github/workflows/rspec.yml

@@ -0,0 +1,33 @@
+name: RSpec
+
+on: [push]
+
+jobs:
+  RSpec:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['3.2', '3.3', '3.4', 'head']
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+
+      - name: Cache gems
+        uses: actions/cache@v3
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-rspec-${{ matrix.ruby-version }}-${{ hashFiles('Gemfile.lock') }}
+          restore-keys:
+            ${{ runner.os }}-rspec-${{ matrix.ruby-version }}-
+
+      - name: Install gems
+        run: bundle install --jobs 4 --retry 3
+
+      - name: Run RSpec
+        run: SIMPLECOV=true bundle exec rspec

data/.gitignore

@@ -0,0 +1,7 @@
+.ruby-version
+.ruby-gemset
+Gemfile.lock
+*.gem
+coverage/
+tmp/*
+.DS_Store

data/.mdl_rules.rb

@@ -0,0 +1,2 @@
+all
+rule "MD013", ignore_code_blocks: true

data/.mdlrc

@@ -0,0 +1,2 @@
+style File.expand_path("../.mdl_rules.rb", __FILE__)
+git_recurse true

data/.quiet_quality.yml

@@ -0,0 +1,7 @@
+---
+default_tools: ["standardrb", "rubocop", "markdown_lint", "rspec"]
+executor: concurrent
+comparison_branch: origin/main
+logging: light
+changed_files: false
+filter_messages: false

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,21 @@
+---
+AllCops:
+  SuggestExtensions: false
+  DisabledByDefault: true
+
+Metrics/AbcSize:
+  Max: 15
+Metrics/CyclomaticComplexity:
+  Max: 8
+Metrics/PerceivedComplexity:
+  Max: 7
+
+Metrics/ClassLength:
+  CountComments: false
+  Max: 150
+Metrics/MethodLength:
+  CountComments: false
+  Max: 15
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true

data/.standard.yml

@@ -0,0 +1,3 @@
+---
+format: progress
+ruby_version: 3.2

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://gem.coop"
+
+gemspec

data/README.md

@@ -0,0 +1,123 @@
+# SlackLine
+
+This is a ruby gem supporting easy construction, sending, editing, and
+threading of messages and threads.
+
+## Usage
+
+Are you ready? Because this is going to be _so easy_.
+
+```ruby
+# Send a simple message directly
+sent_message = SlackLine.message("Something happened!", to: "#general").post
+
+# Construct a more complex message, then send it
+msg = SlackLine.message do
+  section do
+    context "Don't worry! If this message surprises you, context @foobar"
+    text "A thing has happened"
+    text "Yeah, it happened for sure"
+    link "How bad?", problems_path(problem.id)
+  end
+
+  text "More details.."
+end
+sent_message = msg.post(to: "#general")
+
+# Send a _thread_ of messages (strings generate simple messages)
+sent_thread = SlackLine.thread("First text", "Second text", msg, to: "#general").post
+
+# You can also build them inline via dsl
+sent_thread = SlackLine.thread(to: "@dm_recipient") do
+  message do
+    context "yeah"
+    text "That's right"
+  end
+
+  message(already_built_message)
+  message "this makes a basic message directly"
+end.post
+```
+
+And then once you've sent a message or thread, you'll have a SentMessage
+or SentThread object (which is basically an Array of SentMessages). You
+can call `SentMessage#update` on any of those messages to edit them
+after the fact - this is especially useful for keeping a message in a
+public channel updated with the state of the process it's linking to.
+
+`update` accepts a String, a Message, or a block _defining_ a message.
+To update a SentThread, you'll need to choose  message:
+
+```ruby
+sent_message.update "Edit: never mind, false alarm"
+sent_thread.first.update "Problem Resolved!"
+sent_thread.detect { |m| m =~ /Not yet safe/ }&.update do
+  text "it's safe now"
+end
+```
+
+## Configuration
+
+The only required setup is an OAuth token - each of these options can
+be set via ENV or `SlackLine.configure`:
+
+* `slack_token` or `SLACK_LINE_SLACK_TOKEN` (required) - this
+  allows the library to send messages and make API requests.
+* `look_up_users` or `SLACK_LINE_LOOK_UP_USERS` (default false) - if
+  your workspace refuses to turn `@somebody` mentions into links or
+  notifications, you can set this and we'll parse them out, then use
+  the slack API to map them to user/group IDs.
+* `bot_name` or `SLACK_LINE_BOT_NAME` - what to call the bot that's
+  posting (in slack). The default is to use its default name.
+* `default_channel` or `SLACK_LINE_DEFAULT_CHANNEL` - a target name
+  (either a channel with the leading pound-sign, or a user's handle
+  with a leading at-sign). When not supplied, all `send` calls are
+  required to specify a target instead.
+* `per_message_delay` or `SLACK_LINE_PER_MESSAGE_DELAY` is a float,
+  defaulting to 0.0. SlackLine will `sleep` for that duration after
+  each message is posted, to allow you to avoid hitting rate-limits
+  from posting many messages in a row.
+* `per_thread_delay` or `SLACK_LINE_PER_THREAD_DELAY` is a float as
+  well - SlackLine will `sleep` for this duration after each _thread_
+  is posted, and after each non-thread message is posted.
+
+You can just set those via the environment variables, but you can also
+set them on the singleton configuration object:
+
+```ruby
+SlackLine.configure do |config|
+  config.slack_token = ENV["SLACK_TOKEN"]
+  config.look_up_users = true
+  config.bot_name = "CI Bot"
+  config.default_channel = "#ci-flow"
+  config.per_message_delay = 0.2
+  config.per_thread_delay = 2.0
+end
+```
+
+## Multiple Configurations
+
+If you're working in a context where you need to support multiple
+SlackLine configurations, don't worry! The singleton central config is
+what the singleton central Client uses (that's what all of the top-level
+SlackLine methods dispatch to), but you can construct additional clients
+with their own configs easily:
+
+```ruby
+Slackline.configure do |config|
+  config.slack_token = ENV["TOKEN"]
+  config.default_channel = "#general"
+  config.bot_name = "FooBot"
+end
+
+# Now SlackLine.message (et al) will use SlackLine.client,
+# configured as above.
+
+BAR_SLACK = SlackLine::Client.new(default_channel: "#team-bar", bot_name: "BarBot")
+
+# And now you can call those methods on `BAR_SLACK` to use a different
+# default channel and name
+
+BAR_SLACK.thread("Message 1", "Message 2").post
+BAR_SLACK.message("Message 3", to: "#bar-team-3").post
+```

data/bin/slack_line_message

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/slack_line"
+require "optparse"
+require "reline"
+
+options = {
+  post_to: nil,
+  content: nil,
+  dsl: nil
+}
+
+configuration = SlackLine::Configuration.new(SlackLine.configuration)
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: build_slack_line_message [options] [content]"
+
+  opts.on("-t", "--slack-token TOKEN", "Slack API token") { |t| configuration.slack_token = t }
+  opts.on("-u", "--look-up-users", "Enable user look-up") { configuration.look_up_users = true }
+  opts.on("-n", "--bot-name NAME", "Bot name to use") { |n| configuration.bot_name = n }
+  opts.on("-p", "--post-to TARGET", "Channel or user post the message to") { |t| options[:post_to] = t }
+end.parse!
+
+if ARGV.empty?
+  warn "No content provided, reading (as dsl) from stdin. Control+D to finish:\n\n"
+  options[:dsl] = ""
+  while (line = Reline.readline("MSG> ", true))
+    options[:dsl] += line + "\n"
+  end
+else
+  options[:content] = ARGV.dup
+end
+
+client = SlackLine::Client.new(configuration)
+
+message =
+  if options[:content]
+    SlackLine::Message.new(*options[:content], client:)
+  else
+    SlackLine::Message.new(client:) { eval(options[:dsl]) }
+  end
+
+if options[:post_to]
+  message.post(to: options[:post_to])
+  warn "Posted message to #{options[:post_to]}"
+else
+  warn "Preview message at #{message.builder_url}\n\n"
+  puts JSON.pretty_generate(message.content.as_json)
+end

data/bin/slack_line_thread

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/slack_line"
+require "optparse"
+require "reline"
+
+options = {
+  post_to: nil,
+  content: nil,
+  dsl: nil
+}
+
+configuration = SlackLine::Configuration.new(SlackLine.configuration)
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: build_slack_line_message [options] [content]"
+
+  opts.on("-t", "--slack-token TOKEN", "Slack API token") { |t| configuration.slack_token = t }
+  opts.on("-u", "--look-up-users", "Enable user look-up") { configuration.look_up_users = true }
+  opts.on("-n", "--bot-name NAME", "Bot name to use") { |n| configuration.bot_name = n }
+  opts.on("-p", "--post-to TARGET", "Channel or user post the message to") { |t| options[:post_to] = t }
+end.parse!
+
+if ARGV.empty?
+  warn "No content provided, reading (as dsl) from stdin. Control+D to finish:\n\n"
+  options[:dsl] = ""
+  while (line = Reline.readline("THD> ", true))
+    options[:dsl] += line + "\n"
+  end
+else
+  options[:content] = ARGV.dup
+end
+
+client = SlackLine::Client.new(configuration)
+
+thread =
+  if options[:content]
+    SlackLine::Thread.new(*options[:content], client:)
+  else
+    SlackLine::Thread.new(client:) { eval(options[:dsl]) }
+  end
+
+if options[:post_to]
+  thread.post_to(options[:post_to])
+  warn "Posted thread to #{options[:post_to]}"
+else
+  warn "Preview messages at:"
+  thread.builder_urls.each { |url| warn "  #{url}" }
+
+  thread.each do |message|
+    puts "\n\n--------------------- Message ---------------------\n"
+    puts "Preview at: #{message.builder_url}\n\n"
+    puts JSON.pretty_generate(message.content.as_json)
+  end
+end

data/lib/slack_line/client.rb

@@ -0,0 +1,19 @@
+module SlackLine
+  class Client
+    include Memoization
+
+    def initialize(base_config = nil, **overrides)
+      @configuration = Configuration.new(base_config, **overrides)
+
+      raise ArgumentError, "slack_token is required" if @configuration.slack_token.nil?
+    end
+
+    attr_reader :configuration
+
+    memoize def slack_client = Slack::Web::Client.new(token: configuration.slack_token)
+
+    def message(*text_or_blocks, &dsl_block) = Message.new(*text_or_blocks, client: self, &dsl_block)
+
+    def thread(*messages, &dsl_block) = Thread.new(*messages, client: self, &dsl_block)
+  end
+end

data/lib/slack_line/configuration.rb

@@ -0,0 +1,54 @@
+module SlackLine
+  class Configuration
+    attr_accessor :slack_token,
+      :look_up_users, :bot_name, :default_channel,
+      :per_message_delay, :per_thread_delay
+
+    DEFAULTS = {
+      slack_token: nil,
+      look_up_users: false,
+      bot_name: nil,
+      default_channel: nil,
+      per_message_delay: 0.0,
+      per_thread_delay: 0.0
+    }.freeze
+
+    def initialize(base_config = nil, **overrides)
+      @base_config = base_config
+      @overrides = overrides
+
+      @slack_token = cascade(:slack_token, "SLACK_LINE_SLACK_TOKEN", :string)
+      @look_up_users = cascade(:look_up_users, "SLACK_LINE_LOOK_UP_USERS", :boolean)
+      @bot_name = cascade(:bot_name, "SLACK_LINE_BOT_NAME", :string)
+      @default_channel = cascade(:default_channel, "SLACK_LINE_DEFAULT_CHANNEL", :string)
+      @per_message_delay = cascade(:per_message_delay, "SLACK_LINE_PER_MESSAGE_DELAY", :float)
+      @per_thread_delay = cascade(:per_thread_delay, "SLACK_LINE_PER_THREAD_DELAY", :float)
+    end
+
+    private
+
+    def cascade(key, env_name, env_type)
+      if @overrides&.key?(key)
+        @overrides[key]
+      elsif @base_config
+        @base_config.public_send(key)
+      elsif ENV.key?(env_name)
+        from_env(env_name, env_type)
+      else
+        DEFAULTS[key]
+      end
+    end
+
+    def from_env(env_name, env_type)
+      value = ENV.fetch(env_name)
+
+      if env_type == :boolean
+        %w[1 true yes].include?(value.downcase)
+      elsif env_type == :float
+        value.to_f
+      else
+        value
+      end
+    end
+  end
+end

data/lib/slack_line/memoization.rb

@@ -0,0 +1,24 @@
+module SlackLine
+  module Memoization
+    def self.included(base) = base.extend(ClassMethods)
+
+    module ClassMethods
+      def memoize(method_name)
+        original_method = instance_method(method_name)
+
+        define_method(method_name) do |*args|
+          raise(ArgumentError, "Cannot memoize methods that take arguments") if args.any?
+
+          @memoization_cache ||= {}
+
+          if @memoization_cache.key?(method_name)
+            @memoization_cache[method_name]
+          else
+            result = original_method.bind_call(self)
+            @memoization_cache[method_name] = result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack_line/message.rb

@@ -0,0 +1,74 @@
+module SlackLine
+  class Message
+    extend Forwardable
+    include Memoization
+
+    def initialize(*text_or_blocks, client:, &dsl_block)
+      @text_or_blocks = text_or_blocks
+      @dsl_block = dsl_block
+      @client = client
+
+      validate!
+    end
+
+    memoize def content
+      if @dsl_block
+        MessageContext.new(&@dsl_block).content
+      elsif strings?(@text_or_blocks)
+        convert_multistring(*@text_or_blocks)
+      elsif blocks?(@text_or_blocks)
+        @text_or_blocks.first
+      end
+    end
+
+    # easier prototyping/verification. You can definitely construct illegal messages
+    # using the library in various ways, but if Slack's BlockKit Builder accepts it,
+    # it's probably right.
+    memoize def builder_url
+      blocks_json = {blocks: content_data}.to_json
+      escaped_json = CGI.escape(blocks_json)
+      "https://app.slack.com/block-kit-builder##{escaped_json}"
+    end
+
+    def post(to: nil, thread_ts: nil)
+      target = to || configuration.default_channel || raise(ConfigurationError, "No target channel specified and no default_channel configured.")
+      response = slack_client.chat_postMessage(channel: target, blocks: content_data, thread_ts:, username: configuration.bot_name)
+      SentMessage.new(content: content_data, response:, client:)
+    end
+
+    private
+
+    attr_reader :client
+    def_delegators :client, :slack_client, :configuration
+
+    def validate!
+      validate_xor!
+      validate_type!
+    end
+
+    def validate_xor!
+      raise(ArgumentError, "Provide either strings/Slack::BlockKit::Blocks, or a DSL block, not both.") if @dsl_block && @text_or_blocks.any?
+      raise(ArgumentError, "Provide either strings/Slack::BlockKit::Blocks, or a DSL block.") unless @dsl_block || @text_or_blocks.any?
+    end
+
+    def validate_type!
+      unless @text_or_blocks.empty? || blocks?(@text_or_blocks) || strings?(@text_or_blocks)
+        raise(ArgumentError, "Invalid content type: #{@text_or_blocks.class}")
+      end
+    end
+
+    def blocks?(obj) = obj.is_a?(Array) && obj.size == 1 && obj.first.is_a?(Slack::BlockKit::Blocks)
+
+    def strings?(obj) = obj.is_a?(Array) && obj.size > 0 && obj.all? { |item| item.is_a?(String) }
+
+    def convert_multistring(*strs)
+      Slack::BlockKit.blocks do |b|
+        strs.each do |str|
+          b.section { |s| s.mrkdwn(text: str) }
+        end
+      end
+    end
+
+    memoize def content_data = content.as_json
+  end
+end

data/lib/slack_line/message_context.rb

@@ -0,0 +1,30 @@
+module SlackLine
+  class MessageContext
+    def initialize(&block)
+      @content = ::Slack::BlockKit.blocks do |b|
+        @in_progress_blocks = b
+        instance_exec(&block)
+      ensure
+        @in_progress_blocks = nil
+      end
+    end
+
+    attr_reader :content
+
+    def text(content, plain: false)
+      @in_progress_blocks.section do |s|
+        plain ? s.plain_text(text: content) : s.mrkdwn(text: content)
+      end
+    end
+
+    def section(&block) = SectionContext.new(@in_progress_blocks, &block).content
+
+    def context(content, plain: false)
+      @in_progress_blocks.context do |c|
+        plain ? c.plain_text(text: content) : c.mrkdwn(text: content)
+      end
+    end
+
+    def divider = @in_progress_blocks.divider
+  end
+end

data/lib/slack_line/section_context.rb

@@ -0,0 +1,24 @@
+module SlackLine
+  class SectionContext
+    def initialize(parent_context, &block)
+      @content = parent_context.section do |s|
+        @in_progress_section = s
+        instance_exec(&block)
+      ensure
+        @in_progress_section = nil
+      end
+    end
+
+    attr_reader :content
+
+    def text(content, plain: false)
+      if plain
+        @in_progress_section.plain_text(text: content)
+      else
+        @in_progress_section.mrkdwn(text: content)
+      end
+    end
+
+    def link(text, url) = @in_progress_section.button(text: text, url: url, action_id: "link-button")
+  end
+end

data/lib/slack_line/sent_message.rb

@@ -0,0 +1,29 @@
+module SlackLine
+  class SentMessage
+    extend Forwardable
+
+    def initialize(response:, client:, content:, priorly: nil)
+      @content = content
+      @priorly = priorly
+      @response = response
+      @client = client
+    end
+
+    attr_reader :content, :priorly, :response
+    def_delegators :response, :ts, :channel
+
+    def inspect = "#<#{self.class} channel=#{channel.inspect} ts=#{ts.inspect}>"
+
+    def update(*text_or_blocks, &dsl_block)
+      updated_message = Message.new(*text_or_blocks, client:, &dsl_block)
+      new_content = updated_message.content.as_json
+      response = slack_client.chat_update(channel:, ts:, blocks: new_content)
+      SentMessage.new(content: new_content, priorly: content, response:, client:)
+    end
+
+    private
+
+    attr_reader :client
+    def_delegators :client, :slack_client
+  end
+end

data/lib/slack_line/sent_thread.rb

@@ -0,0 +1,18 @@
+module SlackLine
+  class SentThread
+    extend Forwardable
+    include Enumerable
+
+    def initialize(*sent_messages)
+      @sent_messages = sent_messages.freeze
+    end
+
+    attr_reader :sent_messages
+    alias_method :messages, :sent_messages
+    def_delegators :sent_messages, :each, :map, :size, :first, :last, :empty?
+    def_delegators :first, :channel, :ts
+    alias_method :thread_ts, :ts
+
+    def inspect = "#<#{self.class} channel=#{channel.inspect} size=#{size} thread_ts=#{thread_ts.inspect}>"
+  end
+end

data/lib/slack_line/thread.rb

@@ -0,0 +1,73 @@
+module SlackLine
+  class Thread
+    extend Forwardable
+    include Enumerable
+    include Memoization
+
+    def initialize(*supplied_messages, client:, &dsl_block)
+      @supplied_messages = supplied_messages
+      @dsl_block = dsl_block
+      @client = client
+
+      validate!
+    end
+
+    # an Array of SlackLine::Messages
+    memoize def messages = message_contents.map { |mc| convert_supplied_message(mc) }
+
+    def_delegators :messages, :each, :[], :length, :size, :empty?
+
+    memoize def builder_urls = messages.map(&:builder_url)
+
+    def post(to: nil)
+      target = to || client.configuration.default_channel || raise(ConfigurationError, "No target channel specified and no default_channel configured.")
+      sent_messages = []
+      thread_ts = nil
+
+      messages.each do |message|
+        sent = message.post(to: target, thread_ts:)
+        thread_ts ||= sent.ts
+        sent_messages << sent
+      end
+
+      SentThread.new(*sent_messages)
+    end
+
+    private
+
+    attr_reader :client
+    def_delegators :client, :slack_client, :configuration
+
+    def validate!
+      validate_xor!
+      validate_types!
+    end
+
+    def validate_xor!
+      raise(ArgumentError, "Provide either texts/blocks/Messages or a DSL block, not both.") if @dsl_block && @supplied_messages.any?
+      raise(ArgumentError, "Provide either texts/blocks/Messages or a DSL block.") unless @dsl_block || @supplied_messages.any?
+    end
+
+    def validate_types!
+      @supplied_messages.each do |sm|
+        unless sm.is_a?(String) || sm.is_a?(Slack::BlockKit::Blocks) || sm.is_a?(Message)
+          raise(ArgumentError, "Invalid message type: #{sm.class}. Excepted a String, Slack::BlockKit::Blocks, or SlackLine::Message.")
+        end
+      end
+    end
+
+    memoize def dsl_contents = ThreadContext.new(&@dsl_block).contents
+
+    # produces an Array of (mixed) Strings, Slack::BlockKit::Blocks, and SlackLine::Messages
+    # (ThreadContext will produce Strings and Blocks)
+    memoize def message_contents = @dsl_block ? dsl_contents : @supplied_messages
+
+    def convert_supplied_message(sm)
+      if sm.is_a?(String) || sm.is_a?(Slack::BlockKit::Blocks)
+        Message.new(sm, client:)
+      elsif sm.is_a?(Message)
+        sm
+      end
+    end
+  end
+end

data/lib/slack_line/thread_context.rb

@@ -0,0 +1,35 @@
+module SlackLine
+  class ThreadContext
+    def initialize(&block)
+      @contents = []
+      instance_exec(&block)
+    end
+
+    attr_reader :contents
+
+    def text(text)
+      fail(ArgumentError, "Text must be a String.") unless text.is_a?(String)
+
+      @contents << text
+    end
+
+    # supplied should be a String, Slack::BlockKit::Blocks, or an already constructed SlackLine::Message
+    def message(supplied = nil, &msg_block)
+      if (supplied && msg_block) || (!supplied && !msg_block)
+        fail(ArgumentError, "Provide either a supplied message or a message block, not both.")
+      end
+      validate_supplied_message!(supplied)
+
+      @contents << (supplied || MessageContext.new(&msg_block).content)
+    end
+
+    private
+
+    def validate_supplied_message!(sm)
+      expected_types = [NilClass, String, Slack::BlockKit::Blocks, SlackLine::Message]
+      unless expected_types.any? { |t| sm.is_a?(t) }
+        fail(ArgumentError, "Invalid message type: #{sm.class}. Expected a String, Slack::BlockKit::Blocks, or SlackLine::Message.")
+      end
+    end
+  end
+end

data/lib/slack_line/version.rb

@@ -0,0 +1,3 @@
+module SlackLine
+  VERSION = "0.1.0".freeze
+end

data/lib/slack_line.rb

@@ -0,0 +1,31 @@
+require "forwardable"
+require "slack-ruby-block-kit"
+require "slack-ruby-client"
+require "json"
+require "cgi"
+
+require_relative "slack_line/memoization"
+
+module SlackLine
+  Error = Class.new(StandardError)
+  ConfigurationError = Class.new(Error)
+  PostMessageError = Class.new(Error)
+
+  class << self
+    extend Forwardable
+    include Memoization
+
+    # The Singleton configuration object - used by the Singleton client,
+    # and as config defaults for other clients.
+    memoize def configuration = Configuration.new
+
+    def configure = yield(configuration)
+
+    memoize def client = Client.new(configuration)
+
+    def_delegators(:client, :message, :thread)
+  end
+end
+
+glob = File.expand_path("../slack_line/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require(f) }

data/slack_line.gemspec

@@ -0,0 +1,48 @@
+require_relative "lib/slack_line/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "slack_line"
+  spec.version = SlackLine::VERSION
+  spec.authors = ["Eric Mueller"]
+  spec.email = ["nevinera@gmail.com"]
+
+  spec.summary = "Build CLIs that are configured via args, file, and/or environment"
+  spec.description = <<~DESC
+    We've written code that merges/cascades default configuration, config-files,
+    environment variables, and cli-passed arguments _too many times_. This gem
+    intends to distill that into a configuration hash describing those controls
+    and relationships, so that users can supply values in multiple ways.
+  DESC
+  spec.homepage = "https://github.com/nevinera/slack_line"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.require_paths = ["lib"]
+  spec.bindir = "bin"
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`
+      .split("\x0")
+      .reject { |f| f.start_with?("spec") }
+  end
+  spec.executables = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z bin/`
+      .split("\x0")
+      .map { |path| path.sub(/^bin\//, "") }
+  end
+
+  spec.add_development_dependency "rspec", "~> 3.13"
+  spec.add_development_dependency "rspec-its", "~> 1.3"
+  spec.add_development_dependency "rspec-collection_matchers", "~> 1.2.1"
+  spec.add_development_dependency "simplecov", "~> 0.22.0"
+  spec.add_development_dependency "quiet_quality"
+  spec.add_development_dependency "pry", "~> 0.14"
+  spec.add_development_dependency "standard", ">= 1.35.1"
+  spec.add_development_dependency "rubocop", ">= 1.62"
+  spec.add_development_dependency "mdl", "~> 0.12"
+
+  spec.add_dependency "slack-ruby-block-kit", "~> 0.23.0"
+  spec.add_dependency "slack-ruby-client", "~> 3.1.0"
+end

metadata

@@ -0,0 +1,231 @@
+--- !ruby/object:Gem::Specification
+name: slack_line
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Eric Mueller
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec-collection_matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.22.0
+- !ruby/object:Gem::Dependency
+  name: quiet_quality
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.14'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.35.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.35.1
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.62'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.62'
+- !ruby/object:Gem::Dependency
+  name: mdl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: slack-ruby-block-kit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.23.0
+- !ruby/object:Gem::Dependency
+  name: slack-ruby-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+description: |
+  We've written code that merges/cascades default configuration, config-files,
+  environment variables, and cli-passed arguments _too many times_. This gem
+  intends to distill that into a configuration hash describing those controls
+  and relationships, so that users can supply values in multiple ways.
+email:
+- nevinera@gmail.com
+executables:
+- slack_line_message
+- slack_line_thread
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/linters.yml"
+- ".github/workflows/rspec.yml"
+- ".gitignore"
+- ".mdl_rules.rb"
+- ".mdlrc"
+- ".quiet_quality.yml"
+- ".rspec"
+- ".rubocop.yml"
+- ".standard.yml"
+- Gemfile
+- README.md
+- bin/slack_line_message
+- bin/slack_line_thread
+- lib/slack_line.rb
+- lib/slack_line/client.rb
+- lib/slack_line/configuration.rb
+- lib/slack_line/memoization.rb
+- lib/slack_line/message.rb
+- lib/slack_line/message_context.rb
+- lib/slack_line/section_context.rb
+- lib/slack_line/sent_message.rb
+- lib/slack_line/sent_thread.rb
+- lib/slack_line/thread.rb
+- lib/slack_line/thread_context.rb
+- lib/slack_line/version.rb
+- slack_line.gemspec
+homepage: https://github.com/nevinera/slack_line
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/nevinera/slack_line
+  source_code_uri: https://github.com/nevinera/slack_line
+post_install_message:
+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.5.22
+signing_key:
+specification_version: 4
+summary: Build CLIs that are configured via args, file, and/or environment
+test_files: []