lita-jls 0.0.11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 82fcfffe36fd74ada588e3e69026933c65307904
+  data.tar.gz: e7e5e78740affb2ec4e9de2eec9345eb84f77da3
+SHA512:
+  metadata.gz: aab3bdc7a67337e64cac4acd57de18f70ba3713adc38915462dca2e60e85b97c41f95c40e8616763992e098d6d1c82b7fa7ce07ba80931a33f2cd026cf84397d
+  data.tar.gz: 78b56db4fe290dd3ae558cdc3c84a3c0a99d0cc6fd54050c22de2fa83746c334191a697e25250462b730e0031ecfe0fab459edbb421ee01752eacfd3a86782f7

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/fixtures/test-opsbots
+.idea/*

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Jordan Sissel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,24 @@
+# lita-jls
+
+TODO: Add a description of the plugin.
+
+## Installation
+
+Add lita-jls to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-jls"
+```
+
+
+## Configuration
+
+TODO: Describe any configuration attributes the plugin exposes.
+
+## Usage
+
+TODO: Describe the plugin's features and how to use them.
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/lita-jls.rb

@@ -0,0 +1,8 @@
+require "lita"
+
+Lita.load_locales Dir[File.expand_path(
+  File.join("..", "..", "locales", "*.yml"), __FILE__
+)]
+
+require "lita/handlers/jls"
+require "lita-jls/github_url_parser"

data/lib/lita-jls/bot_builder.rb

@@ -0,0 +1,240 @@
+require 'lita-jls/util'
+require 'rubygems'
+require 'open3'
+require 'gems'
+require 'semverly'
+
+module LitaJLS
+  module Reporter
+    class HipChat
+      def initialize(build_results)
+        @build_results = build_results
+      end
+
+      def format(message)
+        formatted_message = []
+
+        @build_results.each do |build_result|
+          if build_result.status == :ok
+            formatted_message << " - (success) #{build_result.message}"
+          else
+            if build_result.full_message
+              formatted_message << " - (stare) #{build_result.message} \nstacktrace: #{build_result.error || build_result.full_message}"
+            else
+              formatted_message << " - (stare) #{build_result.message}"
+            end
+          end
+        end
+
+        message.reply(formatted_message.join("\n"))
+      end
+    end
+  end
+
+  class BuildResult
+    attr_reader :status, :full_message, :error, :message
+
+    def initialize(options = {})
+      @status = options[:status]
+      @full_message = options[:full_message]
+      @error = options[:error]
+      @message = options[:message]
+    end
+  end
+
+  class BotBuilder
+    include LitaJLS::Logger
+
+    class ConfigurationError <  StandardError; end
+
+    GEM_TO_EXCLUDE = ["logstash"].freeze
+
+    TASKS_ORDER = ['bundle install',
+                   'bundle exec rake vendor',
+                   'bundle exec rspec',
+                   'bundle exec rake publish_gem'].freeze
+
+    GEM_CREDENTIALS_FILE = '~/.gem/credentials'
+
+    attr_reader :current_path, :project_name, :ruby_version
+
+    def initialize(path, options = {})
+      @cache_commands = {}
+      @current_path = File.expand_path(path)
+      @project_name = File.basename(current_path)
+      @ruby_version = options.fetch(:ruby_version, nil)
+      @tasks_order = options[:tasks_order] || TASKS_ORDER
+    end
+
+    def is_gem?
+      File.exists?(find_gemspec)
+    end
+
+    def find_gemspec
+      file = [project_name, "gemspec"].join('.')
+      File.join(current_path, file)
+    end
+
+    def gem_specification
+      # HACK: if you are using the `real` bundler way of creating gem
+      # You have to create a version.rb file containing the version number
+      # and require the file in the gemspec. 
+      # Ruby will cache this require and not reload it again in a long running
+      # process like the bot.
+      cmd = "ruby -e \"spec = Gem::Specification.load('#{find_gemspec}'); puts [spec.name, spec.version].join(',')\""
+      results = execute_command_with_ruby(cmd)
+
+      if run_successfully?(results)
+        name, version = results.stdout.strip.split(',')
+        gemspec = Struct.new(:name, :version) 
+        return gemspec.new(name, version)
+      else
+        raise results.stderr
+      end
+    end
+
+    def publishable?
+      if is_gem?
+        return !GEM_TO_EXCLUDE.include?(gem_specification.name)
+      else
+        return false
+      end
+    end
+
+    def run_successfully?(task_result)
+      logger.debug("Check if run run_successfully", :exit_code => task_result.status.inspect, :task_result => task_result.inspect)
+      task_result.status.success?
+    end 
+
+    def execution_report(task_result)
+      if run_successfully?(task_result)
+        report_ok(task_result.cmd, task_result.stdout)
+      else
+        report_error(task_result.cmd, task_result.stdout, task_result.stderr)
+      end
+    end
+
+    def cache_command(cmd, options = {})
+      @cache_commands[cmd] ||= execute_command(cmd, options)
+    end
+
+    def report_error(message, full_message = nil, error = nil)
+     BuildResult.new(:status => :error, :message => message, :full_message => full_message, :error => error)
+    end
+
+    def report_ok(message, full_message = nil)
+     BuildResult.new(:status => :ok, :message => message, :full_message => full_message)
+    end
+
+    def fetch_last_released_version(name)
+      # Assume you have correctly configured the ~/gem/credentials file
+      credentials_file = File.expand_path(GEM_CREDENTIALS_FILE)
+
+      if File.exist?(credentials_file)
+        response = Gems.versions(name)
+        if response != 'This rubygem could not be found.'
+          return response.first.fetch('number', nil)
+        else
+          return nil
+        end
+      else
+        raise ConfigurationError.new("Missing rubygems credentials in #{credentials_file}")
+      end
+    end
+
+    def local_version
+      SemVer.parse(gem_specification.version.to_s)
+    end
+
+    def rubygems_version
+      rubygems_version = fetch_last_released_version(project_name)
+      
+      if rubygems_version.nil?
+        return SemVer.new(0, 0, 0)
+      else 
+        return SemVer.parse(rubygems_version)
+      end
+    end
+
+    def execute_command_with_ruby(cmd)
+      Dir.chdir(current_path) do
+        Bundler.with_clean_env do
+          environment_variables = {}
+
+          if ruby_version
+            if using_rvm?
+              cmd = "rvm #{ruby_version} do #{cmd}"
+            elsif using_rbenv?
+              raise ConfigurationError.new('RBENV is currently not supported')
+            end
+          end
+
+          return cache_command(cmd, environment_variables)
+        end
+      end
+    end
+
+    def execute_command(cmd, environment_variables = {})
+      logger.debug("Running command", :cmd => cmd, :path => current_path)
+      Open3.popen3(environment_variables, cmd, :chdir => current_path) do |input, stdout, stderr, thr|
+        return OpenStruct.new(:stdout => stdout.read,
+                              :status => thr.value,
+                              :stderr => stderr.read,
+                              :cmd => cmd)
+      end
+    end
+
+    def using_rvm?
+      run_successfully?(cache_command('which rvm'))
+    end
+
+    def using_rbenv?
+      run_successfully?(cache_command('which rbenv'))
+    end
+
+    def run_tasks
+      messages = []
+
+      @tasks_order.each do |task|
+        result = execute_command_with_ruby(task)
+        messages << execution_report(result)
+        break unless run_successfully?(result)
+      end
+      messages
+    end
+
+    def build
+      messages = []
+
+      if is_gem?
+        if publishable?
+          if local_version < rubygems_version
+            logger.debug("Remote version is higher on rubygems, we dont do anything")
+
+            messages << report_error("Higher version on rubygems (#{rubygems_version}) than the local version (#{local_version}), see http://rubygems.org/gems/#{project_name}")
+          elsif local_version == rubygems_version
+            logger.debug("Same version on rubygems", :local_version => local_version, :rubygems_version => rubygems_version)
+
+            messages << report_error("Local version and rubygems version are the same (#{local_version}|#{rubygems_version}), see http://rubygems.org/gems/#{project_name}")
+          else
+            logger.debug("Start the build process")
+
+            messages.concat(run_tasks)
+
+            if local_version == rubygems_version
+              messages << report_ok("version on rubygems match local version, published #{local_version} see http://rubygems.org/gems/#{project_name}")
+            else
+              messages << report_error("versions on rubygems doesn't match see http://rubygems.org/gems/#{project_name}")
+            end
+          end
+        else
+          messages << report_error("#{project_name} is blacklisted, you cannot deploy it with this tool.")
+        end
+      else
+        messages << report_error("#{project_name} doesn't have a gemspec")
+      end
+
+      messages
+    end
+  end
+end

data/lib/lita-jls/github_url_parser.rb

@@ -0,0 +1,43 @@
+module LitaJLS
+  class GithubUrlParser
+    attr_reader :user, :project, :pr, :url
+
+    URL_BASE = "https://github.com"
+
+    def initialize(git_url, options)
+      @url = git_url
+      full_path = URI.parse(@url).path
+      _, @user, @project, _, @pr = full_path.split('/')
+
+      @options = { :link => :repository }.merge(options)
+    end
+
+    def valid_url?
+      url =~ /^#{URL_BASE.gsub('/', '\/')}/
+    end
+
+    def validate_repository!
+      if user.nil? || project.nil? || !valid_url?
+        raise "Invalid URL. Expected something like: #{URL_BASE}/elasticsearch/snacktime/"
+      end
+    end
+
+    def validate_pull_request!
+      if user.nil? || project.nil? || pr.nil? || !valid_url?
+        raise "Invalid URL. Expected something like: #{URL_BASE}/elasticsearch/snacktime/pull/12345"
+      end
+    end
+
+    def validate!
+      send("validate_#{@options[:link]}!")
+    end
+
+    def self.parse(git_url, options = {})
+      new(git_url, options)
+    end
+
+    def git_url
+      "#{URL_BASE}/#{user}/#{project}"
+    end
+  end
+end

data/lib/lita-jls/repository.rb

@@ -0,0 +1,57 @@
+require 'lita-jls/util'
+
+module LitaJLS
+  class Repository
+    include LitaJLS::Util
+    include LitaJLS::Logger
+
+    REMOTE = 'origin'
+
+    def initialize(parsed_url)
+      @parsed_url = parsed_url
+    end
+
+    def clone
+      clone_at(@parsed_url.git_url, git_path)
+      git(git_path, "am", "--abort") if unfinished_rebase?
+    end
+
+    def unfinished_rebase?
+      File.directory?(".git/rebase-apply")
+    end
+
+    def git_path
+      @git_path ||= gitdir(@parsed_url.project)
+    end
+    
+    def switch_branch(branch, create_new=false)
+      if create_new
+        logger.info("Creating and switching branches", :branch => branch, :repo => git_path)
+        git(git_path, "checkout", "-b", branch)
+        git(git_path, "reset", "--hard", "#{REMOTE}/master")
+      else
+        logger.info("Switching branches", :branch => branch, :repo => git_path)
+        git(git_path, "checkout", branch)
+        git(git_path, "reset", "--hard", "#{REMOTE}/#{branch}")
+        git(git_path, "pull", "--ff-only")
+      end
+    end
+
+    def git_patch(patch_file)
+      raise "Previous patch apply had failed. Please resolve it before continuing" if File.directory?(".git/rebase-apply")
+      git(git_path, "am", "--3way", patch_file)
+    end
+
+    def git_push_branch(local_branch)
+      git(git_path, "push", "origin", local_branch)
+    end
+
+    def delete_local_branch(branch, ignore_error=false)
+      begin
+        git(git_path, "branch", "-D", branch)
+      rescue => e
+        raise e unless ignore_error
+     end
+    end
+  end
+end

data/lib/lita-jls/util.rb

@@ -0,0 +1,259 @@
+require "cabin"
+require "fileutils"
+require "uri"
+require "faraday" # for cla check
+require "json" # for cla check
+#
+# TODO(sissel): This code needs some suuuper serious refactoring and testing improvements.
+
+module LitaJLS 
+  module Logger
+    def logger
+      return @logger if @logger
+      @logger = Cabin::Channel.get
+      @logger.level = :debug if ENV["DEBUG"]
+      @logger
+    end
+  end
+
+  module Util
+    include Logger
+
+    CLANotSigned = Class.new(StandardError)
+
+    private
+
+    # This method requires @cla_uri being set before it'll work.
+    def cla?(repository, pr)
+      raise "No @cla_uri set. Cannot check CLA signature." unless @cla_uri
+      uri = URI.parse(@cla_uri)
+      conn = Faraday.new(:url => "#{uri.scheme}://#{uri.host}")
+      conn.basic_auth(uri.user, uri.password)
+      response = conn.get(uri.path, :repository => repository, :number => pr)
+      check = JSON.parse(response.body)
+      # TODO(sissel): json exception? .get exception?
+
+      if check["status"] == "error"
+        raise CLANotSigned, check["message"]
+      end
+
+      true
+    end # cla?
+
+    def logstash_team?(user)
+      ["electrical",
+       "jordansissel",
+       "ph",
+       "colinsurprenant",
+       "jsvd",
+       "untergeek",
+       "talevy",
+       "kurtado",
+       "suyograo",
+       "purbon"].include?(user.downcase)
+    end
+
+    # Clone a git url into a local path.
+    #
+    # This caches a remote git repo and performs a clone against that in
+    # order to make subsequent clones faster. It will try to provide the
+    # latest (via 'git fetch') after cloning is complete.
+    def clone_at(url, gitpath)
+      # TODO(sissel): Refactor this into two 'clone' calls.
+      logger.debug("clone_at", :url => url, :gitpath => gitpath)
+
+      # Cache a remote git url so that we can clone it more quickly in the
+      # future.
+      cache = File.join(gitdir(File.join("_")), File.basename(gitpath))
+      FileUtils.mkdir_p(cache) unless File.directory?(cache)
+
+      logger.info("Cloning to cache", :url => url, :cache => cache)
+      begin
+        git(".", "clone", url, cache)
+      rescue => e
+        logger.debug("clone_at failed, trying to open repo instead", :cache => cache, :error => e)
+        git(cache, "log", "-n0") # Verify some kind of git works here
+      end
+      remote = "origin"
+      
+      # Update from remote if already cloned
+      logger.debug("Fetching a remote", :cache => cache, :remote => remote)
+      git(cache, "fetch", remote)
+
+      # Clone from cache.
+      # This allows us to have multiple local working/clones and just keep
+      # cloning from the local cache. The alternative is to clone from the
+      # remote every time we do a new clone_at, and that would be slow through
+      # github or gitlab.
+      logger.info("Cloning from cache", :cache => cache, :gitpath => gitpath)
+      begin
+        git(".", "clone", cache, gitpath)
+      rescue => e
+        logger.info(e)
+        logger.debug("clone_at from cache failed, trying to open repo instead", :repo => gitpath, :cache => cache)
+      end
+      git(gitpath, "remote", "set-url", remote, url)
+
+      uri = URI.parse(url)
+      push_url = "git@github.com:#{uri.path}.git"
+      git(gitpath, "remote", "set-url", "--push", remote, push_url)
+      git(gitpath, "fetch")
+
+      # TODO(sissel): pull --ff-only?
+      gitpath
+    end # def clone_at
+
+    def gitdir(project)
+      if !@gitdir
+        @gitdir = workdir("gitbase")
+        FileUtils.mkdir_p(@gitdir) unless File.directory?(@gitdir) 
+        logger.debug("Git dir", :path => @gitdir)
+      end
+      path = File.join(@gitdir, project)
+      Dir.mkdir(path) unless File.directory?(path)
+      path
+    end # def gitdir
+
+    def workdir(path=nil)
+      return File.join(@workdir, path) if @workdir
+      @workdir = File.join(Dir.tmpdir, "lita-jls")
+      Dir.mkdir(@workdir) unless File.directory?(@workdir)
+      if path.nil?
+        @workdir
+      else
+        File.join(@workdir, path)
+      end
+    end # def workdir
+
+    def apply_patch(repo, patch_body, &block)
+      require "mbox"
+      require "time"
+      # The github '.patch' format is an mbox containing one mail+patch per
+      # commit.
+      mbox = Mbox.new(patch_body)
+      mbox.each_with_index do |mail, i|
+        commit = apply_commit(repo, mail, &block)
+        logger.info("Created commit", :commit => commit, :patch => i)
+      end
+    end # def apply_patch
+
+    def apply_commit(repo, mail, &block)
+      from_re = /([^<]+) (<[^>]+>)/
+      match = from_re.match(mail.headers["from"])
+      name = match[1].gsub(/(^")|("$)/, "")
+      email = match[2].gsub(/^<|>$/, "")
+      if name.nil? || email.nil?
+        raise "Unable to parse name and email from '#{mail.headers["from"]}'. Cannot continue"
+      end
+      time = Time.parse(mail.headers["date"])
+      #File.write("/tmp/x", patch)
+
+      # Take the email subject but strip [PATCH] or [PATCH N/M] out.
+      subject = mail.headers["subject"].gsub(/^\[PATCH[^\]]*\] /, "")
+      # The email body (minus the patch itself) is the rest of the commit message
+      description = /^(?<description>.*\n)?---\n.*$/m.match(mail.content.first.content)["description"] || ""
+
+      if subject.empty? && description.empty?
+        raise "Empty commit message (no subject or description). Refusing to continue."
+      end
+
+      #patch = mail.content.first.content.gsub(/^(?:.*\n)?---\n.*?\n\n/m, "")
+      #patch += "\n" if patch[-1,1] != "\n"
+      # Patch must have a trailing newline.
+      patch = [mail.headers, mail.content, ""].join("\n")
+
+      # Apply the code change to the git index
+      Dir.chdir(repo) do
+        cmd = ["git", "am", "--3way"]
+        File.write("/tmp/patch", patch)
+        IO.popen(cmd, "w+") do |io|
+          io.write(patch)
+          io.close_write
+          logger.pipe(io => :debug)
+        end
+        status = $?
+        if !status.success?
+          logger.warn("Git am failed", :code => status.exitstatus, :command => cmd, :pwd => Dir.pwd)
+          git(repo, "am", "--abort")
+          raise "Git am failed: #{cmd.join(" ")}"
+        end
+        logger.info("Git am successful!", :code => status.exitstatus, :command => cmd, :pwd => Dir.pwd)
+      end
+
+      # Combine subject + description for the full commit message
+      message = "#{subject}\n\n#{description}"
+
+      commit_settings = { 
+        # TODO(sissel): override the committer with whoever
+        #:author => { :email => email, :name => name, :time => time },
+        #:committer => { :email => "jls@semicomplete.com", :name => "Jordan Sissel", :time => Time.now },
+        :message => message
+      }
+
+      # Allow any modifications to the commit object itself.
+      block.call(commit_settings)
+
+      Dir.chdir(repo) do
+        cmd = ["git", "commit", "--amend", "-F-"]
+        IO.popen(cmd, "w+") do |io|
+          io.write(commit_settings[:message])
+          io.close_write
+          logger.pipe(io => :debug)
+        end
+      end
+
+    end # def apply_commit
+
+    def system!(*args)
+      logger.debug("Running command", :args => args)
+      # TODO(sissel): use Open4
+      IO.popen(args, "r") do |io|
+        logger.pipe(io => :debug)
+      end
+      status = $?
+      return if status.success?
+      raise "Command failed; #{args.inspect}"
+    end
+
+    def github_client
+      require "octokit"
+      # This requires you have ~/.netrc setup correctly
+      # I don't know if it works with 2FA
+      @client ||= Octokit::Client.new(:netrc => true).tap do |client|
+        client.login
+        client.auto_paginate = true
+      end
+    end # def client
+
+    def github_issue_label(project, issue, labels)
+      logger.debug('Adding label to a specific issue', :project => project, :issue => issue, :labels => labels)
+      github_client.add_labels_to_an_issue(project, issue, labels) unless labels.empty?
+    rescue => e
+      raise e.class, "Failed adding label '#{labels}' to issue #{issue} on #{project}: #{e}"
+    end # def github_issue_label
+
+    def github_issue_comment(project, issue, comment)
+      logger.debug('Adding a comment to an given issue', :project => project, :issue => issue, :comment => comment)
+      github_client.add_comment(project, issue, comment) unless comment.empty?
+    rescue => e
+      raise e.class, "Failed adding a comment #{comment} to issue #{issue} on #{project}: #{e}"
+
+    end # def github_issue_comment
+
+    def github_create_pr(project, branch, title, body)
+      logger.debug('Creating a pull request', :project => project, :branch => branch)
+      github_client.create_pull_request(project, "master", branch, title, body)
+    end
+
+    def github_get_pr(project, pr_num)
+      github_client.pull_request(project, pr_num)
+    end
+
+    def git(gitdir, *args)
+      Dir.chdir(gitdir) do
+        system!("git", *args)
+      end
+    end
+  end # module Util
+
+end # module LitaJLS