slack-notifier 1.5.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e74413c9d125dd2a973d6035bdc86e6f28549839
-  data.tar.gz: 6081e63972a12dc07acc866e13f8e6bae8a1992d
+  metadata.gz: 47af99d5a1eeca46a62425be8842bc6ff89d9d51
+  data.tar.gz: 3d0519d10cb7a251a49b32b0d27b2e0616f08c54
 SHA512:
-  metadata.gz: 252d1d23a8bb02cfe9ebee51c8d68436799daa59c95572dd18bc481797069ed2fa6fac96869845ffeae900fbf5d73c9df9b4e910f9190f7ca85937293e8d3e31
-  data.tar.gz: bda7747d3bd8e34a0ca2798d50c06c4f2b6e426c2552c2d389247f6ed60ce48a82d26e7f77e7e9c179388e831163d36a237dfe139cdddec689fdb154ee3b7d1b
+  metadata.gz: 0d9a915eb0ebc25b3d1d4042055419cf8628404cf9282fffa41a4f4dfada1eb8aac4c02c9b7415226895a160ee326f0c82d048fa84ede13f829dac19130b2cc8
+  data.tar.gz: 314a2d7812c2d699f201753e15fbcd6c34c778f863123f2e70e7731d8753a338e984bbcb3dd4cd125f01509990b79fc84ac8a3b7daf5b2e70f5484c66cede356

data/lib/slack-notifier.rb

@@ -1,81 +1,56 @@
-require 'net/http'
-require 'uri'
-require 'json'
+# frozen_string_literal: true
+require "uri"
+require "json"
 
-require_relative 'slack-notifier/default_http_client'
-require_relative 'slack-notifier/link_formatter'
+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
+    attr_reader :endpoint
 
-    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
-
-      payload      = default_payload.merge(options)
-      client       = payload.delete(:http_client) || http_client
-      http_options = payload.delete(:http_options)
-
-      unless message.nil?
-        payload.merge!(text: LinkFormatter.format(message))
-      end
+    def initialize webhook_url, options={}, &block
+      @endpoint = URI.parse webhook_url
 
-      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)
+      params[:payload]      = middleware.call(payload).to_json
 
-    HTML_ESCAPE_REGEXP = /[&><]/
-    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;' }
-
-    def escape(text)
-      text.gsub(HTML_ESCAPE_REGEXP, HTML_ESCAPE)
+      client.post endpoint, params
     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/lib/slack-notifier/config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module Slack
+  class Notifier
+    class Config
+      def initialize
+        @http_client = Util::HTTPClient
+        @defaults    = {}
+        @middleware  = [:format_message, :format_attachments]
+      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.rb

@@ -0,0 +1,21 @@
+# 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"

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

@@ -0,0 +1,35 @@
+# 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
+
+        # rubocop:disable Lint/UnusedMethodArgument
+        def call payload={}
+          raise NoMethodError, "method `call` not defined for class #{self.class}"
+        end
+        # rubocop:enable Lint/UnusedMethodArgument
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module Slack
+  class Notifier
+    class PayloadMiddleware
+      class FormatAttachments < Base
+        middleware_name :format_attachments
+
+        options formats: [:html, :markdown]
+
+        def call payload={}
+          attachments = payload.fetch(:attachments, payload["attachments"])
+          wrap_array(attachments).each do |attachment|
+            ["text", :text].each do |key|
+              if attachment.key?(key)
+                attachment[key] = Util::LinkFormatter.format(attachment[key], options)
+              end
+            end
+          end
+
+          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,19 @@
+# frozen_string_literal: true
+module Slack
+  class Notifier
+    class PayloadMiddleware
+      class FormatMessage < Base
+        middleware_name :format_message
+
+        options formats: [: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,35 @@
+# 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={}
+          stack.inject payload do |pld, middleware|
+            middleware.call(pld)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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,53 @@
+# frozen_string_literal: true
+
+require "net/http"
+
+module Slack
+  class Notifier
+    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
+
+        def call
+          http_obj.request request_obj
+        end
+
+        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,63 @@
+# frozen_string_literal: true
+module Slack
+  class Notifier
+    module Util
+      class LinkFormatter
+        # http://rubular.com/r/19cNXW5qbH
+        HTML_PATTERN = / <a (?:.*?) href=['"](.+?)['"] (?:.*?)> (.+?) <\/a> /x
+
+        # http://rubular.com/r/guJbTK6x1f
+        MARKDOWN_PATTERN = /\[ ([^\[\]]*?) \] \( ((https?:\/\/.*?) | (mailto:.*?)) \) /x
+
+        class << self
+          def format string, opts={}
+            LinkFormatter.new(string, opts).formatted
+          end
+        end
+
+        attr_reader :formats
+
+        def initialize string, formats: [:html, :markdown]
+          @formats = formats
+          @orig    = string.respond_to?(:scrub) ? string.scrub : string
+        end
+
+        # rubocop:disable Style/GuardClause
+        def formatted
+          sub_markdown_links(sub_html_links(@orig))
+        rescue => e
+          if RUBY_VERSION < "2.1" && e.message.include?("invalid byte sequence")
+            raise e, "#{e.message}. Consider including the 'string-scrub' gem to strip invalid characters"
+          else
+            raise e
+          end
+        end
+        # rubocop:enable Style/GuardClause
+
+        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