slack-notifier 1.5.1 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e74413c9d125dd2a973d6035bdc86e6f28549839
-  data.tar.gz: 6081e63972a12dc07acc866e13f8e6bae8a1992d
+SHA256:
+  metadata.gz: 2b0deceb91f70d0812f01b82db70eacb8dbf01d4d1985ca02375ac13b36d829e
+  data.tar.gz: 5ec7d0eb36e91bbee6f510411646b4c57935aa661706b791e1dc0941fa66dbd9
 SHA512:
-  metadata.gz: 252d1d23a8bb02cfe9ebee51c8d68436799daa59c95572dd18bc481797069ed2fa6fac96869845ffeae900fbf5d73c9df9b4e910f9190f7ca85937293e8d3e31
-  data.tar.gz: bda7747d3bd8e34a0ca2798d50c06c4f2b6e426c2552c2d389247f6ed60ce48a82d26e7f77e7e9c179388e831163d36a237dfe139cdddec689fdb154ee3b7d1b
+  metadata.gz: 0d42ebede5966444cf3101f9410f442e3fad0cdd3a9a7a25f67ff8c068c474bbd49f08d120070cca8652ffd351d68e99f90f648090b97469e3519761b167f513
+  data.tar.gz: 950d6e0ebc557de14b56b8ea5982e6057eb54530ec7b5b406f3c28ca22c3aaf26744c2ce6d69654b39bc75c8525d43204687b8adb97c331cf21c91f9629bd97f

data/lib/slack-notifier/config.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    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-notifier/payload_middleware/at.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    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-notifier/payload_middleware/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    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 :notifier, :options
+
+        def initialize notifier, opts={}
+          @notifier = notifier
+          @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-notifier/payload_middleware/channels.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    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-notifier/payload_middleware/format_attachments.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    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-notifier/payload_middleware/format_message.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    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-notifier/payload_middleware/stack.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    class PayloadMiddleware
+      class Stack
+        attr_reader :notifier,
+                    :stack
+
+        def initialize notifier
+          @notifier = notifier
+          @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(*[notifier, 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-notifier/payload_middleware.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    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-notifier/util/escape.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    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-notifier/util/http_client.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module Slack
+  class Notifier
+    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::Notifier::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-notifier/util/link_formatter.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Slack
+  class Notifier
+    module Util
+      class LinkFormatter
+        # http://rubular.com/r/19cNXW5qbH
+        HTML_PATTERN = %r{
+          <a
+          (?:.*?)
+          href=['"](.+?)['"]
+          (?:.*?)>
+          (.+?)
+          </a>
+        }x
+
+        # the path portion of a url can contain these characters
+        VALID_PATH_CHARS = '\w\-\.\~\/\?\#\='
+
+        # Attempt at only matching pairs of parens per
+        # the markdown spec http://spec.commonmark.org/0.27/#links
+        #
+        # http://rubular.com/r/y107aevxqT
+        MARKDOWN_PATTERN = %r{
+            \[ ([^\[\]]*?) \]
+            \( ((https?://.*?) | (mailto:.*?)) \)
+            (?! [#{VALID_PATH_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

data/lib/slack-notifier/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Slack
   class Notifier
-    VERSION = "1.5.1"
+    VERSION = "2.4.0".freeze # rubocop:disable Style/RedundantFreeze
   end
 end

data/lib/slack-notifier.rb

@@ -1,81 +1,59 @@
-require 'net/http'
-require 'uri'
-require 'json'
+# frozen_string_literal: true
 
-require_relative 'slack-notifier/default_http_client'
-require_relative 'slack-notifier/link_formatter'
+require "uri"
+require "json"
+
+require_relative "slack-notifier/util/http_client"
+require_relative "slack-notifier/util/link_formatter"
+require_relative "slack-notifier/util/escape"
+require_relative "slack-notifier/payload_middleware"
+require_relative "slack-notifier/config"
 
 module Slack
   class Notifier
-    attr_reader :endpoint, :default_payload
-
-    def initialize webhook_url, options={}
-      @endpoint        = URI.parse webhook_url
-      @default_payload = options
-    end
-
-    def ping message, options={}
-      if message.is_a?(Hash)
-        message, options = nil, message
-      end
-
-      if attachments = options[:attachments] || options["attachments"]
-        wrap_array(attachments).each do |attachment|
-          ["text", :text].each do |key|
-            attachment[key] = LinkFormatter.format(attachment[key]) if attachment.has_key?(key)
-          end
-        end
-      end
+    attr_reader :endpoint
 
-      payload      = default_payload.merge(options)
-      client       = payload.delete(:http_client) || http_client
-      http_options = payload.delete(:http_options)
+    def initialize webhook_url, options={}, &block
+      @endpoint = URI.parse webhook_url
 
-      unless message.nil?
-        payload.merge!(text: LinkFormatter.format(message))
-      end
-
-      params = { payload: payload.to_json }
-      params[:http_options] = http_options if http_options
+      config.http_client(options.delete(:http_client)) if options.key?(:http_client)
+      config.defaults options
+      config.instance_exec(&block) if block_given?
 
-      client.post endpoint, params
+      middleware.set config.middleware
     end
 
-    def http_client
-      default_payload.fetch :http_client, DefaultHTTPClient
+    def config
+      @_config ||= Config.new
     end
 
-    def channel
-      default_payload[:channel]
-    end
+    def ping message, options={}
+      if message.is_a?(Hash)
+        options = message
+      else
+        options[:text] = message
+      end
 
-    def channel= channel
-      default_payload[:channel] = channel
+      post options
     end
 
-    def username
-      default_payload[:username]
-    end
+    def post payload={}
+      params  = {}
+      client  = payload.delete(:http_client) || config.http_client
+      payload = config.defaults.merge(payload)
 
-    def username= username
-      default_payload[:username] = username
-    end
+      params[:http_options] = payload.delete(:http_options) if payload.key?(:http_options)
 
-    HTML_ESCAPE_REGEXP = /[&><]/
-    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;' }
-
-    def escape(text)
-      text.gsub(HTML_ESCAPE_REGEXP, HTML_ESCAPE)
+      middleware.call(payload).map do |pld|
+        params[:payload] = pld.to_json
+        client.post endpoint, params
+      end
     end
 
-    def wrap_array(object)
-      if object.nil?
-        []
-      elsif object.respond_to?(:to_ary)
-        object.to_ary || [object]
-      else
-        [object]
+    private
+
+      def middleware
+        @middleware ||= PayloadMiddleware::Stack.new(self)
       end
-    end
   end
 end

data/spec/end_to_end_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+RSpec.describe Slack::Notifier do
+  {
+    { text: "hello" } =>
+    { payload: { text: "hello" } },
+
+    { text: "[hello](http://example.com/world)" } =>
+    { payload: { text: "<http://example.com/world|hello>" } },
+
+    { text: '<a href="http://example.com">example</a>' } =>
+    { payload: { text: "<http://example.com|example>" } },
+
+    { text: "hello/こんにちは from notifier test" } =>
+    { payload: { text: "hello/こんにちは from notifier test" } },
+
+    { text: "Hello World, enjoy [](http://example.com)." } =>
+    { payload: { text: "Hello World, enjoy <http://example.com>." } },
+
+    { text: "Hello World, enjoy [this](http://example.com)[this2](http://example2.com)" } =>
+    { payload: { text: "Hello World, enjoy <http://example.com|this><http://example2.com|this2>" } },
+
+    { text: "[John](mailto:john@example.com)" } =>
+    { payload: { text: "<mailto:john@example.com|John>" } },
+
+    { text: '<a href="mailto:john@example.com">John</a>' } =>
+    { payload: { text: "<mailto:john@example.com|John>" } },
+
+    { text: "hello", channel: "hodor" } =>
+    { payload: { text: "hello", channel: "hodor" } },
+
+    { text: nil, attachments: [{ text: "attachment message" }] } =>
+    { payload: { text: nil, attachments: [{ text: "attachment message" }] } },
+
+    { text: "the message", channel: "foo", attachments: [{ color: "#000",
+                                                           text: "attachment message",
+                                                           fallback: "fallback message" }] } =>
+    { payload: { text: "the message",
+                 channel: "foo",
+                 attachments: [{ color: "#000",
+                                 text: "attachment message",
+                                 fallback: "fallback message" }] } },
+
+    { attachments: [{ color: "#000",
+                      text: "attachment message",
+                      fallback: "fallback message" }] } =>
+    { payload: { attachments: [{ color: "#000",
+                                 text: "attachment message",
+                                 fallback: "fallback message" }] } },
+
+    { attachments: { color: "#000",
+                     text: "attachment message [hodor](http://winterfell.com)",
+                     fallback: "fallback message" } } =>
+    { payload: { attachments: [{ color: "#000",
+                                 text: "attachment message <http://winterfell.com|hodor>",
+                                 fallback: "fallback message" }] } },
+
+    { attachments: { color: "#000",
+                     text: nil,
+                     fallback: "fallback message" } } =>
+    { payload: { attachments: [{ color: "#000",
+                                 text: nil,
+                                 fallback: "fallback message" }] } },
+
+    { text: "hello", http_options: { timeout: 5 } } =>
+    { http_options: { timeout: 5 }, payload: { text: "hello" } }
+  }.each do |args, payload|
+    it "sends correct payload for #post(#{args})" do
+      http_client       = class_double("Slack::Notifier::Util::HTTPClient", post: nil)
+      notifier          = Slack::Notifier.new "http://example.com", http_client: http_client
+      payload[:payload] = payload[:payload].to_json
+
+      expect(http_client).to receive(:post)
+        .with(URI.parse("http://example.com"), payload)
+
+      notifier.post(args)
+    end
+  end
+
+  it "applies options given to middleware" do
+    client   = class_double("Slack::Notifier::Util::HTTPClient", post: nil)
+    notifier = Slack::Notifier.new "http://example.com" do
+      http_client client
+      middleware format_message: { formats: [] }
+    end
+
+    expect(client).to receive(:post)
+      .with(URI.parse("http://example.com"), payload: { text: "Hello [world](http://example.com)!" }.to_json)
+
+    notifier.post text: "Hello [world](http://example.com)!"
+  end
+end