bitprophet-github 0.3.4

data/lib/github.rb

@@ -0,0 +1,183 @@
+$:.unshift File.dirname(__FILE__)
+require 'github/extensions'
+require 'github/command'
+require 'github/helper'
+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] || 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
+  puts "Usage: github command <space separated arguments>", ''
+  puts "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"
+    puts "  #{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
+        puts ffmt.format(usage_str)
+      end
+    end
+    GitHub.flag_descriptions[command].each do |flag, fdesc|
+      flagstr = "#{" " * longest}  %-#{flongest}s" % "--#{flag}"
+      puts ffmt.format("  #{flagstr}: #{fdesc}")
+    end
+  end
+  puts
+end

data/lib/github/command.rb

@@ -0,0 +1,129 @@
+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 = Open3.popen3(*@command)
+
+        out = out.read.strip
+        err = err.read.strip
+
+        replace @error = err if err.any?
+        replace @out = out if out.any?
+
+        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)__$/ }
+    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

data/lib/github/helper.rb

@@ -0,0 +1,4 @@
+module GitHub
+  class Helper
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe GitHub::Command do
+  before(:each) do
+    @command = GitHub::Command.new(proc { |x| puts x })
+  end
+
+  it "should return a GitHub::Helper" do
+    @command.helper.should be_instance_of(GitHub::Helper)
+  end
+
+  it "should call successfully" do
+    @command.should_receive(:puts).with("test").once
+    @command.call("test")
+  end
+
+  it "should return options" do
+    GitHub.should_receive(:options).with().once.and_return({:ssh => true})
+    @command.options.should == {:ssh => true}
+  end
+
+  it "should successfully call out to the shell" do
+    unguard(Kernel, :fork)
+    unguard(Kernel, :exec)
+    hi = @command.sh("echo hi")
+    hi.should == "hi"
+    hi.out.should == "hi"
+    hi.out?.should be(true)
+    hi.error.should be_nil
+    hi.error?.should be(false)
+    hi.command.should == "echo hi"
+    if RUBY_PLATFORM =~ /mingw|mswin/
+      command = "cmd /c echo bye >&2"
+    else
+      command = "echo bye >&2" 
+    end
+    bye = @command.sh(command)
+    bye.should == "bye"
+    bye.out.should be_nil
+    bye.out?.should be(false)
+    bye.error.should == "bye"
+    bye.error?.should be(true)
+    bye.command.should == command
+    hi_and_bye = @command.sh("echo hi; echo bye >&2")
+    hi_and_bye.should == "hi"
+    hi_and_bye.out.should == "hi"
+    hi_and_bye.out?.should be(true)
+    hi_and_bye.error.should == "bye"
+    hi_and_bye.error?.should be(true)
+    hi_and_bye.command.should == "echo hi; echo bye >&2"
+  end
+
+  it "should return the results of a git operation" do
+    GitHub::Command::Shell.should_receive(:new).with("git rev-parse master").once.and_return do |*cmds|
+      s = mock("GitHub::Commands::Shell")
+      s.should_receive(:run).once.and_return("sha1")
+      s
+    end
+    @command.git("rev-parse master").should == "sha1"
+  end
+
+  it "should print the results of a git operation" do
+    @command.should_receive(:puts).with("sha1").once
+    GitHub::Command::Shell.should_receive(:new).with("git rev-parse master").once.and_return do |*cmds|
+      s = mock("GitHub::Commands::Shell")
+      s.should_receive(:run).once.and_return("sha1")
+      s
+    end
+    @command.pgit("rev-parse master")
+  end
+
+  it "should exec a git command" do
+    @command.should_receive(:exec).with("git rev-parse master").once
+    @command.git_exec "rev-parse master"
+  end
+
+  it "should die" do
+    @command.should_receive(:puts).once.with("=> message")
+    @command.should_receive(:exit!).once
+    @command.die "message"
+  end
+end

data/spec/extensions_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe "When calling #try" do
+  specify "objects should return themselves" do
+    obj = 1; obj.try.should equal(obj)
+    obj = "foo"; obj.try.should equal(obj)
+    obj = { :foo => "bar" }; obj.try.should equal(obj)
+  end
+
+  specify "objects should behave as if #try wasn't called" do
+    "foo".try.size.should == 3
+    { :foo => :bar }.try.fetch(:foo).should == :bar
+    [1, 2, 3].try.map { |x| x + 1 }.should == [2, 3, 4]
+  end
+
+  specify "nil should return the singleton NilClass::NilProxy" do
+    nil.try.should equal(NilClass::NilProxy)
+  end
+
+  specify "nil should ignore any calls made past #try" do
+    nil.try.size.should equal(NilClass::NilProxy)
+    nil.try.sdlfj.should equal(NilClass::NilProxy)
+    nil.try.one.two.three.should equal(NilClass::NilProxy)
+  end
+
+  specify "classes should respond just like objects" do
+    String.try.should equal(String)
+  end
+end
+
+describe "When calling #tap" do
+  specify "objects should behave like Ruby 1.9's #tap" do
+    obj = "foo"
+    obj.tap { |obj| obj.size.should == 3 }.should equal(obj)
+  end
+end