hubeye 0.0.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 by Luke Gruber
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,74 @@
+#Hubeye
+
+Hubeye is composed of a client and server. Once the server is run,
+you can connect to it via the client. Once connected, you'll be
+prompted by a '>'. Type the name of a Github repository. 
+
+Example: (what the user enters is preceded by the prompt)
+
+    >hubeye
+    commit  77b82b54044c16751228
+    tree    8ce18af1461b5c741003
+    parent  ea63fe317fe58dff1c95
+    log tracking info for repos on client quit  => luke-gru
+
+What you see is the latest commit reference, tree reference and parent 
+commit reference on Github for that repository. Note that the user did 
+not type a username. This is because the user defined a username in his
+~/.hubeyerc file.
+
+###~/.hubeyerc
+
+    username = luke-gru
+
+This allows the user to type the repository name only, and to receive
+information regarding that user's repository. The username must be a 
+valid Github username.
+
+###Keeping track of repositories
+
+Hubeye doesn't actually track any repositories unless you disconnect
+from the server and leave the server running. This can be done by:
+
+    >quit
+    Bye!
+
+If Hubeye has any repos to watch, it will watch Github for changes.
+It can keep track of as many repos as you want; just keep typing
+them in. If Hubeye finds a change in a repo, it will tell you that the
+repo has changed in the terminal where the server is running. Also, next
+time you connect to the server via the client, it will remind you. 
+Hubeye does not remove a repo from the watch list unless explicitly 
+told to do so.
+
+    >rm luke-gru/hubeye
+
+this removes luke-gru's hubeye repo from the watch list. You can also
+add another user's repo like this:
+
+    >rails/rails
+
+This adds https://github.com/rails/rails to the watch list.
+
+###Shutting down
+    
+    >shutdown
+
+Next time you start up the server, the watch list is empty.
+In order to have a default watch list:
+
+~/.hubeyerc
+
+    default = rails/rails | dchelimsky/rspec
+
+These will be watched automatically when starting up the server
+
+###All ~/.hubeyerc configurations
+
+    username = luke-gru
+    default = username/reponame | username2/reponame2 | myreponame
+    oncearound = 90
+
+oncearound: number of seconds before completing a check of every repo in
+the watch list for changes
+

data/Rakefile

@@ -0,0 +1,34 @@
+task :install => :chmod do
+  puts "Done"
+end
+
+task :chmod => :makelog do
+  binfile = File.join(File.dirname(__FILE__), "/bin/hubeye")
+  chmod 0777, binfile unless File.executable?(binfile)
+end
+
+task :makelog => :config_file do
+  hublog_dir  =  ENV['HOME'] + "/hublog"
+  mkdir(hublog_dir) unless File.exists?(hublog_dir)
+
+  hooks_dir = hublog_dir + "/hooks"
+  mkdir(hooks_dir) unless File.exists?(hooks_dir)
+
+  repos_dir = hublog_dir + "/repos"
+  mkdir(repos_dir) unless File.exists?(repos_dir)
+
+  hublog_file =  File.join(ENV['HOME'], "/hublog/hublog")
+  touch hublog_file unless File.exists?(hublog_file)
+end
+
+task :config_file do
+  config_file = File.join(ENV['HOME'], ".hubeyerc")
+  touch config_file unless File.exists? config_file
+end
+
+task :config_file => :message
+
+task :message do
+  puts "Installing Hubeye..."
+end
+

data/VERSION.rb

@@ -0,0 +1,5 @@
+#/* vim: set ft=ruby :*/
+class Hubeye
+  VERSION = [0,0,1]
+end
+

data/bin/hubeye

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+# require environment and VERSION files
+require File.join(File.expand_path(File.dirname(__FILE__) + "/../"), "lib/environment")
+require File.expand_path(File.dirname(__FILE__) + "/../VERSION")
+
+# standard lib
+require 'optparse'
+require 'ostruct'
+
+# vendor
+unless RUBY_VERSION >= '1.9'
+  begin
+    require 'daemons'
+  rescue
+    require 'rubygems'
+    retry
+  else
+    RuntimeError.new "The daemons gem is needed to run hubeye as a daemon " +
+                     "on Ruby < 1.9"
+  end
+end
+
+class Options
+  def self.parse(args)
+
+    # defaults
+    options = OpenStruct.new
+    options.server_wanted = true
+    options.client_wanted = false
+    options.server_daemonized = true
+    options.port = 2000
+    options.host = 'localhost'
+
+    opts_saved = OptionParser.new do |opts|
+      opts.banner = "Usage: hubeye [options]"
+      opts.separator ""
+      opts.separator "Specific options:"
+      opts.separator "Note: The default port (for server and client) is 2000"
+
+      opts.on("-s", "--server", "Start the server (default: daemonized process)") do
+        options.client_wanted = false
+        options.server_wanted = true
+      end
+
+      opts.on("-t", "--top", "Run server as non-daemonized (output to term)") do
+        options.server_daemonized = false
+      end
+
+      opts.on("-o", "--host HOST", "Host that the client connects to. Default: 'localhost'") do |h|
+        options.host = h
+      end
+
+      opts.on("-p", "--port PORT", "Port that the server runs on / client connects to") do |p|
+        options.port = p.to_i
+      end
+
+      opts.on("-c", "--client", "Start hubeye client to interact with server.") do
+        options.server_wanted = false
+        options.client_wanted = true
+      end
+
+      opts.on_tail("-v", "--version", "Show hubeye version") do
+        puts Hubeye::VERSION.join('.')
+        exit
+      end
+
+      opts.on_tail("-h", "--help", "Show this message") do
+        puts opts
+        exit
+      end
+    end
+
+    opts_saved.parse!(args)
+    options
+  end # end of Options::parse
+
+end # end of class
+
+
+class Hubeye
+  class << self
+
+    def start
+      options = Options.parse(ARGV)
+      host = options.host
+      port = options.port
+      daemonized = options.server_daemonized
+      if options.server_wanted
+        unless port_open?(port)
+          puts "Other instances are running"
+          exit 1
+        end
+        require File.join(Environment::LIBDIR, '/server/hubeye_server.rb')
+        options.server_daemonized ? start_server(port, :daemon => true) : start_server(port, :daemon => false)
+      else
+        require File.join(Environment::LIBDIR, '/client/hubeye_client.rb')
+        start_client(host, port)
+      end
+    end
+
+
+    def port_open?(port)
+      # this is the solution until multi-threading is implemented
+      # on the TCP server
+      listening_tcps = `netstat -l --tcp --numeric`
+      if /#{port}/ =~ listening_tcps
+        return false
+      end
+      true
+    end
+
+
+    def start_server(port, options={})
+      server = HubeyeServer.new(true) # debug: true
+      if options[:daemon]
+        Process.daemon(true) # don't change dir to '/'
+      end
+      server.start(port, options)
+    end
+
+    # client connection defaults to localhost:2000
+    def start_client(host, port)
+      client = HubeyeClient.new
+      client.start(host, port)
+    end
+
+  end
+end
+
+Hubeye.start
+

data/lib/client/hubeye_client.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+require 'socket'
+
+class HubeyeClient
+
+  def start(host, port)
+    connect(host, port)
+    read_welcome()
+    interact()
+  end
+
+  def _begin
+    begin
+      yield
+    rescue
+      puts $!                 # Display the exception to the user
+    end
+  end
+
+  def connect(host, port)
+    _begin do
+      # Give the user some feedback while connecting.
+      STDOUT.print "Connecting..."      # Say what we're doing
+      STDOUT.flush            # Make it visible right away
+      @s = TCPSocket.open(host, port)    # Connect
+      STDOUT.puts "Done" if @s
+
+      # Now display information about the connection.
+      local, peer = @s.addr, @s.peeraddr
+
+      STDOUT.print "Connected to #{peer[2]}:#{peer[1]}"
+      STDOUT.puts " using local port #{local[1]}"
+    end
+  end
+
+  def read_welcome
+    # Wait just a bit, to see if the server sends any initial message.
+    begin
+      sleep(0.5)            # Wait half a second
+      msg = @s.readpartial(4096)     # Read whatever is ready
+      STDOUT.puts msg.chop      # And display it
+    # If nothing was ready to read, just ignore the exception.
+    rescue SystemCallError
+    rescue NoMethodError
+      STDOUT.puts "The server's not running!"
+    end
+  end
+
+    # Now begin a loop of client/server interaction.
+  def interact
+    while @s
+      loop do
+        STDOUT.print '> '           # Display prompt for local input
+        STDOUT.flush          # Make sure the prompt is visible
+        local = STDIN.gets        # Read line from the console
+        #break if !local             # Quit if no input from console
+        if local.match(/^\.$/) #pwd
+          @s.puts(local.gsub(/\A\.\Z/, "pwd" + Dir.pwd.split('/').last))    # Send the line to the server, daemons gem strips some special chars (/, :)
+        else
+          @s.puts(local.gsub(/\//, 'diiv'))
+        end
+        @s.flush               # Force it out
+        # Read the server's response and print out.
+        # The server may send more than one line, so use readpartial
+        # to read whatever it sends (as long as it all arrives in one chunk).
+
+        sleep 0.5
+        begin
+          response = @s.readpartial(4096)
+        rescue EOFError
+          response = "Bye!"
+        end
+
+        if response.chop.strip == "Bye!"
+          puts(response.chop)
+          @s.close
+          exit
+        elsif response.chop.strip.match(/shutting/i)
+          @s.close
+          exit
+        else
+          puts(response.chop)         # Display response to user
+          next
+        end
+      end
+    end
+  end
+
+end #end of class
+

data/lib/environment.rb

@@ -0,0 +1,10 @@
+module Environment
+
+ROOTDIR = File.join(File.dirname(__FILE__), "..")
+
+LIBDIR = File.join(ROOTDIR, "lib")
+BINDIR = File.join(ROOTDIR, "bin")
+
+$:.unshift(LIBDIR) unless $:.include? LIBDIR
+
+end

data/lib/hooks/executer.rb

@@ -0,0 +1,30 @@
+module Hooks
+  class Command
+
+    class NoHookError < ArgumentError; end
+
+      #options include the directory to execute the command
+      #(that's it for now, will add more functionality later)
+      def self.execute(commands=[], options={})
+        opts = {:directory => nil, :repo => nil}.merge(options)
+        dir  = opts[:directory]
+        repo = opts[:repo]
+        begin
+
+        commands.each do |cmd|
+          if dir
+            Dir.chdir(File.expand_path(dir)) do
+              ::Kernel.system cmd
+            end
+          else
+            ::Kernel.system cmd
+          end
+        end
+
+        rescue ArgumentError
+          raise NoHookError.new "There aren't any hook commands for the repository #{repo}"
+        end
+      end
+
+  end
+end

data/lib/hooks/git_hooks.rb

@@ -0,0 +1,25 @@
+module Hooks
+  module Git
+
+    module Default
+
+      def self.fetch(local_reponame, remotename, branchname)
+        #first, start a process to cd to the local repo
+        #then fetch the remote
+        Dir.chdir(File.expand_path(local_reponame)) do
+          ::Kernel.system("git fetch #{remotename} #{branchname}")
+        end
+      end
+
+      def self.pull(local_reponame, remotename, branchname)
+        #first, start a process to cd to the local repo
+        #then pull the remote
+        Dir.chdir(File.expand_path(local_reponame)) do
+          ::Kernel.system("git pull #{remotename} #{branchname}")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/log/logger.rb

@@ -0,0 +1,39 @@
+class Logger
+
+  def self.log(msg)
+    File.open(ENV['HOME'] + "/hublog" * 2, "a") do |f|
+      f.puts(msg)
+    end
+  end
+
+  def self.relog(msg)
+    #wipe the file and start anew
+    File.open(ENV['HOME'] + "/hublog" * 2, "w") do |f|
+      f.puts(msg)
+    end
+  end
+
+  ##If {include_socket: true} is passed, then log to the client as well. If
+  #{include_terminal: true}, log to the terminal too (make sure that the
+  #process is not daemonized). Always log to the logfile.
+
+  def self.log_change(repo_name, commit_msg, committer, options={})
+    opts = {:include_socket => false, :include_terminal => false}.merge options
+    change_msg = <<-MSG
+    ===============================
+    Repository: #{repo_name.downcase.strip} has changed (#{Time.now.strftime("%m/%d/%Y at %I:%M%p")})
+    Commit msg: #{commit_msg}
+    Committer : #{committer}
+    ===============================
+    MSG
+    if opts[:include_socket]
+      socket.puts(change_msg)
+    end
+
+    if opts[:include_terminal]
+      puts change_msg
+    end
+    Logger.log(change_msg)
+  end
+
+end

data/lib/notification/gnomenotify.rb

@@ -0,0 +1,11 @@
+module Autotest::GnomeNotify
+
+  EXPIRATION_IN_SECONDS = 2
+  CHANGE_ICON = File.join(File.expand_path("images", ::Environment::ROOTDIR), "change_icon.jpg")
+
+  def self.notify(title, msg, img=CHANGE_ICON)
+    options = "-t #{EXPIRATION_IN_SECONDS * 1000} -i #{img}"
+    system "notify-send #{options} '#{title}' '#{msg}'"
+  end
+
+end

data/lib/notification/growl.rb

@@ -0,0 +1,11 @@
+module Autotest::Growl
+
+  EXPIRATION_IN_SECONDS = 2
+  dir =  File.dirname(__FILE__)
+  CHANGE_ICON = File.expand_path(dir + "/../images/change_icon.jpg")
+
+  def self.growl(title, msg, img=CHANGE_ICON, pri=0, stick="")
+    system "growlnotify  -n autotest --image #{img} -p #{pri} -m #{msg.inspect} #{title} #{stick}"
+  end
+
+end

data/lib/notification/notification.rb

@@ -0,0 +1,73 @@
+module Notification
+
+  class Finder
+
+    def self.find_notify
+      if RUBY_PLATFORM =~ /mswin/
+        return
+      elsif RUBY_PLATFORM =~ /linux/
+        libnotify = system('locate libnotify-bin > /dev/null')
+
+        if libnotify && LibChecker.autotest
+          require_relative "gnomenotify"
+          return "libnotify"
+        elsif LibChecker.autotest_notification
+          require_relative "growl"
+          return "growl"
+        else
+          return
+        end
+
+      elsif RUBY_PLATFORM =~ /darwin/i
+
+        if LibChecker.autotest_notification
+        require_relative "growl"
+        return "growl"
+        else
+          return
+        end
+
+      end
+    end
+
+  end
+
+  class LibChecker
+
+    class << self
+      def autotest
+        begin
+          require 'autotest'
+        rescue LoadError
+          if require 'rubygems'
+            retry
+          else
+            return
+          end
+        end
+        if defined? Autotest
+          return true
+        end
+      end
+
+
+      def autotest_notification
+        begin
+          require 'autotest_notification'
+        rescue LoadError
+          if require 'rubygems'
+            retry
+          else
+            return
+          end
+        end
+        if defined? Autotest
+          return true
+        end
+      end
+    end
+
+  end
+
+end # end module
+

data/lib/server/hubeye_server.rb

@@ -0,0 +1,634 @@
+module Server
+  # standard lib.
+  require 'socket'
+  require 'open-uri'
+  require 'yaml'
+
+  # vendor
+  begin
+    require 'nokogiri'
+  rescue LoadError
+    if require 'rubygems'
+      retry
+    else
+      abort 'Nokogiri is needed to run hubeye. Gem install nokogiri'
+    end
+  end
+
+  # hubeye
+  require "notification/notification"
+  require "log/logger"
+  require "timehelper/timehelper"
+  require "hooks/git_hooks"
+  require "hooks/executer"
+
+  # ONCEAROUND: 30 (seconds) is the default amount of time for looking
+  # for changes in every single repository. If tracking lots of repos,
+  # it might be a good idea to increase the value, or hubeye will cry
+  # due to overwork, fatigue and general anhedonia.
+  ONCEAROUND = 30
+  # USERNAME: defined in ~/.hubeyerc
+  USERNAME = 'luke-gru'
+  # find Desktop notification system
+  DESKTOP_NOTIFICATION = Notification::Finder.find_notify
+
+  class InputError < StandardError; end
+
+  def start(port, options={})
+    listen(port)
+    setup_env(options)
+    loop do
+      catch(:next) do
+      not_connected() unless @remote_connection
+      get_input(@socket)
+      puts @input if @debug
+      parse_input()
+      get_github_doc("/#{@username}/#{@repo_name}")
+      parse_doc()
+      @username = USERNAME
+      end
+    end
+  end
+
+  # Listen on port (2000 is the default)
+  def listen(port)
+    @server = TCPServer.open(port)
+  end
+
+
+  def setup_env(options={})
+    @daemonized = options[:daemon]
+    @sockets = [@server]  # An array of sockets we'll monitor
+    @ary_commits_repos = []
+    @hubeye_tracker = []
+    # @username changes if input includes a '/' when removing, adding tracked
+    # repos.
+    @username = 'luke-gru'
+    @remote_connection = false
+  end
+
+
+  def not_connected
+    # if no client is connected, but the commits array contains repos
+    if @sockets.size == 1 and @ary_commits_repos.empty? == false
+
+      while @remote_connection == false
+        @hubeye_tracker.each do |repo|
+          doc = Nokogiri::HTML(open("https://github.com/#{repo}/"))
+
+          # make variable not block-local
+          commit_msg = nil
+
+          doc.xpath('//div[@class = "message"]/pre').each do |node|
+            commit_msg = node.text
+            if @ary_commits_repos.include?(commit_msg)
+              ONCEAROUND.times do
+                sleep 1
+                @remote_connection = client_ready(@sockets) ? true : false
+                break if @remote_connection
+              end
+            else
+              # There was a change to a tracked repository.
+
+              # make variable not block-local
+              committer = nil
+
+              doc.xpath('//div[@class = "actor"]/div[@class = "name"]').each do |node|
+                committer = node.text
+              end
+
+              # notify of change to repository
+              # if they have a Desktop notification
+              # library installed
+              change_msg = "Repo #{repo} has changed\nNew commit: #{commit_msg} => #{committer}"
+              case DESKTOP_NOTIFICATION
+              when "libnotify"
+                Autotest::GnomeNotify.notify("Hubeye", change_msg)
+                Logger.log_change(repo, commit_msg, committer)
+              when "growl"
+                Autotest::Growl.growl("Hubeye", change_msg)
+                Logger.log_change(repo, commit_msg, committer)
+              when nil
+
+                if @daemonized
+                  Logger.log_change(repo, commit_msg, committer)
+                else
+                  Logger.log_change(repo, commit_msg, committer, :include_terminal => true)
+                end
+
+              end
+              # execute any hooks for that repository
+              unless @hook_cmds.nil? || @hook_cmds.empty?
+                if @hook_cmds[repo]
+                  hook_cmds = @hook_cmds[repo].dup
+                  dir = (hook_cmds.include?('/') ? hook_cmds.shift : nil)
+
+                  # execute() takes [commands], {options} where
+                  # options = :directory and :repo
+                  Hooks::Command.execute(hook_cmds, :directory => dir, :repo => repo)
+                end
+              end
+
+              @ary_commits_repos << repo
+              @ary_commits_repos << commit_msg
+              # delete the repo and old commit that appear first in the array
+              index_old_HEAD = @ary_commits_repos.index(repo)
+              @ary_commits_repos.delete_at(index_old_HEAD)
+              # and again to get rid of the commit message
+              @ary_commits_repos.delete_at(index_old_HEAD)
+            end
+          end
+        end
+        redo unless @remote_connection
+      end # end of (while remote_connection == false)
+    end
+    client_connect(@sockets)
+  end
+
+
+  def client_ready(sockets)
+    select(sockets, nil, nil, 2)
+  end
+  private :client_ready
+
+
+  def client_connect(sockets)
+    ready = select(sockets)
+    readable = ready[0]            # These sockets are readable
+    readable.each do |socket|      # Loop through readable sockets
+      if socket == @server         # If the server socket is ready
+        client = @server.accept    # Accept a new client
+        @socket = client           # From here on in referred to as @socket
+        sockets << @socket         # Add it to the set of sockets
+        # Inform the client of connection
+        if !@hubeye_tracker.empty?
+          @socket.puts "Hubeye running on #{Socket.gethostname}\nTracking:#{@hubeye_tracker.join(' ')}"
+        else
+          @socket.puts "Hubeye running on #{Socket.gethostname}"
+        end
+
+        if !@daemonized
+          puts "Client connected at #{::TimeHelper::NOW}"
+        end
+
+        @socket.flush
+        # And log the fact that the client connected
+        if @still_logging == true
+          # if the client quit, do not wipe the log file
+          Logger.log "Accepted connection from #{@socket.peeraddr[2]} (#{::TimeHelper::NOW})"
+        else
+          # wipe the log file and start anew
+          Logger.relog "Accepted connection from #{@socket.peeraddr[2]} (#{::TimeHelper::NOW})"
+        end
+        Logger.log "local:  #{@socket.addr}"
+        Logger.log "peer :  #{@socket.peeraddr}"
+      end
+    end
+  end
+
+
+  def get_input(socket)
+    @input = socket.gets  # Read input from the client
+    @input.chop! unless @input.nil?  # Trim client's input
+    # If no input, the client has disconnected
+    if !@input
+      Logger.log "Client on #{socket.peeraddr[2]} disconnected."
+      @sockets.delete(socket)  # Stop monitoring this socket
+      socket.close  # Close it
+      throw(:next)  # And go on to the next
+    end
+  end
+  private :get_input
+
+
+  def parse_input
+    @input.strip!; @input.downcase!
+    if parse_quit()
+    elsif parse_shutdown()
+    elsif save_hooks_or_repos()
+    elsif load_hooks_or_repos()
+    # parse_hook must be before parse_fullpath_add for the moment
+    elsif parse_hook()
+    elsif hook_list()
+    elsif tracking_list()
+    elsif parse_pwd()
+    elsif parse_empty()
+    elsif parse_remove()
+    elsif parse_fullpath_add()
+    elsif parse_add()
+    else
+      raise InputError "Invalid input #{@input}"
+    end
+  end
+
+
+  def parse_quit
+    if @input =~ /\Aquit|exit\Z/  # If the client asks to quit
+      @socket.puts("Bye!")  # Say goodbye
+      Logger.log "Closing connection to #{@socket.peeraddr[2]}"
+      @remote_connection = false
+      if !@ary_commits_repos.empty?
+        Logger.log "Tracking: "
+        @ary_commits_repos.each do |repo|
+          Logger.log repo if @ary_commits_repos.index(repo).even?
+        end
+      end
+      Logger.log "" # to look pretty when multiple connections per loop
+      @sockets.delete(@socket)  # Stop monitoring the socket
+      @socket.close  # Terminate the session
+      # still_logging makes the server not wipe the log file
+      @still_logging = true
+    else
+      return
+    end
+    throw(:next)
+  end
+
+
+  def parse_shutdown
+    if @input == "shutdown"
+      # local
+      Logger.log "Closing connection to #{@socket.peeraddr[2]}"
+      Logger.log "Shutting down... (#{::TimeHelper::NOW})"
+      Logger.log ""
+      Logger.log ""
+      # peer
+      @socket.puts("Shutting down server")
+    else
+      return
+    end
+    shutdown()
+  end
+
+
+  def shutdown
+    @sockets.delete(@socket)
+    @socket.close
+    exit
+  end
+
+
+  def parse_hook
+    if %r{githook add} =~ @input
+      githook_add()
+    else
+      return
+    end
+  end
+
+
+  ##
+  # @hook_cmds:
+  # repo is the key, value is array of directory and commands. First element
+  # of array is the local directory for that remote repo, rest are commands
+  # related to hooks called on change of commit message (with plans to change
+  # that to commit SHA reference) of the remote repo
+  def githook_add
+    @input.gsub!(/diiv/, '/')
+    # make match-$globals parse input
+    @input =~ /add ([^\/]+\/\w+) (dir: (\S*) )?cmd: (.*)\Z/
+    @hook_cmds ||= {}
+    if $1 != nil && $4 != nil
+      if @hook_cmds[$1]
+        @hook_cmds[$1] << $4
+      elsif $2 != nil
+        @hook_cmds[$1] = [$3, $4]
+      else
+        @hook_cmds[$1] = [$4]
+      end
+      @socket.puts("Hook added")
+    else
+      @socket.puts("Format: 'githook add user/repo [dir: /my/dir/repo ] cmd: git pull origin'")
+    end
+    throw(:next)
+  end
+  private :githook_add
+
+
+  def save_hooks_or_repos
+    if @input =~ %r{\A\s*save hook(s?) as (.+)\Z}
+      if !@hook_cmds.nil? && !@hook_cmds.empty?
+        File.open("#{ENV['HOME']}/hublog/hooks/#{$2}.yml", "w") do |f_out|
+          ::YAML.dump(@hook_cmds, f_out)
+        end
+        @socket.puts("Saved hook#{$1} as #{$2}")
+      else
+        @socket.puts("No hook#{$1} to save")
+      end
+      throw(:next)
+    elsif @input =~ %r{\A\s*save repo(s?) as (.+)\Z}
+      if !@hubeye_tracker.empty?
+        File.open("#{ENV['HOME']}/hublog/repos/#{$2}.yml", "w") do |f_out|
+          ::YAML.dump(@hubeye_tracker, f_out)
+        end
+        @socket.puts("Saved repo#{$1} as #{$2}")
+      else
+        @socket.puts("No remote repos are being tracked")
+      end
+      throw(:next)
+    else
+      return
+    end
+  end
+
+
+  def load_hooks_or_repos
+    if @input =~ %r{\A\s*load hook(s?) (.+)\Z}
+      hookfile = "#{ENV['HOME']}/hublog/hooks/#{$2}.yml"
+
+      # establish non block-local scope
+      newhooks = nil
+
+      if File.exists?(hookfile)
+        File.open(hookfile) do |f|
+          newhooks = ::YAML.load(f)
+        end
+        @hook_cmds ||= {}
+        @hook_cmds = newhooks.merge(@hook_cmds)
+        @socket.puts("Loaded #{$1} #{$2}")
+      else
+        @socket.puts("No #{$1} file to load from")
+      end
+      throw(:next)
+    elsif @input =~ %r{\A\s*load repo(s)? (.+)\Z}
+      if File.exists? repo_file = "#{ENV['HOME']}/hublog/repos/#{$2}.yml"
+        newrepos = nil
+        File.open(repo_file) do |f|
+          newrepos = ::YAML.load(f)
+        end
+
+        if !newrepos
+          @socket.puts "Unable to load #{$2}: empty file"
+          throw(:next)
+        end
+        # newrepos is an array of repos to be tracked
+        newrepos.each do |e|
+          # append the repo and the newest commit message to the repos and
+          # commit messages array, then inform the client of the newest
+          # commit message
+          commit_msg = get_commit_msg(e)
+          # if the commit_msg is non-false, don't do anything, otherwise 'next'
+          commit_msg ? nil : next
+          @ary_commits_repos << e << commit_msg
+          # and append the repo to the hubeye_tracker array
+          @hubeye_tracker << e
+        end
+        @ary_commits_repos.uniq!
+        @hubeye_tracker.uniq!
+
+        @socket.puts "Loaded #{$2}.\nTracking:\n#{show_repos_pretty()}"
+      else
+        # no repo file with that name
+        @socket.puts("No file to load from")
+      end
+      throw(:next)
+    end
+    return
+  end
+
+
+  # helper method to get commit message for a
+  # single repo
+  def get_commit_msg(remote_repo)
+    begin
+      @doc = Nokogiri::HTML(open("https://github.com#{'/' + remote_repo}"))
+    rescue
+      return nil
+    end
+    # returns the commit message
+    commit_msg = parse_msg(@doc)
+  end
+
+
+  def show_repos_pretty
+    pretty_repos = ""
+    @ary_commits_repos.each do |e|
+      if @ary_commits_repos.index(e).even?
+        pretty_repos += e + "\n"
+      else
+        pretty_repos += "  " + e + "\n"
+      end
+    end
+    pretty_repos
+  end
+
+
+  def hook_list
+    if @input =~ %r{hook list}
+      unless @hook_cmds.nil? || @hook_cmds.empty?
+        @hook_cmds.each do |repo, ary|
+          remote = repo
+          if ary.first.include? '/'
+            local = ary.first
+            cmds  = ary[1..-1]
+          else
+            cmds = ary
+            local = "N/A"
+          end
+          format_string = <<-EOS
+remote: #{remote}
+  dir : #{local}
+  cmds: #{cmds.each {|cmd| print cmd + ' ' }} \n
+           EOS
+        end
+        @socket.puts(format_string)
+        @socketspoke = true
+      end
+    else
+      return
+    end
+    @socket.puts("No hooks") unless @socketspoke
+    @socketspoke = nil
+    throw(:next)
+  end
+
+
+  # show the client what repos (with commit messages)
+  # they're tracking
+  def tracking_list
+    if @input =~ /\Atracking\s*\Z/
+      list = show_repos_pretty
+      @socket.puts(list)
+      throw(:next)
+    else
+      return
+    end
+  end
+
+
+  # This means the user pressed '.' in the client,
+  # wanting to track the pwd repo. The period is replaced
+  # by 'pwd' in the client application and sent to @input because of
+  # problems with the period getting stripped in TCP transit. The name
+  # of the client's present working directory comes right after the 'pwd'.
+  # Typing '.' in the client only works (ie: begins tracking the remote repo)
+  # if the root directory of the git repository has the same name as one of
+  # the user's github repositories.
+  def parse_pwd
+    if @input.match(/^pwd/)
+      @repo_name = @input[3..-1]
+    else
+      return
+    end
+    return true
+  end
+
+
+  def parse_empty
+    if @input == ''
+      @socket.puts("")
+      throw(:next)
+    else
+      return
+    end
+  end
+
+
+  # Like the method parse_pwd, in which the client application replaces
+  # the '.' with 'pwd' and sends that to this server instead, parse_remove
+  # does pretty much the same thing with '/'. This is because of the slash
+  # getting stripped in TCP transit. Here, the slash is replaced with 'diiv',
+  # as this is unlikely to be included anywhere in a real username/repository
+  # combination (or is it... duh duh DUUUUHH)
+  # p.s. no it isn't
+  def parse_remove
+    if %r{\Arm ([\w-](diiv)?[\w-]*)\Z} =~ @input
+      if $1.include?("diiv")
+        @username, @repo_name = $1.split('diiv')
+      else
+        @username, @repo_name = "#{@username}/#{$1}".split('/')
+      end
+
+      begin
+        index_found = @ary_commits_repos.index("#{@username}/#{@repo_name}")
+        if index_found
+          # consecutive indices in the array
+          for i in 1..2
+            @ary_commits_repos.delete_at(index_found)
+          end
+          @hubeye_tracker.delete("#{@username}/#{@repo_name}")
+          @socket.puts("Stopped watching repository #{@username}/#{@repo_name}")
+          sleep 0.5
+          throw(:next)
+        else
+          @socket.puts("Repository #{@username}/#{@repo_name} not currently being watched")
+          throw(:next)
+        end
+      rescue
+        @socket.puts($!)
+        throw(:next)
+      end
+    else
+      return
+    end
+  end
+
+
+  def parse_fullpath_add
+    if @input.include?('diiv')
+      # includes a '/', such as rails/rails, but in the adding to tracker context
+      @username, @repo_name = @input.split('diiv')
+    else
+      return
+    end
+    return true
+  end
+
+
+  # if the input is not the above special scenarios
+  def parse_add
+    @repo_name = @input
+  end
+
+
+  def get_github_doc(full_repo_path)
+    begin
+      # if adding a repo with another username
+      @doc = Nokogiri::HTML(open("https://github.com#{full_repo_path}"))
+    rescue OpenURI::HTTPError
+      @socket.puts("Not a Github repository!")
+      throw(:next)
+    rescue URI::InvalidURIError
+      @socket.puts("Not a valid URI")
+      throw(:next)
+    end
+  end
+
+
+  def parse_doc
+    # get commit msg
+    @commit_msg = parse_msg(@doc)
+    # get committer
+    @committer = parse_committer()
+
+    # new repo to track
+    full_repo_name = "#{@username}/#{@repo_name}"
+    if !@ary_commits_repos.include?(full_repo_name)
+      @ary_commits_repos << full_repo_name
+      @hubeye_tracker << full_repo_name
+      @ary_commits_repos << @commit_msg
+      # get commit info
+      @info = parse_info()
+      @msg =  "#{@commit_msg} => #{@committer}".gsub(/\(author\)/, '')
+      # log the fact that the user added a repo to be tracked
+      Logger.log("Added to tracker: #{@ary_commits_repos[-2]} (#{::TimeHelper::NOW})")
+      # show the user, via the client, the info and commit msg for the commit
+      @socket.puts("#{@info}\n#{@msg}")
+
+    # new commit to tracked repo
+    elsif !@ary_commits_repos.include?(@commit_msg)
+      begin
+        index_of_msg = @ary_commits_repos.index(@username + "/" + @repo_name) + 1
+        @ary_commits_repos.delete_at(index_of_msg)
+        @ary_commits_repos.insert(index_of_msg - 1, @commit_msg)
+
+        # log to the logfile and tell the client
+        if @daemonized
+          Logger.log_change(@repo_name, @commit_msg, @committer,
+                            :include_socket => true)
+        else
+          Logger.log_change(@repo_name, @commit_msg, @committer,
+                            :include_socket => true, :include_terminal => true)
+        end
+      rescue
+        @socket.puts($!)
+      end
+    else
+      # no change to the tracked repo
+      @socket.puts("Repository #{@repo_name} has not changed")
+    end
+  end
+
+
+  def parse_msg(html_doc)
+    # get commit msg
+    html_doc.xpath('//div[@class = "message"]/pre').each do |node|
+      return commit_msg = node.text
+    end
+  end
+
+
+  def parse_committer
+    @doc.xpath('//div[@class = "actor"]/div[@class = "name"]').each do |node|
+      return committer = node.text
+    end
+  end
+
+
+  def parse_info
+    @doc.xpath('//div[@class = "machine"]').each do |node|
+      return info =  node.text.gsub(/\n/, '').gsub(/tree/, "\ntree").gsub(/parent.*?(\w)/, "\nparent  \\1").strip!
+    end
+  end
+
+end # of Server module
+
+class HubeyeServer
+  include Server
+
+  def initialize(debug=false)
+    @debug = debug
+  end
+
+end
+

data/lib/timehelper/timehelper.rb

@@ -0,0 +1,3 @@
+module TimeHelper
+  NOW = Time.now.strftime("%m/%d/%Y at %I:%M%p")
+end

data/test/notification.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), "/../lib/notification/notification")
+
+class NotifyTests < Test::Unit::TestCase
+
+  def test_libnotify_on_linux
+    if RUBY_PLATFORM =~ /linux/i
+    assert_equal "libnotify", ::Notification::Finder.find_notify
+    end
+  end
+
+  def test_growl_returns_on_darwin
+    if RUBY_PLATFORM =~ /darwin/i
+    assert_equal "growl", ::Notification::Finder.find_notify
+    end
+  end
+
+end

data/test/test.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'test/unit'
+require_relative "notification"
+require File.join(File.dirname(__FILE__), "/../lib/environment")

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: hubeye
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Luke Gruber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-31 00:00:00.000000000 -04:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &69555570 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *69555570
+description: Github repository commit watcher -- keep your eye on new commits from
+  multiple repos through an interactive CLI
+email: luke.gru@gmail.com
+executables:
+- hubeye
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/client/hubeye_client.rb
+- lib/notification/growl.rb
+- lib/notification/gnomenotify.rb
+- lib/notification/notification.rb
+- lib/timehelper/timehelper.rb
+- lib/server/hubeye_server.rb
+- lib/hooks/executer.rb
+- lib/hooks/git_hooks.rb
+- lib/log/logger.rb
+- lib/environment.rb
+- bin/hubeye
+- Rakefile
+- README.md
+- VERSION.rb
+- LICENSE
+- test/test.rb
+- test/notification.rb
+has_rdoc: true
+homepage: 
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Github repository commit watcher -- keep your eye on new commits from multiple
+  repos through an interactive CLI
+test_files: []