codebot 1.2.0

data/lib/codebot/formatters/pull_request_review_comment.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Portions (c) 2008 Logical Awesome, LLC (released under the MIT license).
+# See the LICENSE file for the full MIT license text.
+
+module Codebot
+  module Formatters
+    # This class formats pull_request_review_comment events.
+    class PullRequestReviewComment < Formatter
+      # Formats IRC messages for a pull_request_review_comment event.
+      #
+      # @return [Array<String>] the formatted messages
+      def format
+        ["#{summary}: #{format_url url}"]
+      end
+
+      def summary
+        default_format % {
+          repository: format_repository(repository_name),
+          sender: format_user(sender_name),
+          number: pull_number,
+          hash: format_hash(commit_id),
+          short: prettify(comment_body)
+        }
+      end
+
+      def default_format
+        '[%<repository>s] %<sender>s commented on pull request #%<number>s ' \
+        '%<hash>s: %<summary>s'
+      end
+
+      def summary_url
+        extract(:comment, :html_url).to_s
+      end
+
+      def comment_body
+        extract(:comment, :body)
+      end
+
+      def commit_id
+        extract(:comment, :commit_id)
+      end
+
+      def pull_number
+        extract(:pull_request, :number)
+      end
+    end
+  end
+end

data/lib/codebot/formatters/push.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: false
+
+# Portions (c) 2008 Logical Awesome, LLC (released under the MIT license).
+# See the LICENSE file for the full MIT license text.
+
+module Codebot
+  module Formatters
+    # This class formats push events.
+    class Push < Formatter # rubocop:disable Metrics/ClassLength
+      # Formats IRC messages for a push event.
+      #
+      # @return [Array<String>] the formatted messages
+      def format
+        ["#{summary}: #{format_url url}"] + distinct_commits.map do |commit|
+          format_commit_message(commit)
+        end
+      end
+
+      def summary # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/LineLength
+        msg = "[#{format_repository repository_name}]"
+        msg << " #{format_user(pusher_name)}"
+
+        if created?
+          if tag?
+            msg << " tagged #{format_branch tag_name} at "
+            msg << if base_ref
+                     format_branch(base_ref_name)
+                   else
+                     format_hash(after_sha)
+                   end
+          else
+            msg << " created #{format_branch branch_name}"
+            msg << if base_ref
+                     " from #{format_branch base_ref_name}"
+                   else
+                     " at #{format_hash after_sha}"
+                   end
+
+            len = distinct_commits.length
+            msg << " (+#{format_number len, 'new commit', 'new commits'})"
+          end
+        elsif deleted?
+          msg << " #{format_dangerous 'deleted'}"
+          msg << " #{format_branch branch_name}"
+          msg << " at #{format_hash before_sha}"
+        elsif forced?
+          msg << " #{format_dangerous 'force-pushed'}"
+          msg << " #{format_branch branch_name}"
+          msg << " from #{format_hash before_sha}"
+          msg << " to #{format_hash after_sha}"
+        elsif !commits.empty? && distinct_commits.empty?
+          if base_ref
+            msg << " merged #{format_branch base_ref_name}"
+            msg << " into #{format_branch branch_name}"
+          else
+            msg << " fast-forwarded #{format_branch branch_name}"
+            msg << " from #{format_hash before_sha}"
+            msg << " to #{format_hash after_sha}"
+          end
+        else
+          len = distinct_commits.length
+          msg << " pushed #{format_number len, 'new commit', 'new commits'}"
+          msg << " to #{format_branch branch_name}"
+        end
+        msg
+      end
+
+      def format_commit_message(commit) # rubocop:disable Metrics/AbcSize
+        author = commit['author']['name'] if commit['author'].is_a? Hash
+        default_format % {
+          repository: format_repository(repository_name),
+          branch: format_branch(branch_name),
+          hash: format_hash(commit['id']),
+          author: format_user(author),
+          title: prettify(full_commit_message(commit))
+        }
+      end
+
+      def default_format
+        '%<repository>s/%<branch>s %<hash>s %<author>s: %<title>s'
+      end
+
+      def full_commit_message(commit)
+        (commit.is_a?(Hash) ? commit['message'] : nil).to_s
+      end
+
+      def summary_url # rubocop:disable Metrics/AbcSize
+        if created?    then distinct_commits.empty? ? branch_url : compare_url
+        elsif deleted? then before_sha_url
+        elsif forced?  then branch_url
+        elsif distinct_commits.length == 1
+          distinct_commits.first['url'].to_s
+        else
+          compare_url
+        end
+      end
+
+      def created?
+        /\A0{40}\z/ =~ extract(:before)
+      end
+
+      def deleted?
+        /\A0{40}\z/ =~ extract(:after)
+      end
+
+      def forced?
+        extract(:forced)
+      end
+
+      def tag?
+        %r{\Arefs/tags/} =~ ref
+      end
+
+      def commits
+        extract(:commits)
+      end
+
+      def pusher_name
+        extract(:pusher, :name) || 'somebody'
+      end
+
+      def ref
+        extract(:ref).to_s
+      end
+
+      def ref_name
+        ref.sub(%r{\Arefs/(heads|tags)/}, '')
+      end
+
+      alias tag_name ref_name
+      alias branch_name ref_name
+
+      def base_ref
+        extract(:base_ref)
+      end
+
+      def base_ref_name
+        base_ref.sub(%r{\Arefs/(heads|tags)/}, '')
+      end
+
+      def branch_url
+        "#{repository_url}/commits/#{branch_name}"
+      end
+
+      def compare_url
+        extract(:compare).to_s
+      end
+
+      def before_sha
+        extract(:before).to_s
+      end
+
+      def before_sha_url
+        "#{repository_url}/commits/#{before_sha}"
+      end
+
+      def after_sha
+        extract(:after).to_s
+      end
+
+      def after_sha_url
+        "#{repository_url}/commits/#{after_sha}"
+      end
+
+      def distinct_commits
+        extract(:distinct_commits) || commits.select do |commit|
+          commit['distinct'] && !commit['message'].to_s.strip.empty?
+        end
+      end
+    end
+  end
+end

data/lib/codebot/formatters/watch.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Codebot
+  module Formatters
+    # This class formats watch events.
+    class Watch < Formatter
+      # Formats IRC messages for a watch event.
+      #
+      # @return [Array<String>] the formatted messages
+      def format
+        ["#{summary}: #{format_url url}"] if started?
+      end
+
+      def summary
+        default_format % {
+          repository: format_repository(repository_name),
+          sender: format_user(sender_name)
+        }
+      end
+
+      def default_format
+        '[%<repository>s] %<sender>s starred the repository'
+      end
+
+      def action
+        extract(:action)
+      end
+
+      def started?
+        action.eql? 'started'
+      end
+
+      def summary_url
+        "#{repository_url}/stargazers"
+      end
+    end
+  end
+end

data/lib/codebot/integration.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require 'codebot/channel'
+require 'codebot/cryptography'
+require 'codebot/sanitizers'
+require 'codebot/serializable'
+
+module Codebot
+  # This class represents an integration that maps an endpoint to the
+  # corresponding IRC channels.
+  class Integration < Serializable # rubocop:disable Metrics/ClassLength
+    include Sanitizers
+
+    # @return [String] the name of this integration
+    attr_reader :name
+
+    # @return [String] the endpoint mapped to this integration
+    attr_reader :endpoint
+
+    # @return [String] the secret for verifying the authenticity of payloads
+    #                  delivered to the endpoint
+    attr_reader :secret
+
+    # @return [Array<Channel>] the channels notifications will be delivered to
+    attr_reader :channels
+
+    attr_accessor :gitlab
+    attr_accessor :shortener_url
+    attr_accessor :shortener_secret
+
+    # Creates a new integration from the supplied hash.
+    #
+    # @param params [Hash] A hash with symbolic keys representing the instance
+    #                      attributes of this integration. The key +:name+ is
+    #                      required.
+    def initialize(params)
+      update!(params)
+    end
+
+    # Updates the integration from the supplied hash.
+    #
+    # @param params [Hash] A hash with symbolic keys representing the instance
+    #                      attributes of this integration.
+    def update!(params)
+      self.name     = params[:name]
+      self.endpoint = params[:endpoint]
+      self.secret   = params[:secret]
+      self.gitlab   = params[:gitlab] || false
+      self.shortener_url = params[:shortener_url]
+      self.shortener_secret = params[:shortener_secret]
+      set_channels params[:channels], params[:config]
+    end
+
+    # Adds the specified channels to this integration.
+    #
+    # @note This method is not thread-safe and should only be called from an
+    #       active transaction.
+    # @param channels [Hash] the channel data to add
+    # @param conf [Hash] the previously deserialized configuration
+    # @raise [CommandError] if one of the channel identifiers already exists
+    def add_channels!(channels, conf)
+      channels.each_key do |identifier|
+        if @channels.any? { |chan| chan.identifier_eql?(identifier) }
+          raise CommandError, "channel #{identifier.inspect} already exists"
+        end
+      end
+      new_channels = Channel.deserialize_all(channels, conf)
+      @channels.push(*new_channels)
+    end
+
+    # Deletes the specified channels from this integration.
+    #
+    # @note This method is not thread-safe and should only be called from an
+    #       active transaction.
+    # @param identifiers [Array<String>] the channel identifiers to remove
+    # @raise [CommandError] if one of the channel identifiers does not exist
+    def delete_channels!(identifiers)
+      identifiers.each do |identifier|
+        channel = @channels.find { |chan| chan.identifier_eql? identifier }
+        if channel.nil?
+          raise CommandError, "channel #{identifier.inspect} does not exist"
+        end
+
+        @channels.delete channel
+      end
+    end
+
+    def name=(name)
+      @name = valid! name, valid_identifier(name), :@name,
+                     required: true,
+                     required_error: 'integrations must have a name',
+                     invalid_error: 'invalid integration name %s'
+    end
+
+    def endpoint=(endpoint)
+      @endpoint = valid!(endpoint, valid_endpoint(endpoint), :@endpoint,
+                         invalid_error: 'invalid endpoint %s') do
+        Cryptography.generate_endpoint
+      end
+    end
+
+    def secret=(secret)
+      @secret = valid!(secret, valid_secret(secret), :@secret,
+                       invalid_error: 'invalid secret %s') do
+        Cryptography.generate_secret
+      end
+    end
+
+    # Checks whether payloads delivered to this integration must be verified.
+    #
+    # @return [Boolean] whether verification is required
+    def verify_payloads?
+      !secret.to_s.strip.empty?
+    end
+
+    # Sets the list of channels.
+    #
+    # @param channels [Array<Channel>] the list of channels
+    # @param conf [Hash] the previously deserialized configuration
+    def set_channels(channels, conf)
+      if channels.nil?
+        @channels = [] if @channels.nil?
+        return
+      end
+      @channels = valid!(channels, Channel.deserialize_all(channels, conf),
+                         :@channels,
+                         invalid_error: 'invalid channel list %s') { [] }
+    end
+
+    # Checks whether the name of this integration is equal to another name.
+    #
+    # @param name [String] the other name
+    # @return [Boolean] +true+ if the names are equal, +false+ otherwise
+    def name_eql?(name)
+      @name.casecmp(name).zero?
+    end
+
+    # Checks whether the endpoint associated with this integration is equal
+    # to another endpoint.
+    #
+    # @param endpoint [String] the other endpoint
+    # @return [Boolean] +true+ if the endpoints are equal, +false+ otherwise
+    def endpoint_eql?(endpoint)
+      @endpoint.eql? endpoint
+    end
+
+    # Serializes this integration.
+    #
+    # @param conf [Hash] the deserialized configuration
+    # @return [Array, Hash] the serialized object
+    def serialize(conf)
+      check_channel_networks!(conf)
+      [name, {
+        'endpoint' => endpoint,
+        'secret' => secret,
+        'gitlab' => gitlab,
+        'shortener_url' => shortener_url,
+        'shortener_secret' => shortener_secret,
+        'channels' => Channel.serialize_all(channels, conf)
+      }]
+    end
+
+    # Compares the channels against the specified configuration, dropping any
+    # channels belonging to networks that no longer exist.
+    #
+    # @param conf [Config] the configuration
+    def check_channel_networks!(conf)
+      @channels.select! do |channel|
+        conf[:networks].include? channel.network
+      end
+    end
+
+    # Deserializes an integration.
+    #
+    # @param name [String] the name of the integration
+    # @param data [Hash] the serialized data
+    # @return [Hash] the parameters to pass to the initializer
+    def self.deserialize(name, data)
+      {
+        name: name,
+        endpoint: data['endpoint'],
+        secret: data['secret'],
+        gitlab: data['gitlab'],
+        shortener_url: data['shortener_url'],
+        shortener_secret: data['shortener_secret'],
+        channels: data['channels']
+      }
+    end
+
+    # @return [true] to indicate that data is serialized into a hash
+    def self.serialize_as_hash?
+      true
+    end
+  end
+end