neetob-ud 0.2.5

data/install.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+
+last_wd=$(pwd)
+cd "/tmp/neetob/"
+bundle install
+echo "Building gem..."
+bundle exec rake build
+echo -e "\nHold tight! The next step might take some time..."
+gem install "/tmp/neetob/pkg/neetob*.gem"
+cd "${last_wd}"
+rm -rf "/tmp/neetob/"
+echo -e "\n"
+cat <<EOF
+=========================
+             _       _
+ ___ ___ ___| |_ ___| |_
+|   | -_| -_|  _| . | . |
+|_|_|___|___|_| |___|___|
+=========================
+EOF
+neetob help

data/lib/neetob/cli/base.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "ui"
+require_relative "../utils"
+require_relative "../../../neeto_compliance/lib/neeto_compliance/neeto_repos.rb"
+
+module Neetob
+  class CLI::Base
+    include Utils
+
+    NEETO_APPS_LIST_LINK = "https://github.com/bigbinary/neeto-compliance/blob/main/lib/neeto_compliance/neeto_apps.rb"
+
+    attr_reader :ui
+
+    def initialize
+      @ui = CLI::UI.new
+    end
+
+    private
+
+      def find_all_matching_apps(apps, platform_name, sandbox_mode, quiet = false, all_neeto_repos = false)
+        inform_about_current_working_mode(sandbox_mode, quiet)
+        all_available_apps = sandbox_mode ?
+          testing_apps(platform_name) :
+          build_app_list_from_neeto_compliance(platform_name, all_neeto_repos)
+        matching_apps = match_apps(apps || ["*"], all_available_apps)
+        if matching_apps.length == 0
+          error_msg = sandbox_mode ?
+          "Only \"neeto-dummy\" app is available for sandbox mode. Remove the \"--sandbox\" flag to run the given command for all the neeto applications." :
+          "No matching app is found in the neeto apps list maintained at \"#{NEETO_APPS_LIST_LINK}\""
+          ui.error(error_msg)
+          exit
+        end
+
+        matching_apps
+      end
+
+      def match_apps(required_apps, available_apps)
+        apps = required_apps&.map { |app| Regexp.new "#{app.gsub("*", "[-a-zA-Z0-9]*")}" }
+        available_apps.select do |available_app|
+          apps&.any? { |app| app.match?(available_app) }
+        end
+      end
+
+      def read_json_file(path)
+        file = File.read(path)
+        JSON.parse(file)
+      end
+
+      def build_app_list_from_neeto_compliance(platform_name, all_neeto_repos)
+        apps = all_neeto_repos ? fetch_all_neeto_repos : NeetoCompliance::NeetoRepos.products.keys
+        platform_name == :heroku ? add_env_suffix(apps) : prefix_org_name(apps)
+      end
+
+      def add_env_suffix(apps)
+        [
+          suffix_slug(apps, :staging),
+          suffix_slug(apps, :production)
+        ].flatten.sort
+      end
+
+      def suffix_slug(apps, suffix)
+        apps.map { |app| "#{app}-#{suffix}" }
+      end
+
+      def prefix_org_name(apps)
+        apps.map { |app| "bigbinary/#{app}" }
+      end
+
+      def testing_apps(platform_name)
+        platform_name == :heroku ? ["neeto-dummy"] : ["bigbinary/neeto-dummy"]
+      end
+
+      def inform_about_current_working_mode(sandbox_mode, quiet)
+        return if quiet
+
+        callout_message = "Running in the sandbox mode. \nOnly \"neeto-dummy\" app will be available."
+        unless sandbox_mode
+          callout_message = "Running in non-sandbox mode. \nAll neeto applications are available. Some of the actions are irreversible."
+        end
+        ui.say(callout_message)
+      end
+
+      def fetch_all_neeto_repos
+        NeetoCompliance::NeetoRepos::products.keys +
+        NeetoCompliance::NeetoRepos::nanos +
+        NeetoCompliance::NeetoRepos::widgets +
+        NeetoCompliance::NeetoRepos::chrome_extensions +
+        NeetoCompliance::NeetoRepos::helper_packages +
+        NeetoCompliance::NeetoRepos::electron_apps +
+        NeetoCompliance::NeetoRepos::executables +
+        NeetoCompliance::NeetoRepos::mobile_apps +
+        NeetoCompliance::NeetoRepos::other_repos
+      end
+  end
+end

data/lib/neetob/cli/fetchorupdate_repos/execute.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module FetchorupdateRepos
+      class Execute < Base
+        attr_accessor :sandbox, :apps, :all_neeto_repos
+
+        def initialize(sandbox = false, all_neeto_repos = false, apps = ["*"])
+          super()
+          @sandbox = sandbox
+          @apps = apps
+          @all_neeto_repos = all_neeto_repos
+        end
+
+        def run
+          neeto_apps = find_all_matching_apps(apps, :github, sandbox, false, all_neeto_repos)
+          neeto_apps.each do |app|
+            app_name = app.split("/").last
+            ui.info("\nWorking on #{app_name}\n")
+            if directory_exists(app_name)
+              checkout_to_main_and_fetch_commits(app_name)
+            else
+              clone_repo(app_name)
+            end
+          end
+        end
+
+        def directory_exists(app_name)
+          File.directory?(app_name)
+        end
+
+        def checkout_to_main_and_fetch_commits(app_name)
+          %x[ cd #{app_name} && git checkout main && git pull origin main ]
+          if $?.success?
+            puts "------Successfully pulled main branch of #{app_name}------"
+          else
+            puts "------Unable to pull the main branch of #{app_name} due to conflicts------"
+          end
+        end
+
+        def clone_repo(app_name)
+          `git clone git@github.com:bigbinary/#{app_name}.git`
+          if $?.success?
+            puts "------Done cloning #{app_name}------"
+          else
+            puts "------Failed cloning #{app_name}------"
+          end
+        end
+      end
+    end
+  end
+end

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,42 @@
+# 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
+
+        def check_for_apps_and_all_neeto_repos_option(apps, all_neeto_repos)
+          if (apps.nil? && !all_neeto_repos) || (!apps.nil? && all_neeto_repos)
+            ui.error("Please provide either \"apps\" or \"all-neeto-repos\" option.")
+            exit
+          end
+        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,54 @@
+# 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", desc: "Github app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web\""
+        option :all_neeto_repos, type: :boolean, aliases: "--all",
+          desc: "Use this flag for working with all neeto repos", default: false
+        def protect_branch
+          ProtectBranch.new(
+            options[:branch], options[:apps], options[:path], options[:sandbox],
+            options[:all_neeto_repos]).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,65 @@
+# 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",
+            desc: "Github app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web\""
+          class_option :all_neeto_repos,
+            type: :boolean, aliases: "--all", default: false,
+            desc: "Use this flag for working with all neeto repos"
+
+          desc "list", "List all the labels in the Github repos"
+          def list
+            List.new(options[:apps], options[:sandbox], options[:all_neeto_repos]).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], options[:all_neeto_repos]).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], options[:all_neeto_repos]).run
+          end
+
+          desc "delete_all", "Delete all the labels from the Github repos"
+          def delete_all
+            DeleteAll.new(options[:apps], options[:sandbox], options[:all_neeto_repos]).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], options[:all_neeto_repos]).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],
+              options[:all_neeto_repos]).run
+          end
+        end
+      end
+    end
+  end
+end