watch_tower 0.0.1.beta5 → 0.0.1.beta6

data/lib/watch_tower.rb

@@ -22,6 +22,7 @@ TEMPLATE_PATH = File.join(LIB_PATH, 'templates')
 USER_PATH = File.expand_path(File.join(ENV['HOME'], '.watch_tower'))
 DATABASE_PATH = File.join(USER_PATH, 'databases')
 LOG_PATH = File.join(USER_PATH, 'log')
+EDITOR_EXTENSIONS_PATH = File.join(LIB_PATH, 'editor', 'extensions')
 
 # Define the environment by default set to development
 ENV['WATCH_TOWER_ENV'] ||= 'development'
@@ -33,6 +34,8 @@ FileUtils.mkdir_p LOG_PATH
 
 # module WatchTower
 module WatchTower
+  # Make sure all the methods are available as both Class and Instance methods.
+  extend self
 
   # Create a logger
   LOG = Logger.new(File.join(LOG_PATH, "#{ENV['WATCH_TOWER_ENV']}.log"))
@@ -44,23 +47,40 @@ module WatchTower
   # Returh the threads
   #
   # @return [Hash] Threads
-  def self.threads
+  def threads
     @@threads
   end
 
   # Get WatchTower's environment
   #
   # @return [String] The current environment
-  def self.env
+  def env
     ENV['WATCH_TOWER_ENV']
   end
 
   # Set WatchTower's environment
   #
   # @param [String] The environment
-  def self.env=(environment)
+  def env=(environment)
     ENV['WATCH_TOWER_ENV'] = environment
   end
+
+  # Cross-platform way of finding an executable in the $PATH.
+  #
+  # Taken from hub
+  # https://github.com/defunkt/hub/blob/master/lib/hub/context.rb#L186
+  #
+  # which('ruby') #=> /usr/bin/ruby
+  def which(cmd)
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+      exts.each { |ext|
+        exe = "#{path}/#{cmd}#{ext}"
+        return exe if File.executable? exe
+      }
+    end
+    return nil
+  end
 end
 
 # Make sure we are running UTF-8
@@ -76,4 +96,4 @@ require "watch_tower/editor"
 require "watch_tower/project"
 require "watch_tower/eye"
 require "watch_tower/file_tree"
-require "watch_tower/server"
+require "watch_tower/server"

data/spec/watch_tower/appscript_spec.rb

@@ -8,33 +8,9 @@ module ::Appscript
         extend ::Appscript
       end
     end
-    describe "#app" do
 
+    describe "#app" do
       it { should respond_to :app }
-
-      it "should return an instance of Application" do
-        subject.app.should be_instance_of ::Appscript::Application
-      end
-    end
-
-    describe "#its" do
-      it { should respond_to :its }
-    end
-
-    describe "#name" do
-      it { should respond_to :name }
-    end
-  end
-
-  describe "Application" do
-    subject { ::Appscript.app('TextMate') }
-
-    [:name, :version, :processes, :unix_id, :by_pid, :is_running?].each do |method|
-      it "should respond to #{method}" do
-        -> {
-          subject.send(method)
-        }.should_not raise_error NoMethodError
-      end
     end
   end
 end

data/spec/watch_tower/editor/textmate_spec.rb

@@ -2,21 +2,41 @@ require 'spec_helper'
 
 module Editor
   describe Textmate do
+    before(:each) do
+      @file_path = '/path/to/file.rb'
+      @app = mock()
+      @app.stubs(:is_running?).returns(true)
+      @documents = mock
+      @document = mock
+      @path = mock
+      @path.stubs(:get).returns(@file_path)
+      @document.stubs(:path).returns(@path)
+      @documents.stubs(:get).returns([@document])
+      @app.stubs(:document).returns(@documents)
+      @name = mock
+      @name.stubs(:get).returns("TextMate")
+      @app.stubs(:name).returns(@name)
+      @version = mock
+      @version.stubs(:get).returns("1.5.10")
+      @app.stubs(:version).returns(@version)
+      Textmate.any_instance.stubs(:editor).returns(@app)
+    end
+
     it { should respond_to :current_path }
 
     it { should respond_to :name }
     its(:name) { should_not raise_error NotImplementedError }
+    its(:name) { should_not be_empty }
 
     it { should respond_to :version }
     its(:version) { should_not raise_error NotImplementedError }
+    its(:version) { should_not be_empty }
 
     describe "#is_running?" do
       it { should respond_to :is_running? }
 
       it "should return wether Textmate is running or not" do
-        app = mock()
-        app.expects(:is_running?).returns(true).once
-        Textmate.any_instance.stubs(:editor).returns(app)
+        @app.expects(:is_running?).returns(true).once
 
         subject.is_running?.should be_true
       end
@@ -26,24 +46,19 @@ module Editor
       it { should respond_to :current_path }
 
       it "should return the current_path if textmate running" do
-        app = mock()
-        app.expects(:is_running?).returns(true).once
-        documents = mock
-        document = mock
-        path = mock
-        path.expects(:get).returns('/path/to/file.rb')
-        document.expects(:path).returns(path).once
-        documents.expects(:get).returns([document]).once
-        app.expects(:document).returns(documents).once
-        Textmate.any_instance.stubs(:editor).returns(app)
-
-        subject.current_path.should == '/path/to/file.rb'
+        @app.expects(:is_running?).returns(true).once
+        @path.expects(:get).returns(@file_path).once
+        @document.expects(:path).returns(@path).once
+        @documents.expects(:get).returns([@document]).once
+        @app.expects(:document).returns(@documents).once
+        Textmate.any_instance.stubs(:editor).returns(@app)
+
+        subject.current_path.should == @file_path
       end
 
       it "should return nil if textmate ain't running" do
-        app = mock()
-        app.expects(:is_running?).returns(false).once
-        Textmate.any_instance.stubs(:editor).returns(app)
+        @app.expects(:is_running?).returns(false).once
+        Textmate.any_instance.stubs(:editor).returns(@app)
 
         subject.current_path.should be_nil
       end
@@ -53,28 +68,23 @@ module Editor
       it { should respond_to :current_paths }
 
       it "should return the current_paths if textmate running" do
-        app = mock()
-        app.expects(:is_running?).returns(true).once
-        documents = mock
-        document = mock
-        path = mock
-        path.expects(:get).returns('/path/to/file.rb')
-        document.expects(:path).returns(path).once
-        documents.expects(:get).returns([document]).once
-        app.expects(:document).returns(documents).once
-        Textmate.any_instance.stubs(:editor).returns(app)
-
-        subject.current_paths.should == ['/path/to/file.rb']
+        @app.expects(:is_running?).returns(true).once
+        @path.expects(:get).returns(@file_path).once
+        @document.expects(:path).returns(@path).once
+        @documents.expects(:get).returns([@document]).once
+        @app.expects(:document).returns(@documents).once
+        Textmate.any_instance.stubs(:editor).returns(@app)
+
+        subject.current_paths.should == [@file_path]
       end
 
       it "should return nil if textmate ain't running" do
-        app = mock()
-        app.expects(:is_running?).returns(false).once
-        Textmate.any_instance.stubs(:editor).returns(app)
+        @app.expects(:is_running?).returns(false).once
+        Textmate.any_instance.stubs(:editor).returns(@app)
 
         subject.current_paths.should be_nil
       end
     end
 
   end
-end
+end

data/spec/watch_tower/editor/vim_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+module Editor
+  describe Vim do
+    before(:each) do
+      # Stubs which
+      WatchTower.stubs(:which).with('vim').returns('/usr/bin/vim')
+      WatchTower.stubs(:which).with('gvim').returns('/usr/bin/gvim')
+      WatchTower.stubs(:which).with('mvim').returns(nil)
+
+      # Stub systemu
+      Vim.any_instance.stubs(:systemu).with("/usr/bin/vim --help").returns([0, "", ""])
+      Vim.any_instance.stubs(:systemu).with("/usr/bin/gvim --help").returns([0, "--remote server", ""])
+      Vim.any_instance.stubs(:systemu).with("/usr/bin/gvim --servername VIM --remote-send ':source #{Vim::VIM_EXTENSION_PATH}<CR>'")
+      Vim.any_instance.stubs(:systemu).with("/usr/bin/gvim --servername VIM --remote-expr 'watchtower#ls()'").returns([0, <<-EOS, ''])
+/path/to/file.rb
+EOS
+      Vim.any_instance.stubs(:systemu).with('/usr/bin/gvim --serverlist').returns([0, <<-EOC, ''])
+VIM
+EOC
+      Vim.any_instance.stubs(:systemu).with("/usr/bin/gvim --version").
+        returns [0, <<-EOV, '']
+VIM - Vi IMproved 7.3 (2010 Aug 15)
+Included patches: 1-202, 204-222, 224-322
+Compiled by 'http://www.opensuse.org/'
+Huge version without GUI.  Features included (+) or not (-):
++arabic +autocmd -balloon_eval -browse ++builtin_terms +byte_offset +cindent
+-clientserver -clipboard +cmdline_compl +cmdline_hist +cmdline_info +comments
++conceal +cryptv +cscope +cursorbind +cursorshape +dialog_con +diff +digraphs
+-dnd -ebcdic +emacs_tags +eval +ex_extra +extra_search +farsi +file_in_path
++find_in_path +float +folding -footer +fork() +gettext -hangul_input +iconv
++insert_expand +jumplist +keymap +langmap +libcall +linebreak +lispindent
++listcmds +localmap -lua +menu +mksession +modify_fname +mouse -mouseshape
++mouse_dec -mouse_gpm -mouse_jsbterm +mouse_netterm -mouse_sysmouse
++mouse_xterm +multi_byte +multi_lang -mzscheme +netbeans_intg +path_extra -perl
+ +persistent_undo +postscript +printer +profile -python -python3 +quickfix
++reltime +rightleft -ruby +scrollbind +signs +smartindent +sniff +startuptime
++statusline -sun_workshop +syntax +tag_binary +tag_old_static -tag_any_white
+-tcl +terminfo +termresponse +textobjects +title -toolbar +user_commands
++vertsplit +virtualedit +visual +visualextra +viminfo +vreplace +wildignore
++wildmenu +windows +writebackup -X11 -xfontset -xim -xsmp -xterm_clipboard
+-xterm_save
+   system vimrc file: "/etc/vimrc"
+     user vimrc file: "$HOME/.vimrc"
+      user exrc file: "$HOME/.exrc"
+  fall-back for $VIM: "/etc"
+ f-b for $VIMRUNTIME: "/usr/share/vim/current"
+Compilation: gcc -c -I. -Iproto -DHAVE_CONFIG_H   -I/usr/local/include  -fmessage-length=0 -O2 -Wall -D_FORTIFY_SOURCE=2 -fstack-protector -funwind-tables -fasynchronous-unwind-tables -g -Wall -pipe -fno-strict-aliasing -fstack-protector-all
+Linking: gcc   -L/usr/local/lib -Wl,--as-needed -o vim       -lm -lnsl  -lncurses -lacl -lattr -ldl
+EOV
+    end
+
+    it { should respond_to :name }
+    its(:name) { should_not raise_error NotImplementedError }
+    its(:name) { should_not be_empty }
+
+    it { should respond_to :version }
+    its(:version) { should_not raise_error NotImplementedError }
+    its(:version) { should_not be_empty }
+    its(:version) { should == '7.3' }
+
+    describe "#supported_vims" do
+      it { should respond_to :supported_vims }
+
+      it "should return gvim" do
+        Vim.any_instance.expects(:systemu).with("/usr/bin/vim --help").returns([0, "", ""]).once
+        Vim.any_instance.expects(:systemu).with("/usr/bin/gvim --help").returns([0, "--remote server", ""]).once
+        WatchTower.expects(:which).with('vim').returns('/usr/bin/vim').once
+        WatchTower.expects(:which).with('gvim').returns('/usr/bin/gvim').once
+        WatchTower.expects(:which).with('mvim').returns(nil).once
+
+        subject.send :supported_vims
+        subject.instance_variable_get('@vims').should == ['/usr/bin/gvim']
+      end
+    end
+
+    describe "#editor" do
+      it { should respond_to :editor }
+
+      it "should return /usr/bin/gvim" do
+        subject.send(:editor).should == '/usr/bin/gvim'
+      end
+    end
+
+    describe "#servers" do
+      it { should respond_to :servers }
+
+      it "should return VIM" do
+        Vim.any_instance.expects(:systemu).with('/usr/bin/gvim --serverlist').returns([0, <<-EOC, '']).once
+VIM
+EOC
+        subject.send(:servers).should == ['VIM']
+      end
+    end
+
+    describe "#send_extensions_to_editor" do
+      it { should respond_to :send_extensions_to_editor }
+
+      it "should send the extensions to vim" do
+        Vim.any_instance.expects(:systemu).with("/usr/bin/gvim --servername VIM --remote-send ':source #{Vim::VIM_EXTENSION_PATH}<CR>'").once
+
+        subject.send :send_extensions_to_editor
+      end
+    end
+
+    describe "#is_running?" do
+      it { should respond_to :is_running? }
+
+      it "should return true if ViM is running" do
+        subject.is_running?.should be_true
+      end
+    end
+
+    describe "#current_paths" do
+      it { should respond_to :current_paths }
+
+      it "should call is_running?" do
+        Vim.any_instance.expects(:is_running?).returns(false).once
+
+        subject.current_paths
+      end
+
+      it "should call send_extensions_to_editor" do
+        Vim.any_instance.expects(:send_extensions_to_editor).once
+
+        subject.current_paths
+      end
+
+      it "should be nil if is_running? is false" do
+        Vim.any_instance.stubs(:is_running?).returns(false)
+
+        subject.current_paths.should be_nil
+      end
+
+      it "should be able to parse ls output" do
+        Vim.any_instance.expects(:systemu).with("/usr/bin/gvim --servername VIM --remote-expr 'watchtower#ls()'").returns([0, <<-EOS, '']).once
+/path/to/file.rb
+/path/to/file2.rb
+EOS
+
+        documents = subject.current_paths
+        documents.should include("/path/to/file.rb")
+        documents.should include("/path/to/file2.rb")
+      end
+
+      it "should not return duplicate documents" do
+        Vim.any_instance.expects(:systemu).with("/usr/bin/gvim --servername VIM --remote-expr 'watchtower#ls()'").returns([0, <<-EOS, '']).once
+/path/to/file.rb
+/path/to/file.rb
+/path/to/file.rb
+/path/to/file.rb
+/path/to/file.rb
+EOS
+
+        documents = subject.current_paths
+        documents.should include("/path/to/file.rb")
+        documents.size.should == 1
+      end
+    end
+
+  end
+end

data/spec/watch_tower/eye_spec.rb

@@ -10,6 +10,7 @@ describe Eye do
     @project_path = '/home/user/Code/OpenSource/watch_tower'
     @project_name = 'watch_tower'
     ::File.stubs(:exists?).with(@file_path).returns(true)
+    ::File.stubs(:file?).with(@file_path).returns(true)
 
     # Mock the editor
     @editor = mock
@@ -74,6 +75,12 @@ describe Eye do
       subject.start
     end
 
+    it "should call File.file?" do
+      ::File.expects(:file?).with(@file_path).returns(true).once
+
+      subject.start
+    end
+
     it "shouldn't add the file if it matches the ignore list" do
       ignored_path = '/path/to/project/.git/COMMIT_MESSAGE'
       ::File.stubs(:exists?).with(ignored_path).returns(true)

data/watch_tower.gemspec

@@ -10,17 +10,28 @@ Gem::Specification.new do |s|
   s.email       = ["wael.nasreddine@gmail.com"]
   s.homepage    = "https://github.com/TechnoGate/watch_tower"
   s.summary     = <<-MSG
-WatchTower helps you track the time you spend on each project and on each file
-in the projects.
+WatchTower helps you track how much time you spend on all of your projects, at
+the project, directory, and file level.
 MSG
   s.description = <<-MSG
-Did you ever wonder how much each of your projects really costs? Watch Tower
-comes to the rescue.
-
-WatchTower runs in the background and monitors your editors and records the
-time you spend on each file and thus on the project in total. Using a simple
-but powerful web interface, you can view details and statistics about each
-project and each file.
+Did you ever want to keep track of how much time you _really_ spend on all of
+your projects? Sure, you can try to remember to keep running estimates of your
+time in the hope that you can aggregate those estimates later into some
+meaningful data. But sometimes you forget, or an error creeps into your
+estimate. And those errors add up. Quickly.
+
+You can try some tracking software that depends on you to start and stop
+timers. But what happens if you forget to start or stop one of those timers?
+
+What you need is a passive system that will take care of all of this for you,
+so you can focus on the actual work, which is where WatchTower comes into
+play.
+
+WatchTower runs in the background and keeps track of the time spent editing
+each file with one of the supported editors (listed below). Since WatchTower
+keeps track of the time spent on each file, and it knows which project each
+file belongs to, you can view details and statistics on each project, right
+down to the file level.
 MSG
 
   s.files         = `git ls-files`.split("\n")
@@ -58,6 +69,12 @@ MSG
   s.add_dependency 'sass', '~>3.1.10'
   s.add_dependency 'sprockets', '~>2.0.2'
 
+  # System commands
+  s.add_dependency 'systemu', '~>2.4.0'
+
+  # Crontab editor
+  s.add_dependency 'cronedit', '~>0.3.0' if RbConfig::CONFIG['target_os'] =~ /linux/i
+
   ####
   # Development dependencies
   ####
@@ -94,4 +111,4 @@ MSG
   # Debugging
   ####
   s.add_development_dependency 'pry', '~>0.9.6.2'
-end
+end