codeclimate-services 0.3.0

data/lib/cc/service/invocation/with_retries.rb

@@ -0,0 +1,17 @@
+class CC::Service::Invocation
+  class WithRetries
+    def initialize(invocation, retries)
+      @invocation = invocation
+      @retries = retries
+    end
+
+    def call
+      @invocation.call
+    rescue => ex
+      raise ex if @retries.zero?
+
+      @retries -= 1
+      retry
+    end
+  end
+end

data/lib/cc/service/invocation/with_return_values.rb

@@ -0,0 +1,18 @@
+class CC::Service::Invocation
+  class WithReturnValues
+    def initialize(invocation, message = nil)
+      @invocation = invocation
+      @message = message || "An internal error happened"
+    end
+
+    def call
+      result = @invocation.call
+      if result.nil?
+        { ok: false, message: @message }
+      else
+        result
+      end
+    end
+  end
+end
+

data/lib/cc/service/invocation.rb

@@ -0,0 +1,57 @@
+require 'cc/service/invocation/invocation_chain'
+require 'cc/service/invocation/with_retries'
+require 'cc/service/invocation/with_metrics'
+require 'cc/service/invocation/with_error_handling'
+require 'cc/service/invocation/with_return_values'
+
+class CC::Service::Invocation
+  MIDDLEWARE = {
+    retries: WithRetries,
+    metrics: WithMetrics,
+    error_handling: WithErrorHandling,
+    return_values: WithReturnValues,
+  }
+
+  attr_reader :result
+
+  # Build a chain of invocation wrappers which eventually calls receive
+  # on the given service, then execute that chain.
+  #
+  # Order is important. Each call to #with, wraps the last.
+  #
+  # Usage:
+  #
+  #   CC::Service::Invocation.invoke(service) do |i|
+  #     i.with :retries, 3
+  #     i.with :metrics, $statsd
+  #     i.with :error_handling, Rails.logger
+  #   end
+  #
+  # In the above example, service.receive could happen 4 times (once,
+  # then three retries) before an exception is re-raised up to the
+  # metrics collector, then up again to the error handling. If the order
+  # were reversed, the error handling middleware would prevent the other
+  # middleware from seeing any exceptions at all.
+  def self.invoke(service, &block)
+    instance = new(service, &block)
+    instance.result
+  end
+
+  def initialize(service)
+    @chain = InvocationChain.new { service.receive }
+
+    yield(self) if block_given?
+
+    @result = @chain.call
+  end
+
+  def with(middleware, *args)
+    if klass = MIDDLEWARE[middleware]
+      wrap(klass, *args)
+    end
+  end
+
+  def wrap(klass, *args)
+    @chain.wrap(klass, *args)
+  end
+end

data/lib/cc/service/response_check.rb

@@ -0,0 +1,42 @@
+class CC::Service
+  class HTTPError < StandardError
+    attr_reader :response_body, :status, :params, :endpoint_url
+    attr_accessor :user_message
+
+    def initialize(message, env)
+      @response_body = env[:body]
+      @status        = env[:status]
+      @params        = env[:params]
+      @endpoint_url  = env[:url].to_s
+
+      super(message)
+    end
+  end
+
+  class ResponseCheck < Faraday::Response::Middleware
+    ErrorStatuses = 400...600
+
+    def on_complete(env)
+      if ErrorStatuses === env[:status]
+        message = error_message(env) ||
+          "API request unsuccessful (#{env[:status]})"
+
+        raise HTTPError.new(message, env)
+      end
+    end
+
+  private
+
+    def error_message(env)
+      # We only handle Jira (or responses which look like Jira's). We will add
+      # more logic here over time to account for other service's typical error
+      # responses as we see them.
+      if env[:response_headers]["content-type"] =~ /application\/json/
+        errors = JSON.parse(env[:body])["errors"]
+        errors.is_a?(Hash) && errors.values.map(&:capitalize).join(", ")
+      end
+    rescue JSON::ParserError
+    end
+
+  end
+end

data/lib/cc/service.rb

@@ -0,0 +1,127 @@
+module CC
+  class Service
+    require "cc/service/config"
+    require "cc/service/http"
+    require "cc/service/helper"
+    require "cc/service/formatter"
+    require "cc/service/invocation"
+    require "axiom/types/password"
+
+    dir = File.expand_path '../helpers', __FILE__
+    Dir["#{dir}/*_helper.rb"].sort.each do |helper|
+      require helper
+    end
+
+    dir = File.expand_path '../formatters', __FILE__
+    Dir["#{dir}/*_formatter.rb"].sort.each do |formatter|
+      require formatter
+    end
+
+    def self.load_services
+      path = File.expand_path("../services/**/*.rb", __FILE__)
+      Dir[path].sort.each { |lib| require(lib) }
+    end
+
+    Error = Class.new(StandardError)
+    ConfigurationError = Class.new(Error)
+
+    include HTTP
+    include Helper
+
+    attr_reader :event, :config, :payload
+
+    ALL_EVENTS = %w[test unit coverage quality vulnerability snapshot pull_request issue]
+
+    # Tracks the defined services.
+    def self.services
+      @services ||= []
+    end
+
+    def self.inherited(svc)
+      Service.services << svc
+      super
+    end
+
+    def self.by_slug(slug)
+      services.detect { |s| s.slug == slug }
+    end
+
+    class << self
+      attr_writer :title
+      attr_accessor :description
+      attr_accessor :issue_tracker
+    end
+
+    def self.title
+      @title ||= begin
+        hook = name.dup
+        hook.sub! /.*:/, ''
+        hook
+      end
+    end
+
+    def self.slug
+      @slug ||= begin
+        hook = name.dup
+        hook.downcase!
+        hook.sub! /.*:/, ''
+        hook
+      end
+    end
+
+    def initialize(config, payload)
+      @payload     = payload.stringify_keys
+      @config      = create_config(config)
+      @event       = @payload["name"].to_s
+
+      load_helper
+      validate_event
+    end
+
+    def receive
+      methods = [:receive_event, :"receive_#{event}"]
+
+      methods.each do |method|
+        if respond_to?(method)
+          return public_send(method)
+        end
+      end
+
+      { ok: false, ignored: true,  message: "No service handler found" }
+    end
+
+    private
+
+    def load_helper
+      helper_name = "#{event.classify}Helper"
+
+      if Service.const_defined?(helper_name)
+        @helper = Service.const_get(helper_name)
+        extend @helper
+      end
+    end
+
+    def validate_event
+      unless ALL_EVENTS.include?(event)
+        raise ArgumentError.new("Invalid event: #{event}")
+      end
+    end
+
+    def create_config(config)
+      config_class.new(config).tap do |c|
+        unless c.valid?
+          raise ConfigurationError, "Invalid config: #{config.inspect}"
+        end
+      end
+    end
+
+    def config_class
+      if defined?("#{self.class.name}::Config")
+        "#{self.class.name}::Config".constantize
+      else
+        Config
+      end
+    end
+
+  end
+end

data/lib/cc/services/asana.rb

@@ -0,0 +1,90 @@
+class CC::Service::Asana < CC::Service
+  class Config < CC::Service::Config
+    attribute :api_key, String, label: "API key"
+
+    attribute :workspace_id, String, label: "Workspace ID"
+
+    attribute :project_id, String, label: "Project ID",
+      description: "(optional)"
+
+    attribute :assignee, String, label: "Assignee",
+      description: "Assignee email address (optional)"
+
+    validates :api_key, presence: true
+    validates :workspace_id, presence: true
+  end
+
+  ENDPOINT = "https://app.asana.com/api/1.0/tasks"
+
+  self.title = "Asana"
+  self.description = "Create tasks in Asana"
+  self.issue_tracker = true
+
+  def receive_test
+    result = create_task("Test task from Code Climate")
+    result.merge(
+      message: "Ticket <a href='#{result[:url]}'>#{result[:id]}</a> created."
+    )
+  rescue CC::Service::HTTPError => ex
+    body = JSON.parse(ex.response_body)
+    ex.user_message = body["errors"].map{|e| e["message"] }.join(" ")
+    raise ex
+  end
+
+  def receive_issue
+    title = %{Fix "#{issue["check_name"]}" issue in #{constant_name}}
+
+    body = [issue["description"], details_url].join("\n\n")
+
+    create_task(title, body)
+  end
+
+  def receive_quality
+    title = "Refactor #{constant_name} from #{rating} on Code Climate"
+
+    create_task("#{title} - #{details_url}")
+  end
+
+  def receive_vulnerability
+    formatter = CC::Formatters::TicketFormatter.new(self)
+    title     = formatter.format_vulnerability_title
+
+    create_task("#{title} - #{details_url}")
+  end
+
+private
+
+  def create_task(name, notes = nil)
+    params = generate_params(name, notes)
+    authenticate_http
+    http.headers["Content-Type"] = "application/json"
+    service_post(ENDPOINT, params.to_json) do |response|
+      body = JSON.parse(response.body)
+      id = body['data']['id']
+      url = "https://app.asana.com/0/#{config.workspace_id}/#{id}"
+      { id: id, url: url }
+    end
+  end
+
+  def generate_params(name, notes = nil)
+    params = {
+      data: { workspace: config.workspace_id, name: name, notes: notes }
+    }
+
+    if config.project_id.present?
+      # Note this is undocumented, found via trial & error
+      params[:data][:projects] = [config.project_id]
+    end
+
+    if config.assignee.present?
+      params[:data][:assignee] = config.assignee
+    end
+
+    params
+  end
+
+  def authenticate_http
+    http.basic_auth(config.api_key, "")
+  end
+
+end

data/lib/cc/services/campfire.rb

@@ -0,0 +1,55 @@
+class CC::Service::Campfire < CC::Service
+  class Config < CC::Service::Config
+    attribute :subdomain, String,
+      description: "The Campfire subdomain for the account"
+    attribute :token, String,
+      description: "Your Campfire API auth token"
+    attribute :room_id, String,
+      description: "Check your campfire URL for a room ID. Usually 6 digits."
+
+    validates :subdomain, presence: true
+    validates :room_id, presence: true
+    validates :token, presence: true
+  end
+
+  self.description = "Send messages to a Campfire chat room"
+
+  def receive_test
+    speak(formatter.format_test).merge(
+      message: "Test message sent"
+    )
+  end
+
+  def receive_coverage
+    speak(formatter.format_coverage)
+  end
+
+  def receive_quality
+    speak(formatter.format_quality)
+  end
+
+  def receive_vulnerability
+    speak(formatter.format_vulnerability)
+  end
+
+  private
+
+  def formatter
+    CC::Formatters::PlainFormatter.new(self)
+  end
+
+  def speak(line)
+    http.headers['Content-Type']  = 'application/json'
+    params = { message: { body: line } }
+
+    http.basic_auth(config.token, "X")
+    service_post(speak_uri, params.to_json)
+  end
+
+  def speak_uri
+    subdomain = config.subdomain
+    room_id = config.room_id
+    "https://#{subdomain}.campfirenow.com/room/#{room_id}/speak.json"
+  end
+
+end

data/lib/cc/services/flowdock.rb

@@ -0,0 +1,61 @@
+class CC::Service::Flowdock < CC::Service
+  class Config < CC::Service::Config
+    attribute :api_token, String,
+      label: "API Token",
+      description: "The API token of the Flow to send notifications to",
+      link: "https://www.flowdock.com/account/tokens"
+    validates :api_token, presence: true
+  end
+
+  BASE_URL = "https://api.flowdock.com/v1"
+  INVALID_PROJECT_CHARACTERS = /[^0-9a-z\-_ ]+/i
+
+  self.description = "Send messages to a Flowdock inbox"
+
+  def receive_test
+    notify("Test", repo_name, formatter.format_test).merge(
+      message: "Test message sent"
+    )
+  end
+
+  def receive_coverage
+    notify("Coverage", repo_name, formatter.format_coverage)
+  end
+
+  def receive_quality
+    notify("Quality", repo_name, formatter.format_quality)
+  end
+
+  def receive_vulnerability
+    notify("Vulnerability", repo_name, formatter.format_vulnerability)
+  end
+
+  private
+
+  def formatter
+    CC::Formatters::LinkedFormatter.new(
+      self,
+      prefix: "",
+      prefix_with_repo: false,
+      link_style: :html
+    )
+  end
+
+  def notify(subject, project, content)
+    params = {
+      source:       "Code Climate",
+      from_address: "hello@codeclimate.com",
+      from_name:    "Code Climate",
+      format:       "html",
+      subject:      subject,
+      project:      project.gsub(INVALID_PROJECT_CHARACTERS, ''),
+      content:      content,
+      link:         "https://codeclimate.com"
+    }
+
+    url = "#{BASE_URL}/messages/team_inbox/#{config.api_token}"
+    http.headers["User-Agent"] = "Code Climate"
+
+    service_post(url, params)
+  end
+end

data/lib/cc/services/github_issues.rb

@@ -0,0 +1,80 @@
+class CC::Service::GitHubIssues < CC::Service
+  class Config < CC::Service::Config
+    attribute :oauth_token, String,
+      label: "OAuth Token",
+      description: "A personal OAuth token with permissions for the repo"
+    attribute :project, String,
+      label: "Project",
+      description: "Project name on GitHub (e.g 'thoughtbot/paperclip')"
+    attribute :labels, String,
+      label: "Labels (comma separated)",
+      description: "Comma separated list of labels to apply to the issue"
+
+    validates :oauth_token, presence: true
+  end
+
+  self.title = "GitHub Issues"
+  self.description = "Open issues on GitHub"
+  self.issue_tracker = true
+
+  BASE_URL = "https://api.github.com"
+
+  def receive_test
+    result = create_issue("Test ticket from Code Climate", "")
+    result.merge(
+      message: "Issue <a href='#{result[:url]}'>##{result[:number]}</a> created."
+    )
+  rescue CC::Service::HTTPError => e
+    body = JSON.parse(e.response_body)
+    e.user_message = body["message"]
+    raise e
+  end
+
+  def receive_quality
+    title = "Refactor #{constant_name} from #{rating} on Code Climate"
+
+    create_issue(title, details_url)
+  end
+
+  def receive_vulnerability
+    formatter = CC::Formatters::TicketFormatter.new(self)
+
+    create_issue(
+      formatter.format_vulnerability_title,
+      formatter.format_vulnerability_body
+    )
+  end
+
+  def receive_issue
+    title = %{Fix "#{issue["check_name"]}" issue in #{constant_name}}
+
+    body = [issue["description"], details_url].join("\n\n")
+
+    create_issue(title, body)
+  end
+
+private
+
+  def create_issue(title, issue_body)
+    params = { title: title, body: issue_body }
+
+    if config.labels.present?
+      params[:labels] = config.labels.split(",").map(&:strip).reject(&:blank?).compact
+    end
+
+    http.headers["Content-Type"] = "application/json"
+    http.headers["Authorization"] = "token #{config.oauth_token}"
+    http.headers["User-Agent"] = "Code Climate"
+
+    url = "#{BASE_URL}/repos/#{config.project}/issues"
+    service_post(url, params.to_json) do |response|
+      body = JSON.parse(response.body)
+      {
+        id: body["id"],
+        number: body["number"],
+        url: body["html_url"]
+      }
+    end
+  end
+
+end