neetob 0.1.0

data/lib/neetob/cli/heroku/config_vars/commands.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "list"
+require_relative "audit"
+require_relative "upsert"
+require_relative "remove"
+require_relative "../../sub_command_base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class Commands < SubCommandBase
+          desc "list", "List all the config variables in the Heroku apps"
+          option :apps, type: :array, aliases: :a, required: true, desc: "Heroku app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web-staging\""
+          option :keys, type: :array, desc: "Array of config vars that needs to be listed."
+          option :path, type: :string, desc: "The JSON file path which has config vars that needs to be listed"
+          def list
+            List.new(options[:apps], options[:keys], options[:path], options[:sandbox]).run
+          end
+
+          desc "audit", "Verify whether config vars set in Heroku apps matches against the conditions specified in JSON file."
+          option :apps, type: :array, aliases: :a, required: true, desc: "Heroku app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web-staging\""
+          option :path, type: :string, desc: "The JSON file path from which config vars will be compared"
+          def audit
+            Audit.new(options[:apps], options[:path], options[:sandbox]).run
+          end
+
+          desc "upsert", "Update and insert the config vars in Heroku apps"
+          option :apps, type: :array, aliases: :a, desc: "Heroku app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web-staging\""
+          option :path, type: :string, aliases: :p, desc: "The JSON file path from which config vars will be upserted"
+          option :path_with_project_keys, type: :string, desc: "The JSON file path with the project names as the key containing required config vars for each project."
+          def upsert
+            Upsert.new(options[:apps], options[:path], options[:path_with_project_keys], options[:sandbox]).run
+          end
+
+          desc "remove", "Remove the config vars from Heroku apps"
+          option :apps, type: :array, aliases: :a, required: true, desc: "Heroku app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web-staging\""
+          option :keys, type: :array, required: true, desc: "Array of config vars to be removed."
+          def remove
+            Remove.new(options[:apps], options[:keys], options[:sandbox]).run
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/config_vars/list.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class List < Base
+          attr_accessor :apps, :sandbox, :keys, :required_config_vars_file_path
+
+          def initialize(apps, keys = [], required_config_vars_file_path = "", sandbox = false)
+            super()
+            @apps = apps
+            @sandbox = sandbox
+            @keys = keys
+            @required_config_vars_file_path = required_config_vars_file_path
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :heroku, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n  Config of #{app}\n")
+              config = `heroku config -a #{app} --json`
+              unless $?.success?
+                ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+                ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+                next
+              end
+              table = Terminal::Table.new headings: table_columns, rows: filter_config(config)
+              ui.success(table)
+            end
+          end
+
+          private
+
+            def table_columns
+              ["Key", "Value"]
+            end
+
+            def filter_config(config)
+              parsed_config = JSON.parse(config)
+              if keys.nil? && required_config_vars_file_path.nil?
+                return parsed_config
+              end
+
+              required_config = keys || read_json_file(required_config_vars_file_path)
+              required_config.map do |key|
+                [key, parsed_config[key]]
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/config_vars/remove.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class Remove < Base
+          attr_accessor :apps, :keys, :sandbox
+
+          def initialize(apps, keys = [], sandbox = false)
+            super()
+            @apps = apps
+            @keys = keys
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :heroku, sandbox)
+            matching_apps.each do |app|
+              `heroku access -a #{app}`
+
+              unless $?.success?
+                ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+                ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+                next
+              end
+
+              keys.each do |key|
+                `heroku config:unset #{key} -a #{app}`
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/config_vars/upsert.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class Upsert < Base
+          attr_accessor :apps, :required_config_vars_json_file_path,
+            :required_config_vars_with_project_keys_json_file_path, :sandbox
+
+          def initialize(apps, required_config_vars_json_file_path,
+required_config_vars_with_project_keys_json_file_path, sandbox = false)
+            super()
+            @apps = apps
+            @required_config_vars_json_file_path = required_config_vars_json_file_path
+            @required_config_vars_with_project_keys_json_file_path =
+              required_config_vars_with_project_keys_json_file_path
+            @sandbox = sandbox
+          end
+
+          def run
+            check_the_given_arguments
+            inform_about_current_working_mode(sandbox) if apps.nil?
+            apps_to_be_updated = apps.nil? ?
+            read_json_file(required_config_vars_with_project_keys_json_file_path) :
+            find_all_matching_apps(apps, :heroku, sandbox)
+            inform_about_default_config_vars_file
+
+            apps_to_be_updated.each do |app|
+              required_config = apps.nil? ? app[1] : read_json_file(required_config_vars_json_file_path || default_config_vars_upsert_file_path)
+              app = app[0] if apps.nil?
+
+              if apps.nil? && sandbox && app != "neeto-dummy"
+                ui.error("The \"#{app}\" app is not available in sandbox mode.")
+                next
+              end
+
+              upsert_config_variables(app, required_config)
+            end
+          end
+
+          private
+
+            def upsert_config_variables(app, vars)
+              `heroku access -a #{app}`
+              unless $?.success?
+                ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+                ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+                return
+              end
+
+              vars.each do |key, val|
+                `heroku config:set #{key}='#{val}'  -a #{app}`
+              end
+            end
+
+            def check_the_given_arguments
+              if (!apps.nil? && !required_config_vars_with_project_keys_json_file_path.nil?) ||
+                  (apps.nil? && required_config_vars_with_project_keys_json_file_path.nil?)
+                ui.error("Please provide either apps or path to the config file with project keys")
+                exit
+              end
+            end
+
+            def default_config_vars_upsert_file_path
+              File.expand_path("../../../../../data/config-vars-upsert.json", __dir__)
+            end
+
+            def inform_about_default_config_vars_file
+              if !apps.nil? && required_config_vars_with_project_keys_json_file_path.nil? && required_config_vars_json_file_path.nil?
+                ui.info("Upserting config vars from the \"neetob/data/config-vars-upsert.json\" file")
+              end
+            end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Heroku
+      class Execute < Base
+        attr_accessor :apps, :command_to_execute, :should_run_in_rails_console, :sandbox
+
+        def initialize(apps, command_to_execute, should_run_in_rails_console = false, sandbox = false)
+          super()
+          @apps = apps
+          @command_to_execute = command_to_execute
+          @should_run_in_rails_console = should_run_in_rails_console
+          @sandbox = sandbox
+        end
+
+        def run
+          matching_apps = find_all_matching_apps(apps, :heroku, sandbox)
+          rails_runner_command = "heroku run rails runner '#{command_to_execute}'"
+          heroku_command = should_run_in_rails_console ? rails_runner_command : command_to_execute
+          matching_apps.each do |app|
+            ui.info("\n  Working on #{app}\n")
+            output = `#{heroku_command} -a #{app}`
+            unless $?.success?
+              ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+              ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+              next
+            end
+            ui.success(output)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "ls"
+
+module Neetob
+  class CLI
+    module Local
+      class Commands < Thor
+        desc "ls", "List the files in local neeto repos"
+        option :apps, type: :array, aliases: "-a", required: true, desc: "Neeto app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web\""
+        option :dir, type: :string, aliases: "-d", desc: "Mention the directory you want to list"
+        def ls
+          Ls.new(options[:apps], options[:dir], options[:sandbox]).run
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/local/ls.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Local
+      class Ls < Base
+        attr_accessor :sandbox, :apps, :dir
+
+        def initialize(apps, dir, sandbox = false)
+          super()
+          @apps = apps
+          @dir = dir
+          @sandbox = sandbox
+        end
+
+        def run
+          matching_apps = find_all_matching_apps(apps, :github, sandbox, true)
+          matching_apps.each do |app|
+            app_name = app.split("/")[1]
+            ui.info("\nListing files from #{app_name}/#{dir}\n")
+            ui.info(`cd ./#{app_name} && ls #{dir}`)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/sub_command_base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "thor"
+
+class SubCommandBase < Thor
+  def self.banner(command, namespace = nil, subcommand = false)
+    "#{basename} #{subcommand_prefix} #{command.usage}"
+  end
+
+  def self.subcommand_prefix
+    self.name
+      .split("::")[2..-2]
+      .map { |name| name.gsub(%r{^[A-Z]}) { |match| match[0].downcase } }
+      .map { |name| name.gsub(%r{[A-Z]}) { |match| "-#{match[0].downcase}" } }
+      .join(" ")
+  end
+end

data/lib/neetob/cli/ui.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+4# frozen_string_literal: true
+
+require "thor"
+
+module Neetob
+  class CLI
+    class UI
+      attr_accessor :shell
+
+      def initialize
+        @shell = Thor::Base.shell.new
+      end
+
+      def say(statement, color = Thor::Shell::Color::YELLOW)
+        shell.say(statement, color)
+      end
+
+      def ask(question, echo = true)
+        shell.ask(question, echo: echo)
+      end
+
+      def yes?(question)
+        shell.yes?(question)
+      end
+
+      def error(statement)
+        shell.say(statement, Thor::Shell::Color::RED)
+      end
+
+      def success(statement)
+        shell.say(statement, Thor::Shell::Color::GREEN)
+      end
+
+      def info(statement)
+        shell.say(statement)
+      end
+    end
+  end
+end

data/lib/neetob/cli/users/audit.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Users
+      class Audit < Base
+        attr_accessor :sandbox
+
+        def initialize(sandbox = false)
+          super()
+          @sandbox = sandbox
+        end
+
+        def run
+          users_data = users_for_all_available_apps
+          users = extract_values_from_user_data(users_data)
+          email_repos_map = create_email_repos_map(users)
+          unique_users = users.uniq { |user| [user[0], user[1]] }.sort
+          ui.info("\nUsers with multiple emails:")
+          find_users_with_multiple_emails(unique_users.transpose, email_repos_map)
+          ui.info("Users with emails having 3rd party domains:")
+          find_users_with_invalid_emails(unique_users.transpose, email_repos_map)
+        end
+
+        private
+
+          def users_for_all_available_apps
+            find_all_matching_apps(["*"], :github, sandbox, true).map do |app|
+              clone_repo_and_get_users(app).split("\n").map { |user| "#{user} #{app}" }
+            end
+          end
+
+          def extract_values_from_user_data(users)
+            users.flatten.map do |user|
+              values = user.strip.split(" ")[1..-1]
+              [values[0..-3].join(" "), clean_email(values[-2]), clean_repo_name(values[-1])]
+            end
+          end
+
+          def clone_repo_and_get_users(app)
+            app_name_without_org_suffix = app.split("/")[1]
+            `git -C ./#{app_name_without_org_suffix} shortlog -sne`
+          end
+
+          def create_email_repos_map(users)
+            map = {}
+            users.each do |user|
+              email = user[1]
+              repo = user[2]
+              map[email] = [] unless map.key?(email)
+              map[email].push(repo)
+            end
+            map
+          end
+
+          def find_users_with_multiple_emails(users, email_repos_map)
+            user_emails = {}
+            users[0].each_with_index do |name, index|
+              email = users[1][index]
+              user_emails[name] = [] unless user_emails.key?(name)
+              user_emails[name].push(email)
+            end
+            user_with_multiple_emails = user_emails.filter { |_, val| val.length > 1 }
+            table_rows = create_rows_and_add_repos(user_with_multiple_emails, email_repos_map)
+            create_and_show_table(table_rows, table_columns)
+          end
+
+          def find_users_with_invalid_emails(users, email_repos_map)
+            user_with_invalid_emails = {}
+            users[1].each_with_index do |email, index|
+              name = users[0][index]
+              if invalid_email?(email)
+                user_with_invalid_emails[name] = [] unless user_with_invalid_emails.key?(name)
+                user_with_invalid_emails[name].push(email)
+              end
+            end
+            table_rows = create_rows_and_add_repos(user_with_invalid_emails, email_repos_map)
+            create_and_show_table(table_rows, table_columns)
+          end
+
+          def table_columns
+            [:Name, :Email, :Repo]
+          end
+
+          def create_rows_and_add_repos(users, email_repos_map)
+            users.map do |name, emails|
+              repos = emails.map { |email| email_repos_map[email] }
+              [name, emails.join(", "), join_and_truncate_repos(repos)]
+            end
+          end
+
+          def create_and_show_table(data, column_names)
+            table = Terminal::Table.new headings: column_names, rows: data
+            ui.error(table)
+          end
+
+          def join_and_truncate_repos(repos)
+            repos.flatten.uniq.join(",").truncate(35)
+          end
+
+          def clean_email(email)
+            email.gsub(/<|>/, "")
+          end
+
+          def clean_repo_name(repo)
+            repo.gsub("bigbinary/", "")
+          end
+
+          def invalid_email?(email)
+            !allowed_email_domains.any? { |domain| email.downcase.include?(domain) }
+          end
+
+          def allowed_email_domains
+            ["github", "gmail", "bigbinary"]
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "audit"
+require_relative "commits"
+
+module Neetob
+  class CLI
+    module Users
+      class Commands < Thor
+        desc "audit", "Audit the users of all the neeto apps"
+        def audit
+          Audit.new(options[:sandbox]).run
+        end
+
+        desc "commits", "List the commits of a user across the neeto apps"
+        option :apps, type: :array, aliases: "-a", default: ["*"], desc: "Github app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web\""
+        option :author, type: :string, required: true, desc: "Github username of the person whose commits you want to list"
+        option :duration, type: :string, required: true, desc: "Duration for which you want to list the commits. Example: \"6.months\" \"10.days\""
+        def commits
+          Commits.new(
+            options[:author], options[:duration], options[:apps],
+            options[:sandbox]).run
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/users/commits.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Users
+      class Commits < Base
+        attr_accessor :sandbox, :apps, :author, :duration
+
+        def initialize(author, duration, apps = ["*"], sandbox = false)
+          super()
+          @sandbox = sandbox
+          @apps = apps
+          @author = author
+          @duration = duration
+        end
+
+        def run
+          table_rows = build_commit_rows
+          html_content = build_html_content(table_rows)
+          create_html_file(html_content)
+          open_html_file_in_default_system_application
+        end
+
+        private
+
+          def build_commit_rows
+            find_all_matching_apps(apps, :github, sandbox, true).map do |app|
+              commits = commits_within_range(app)
+              if commits.empty?
+                ui.error("No commits found in \"#{app}\" for the given author and duration.")
+                next
+              end
+
+              build_table_rows(app, commits)
+            end
+          end
+
+          def commits_within_range(app)
+            `git -C ./#{app_name_without_org_suffix(app)} log --pretty=format:"%H:::%ae:::%ar:::%s" --author=#{author} --since=#{duration} --no-merges`
+          end
+
+          def build_table_rows(app, commits)
+            commits.split("\n").map { |commit| html_table_row(app, *commit.split(":::")) }
+          end
+
+          def app_name_without_org_suffix(app)
+            app.split("/")[1]
+          end
+
+          def html_table_row(app, commit, email, time, title)
+            starting_7_characters_of_commit = commit[0..6]
+            "<tr>
+              <td class='commit'><a href='https://github.com/#{app}/commit/#{commit}'
+                  target='_blank'>#{starting_7_characters_of_commit}</a></td>
+              <td class='project'>#{app_name_without_org_suffix(app)}</td>
+              <td class='email'>#{email}</td>
+              <td class='time'>#{time}</td>
+              <td class='title'>#{title}</td>
+            </tr>"
+          end
+
+          def build_html_content(table_rows)
+            "<!DOCTYPE html>
+            <html>
+            <body>
+              <style>
+                table {
+                  font-family: arial, sans-serif;
+                  border-collapse: collapse;
+                  width: 100%;
+                }
+                td, th {
+                  border: 1px solid #dddddd;
+                  text-align: left;
+                  padding: 8px;
+                }
+                tr:nth-child(even) {
+                  background-color: #dddddd;
+                }
+                .project {
+                  color: blue;
+                }
+                .commit {
+                  color: blueviolet;
+                }
+                .email {
+                  color: green;
+                  width: 50px;
+                }
+                .time {
+                  color: darkorange;
+                }
+                .title {
+                  color: lightcoral
+                }
+              </style>
+              <table>
+                <tr>
+                  <th>Commit</th>
+                  <th>Product</th>
+                  <th>Email</th>
+                  <th>Created at</th>
+                  <th>Title</th>
+                </tr>
+                #{table_rows.empty? ? "<tr><td>No commits found in the given duration</td></tr>" : table_rows.join}
+              </table>
+            </body>
+            </html>"
+          end
+
+          def create_html_file(html_content)
+            commits_file = File.new("commits.html", "w")
+            commits_file.puts(html_content)
+            commits_file.close
+          end
+
+          def open_html_file_in_default_system_application
+            `open ./commits.html`
+          end
+      end
+    end
+  end
+end

data/lib/neetob/cli.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module Neetob
+  class CLI < Thor
+    require_relative "cli/heroku/commands"
+    require_relative "cli/github/commands"
+    require_relative "cli/users/commands"
+    require_relative "cli/fetchorupdate_repos/execute"
+    require_relative "cli/local/commands"
+
+    class_option :sandbox,
+      {
+        type: :boolean, default: false,
+        desc: "All the commands in sandbox mode will run only on the \"neeto-dummy\" app."
+      }
+
+    def self.start(*)
+      super
+    end
+
+    desc "heroku", "Interact with any resource in Heroku"
+    subcommand "heroku", Heroku::Commands
+
+    desc "github", "Interact with any resource in Github"
+    subcommand "github", Github::Commands
+
+    desc "users", "Interact with the contributors of neeto apps"
+    subcommand "users", Users::Commands
+
+    desc "local", "Interact with the local neeto repos"
+    subcommand "local", Local::Commands
+
+    desc "make_repos_uptodate", "Uptodate all neeto repos"
+    def make_repos_uptodate
+      FetchorupdateRepos::Execute.new(options[:sandbox]).run
+    end
+  end
+end