wfarr-github 0.4.1

data/lib/commands/issues.rb

@@ -0,0 +1,17 @@
+desc "Project issues tools - sub-commands : open [user], closed [user]"
+flags :after => "Only show issues updated after a certain date"
+flags :label => "Only show issues with a certain label"
+command :issues do |command, user|
+  return if !helper.project
+  user ||= helper.owner
+
+  case command
+  when 'open', 'closed'
+    report = YAML.load(open(@helper.list_issues_for(user, command)))
+    @helper.print_issues(report['issues'], options)
+  when 'web'
+    helper.open helper.issues_page_for(user)
+  else
+    helper.print_issues_help
+  end
+end

data/lib/commands/network.rb

@@ -0,0 +1,110 @@
+desc "Project network tools - sub-commands : web [user], list, fetch, commits"
+flags :after => "Only show commits after a certain date"
+flags :before => "Only show commits before a certain date"
+flags :shas => "Only show shas"
+flags :project => "Filter commits on a certain project"
+flags :author => "Filter commits on a email address of author"
+flags :applies => "Filter commits to patches that apply cleanly"
+flags :noapply => "Filter commits to patches that do not apply cleanly"
+flags :nocache => "Do not use the cached network data"
+flags :cache => "Use the network data even if it's expired"
+flags :sort => "How to sort : date(*), branch, author"
+flags :common => "Show common branch point"
+flags :thisbranch => "Look at branches that match the current one"
+flags :limit => "Only look through the first X heads - useful for really large projects"
+command :network do |command, user|
+  return if !helper.project
+  user ||= helper.owner
+
+  case command
+  when 'web'
+    helper.open helper.network_page_for(user)
+  when 'list'
+    helper.network_members(user, options).each { |user| puts user }
+  when 'fetch'
+    # fetch each remote we don't have
+    data = helper.get_network_data(user, options)
+    data['users'].each do |hsh|
+      u = hsh['name']
+      GitHub.invoke(:track, u) unless helper.tracking?(u)
+      puts "fetching #{u}"
+      GitHub.invoke(:fetch_all, u)
+    end
+  when 'commits'
+    # show commits we don't have yet
+
+    $stderr.puts 'gathering heads'
+    cherry = []
+
+    if helper.cache_commits_data(options)
+      ids = []
+      data = helper.get_network_data(user, options)
+      data['users'].each do |hsh|
+        u = hsh['name']
+        if options[:thisbranch]
+          user_ids = hsh['heads'].map { |a| a['id'] if a['name'] == helper.current_branch }.compact
+        else
+          user_ids = hsh['heads'].map { |a| a['id'] }
+        end
+        user_ids.each do |id|
+          if !helper.has_commit?(id) && helper.cache_expired?
+            GitHub.invoke(:track, u) unless helper.tracking?(u)
+            puts "fetching #{u}"
+            GitHub.invoke(:fetch_all, u)
+          end
+        end
+        ids += user_ids
+      end
+      ids.uniq!
+
+      $stderr.puts 'has heads'
+
+      # check that we have all these shas locally
+      local_heads = helper.local_heads
+      local_heads_not = local_heads.map { |a| "^#{a}"}
+      looking_for = (ids - local_heads) + local_heads_not
+      commits = helper.get_commits(looking_for)
+
+      $stderr.puts 'ID SIZE:' + ids.size.to_s
+
+      ignores = helper.ignore_sha_array
+
+      ids.each do |id|
+        next if ignores[id] || !commits.assoc(id)
+        cherries = helper.get_cherry(id)
+        cherries = helper.remove_ignored(cherries, ignores)
+        cherry += cherries
+        helper.ignore_shas([id]) if cherries.size == 0
+        $stderr.puts "checking head #{id} : #{cherry.size.to_s}"
+        break if options[:limit] && cherry.size > options[:limit].to_i
+      end
+    end
+
+    if cherry.size > 0 || !helper.cache_commits_data(options)
+      helper.print_network_cherry_help if !options[:shas]
+
+      if helper.cache_commits_data(options)
+        $stderr.puts "caching..."
+        $stderr.puts "commits: " + cherry.size.to_s
+        our_commits = cherry.map { |item| c = commits.assoc(item[1]); [item, c] if c }
+        our_commits.delete_if { |item| item == nil }
+        helper.cache_commits(our_commits)
+      else
+        $stderr.puts "using cached..."
+        our_commits = helper.commits_cache
+      end
+
+      helper.print_commits(our_commits, options)
+    else
+      puts "no unapplied commits"
+    end
+  else
+    helper.print_network_help
+  end
+end
+
+desc "Ignore a SHA (from 'github network commits')"
+command :ignore do |sha|
+  commits = helper.resolve_commits(sha)
+  helper.ignore_shas(commits)             # add to .git/ignore-shas file
+end

data/lib/github.rb

@@ -0,0 +1,185 @@
+$:.unshift File.dirname(__FILE__)
+require 'github/extensions'
+require 'github/command'
+require 'github/helper'
+require 'github/ui'
+require 'fileutils'
+require 'rubygems'
+require 'open-uri'
+require 'json'
+require 'yaml'
+require 'text/format'
+
+##
+# Starting simple.
+#
+# $ github <command> <args>
+#
+#   GitHub.command <command> do |*args|
+#     whatever
+#   end
+#
+
+module GitHub
+  extend self
+
+  BasePath = File.expand_path(File.dirname(__FILE__))
+
+  def command(command, options = {}, &block)
+    command = command.to_s
+    debug "Registered `#{command}`"
+    descriptions[command] = @next_description if @next_description
+    @next_description = nil
+    flag_descriptions[command].update @next_flags if @next_flags
+    usage_descriptions[command] = @next_usage if @next_usage
+    @next_flags = nil
+    @next_usage = []
+    commands[command] = Command.new(block)
+    Array(options[:alias] || options[:aliases]).each do |command_alias|
+      commands[command_alias.to_s] = commands[command.to_s]
+    end
+  end
+
+  def desc(str)
+    @next_description = str
+  end
+
+  def flags(hash)
+    @next_flags ||= {}
+    @next_flags.update hash
+  end
+
+  def usage(string)
+    @next_usage ||= []
+    @next_usage << string
+  end
+
+  def helper(command, &block)
+    debug "Helper'd `#{command}`"
+    Helper.send :define_method, command, &block
+  end
+
+  def activate(args)
+    @@original_args = args.clone
+    @options = parse_options(args)
+    @debug = @options.delete(:debug)
+    @learn = @options.delete(:learn)
+    Dir[BasePath + '/commands/*.rb'].each do |command|
+      load command
+    end
+    invoke(args.shift, *args)
+  end
+
+  def invoke(command, *args)
+    block = find_command(command)
+    debug "Invoking `#{command}`"
+    block.call(*args)
+  end
+
+  def find_command(name)
+    name = name.to_s
+    commands[name] || (commands[name] = GitCommand.new(name)) || commands['default']
+  end
+
+  def commands
+    @commands ||= {}
+  end
+
+  def descriptions
+    @descriptions ||= {}
+  end
+
+  def flag_descriptions
+    @flagdescs ||= Hash.new { |h, k| h[k] = {} }
+  end
+
+  def usage_descriptions
+    @usage_descriptions ||= Hash.new { |h, k| h[k] = [] }
+  end
+
+  def options
+    @options
+  end
+
+  def original_args
+    @@original_args ||= []
+  end
+
+  def parse_options(args)
+    idx = 0
+    args.clone.inject({}) do |memo, arg|
+      case arg
+      when /^--(.+?)=(.*)/
+        args.delete_at(idx)
+        memo.merge($1.to_sym => $2)
+      when /^--(.+)/
+        args.delete_at(idx)
+        memo.merge($1.to_sym => true)
+      when "--"
+        args.delete_at(idx)
+        return memo
+      else
+        idx += 1
+        memo
+      end
+    end
+  end
+
+  def debug(*messages)
+    puts *messages.map { |m| "== #{m}" } if debug?
+  end
+
+  def learn(message)
+    if learn?
+      puts "== " + Color.yellow(message)
+    else
+      debug(message)
+    end
+  end
+
+  def learn?
+    !!@learn
+  end
+
+  def debug?
+    !!@debug
+  end
+
+  def load(file)
+    file[0] =~ /^\// ? path = file : path = BasePath + "/commands/#{File.basename(file)}"
+    data = File.read(path)
+    GitHub.module_eval data, path
+  end
+end
+
+GitHub.command :default, :aliases => ['', '-h', 'help', '-help', '--help'] do
+  message = []
+  message << "Usage: github command <space separated arguments>"
+  message << "Available commands:"
+  longest = GitHub.descriptions.map { |d,| d.to_s.size }.max
+  indent = longest + 6 # length of "  " + " => "
+  fmt = Text::Format.new(
+    :first_indent => indent,
+    :body_indent => indent,
+    :columns => 79 # be a little more lenient than the default
+  )
+  GitHub.descriptions.sort {|a,b| a.to_s <=> b.to_s }.each do |command, desc|
+    cmdstr = "%-#{longest}s" % command
+    desc = fmt.format(desc).strip # strip to eat first "indent"
+    message << "  #{cmdstr} => #{desc}"
+    flongest = GitHub.flag_descriptions[command].map { |d,| "--#{d}".size }.max
+    ffmt = fmt.clone
+    ffmt.body_indent += 2 # length of "% " and/or "--"
+    GitHub.usage_descriptions[command].each do |usage_descriptions|
+      usage_descriptions.each_line do |usage|
+        usage_str = "%% %-#{flongest}s" % usage
+        message << ffmt.format(usage_str)
+      end
+    end
+    GitHub.flag_descriptions[command].sort {|a,b| a.to_s <=> b.to_s }.each do |flag, fdesc|
+      flagstr = "#{" " * longest}  %-#{flongest}s" % "--#{flag}"
+      message << ffmt.format("  #{flagstr}: #{fdesc}")
+    end
+  end
+  puts message.map { |m| m.gsub(/\n$/,'') }.join("\n") + "\n"
+end

data/lib/github/command.rb

@@ -0,0 +1,131 @@
+require 'fileutils'
+
+if RUBY_PLATFORM =~ /mswin|mingw/
+  begin
+    require 'win32/open3'
+  rescue LoadError
+    warn "You must 'gem install win32-open3' to use the github command on Windows"
+    exit 1
+  end
+else
+  require 'open3'
+end
+
+module GitHub
+  class Command
+    include FileUtils
+
+    def initialize(block)
+      (class << self;self end).send :define_method, :command, &block
+    end
+
+    def call(*args)
+      arity = method(:command).arity
+      args << nil while args.size < arity
+      send :command, *args
+    end
+
+    def helper
+      @helper ||= Helper.new
+    end
+
+    def options
+      GitHub.options
+    end
+
+    def pgit(*command)
+      puts git(*command)
+    end
+
+    def git(command)
+      run :sh, command
+    end
+
+    def git_exec(command)
+      run :exec, command
+    end
+
+    def run(method, command)
+      if command.is_a? Array
+        command = [ 'git', command ].flatten
+        GitHub.learn command.join(' ')
+      else
+        command = 'git ' + command
+        GitHub.learn command
+      end
+
+      send method, *command
+    end
+
+    def sh(*command)
+      Shell.new(*command).run
+    end
+
+    def die(message)
+      puts "=> #{message}"
+      exit!
+    end
+
+    def github_user
+      git("config --get github.user")
+    end
+
+    def github_token
+      git("config --get github.token")
+    end
+
+    def shell_user
+      ENV['USER']
+    end
+
+    def current_user?(user)
+      user == github_user || user == shell_user
+    end
+
+    class Shell < String
+      attr_reader :error
+      attr_reader :out
+
+      def initialize(*command)
+        @command = command
+      end
+
+      def run
+        GitHub.debug "sh: #{command}"
+
+        out = err = nil
+        Open3.popen3(*@command) do |_, pout, perr|
+          out = pout.read.strip
+          err = perr.read.strip
+        end
+
+        replace @error = err if !err.empty?
+        replace @out = out if !out.empty?
+
+        self
+      end
+
+      def command
+        @command.join(' ')
+      end
+
+      def error?
+        !!@error
+      end
+
+      def out?
+        !!@out
+      end
+    end
+  end
+
+  class GitCommand < Command
+    def initialize(name)
+      @name = name
+    end
+
+    def command(*args)
+      git_exec [ @name, args ]
+    end
+  end
+end

data/lib/github/extensions.rb

@@ -0,0 +1,39 @@
+# define #try
+class Object
+  def try
+    self
+  end
+end
+
+class NilClass
+  klass = Class.new
+  klass.class_eval do
+    instance_methods.each { |meth| undef_method meth.to_sym unless meth =~ /^(__(id|send)__|object_id)$/ }
+    def method_missing(*args)
+      self
+    end
+  end
+  NilProxy = klass.new
+  def try
+    NilProxy
+  end
+end
+
+# define #tap
+class Object
+  def tap(&block)
+    block.call(self)
+    self
+  end
+end
+
+# cute
+module Color
+  COLORS = { :clear => 0, :red => 31, :green => 32, :yellow => 33 }
+  def self.method_missing(color_name, *args)
+    color(color_name) + args.first + color(:clear)
+  end
+  def self.color(color)
+    "\e[#{COLORS[color.to_sym]}m"
+  end
+end