hubeye 0.3.3 → 0.3.5

data/lib/hubeye/server/session.rb

@@ -2,24 +2,21 @@ module Hubeye
   module Server
     class Session
       attr_accessor :repo_name, :username, :continuous
-      attr_writer :tracker, :hooks
+      attr_writer   :hooks
 
       def initialize
-        setup_singleton_methods
-      end
-
-      def tracker
-        @tracker ||= {}
+        defaults!
       end
 
       def hooks
         @hooks ||= {}
       end
 
-      def cleanup
+      def defaults!
         reset_username
         reset_repo_name
       end
+      alias cleanup! defaults!
 
       private
       def reset_username
@@ -30,30 +27,6 @@ module Hubeye
         self.repo_name = ""
       end
 
-      def setup_singleton_methods
-        tracker.singleton_class.class_eval do
-          def add_or_replace! input, new_sha=nil
-            if Hash === input and new_sha.nil?
-              repo = input.keys.first
-              hash = true
-            else
-              repo = input
-              two_args = true
-            end
-            if keys.include? repo and self[repo] == new_sha
-              return
-            elsif keys.include? repo
-              ret = {:replace => true}
-            else
-              ret = {:add => true}
-            end
-            two_args ? merge!(repo => new_sha) : merge!(input)
-            ret
-          end
-        end
-      end
-
-    end # end of Session class
+    end
   end
 end
-

data/lib/hubeye/server/strategies/add_hook.rb

@@ -0,0 +1,32 @@
+module Hubeye
+  module Server
+    module Strategies
+
+      class AddHook
+        def call
+          cwd       = File.expand_path('.')
+          repo_name = @matches[1]
+          directory = @matches[3]
+          command   = @matches[4]
+          hooks     = session.hooks
+          if repo_name.nil? and command.nil?
+            socket.deliver "Format: 'hook add user/repo [dir: /my/dir/repo ] cmd: some_cmd'"
+            return
+          end
+          directory = directory || cwd
+          if hooks[repo_name]
+            if hooks[repo_name][directory]
+              hooks[repo_name][directory] << command
+            else
+              hooks[repo_name][directory] = [command]
+            end
+          else
+            hooks[repo_name] = {directory => [command]}
+          end
+          socket.deliver "Hook added"
+        end
+      end
+
+    end
+  end
+end

data/lib/hubeye/server/strategies/add_repo.rb

@@ -0,0 +1,91 @@
+require 'set'
+
+module Hubeye
+  module Server
+    module Strategies
+
+      class AddRepo
+        STATES = [:added, :replaced, :unchanged, :invalid].freeze
+        ADDED = "%{committer} => %{message}\n".freeze
+        REPLACED = "New commit on %s\n".freeze
+        UNCHANGED = "Repository %s hasn't changed\n".freeze
+        INVALID  = "%s isn't a valid Github repository\n".freeze
+
+        # Add the given space-separated Github repo(s) if they're valid
+        def call
+          repo_names_given = @matches[1].split
+          @multiple_repos_given = repo_names_given.size > 1
+          @unique_repo_names = Set.new
+          # hash of states associated with repository names.
+          # Ex: {:added => ['luke-gru/hubeye'], :replaced => ['rails/rails'], ...}
+          @states_with_repos = Hash[STATES.map {|s| [ s, [] ]}]
+          repo_names_given.each do |name|
+            full_name = server.full_repo_name(name)
+            @unique_repo_names << full_name
+          end
+          add_repos
+          gather_output
+          socket.deliver @output
+        end
+
+        private
+
+        def add_repos
+          @unique_repo_names.each do |full_name|
+            change_state = tracker << full_name
+            @states_with_repos[change_state] << full_name
+          end
+        end
+
+        def gather_output
+          @output = ''
+          STATES.each do |state|
+            @states_with_repos[state].each do |full_name|
+              @output << header(full_name) if @multiple_repos_given
+              case state
+              when :added
+                cmt = tracker.commit(full_name)
+                @output << ADDED % {:committer => cmt.committer_name, :message =>  cmt.message}
+              when :replaced
+                cmt = tracker.commit(full_name)
+                @output << REPLACED % full_name
+                log_change(full_name, cmt)
+              when :unchanged
+                @output << UNCHANGED % full_name
+              when :invalid
+                @output << INVALID % full_name
+              end
+              @output << "\n" if @multiple_repos_given && full_name != last_repo_outputted
+            end
+          end
+        end
+
+        def header(full_name)
+          ''.tap do |output|
+            output << full_name + "\n"
+            output << ('=' * full_name.length) + ("\n" * 2)
+          end
+        end
+
+        def log_change(repo_name, cmt)
+          if server.daemonized
+            Logger.log_change("#{repo_name}", cmt.message, cmt.committer_name)
+          else
+            Logger.log_change("#{repo_name}", cmt.message, cmt.committer_name,
+                              :include_terminal => true)
+          end
+        end
+
+        def last_repo_outputted
+          return @last if @last
+          STATES.reverse_each do |state|
+            repo_names = @states_with_repos[state]
+            next if repo_names.last.nil?
+            return (@last = repo_names.last)
+          end
+        end
+      end # end of AddRepo
+
+    end
+  end
+end

data/lib/hubeye/server/strategies/decision.rb

@@ -0,0 +1,121 @@
+require 'forwardable'
+
+$decision_relatives = Dir.glob( File.join(File.expand_path("../", __FILE__), '*') )
+$decision_relatives.each {|file| require file }
+
+module Hubeye
+  module Server
+    module Strategies
+
+        # STRATEGIES hash
+        # ===============
+        # keys: input matches
+        # OR
+        # lambda {|input| input.something?} => SomeStrategy.new(decision)
+        #
+        # values: lambda {|decision, matches|  SomeStrategy.new(decision, matches)}
+        STRATEGIES = {
+          %r{\Ashutdown\Z} => lambda {|d, m| Shutdown.new(d, m)},
+          %r{\Aquit|exit\Z} => lambda {|d, m| Exit.new(d, m)},
+          %r{\Atracking\s*\Z} => lambda {|d, m| ListTracking.new(d, m)},
+          %r{\Atracking\s*-d\Z} => lambda {|d, m| ListTracking.new(d, m, :details => true)},
+          %r{\Aadd (.*)} => lambda {|d, m| AddRepo.new(d, m)},
+          %r{\A\s*save hook(s?) as (.+)\Z} => lambda {|d, m| SaveHook.new(d, m)},
+          %r{\A\s*save repo(s?) as (.+)\Z} => lambda {|d, m| SaveRepo.new(d, m)},
+          %r{\A\s*load hook(s?) (.+)\Z} => lambda {|d, m| LoadHook.new(d, m)},
+          %r{\A\s*load repo(s?) (.+)\Z} => lambda {|d, m| LoadRepo.new(d, m)},
+          %r{\A\s*internal load hook(s?) (.+)\Z} => lambda {|d, m| LoadHook.new(d, m, :internal => true)},
+          %r{\A\s*internal load repo(s?) (.+)\Z} => lambda {|d, m| LoadRepo.new(d, m, :internal => true)},
+          %r{\Ahook add ([-\w]+/[-\w]+) (dir:\s?(.*))?\s*cmd:\s?(.*)\Z} => lambda {|d, m| AddHook.new(d, m)},
+          %r{\Ahook list\Z} => lambda {|d, m| ListHooks.new(d, m)},
+          %r{^\s*$} => lambda {|d, m| Next.new(d, m)},
+          %r{\Arm\s*-a\Z} => lambda {|d, m| RmRepo.new(d, m, :all => true)},
+          %r{\Arm ([-\w]+/?[-\w]*)\Z} => lambda {|d, m| RmRepo.new(d, m)},
+          # if all else fails, try to add the input as a repo
+          %r{\A(.*)} => lambda {|d, m| AddRepo.new(d, m)},
+        }
+
+      class Decision
+        extend Forwardable
+        attr_reader :server, :input
+        InvalidInput = Class.new(StandardError)
+
+        def_delegators :@server, :tracker, :session, :sockets, :socket
+
+        def initialize(server, options={})
+          @server = server
+          opts = {:internal_input => nil}.merge options
+          invalid_input = lambda {
+            @server.remote_connection = false
+            throw(:invalid_input)
+          }
+
+          if !opts[:internal_input]
+            begin
+              @input = socket.read_all
+            rescue => e
+              STDOUT.puts e
+              invalid_input.call
+            end
+            # check if the client pressed ^C or ^D
+            if @input.nil?
+              invalid_input.call
+            end
+          else
+            @input = opts[:internal_input]
+          end
+          @input = @input.strip.downcase
+          @input.gsub! /diiv/, '/'
+        end
+
+        # Get all the strategy classes from the files names in the /server/strategies/
+        # directory
+
+        @@strategy_classes = []
+        relatives = $decision_relatives.dup
+        relatives.delete_if {|file| file == __FILE__}
+
+        relatives.each do |file|
+          strat = File.basename(file)
+          class_name = strat.sub(/\.rb/, '').split('_').map(&:capitalize).join
+          @@strategy_classes << class_name
+        end
+
+        @@strategy_classes.each do |class_name|
+          klass = Hubeye::Server::Strategies.const_get(class_name)
+          klass.class_eval do
+            extend Forwardable
+            attr_reader :server
+
+            def_delegators :@decision, :input
+            def_delegators :@server, :tracker, :session, :sockets, :socket
+
+            def initialize decision, matches=nil, options={}
+              @decision = decision
+              @matches  = matches
+              @options  = options
+              @server   = @decision.server
+              call
+            end
+          end
+        end
+
+        def call_strategy
+          STRATEGIES.each do |inp,strat|
+            if inp.respond_to? :match
+              if m = @input.match(inp)
+                return strat.call(self, m)
+              end
+            elsif inp.respond_to? :call
+              if inp.call(@input)
+                return strat.call(self)
+              end
+            end
+          end
+          raise InvalidInput
+        end
+      end # end of Decision
+
+    end
+  end
+end

data/lib/hubeye/server/strategies/exit.rb

@@ -0,0 +1,23 @@
+module Hubeye
+  module Server
+    module Strategies
+
+      class Exit
+        def call
+          socket.deliver "Bye!"
+          # mark the session as continuous to not wipe the log file
+          session.continuous = true
+          server.remote_connection = false
+          Logger.log "Closing connection to #{socket.peeraddr[2]}"
+          unless tracker.empty?
+            Logger.log "Tracking: #{tracker.repo_names.join ', '}"
+          end
+          Logger.log ""
+          sockets.delete(socket)
+          socket.close
+        end
+      end
+
+    end
+  end
+end

data/lib/hubeye/server/strategies/list_hooks.rb

@@ -0,0 +1,38 @@
+module Hubeye
+  module Server
+    module Strategies
+
+      class ListHooks
+        def call
+          hooks = session.hooks
+          if hooks.empty?
+            socket.deliver "No hooks"
+            return
+          end
+          pwd = File.expand_path('.')
+          format_string = ""
+          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.deliver format_string
+        end
+      end
+
+    end
+  end
+end

data/lib/hubeye/server/strategies/list_tracking.rb

@@ -0,0 +1,27 @@
+module Hubeye
+  module Server
+    module Strategies
+
+      class ListTracking
+        def call
+          output = ''
+          if @options[:details]
+            commit_list = tracker.commit_list
+            commit_list.each do |cmt|
+              output << cmt.repo_name + "\n"
+              underline = '=' * cmt.repo_name.length
+              output << underline + "\n\n"
+              output << (cmt.committer_name + " => ") + (cmt.message + "\n")
+              output << "\n" unless cmt.repo_name == commit_list.last.repo_name
+            end
+          else
+            output << tracker.repo_names.join(', ')
+          end
+          output = "none" if output.empty?
+          socket.deliver output
+        end
+      end
+
+    end
+  end
+end

data/lib/hubeye/server/strategies/load_hook.rb

@@ -0,0 +1,34 @@
+require 'yaml'
+
+module Hubeye
+  module Server
+    module Strategies
+
+      class LoadHook
+        def call
+          if _t = @options[:internal]
+            @silent = _t
+          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
+            # need to fix this to check if there are already commands for that
+            # repo
+            session.hooks.merge!(new_hooks)
+            unless @silent
+              socket.deliver "Loaded #{@matches[1]} #{@matches[2]}"
+            end
+          else
+            unless @silent
+              socket.deliver "No #{@matches[1]} file to load from"
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/hubeye/server/strategies/load_repo.rb

@@ -0,0 +1,35 @@
+require 'yaml'
+
+module Hubeye
+  module Server
+    module Strategies
+
+      class LoadRepo
+        def call
+          if _t = @options[:internal]
+            @silent = _t
+          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.deliver "Unable to load #{@matches[2]}: empty file" unless @silent
+              return
+            end
+            new_repos.each do |r|
+              tracker << server.full_repo_name(r)
+            end
+            unless @silent
+              socket.deliver "Loaded #{@matches[2]}.\nTracking:\n#{tracker.repo_names.join ', '}"
+            end
+          else
+            socket.deliver "No file to load from"  unless @silent
+          end
+        end
+      end
+
+    end
+  end
+end