gitarro 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 21a43e24207cd6e412c688d57f5b72ed7ea32cec
+  data.tar.gz: 609ce571224ad1e2f22c07ac485827ecb9d58a48
+SHA512:
+  metadata.gz: e15bf72520a193ba91c5c0a3a8d997e9d383602c79eee58268f23a8ee1d91a8cde6e6ff8548a94c43140d0e8a4b0e12365e04e0c0a05ff12de40c081f8e5c163
+  data.tar.gz: 340b3c242adc41878378ca5753ed4aa92ffbf0402fadffd4fc0a894f7477f603879d97abeedca827cd66243ea94d16490b94650430215c4d153a64e9e1cd19cc

data/bin/gitarro

@@ -0,0 +1,34 @@
+#!/usr/bin/ruby
+
+require 'English'
+require 'octokit'
+require 'optparse'
+require 'gitarro/opt_parser'
+require 'gitarro/git_op'
+require 'gitarro/backend'
+
+b = Backend.new
+prs = b.open_prs
+
+prs.each do |pr|
+  puts '=' * 30 + "\n" + "TITLE_PR: #{pr.title}, NR: #{pr.number}\n" + '=' * 30
+  # this check the last commit state, catch for review or not reviewd status.
+  comm_st = b.client.status(b.repo, pr.head.sha)
+  # pr number trigger.
+  break if b.trigger_by_pr_number(pr)
+  # retrigger if magic word found
+  b.retrigger_check(pr)
+  # check if changelog test was enabled
+  break if b.changelog_active(pr, comm_st)
+  # 0) do test for unreviewed pr
+  break if b.unreviewed_pr_test(pr, comm_st)
+  # we run the test in 2 conditions:
+  # 1) the context  is not set, test didnt run
+  # 2) the pending status is set on commit, repeat always when pending set
+  # check the conditions 1,2 and it they happens run_test
+  break if b.reviewed_pr_test(comm_st, pr)
+end
+STDOUT.flush
+
+# red balls for jenkins
+exit 1 if b.j_status == 'failure'

data/lib/gitarro/backend.rb

@@ -0,0 +1,281 @@
+#! /usr/bin/ruby
+
+require 'octokit'
+require 'optparse'
+require 'English'
+require_relative 'opt_parser'
+require_relative 'git_op'
+
+# This is a private class, which has the task to execute/run tests
+# called by Backend
+class TestExecutor
+  def initialize(options)
+    @options = options
+    @options.each do |key, value|
+      instance_variable_set("@#{key}", value)
+      self.class.send(:attr_accessor, key)
+    end
+  end
+
+  # this will clone the repo and execute the tests
+  def pr_test(pr)
+    git = GitOp.new(@git_dir, pr, @options)
+    # merge PR-branch to upstream branch
+    git.merge_pr_totarget(pr.base.ref, pr.head.ref)
+    # do valid tests and store the result
+    test_status = run_script
+    # del branch
+    git.del_pr_branch(pr.base.ref, pr.head.ref)
+    test_status
+  end
+
+  # run validation script for validating the PR.
+  def run_script
+    script_exists?(@test_file)
+    puts `#{@test_file}`
+    $CHILD_STATUS.exitstatus.nonzero? ? 'failure' : 'success'
+  end
+
+  private
+
+  def script_exists?(script)
+    n_exist = "\'#{script}\' doesn't exists.Enter valid file, -t option"
+    raise n_exist if File.file?(script) == false
+  end
+end
+
+# this the public class is the backend of gitarro,
+# were we execute the tests and so on
+class Backend
+  attr_accessor :j_status, :options, :client, :pr_files, :gbexec
+  # public method of backend
+  def initialize(option = nil)
+    Octokit.auto_paginate = true
+    @client = Octokit::Client.new(netrc: true)
+    @options = option.nil? ? OptParser.new.cmdline_options : option
+    @j_status = ''
+    @pr_files = []
+    # each options will generate a object variable dinamically
+    @options.each do |key, value|
+      instance_variable_set("@#{key}", value)
+      self.class.send(:attr_accessor, key)
+    end
+    @gbexec = TestExecutor.new(@options)
+  end
+
+  # public method for get prs opens
+  # given a repo
+  def open_prs
+    prs = @client.pull_requests(@repo, state: 'open')
+    puts 'no Pull request OPEN on the REPO!' unless prs.any?
+    prs
+  end
+
+  # public for etrigger the test
+  def retrigger_check(pr)
+    return unless retrigger_needed?(pr)
+    client.create_status(@repo, pr.head.sha, 'pending',
+                         context: @context, description: @description,
+                         target_url: @target_url)
+    exit 1 if @check
+    launch_test_and_setup_status(@repo, pr)
+    j_status == 'success' ? exit(0) : exit(1)
+  end
+
+  # public always rerun tests against the pr number if this exists
+  def trigger_by_pr_number(pr)
+    return false if @pr_number.nil?
+    return false if @pr_number != pr.number
+    puts "Got triggered by PR_NUMBER OPTION, rerunning on #{@pr_number}"
+    launch_test_and_setup_status(@repo, pr)
+    true
+  end
+
+  # public method, trigger changelogtest if option active
+  def changelog_active(pr, comm_st)
+    return false unless @changelog_test
+    return false unless changelog_changed(@repo, pr, comm_st)
+    true
+  end
+
+  def unreviewed_pr_test(pr, comm_st)
+    return unless unreviewed_pr_ck(comm_st)
+    pr_all_files_type(@repo, pr.number, @file_type)
+    return if empty_files_changed_by_pr
+    # gb.check is true when there is a job running as scheduler
+    # which doesn't execute the test but trigger another job
+    return false if @check
+    launch_test_and_setup_status(@repo, pr)
+    true
+  end
+
+  def reviewed_pr_test(comm_st, pr)
+    # if PR status is not on pending and the context is not set,
+    #  we dont run the tests
+    return false unless context_pr(comm_st) == false ||
+                        pending_pr(comm_st) == true
+    pr_all_files_type(@repo, pr.number, @file_type)
+    return true if changelog_active(pr, comm_st)
+    return false unless @pr_files.any?
+    exit 1 if @check
+    launch_test_and_setup_status(@repo, pr)
+    true
+  end
+
+  private
+
+  # this function setup first pending to PR, then execute the tests
+  # then set the status according to the results of script executed.
+  # pr_head = is the PR branch
+  # base = is a the upstream branch, where the pr targets
+  def launch_test_and_setup_status(repo, pr)
+    # pending
+    @client.create_status(repo, pr.head.sha, 'pending',
+                          context: @context, description: @description,
+                          target_url: @target_url)
+    # do tests
+    @j_status = gbexec.pr_test(pr)
+    # set status
+    @client.create_status(repo, pr.head.sha, @j_status,
+                          context: @context, description: @description,
+                          target_url: @target_url)
+  end
+
+  # this function will check if the PR contains in comment the magic word
+  # # for retrigger all the tests.
+  def magicword(repo, pr_number, context)
+    magic_word_trigger = "@gitarro rerun #{context} !!!"
+    pr_comment = @client.issue_comments(repo, pr_number)
+    # a pr contain always a comments, cannot be nil
+    pr_comment.each do |com|
+      # delete comment otherwise it will be retrigger infinetely
+      if com.body.include? magic_word_trigger
+        @client.delete_comment(repo, com.id)
+        return true
+      end
+    end
+    false
+  end
+
+  # check all files of a Prs Number if they are a specific type
+  # EX: Pr 56, we check if files are '.rb'
+  def pr_all_files_type(repo, pr_number, type)
+    files = @client.pull_request_files(repo, pr_number)
+    files.each do |file|
+      @pr_files.push(file.filename) if file.filename.include? type
+    end
+  end
+
+  # check if the commit of a pr is on pending
+  def pending_pr(comm_st)
+    # 2) pending
+    pending_on_context = false
+    (0..comm_st.statuses.size - 1).each do |pr_status|
+      if comm_st.statuses[pr_status]['context'] == @context &&
+         comm_st.statuses[pr_status]['state'] == 'pending'
+        pending_on_context = true
+      end
+    end
+    pending_on_context
+  end
+
+  # if the Pr contains magic word, test changelog
+  # is true
+  def magic_comment(repo, pr_num)
+    @client.issue_comments(repo, pr_num).each do |com|
+      if com.body.include?('no changelog needed!')
+        @j_status = 'success'
+        break
+      end
+    end
+  end
+
+  # check it the cm of pr contain the context from gitarro already
+  def context_pr(cm_st)
+    # 1) context_present == false  triggers test. >
+    # this means  the PR is not with context tagged
+    context_present = false
+    (0..cm_st.statuses.size - 1).each do |pr_status|
+      context_present = true if cm_st.statuses[pr_status]['context'] == @context
+    end
+    context_present
+  end
+
+  # if the pr has travis test and one custom, we will have 2 elements.
+  # in this case, if the 1st element doesn't have the state property
+  # state property is "pending", failure etc.
+  # if we don't have this, so we have 0 status
+  # the PRs is "unreviewed"
+  def unreviewed_pr_ck(comm_st)
+    puts comm_st.statuses[0]['state']
+    return false
+  rescue NoMethodError
+    return true
+  end
+
+  def success_status?(comm_st)
+    status = false
+    (0..comm_st.statuses.size - 1).each do |pr_status|
+      if comm_st.statuses[pr_status]['context'] == @context &&
+         comm_st.statuses[pr_status]['state'] == 'success'
+        status = true
+      end
+    end
+    status
+  end
+
+  def failed_status?(comm_st)
+    status = false
+    (0..comm_st.statuses.size - 1).each do |pr_status|
+      if comm_st.statuses[pr_status]['context'] == @context &&
+         comm_st.statuses[pr_status]['state'] == 'failure'
+        status = true
+      end
+    end
+    status
+  end
+
+  # control if the pr change add any files, specified
+  # it can be also a dir
+  def empty_files_changed_by_pr
+    return if pr_files.any?
+    puts "no files of type #{@file_type} found! skipping"
+    true
+  end
+
+  def do_changelog_test(repo, pr)
+    @j_status = 'failure'
+    pr_all_files_type(repo, pr.number, @file_type)
+    # if the pr contains changes on .changes file, test ok
+    @j_status = 'success' if @pr_files.any?
+    magic_comment(repo, pr.number)
+    @client.create_status(repo, pr.head.sha, @j_status,
+                          context: @context, description: @description,
+                          target_url: @target_url)
+    true
+  end
+
+  # do the changelog test and set status
+  def changelog_changed(repo, pr, comm_st)
+    return false unless @changelog_test
+    # only execute 1 time, don"t run if test is failed, or ok
+    return false if failed_status?(comm_st)
+    return false if success_status?(comm_st)
+    do_changelog_test(repo, pr)
+  end
+
+  def retrigger_needed?(pr)
+    # we want redo sometimes tests
+    return false unless magicword(@repo, pr.number, @context)
+    # changelog trigger
+    if @changelog_test
+      do_changelog_test(@repo, pr)
+      return false
+    end
+    pr_all_files_type(@repo, pr.number, @file_type)
+    return false unless @pr_files.any?
+    # if check is set, the comment in the trigger job will be del.
+    # so setting it to pending, it will be remembered
+    true
+  end
+end

data/lib/gitarro/git_op.rb

@@ -0,0 +1,128 @@
+#! /usr/bin/ruby
+
+require 'English'
+require 'fileutils'
+require 'timeout'
+
+# git operation for gitarro
+class GitOp
+  attr_reader :git_dir, :pr, :pr_fix, :repo_external, :repo_protocol
+  def initialize(git_dir, pr, options)
+    @git_dir = git_dir
+    # prefix for the test pr that gitarro tests.
+    @pr_fix = 'PR-'
+    # pr object for extract all relev. data.
+    @pr = pr
+    # All GitBot options
+    @options = options
+    # object to handle external repos
+    @repo_external = ExternalRepoGit.new(pr, options)
+    gh = 'https://github.com/'
+    gg = 'git@github.com:'
+    @repo_protocol = @options[:https] ? gh : gg
+  end
+
+  def ck_or_clone_git
+    return if File.directory?(git_dir)
+    FileUtils.mkdir_p(git_dir)
+    Dir.chdir git_dir
+    repo_url = "#{repo_protocol}#{@options[:repo]}.git"
+    puts `git clone #{repo_url}`
+  end
+
+  # this function merge the pr branch  into target branch,
+  # where the author of pr wanted to submit
+  def goto_prj_dir
+    git_repo_dir = git_dir + '/' + @options[:repo].split('/')[1]
+    # chech that dir exist, otherwise clone it
+    ck_or_clone_git
+    begin
+      # /tmp/gitarro, this is in case the dir already exists
+      Dir.chdir git_repo_dir
+    rescue Errno::ENOENT
+      # this is in case we clone the repo
+      Dir.chdir @options[:repo].split('/')[1]
+    end
+  end
+
+  def check_git_dir
+    msg_err = 'gitarro is not working on a git directory'
+    raise msg_err if File.directory?('.git') == false
+  end
+
+  # this is for preventing that a test branch exists already
+  # and we have some internal error
+  def check_duplicata_pr_branch(pr)
+    puts `git branch --list #{pr}`
+    `git branch -D #{pr} 2>/dev/null` if $CHILD_STATUS.exitstatus.zero?
+  end
+
+  # merge pr_branch into upstream targeted branch
+  def merge_pr_totarget(upstream, pr_branch)
+    goto_prj_dir
+    check_git_dir
+    `git checkout #{upstream}`
+    check_duplicata_pr_branch("#{pr_fix}#{pr_branch}")
+    `git remote update`
+    `git fetch`
+    `git pull origin #{upstream}`
+    `git checkout -b #{pr_fix}#{pr_branch} origin/#{pr_branch}`
+    return if $CHILD_STATUS.exitstatus.zero?
+    # if it fails the PR contain a forked external repo
+    repo_external.checkout_into
+  end
+
+  # cleanup the pr_branch(delete it)
+  def del_pr_branch(upstream, pr)
+    `git checkout #{upstream}`
+    `git branch -D  #{pr_fix}#{pr}`
+  end
+end
+
+# This private class handle the case the repo from PR
+# comes from a user external repo
+# PR open against: openSUSE/gitarro
+# PR repo:  MyUSER/gitarro
+class ExternalRepoGit
+  attr_reader :pr, :rem_repo, :pr_fix
+  def initialize(pr, options)
+    # pr object for extract all relev. data.
+    @pr = pr
+    @pr_fix = 'PR-'
+    @options = options
+  end
+
+  def checkout_into
+    rem_repo = 'rem' + pr.head.ref
+    add_remote(rem_repo)
+    fetch_remote(rem_repo)
+    checkout_to_rem_branch(rem_repo)
+    remove_repo(rem_repo)
+  end
+
+  private
+
+  def checkout_to_rem_branch(rem_repo)
+    puts `git checkout -b #{pr_fix}#{branch_rem} #{rem_repo}/#{branch_rem}`
+    exit 1 if $CHILD_STATUS.exitstatus.nonzero?
+  end
+
+  def branch_rem
+    pr.head.ref
+  end
+
+  def add_remote(rem_repo)
+    repo_url = @options[:https] ? pr.head.repo.html_url : pr.head.repo.ssh_url
+    puts `git remote add #{rem_repo} #{repo_url}`
+  end
+
+  def fetch_remote(rem_repo)
+    puts `git remote update`
+    puts `git fetch`
+    puts `git pull #{rem_repo} #{pr.head.ref}`
+  end
+
+  def remove_repo(rem_repo)
+    puts `git remote remove #{rem_repo}`
+  end
+end

data/lib/gitarro/opt_parser.rb

@@ -0,0 +1,197 @@
+#! /usr/bin/ruby
+
+# this are the mandatory options
+module MandatoryOptions
+  # primary
+  def context_opt(opt)
+    desc = 'Context to set on comment (test name). For example: python-test.'
+    opt.on('-c', "--context 'CONTEXT'", desc) do |context|
+      @options[:context] = context
+    end
+  end
+
+  def repo_opt(opt)
+    desc = 'GitHub repository to look for PRs. For example: openSUSE/gitarro.'
+    opt.on('-r', "--repo 'REPO'", desc) { |repo| @options[:repo] = repo }
+  end
+
+  def test_opt(opt)
+    desc = 'Command, or full path to script/binary to be used to run the test.'
+    opt.on('-t', "--test 'TEST.SH'", desc) do |test_file|
+      @options[:test_file] = test_file
+    end
+  end
+
+  def file_opt(opt)
+    file_description = 'pr_file type to run the test against: .py, .rb'
+    opt.on('-f', "--file \'.py\'", file_description) do |file_type|
+      @options[:file_type] = file_type
+    end
+  end
+
+  def git_opt(opt)
+    desc = 'Specify a location where gitarro will clone the GitHub project. '\
+           'If the dir does not exists, gitarro will create one. '\
+           'For example: /tmp/'
+    opt.on('-g', "--git_dir 'GIT_LOCAL_DIR'", desc) do |git_dir|
+      @options[:git_dir] = git_dir
+    end
+  end
+
+  def mandatory_options(opt)
+    opt.separator 'Mandatory options:'
+    repo_opt(opt)
+    context_opt(opt)
+    test_opt(opt)
+    file_opt(opt)
+    git_opt(opt)
+  end
+end
+
+# this are the optional options
+module OptionalOptions
+  def check_opt(opt)
+    desc = 'Check if there is any PR requiring a test, but do not run it.'
+    opt.on('-C', '--check', desc) { |check| @options[:check] = check }
+  end
+
+  def desc_opt(opt)
+    opt.on('-d', "--description 'DESCRIPTION'", 'Test decription') do |d|
+      @options[:description] = d
+    end
+  end
+
+  def url_opt(opt)
+    desc = 'Specify the URL to append to add to the GitHub review. ' \
+           'Usually you will use an URL to the Jenkins build log.'
+    opt.on('-u', "--url 'TARGET_URL'", desc) do |target_url|
+      @options[:target_url] = target_url
+    end
+  end
+
+  def https_opt(opt)
+    https_desc = 'If present, use https instead of ssh for git operations'
+    opt.on('--https', https_desc) { |https| @options[:https] = https }
+  end
+
+  def changelog_opt(opt)
+    desc = 'Check if the PR includes a changelog entry ' \
+           '(Automatically sets --file ".changes").'
+    opt.on('--changelogtest', desc) do |changelogtest|
+      @options[:changelog_test] = changelogtest
+    end
+  end
+
+  def pr_number(opt)
+    desc = 'Specify the PR number instead of checking all of them. ' \
+           'Force to rerun against a specific PR number,' \
+           'even if it is not needed.'
+    opt.on('-P', "--PR 'NUMBER'", desc) do |pr_number|
+      @options[:pr_number] = Integer(pr_number)
+    end
+  end
+
+  def optional_options(opt)
+    opt.separator ''
+    opt.separator 'Optional options:'
+    desc_opt(opt)
+    check_opt(opt)
+    changelog_opt(opt)
+    url_opt(opt)
+    pr_number(opt)
+    https_opt(opt)
+  end
+end
+
+# this class is only private and helper for main class OptParser
+class OptParserInternal
+  include MandatoryOptions
+  include OptionalOptions
+  attr_accessor :options
+  def initialize
+    @options = {}
+    @options = options.clone if options.any?
+  end
+
+  # all this methods are private
+  def raise_incorrect_syntax(msg)
+    puts "Incorrect syntax: #{msg}\n\n"
+    puts 'Use option -h for help'
+    exit 1
+  end
+
+  def ck_mandatory_option(option)
+    return unless @options[option.to_sym].nil?
+    raise_incorrect_syntax("option --#{option} not found")
+  end
+
+  def parse(opt_parser)
+    parse_options(opt_parser)
+    mandatory_options = %w[repo context test_file file_type git_dir]
+    mandatory_options.each { |opt| ck_mandatory_option(opt) }
+    if @options[:test_file].nil? && @options[:changelog_test].nil?
+      raise_incorrect_syntax('Incorrect syntax (use -h for help)')
+    end
+    defaults_false
+    defaults_to_text
+  end
+
+  # option help
+  def option_help(opt)
+    opt.separator ''
+    opt.separator 'Help:'
+    opt.on('-h', '--help', 'help') do
+      opt.separator ''
+      opt.separator "Example: gitarro.rb -r openSUSE/gitarro -c 'python-test' "\
+                    "-d 'someCoolTest' -g /tmp/pr-ruby01/ -t /tmp/test.sh "\
+                    "-f '.py'"
+      puts @opt_parser
+      exit 0
+    end
+  end
+
+  private
+
+  def parse_options(opt_parser)
+    opt_parser.parse!
+  rescue OptionParser::ParseError
+    raise_incorrect_syntax($ERROR_INFO.to_s)
+  end
+
+  # set some default values
+  def defaults_false
+    @options[:check] = false if @options[:check].nil?
+    @options[:changelog_test] = false if @options[:changelog_test].nil?
+    @options[:target_url] = '' if @options[:target_url].nil?
+    @options[:https] = false if @options[:https].nil?
+  end
+
+  def defaults_to_text
+    desc = 'use option -d to set a custom test description.'
+    @options[:file_type] = '.changes' if @options[:changelog_test]
+    @options[:description] = desc if @options[:description].nil?
+  end
+end
+
+# Opt_parser class, is for getting needed options
+#  this is the public class used by backend
+class OptParser < OptParserInternal
+  private
+
+  def option_banner(opt)
+    opt.banner = "Usage: gitarro.rb [options]\n\n" \
+  end
+
+  public
+
+  def cmdline_options
+    @opt_parser = OptionParser.new do |opt|
+      option_banner(opt)
+      mandatory_options(opt)
+      optional_options(opt)
+      option_help(opt)
+    end
+    parse(@opt_parser)
+    @options
+  end
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: gitarro
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Dario Maiocchi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: english
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: netrc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: octokit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.49'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+description: gitarro run tests on GitHub PRs using almost any script,language or binary,
+  it integrate easy with other tools.
+email: dmaiocchi@suse.com
+executables:
+- gitarro
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/gitarro
+- lib/gitarro/backend.rb
+- lib/gitarro/git_op.rb
+- lib/gitarro/opt_parser.rb
+homepage: https://github.com/openSUSE/gitarro
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: gitarro gem
+test_files: []