gitarro 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21a43e24207cd6e412c688d57f5b72ed7ea32cec
-  data.tar.gz: 609ce571224ad1e2f22c07ac485827ecb9d58a48
+  metadata.gz: ccdb6d7e8c2822e5d5d3fe1927b230682c66c23e
+  data.tar.gz: 6420d8c9820c8304af0360ad33735e48fb720b38
 SHA512:
-  metadata.gz: e15bf72520a193ba91c5c0a3a8d997e9d383602c79eee58268f23a8ee1d91a8cde6e6ff8548a94c43140d0e8a4b0e12365e04e0c0a05ff12de40c081f8e5c163
-  data.tar.gz: 340b3c242adc41878378ca5753ed4aa92ffbf0402fadffd4fc0a894f7477f603879d97abeedca827cd66243ea94d16490b94650430215c4d153a64e9e1cd19cc
+  metadata.gz: 202efc92cb0f803c0ad60864778bc29a37a3172c61ab5311eafcf6a1ab6a95dab1bea7b086895d2d5a4b1e567ab34441fb686810b6d438d6ba914f33caefd89f
+  data.tar.gz: 96096a7ac449182c9c7cafa55d770b81f76c3c77516f1d26ebd3448c79a2523f8e078755d70db98384e13995c248e55ba9f152ef619bb58f6bf1999562e941ad

data/bin/gitarro

@@ -8,27 +8,25 @@ require 'gitarro/git_op'
 require 'gitarro/backend'
 
 b = Backend.new
-prs = b.open_prs
+prs = b.open_newer_prs
+exit 0 if prs.empty?
 
 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)
+  break if b.triggered_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)
+  break if b.changelog_active?(pr, comm_st)
   # 0) do test for unreviewed pr
-  break if b.unreviewed_pr_test(pr, comm_st)
+  break if b.unreviewed_new_pr?(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)
+  break if b.reviewed_pr?(comm_st, pr)
 end
 STDOUT.flush
-
-# red balls for jenkins
-exit 1 if b.j_status == 'failure'

data/lib/gitarro/backend.rb

@@ -2,9 +2,65 @@
 
 require 'octokit'
 require 'optparse'
+require 'time'
 require 'English'
+require 'faraday-http-cache'
 require_relative 'opt_parser'
 require_relative 'git_op'
+require 'active_support'
+
+# by default enabled (faraday_cache in memory, will be deleted
+# after gitarro run 2nd time. usefull for -C check option
+# and performance, since we cache)
+module CachingOctokit
+  def create_dir_store(cache_path)
+    cache_name = 'httpcache'
+    full_cache_dir = "#{cache_path}#{cache_name}"
+    ActiveSupport::Cache::FileStore.new(full_cache_dir)
+  end
+
+  def generate_cache(httpcache_path)
+    # changed_since cannot work with cache
+    return false if @changed_since > 0
+    stack = Faraday::RackBuilder.new do |builder|
+      builder.use Faraday::HttpCache,
+                  store: create_dir_store(httpcache_path),
+                  serializer: Marshal,
+                  shared_cache: false
+      builder.use Octokit::Response::RaiseError
+      builder.adapter Faraday.default_adapter
+    end
+    Octokit.middleware = stack
+  end
+end
+
+# this module have helper methods for changelog tests
+# it will be removed soon, but it helps to extract all
+# changelog code from backend class
+module ChangelogTests
+  def magic_comment?(pr_num)
+    @client.issue_comments(@repo, pr_num).any? do |com|
+      com.body.include?('no changelog needed!')
+    end
+  end
+
+  def do_changelog_test(pr)
+    # if the pr contains changes on .changes file, test ok
+    test_status = 'failure'
+    test_status = 'success' if pr_all_files_type(pr.number, @file_type).any?
+    test_status = 'success' if magic_comment?(pr.number)
+    create_status(pr, test_status)
+    test_status
+  end
+
+  # do the changelog test and set status
+  def changelog_changed?(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) || success_status?(comm_st)
+    do_changelog_test(pr)
+  end
+end
 
 # This is a private class, which has the task to execute/run tests
 # called by Backend
@@ -47,158 +103,185 @@ 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
+  attr_accessor :options, :client, :gbexec
+  # changelog tests module ( FIXME  remove this once changelog
+  # tests are gone from backend and run separately
+  include CachingOctokit
+  include ChangelogTests
   # 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
+    # if changed_since option on, dont generate cache.
+    generate_cache(@cachehttp)
+    Octokit.auto_paginate = true
+    @client = Octokit::Client.new(netrc: true)
     @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?
+  # public method for get prs opened and matching the changed_since
+  # condition
+  def open_newer_prs
+    prs = @client.pull_requests(@repo, state: 'open').select do |pr|
+      pr_last_update_less_than(pr, @options[:changed_since])
+    end
+    print_pr_resume(prs)
     prs
   end
 
-  # public for etrigger the test
+  # public for retrigger 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)
+    create_status(pr, 'pending')
+    print_test_required
+    exit 0 if @check
+    launch_test_and_setup_status(pr) == '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
+  def triggered_by_pr_number?(pr)
+    return false if @pr_number.nil? || @pr_number != pr.number
     puts "Got triggered by PR_NUMBER OPTION, rerunning on #{@pr_number}"
-    launch_test_and_setup_status(@repo, pr)
-    true
+    print_test_required
+    launch_test_and_setup_status(pr)
   end
 
+  # FIXME: remove this pub. method once changelog test are separated
   # public method, trigger changelogtest if option active
-  def changelog_active(pr, comm_st)
+  def changelog_active?(pr, comm_st)
     return false unless @changelog_test
-    return false unless changelog_changed(@repo, pr, comm_st)
+    return false unless changelog_changed?(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
+  def unreviewed_new_pr?(pr, comm_st)
+    return unless commit_is_unreviewed?(comm_st)
+    pr_all_files_type(pr.number, @file_type)
+    return if empty_files_changed_by_pr(pr)
     # gb.check is true when there is a job running as scheduler
     # which doesn't execute the test but trigger another job
+    print_test_required
     return false if @check
-    launch_test_and_setup_status(@repo, pr)
-    true
+    launch_test_and_setup_status(pr)
   end
 
-  def reviewed_pr_test(comm_st, pr)
+  def reviewed_pr?(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)
+    return false unless context_present?(comm_st) == false ||
+                        pending_pr?(comm_st)
+    return true if changelog_active?(pr, comm_st)
+    return false unless pr_all_files_type(pr.number, @file_type).any?
+    print_test_required
+    exit(0) if @check
+    launch_test_and_setup_status(pr)
   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)
+  def retriggered_by_comment?(pr_number, context)
+    magic_word_trigger = "gitarro rerun #{context} !!!"
     # a pr contain always a comments, cannot be nil
-    pr_comment.each do |com|
+    @client.issue_comments(@repo, pr_number).each do |com|
       # delete comment otherwise it will be retrigger infinetely
       if com.body.include? magic_word_trigger
-        @client.delete_comment(repo, com.id)
+        @client.delete_comment(@repo, com.id)
         return true
       end
     end
     false
   end
 
+  private
+
+  # Show a message stating if there are opened PRs or not
+  def print_pr_resume(prs)
+    if prs.any?
+      puts "[PRS=#{prs.any?}] PRs opened. Analyzing them..."
+      return
+    end
+    if @options[:changed_since] >= 0
+      puts "[PRS=#{prs.any?}] No Pull Requests opened or with changes " \
+           "newer than #{options[:changed_since]} seconds"
+    else
+      puts "[PRS=#{prs.any?}] No Pull Requests opened"
+    end
+  end
+
+  def print_test_required
+    puts '[TESTREQUIRED=true] PR requires test'
+  end
+
+  # Create a status for a PR
+  def create_status(pr, status)
+    client.create_status(@repo, pr.head.sha, status, context: @context,
+                                                     description: @description,
+                                                     target_url: @target_url)
+  end
+
+  # Return true if the PR was updated in less than the value of variable sec
+  # or if sec < 0 (the check was disabled)
+  # GitHub considers a PR updated when there is a new commit or a new comment
+  def pr_last_update_less_than(pr, sec)
+    Time.now.utc - pr.updated_at < sec || sec < 0 ? true : false
+  end
+
+  # 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
+  # it return a string 'success', 'failure' (github status)
+  def launch_test_and_setup_status(pr)
+    # pending
+    create_status(pr, 'pending')
+    # do tests
+    test_status = gbexec.pr_test(pr)
+    # set status
+    create_status(pr, test_status)
+    # return status for other functions
+    test_status
+  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
+  def pr_all_files_type(pr_number, type)
+    filter_files_by_type(@client.pull_request_files(@repo, pr_number), type)
   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
+  # by default type is 'notype', which imply we get all files
+  # modified by a Pull Request
+  # otherwise we filter the file '.rb' type or fs ''
+  def filter_files_by_type(files, type)
+    # ff: filtered files array
+    ff = []
+    if type == 'notype'
+      ff = files
+    else
+      files.each { |f| ff.push(f.filename) if f.filename.include? type }
     end
-    pending_on_context
+    ff
   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
+  # check if the commit of a pr is on pending
+  def pending_pr?(comm_st)
+    # 2) pending
+    (0..comm_st.statuses.size - 1).any? do |pr_status|
+      comm_st.statuses[pr_status]['context'] == @context &&
+        comm_st.statuses[pr_status]['state'] == 'pending'
     end
   end
 
   # check it the cm of pr contain the context from gitarro already
-  def context_pr(cm_st)
+  def context_present?(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
+    (0..cm_st.statuses.size - 1).any? do |pr_status|
+      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.
@@ -206,7 +289,7 @@ class Backend
   # 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)
+  def commit_is_unreviewed?(comm_st)
     puts comm_st.statuses[0]['state']
     return false
   rescue NoMethodError
@@ -214,68 +297,37 @@ class Backend
   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
+    (0..comm_st.statuses.size - 1).any? do |pr_status|
+      comm_st.statuses[pr_status]['context'] == @context &&
+        comm_st.statuses[pr_status]['state'] == 'success'
     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
+    (0..comm_st.statuses.size - 1).any? do |pr_status|
+      comm_st.statuses[pr_status]['context'] == @context &&
+        comm_st.statuses[pr_status]['state'] == 'failure'
     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?
+  def empty_files_changed_by_pr(pr)
+    return if pr_all_files_type(pr.number, @file_type).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)
+    return false unless retriggered_by_comment?(pr.number, @context)
     # changelog trigger
     if @changelog_test
-      do_changelog_test(@repo, pr)
+      do_changelog_test(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
+    pr_all_files_type(pr.number, @file_type).any?
   end
 end

data/lib/gitarro/git_op.rb

@@ -4,6 +4,7 @@ require 'English'
 require 'fileutils'
 require 'timeout'
 
+# This class is used by lib/backend.rb
 # git operation for gitarro
 class GitOp
   attr_reader :git_dir, :pr, :pr_fix, :repo_external, :repo_protocol
@@ -13,7 +14,7 @@ class GitOp
     @pr_fix = 'PR-'
     # pr object for extract all relev. data.
     @pr = pr
-    # All GitBot options
+    # All gitarro options
     @options = options
     # object to handle external repos
     @repo_external = ExternalRepoGit.new(pr, options)
@@ -22,12 +23,41 @@ class GitOp
     @repo_protocol = @options[:https] ? gh : gg
   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
+
+  private
+
   def ck_or_clone_git
-    return if File.directory?(git_dir)
-    FileUtils.mkdir_p(git_dir)
+    git_repo_dir = git_dir + '/' + @options[:repo].split('/')[1]
+    return if File.directory?(git_repo_dir)
+    FileUtils.mkdir_p(git_dir) unless File.directory?(git_dir)
     Dir.chdir git_dir
+    clone_repo
+  end
+
+  def clone_repo
     repo_url = "#{repo_protocol}#{@options[:repo]}.git"
     puts `git clone #{repo_url}`
+    exit 1 if $CHILD_STATUS.exitstatus.nonzero?
   end
 
   # this function merge the pr branch  into target branch,
@@ -56,27 +86,6 @@ class GitOp
     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

data/lib/gitarro/opt_parser.rb

@@ -22,13 +22,6 @@ module MandatoryOptions
     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. '\
@@ -43,7 +36,6 @@ module MandatoryOptions
     repo_opt(opt)
     context_opt(opt)
     test_opt(opt)
-    file_opt(opt)
     git_opt(opt)
   end
 end
@@ -69,11 +61,26 @@ module OptionalOptions
     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 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 cachehttp_opt(opt)
+    desc = 'Custom path where http cache for gitarro is stored' \
+           'by default is set to /tmp/gitarro/httpcache'
+    opt.on('-k', "--cachepath 'CACHEPATH'", desc) do |cache_http|
+      @options[:cachehttp] = cache_http
+    end
+  end
+
   def changelog_opt(opt)
     desc = 'Check if the PR includes a changelog entry ' \
            '(Automatically sets --file ".changes").'
@@ -91,15 +98,26 @@ module OptionalOptions
     end
   end
 
+  def changed_since(opt)
+    changed_since_desc = 'If present, will only check PRs with a ' \
+                       'change in the last X seconds'
+    opt.on("--changed_since 'SECONDS'",
+           changed_since_desc) do |changed_since|
+      @options[:changed_since] = Integer(changed_since)
+    end
+  end
+
   def optional_options(opt)
-    opt.separator ''
-    opt.separator 'Optional options:'
+    opt.separator "\n Optional options:"
     desc_opt(opt)
     check_opt(opt)
+    file_opt(opt)
     changelog_opt(opt)
     url_opt(opt)
     pr_number(opt)
     https_opt(opt)
+    cachehttp_opt(opt)
+    changed_since(opt)
   end
 end
 
@@ -127,7 +145,7 @@ class OptParserInternal
 
   def parse(opt_parser)
     parse_options(opt_parser)
-    mandatory_options = %w[repo context test_file file_type git_dir]
+    mandatory_options = %w[repo context test_file 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)')
@@ -138,11 +156,10 @@ class OptParserInternal
 
   # option help
   def option_help(opt)
-    opt.separator ''
-    opt.separator 'Help:'
+    opt.separator "\n Help:"
     opt.on('-h', '--help', 'help') do
-      opt.separator ''
-      opt.separator "Example: gitarro.rb -r openSUSE/gitarro -c 'python-test' "\
+      opt.separator " \n Example: gitarro.rb -r " \
+                    "openSUSE/gitarro -c 'python-test " \
                     "-d 'someCoolTest' -g /tmp/pr-ruby01/ -t /tmp/test.sh "\
                     "-f '.py'"
       puts @opt_parser
@@ -164,29 +181,24 @@ class OptParserInternal
     @options[:changelog_test] = false if @options[:changelog_test].nil?
     @options[:target_url] = '' if @options[:target_url].nil?
     @options[:https] = false if @options[:https].nil?
+    @options[:changed_since] = -1 if @options[:changed_since].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?
+    @options[:file_type] = 'notype' if @options[:file_type].nil?
+    @options[:cachehttp] = '/tmp/gitarro' if @options[:cachehttp].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)
+      opt.banner = "Usage: gitarro.rb [options]\n\n"
       mandatory_options(opt)
       optional_options(opt)
       option_help(opt)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gitarro
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors:
 - Dario Maiocchi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-26 00:00:00.000000000 Z
+date: 2017-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: english
@@ -122,6 +122,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: faraday-http-cache
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 description: gitarro run tests on GitHub PRs using almost any script,language or binary,
   it integrate easy with other tools.
 email: dmaiocchi@suse.com