Mange-git-remote-monitor 0.1.1 → 0.1.2

data/HISTORY.markdown

@@ -0,0 +1,26 @@
+VERSION 0.1.2
+=============
+Major refactoring for upcoming beta. A few bug fixes, too.
+
+  * Added note type to Meow for more client customization.
+  * Refactored the notification system into a plug-in based system.
+    It will be much easier to test and extend this, and getting it to work with new notification systems on
+    other platforms is going to be a piece of cake from now on.
+  * New options for executable: --list-plugins, --version
+  * You can now specify a DIR for the monitor executable
+  * BUG: Human-readable error when trying to fetch in a repo without remotes
+  * BUG: Error out when entering a directory which is not part of a repository
+
+VERSION 0.1.1
+=============
+Quick patch release to fix serious error in the gem creation.
+
+  * BUG: Only the executable was built into the gem
+  * BUG: The executable did not try to load the lib when running gem executable
+
+VERSION 0.1.0
+=============
+  * Basic support for notifications
+  * Basic fetch wrapper to git
+  * Basic monitor, waiting 20 seconds between each fetch
+  * Simple comparing remotes with local possible

data/Rakefile

@@ -26,12 +26,15 @@ end
 
 Spec::Rake::SpecTask.new do |t|
   t.libs << 'lib'
+  t.spec_files = FileList['spec/**/*.rb']
   t.verbose = false
   t.rcov = false
 end
 
 Spec::Rake::SpecTask.new('rcov') do |t|
   t.libs << 'lib'
+  t.spec_files = FileList['spec/**/*.rb']
+  t.rcov_opts = ['--exclude', 'spec,rcov']
   t.verbose = false
   t.rcov = true
 end
@@ -44,4 +47,4 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-task :default => :test
+task :default => :spec

data/TODO

@@ -2,22 +2,23 @@ TODO
 ====
 
 Before beta:
-  * More specs
-    * Need to figure out how to simulate the stuff better; reduce inter-dependencies
-    * Command line arguments
-    * Specify a project name
-    * Specify path
-    * Specify fetch interval
+  * Command line arguments
+  * Specify a project name
   * Daemonize the program
   * Look at real Git libraries; might be better than calling the system
-
+  
 Before 1.0:
   * Read/Save configuration with git-config(1)
   * Make it easy to quit the daemons (git-remote-monitor --kill-all, or similar)
-
+  
 Before 1.1:
   * Extend to more notification systems than Meow (Growl on Mac OS X)
     * knotify
     * Whatever Gnome uses
     * Windows possible?
-    * XMPP? Too crazy?
+    * Email?
+    * HTTP request to a URL?
+    * Run generic command?
+    * XMPP? Too crazy?
+  * Let notification plugins have configuration settings
+    * Project name/Notifier plugin structure. Have a wildcard project for default settings.

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 1
+:patch: 2
 :major: 0
 :minor: 1

data/bin/git-remote-monitor

@@ -26,9 +26,9 @@
 #
 
 # Add ../lib/ as a load path in case we are doing development
-$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-REQUIRED_GEMS = ['rubygems', 'meow']
+REQUIRED_GEMS = ['rubygems']
 begin
   REQUIRED_GEMS.each { |g| require g }
 rescue LoadError => e
@@ -45,19 +45,27 @@ require 'rdoc/usage'
 
 $usage = %Q{
 = Synopsis
-Monitors the current branch's remote for changes at a fixed interval. Changes will be fetched and you will be
-notified about how many commits you are behind.
+Monitors the HEAD's (current branch) remote for changes at a fixed interval. Changes will be fetched
+and you will be notified about them in any notification system you specify.
 
 = Usage
-git remote-monitor [OPTIONS]
+git remote-monitor [OPTIONS] [DIR]
+
+When no DIR is specified, current working directory will be used.
 
 == Options
 -h, --help:
    displays this usage information
 
+-V, --version:
+   displays version information
+
 -i TIME, --interval=TIME:
    time, in seconds, between each fetch. Defaults to 60 seconds.
 
+-p, --list-plugins:
+   list all notification plugins and show which ones are active on your system, then quit.
+
 == Daemon
 Since this utility is in an early stage, no daemon capabilities have yet been added. It is recommended that
 you start the command in the background (append a single & to the end of the command line) so you can keep
@@ -71,7 +79,7 @@ using your term to other things while the program is running.
 # RubyGems will call this from a wrapper, and #usage is hardcoded to look
 # at the top-level file instead of the current one. I have changed this
 # code to instead just parse a string.
-def usage_and_exit!
+def usage_information
   markup = SM::SimpleMarkup.new
   flow_convertor = SM::ToFlow.new
 
@@ -80,8 +88,33 @@ def usage_and_exit!
   options = RI::Options.instance
   formatter = options.formatter.new(options, "")
   formatter.display_flow(flow)
+end
+
+def version_information
+  require 'yaml'
+  version = YAML::load_file(File.join(GitRemoteMonitor.root, 'VERSION.yml'))
+  stability = (version[:minor] % 2 == 0) ? "stable" : "unstable"
+  puts "#{File.basename($0)} version #{version[:major]}.#{version[:minor]}.#{version[:patch]} (#{stability})"
+  puts "Run in ruby #{RUBY_VERSION} (#{RUBY_PLATFORM}) released #{RUBY_RELEASE_DATE}, patchlevel #{RUBY_PATCHLEVEL}"
+end
+
+def list_plugins
+  loaded = GitRemoteMonitor::Notifiers.notifier_plugins
+  available = GitRemoteMonitor::Notifiers.available_notifiers
+  preferred = GitRemoteMonitor::Notifiers.preferred_notifier
   
-  exit(0)
+  puts "Plugins currently in this version of git-remote-monitor:"
+  loaded.each do |plugin|
+    status = if plugin == preferred
+      " (Available, Active)"
+    elsif available.include?(plugin)
+      " (Available)"
+    else
+      ""
+    end
+    plugin_name = plugin.to_s.sub(/^.*::/, '')
+    puts "\t* #{plugin_name}#{status}"
+  end
 end
 
 #
@@ -89,14 +122,23 @@ end
 #
 def parse_command_line_arguments!
   opts = GetoptLong.new(
-    [ '--help',       '-h', GetoptLong::NO_ARGUMENT ],
-    [ '--interval',   '-i', GetoptLong::REQUIRED_ARGUMENT]
+    [ '--help',         '-h', GetoptLong::NO_ARGUMENT ],
+    [ '--version',      '-V', GetoptLong::NO_ARGUMENT ],
+    [ '--list-plugins', '-p', GetoptLong::NO_ARGUMENT ],
+    [ '--interval',     '-i', GetoptLong::REQUIRED_ARGUMENT]
   )
   
   opts.each do |opt, arg|
     case opt
     when '--help'
-      usage_and_exit!
+      usage_information
+      exit(0)
+    when '--version'
+      version_information
+      exit(0)
+    when '--list-plugins'
+      list_plugins
+      exit(0)
     when '--interval'
       interval = arg.to_i
       unless interval > 10
@@ -106,17 +148,25 @@ def parse_command_line_arguments!
       $interval = interval
     end
   end
+  
+  # ARGV now contains all non-params. Check for only one extra param, max. This is the DIR.
+  if $ARGV.size > 1
+    $stderr.puts "Only one directory may be specified!"
+    Kernel.exit(1)
+  elsif $ARGV.size == 1
+    $dir = $ARGV.first
+  end
 end
 
 # Default values for the command line options
 $interval = 60
+$dir      = Dir.pwd
 
 begin
   parse_command_line_arguments!
   
   notifier = GitRemoteMonitor::Notifier.new
-  # Hardcoded values for now
-  monitor  = GitRemoteMonitor::Monitor.new(Dir.pwd, $interval, notifier)
+  monitor  = GitRemoteMonitor::Monitor.new($dir, $interval, notifier)
   
   monitor.start_monitoring!
 rescue => e

data/lib/git_remote_monitor.rb

@@ -20,9 +20,13 @@
 # THE SOFTWARE.
 
 module GitRemoteMonitor
-  PATH = File.join(File.dirname(__FILE__), '..')
+  
+  def self.root
+    File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  end
+  
 end
 
-['git_wrapper', 'monitor', 'notifier'].each do |file|
+%w(git_wrapper notifiers monitor status notifier).each do |file|
   require File.join(File.dirname(__FILE__), 'git_remote_monitor', file)
 end

data/lib/git_remote_monitor/git_wrapper.rb

@@ -62,11 +62,31 @@ class GitRemoteMonitor::GitWrapper
     # The method will return true if a fetch was made or false if nothing was fetched.
     #
     def fetch!
+      raise "This repository have no remotes to fetch from!" unless has_remotes?
       # If the output was empty, no actual fetch was done
       return !call_fetch.strip.empty?
     end
     
-    private
+    #
+    # Returns number of defined remotes or nil if no remotes are defined. Useful for
+    # if statements before doing fetches and whatnot.
+    #
+    # Works on current working dir, like most of the methods here.
+    #
+    def has_remotes?
+      remotes = call_remotes_list.strip.split("\n").size
+      return nil if remotes == 0
+      remotes
+    end
+    
+    #
+    # Returns true if current working dir is inside a git repository. False otherwise.
+    #
+    def in_repo?
+      call_repo_discovery
+    end
+    
+    protected
       # Do the actual system call for "git fetch", returning output
       def call_fetch
         output = `git fetch 2>&1`
@@ -97,5 +117,16 @@ class GitRemoteMonitor::GitWrapper
       def call_get_remote(local_name)
         `git config branch.#{local_name}.remote`
       end
+      
+      def call_remotes_list
+        `git branch -r --no-color`
+      end
+      
+      # Runs a simple plumbing command to quickly see if there is a repository in current working dir.
+      # Returns true or false depending on success in calling the command.
+      def call_repo_discovery
+        `git show-ref`
+        $?.success?
+      end
   end
 end

data/lib/git_remote_monitor/monitor.rb

@@ -24,37 +24,47 @@
 # instance about the changes later on.
 #
 class GitRemoteMonitor::Monitor
+  attr_reader :name, :directory
+  
   def initialize(directory, interval, notifier, name = nil)
     @directory = directory
     @name      = name || File.basename(directory)
     @interval  = interval.to_i
     @notifier  = notifier
     
-    move_to_directory!(@directory)
+    self.class.move_to_directory!(@directory)
   end
   
   def start_monitoring!
-    while true
+    loop do
       notify! if GitRemoteMonitor::GitWrapper.fetch!
       sleep @interval
+      break unless should_loop_monitoring?
     end
   end
   
   protected
-  
+    
+    # This method is added only for easier testing. Might be usable in the future, though.
+    def should_loop_monitoring?
+      true
+    end
+    
     def notify!
       # Find out the status
       local = GitRemoteMonitor::GitWrapper.local_branch
       remote = GitRemoteMonitor::GitWrapper.remote_branch
       my_commits, their_commits = GitRemoteMonitor::GitWrapper.get_tracking_info(local, remote)
-      @notifier.notify_commits(@name, local, my_commits, their_commits)
-    end    
-  
-    def move_to_directory!(directory)
+      @notifier.notify_commits(self, local, my_commits, their_commits)
+    end
+    
+    def self.move_to_directory!(directory)
       unless File.exist?(directory) and File.directory?(directory)
         raise "#{directory} not found or not a directory"
       end
       Dir.chdir(directory)
+      raise "#{File.expand_path(directory)} is not part of a git repository" unless GitRemoteMonitor::GitWrapper.in_repo?
     end
+    
   
 end

data/lib/git_remote_monitor/notifier.rb

@@ -19,42 +19,21 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+#
+# In its current form, this class is not much more than simple glue between the monitor and the
+# whole notification system. Its primary use right now is to separate the logic properly. It
+# will hopefully be refactored quite a bit in the future.
+#
 class GitRemoteMonitor::Notifier
   
-  def initialize()
-    # TODO: Auto-discover notification systems and load the one the user have
-    # For now, just use meow. REMEMBER: Remove 'meow' from the bin/ script when
-    # this requirement changes here!
-    
-    require 'meow'
-    @notifier = ::Meow.new('git-remote-monitor')
+  def initialize
+    @notifier = GitRemoteMonitor::Notifiers.preferred_notifier.new
   end
   
-  def notify_commits(name, branch_name, local_commits, remote_commits)
-    message = get_message(local_commits, remote_commits)
-    if message
-      @notifier.notify("#{name} (#{branch_name})", message, :icon => "#{GitRemoteMonitor::PATH}/images/git-logo.png")
-    end
+  # FIXME: This method should probably be refactored later on. We shouldn't need this many arguments.
+  def notify_commits(monitor, branch_name, local_commits, remote_commits)
+    status = GitRemoteMonitor::Status.new(monitor, branch_name, local_commits, remote_commits)
+    @notifier.send_notification!(status)
   end
   
-  protected
-    def get_message(local_commits, remote_commits)
-      # If there aren't any commits on the remote, we just ignore
-      # this difference. It's because we don't want to notify the user
-      # that they are x commits before the remote.
-      unless remote_commits == 0
-
-        # Now, we can have this scenarios:
-        #   1. The branch has not diverged; user has no commits, but remote has.
-        #   2. The branch has diverged; both the user and the remote has commits
-        message = if local_commits > 0
-          "Diverged! Remote has #{remote_commits} new commits, and you have #{local_commits} commits to push."
-        else
-          "Remote got updated! Now #{remote_commits} commits in front of you."
-        end
-        return message
-      end
-      nil
-    end
-    
 end

data/lib/git_remote_monitor/notifiers.rb

@@ -0,0 +1,52 @@
+# The MIT License
+# Copyright © 2009 Magnus Bergmark
+# 
+# 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.
+
+#
+# This class is a mediator between the monitor and the actual notifier plugins.
+# It will give you information about which plugin the monitor should use and also
+# have the capability to tell you about the available plugins and all the defined
+# ones.
+#
+class GitRemoteMonitor::Notifiers
+  class << self
+    
+    # Returns the first plugin that is available; does not load any unneccessary stuff
+    # from plugins that will not be used.
+    def preferred_notifier
+      @preferred_notifier ||= notifier_plugins.find { |plugin| plugin.available? }
+    end
+    
+    # Returns an array of all plugins that are available for use; will load a lot of gems
+    # and libraries which you may not want to use.
+    def available_notifiers
+      @available_notifiers ||= notifier_plugins.find_all { |plugin| plugin.available? }
+    end
+    
+    # Returns an array of all defined plugins as classes.
+    def notifier_plugins
+      [Meow]
+    end
+    
+  end
+end
+
+require 'git_remote_monitor/notifiers/base'
+require 'git_remote_monitor/notifiers/meow'