slack_line 0.1.0 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61c279b95b271ef984af73457248e82ab75a576aa46820bd59cacd8c8f6c8042
-  data.tar.gz: 57bc942d244ef3b45d95344ff0ab5bffb4412bc840016d2bf8e55450e1600742
+  metadata.gz: 5012be14f249f312a75b1d5cca149fd938eb2d6b66db4b51fb93789b3a4030e9
+  data.tar.gz: 6a4244475ce9b64db464f391d6dbfa0c8d6a1dc509854b1b05a6bc1149ad78de
 SHA512:
-  metadata.gz: 8dd4210ffac87ab836e38902287098458dc0368d785f22c4a70221cc949cef70a219c0a96ed2adb37098d634e1c98899d1b59719cf41cfd7a248fe4259b12956
-  data.tar.gz: 20e53e6fa522453b25513f4ddfb503b74a7e1f31153837d7fb1dacfe9c89db19b4e5a2b29839ed24d5ef999da6b8fb16bed94a2fd09c76825afa41a997c29af5
+  metadata.gz: 1bb9462733e8c15e292606d303c04d2c72855d9d141ebfd917b9f2bf415b964aad0dd34fd0832c1a74064f551272da0dfce670ae43047828ee0c89a8fd86f6c5
+  data.tar.gz: 455afd3746d46319fe637e924034655cfa9f42da2c06d8c30a3f578ed70e2245811f6f7a5404d37939360cdb47309a966485d8151ec41e578724fb494c222a18

data/README.md

@@ -121,3 +121,14 @@ BAR_SLACK = SlackLine::Client.new(default_channel: "#team-bar", bot_name: "BarBo
 BAR_SLACK.thread("Message 1", "Message 2").post
 BAR_SLACK.message("Message 3", to: "#bar-team-3").post
 ```
+
+## Slack App Permissions
+
+In order to post/update messages, the app behind your `SLACK_LINE_TOKEN` can use these permissions:
+
+* `chat:write` - send messages at all.
+* `chat:write.public` - send messages to public channels your app _isn't a member of_ (so you don't
+  need to invite them to the relevant channels to make them work).
+* `im:write` - start direct messages with individuals.
+* `users:read` and `usergroups:read` - look up users/groups for (a) messaging them directly or
+  (b) supporting the `look_up_users` config option (for those more restrictive workspaces)

data/bin/slack_line_message

@@ -1,49 +1,9 @@
 #!/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)
+begin
+  SlackLine::Cli::SlackLineMessage.new(argv: ARGV).run
+rescue SlackLine::Cli::ExitException => e
+  abort e.message
 end

data/bin/slack_line_thread

@@ -1,55 +1,9 @@
 #!/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
+begin
+  SlackLine::Cli::SlackLineThread.new(argv: ARGV).run
+rescue SlackLine::Cli::ExitException => e
+  abort e.message
 end

data/lib/slack_line/cli/slack_line_message.rb

@@ -0,0 +1,154 @@
+require "optparse"
+require "reline"
+
+module SlackLine
+  module Cli
+    class SlackLineMessage
+      def initialize(argv:, stdout: $stdout, stderr: $stderr)
+        @argv = argv
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def run
+        if options[:append]
+          run_append
+        elsif options[:update]
+          run_update
+        elsif options[:post_to]
+          run_post
+        else
+          run_preview
+        end
+      end
+
+      def options
+        return @options if defined?(@options)
+        opts = {post_to: nil, append: nil, update: nil, message_number: nil, save: nil, slack_token: nil, look_up_users: nil, bot_name: nil, backoff: nil}
+        remaining = option_parser(opts).parse(@argv.dup)
+        if remaining.empty?
+          opts[:dsl] = read_stdin
+        else
+          opts[:content] = remaining
+        end
+        validate_options!(opts)
+        @options = opts
+      end
+
+      def configuration
+        return @configuration if defined?(@configuration)
+        cfg_opts = options.slice(:slack_token, :look_up_users, :bot_name, :backoff).compact
+        @configuration = Configuration.new(nil, **cfg_opts)
+      end
+
+      private
+
+      attr_reader :stdout, :stderr
+
+      def option_parser(opts) # rubocop:disable Metrics/AbcSize
+        OptionParser.new do |parser|
+          parser.on("-t", "--slack-token TOKEN") { |t| opts[:slack_token] = t }
+          parser.on("-u", "--look-up-users") { opts[:look_up_users] = true }
+          parser.on("-n", "--bot-name NAME") { |n| opts[:bot_name] = n }
+          parser.on("-p", "--post-to TARGET") { |t| opts[:post_to] = t }
+          parser.on("-a", "--append PATH") { |p| opts[:append] = p }
+          parser.on("-U", "--update PATH") { |p| opts[:update] = p }
+          parser.on("-m", "--message-number N", Integer) { |n| opts[:message_number] = n }
+          parser.on("-s", "--save PATH") { |p| opts[:save] = p }
+          parser.on("--no-backoff") { opts[:backoff] = false }
+        end
+      end
+
+      def validate_options!(opts)
+        if [opts[:post_to], opts[:append], opts[:update]].compact.size > 1
+          raise(ExitException, "Only one of --post-to, --append, or --update can be used at a time")
+        end
+        raise ExitException, "--message-number requires --update" if opts[:message_number] && !opts[:update]
+        raise ExitException, "--message-number cannot be less than 0" if opts[:message_number] && opts[:message_number] < 0
+      end
+
+      def read_stdin
+        stderr.puts "No content provided, reading (as dsl) from stdin. Control+D to finish:\n\n"
+        lines = []
+        while (line = Reline.readline("MSG> ", true))
+          lines << line
+        end
+        lines.join("\n")
+      end
+
+      def client = @client ||= Client.new(configuration)
+
+      def load_json(path, client:) = SlackLine.from_json(JSON.parse(File.read(path)), client:)
+
+      def save(result) = File.write(options[:save], JSON.pretty_generate(result.as_json))
+
+      def message
+        @message ||=
+          if options[:content]
+            Message.new(*options[:content], client:)
+          else
+            dsl = options[:dsl]
+            Message.new(client:) { eval(dsl) } # standard:disable Security/Eval
+          end
+      end
+
+      def append_target = @append_target ||= load_json(options[:append], client:)
+
+      def run_append
+        sent_thread = append_target.append(message)
+        stderr.puts "Appended to thread in #{sent_thread.channel}"
+        save(sent_thread) if options[:save]
+      end
+
+      def update_target = @update_target ||= load_json(options[:update], client:)
+
+      def validate_update_flags!
+        message_number = options[:message_number]
+        if update_target.is_a?(SentMessage)
+          raise(ExitException, "--message-number cannot be used when updating a single message") if message_number
+        elsif message_number.nil?
+          raise(ExitException, "--message-number is required when updating a thread")
+        elsif message_number >= update_target.size
+          raise(ExitException, "--message-number #{message_number} is out of range (thread has #{update_target.size} messages)")
+        end
+      end
+
+      def message_to_update
+        return @message_to_update if defined?(@message_to_update)
+
+        validate_update_flags!
+        if update_target.is_a?(SentMessage)
+          @message_to_update = update_target
+        else
+          msg_num = options[:message_number]
+          @message_to_update = update_target.sent_messages[msg_num]
+        end
+      end
+
+      def run_update
+        updated_msg = message_to_update.update(message)
+        result = update_target.is_a?(SentThread) ? rebuilt_thread(updated_msg) : updated_msg
+        type = update_target.is_a?(SentThread) ? "thread" : "message"
+        stderr.puts "Updated #{type} in #{result.channel}"
+        save(result) if options[:save]
+      end
+
+      def rebuilt_thread(updated_msg)
+        idx = options[:message_number]
+        msgs = update_target.sent_messages
+        SentThread.new(*msgs[0...idx], updated_msg, *msgs[(idx + 1)..])
+      end
+
+      def run_post
+        sent = message.post(to: options[:post_to])
+        stderr.puts "Posted message to #{options[:post_to]}"
+        save(sent) if options[:save]
+      end
+
+      def run_preview
+        stderr.puts "Preview message at #{message.builder_url}\n\n"
+        stdout.puts JSON.pretty_generate(message.content.as_json)
+      end
+    end
+  end
+end

data/lib/slack_line/cli/slack_line_thread.rb

@@ -0,0 +1,96 @@
+require "optparse"
+require "reline"
+
+module SlackLine
+  module Cli
+    class SlackLineThread
+      def initialize(argv:, stdout: $stdout, stderr: $stderr)
+        @argv = argv
+        @stdout = stdout
+        @stderr = stderr
+      end
+
+      def run
+        if options[:post_to]
+          run_post
+        else
+          run_preview
+        end
+      end
+
+      def options
+        return @options if defined?(@options)
+        opts = {post_to: nil, save: nil, slack_token: nil, look_up_users: nil, bot_name: nil, backoff: nil}
+        remaining = option_parser(opts).parse(@argv.dup)
+        if remaining.empty?
+          opts[:dsl] = read_stdin
+        else
+          opts[:content] = remaining
+        end
+        @options = opts
+      end
+
+      def configuration
+        return @configuration if defined?(@configuration)
+        cfg_opts = options.slice(:slack_token, :look_up_users, :bot_name, :backoff).compact
+        @configuration = Configuration.new(nil, **cfg_opts)
+      end
+
+      private
+
+      attr_reader :stdout, :stderr
+
+      def option_parser(opts)
+        OptionParser.new do |parser|
+          parser.on("-t", "--slack-token TOKEN") { |t| opts[:slack_token] = t }
+          parser.on("-u", "--look-up-users") { opts[:look_up_users] = true }
+          parser.on("-n", "--bot-name NAME") { |n| opts[:bot_name] = n }
+          parser.on("-p", "--post-to TARGET") { |t| opts[:post_to] = t }
+          parser.on("-s", "--save PATH") { |p| opts[:save] = p }
+          parser.on("--no-backoff") { opts[:backoff] = false }
+        end
+      end
+
+      def read_stdin
+        stderr.puts "No content provided, reading (as dsl) from stdin. Control+D to finish:\n\n"
+        lines = []
+        while (line = Reline.readline("THD> ", true))
+          lines << line
+        end
+        lines.join("\n")
+      end
+
+      def client = @client ||= Client.new(configuration)
+
+      def save(result) = File.write(options[:save], JSON.pretty_generate(result.as_json))
+
+      def thread
+        @thread ||=
+          if options[:content]
+            Thread.new(*options[:content], client:)
+          else
+            dsl = options[:dsl]
+            Thread.new(client:) { eval(dsl) } # standard:disable Security/Eval
+          end
+      end
+
+      def run_post
+        sent = thread.post(to: options[:post_to])
+        stderr.puts "Posted thread to #{options[:post_to]}"
+        save(sent) if options[:save]
+      end
+
+      def preview_message(message)
+        stdout.puts "\n\n--------------------- Message ---------------------\n"
+        stdout.puts "Preview at: #{message.builder_url}\n\n"
+        stdout.puts JSON.pretty_generate(message.content.as_json)
+      end
+
+      def run_preview
+        stderr.puts "Preview messages at:"
+        thread.builder_urls.each { |url| stderr.puts "  #{url}" }
+        thread.each { |message| preview_message(message) }
+      end
+    end
+  end
+end

data/lib/slack_line/cli.rb

@@ -0,0 +1,8 @@
+module SlackLine
+  module Cli
+    ExitException = Class.new(StandardError)
+  end
+end
+
+glob = File.expand_path("../cli/*.rb", __FILE__)
+Dir.glob(glob).sort.each { |f| require(f) }

data/lib/slack_line/client.rb

@@ -15,5 +15,9 @@ module SlackLine
     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)
+
+    memoize def users = Users.new(slack_client:)
+
+    memoize def groups = Groups.new(slack_client:)
   end
 end

data/lib/slack_line/configuration.rb

@@ -2,7 +2,10 @@ module SlackLine
   class Configuration
     attr_accessor :slack_token,
       :look_up_users, :bot_name, :default_channel,
-      :per_message_delay, :per_thread_delay
+      :per_message_delay, :per_thread_delay,
+      :backoff
+
+    alias_method :look_up_users?, :look_up_users
 
     DEFAULTS = {
       slack_token: nil,
@@ -10,7 +13,8 @@ module SlackLine
       bot_name: nil,
       default_channel: nil,
       per_message_delay: 0.0,
-      per_thread_delay: 0.0
+      per_thread_delay: 0.0,
+      backoff: true
     }.freeze
 
     def initialize(base_config = nil, **overrides)
@@ -23,6 +27,7 @@ module SlackLine
       @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)
+      @backoff = cascade(:backoff, "SLACK_LINE_NO_BACKOFF", :inverse_boolean)
     end
 
     private
@@ -44,6 +49,8 @@ module SlackLine
 
       if env_type == :boolean
         %w[1 true yes].include?(value.downcase)
+      elsif env_type == :inverse_boolean
+        !%w[1 true yes].include?(value.downcase)
       elsif env_type == :float
         value.to_f
       else

data/lib/slack_line/groups.rb

@@ -0,0 +1,25 @@
+module SlackLine
+  class Groups
+    include Memoization
+
+    def initialize(slack_client:)
+      @slack_client = slack_client
+    end
+
+    memoize def all = fetch_groups
+
+    def find(handle:)
+      groups_by_handle[handle.downcase]
+    end
+
+    private
+
+    attr_reader :slack_client
+
+    memoize def fetch_groups
+      slack_client.usergroups_list.usergroups || []
+    end
+
+    memoize def groups_by_handle = all.map { |g| [g.handle.downcase, g] }.to_h
+  end
+end

data/lib/slack_line/message.rb

@@ -30,11 +30,7 @@ module SlackLine
       "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
+    def post(to: nil, thread_ts: nil) = MessageSender.new(message: self, client:, to:, thread_ts:).post
 
     private
 

data/lib/slack_line/message_converter.rb

@@ -0,0 +1,49 @@
+module SlackLine
+  class MessageConverter
+    def initialize(blocks, client:)
+      @blocks = blocks
+      @client = client
+    end
+
+    def convert = resolve_mentions(@blocks)
+
+    private
+
+    attr_reader :client
+
+    def resolve_mentions(json)
+      case json
+      when Array then resolve_mentions_in_array(json)
+      when Hash then resolve_mentions_in_hash(json)
+      else json
+      end
+    end
+
+    def resolve_mentions_in_array(array)
+      array.map { |item| resolve_mentions(item) }
+    end
+
+    def resolve_mentions_in_hash(hash)
+      text_key = hash.key?(:text) ? :text : "text"
+      type_key = hash.key?(:type) ? :type : "type"
+      if hash[type_key] == "mrkdwn" && hash[text_key].is_a?(String)
+        hash.merge(text_key => substitute_mentions(hash[text_key]))
+      else
+        hash.transform_values { |v| resolve_mentions(v) }
+      end
+    end
+
+    def substitute_mentions(text)
+      text.gsub(/@([\w-]+)/) do |match|
+        token = $1
+        if (user = client.users.find(display_name: token))
+          "<@#{user.id}>"
+        elsif (group = client.groups.find(handle: token))
+          "<!subteam^#{group.id}>"
+        else
+          match
+        end
+      end
+    end
+  end
+end

data/lib/slack_line/message_sender.rb

@@ -0,0 +1,75 @@
+module SlackLine
+  class MessageSender
+    extend Forwardable
+    include Memoization
+
+    def initialize(message:, client:, to: nil, thread_ts: nil)
+      @message = message
+      @client = client
+      @to = to
+      @thread_ts = thread_ts
+    end
+
+    def post = SentMessage.new(content: content_data, response: api_response, client:)
+
+    private
+
+    memoize def supplied_target
+      to ||
+        configuration.default_channel ||
+        raise(ConfigurationError, "No target channel specified and no default_channel configured.")
+    end
+
+    memoize def target
+      if supplied_target.start_with?("@")
+        name = supplied_target[1..]
+        client.users.find(display_name: name)&.id ||
+          raise(UserNotFoundError, "User with display name '#{name}' was not found.")
+      else
+        supplied_target
+      end
+    end
+
+    MAX_RETRIES = 2
+
+    memoize def api_response
+      if configuration.backoff
+        with_rate_limit_backoff { call_api }
+      else
+        call_api
+      end
+    end
+
+    def call_api
+      slack_client.chat_postMessage(
+        channel: target,
+        blocks: content_data,
+        thread_ts: thread_ts,
+        username: configuration.bot_name
+      )
+    end
+
+    def with_rate_limit_backoff
+      retries = 0
+      begin
+        yield
+      rescue Slack::Web::Api::Errors::TooManyRequestsError => e
+        raise if retries >= MAX_RETRIES
+        retries += 1
+        sleep(e.retry_after)
+        retry
+      end
+    end
+
+    attr_reader :message, :to, :thread_ts, :client
+    def_delegators :client, :configuration, :slack_client
+    def_delegators :message, :content
+    def_delegators :configuration, :look_up_users?
+
+    memoize def raw_content_data = content.as_json
+
+    memoize def converter = MessageConverter.new(raw_content_data, client:)
+
+    memoize def content_data = look_up_users? ? converter.convert : raw_content_data
+  end
+end

data/lib/slack_line/sent_message.rb

@@ -12,11 +12,33 @@ module SlackLine
     attr_reader :content, :priorly, :response
     def_delegators :response, :ts, :channel
 
+    def thread_ts = response.thread_ts || ts
+
     def inspect = "#<#{self.class} channel=#{channel.inspect} ts=#{ts.inspect}>"
 
+    def as_json
+      {"type" => "message", "ts" => ts, "channel" => channel,
+       "thread_ts" => response.thread_ts, "content" => content, "priorly" => priorly}
+    end
+
+    def self.from_json(data, client:)
+      raise ArgumentError, "Expected type 'message', got #{data["type"].inspect}" unless data["type"] == "message"
+
+      response_hash = {ts: data["ts"], channel: data["channel"]}
+      response_hash[:thread_ts] = data["thread_ts"] if data["thread_ts"]
+      response = Slack::Messages::Message.new(response_hash)
+      new(response:, client:, content: data["content"], priorly: data["priorly"])
+    end
+
+    def append(*text_or_blocks, &dsl_block)
+      appended = Thread.new(*text_or_blocks, client:, &dsl_block)
+      new_sent = appended.messages.map { |m| m.post(to: channel, thread_ts:) }
+      SentThread.new(self, *new_sent)
+    end
+
     def update(*text_or_blocks, &dsl_block)
-      updated_message = Message.new(*text_or_blocks, client:, &dsl_block)
-      new_content = updated_message.content.as_json
+      replacement = replacement_message(*text_or_blocks, &dsl_block)
+      new_content = replacement.content.as_json
       response = slack_client.chat_update(channel:, ts:, blocks: new_content)
       SentMessage.new(content: new_content, priorly: content, response:, client:)
     end
@@ -25,5 +47,11 @@ module SlackLine
 
     attr_reader :client
     def_delegators :client, :slack_client
+
+    def replacement_message(*text_or_blocks, &dsl_block)
+      return text_or_blocks.first if text_or_blocks.size == 1 && text_or_blocks.first.is_a?(Message)
+
+      Message.new(*text_or_blocks, client:, &dsl_block)
+    end
   end
 end

data/lib/slack_line/sent_thread.rb

@@ -13,6 +13,21 @@ module SlackLine
     def_delegators :first, :channel, :ts
     alias_method :thread_ts, :ts
 
+    def append(*text_or_blocks, &dsl_block)
+      extended = first.append(*text_or_blocks, &dsl_block)
+      SentThread.new(*sent_messages, *extended.sent_messages[1..])
+    end
+
     def inspect = "#<#{self.class} channel=#{channel.inspect} size=#{size} thread_ts=#{thread_ts.inspect}>"
+
+    def as_json
+      {"type" => "thread", "messages" => sent_messages.map(&:as_json)}
+    end
+
+    def self.from_json(data, client:)
+      raise ArgumentError, "Expected type 'thread', got #{data["type"].inspect}" unless data["type"] == "thread"
+
+      new(*data["messages"].map { |m| SentMessage.from_json(m, client:) })
+    end
   end
 end

data/lib/slack_line/thread.rb

@@ -20,12 +20,11 @@ module SlackLine
     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:)
+        sent = message.post(to:, thread_ts:)
         thread_ts ||= sent.ts
         sent_messages << sent
       end

data/lib/slack_line/users.rb

@@ -0,0 +1,44 @@
+module SlackLine
+  class Users
+    include Memoization
+
+    def initialize(slack_client:)
+      @slack_client = slack_client
+    end
+
+    memoize def all = all_users.reject(&:deleted).reject(&:is_bot)
+
+    def find(display_name:)
+      users_by_display_name[display_name.downcase]
+    end
+
+    private
+
+    attr_reader :slack_client
+
+    def fetch_page(cursor: nil)
+      params = {limit: 200}
+      params[:cursor] = cursor if cursor
+
+      response = slack_client.users_list(params)
+      users = response.members || []
+      next_cursor = response.dig("response_metadata", "next_cursor")
+
+      [users, next_cursor]
+    end
+
+    memoize def all_users
+      all_users, cursor = fetch_page
+
+      while cursor
+        users, cursor = fetch_page(cursor:)
+        all_users.concat(users)
+        break if cursor.nil? || cursor.empty?
+      end
+
+      all_users
+    end
+
+    memoize def users_by_display_name = all.map { |u| [u.profile.display_name.downcase, u] }.to_h
+  end
+end

data/lib/slack_line/version.rb

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

data/lib/slack_line.rb

@@ -10,6 +10,7 @@ module SlackLine
   Error = Class.new(StandardError)
   ConfigurationError = Class.new(Error)
   PostMessageError = Class.new(Error)
+  UserNotFoundError = Class.new(Error)
 
   class << self
     extend Forwardable
@@ -24,6 +25,14 @@ module SlackLine
     memoize def client = Client.new(configuration)
 
     def_delegators(:client, :message, :thread)
+
+    TYPES = {"message" => ->(data, client:) { SentMessage.from_json(data, client:) },
+             "thread" => ->(data, client:) { SentThread.from_json(data, client:) }}.freeze
+
+    def from_json(data, client:)
+      loader = TYPES[data["type"]] or raise(ArgumentError, "Unknown type #{data["type"].inspect}")
+      loader.call(data, client:)
+    end
   end
 end
 

data/slack_line.gemspec

@@ -25,11 +25,12 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`
       .split("\x0")
-      .reject { |f| f.start_with?("spec") }
+      .reject { |f| f.start_with?("spec", "bin/qa") }
   end
   spec.executables = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z bin/`
       .split("\x0")
+      .reject { |f| f.start_with?("bin/qa") }
       .map { |path| path.sub(/^bin\//, "") }
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slack_line
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: '1.0'
 platform: ruby
 authors:
 - Eric Mueller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-31 00:00:00.000000000 Z
+date: 2026-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -191,16 +191,23 @@ files:
 - bin/slack_line_message
 - bin/slack_line_thread
 - lib/slack_line.rb
+- lib/slack_line/cli.rb
+- lib/slack_line/cli/slack_line_message.rb
+- lib/slack_line/cli/slack_line_thread.rb
 - lib/slack_line/client.rb
 - lib/slack_line/configuration.rb
+- lib/slack_line/groups.rb
 - lib/slack_line/memoization.rb
 - lib/slack_line/message.rb
 - lib/slack_line/message_context.rb
+- lib/slack_line/message_converter.rb
+- lib/slack_line/message_sender.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/users.rb
 - lib/slack_line/version.rb
 - slack_line.gemspec
 homepage: https://github.com/nevinera/slack_line