neetob 0.1.0

data/lib/neetob/cli/github/auth.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "../ui"
+require "net/http"
+require "uri"
+require "json"
+require "launchy"
+require "fileutils"
+
+module Neetob
+  class CLI
+    module Github
+      class Auth
+        attr_accessor :client_id, :grant_type, :uris, :provider, :scope, :access_token, :ui
+
+        def initialize(client_id:, grant_type:, auth_uris:, provider:, scope:)
+          @client_id = client_id
+          @grant_type = grant_type
+          @uris = auth_uris
+          @provider = provider
+          @scope = scope
+          @access_token = retrieve_persisted_token
+          @ui = CLI::UI.new
+        end
+
+        def token_persisted?
+          access_token_present?
+        end
+
+        def open_url_in_browser!(url)
+          Launchy.open(url) do |exception|
+            raise(StandardError, "Attempted to open #{url} in browser and failed because #{exception}.")
+          end
+        end
+
+        def start_oauth2_device_flow
+          auth_data = request_authorization
+          show_user_code(auth_data[:user_code])
+          open_url_in_browser!(auth_data[:verification_uri])
+          poll_for_token(auth_data)
+        end
+
+        def request_authorization
+          post(uris["auth_req"], params: { client_id: client_id, scope: scope })
+        end
+
+        private
+
+          def show_user_code(code)
+            ui.say("You'll be redirected to the browser in 5 secs. Enter the following code in the browser:")
+            ui.success(code)
+            sleep 5
+          end
+
+          def tmp_token_path(provider)
+            "/tmp/neetob_#{provider}_token"
+          end
+
+          def provider_local_token_path
+            @_provider_local_token_path ||= tmp_token_path(provider)
+          end
+
+          def retrieve_persisted_token
+            File.read(provider_local_token_path) if File.file?(provider_local_token_path)
+          end
+
+          def parse_response(http_result)
+            case http_result
+            when Net::HTTPOK
+              JSON.parse(http_result.body, { symbolize_names: true })
+            else
+              raise(StandardError, "Request failed with status code #{http_result.code}. #{http_result.body}")
+              nil
+            end
+          end
+
+          def post(url, params:, headers: { "Accept" => "application/json" })
+            base_uri = URI(url)
+            enc_params = URI.encode_www_form(params)
+            http_result = Net::HTTP.post(base_uri, enc_params, headers)
+            parse_response(http_result)
+          end
+
+          def poll_for_token(auth_data)
+            interval = auth_data[:interval]
+            loop do
+              res = post(
+                uris["token_req"],
+                params: {
+                  client_id: client_id,
+                  device_code: auth_data[:device_code],
+                  grant_type: grant_type
+                }
+              )
+
+              if res.key?(:error)
+                case res[:error]
+                when "authorization_pending"
+                  # dont hit the endpoint too fast such that we get rate limited
+                  sleep interval
+                  next
+                when "slow_down"
+                  # increase polling interval incase rate limited
+                  interval = res["interval"]
+                  sleep interval
+                  next
+                when "access_denied"
+                  # user clicks cancel button
+                  raise(StandardError, "Access denied while authorizing #{provider} access.")
+                  break
+                else
+                  raise(StandardError, res)
+                  break
+                end
+              end
+
+              # We won't be running this script regularly. Thus storing in /tmp/
+              # for temporary reuse of token till machine is rebooted
+              File.write(provider_local_token_path, res[:access_token])
+              FileUtils.chmod(0600, provider_local_token_path)
+
+              self.access_token = res[:access_token]
+              ui.info("You've been authenticated!")
+              break
+            end
+          end
+
+          def access_token_present?
+            !(access_token.nil? || access_token.empty?)
+          end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "octokit"
+
+require_relative "../base"
+require_relative "../../exception_handler"
+require_relative "auth"
+require_relative "../../utils"
+
+module Neetob
+  class CLI
+    module Github
+      class Base < CLI::Base
+        include Utils
+        attr_accessor :client
+
+        def initialize
+          super()
+          auth_client = Auth.new(**read_and_parse_auth_params_from_env)
+          unless auth_client.token_persisted?
+            auth_client.start_oauth2_device_flow
+          end
+          @client = Octokit::Client.new(access_token: auth_client.access_token)
+        end
+
+        private
+
+          def read_and_parse_auth_params_from_env
+            hash_with_keys_of_string_type = JSON.parse(ENV["AUTH_PARAMS"])
+            symbolize_keys(hash_with_keys_of_string_type)
+          end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/commands.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "labels/commands"
+require_relative "issues/commands"
+require_relative "search"
+require_relative "protect_branch"
+require_relative "login"
+require_relative "make_pr/commands"
+
+module Neetob
+  class CLI
+    module Github
+      class Commands < Thor
+        desc "labels", "Interact with the labels of Github repos"
+        subcommand "labels", Labels::Commands
+
+        desc "issues", "Interact with the issues of Github repos"
+        subcommand "issues", Issues::Commands
+
+        desc "make-pr", "Create PRs across multiple Github repos"
+        subcommand "make_pr", MakePr::Commands
+
+        desc "search", "Find the lines matching the given keyword in the specified file across all the neeto apps"
+        option :apps, type: :array, aliases: "-a", required: true, desc: "Github app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web\""
+        option :keyword, type: :string, aliases: "-k", desc: "Keyword which needs to be searched", required: true
+        option :path, type: :string, aliases: "-p",
+          desc: "Path of the file in which you want to search the given keyword.", required: true
+        def search
+          Search.new(options[:apps], options[:keyword], options[:path], options[:sandbox]).run
+        end
+
+        desc "login", "Update the Github access token by authenticating via browser"
+        def login
+          Login.new
+        end
+
+        desc "protect_branch", "Protect the specified branch with the given rules"
+        option :branch, type: :string, aliases: "-b",
+          desc: "Name of the branch whose protections rules needs to be updated", required: true
+        option :path, type: :string, aliases: "-p",
+          desc: "The JSON file path which specify all the required rules for branch protection"
+        option :apps, type: :array, aliases: "-a", required: true, desc: "Github app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web\""
+        def protect_branch
+          ProtectBranch.new(options[:branch], options[:apps], options[:path], options[:sandbox]).run
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/issues/commands.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "list"
+require_relative "create"
+require_relative "../../sub_command_base"
+
+module Neetob
+  class CLI
+    module Github
+      module Issues
+        class Commands < SubCommandBase
+          class_option :apps,
+            {
+              type: :array, aliases: "-a", required: true,
+              desc: "Github app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web\""
+            }
+
+          desc "list", "List the issues in the Github repos"
+          option :state, type: :string, default: "open", aliases: "-s", desc: "State of the issues. Can be open or closed."
+          option :assignee, type: :string, desc: "Username of the current assignee. Can also use \"none\"."
+          option :label, type: :string, aliases: "-l", desc: "Label name to filter out the issues"
+          option :count, type: :boolean, aliases: "-c", desc: "Also shows the count of issues"
+          option :search, type: :string, desc: "Can provide custom query to filter or sort issues. Example: \"created:2022-11-07..2022-11-08 sort:comments-asc\""
+          def list
+            List.new(
+              options[:apps], options[:assignee], options[:state], options[:search], options[:count],
+              options[:label], options[:sandbox]).run
+          end
+
+          desc "create", "Create a issue in the Github repos"
+          option :title, type: :string, required: true, aliases: "-t", desc: "Title of the issue"
+          option :description, type: :string, aliases: "-d", desc: "Description of the issue"
+          option :assignee, type: :string, desc: "Username of the user you want to assign this issue."
+          option :labels, type: :string, desc: "List of comma separated labels you want to add in this issue. Example: \"--labels bug,ui\""
+          def create
+            Create.new(
+              options[:apps],
+              options[:title],
+              options[:description],
+              options[:assignee],
+              options[:labels],
+              options[:sandbox]
+            ).run
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/issues/create.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Github
+      module Issues
+        class Create < Base
+          attr_accessor :apps, :issue_title, :issue_description, :issue_assignee, :issue_labels, :sandbox
+
+          def initialize(apps, issue_title, issue_description = "", issue_assignee = "", issue_labels = "",
+sandbox = false)
+            super()
+            @apps = apps
+            @issue_title = issue_title
+            @issue_description = issue_description
+            @issue_assignee = issue_assignee
+            @issue_labels = issue_labels
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :github, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n  Creating issue in \"#{app}\"  \n")
+              begin
+                issue_options = { assignee: issue_assignee, labels: issue_labels }
+                issue = client.create_issue(app, issue_title, issue_description, issue_options)
+                ui.success("Created the issue successfully \nLink: #{issue[:html_url]}")
+              rescue StandardError => e
+                ExceptionHandler.new(e).process
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/issues/list.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "thor"
+require "action_view"
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Github
+      module Issues
+        class List < Base
+          include ActionView::Helpers::DateHelper
+
+          attr_accessor :apps, :issue_state, :issue_assignee, :issue_search_query, :show_issues_count, :issue_label,
+            :sandbox
+
+          def initialize(apps, issue_assignee = "", issue_state = "open",
+                         issue_search_query = "", show_issues_count = false, issue_label = "",
+                         sandbox = false)
+            super()
+            @apps = apps
+            @issue_state = issue_state
+            @issue_assignee = issue_assignee
+            @show_issues_count = show_issues_count
+            @issue_search_query = issue_search_query
+            @issue_label = issue_label
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :github, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n  Issues of #{app}  \n")
+              begin
+                issues = client.search_issues(uri_with_query_options(app))
+                ui.info("There are #{issues[:total_count]} issues with matching query") if show_issues_count
+                table_rows = create_table(issues[:items])
+                table = Terminal::Table.new headings: table_columns, rows: table_rows
+                ui.success(table)
+              rescue StandardError => e
+                ExceptionHandler.new(e).process
+              end
+            end
+          end
+
+          private
+
+            def table_columns
+              issue_label.nil? ?
+              ["Title", "Created at", "Assignee", "Link"] :
+              ["Title", "Created at", "Assignee", "Link", "Labels"]
+            end
+
+            def create_table(issues)
+              issues.map do |issue|
+                row_data = [
+                  issue[:title],
+                  "#{distance_of_time_in_words(issue[:created_at], Time.now)} ago",
+                  issue.dig(:assignee, :login),
+                  issue[:html_url]
+                ]
+                issue_label.nil? ? row_data : row_data.push(labels_names(issue[:labels]))
+              end
+            end
+
+            def uri_with_query_options(app)
+              uri = "repo:#{app} is:issue state:#{issue_state}"
+              unless issue_label.nil?
+                check_valid_labels(app)
+                uri.concat(" label:#{issue_label}")
+              end
+              uri.concat(issue_assignee == "none" ? " no:assignee" : " assignee:#{issue_assignee}") if issue_assignee
+              "#{uri} #{issue_search_query}"
+            end
+
+            def labels_names(labels)
+              labels.map { |label| label[:name] }.join(", ")
+            end
+
+            def check_valid_labels(app)
+              issue_label.split(",").each { |label| valid_label?(app, label) }
+            end
+
+            def valid_label?(app, label)
+              client.label(app, label)
+            rescue Octokit::NotFound => e
+              ui.error("There is no \"#{label}\" label in the \"#{app}\" repo.")
+            end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/labels/commands.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "list"
+require_relative "show"
+require_relative "upsert"
+require_relative "delete_all"
+require_relative "delete"
+require_relative "update"
+require_relative "../../sub_command_base"
+
+module Neetob
+  class CLI
+    module Github
+      module Labels
+        class Commands < SubCommandBase
+          class_option :apps,
+            {
+              type: :array, aliases: "-a", required: true,
+              desc: "Github app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web\""
+            }
+
+          desc "list", "List all the labels in the Github repos"
+          def list
+            List.new(options[:apps], options[:sandbox]).run
+          end
+
+          desc "show", "Show details about the given label in the Github repos"
+          option :name, type: :string, aliases: "-n", required: true, desc: "Name of the label"
+          def show
+            Show.new(options[:apps], options[:name], options[:sandbox]).run
+          end
+
+          desc "upsert", "Create and update labels in the Github repos"
+          option :path, type: :string, aliases: "-p", desc: "The JSON file path which has a list of all the required labels. Each label should have name. The color and description are optional"
+          def upsert
+            Upsert.new(options[:apps], options[:path], options[:sandbox]).run
+          end
+
+          desc "delete_all", "Delete all the labels from the Github repos"
+          def delete_all
+            DeleteAll.new(options[:apps], options[:sandbox]).run
+          end
+
+          desc "delete", "Delete some labels from the Github repos"
+          option :labels, type: :array, required: true, desc: "Labels you want to delete from the repos."
+          def delete
+            Delete.new(options[:apps], options[:labels], options[:sandbox]).run
+          end
+
+          desc "update", "Update a label name in Github repos"
+          option :old_name, type: :string, required: true, desc: "Current label name which needs to be updated"
+          option :new_name, type: :string, required: true, desc: "New name for the updated label"
+          def update
+            Update.new(options[:apps], options[:old_name], options[:new_name], options[:sandbox]).run
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/labels/delete.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Github
+      module Labels
+        class Delete < Base
+          attr_accessor :apps, :sandbox, :labels
+
+          def initialize(apps, labels, sandbox = false)
+            super()
+            @labels = labels
+            @apps = apps
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :github, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n Deleting labels from #{app} repo \n")
+              labels.each do |label|
+                delete_label(app, label)
+              end
+            end
+          end
+
+          private
+
+            def delete_label(app, label)
+              if client.delete_label!(app, label)
+                ui.success("The \"#{label}\" label deleted successfully")
+              else
+                ui.error("The \"#{label}\" label can't be deleted. Please check and try again")
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/labels/delete_all.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Github
+      module Labels
+        class DeleteAll < Base
+          attr_accessor :apps, :sandbox
+
+          def initialize(apps, sandbox = false)
+            super()
+            @apps = apps
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :github, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n Working on #{app} repo \n")
+              begin
+                labels = client.labels(app)
+                labels.each do |label|
+                  delete_label(app, label)
+                end
+              rescue StandardError => e
+                ExceptionHandler.new(e).process
+              end
+            end
+          end
+
+          private
+
+            def delete_label(app, label_details)
+              if client.delete_label!(app, label_details[:name])
+                ui.success("The \"#{label_details[:name]}\" label deleted successfully")
+              else
+                ui.error("The \"#{label_details[:name]}\" label can't be deleted. Please try again")
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/labels/list.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Github
+      module Labels
+        class List < Base
+          attr_accessor :apps, :sandbox
+
+          def initialize(apps, sandbox = false)
+            super()
+            @apps = apps
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :github, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n  Labels of #{app}  \n")
+              begin
+                labels = client.labels(app)
+                ui.success(labels)
+              rescue StandardError => e
+                ExceptionHandler.new(e).process
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/labels/show.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Github
+      module Labels
+        class Show < Base
+          attr_accessor :apps, :label_name, :sandbox
+
+          def initialize(apps, label_name, sandbox = false)
+            super()
+            @apps = apps
+            @label_name = label_name
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :github, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n \"#{label_name}\" label details from #{app}  \n")
+              begin
+                label_details = client.label(app, label_name)
+                ui.success(label_details.inspect)
+              rescue StandardError => e
+                ExceptionHandler.new(e).process
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/github/labels/update.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Github
+      module Labels
+        class Update < Base
+          attr_accessor :apps, :sandbox, :old_name, :new_name
+
+          def initialize(apps, old_name, new_name, sandbox = false)
+            super()
+            @apps = apps
+            @sandbox = sandbox
+            @old_name = old_name
+            @new_name = new_name
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :github, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n Updating label for #{app} repo \n")
+              update_label!(app, old_name, new_name)
+            end
+          end
+
+          private
+
+            def update_label!(app, old_name, new_name)
+              client.update_label(app, old_name, { name: new_name })
+              ui.success("Label \"#{old_name}\" updated to \"#{new_name}\" successfully")
+            end
+        end
+      end
+    end
+  end
+end