github-ripper 0.1.0

data/lib/github-ripper/git.rb

@@ -0,0 +1,81 @@
+#
+# Class docs to go here
+#
+
+#
+# This class smells of :reek:DataClump
+#
+class GithubRipper
+    class << self
+        #
+        # Everything below here is private
+        #
+
+        private
+
+        def get_clone_type(options)
+            return 'git clone git@github.com:' if flag_set?(options, :use_git)
+
+            return "git clone https://#{options[:token]}@github.com/" if get_option(options, :token)
+
+            'git clone https://github.com/'
+        end
+
+        def repo_full_path(options, repo)
+            "#{options[:base_dir]}/Repos/#{repo}"
+        end
+
+        def repo_exists?(repo_path)
+            File.directory?(repo_path)
+        end
+
+        def execute_command(command)
+            error_string = ''
+            return_code = 0
+
+            Open3.popen3(command) do |_stdin, stdout, _stderr, wait_thr|
+                error_string = stdout.read.chomp.to_s
+                return_code = wait_thr.value.exitstatus
+            end
+            output = error_string.split(/\n+/).reject(&:empty?).join(', ')
+            [return_code, output]
+        end
+
+        def clone_repo(options, repo, repo_path)
+            return { :repo => repo, :path => repo_path, :status => 'Dry Run', :when => 'git clone', :info => '' } if flag_set?(options, :dry_run)
+
+            FileUtils.mkdir_p repo_path
+
+            clone_type = get_clone_type(options)
+            command = "#{clone_type}#{repo} #{repo_path}"
+            return_code, output = execute_command(command)
+
+            return { :repo => repo, :path => repo_path, :status => 'Failed', :when => 'git clone', :info => output } if return_code.positive?
+
+            { :repo => repo, :path => repo_path, :status => 'Success', :when => 'git clone', :info => 'Clone Succeeded' }
+        end
+
+        def update_repo(options, repo, repo_path)
+            return { :repo => repo, :path => repo_path, :status => 'Dry Run', :when => 'git clone', :info => '' } if flag_set?(options, :dry_run)
+
+            olddir = Dir.pwd
+            Dir.chdir repo_path
+
+            command = 'git pull 2>&1'
+            return_code, output = execute_command(command)
+            Dir.chdir olddir
+
+            return { :repo => repo, :path => repo_path, :status => 'Failed', :when => 'git pull', :info => output } if return_code.positive?
+
+            { :repo => repo, :path => repo_path, :status => 'Success', :when => 'git pull', :info => 'Pull Succeeded' }
+        end
+
+        def clone_repo_wrapper(options, repo)
+            repo_path = repo_full_path(options, repo)
+
+            return update_repo(options, repo, repo_path) if repo_exists?(repo_path)
+
+            clone_repo(options, repo, repo_path)
+        end
+    end
+end

data/lib/github-ripper/report.rb

@@ -0,0 +1,38 @@
+#
+# Class level docs
+#
+class GithubRipper
+    class << self
+        #
+        # Everything below here is private
+        #
+
+        private
+
+        def display_table?(error_count, options)
+            # Dry run - force display of all
+            return true if flag_set?(options, :dry_run)
+
+            # Quite / Silent - show nothing
+            return false if flag_set?(options, :quiet) || flag_set?(options, :silent)
+
+            # Errors or full report wanted
+            return true if error_count.positive? || flag_set?(options, :full_report)
+
+            # If in doubt say nothing
+            false
+        end
+
+        #
+        # This method smells of :reek:LongParameterList, :reek:DuplicateMethodCall
+        #
+        def draw_report(results, repo_count, error_count, options)
+            return unless display_table?(error_count, options)
+
+            table = create_table
+            table = add_title(table, repo_count, error_count, options)
+            table = add_rows(table, results, options)
+            display_table(table)
+        end
+    end
+end

data/lib/github-ripper/repos.rb

@@ -0,0 +1,57 @@
+#
+# Class docs to go here
+#
+class GithubRipper
+    class << self
+        #
+        # Everything below here is private
+        #
+
+        private
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # This method smells of :reek:NilCheck
+        def handle_required_parameters(options)
+            return if get_option(options, :token)
+
+            raise StandardError.new('Please supply a username (-u) or a token (-t)') if (flag_set?(options, :user_repos) || flag_set?(options, :org_members_repos) || flag_set?(options, :all_repos)) && get_option(options, :user).nil?
+
+            raise StandardError.new('Please supply an organisation name (-o) or a token (-t)') if flag_set?(options, :org_repos) && get_option(options, :org).nil?
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        #
+        # docs go here
+        #
+        def get_repo_list(options)
+            handle_required_parameters(options)
+
+            function = function_map_lookup(options)
+
+            raise StandardError.new('Missing parameters') unless function
+
+            JSON.parse(function_wrapper(function, options))
+        end
+
+        #
+        # This method smells of :reek:DuplicateMethodCall
+        #
+        def rip_repos(options, repos)
+            repo_count = repos.size
+
+            results = if flag_set?(options, :silent)
+                          Parallel.map(repos) { |repo| clone_repo_wrapper(options, repo) }
+                      else
+                          Parallel.map(repos, :progress => "Cloning #{repo_count}") { |repo| clone_repo_wrapper(options, repo) }
+                      end
+            results.compact
+        end
+
+        def process_results(results, options)
+            repo_count = count_repos(results)
+            error_count = count_errors(results)
+            results = filter_results(results, options)
+            [results, repo_count, error_count]
+        end
+    end
+end

data/lib/github-ripper/table.rb

@@ -0,0 +1,49 @@
+#
+# Class level docs
+#
+class GithubRipper
+    class << self
+        #
+        # Everything below here is private
+        #
+
+        private
+
+        # This method smells of :reek:UtilityFunction
+        def create_table
+            Terminal::Table.new :headings => ['Repo', 'Path', 'Status', 'When', 'Information']
+        end
+
+        # This method smells of :reek:ControlParameter, :reek:LongParameterList
+        def add_title(table, repo_count, error_count, options)
+            title = "There were #{error_count} #{plural(error_count, 'error')}"
+            title += " from #{repo_count} #{plural(repo_count, 'repository', 'respositories')}" if flag_set?(options, :full_report) || flag_set?(options, :dry_run)
+
+            table.title = title
+            table
+        end
+
+        # This method smells of :reek:UtilityFunction, :reek:ControlParameter
+        def visible_row?(repo, options)
+            # Dry run - force display of all
+            return true if flag_set?(options, :dry_run)
+
+            repo[:status] == 'Failed' || flag_set?(options, :full_report)
+        end
+
+        def add_single_row(table, repo, options)
+            status = repo[:status]
+            table.add_row [set_colour(repo[:repo], status), set_colour(repo[:path], status), set_colour(status, status), set_colour(repo[:when], status), set_colour(repo[:info], status)] if visible_row?(repo, options)
+            table
+        end
+
+        def add_rows(table, results, options)
+            results.each { |repo| table = add_single_row(table, repo, options) }
+            table
+        end
+
+        def display_table(table)
+            puts table
+        end
+    end
+end

data/lib/github-ripper/utils.rb

@@ -0,0 +1,64 @@
+#
+# Class docs to go here
+#
+class GithubRipper
+    class << self
+        #
+        # Everything below here is private
+        #
+
+        private
+
+        #
+        # This method smells of :reek:DuplicateMethodCall
+        #
+        def set_colour(item, status)
+            return Rainbow(item).yellow if item.downcase == 'dry run'
+
+            case status.downcase
+            when 'dry run'
+                Rainbow(item).cyan
+            when 'failed'
+                Rainbow(item).red
+            else
+                Rainbow(item).green
+            end
+        end
+
+        # This method smells :reek:UtilityFunction, :reek:ControlParameter
+        def plural(count, singular, plural = nil)
+            if count == 1
+                singular.to_s
+            elsif plural
+                plural.to_s
+            else
+                "#{singular}s"
+            end
+        end
+
+        # This method smells of :reek:UtilityFunction
+        def count_repos(results)
+            results.size
+        end
+
+        # This method smells of :reek:UtilityFunction
+        def count_errors(results)
+            results.select { |repo| repo[:status] == 'Failed' }.size
+        end
+
+        # This method smells of :reek:UtilityFunction
+        def filter_results(results, options)
+            results.select { |repo| repo[:status] == 'Failed' || flag_set?(options, :full_report) || flag_set?(options, :dry_run) }.sort_by { |repo| repo[:repo].downcase }
+        end
+
+        def get_option(options, name)
+            options[name] if options.key?(name)
+        end
+
+        def flag_set?(options, name)
+            return true if options.key?(name) && options[name] == true
+
+            false
+        end
+    end
+end

data/lib/github-ripper/version.rb

@@ -0,0 +1,6 @@
+#
+# Class docs to go here
+#
+class GithubRipper
+    VERSION = '0.1.0'.freeze
+end

data/lib/github-ripper/wrapper.rb

@@ -0,0 +1,21 @@
+#
+# Class docs to go here
+#
+class GithubRipper
+    class << self
+        #
+        # Everything below here is private
+        #
+
+        private
+
+        def function_wrapper(function, options)
+            begin
+                results = GithubListerCore.send(function, options)
+            rescue UnknownError, InvalidTokenError, MissingTokenError, TooManyRequests, NotFoundError, MissingOrganisationError, InvalidOptionsHashError => exception
+                raise StandardError.new(exception.to_s)
+            end
+            results || []
+        end
+    end
+end

data/stale.yml

@@ -0,0 +1,17 @@
+# Number of days of inactivity before an issue becomes stale
+daysUntilStale: 60
+# Number of days of inactivity before a stale issue is closed
+daysUntilClose: 7
+# Issues with these labels will never be considered stale
+exemptLabels:
+  - pinned
+  - security
+# Label to use when marking an issue as stale
+staleLabel: wontfix
+# Comment to post when marking an issue as stale. Set to `false` to disable
+markComment: >
+  This issue has been automatically marked as stale because it has not had
+  recent activity. It will be closed if no further activity occurs. Thank you
+  for your contributions.
+# Comment to post when closing a stale issue. Set to `false` to disable
+closeComment: true

data/testing/VERSION.txt

@@ -0,0 +1 @@
+0.1.0

data/testing/get-raw.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+#
+# This is a very simply testing script to allow for testing of local changes without having to install the gem locally
+#
+
+require 'json'
+
+$LOAD_PATH.unshift('./lib')
+
+require 'bundler/setup'
+require 'github-ripper'
+
+options = {}
+
+pp GithubRipper.rip(options)

data/testing/ghrip

@@ -0,0 +1,110 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift('./lib')
+
+require 'bundler/setup'
+
+require 'github-ripper'
+require 'json'
+require 'optparse'
+require 'pp'
+
+MANDATORY_PARAMETERS = [].freeze
+DEFAULT_VALUES = {}.freeze
+
+def init_default_parser
+    parser = OptionParser.new
+
+    parser.banner = "Usage: #{$PROGRAM_NAME}"
+
+    parser.on('-h', '--help', 'Display this screen') do
+        puts parser
+        exit(1)
+    end
+    parser
+end
+
+# This method reeks of :reek:UtilityFunction, :reek:TooManyStatements
+def add_parameters(parser, options)
+    parser.separator ''
+    parser.separator 'Parameters:'
+    parser.on('-t', '--token <token>', 'GitHub personal access token (PAT)') { |token| options[:token] = token }
+    parser.on('-b', '--base-dir <path>', "The base directory to download to [default: #{File.expand_path('~')}/Downloads/]") { |base_dir| options[:base_dir] = base_dir }
+    parser.on('-g', '--use-git', TrueClass, 'Use git instead of https to clone the repositories') { |_errors| options[:use_git] = true }
+    [parser, options]
+end
+
+# This method reeks of :reek:UtilityFunction, :reek:TooManyStatements
+def add_repo_flag_parameters(parser, options)
+    parser.separator ''
+    parser.separator 'Cloning Parameters:'
+    parser.on('-u', '--user <names>', 'Github username(s) to rip') { |user| options[:user] = user }
+    parser.on('-o', '--org <names>', 'Github organisation(s) to rip') { |org| options[:org] = org }
+    parser.on('-U', '--user-repos', TrueClass, 'Rip all of the repositories for the named user(s)') { |_dry_run| options[:user_repos] = true }
+    parser.on('-M', '--org-member-repos', TrueClass, 'Rip all of the repositories for all organisation the user(s) is a member of') { |_quiet| options[:org_members_repos] = true }
+    parser.on('-A', '--all-repos', TrueClass, 'Same as running -U -M') { |_silent| options[:all_repos] = true }
+    parser.on('-O', '--org-repos', TrueClass, 'Rip all of the repositories for the named organisation(s)') { |_errors| options[:org_repos] = true }
+    [parser, options]
+end
+
+# This method reeks of :reek:UtilityFunction, :reek:TooManyStatements
+def add_flag_parameters(parser, options)
+    parser.separator ''
+    parser.separator 'Flags:'
+    parser.on('-d', '--dry-run', 'Show a list of repositories that WOULD be ripped') { |_dry_run| options[:dry_run] = true }
+    parser.on('-f', '--full', 'Show status of all repositories in post run report') { |_errors| options[:full_report] = true }
+    parser.on('-q', '--quiet', 'Suppress the showing of the post run report') { |_quiet| options[:quiet] = true }
+    parser.on('-s', '--silent', 'Suppress all output') { |_silent| options[:silent] = true }
+    [parser, options]
+end
+
+def create_parser
+    options = DEFAULT_VALUES.dup
+
+    parser = init_default_parser
+    parser, options = add_parameters(parser, options)
+    parser, options = add_repo_flag_parameters(parser, options)
+    parser, options = add_flag_parameters(parser, options)
+
+    [parser, options]
+end
+
+def process_parser(parser, options)
+    begin
+        parser.parse!
+        missing = MANDATORY_PARAMETERS.reject { |param| options.include?(param) }
+        raise OptionParser::MissingArgument.new(missing.join(', ')) unless missing.empty?
+    rescue OptionParser::InvalidOption, OptionParser::InvalidArgument, OptionParser::MissingArgument => exception
+        exit_with_error(parser, exception)
+    end
+    #
+    # The parser will use :"some-symbol" so we convert it to :some_symbol
+    #
+    options.transform_keys(&:to_s).transform_keys { |key| key.gsub('-', '_') }.transform_keys(&:to_sym)
+end
+
+def exit_with_error(parser, exception = nil)
+    puts exception if exception
+    puts parser.help
+    exit
+end
+
+def process_arguments
+    parser, options = create_parser
+    options = process_parser(parser, options)
+
+    exit_with_error(parser) if options.empty?
+    options
+end
+
+def main
+    options = process_arguments
+
+    begin
+        GithubRipper.rip(options)
+    rescue StandardError => exception
+        puts exception
+    end
+end
+
+main