github 0.1.1 → 0.4.0

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

@@ -1,32 +1,57 @@
 $:.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.register <command> do |*args|
-#     whatever 
+#   GitHub.command <command> do |*args|
+#     whatever
 #   end
 #
-# We'll probably want to use the `choice` gem for concise, tasty DSL
-# arg parsing action.
-#
 
 module GitHub
   extend self
 
-  BasePath = File.expand_path(File.dirname(__FILE__) + '/..')
+  BasePath = File.expand_path(File.dirname(__FILE__))
 
-  def register(command, &block)
+  def command(command, options = {}, &block)
+    command = command.to_s
     debug "Registered `#{command}`"
-    commands[command.to_s] = Command.new(block)
+    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 describe(hash)
-    descriptions.update hash
+  def flags(hash)
+    @next_flags ||= {}
+    @next_flags.update hash
+  end
+
+  def usage(string)
+    @next_usage ||= []
+    @next_usage << string
   end
 
   def helper(command, &block)
@@ -35,18 +60,27 @@ module GitHub
   end
 
   def activate(args)
+    @@original_args = args.clone
     @options = parse_options(args)
-    load 'helpers.rb'
-    load 'commands.rb'
+    @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 = commands[command.to_s] || commands['default']
+    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
@@ -55,43 +89,97 @@ module GitHub
     @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)
-    @debug = args.delete('--debug')
-    args.inject({}) do |memo, arg|
-      if arg =~ /^--([^=]+)=(.+)/
-        args.delete(arg)
+    idx = 0
+    args.clone.inject({}) do |memo, arg|
+      case arg
+      when /^--(.+?)=(.*)/
+        args.delete_at(idx)
         memo.merge($1.to_sym => $2)
-      elsif arg =~ /^--(.+)/
-        args.delete(arg)
+      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 load(file)
-    file[0] == ?/ ? super : super(BasePath + "/commands/#{file}")
-  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.register :default do
-  puts "Usage: github command <space separated arguments>", ''
-  puts "Available commands:", ''
-  GitHub.descriptions.each do |command, desc|
-    puts "  #{command} => #{desc}"
+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 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
+  puts message.map { |m| m.gsub(/\n$/,'') }.join("\n") + "\n"
 end

data/lib/github/command.rb

@@ -1,7 +1,20 @@
-require 'open3'
+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
@@ -11,7 +24,7 @@ module GitHub
       args << nil while args.size < arity
       send :command, *args
     end
-    
+
     def helper
       @helper ||= Helper.new
     end
@@ -24,12 +37,24 @@ module GitHub
       puts git(*command)
     end
 
-    def git(*command)
-      sh ['git', command].flatten.join(' ')
+    def git(command)
+      run :sh, command
     end
 
-    def git_exec(*command)
-      exec ['git', command].flatten.join(' ')
+    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)
@@ -41,23 +66,43 @@ module GitHub
       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 = Open3.popen3(*@command)
-
-        out = out.read.strip
-        err = err.read.strip
 
-        if out.any?
-          replace @out = out
-        elsif err.any?
-          replace @error = err
+        out = err = nil
+        Open3.popen3(*@command) do |_, pout, perr|
+          out = pout.read.strip
+          err = perr.read.strip
         end
+
+        replace @error = err if err.any?
+        replace @out = out if out.any?
+
+        self
       end
 
       def command
@@ -73,4 +118,14 @@ module GitHub
       end
     end
   end
+
+  class GitCommand < Command
+    def initialize(name)
+      @name = name
+    end
+
+    def command(*args)
+      git_exec [ @name, args ]
+    end
+  end
 end