git-multi 1.0.0

data/lib/git/hub.rb

@@ -0,0 +1,95 @@
+require 'octokit'
+
+begin
+  require 'net/http/persistent'
+  Octokit.middleware.swap(
+    Faraday::Adapter::NetHttp,          # default Faraday adapter
+    Faraday::Adapter::NetHttpPersistent # experimental Faraday adapter
+  )
+rescue LoadError
+  # NOOP  -  `Net::HTTP::Persistent` is optional, so
+  # if the gem isn't installed, then we run with the
+  # default `Net::HTTP` Faraday adapter;  if however
+  # the gem is installed then we make Faraday use it
+  # to benefit from persistent HTTP connections
+end
+
+module Git
+  module Hub
+
+    module_function
+
+    def client
+      @client ||= Octokit::Client.new(
+        :access_token => Git::Multi::TOKEN,
+        :auto_paginate => true,
+      )
+    end
+
+    class << self
+      private :client
+    end
+
+    def connected?
+      @connected ||= begin
+        client.validate_credentials
+        true
+      rescue Faraday::ConnectionFailed
+        false
+      end
+    end
+
+    # FIXME update login as part of `--refresh`
+
+    def login
+      @login ||= begin
+        client.user.login
+      rescue Octokit::Unauthorized, Faraday::ConnectionFailed
+        nil
+      end
+    end
+
+    # FIXME update orgs as part of `--refresh`
+
+    def orgs
+      @orgs ||= begin
+        client.organizations.map(&:login)
+      rescue Octokit::Unauthorized, Faraday::ConnectionFailed
+        []
+      end
+    end
+
+    #
+    # https://developer.github.com/v3/repos/#list-user-repositories
+    #
+
+    @user_repositories = Hash.new { |repos, (user, type)|
+      repos[[user, type]] = begin
+        notify("Refreshing #{type} '#{user}' repositories from GitHub")
+        client.repositories(user, :type => type).
+        sort_by { |repo| repo[:name].downcase }
+      end
+    }
+
+    def user_repositories(user, type = :owner) # all, owner, member
+      @user_repositories[[user, type]]
+    end
+
+    #
+    # https://developer.github.com/v3/repos/#list-organization-repositories
+    #
+
+    @org_repositories = Hash.new { |repos, (org, type)|
+      repos[[org, type]] = begin
+        notify("Refreshing #{type} '#{org}' repositories from GitHub")
+        client.org_repositories(org, :type => type).
+        sort_by { |repo| repo[:name].downcase }
+      end
+    }
+
+    def org_repositories(org, type = :owner) # all, public, private, forks, sources, member
+      @org_repositories[[org, type]]
+    end
+
+  end
+end

data/lib/git/multi/commands.rb

@@ -0,0 +1,189 @@
+module Git
+  module Multi
+    module Commands
+
+      module_function
+
+      def version
+        puts Git::Multi::LONG_VERSION
+      end
+
+      def check
+        Settings.user_status(Git::Multi::USER)
+        Settings.organization_status(Git::Multi::ORGANIZATIONS)
+        Settings.token_status(Git::Multi::TOKEN)
+        Settings.home_status(Git::Multi::HOME)
+        Settings.main_workarea_status(Git::Multi::WORKAREA)
+        Settings.user_workarea_status(Git::Multi::USER)
+        Settings.organization_workarea_status(Git::Multi::ORGANIZATIONS)
+        Settings.file_status(Git::Multi::REPOSITORIES)
+      end
+
+      def help
+        # instead of maintaining a list of valid query args in the help-
+        # file, we determine it at runtime... less is more, and all that
+        # TODO remove attributes we 'adorned' the repos with on line 95?
+        query_args = Git::Multi.repositories.sample.fields.sort.each_slice(3).map {
+          |foo, bar, qux| '%-20s  %-20s %-20s' % [foo, bar, qux]
+        }
+        puts File.read(Git::Multi::MAN_PAGE) % {
+          :version => Git::Multi::VERSION,
+          :query_args => query_args.join("\n    "),
+        }
+      end
+
+      def report
+        if (missing_repos = Git::Multi::missing_repositories).any?
+          notify(missing_repos.map(&:full_name), :subtitle => "#{missing_repos.count} missing repos")
+        end
+      end
+
+      def list
+        puts Git::Multi.repositories.map(&:full_name)
+      end
+
+      def archived
+        puts Git::Multi.archived_repositories.map(&:full_name)
+      end
+
+      def forked
+        puts Git::Multi.forked_repositories.map(&:full_name)
+      end
+
+      def private
+        puts Git::Multi.private_repositories.map(&:full_name)
+      end
+
+      def paths
+        puts Git::Multi.repositories.map(&:local_path)
+      end
+
+      def missing
+        puts Git::Multi.missing_repositories.map(&:full_name)
+      end
+
+      def excess
+        puts Git::Multi.excess_repositories.map(&:full_name)
+      end
+
+      def stale
+        puts Git::Multi.stale_repositories.map(&:full_name)
+      end
+
+      def spurious
+        puts Git::Multi.spurious_repositories.map(&:full_name)
+      end
+
+      def count
+        # https://developer.github.com/v3/repos/#list-user-repositories
+        user = Git::Multi::USER
+        %w{ all owner member }.each { |type|
+          puts ["#{user}/#{type}", Git::Hub.user_repositories(user, type).count].join("\t")
+        }
+        # https://developer.github.com/v3/repos/#list-organization-repositories
+        for org in Git::Multi::ORGANIZATIONS
+          %w{ all public private forks sources member }.each { |type|
+            puts ["#{org}/#{type}", Git::Hub.org_repositories(org, type).count].join("\t")
+          }
+        end
+      end
+
+      def refresh
+        Git::Multi.refresh_repositories
+      end
+
+      def json
+        puts Git::Multi.repositories.to_json
+      end
+
+      def clone
+        Git::Multi.missing_repositories.each do |repo|
+          FileUtils.mkdir_p repo.parent_dir
+          repo.just_do_it(
+            ->(project) {
+              notify "Cloning '#{repo.full_name}' repo into #{repo.parent_dir.parent}"
+              Kernel.system "git clone -q #{project.rels[:ssh].href.shellescape}"
+            },
+            ->(project) {
+              Kernel.system "git clone -q #{project.rels[:ssh].href.shellescape}"
+            },
+            :in_dir => :parent_dir
+          )
+        end
+      end
+
+      def query args = []
+        Git::Multi.repositories.each do |repo|
+          repo.just_do_it(
+            ->(project) {
+              args.each do |attribute|
+                puts "#{attribute}: #{project[attribute]}"
+              end
+            },
+            ->(project) {
+              print "#{project.full_name}: "
+              puts args.map { |attribute| project[attribute] }.join(' ')
+            },
+          )
+        end
+      end
+
+      def system args = []
+        args.map!(&:shellescape)
+        Git::Multi.cloned_repositories.each do |repo|
+          repo.just_do_it(
+            ->(project) {
+              Kernel.system "#{args.join(' ')}"
+            },
+            ->(project) {
+              Kernel.system "#{args.join(' ')} 2>&1 | sed -e 's#^##{project.full_name.shellescape}: #'"
+            },
+            :in_dir => :local_path
+          )
+        end
+      end
+
+      def raw args
+        args.unshift ['sh', '-c']
+        system args.flatten
+      end
+
+      def exec command, args = []
+        args.unshift ['git', '--no-pager', command]
+        system args.flatten
+      end
+
+      def find commands
+        Git::Multi.cloned_repositories.each do |repo|
+          Dir.chdir(repo.local_path) do
+            begin
+              if repo.instance_eval(commands.join(' && '))
+                repo.just_do_it(
+                  ->(project) { nil ; },
+                  ->(project) { puts project.full_name ; },
+                )
+              end
+            rescue Octokit::NotFound
+              # project no longer exists on github.com
+              # consider running "git multi --stale"...
+            end
+          end
+        end
+      end
+
+      def eval commands
+        Git::Multi.cloned_repositories.each do |repo|
+          Dir.chdir(repo.local_path) do
+            begin
+              repo.instance_eval(commands.join(' ; '))
+            rescue Octokit::NotFound
+              # project no longer exists on github.com
+              # consider running "git multi --stale"...
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/git/multi/settings.rb

@@ -0,0 +1,89 @@
+module Git
+  module Multi
+    module Settings
+
+      TICK  = ["2714".hex].pack("U*").green.freeze
+      CROSS = ["2718".hex].pack("U*").red.freeze
+      ARROW = ["2794".hex].pack("U*").blue.freeze
+
+      module_function
+
+      def setting_status messages, valid, optional = false
+        fields = messages.compact.join(' - ')
+        icon = valid ? TICK : optional ? ARROW : CROSS
+        if $INTERACTIVE
+          print "   #{fields}" ; sleep 0.75 ; puts "\x0d#{icon}"
+        else
+          puts "#{icon}  #{fields}"
+        end
+      end
+
+      def file_status file, message = 'File'
+        setting_status(
+          [
+            message,
+            abbreviate(file),
+            File.file?(file) ? "#{File.size(file).commify} bytes" : nil,
+          ],
+          file && !file.empty? && File.file?(file),
+          false
+        )
+      end
+
+      def directory_status messages, directory
+        setting_status(
+          messages,
+          directory && !directory.empty? && File.directory?(directory),
+          false
+        )
+      end
+
+      def workarea_status message, workarea, owner
+        directory_status(
+          [
+            message,
+            File.join(abbreviate(workarea, :workarea), owner),
+            File.directory?(workarea) ? "#{Dir.new(workarea).git_repos(owner).count.commify} repos" : nil
+          ],
+          workarea
+        )
+      end
+
+      def user_status user
+        setting_status(["User", user], user && !user.empty?)
+      end
+
+      def organization_status orgs
+        for org in orgs
+          setting_status(["Organization", org], org && !org.empty?, true)
+          setting_status(["Organization", "member?"], Git::Hub.orgs.include?(org), !Git::Hub.connected?)
+        end
+      end
+
+      def token_status token
+        setting_status(["Token", symbolize(token), describe(token)], !token.nil? && !token.empty?)
+        setting_status(["Token", "valid?"], !token.nil? && !token.empty? && Git::Hub.login, !Git::Hub.connected?)
+        setting_status(["Token", "owned by #{Git::Multi::USER}?"], Git::Hub.login == Git::Multi::USER, !Git::Hub.connected?)
+      end
+
+      def home_status home
+        directory_status(["Home", home], home)
+      end
+
+      def main_workarea_status workarea
+        directory_status(["Workarea (main)", abbreviate(workarea, :home)], workarea)
+      end
+
+      def user_workarea_status user
+        workarea_status("Workarea (user: #{user})", Git::Multi::WORKAREA, user)
+      end
+
+      def organization_workarea_status orgs
+        for org in orgs
+          workarea_status("Workarea (org: #{org})", Git::Multi::WORKAREA, org)
+        end
+      end
+
+    end
+  end
+end

data/lib/git/multi/version.rb

@@ -0,0 +1,32 @@
+require 'octokit'
+require 'sawyer'
+require 'psych'
+
+module Git
+  module Multi
+    NAME = 'git-multi'
+    VERSION = '1.0.0'
+
+    LONG_VERSION = "%s v%s (%s v%s, %s v%s, %s v%s)" % [
+      NAME,
+      VERSION,
+      'octokit.rb',
+      Octokit::VERSION,
+      'sawyer',
+      Sawyer::VERSION,
+      'psych',
+      Psych::VERSION,
+    ]
+
+    PIM = <<~"EOPIM" # gem post_install_message
+
+    The required settings are as follows:
+
+    git config --global --add github.user <your_github_username>
+    git config --global --add github.organizations <your_github_orgs>
+    git config --global --add github.token <your_github_token>
+    git config --global --add gitmulti.workarea <your_root_workarea>
+
+    EOPIM
+  end
+end

data/lib/git/multi.rb

@@ -0,0 +1,190 @@
+require 'etc'
+require 'json'
+require 'pathname'
+require 'fileutils'
+require 'shellwords'
+
+require 'octokit'
+require 'sawyer'
+
+require 'ext/dir'
+require 'ext/utils'
+require 'ext/string'
+require 'ext/notify'
+require 'ext/commify'
+require 'ext/sawyer/resource'
+
+require 'git/hub'
+
+require 'git/multi/version'
+require 'git/multi/settings'
+require 'git/multi/commands'
+
+module Git
+  module Multi
+
+    HOME             = Dir.home
+
+    DEFAULT_WORKAREA = File.join(HOME, 'Workarea')
+    WORKAREA         = git_option('gitmulti.workarea', DEFAULT_WORKAREA)
+
+    DEFAULT_TOKEN    = env_var('OCTOKIT_ACCESS_TOKEN') # same as Octokit
+    TOKEN            = git_option('github.token', DEFAULT_TOKEN)
+
+    CACHE            = File.join(HOME, '.git', 'multi')
+    REPOSITORIES     = File.join(CACHE, 'repositories.byte')
+
+    USER             = git_option('github.user')
+    ORGANIZATIONS    = git_option('github.organizations').split(/\s*,\s*/)
+
+    MAN_PAGE         = File.expand_path('../../doc/git-multi.man', __dir__)
+
+    module_function
+
+    #
+    # local repositories (in WORKAREA)
+    #
+
+    @local_user_repositories = Hash.new { |repos, user|
+      repos[user] = Dir.new(WORKAREA).git_repos(user)
+    }
+
+    @local_org_repositories = Hash.new { |repos, org|
+      repos[org] = Dir.new(WORKAREA).git_repos(org)
+    }
+
+    def local_repositories
+      (
+        @local_user_repositories[USER] +
+        ORGANIZATIONS.map { |org| @local_org_repositories[org] }
+      ).flatten
+    end
+
+    #
+    # remote repositories (on GitHub)
+    #
+
+    def github_repositories
+      @github_repositories ||= (
+        Git::Hub.user_repositories(USER) +
+        ORGANIZATIONS.map { |org| Git::Hub.org_repositories(org) }
+      ).flatten
+    end
+
+    def refresh_repositories
+      File.directory?(CACHE) || FileUtils.mkdir_p(CACHE)
+
+      File.open(REPOSITORIES, 'wb') do |file|
+        Marshal.dump(github_repositories, file)
+      end
+    end
+
+    #
+    # the main `Git::Multi` capabilities
+    #
+
+    module Nike
+
+      def just_do_it interactive, pipeline, options = {}
+        working_dir = case options[:in_dir]
+          when :parent_dir then self.parent_dir
+          when :local_path then self.local_path
+          else Dir.pwd
+        end
+        Dir.chdir(working_dir) do
+          if $INTERACTIVE
+            puts "%s (%s)" % [
+              self.full_name.invert,
+              self.fractional_index
+            ]
+            interactive.call(self)
+          else
+            pipeline.call(self)
+          end
+        end
+      end
+
+    end
+
+    def repositories
+      if File.size?(REPOSITORIES)
+        @repositories ||= Marshal.load(File.read(REPOSITORIES)).tap do |projects|
+          notify "Finished loading #{REPOSITORIES}"
+          projects.each_with_index do |project, index|
+            # ensure 'project' has handle on an Octokit client
+            project.client = Git::Hub.send(:client)
+            # adorn 'project', which is a Sawyer::Resource
+            project.parent_dir = Pathname.new(File.join(WORKAREA, project.owner.login))
+            project.local_path = Pathname.new(File.join(WORKAREA, project.full_name))
+            project.fractional_index = "#{index + 1}/#{projects.count}"
+            # fix 'project' => https://github.com/octokit/octokit.rb/issues/727
+            project.compliant_ssh_url = 'ssh://%s/%s' % project.ssh_url.split(':', 2)
+            # extend 'project' with 'just do it' capabilities
+            project.extend Nike
+          end
+        end
+      else
+        refresh_repositories and repositories
+      end
+    end
+
+    #
+    # lists of repositories with a given state
+    #
+
+    def archived_repositories
+      repositories.find_all(&:archived)
+    end
+
+    def forked_repositories
+      repositories.find_all(&:fork)
+    end
+
+    def private_repositories
+      repositories.find_all(&:private)
+    end
+
+    #
+    # derived lists of repositories
+    #
+
+    def excess_repositories
+      repository_full_names = repositories.map(&:full_name)
+      local_repositories.reject { |project|
+        repository_full_names.include? project.full_name
+      }
+    end
+
+    def stale_repositories
+      repository_full_names = github_repositories.map(&:full_name)
+      repositories.reject { |project|
+        repository_full_names.include? project.full_name
+      }
+    end
+
+    def spurious_repositories
+      cloned_repositories.find_all { |project|
+        origin_url = `git -C #{project.local_path} config --get remote.origin.url`.chomp
+        ![
+          project.clone_url,
+          project.ssh_url,
+          project.compliant_ssh_url,
+          project.git_url,
+        ].include? origin_url
+      }
+    end
+
+    def missing_repositories
+      repositories.find_all { |project|
+        !File.directory? project.local_path
+      }
+    end
+
+    def cloned_repositories
+      repositories.find_all { |project|
+        File.directory? project.local_path
+      }
+    end
+
+  end
+end