slack-messenger 2.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f07dd2e13c155464bd8d99c0cbba74ff48da2d8e84a19ccbd5026070e9c95a78
+  data.tar.gz: 723e2b2a499ce27ab08b1d1920a20e6473802cba49232edcabc936ab5dbdd434
+SHA512:
+  metadata.gz: db2415864731bdc11c27c691c0d7ee70d6157517234fd6c7aa426b26824198818cfddc093e89851b17efbc9cd2262decfb0b4fba5fe18692a4d2d94b7ad07929
+  data.tar.gz: 834a3ba19a3919b8ea1faac84372077f98c5c4a8ba28ca6e6b0a3d310a80099b3184beeb16ec12b70b8690f4dea2542f79c718b82264358dadd839920f8c4c34

data/lib/slack-messenger.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "uri"
+require "json"
+
+require_relative "slack-messenger/util/http_client"
+require_relative "slack-messenger/util/link_formatter"
+require_relative "slack-messenger/util/escape"
+require_relative "slack-messenger/payload_middleware"
+require_relative "slack-messenger/config"
+
+module Slack
+  class Messenger
+    attr_reader :endpoint
+
+    def initialize webhook_url, options={}, &block
+      @endpoint = URI.parse webhook_url
+
+      config.http_client(options.delete(:http_client)) if options.key?(:http_client)
+      config.defaults options
+      config.instance_exec(&block) if block_given?
+
+      middleware.set config.middleware
+    end
+
+    def config
+      @_config ||= Config.new
+    end
+
+    def ping message, options={}
+      if message.is_a?(Hash)
+        options = message
+      else
+        options[:text] = message
+      end
+
+      post options
+    end
+
+    def post payload={}
+      params  = {}
+      client  = payload.delete(:http_client) || config.http_client
+      payload = config.defaults.merge(payload)
+
+      params[:http_options] = payload.delete(:http_options) if payload.key?(:http_options)
+
+      middleware.call(payload).map do |pld|
+        params[:payload] = pld.to_json
+        client.post endpoint, params
+      end
+    end
+
+    private
+
+      def middleware
+        @middleware ||= PayloadMiddleware::Stack.new(self)
+      end
+  end
+end

data/lib/slack-messenger/config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    class Config
+      def initialize
+        @http_client = Util::HTTPClient
+        @defaults    = {}
+        @middleware  = %i[
+          format_message
+          format_attachments
+          at
+          channels
+        ]
+      end
+
+      def http_client client=nil
+        return @http_client if client.nil?
+        raise ArgumentError, "the http client must respond to ::post" unless client.respond_to?(:post)
+
+        @http_client = client
+      end
+
+      def defaults new_defaults=nil
+        return @defaults if new_defaults.nil?
+        raise ArgumentError, "the defaults must be a Hash" unless new_defaults.is_a?(Hash)
+
+        @defaults = new_defaults
+      end
+
+      def middleware *args
+        return @middleware if args.empty?
+
+        @middleware =
+          if args.length == 1 && args.first.is_a?(Array) || args.first.is_a?(Hash)
+            args.first
+          else
+            args
+          end
+      end
+    end
+  end
+end

data/lib/slack-messenger/payload_middleware.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    class PayloadMiddleware
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register middleware, name
+          registry[name] = middleware
+        end
+      end
+    end
+  end
+end
+
+require_relative "payload_middleware/stack"
+require_relative "payload_middleware/base"
+require_relative "payload_middleware/format_message"
+require_relative "payload_middleware/format_attachments"
+require_relative "payload_middleware/at"
+require_relative "payload_middleware/channels"

data/lib/slack-messenger/payload_middleware/at.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    class PayloadMiddleware
+      class At < Base
+        middleware_name :at
+
+        options at: []
+
+        def call payload={}
+          return payload unless payload[:at]
+
+          payload[:text] = "#{format_ats(payload.delete(:at))}#{payload[:text]}"
+          payload
+        end
+
+        private
+
+          def format_ats ats
+            Array(ats).map { |at| "<#{at_cmd_char(at)}#{at}> " }
+                      .join("")
+          end
+
+          def at_cmd_char at
+            case at
+            when :here, :channel, :everyone, :group
+              "!"
+            else
+              "@"
+            end
+          end
+      end
+    end
+  end
+end

data/lib/slack-messenger/payload_middleware/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    class PayloadMiddleware
+      class Base
+        class << self
+          def middleware_name name
+            PayloadMiddleware.register self, name.to_sym
+          end
+
+          def options default_opts
+            @default_opts = default_opts
+          end
+
+          def default_opts
+            @default_opts ||= {}
+          end
+        end
+
+        attr_reader :messenger, :options
+
+        def initialize messenger, opts={}
+          @messenger = messenger
+          @options  = self.class.default_opts.merge opts
+        end
+
+        def call _payload={}
+          raise NoMethodError, "method `call` not defined for class #{self.class}"
+        end
+      end
+    end
+  end
+end

data/lib/slack-messenger/payload_middleware/channels.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    class PayloadMiddleware
+      class Channels < Base
+        middleware_name :channels
+
+        def call payload={}
+          return payload unless payload[:channel].respond_to?(:to_ary)
+
+          payload[:channel].to_ary.map do |channel|
+            pld = payload.dup
+            pld[:channel] = channel
+            pld
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack-messenger/payload_middleware/format_attachments.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    class PayloadMiddleware
+      class FormatAttachments < Base
+        middleware_name :format_attachments
+
+        options formats: %i[html markdown]
+
+        def call payload={}
+          payload = payload.dup
+          attachments = payload.delete(:attachments)
+          attachments ||= payload.delete("attachments")
+
+          attachments = wrap_array(attachments).map do |attachment|
+            ["text", :text].each do |key|
+              if attachment.key?(key)
+                attachment[key] = Util::LinkFormatter.format(attachment[key], options)
+              end
+            end
+
+            attachment
+          end
+
+          payload[:attachments] = attachments if attachments && !attachments.empty?
+          payload
+        end
+
+        private
+
+          def wrap_array object
+            if object.nil?
+              []
+            elsif object.respond_to?(:to_ary)
+              object.to_ary || [object]
+            else
+              [object]
+            end
+          end
+      end
+    end
+  end
+end

data/lib/slack-messenger/payload_middleware/format_message.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    class PayloadMiddleware
+      class FormatMessage < Base
+        middleware_name :format_message
+
+        options formats: %i[html markdown]
+
+        def call payload={}
+          return payload unless payload[:text]
+          payload[:text] = Util::LinkFormatter.format(payload[:text], options)
+
+          payload
+        end
+      end
+    end
+  end
+end

data/lib/slack-messenger/payload_middleware/stack.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    class PayloadMiddleware
+      class Stack
+        attr_reader :messenger,
+                    :stack
+
+        def initialize messenger
+          @messenger = messenger
+          @stack    = []
+        end
+
+        def set *middlewares
+          middlewares =
+            if middlewares.length == 1 && middlewares.first.is_a?(Hash)
+              middlewares.first
+            else
+              middlewares.flatten
+            end
+
+          @stack = middlewares.map do |key, opts|
+            PayloadMiddleware.registry.fetch(key).new(*[messenger, opts].compact)
+          end
+        end
+
+        def call payload={}
+          result = stack.inject payload do |pld, middleware|
+            as_array(pld).flat_map do |p|
+              middleware.call(p)
+            end
+          end
+
+          as_array(result)
+        end
+
+        private
+
+          def as_array args
+            if args.respond_to?(:to_ary)
+              args.to_ary
+            else
+              [args]
+            end
+          end
+      end
+    end
+  end
+end

data/lib/slack-messenger/util/escape.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    module Util
+      module Escape
+        HTML_REGEXP  = /[&><]/
+        HTML_REPLACE = { "&" => "&amp;", ">" => "&gt;", "<" => "&lt;" }.freeze
+
+        def self.html string
+          string.gsub(HTML_REGEXP, HTML_REPLACE)
+        end
+      end
+    end
+  end
+end

data/lib/slack-messenger/util/http_client.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module Slack
+  class Messenger
+    class APIError < StandardError; end
+
+    module Util
+      class HTTPClient
+        class << self
+          def post uri, params
+            HTTPClient.new(uri, params).call
+          end
+        end
+
+        attr_reader :uri, :params, :http_options
+
+        def initialize uri, params
+          @uri          = uri
+          @http_options = params.delete(:http_options) || {}
+          @params       = params
+        end
+
+        # rubocop:disable Layout/IndentHeredoc
+        def call
+          http_obj.request(request_obj).tap do |response|
+            unless response.is_a?(Net::HTTPSuccess)
+              raise Slack::Messenger::APIError, <<-MSG
+The slack API returned an error: #{response.body} (HTTP Code #{response.code})
+Check the "Handling Errors" section on https://api.slack.com/incoming-webhooks for more information
+MSG
+            end
+          end
+        end
+        # rubocop:enable Layout/IndentHeredoc
+
+        private
+
+          def request_obj
+            req = Net::HTTP::Post.new uri.request_uri
+            req.set_form_data params
+
+            req
+          end
+
+          def http_obj
+            http = Net::HTTP.new uri.host, uri.port
+            http.use_ssl = (uri.scheme == "https")
+
+            http_options.each do |opt, val|
+              if http.respond_to? "#{opt}="
+                http.send "#{opt}=", val
+              else
+                warn "Net::HTTP doesn't respond to `#{opt}=`, ignoring that option"
+              end
+            end
+
+            http
+          end
+      end
+    end
+  end
+end

data/lib/slack-messenger/util/link_formatter.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Slack
+  class Messenger
+    module Util
+      class LinkFormatter
+        # http://rubular.com/r/19cNXW5qbH
+        HTML_PATTERN = %r{
+          <a
+          (?:.*?)
+          href=['"](.+?)['"]
+          (?:.*?)>
+          (.+?)
+          </a>
+        }x
+
+        VALID_URI_CHARS = '\w\-\.\~\:\/\?\#\[\]\@\!\$\&\'\*\+\,\;\='
+
+        # Attempt at only matching pairs of parens per
+        # the markdown spec http://spec.commonmark.org/0.27/#links
+        #
+        # https://rubular.com/r/WfdZ1arvF6PNWO
+        MARKDOWN_PATTERN = %r{
+            \[ ([^\[\]]*?) \]
+            \(
+              ( (?:https?:\/\/|mailto:)
+              (?:[#{VALID_URI_CHARS}]*?|[#{VALID_URI_CHARS}]*?\([#{VALID_URI_CHARS}]*?\)[#{VALID_URI_CHARS}]*?) )
+            \)
+        }x
+
+        class << self
+          def format string, opts={}
+            LinkFormatter.new(string, opts).formatted
+          end
+        end
+
+        attr_reader :formats
+
+        def initialize string, formats: %i[html markdown]
+          @formats = formats
+          @orig    = string.respond_to?(:scrub) ? string.scrub : string
+        end
+
+        # rubocop:disable Lint/RescueWithoutErrorClass
+        def formatted
+          return @orig unless @orig.respond_to?(:gsub)
+
+          sub_markdown_links(sub_html_links(@orig))
+        rescue => e
+          raise e unless RUBY_VERSION < "2.1" && e.message.include?("invalid byte sequence")
+          raise e, "#{e.message}. Consider including the 'string-scrub' gem to strip invalid characters"
+        end
+        # rubocop:enable Lint/RescueWithoutErrorClass
+
+        private
+
+          def sub_html_links string
+            return string unless formats.include?(:html)
+
+            string.gsub(HTML_PATTERN) do
+              slack_link Regexp.last_match[1], Regexp.last_match[2]
+            end
+          end
+
+          def sub_markdown_links string
+            return string unless formats.include?(:markdown)
+
+            string.gsub(MARKDOWN_PATTERN) do
+              slack_link Regexp.last_match[2], Regexp.last_match[1]
+            end
+          end
+
+          def slack_link link, text=nil
+            "<#{link}" \
+            "#{text && !text.empty? ? "|#{text}" : ''}" \
+            ">"
+          end
+      end
+    end
+  end
+end