terminitor 0.0.5 → 0.1.0

data/lib/terminitor/cores/konsole_core.rb

@@ -0,0 +1,54 @@
+module Terminitor
+  # KDE Konsole Core for Terminitor
+  # This Core manages all the interaction with Konsole's dbus interface 
+  class KonsoleCore < AbstractCore
+    def initialize(path)
+      super
+      bus = DBus::SessionBus.instance
+      @konsole_service = bus.service("org.kde.konsole")
+      @konsole = get_konsole
+    end
+ 
+    # Executes the Command
+    # execute_command 'cd /path/to', {}
+    def execute_command(cmd, options = {})
+      # add carriange return if missing, otherwise the command won't be executed
+      cmd += "\n" if (cmd =~ /\n\Z/).nil?
+      options[:in].sendText(cmd)
+    end
+
+    # Opens a new tab and returns itself.
+    def open_tab
+      session_number = @konsole.newSession
+      session_object = @konsole_service.object("/Sessions/#{session_number}")
+      session_object.introspect
+      session_object["org.kde.konsole.Session"]
+    end
+
+    # Opens a new window and returns the tab object.
+    def open_window
+      session_number = @konsole.currentSession
+      session_object = @konsole_service.object("/Sessions/#{session_number}")
+      session_object.introspect
+      session_object["org.kde.konsole.Session"]
+    end
+
+    protected
+
+    def get_konsole
+     begin
+        konsole_object = @konsole_service.object("/Konsole")
+        konsole_object.introspect
+        return konsole_object["org.kde.konsole.Konsole"]
+      rescue DBus::Error => e
+        if e.dbus_message.error_name =="org.freedesktop.DBus.Error.ServiceUnknown"
+          system "konsole"
+          sleep(2)
+          retry
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/terminitor/cores/mac_core.rb

@@ -0,0 +1,79 @@
+module Terminitor
+  # Mac OS X Core for Terminitor
+  # This Core manages all the interaction with Appscript and the Terminal
+  class MacCore < AbstractCore
+    include Appscript
+    
+    # Initialize @terminal with Terminal.app, Load the Windows, store the Termfile
+    # Terminitor::MacCore.new('/path')
+    def initialize(path)
+      super
+      @terminal = app('Terminal')
+      @windows  = @terminal.windows
+    end
+            
+    # executes the given command via appscript
+    # execute_command 'cd /path/to', :in => #<tab>
+    def execute_command(cmd, options = {})
+      active_window.do_script(cmd, options)
+    end
+
+    # Opens a new tab and returns itself.
+    def open_tab
+      super
+      terminal_process.keystroke("t", :using => :command_down)
+      return_last_tab
+    end
+
+    # Opens A New Window and returns the tab object.
+    def open_window
+      terminal_process.keystroke("n", :using => :command_down)
+      return_last_tab
+    end
+
+    # Returns the Terminal Process
+    # We need this method to workaround appscript so that we can instantiate new tabs and windows.
+    # otherwise it would have looked something like window.make(:new => :tab) but that doesn't work.
+    def terminal_process
+      app("System Events").application_processes["Terminal.app"]
+    end
+    
+    # Returns the last instantiated tab from active window
+    def return_last_tab
+      local_window = active_window
+      local_tabs = local_window.tabs if local_window
+      local_tabs.last.get if local_tabs
+    end
+
+    # returns the active window by checking if its the :frontmost 
+    def active_window
+      windows = @terminal.windows.get
+      windows.detect do |window|
+        window.properties_.get[:frontmost] rescue false
+      end
+    end
+
+    private
+    
+    # These methods are here for reference so I can ponder later
+    # how I could possibly use them.
+    # And Currently aren't tested. =(
+    
+    # returns a window by the id
+    def window_by_id(id)
+      @windows.ID(id)
+    end
+
+    # grabs the window id.
+    def window_id(window)
+      window.id_.get
+    end
+
+    # set_window_title #<Window>, "hi"
+    # Note: This sets all the windows to the same title.
+    def set_window_title(window, title)
+      window.custom_title.set(title)
+    end
+    
+  end
+end

data/lib/terminitor/dsl.rb

@@ -0,0 +1,81 @@
+module Terminitor
+  # This class parses the Termfile to fit the new Ruby Dsl Syntax
+  class Dsl
+
+    def initialize(path)
+      file = File.read(path)
+      @setup = []
+      @windows = { 'default' => {}}
+      @_context = @windows['default'] 
+      instance_eval(file)
+    end
+
+    # Contains all commands that will be run prior to the usual 'workflow'
+    # e.g bundle install, setup forks, etc ...
+    # setup "bundle install", "brew update"
+    # setup { run('bundle install') }
+    def setup(*commands, &block)
+      setup_tasks = @setup
+      if block_given?
+        @_context, @_old_context = setup_tasks, @_context
+        instance_eval(&block)
+        @_context = @_old_context
+      else
+        setup_tasks.concat(commands)
+      end
+    end
+
+    # sets command context to be run inside a specific window
+    # window('new window') { tab('ls','gitx') }
+    def window(name = nil, &block)
+      window_tabs = @windows[name || "window#{@windows.keys.size}"] = {}
+      @_context, @_old_context = window_tabs, @_context
+      instance_eval(&block)
+      @_context = @_old_context
+    end
+
+    # stores command in context
+    # run 'brew update'
+    def run(command)
+      @_context << command
+    end
+
+    # sets command context to be run inside specific tab
+    # tab('new tab') { run 'mate .' }
+    # tab 'ls', 'gitx'
+    def tab(name= nil, *commands, &block)
+      if block_given?
+        tab_tasks = @_context[name || "tab#{@_context.keys.size}"] = []
+        @_context, @_old_context = tab_tasks, @_context
+        instance_eval(&block)
+        @_context = @_old_context
+      else
+        tab_tasks = @_context["tab#{@_context.keys.size}"] = []
+        tab_tasks.concat([name] + commands)
+      end
+    end
+
+    # Returns yaml file as Terminitor formmatted hash
+    def to_hash
+      { :setup => @setup, :windows => @windows }
+    end
+
+
+    private
+
+    #
+    # in_context @setup, commands, &block
+    # in_context @tabs["name"], commands, &block
+    def in_context(tasks_instance,*commands, &block)
+      if block_given?
+        @_context, @_old_context = instance_variable_get(name), @_context
+        instance_eval(&block)
+        @_context = @_old_context
+      else
+        @setup << commands
+      end
+    end
+
+
+  end
+end

data/lib/terminitor/runner.rb

@@ -1,67 +1,103 @@
 module Terminitor
+  # This module contains all the helper methods for the Cli component.
   module Runner
 
+    # Finds the appropriate platform core, else say you don't got it.
+    # find_core RUBY_PLATFORM
+    def find_core(platform)
+      core = case platform.downcase
+      when %r{darwin} then Terminitor::MacCore
+      when %r{linux}  then Terminitor::KonsoleCore # TODO check for gnome and others
+      else nil
+      end
+    end
+
+    # Execute the core with the given method.
+    # execute_core :process!, 'project'
+    # execute_core :setup!, 'my_project'
+    def execute_core(method, project)
+      if path = resolve_path(project)
+        core = find_core(RUBY_PLATFORM)
+        core ? core.new(path).send(method) : say("No suitable core found!")
+      else
+        return_error_message(project)
+      end
+    end
+
     # opens doc in system designated editor
+    # open_in_editor '/path/to', 'nano'
     def open_in_editor(path, editor=nil)
       editor = editor || ENV['TERM_EDITOR'] || ENV['EDITOR']
       say "please set $EDITOR or $TERM_EDITOR in your .bash_profile." unless editor
       system("#{editor || 'open'} #{path}")
     end
 
-    def do_project(path)
-      terminal = app('Terminal')
-      tabs = load_config(path)
+    # returns path to file
+    # resolve_path 'my_project'
+    def resolve_path(project)
+      unless project.empty?
+        path = config_path(project, :yml) # Give old yml path
+        return path if File.exists?(path)
+        path = config_path(project, :term) # Give new term path.
+        return path if File.exists?(path)
+        nil
+      else
+        path = File.join(options[:root],"Termfile")
+        return path if File.exists?(path)
+        nil
+      end
+    end
 
-      tabs.each do |hash|
-        tabname = hash.keys.first
-        cmds = hash.values.first
+    # returns first line of file
+    # grab_comment_for_file '/path/to'
+    def grab_comment_for_file(file)
+      first_line = File.readlines(file).first
+      first_line =~ /^\s*?#/ ? ("-" + first_line.gsub("#","")) : "\n"
+    end
 
-        tab = self.open_tab(terminal)
-        cmds = [cmds].flatten
-        cmds.insert(0, "cd \"#{@working_dir}\" ; clear") unless @working_dir.to_s.empty?
-        cmds.each do |cmd|
-          terminal.windows.last.do_script(cmd, :in => tab)
-        end
+    # Return file in config_path
+    # config_path '/path/to', :term
+    def config_path(file, type = :yml)
+      return File.join(options[:root],"Termfile") if file.empty?
+      dir = File.join(ENV['HOME'],'.terminitor')
+      if type == :yml
+        File.join(dir, "#{file.sub(/\.yml$/, '')}.yml")
+      else
+        File.join(dir, "#{file.sub(/\.term$/, '')}.term")
       end
     end
 
-    def resolve_path(project)
+    # Returns error message depending if project is specified
+    # return_error_message 'hi
+    def return_error_message(project)
       unless project.empty?
-        File.join(ENV['HOME'],'.terminitor', "#{project.sub(/\.yml$/, '')}.yml")
+        say "'#{project}' doesn't exist! Please run 'terminitor open #{project.gsub(/\..*/,'')}'"
       else
-        File.join(options[:root],"Termfile")
+        say "Termfile doesn't exist! Please run 'terminitor open' in project directory"
       end
     end
 
-    def load_config(path)
-      YAML.load(File.read(path))
+    # This will clone a repo in the current directory.
+    # It will first try to clone via ssh(read/write),
+    # if not fall back to git-read only, else, fail.
+    def clone_repo(username, project)
+      github = `which github`
+      return false if github.empty?
+      command = "github clone #{username} #{project}"
+      system(command + " --ssh") || system(command)
     end
 
-    # somewhat hacky in that it requires Terminal to exist,
-    # which it would if we run this script from a Terminal,
-    # but it won't work if called e.g. from cron.
-    # The latter case would just require us to open a Terminal
-    # using do_script() first with no :in target.
-    #
-    # One more hack:  if we're getting the first tab, we return
-    # the term window's only current tab, else we send a CMD+T
-    def open_tab(terminal)
-      if @got_first_tab_already
-        app("System Events").application_processes["Terminal.app"].keystroke("t", :using => :command_down)
+    # Fetch the git repo and run the setup block
+    # fetch_repo 'achiu', 'terminitor', :setup => true
+    def fetch_repo(username, project, options ={})
+      if clone_repo(username, project)
+        path = File.join(Dir.pwd, project)
+        FileUtils.cd(path)
+        invoke(:setup, []) if options[:setup]
+      else
+        say("could not fetch repo!")
       end
-      @got_first_tab_already = true
-      local_window = active_window(terminal)
-      @working_dir = Dir.pwd
-      local_tabs = local_window.tabs if local_window
-      local_tabs.last.get if local_tabs
     end
 
-    # makes sure to set active window as frontmost.
-    def active_window(terminal)
-      (1..terminal.windows.count).each do |i|
-        window = terminal.windows[i]
-        return window if window.properties_.get[:frontmost]
-      end
-    end
   end
 end

data/lib/terminitor/version.rb

@@ -1,3 +1,3 @@
 module Terminitor
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/lib/terminitor/yaml.rb

@@ -0,0 +1,20 @@
+require 'yaml'
+
+module Terminitor
+  # This class holds the legacy YAML sytnax for Terminitor
+  class Yaml
+    attr_accessor :file
+    
+    # Load in the Yaml file...
+    def initialize(path)
+      @file = YAML.load File.read(path)
+    end
+    
+    # Returns yaml file as Terminitor formmatted hash
+    def to_hash
+      combined = @file.inject({}) {|base, item| base.merge!(item) ; base } # merge the array of hashes.
+      { :setup => nil, :windows => { 'default' => combined } }
+    end
+
+  end
+end

data/templates/example.yml.tt

@@ -0,0 +1,16 @@
+# COMMENT OF SCRIPT HERE
+# you can make as many tabs as you wish...
+# tab names are actually arbitrary at this point too.
+---
+- tab1:
+  - cd ~/foo/bar
+  - gitx
+- tab2:
+  - mysql -u root
+  - use test;
+  - show tables;
+- tab3: echo "hello world"
+- tab4: cd ~/baz/ && git pull
+- tab5:
+  - cd ~/foo/project
+  - autotest

data/terminitor.gemspec

@@ -13,17 +13,24 @@ Gem::Specification.new do |s|
 
   s.required_rubygems_version = ">= 1.3.6"
   s.rubyforge_project         = "terminitor"
-
-  s.add_dependency "rb-appscript"
+  
+  # Platform Specific Dependencies
+  case RUBY_PLATFORM.downcase
+  when %r{darwin}
+    s.add_dependency "rb-appscript"
+  else
+  end
+  
   s.add_dependency "thor", "~>0.14.0"
+  s.add_dependency "github"
   s.add_development_dependency "bundler", "~>1.0.0"
-  s.add_development_dependency "riot", "~>0.14.0"
+  s.add_development_dependency "riot", "~>0.11.0"
   s.add_development_dependency "rr"
   s.add_development_dependency "fakefs"
   s.post_install_message = %q{********************************************************************************
 
     Terminitor is installed! 
-    Please run 'terminitor setup'. 
+    Please run 'terminitor init'. 
     This will create a directory at ~/.terminitor which will hold all your global scripts.
     Thanks!
 

data/test.watchr

@@ -0,0 +1,70 @@
+ENV["WATCHR"] = "1"
+system 'clear'
+
+def growl(message)
+  growlnotify = `which growlnotify`.chomp
+  title = "Watchr Test Results"
+  image = message.include?('0 failures, 0 errors') ? "~/.watchr_images/passed.png" : "~/.watchr_images/failed.png"
+  options = "-w -n Watchr --image '#{File.expand_path(image)}' -m '#{message}' '#{title}'"
+  system %(#{growlnotify} #{options} &)
+end
+
+def run(cmd)
+  puts(cmd)
+  `#{cmd}`
+end
+
+def run_test_file(file)
+  system('clear')
+  result = run(%Q(ruby -I"lib:test" -rubygems #{file}))
+  growl result.split("\n").last rescue nil
+  puts result
+end
+
+def run_all_tests
+  system('clear')
+  result = run "rake test"
+  growl result.split("\n").last rescue nil
+  puts result
+end
+
+def run_all_features
+  system('clear')
+  run "cucumber"
+end
+
+def related_test_files(path)
+  Dir['test/**/*.rb'].select { |file| file =~ /#{File.basename(path).split(".").first}_test.rb/ }
+end
+
+def run_suite
+  run_all_tests
+  # run_all_features
+end
+
+watch('test/teststrap\.rb') { run_all_tests }
+watch('test/(.*).*_test\.rb') { |m| run_test_file(m[0]) }
+watch('lib/.*/.*\.rb') { |m| related_test_files(m[0]).map {|tf| run_test_file(tf) } }
+# watch('features/.*/.*\.feature') { run_all_features }
+
+# Ctrl-\
+Signal.trap 'QUIT' do
+  puts " --- Running all tests ---\n\n"
+  run_all_tests
+end
+
+@interrupted = false
+
+# Ctrl-C
+Signal.trap 'INT' do
+  if @interrupted then
+    @wants_to_quit = true
+    abort("\n")
+  else
+    puts "Interrupt a second time to quit"
+    @interrupted = true
+    Kernel.sleep 1.5
+    # raise Interrupt, nil # let the run loop catch it
+    run_suite
+  end
+end