hubeye 0.1.0 → 0.2.5

data/lib/server/hubeye_server.rb

@@ -1,764 +1,752 @@
-module Server
-  # standard lib.
-  require 'socket'
-  require 'yaml'
-
-  # vendor
-  begin
-    require 'octopi'
-  rescue LoadError
-    if require 'rubygems'
-      retry
-    else
-      abort 'Octopi is needed to run hubeye. Gem install octopi'
+class Hubeye
+
+  # simple interface to Github's api v3 for commits
+  class Commit
+    attr_reader :raw_input, :repo, :only_sha, :latest
+    def initialize(input)
+      @raw_input = input
+      @repo = input.keys.first
+      if Hash === input
+        if input[@repo].keys == ["sha"]
+          @only_sha = true
+        else
+          @latest = true
+        end
+      else
+        raise ArgumentError.new "input must be a kind of hash"
+      end
     end
-  end
-  include Octopi
-
-  # hubeye
-  require "config/parser"
-  require "log/logger"
-  require "notification/notification"
-  require "hooks/git_hooks"
-  require "hooks/executer"
-  require "helpers/time"
-  include Helpers::Time
-
-  CONFIG_FILE = ENV['HOME'] + "/.hubeye/hubeyerc"
-  CONFIG = {}
-  # find Desktop notification system
-
-  # CONFIG options: defined in ~/.hubeye/hubeyerc
-  #
-  # Option overview:
-  #
-  # CONFIG[:oncearound]: 60 (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.
-  #
-  # hubeyerc format => oncearound: 1000
-  #
-  # CONFIG[:username] is the username used when not specified.
-  # hubeyerc format => username: 'hansolo'
-  # when set to 'hansolo'
-  # >rails
-  # would track https://www.github.com/hansolo/rails
-  # but a full URI path won't use CONFIG[:username]
-  # >rails/rails
-  # would track https://www.github.com/rails/rails
-  ::Hubeye::Config::Parser.new(CONFIG_FILE) do |c|
-    CONFIG[:username]       = c.username || 'john_doe'
-    CONFIG[:oncearound]     = c.oncearound || 60
-    CONFIG[:load_repos]     = c.load_repos || []
-    CONFIG[:load_hooks]     = c.load_hooks || []
-    CONFIG[:default_track]  = c.default_track || nil
-    # returns true or false if defined in hubeyerc
-    CONFIG[:notification_wanted] = case c.notification_wanted
-                          when false
-                            false
-                          when true
-                            true
-                          when nil
-                            # default is true if not defined in hubeyerc
-                            true
-                          end
-  end
-
-  CONFIG[:desktop_notification] = (CONFIG[:notification_wanted] ?
-                                  Notification::Finder.find_notify : nil)
 
-  class InputError < StandardError; end
+    def sha
+      @sha ||= @raw_input[@repo]['sha']
+    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()
-        parse_doc()
-        @username = CONFIG[:username]
+    def commit_message
+      if @only_sha
+        return
+      elsif @latest
+        @commit_message ||= @raw_input[@repo]['commit']['message']
+      else
+        raise
       end
     end
-  end
 
-  # Listen on port (2000 is the default)
-  def listen(port)
-    @server = TCPServer.open(port)
+    def committer_name
+      if @only_sha
+        return
+      elsif @latest
+        @committer_name ||= @raw_input[@repo]['commit']['committer']['name']
+      else
+        raise
+      end
+    end
   end
 
-
-  def setup_env(options={})
-    @daemonized = options[:daemon]
-    @sockets = [@server]  # An array of sockets we'll monitor
-    if CONFIG[:default_track].nil?
-      # will be array of 2-element arrays that contain the
-      # tracked repo name [0] and hash of latest sha and latest commit object
-      # for that repo [1]
-      # Example:
-      # [ ['luke-gru/hubeye', {:sha1 => 90j93r0rf389, :commit => <#Commit Object>}], [..., ...] ]
-      @hubeye_tracker = []
-    else
-      # default tracking arrays (hubeyerc configurations)
-      @hubeye_tracker = CONFIG[:default_track]
-    end
-    setup_hubeye_singleton_methods
-
-    if CONFIG[:load_hooks].empty?
-      # do nothing (the hooks hash is only assigned when needed)
-    else
-      hooks_ary = CONFIG[:load_hooks].dup
-      load_hooks_or_repos :internal_input => hooks_ary,
-                          :internal_input_hooks => true
+  module Server
+    attr_accessor :remote_connection
+    attr_reader :socket, :sockets, :session, :daemonized
+
+    # standard lib.
+    require 'socket'
+    require 'yaml'
+    require 'json'
+    require 'open-uri'
+    # hubeye
+    require "config/parser"
+    require "log/logger"
+    require "notification/notification"
+    require "hooks/git_hooks"
+    require "hooks/executer"
+    require "helpers/time"
+    include Helpers::Time
+
+    CONFIG_FILE = ENV['HOME'] + "/.hubeye/hubeyerc"
+    CONFIG = {}
+    # find Desktop notification system
+
+    # CONFIG options: defined in ~/.hubeye/hubeyerc
+    #
+    # Option overview:
+    #
+    # CONFIG[:oncearound]: 60 (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.
+    #
+    # hubeyerc format => oncearound: 1000
+    #
+    # CONFIG[:username] is the username used when not specified.
+    # hubeyerc format => username: 'hansolo'
+    # when set to 'hansolo'
+    # >rails
+    # would track https://www.github.com/hansolo/rails
+    # but a full URI path won't use CONFIG[:username]
+    # >rails/rails
+    # would track https://www.github.com/rails/rails
+    Config::Parser.new(CONFIG_FILE) do |c|
+      CONFIG[:username]       = c.username ||
+        `git config --get-regexp github`.split(' ').last
+      CONFIG[:oncearound]     = c.oncearound || 60
+      CONFIG[:load_repos]     = c.load_repos || []
+      CONFIG[:load_hooks]     = c.load_hooks || []
+      CONFIG[:default_track]  = c.default_track || nil
+
+      CONFIG[:notification_wanted] = if c.notification_wanted.nil?
+                                       true
+                                     else
+                                       c.notification_wanted
+                                     end
     end
 
-    if CONFIG[:load_repos].empty?
-      # do nothing
-    else
-      repos_ary = CONFIG[:load_repos].dup
-      load_hooks_or_repos :internal_input => repos_ary,
-                          :internal_input_repos => true
-    end
-    # @username changes if input includes a '/' when removing and adding
-    # tracked repos.
-    @username = CONFIG[:username]
-    @remote_connection = false
-  end
+    CONFIG[:desktop_notification] = Notification::Finder.find_notify if
+    CONFIG[:notification_wanted]
 
-  class ::Array
-    include Octopi
-    class NotTrackerElementError < TypeError ; end
+    class Strategy
+      UnknownStrategy = Class.new(StandardError)
+      attr_reader :server, :input
 
-    def extract_old_and_new
-      if length != 2
-        raise NotTrackerElementError.new "#{self} is not a @hubeye_tracker element"
-      else
-        tracked_repo, tracked_sha = self[0], self[1][:sha1]
-        username, repo_name = tracked_repo.split '/'
-        begin
-          gh_user = User.find(username)
-        rescue Octopi::NotFound
-          # fall back to using default username if not found
-          gh_user = @username
+      def initialize(server, options={})
+        @server = server
+        opts = {:internal_input => nil}.merge options
+        if !opts[:internal_input]
+          @input = server.socket.gets
+          @input.chop!
+        else
+          @input = opts[:internal_input]
         end
-        begin
-          repo = gh_user.repository repo_name
-        rescue Octopi::NotFound
-          raise
+        unless @input
+          Logger.log "Client on #{@server.socket.peeraddr[2]} disconnected."
+          @server.sockets.delete(socket)
+          @server.socket.close
+          return
         end
+        @input = @input.strip.downcase
+        @input.gsub! /diiv/, '/'
       end
-      [tracked_sha, repo]
-    end
-  end
 
-  def setup_hubeye_singleton_methods
-    def_try_append_or_replace!
-    def_eyeing
-    def_rm_repo
-  end
+      STRATEGY_CLASSES = [ "Shutdown", "Exit", "SaveHook", "SaveRepo",
+        "LoadHook", "LoadRepo", "AddHook", "ListHooks", "ListTracking",
+        "Next", "RmRepo", "AddRepo" ]
+
+
+      STRATEGY_CLASSES.each do |klass_str|
+        binding.eval "class #{klass_str}; end"
+        klass = const_get klass_str.intern
+        klass.class_eval do
+          def initialize matches, strategy, options={}
+            @options  = options
+            @matches  = matches
+            @server   = strategy.server
+            @input    = strategy.input
+            @socket   = @server.socket
+            @sockets  = @server.sockets
+            @session  = @server.session
+            call
+          end
+        end
+      end
 
-  def def_try_append_or_replace!
-    @hubeye_tracker.singleton_class.class_eval do
-      define_method :try_append_or_replace! do |repo_name, new_commit_obj|
-        status = {:replace => nil, :add => nil, :same => true}
-        match = nil
-        map! do |e|
-          if e[0] == repo_name
-            match = true
-            if e[1][:sha1] == new_commit_obj.id
-              e
-            else
-              e[1][:sha1]   = new_commit_obj.id
-              e[1][:commit] = new_commit_obj
-              status = status.merge :replace => true, :same => false
+      # strategy classes
+      class Exit
+        def call
+          @socket.puts "Bye!"
+          # mark the session as continuous to not wipe the log file
+          @session.continuous = true
+          Logger.log "Closing connection to #{@socket.peeraddr[2]}"
+          @server.remote_connection = false
+          if !@session.tracker.empty?
+            Logger.log "Tracking: #{@session.tracker.keys.join ', '}"
+          end
+          # to look pretty when multiple connections per loop
+          Logger.log ""
+          @sockets.delete(@socket)
+          @socket.close
+        end
+      end
+
+      class Shutdown
+        def call
+          Logger.log "Closing connection to #{@socket.peeraddr[2]}"
+          Logger.log "Shutting down... (#{::Hubeye::Server::NOW})"
+          Logger.log ""
+          Logger.log ""
+          @socket.puts("Shutting down server")
+          @sockets.delete(@socket)
+          @socket.close
+          unless @server.daemonized
+            STDOUT.puts "Shutdown gracefully."
+          end
+          exit 0
+        end
+      end
+
+      class SaveHook
+        def call
+          hooks = @session.hooks
+          if !hooks.empty?
+            file = "#{ENV['HOME']}/.hubeye/hooks/#{@matches[2]}.yml"
+            if File.exists? file
+              override?
             end
+            File.open(file, "w") do |f_out|
+              ::YAML.dump(hooks, f_out)
+            end
+            @socket.puts("Saved hook#{@matches[1]} as #{@matches[2]}")
           else
-            e
+            @socket.puts("No hook#{@matches[1]} to save")
           end
-        end # end of map!
-        if match
-          return status
-        else
-          self << [repo_name, {:sha1 => new_commit_obj.id,
-                               :commit => new_commit_obj}]
-          return status.merge :add => true, :same => false
+        end
+
+        private
+        def override?
         end
       end
-    end
-  end
 
-  def def_eyeing
-    @hubeye_tracker.singleton_class.class_eval do
-      define_method :eyeing do
-        (ary = []).tap do
-          each do |e|
-            ary << e[0]
+      class SaveRepo
+        def call
+          if !@session.tracker.empty?
+            file = "#{ENV['HOME']}/.hubeye/repos/#{@matches[2]}.yml"
+            if File.exists? file
+              override?
+            end
+            # dump only the repository names, not the shas
+            File.open(file, "w") do |f_out|
+              ::YAML.dump(@session.tracker.keys, f_out)
+            end
+            @socket.puts("Saved repo#{@matches[1]} as #{@matches[2]}")
+          else
+            @socket.puts("No remote repos are being tracked")
           end
         end
-      end
-    end
-  end
 
-  def def_rm_repo
-    @hubeye_tracker.singleton_class.class_eval do
-      define_method :rm_repo do |repo_name|
-        match = nil
-        reject! do |e|
-          e[0] == repo_name ? match = true : nil
+        private
+        def override?
         end
-        match
       end
-    end
-  end
 
+      class LoadHook
+        def call
+          if @options[:internal]
+            @silent = @options[:internal]
+          end
+          hookfile = "#{ENV['HOME']}/.hubeye/hooks/#{@matches[2]}.yml"
+          new_hooks = nil
+          if File.exists?(hookfile)
+            File.open(hookfile) do |f|
+              new_hooks = ::YAML.load(f)
+            end
+            @session.hooks.merge!(new_hooks)
+            unless @silent
+              @socket.puts("Loaded #{@matches[1]} #{@matches[2]}")
+            end
+          else
+            unless @silent
+              @socket.puts("No #{@matches[1]} file to load from")
+            end
+          end
+        end
+      end
 
-  def not_connected
-    # if no client is connected, but the commits array contains repos
-    if @sockets.size == 1 and !@hubeye_tracker.empty?
-
-      while @remote_connection == false
-        sleep_amt = CONFIG[:oncearound] / @hubeye_tracker.length
-        @hubeye_tracker.each do |ary|
-          # this method does api calls, takes a couple of seconds to
-          # complete right now (TODO: see what's taking so long)
-          start_time = Time.now
-          old_sha, new_repo = ary.extract_old_and_new
-          api_time = (Time.now - start_time).to_i
-          new_commit = new_repo.commits.first
-          if new_commit.id == old_sha
-            (sleep_amt - api_time).times do
-              sleep 1
-              @remote_connection = client_ready(@sockets) ? true : false
-              break if @remote_connection
+      class LoadRepo
+        def call
+          if @options[:internal]
+            @silent = @options[:internal]
+          end
+          if File.exists?(repo_file = "#{ENV['HOME']}/.hubeye/repos/#{@matches[2]}.yml")
+            new_repos = nil
+            File.open(repo_file) do |f|
+              new_repos = ::YAML.load(f)
+            end
+            if !new_repos
+              @socket.puts "Unable to load #{@matches[2]}: empty file" unless @silent
+              return
+            end
+            new_repos.each do |r|
+              # add the repo name to the hubeye tracker
+              commit = @server.track(r)
+              @session.tracker.add_or_replace!(commit.repo, commit.sha)
+            end
+            unless @silent
+              @socket.puts "Loaded #{@matches[2]}.\nTracking:\n#{@session.tracker.keys.join ', '}"
             end
           else
-            # There was a change to a tracked repository.
-            full_repo_name = ary[0]
-            commit_msg     = new_commit.message
-            committer      = new_commit.author['name']
-            # notify of change to repository
-            # if they have a Desktop notification
-            # library installed
-            change_msg = "Repo #{full_repo_name} has changed\nNew commit: " +
-                         "#{commit_msg}\n=> #{committer}"
-            case CONFIG[:desktop_notification]
-            when "libnotify"
-              Autotest::GnomeNotify.notify("Hubeye", change_msg)
-              Logger.log_change(full_repo_name, commit_msg, committer)
-            when "growl"
-              Autotest::Growl.growl("Hubeye", change_msg)
-              Logger.log_change(full_repo_name, commit_msg, committer)
-            when nil
-              if @daemonized
-                Logger.log_change(full_repo_name, commit_msg, committer)
+            @socket.puts("No file to load from") unless @silent
+          end
+        end
+      end
+
+      class AddHook
+        def call
+          cwd  = File.expand_path('.')
+          repo = @matches[1]
+          dir  = @matches[3]
+          cmd  = @matches[4]
+          if repo != nil and cmd != nil
+            if @session.hooks[repo]
+              if dir
+                if @session.hooks[repo][dir]
+                  @session.hooks[repo][dir] << cmd
+                else
+                  @session.hooks[repo][dir] = [cmd]
+                end
               else
-                Logger.log_change(full_repo_name, commit_msg, committer, :include_terminal => true)
+                if @session.hooks[repo][cwd]
+                  @session.hooks[repo][cwd] << cmd
+                else
+                  @session.hooks[repo][cwd] = [cmd]
+                end
               end
-            end
-            # execute any hooks for that repository
-            unless @hook_cmds.nil? || @hook_cmds.empty?
-              if @hook_cmds[full_repo_name]
-                hook_cmds = @hook_cmds[full_repo_name].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)
+            else
+              if dir
+                @session.hooks[repo] = {dir => [cmd]}
+              else
+                @session.hooks[repo] = {cwd => [cmd]}
               end
             end
-            @hubeye_tracker.try_append_or_replace!(full_repo_name, new_commit)
+            @socket.puts("Hook added")
+          else
+            @socket.puts("Format: 'hook add user/repo [dir: /my/dir/repo ] cmd: git pull origin'")
           end
         end
-        redo unless @remote_connection
-      end # end of (while remote_connection == false)
-    end
-    client_connect(@sockets)
-  end
-
+      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
-        basic_inform = "Hubeye running on #{Socket.gethostname} as #{@username}"
-        if !@hubeye_tracker.empty?
-          @socket.puts "#{basic_inform}\nTracking:#{@hubeye_tracker.eyeing.join ', '}"
-        else
-          @socket.puts basic_inform
+      class ListHooks
+        def call
+          unless @session.hooks.empty?
+            pwd = File.expand_path('.')
+            format_string = ""
+            @session.hooks.each do |repo, hash|
+              local_dir = nil
+              command = nil
+              hash.each do |dir,cmd|
+                if dir.nil?
+                  local_dir = pwd
+                  command = cmd.join("\n" + (' ' * 8))
+                else
+                  command = cmd
+                  local_dir = dir
+                end
+              end
+              format_string << <<EOS
+remote: #{repo}
+dir:    #{local_dir}
+cmds:   #{command}\n
+EOS
+            end
+            @socket.puts(format_string)
+          else
+            @socket.puts("No hooks")
+          end
         end
+      end
 
-        if !@daemonized
-          puts "Client connected at #{NOW}"
+      class ListTracking
+        def call
+          output = ''
+          if @options[:details]
+            commit_list = []
+            @session.tracker.keys.each do |repo|
+              commit = @server.track(repo, :list => true)
+              commit_list << commit
+            end
+            commit_list.each do |c|
+              output << c.repo + "\n"
+              underline = '=' * c.repo.length
+              output << underline + "\n"
+              output << c.commit_message + "\n=> " +
+                c.committer_name + "\n"
+              output << "\n" unless c.repo == commit_list.last.repo
+            end
+          else
+            output << @session.tracker.keys.join(', ')
+          end
+          output = "none" if output.empty?
+          @socket.puts(output)
         end
+      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]} (#{NOW})"
-        else
-          # wipe the log file and start anew
-          Logger.relog "Accepted connection from #{@socket.peeraddr[2]} (#{NOW})"
+      class Next
+        def call
+          @socket.puts("")
         end
-        Logger.log "local:  #{@socket.addr}"
-        Logger.log "peer :  #{@socket.peeraddr}"
       end
-    end
-  end
 
+      class RmRepo
+        def call
+          if @matches[1].include?("/")
+            @session.username, @session.repo_name = @matches[1].split('/')
+          else
+            @session.repo_name = @matches[1]
+          end
+          rm = @session.tracker.delete("#{@session.username}/#{@session.repo_name}")
+          if rm
+            @socket.puts("Stopped watching repository #{@session.username}/#{@session.repo_name}")
+          else
+            @socket.puts("Repository #{@session.username}/#{@session.repo_name} not currently being watched")
+          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
+      class AddRepo
+        def call
+          if @options and @options[:pwd]
+            @session.repo_name = File.dirname(File.expand_path('.'))
+          elsif @options and @options[:fullpath]
+            @session.username, @session.repo_name = @input.split('/')
+          else
+            @session.repo_name = @input
+          end
+          add_repo
+        end
 
+        private
+        def add_repo
+          full_repo_name = "#{@session.username}/#{@session.repo_name}"
+          commit = @server.track(full_repo_name, :latest => true)
+          new_sha = commit.sha
+          commit_msg = commit.commit_message
+          committer  = commit.committer_name
+          msg = "#{commit_msg}\n=> #{committer}"
+          change = @session.tracker.add_or_replace!(full_repo_name, new_sha)
+          # new repo to track
+          if !change
+            @socket.puts("Repository #{full_repo_name} has not changed")
+            return
+          elsif change[:add]
+            # log the fact that the user added a repo to be tracked
+            Logger.log("Added to tracker: #{full_repo_name} (#{::Hubeye::Server::NOW})")
+            # show the user, via the client, the info and commit msg for the commit
+            @socket.puts(msg)
+          elsif change[:replace]
+            change_msg = "New commit on #{full_repo_name}\n"
+            change_msg << msg
+            @socket.puts(change_msg)
+            if @server.daemonized
+              Logger.log_change(full_repo_name, commit_msg, committer)
+            else
+              Logger.log_change(full_repo_name, commit_msg, committer,
+                                :include_terminal => true)
+            end
+          end
+        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 !@hubeye_tracker.empty?
-        Logger.log "Tracking: #{@hubeye_tracker.eyeing.join ', '}"
-      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
+      # STRATEGIES hash
+      # ===============
+      # keys: input matches
+      # OR
+      # lambda {|input| input.something?} => value
+      #
+      # values: lambda {|matchdata, basestrategy| SomeStrategy.new(matchdata, basestrategy)}
+      STRATEGIES = {
+        %r{\Ashutdown\Z} => lambda {|m, s| Shutdown.new(m, s)},
+        %r{\Aquit|exit\Z} => lambda {|m, s| Exit.new(m, s)},
+        %r{\A\s*save hook(s?) as (.+)\Z} => lambda {|m, s| SaveHook.new(m, s)},
+        %r{\A\s*save repo(s?) as (.+)\Z} => lambda {|m, s| SaveRepo.new(m, s)},
+        %r{\A\s*load hook(s?) (.+)\Z} => lambda {|m, s| LoadHook.new(m, s)},
+        %r{\A\s*load repo(s?) (.+)\Z} => lambda {|m, s| LoadRepo.new(m, s)},
+        %r{\A\s*internal load hook(s?) (.+)\Z} => lambda {|m, s| LoadHook.new(m, s, :internal => true)},
+        %r{\A\s*internal load repo(s?) (.+)\Z} => lambda {|m, s| LoadRepo.new(m, s, :internal => true)},
+        %r{\Ahook add ([-\w]+/[-\w]+) (dir:\s?(.*))?\s*cmd:\s?(.*)\Z} => lambda {|m, s| AddHook.new(m, s)},
+        %r{\Ahook list\Z} => lambda {|m, s| ListHooks.new(m, s)},
+        %r{\Atracking\s*\Z} => lambda {|m, s| ListTracking.new(m, s)},
+        %r{\Atracking\s*-d\Z} => lambda {|m, s| ListTracking.new(m, s, :details => true)},
+        %r{^pwd} => lambda {|m, s| AddRepo.new(m, s, :pwd => true)},
+        %r{^\s*$} => lambda {|m, s| Next.new(m, s)},
+        %r{\Arm ([-\w]+/?[-\w]*)\Z} => lambda {|m, s| RmRepo.new(m, s)},
+        lambda {|inp| inp.include? '/'} => lambda {|m, s| AddRepo.new(m, s, :fullpath => true)},
+        lambda {|inp| not inp.nil?} => lambda {|m, s| AddRepo.new(m, s)}
+      }
+
+      def call
+        STRATEGIES.each do |inp,strat|
+          if inp.respond_to? :match
+            if m = @input.match(inp)
+              return strat.call(m, self)
+            end
+          elsif inp.respond_to? :call
+            if m = inp.call(@input)
+              return strat.call(m, self)
+            end
+          end
+        end
+        raise UnknownStrategy
+      end
     end
-    throw(:next)
-  end
 
+    class Session
+      attr_accessor :repo_name, :username, :continuous
+      attr_writer :tracker, :hooks
 
-  def parse_shutdown
-    if @input == "shutdown"
-      # local
-      Logger.log "Closing connection to #{@socket.peeraddr[2]}"
-      Logger.log "Shutting down... (#{NOW})"
-      Logger.log ""
-      Logger.log ""
-      # peer
-      @socket.puts("Shutting down server")
-    else
-      return
-    end
-    shutdown
-  end
+      def initialize
+        setup_singleton_methods
+      end
 
+      def tracker
+        @tracker ||= {}
+      end
 
-  def shutdown
-    @sockets.delete(@socket)
-    @socket.close
-    exit
-  end
+      def hooks
+        @hooks ||= {}
+      end
 
+      def cleanup
+        reset_username
+        reset_repo_name
+      end
 
-  def parse_hook
-    if %r{hook add} =~ @input
-      hook_add
-    else
-      return
-    end
-  end
+      private
+      def reset_username
+        self.username = CONFIG[:username]
+      end
 
+      def reset_repo_name
+        self.repo_name = ""
+      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 hook_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]
+      def setup_singleton_methods
+        tracker.singleton_class.class_eval do
+          def add_or_replace! repo_name, new_sha=nil
+            if Hash === repo_name
+              merge! repo_name
+              return true
+            else
+              if keys.include? repo_name and self[repo_name] == new_sha
+                return
+              elsif keys.include? repo_name
+                ret = {:replace => true}
+              else
+                ret = {:add => true}
+              end
+            end
+            merge! repo_name => new_sha
+            ret
+          end
+        end
+      end
+    end # end of Session class
+
+    def start(port, options={})
+      listen(port)
+      setup_env(options)
+      loop do
+        waiting = catch(:connect) do
+          look_for_changes unless @remote_connection
+        end
+        client_connect(@sockets) if waiting
+        strategy = Strategy.new(self)
+        strategy.call
+        @session.cleanup
       end
-      @socket.puts("Hook added")
-    else
-      @socket.puts("Format: 'hook add user/repo [dir: /my/dir/repo ] cmd: git pull origin'")
     end
-    throw(:next)
-  end
-  private :hook_add
 
+    # The track method closes over a list variable to store recent info on
+    # tracked repositories.
+    # Options: :sha, :latest, :full, :list (all boolean).
+    # The :list => true option gives back the commit object from the list.
 
-  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']}/.hubeye/hooks/#{$2}.yml", "w") do |f_out|
-          ::YAML.dump(@hook_cmds, f_out)
-        end
-        @socket.puts("Saved hook#{$1} as #{$2}")
+    list = []
+
+    define_method :track do |repo, options={}|
+      if repo.include? '/'
+        username, repo_name = repo.split '/'
+        full_repo_name = repo
       else
-        @socket.puts("No hook#{$1} to save")
+        username, repo_name = @session.username, repo
+        full_repo_name = "#{username}/#{repo_name}"
       end
-      throw(:next)
-    elsif @input =~ %r{\A\s*save repo(s?) as (.+)\Z}
-      if !@hubeye_tracker.empty?
-        File.open("#{ENV['HOME']}/.hubeye/repos/#{$2}.yml", "w") do |f_out|
-          ::YAML.dump(@hubeye_tracker.eyeing, f_out)
+      unless options[:list]
+        hist = nil
+        begin
+          open "https://api.github.com/repos/#{username}/" \
+          "#{repo_name}/commits" do |f|
+            hist = JSON.parse f.read
+          end
+        rescue
+          @socket.puts "Not a Github repository name"
+          return
         end
-        @socket.puts("Saved repo#{$1} as #{$2}")
+        new_info =
+          {full_repo_name =>
+            {'sha' => hist.first['sha'],
+             'commit' =>
+               {'message' => hist.first['commit']['message'],
+                'committer' => {'name' => hist.first['commit']['committer']['name']}
+               }
+            }
+          }
+        commit = Commit.new(new_info)
+        # update the list
+        list.reject! {|cmt| cmt.repo == full_repo_name}
+        list << commit
+      end
+      if options[:full]
+        # unsupported so far
+        raise ArgumentError.new
+      elsif options[:latest]
+        commit.dup
+      elsif options[:list]
+        list.each {|c| return c if c.repo == full_repo_name}
+        nil
       else
-        @socket.puts("No remote repos are being tracked")
+        # default
+        Commit.new full_repo_name => {'sha' => hist.first['sha']}
       end
-      throw(:next)
-    else
-      return
     end
-  end
 
-
-  # options are internal input: can be true or falselike.
-  # When falselike (nil is default), it outputs to the client socket.
-  # When truelike (such as when used internally), it outputs nothing.
-  def load_hooks_or_repos(options={})
-    opts = {:internal_input => nil, :internal_input_hooks => nil,
-      :internal_input_repos => nil}.merge options
-    if opts[:internal_input].nil?
-      load_hooks_repos_from_terminal_input
-    elsif opts[:internal_input]
-      input = opts[:internal_input]
-      if opts[:internal_input_hooks]
-        load_hooks_from_internal_input(input)
-      elsif opts[:internal_input_repos]
-        load_repos_from_internal_input(input)
-      end
+    private
+    def listen(port)
+      @server = TCPServer.open(port)
     end
-  end
 
-  def load_hooks_repos_from_terminal_input
-    if @input =~ %r{\A\s*load hook(s?) (.+)\Z}
-      hookfile = "#{ENV['HOME']}/.hubeye/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']}/.hubeye/repos/#{$2}.yml"
-        newrepos = nil
-        File.open(repo_file) do |f|
-          newrepos = ::YAML.load(f)
+    def setup_env(options={})
+      @daemonized = options[:daemon]
+      @sockets = [@server]  # An array of sockets we'll monitor
+      @session = Session.new
+      unless CONFIG[:default_track].nil?
+        CONFIG[:default_track].each do |repo|
+          commit = track(repo)
+          @session.tracker.merge! commit.repo => commit.sha
         end
+      end
+      unless CONFIG[:load_hooks].empty?
+        hooks = CONFIG[:load_hooks].dup
+        session_load :hooks => hooks
+      end
+      unless CONFIG[:load_repos].empty?
+        repos = CONFIG[:load_repos].dup
+        session_load :repos => repos
+      end
+      @session.username = CONFIG[:username]
+      @remote_connection = false
+    end
 
-        if !newrepos
-          @socket.puts "Unable to load #{$2}: empty file"
-          throw(:next)
+    def session_load options={}
+      opts = {:hooks => nil, :repos => nil}.merge options
+      if hooks = opts[:hooks]
+        hooks.each do |h|
+          strat = Strategy.new(self, :internal_input => "internal load hook #{h}")
+          strat.call
         end
-        # newrepos is an array of repos to be tracked
-        newrepos.each do |e|
-          # append the repo name and the commit hash to the hubeye tracker
-          # array, then inform the client of the newest commit message
-          username, repo = e.split '/'
-          gh_user = User.find(username)
-          gh_repo = gh_user.repository repo
-          new_commit = gh_repo.commits.first
-          @hubeye_tracker.try_append_or_replace!(e, new_commit)
+      elsif repos = opts[:repos]
+        repos.each do |r|
+          strat = Strategy.new(self, :internal_input => "internal load repo #{r}")
+          strat.call
         end
-        @socket.puts "Loaded #{$2}.\nTracking:\n#{@hubeye_tracker.eyeing.join ', '}"
       else
-        # no repo file with that name
-        @socket.puts("No file to load from")
+        raise ArgumentError.new "Must load either hooks or repos"
       end
-      throw(:next)
     end
-    return
-  end
 
-  def load_hooks_from_internal_input(input)
-    if input.respond_to? :to_a
-      input = input.to_a
-      input.each do |hook|
-        hookfile = "#{ENV['HOME']}/.hubeye/hooks/#{hook}.yml"
-        newhook = nil
-        if File.exists?(hookfile)
-          File.open(hookfile) do |f|
-            newhook = ::YAML.load(f)
+    #TODO: refactor this ugly, long method into a new class
+    def look_for_changes
+      # if no client is connected, but the commits array contains repos
+      if @sockets.size == 1 and !@session.tracker.empty?
+
+        loop do
+          sleep_amt = CONFIG[:oncearound] / @session.tracker.length
+          @session.tracker.each do |repo,sha|
+            start_time = Time.now
+            commit = track(repo, :latest => true)
+            api_time = (Time.now - start_time).to_i
+            if commit.sha == sha
+              (sleep_amt - api_time).times do
+                sleep 1
+                @remote_connection = client_ready(@sockets) ? true : false
+                throw(:connect, true) if @remote_connection
+              end
+            else
+              # There was a change to a tracked repository.
+              full_repo_name = commit.repo
+              commit_msg     = commit.commit_message
+              committer      = commit.committer_name
+              new_sha        = commit.sha
+              change_msg = "Repo #{full_repo_name} has changed\nNew commit: " \
+                "#{commit_msg}\n=> #{committer}"
+              case CONFIG[:desktop_notification]
+              when "libnotify"
+                Autotest::GnomeNotify.notify("Hubeye", change_msg)
+                Logger.log_change(full_repo_name, commit_msg, committer)
+              when "growl"
+                Autotest::Growl.growl("Hubeye", change_msg)
+                Logger.log_change(full_repo_name, commit_msg, committer)
+              when nil
+                if @daemonized
+                  Logger.log_change(full_repo_name, commit_msg, committer)
+                else
+                  Logger.log_change(full_repo_name, commit_msg, committer, :include_terminal => true)
+                end
+              end
+              # execute any hooks for that repository
+              unless @session.hooks.nil? || @session.hooks.empty?
+                if hooks = @session.hooks[full_repo_name]
+                  hooks = hooks.dup
+                  hooks.each do |dir,cmds|
+                    # execute() takes [commands], {options} where
+                    # options = :directory and :repo
+                    Hooks::Command.execute(cmds, :directory => dir, :repo => full_repo_name)
+                  end
+                end
+              end
+              @session.tracker.add_or_replace!(full_repo_name, new_sha)
+            end
           end
-          @hook_cmds ||= {}
-          @hook_cmds = newhook.merge(@hook_cmds)
-        else
-          # do nothing because of no extra processing after this, newhook
-          # can stay nil if the hook file doesn't exist
-        end
+        end # end of (while remote_connection == false)
+      else
+        @remote_connection = client_ready(@sockets, :block => true) ? true : false
+        throw(:connect, true) if @remote_connection
       end
-    else
-      raise ArgumentError.new "#{input} must be array-like"
     end
-  end
 
-  def load_repos_from_internal_input(input)
-    if input.respond_to? :to_a
-      input = input.to_a
-      newrepos = []
-      input.each do |repo|
-        repofile = "#{ENV['HOME']}/.hubeye/repos/#{repo}.yml"
-        newrepo = nil
-        if File.exists?(repofile)
-          File.open(repofile) do |f|
-            newrepo = ::YAML.load(f)
-          end
-          # empty repo file, go to next repo file in the array
-          if !newrepo
-            next
-          else
-            # append the newrepo array to the newrepos array
-            newrepos << newrepo
-          end
-        else
-          # file doesn't exist, next repo file
-          next
-        end
-      end # end of input#each
-      # flatten the newrepos array because it contains arrays
-      newrepos.flatten!
-      newrepos.each do |e|
-        username, repo = e.split '/'
-        gh_user = User.find(username)
-        gh_repo = gh_user.repository repo
-        new_commit = gh_repo.commits.first
-        @hubeye_tracker.try_append_or_replace!(e, new_commit)
-      end
-    else
-      raise ArgumentError.new "#{input} must be array-like"
+    def client_ready(sockets, options={})
+      if options[:block]
+        select(sockets, nil, nil)
+      else
+        select(sockets, nil, nil, 1)
+      end
     end
-  end
 
-  def hook_list
-    if @input =~ %r{hook list}
-      unless @hook_cmds.nil? || @hook_cmds.empty?
-        format_string = ""
-        @hook_cmds.each do |repo, ary|
-          remote = repo
-          if ary.first.include? '/'
-            local = ary.first
-            cmds  = ary[1..-1]
+    def client_connect(sockets)
+      ready = select(sockets)
+      readable = ready[0]
+      readable.each do |socket|
+        if socket == @server
+          @socket = @server.accept
+          sockets << @socket
+          # Inform the client of connection
+          basic_inform = "Hubeye running on #{Socket.gethostname} as #{@session.username}"
+          if !@session.tracker.empty?
+            @socket.puts "#{basic_inform}\nTracking: #{@session.tracker.keys.join ', '}"
           else
-            cmds = ary
-            local = "N/A"
+            @socket.puts basic_inform
           end
-          format_string += <<-EOS
-remote: #{remote}
-  dir : #{local}
-  cmds: #{cmds.each {|cmd| print cmd + ' ' }} \n
-  EOS
+          if !@daemonized
+            puts "Client connected at #{NOW}"
+          end
+          @socket.flush
+          # And log the fact that the client connected
+          # if the client quit, do not wipe the log file
+          if @session.continuous
+            Logger.log "Accepted connection from #{@socket.peeraddr[2]} (#{NOW})"
+          else
+            # wipe the log file and start anew
+            Logger.relog "Accepted connection from #{@socket.peeraddr[2]} (#{NOW})"
+          end
+          Logger.log "local:  #{@socket.addr}"
+          Logger.log "peer :  #{@socket.peeraddr}"
         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 = @hubeye_tracker.eyeing.join ', '
-      @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
-      rm = @hubeye_tracker.rm_repo("#{@username}/#{@repo_name}")
-      if rm
-        @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
-    else
-      return
     end
-  end
 
+  end # of Server module
 
-  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
+  class HubeyeServer
+    include Server
 
-
-  # if the input is not the above special scenarios
-  def parse_add
-    @repo_name = @input
-  end
-
-  def parse_doc
-    @full_repo_name = "#{@username}/#{@repo_name}"
-    begin
-      gh_user = User.find(@username)
-      gh_repo = gh_user.repository @repo_name
-    rescue ArgumentError, Octopi::NotFound
-      #Octopi library's User.find ArgumentError
-      @socket.puts "Not a Github repository name"
-      throw :next
+    def initialize(debug=true)
+      @debug = debug
     end
-    new_commit = gh_repo.commits.first
-    change_status = @hubeye_tracker.try_append_or_replace!(@full_repo_name, new_commit)
-    # get commit info
-    commit_msg = new_commit.message
-    committer  = new_commit.author['name']
-    url = "https://www.github.com#{new_commit.url[0..-30]}"
-    msg =  "#{commit_msg}\n=> #{committer}"
-    # new repo to track
-    if change_status[:add]
-      # log the fact that the user added a repo to be tracked
-      Logger.log("Added to tracker: #{@full_repo_name} (#{NOW})")
-      # show the user, via the client, the info and commit msg for the commit
-      @socket.puts("#{msg}\n#{url}")
-
-      # new commit to tracked repo
-    elsif change_status[:replace]
-      change_msg = "New commit on #{@full_repo_name}\n"
-      change_msg << "#{msg}\n#{url}"
-      @socket.puts(change_msg)
-      begin
-        # log to the logfile and tell the client
-        if @daemonized
-          Logger.log_change(@full_repo_name, commit_msg, committer)
-        else
-          Logger.log_change(@full_repo_name, commit_msg, committer,
-                            :include_terminal => true)
-        end
-      rescue
-        throw :next
-      end
-    else
-      # no change to the tracked repo
-      @socket.puts("Repository #{@full_repo_name} has not changed")
-    end
-  end
 
-end # of Server module
-
-class HubeyeServer
-  include Server
-
-  def initialize(debug=true)
-    @debug = debug
   end
-
 end