hilfer 0.9.0

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.1.1 / 2008-03-10
+
+* package as Gem using Hoe
+
+  * yes, really.
+

data/README.txt

@@ -0,0 +1,49 @@
+= hilfer
+
+* http://www.semiosix.com/hilfer
+
+== DESCRIPTION:
+
+Directory browser with plenty of keyboard shortcuts and integration with scite
+rails and subversion
+
+== FEATURES/PROBLEMS:
+
+See TODO list
+
+== SYNOPSIS:
+
+  hilfer [directory]
+
+== REQUIREMENTS:
+
+ruby-gtk2
+
+== INSTALL:
+
+sudo gem install
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 FIX
+
+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.

data/bin/ec

@@ -0,0 +1,9 @@
+#! /bin/bash
+pipe=` cat /tmp/$USER.hilfer.scite`
+if [ x$1 == x ]; then
+	wd=`pwd`
+else
+	wd=$1
+fi
+
+test -e $pipe && echo cwd:$wd >$pipe

data/bin/hilfer

@@ -0,0 +1,260 @@
+#!/usr/bin/ruby
+
+require 'yaml'
+require 'pathname'
+
+require 'hilfer/tree_viewer.rb'
+
+require 'optparse'
+
+# defaults
+$options = { :debug => false, :hidden => false, :auto_sync => false, :quit_editor => false }
+
+oparser = OptionParser.new
+oparser.on( '-y', '--auto-sync', 'track editor current file changes') { |o| $options[:host] = true }
+oparser.on( '-s', '--show-hidden', 'Show hidden files' ) { |o| $options[:user] = true }
+oparser.on( '-D', '-d', '-v', '--debug' ) { |o| $options[:debug] = true }
+oparser.on( '-q', '--quit-editor', 'close editor on shutdown' ) { |o| puts "o: #{o.inspect}"; $options[:quit_editor] = true }
+
+oparser.on( '-h', '-?', '--help' ) do |o|
+  puts oparser.to_s
+  exit( 0 )
+end
+
+# remove parsed options
+ARGV = args = oparser.parse( ARGV )
+
+# this must come after options parsing or it tries to eat the options
+require 'gtk2'
+
+# NOTE no space after comma, trailing comma is so
+# that bold, italic etc and font size can be specified
+FIXED_FONT = "Lucida Console,Courier New,"
+CONFIG_FILE = File.expand_path( '~/.hilfer' )
+
+=begin rdoc
+HilferItems are stored in the TreeModel
+- item is the display name (ie filename and extension)
+- path is the full pathname, expanded, unqualified etc etc
+- last_child_used is the GtkTreeView path of the last child of a directory
+ node that had selection
+- status is either :expanded or :collapsed
+- populated is whether or not this directory node has been populated
+from the filesystem. To aid in recursively populating the tree
+=end
+class HilferItem
+  attr_accessor :item, :path, :last_child_used, :status, :svn_status, :colour
+  attr_writer :populated
+
+  def initialize( item, path )
+    @item = item
+    @path = path
+    @dir = File.directory? path
+    @populated = false
+    @status = :collapsed
+    @colour = '#000'
+  end
+
+  def dir?
+    @dir
+  end
+
+  def to_s
+    @item
+  end
+
+  # always return true for file nodes
+  def populated?
+    if !dir?
+      true
+    else
+      @populated
+    end
+  end
+
+  # always return false for file nodes
+  def expanded?
+    if !dir?
+      false
+    else
+      @status == :expanded
+    end
+  end
+
+end
+
+=begin rdoc
+Knows how to lauch gnome-terminal with mutiple tabs,
+each opened on a different directory
+=end
+class GnomeTerminal
+  def launch( dirs )
+    # construct arguments and launch
+    args = [ "gnome-terminal" ]
+    dirs.uniq.each do |x|
+      # first one will be a window, subsequent ones are tabs
+      args << ( args.size == 1 ? '--window' : '--tab' )
+      args << "--working-directory=#{x}"
+    end
+    system( *args )
+  end
+end
+
+=begin rdoc
+Just launches xterm. I couldn't figure out how to open it in different
+directories.
+
+use it by saying
+
+  $options[:terminal] = Xterm.new
+
+before the call to TreeViewer.new
+=end
+class Xterm
+  def launch( dirs )
+    system( 'xterm &' )
+  end
+end
+
+# yes, this actually does catch method calls polymorphically
+# but you can't change the TreePath or TreeIter that are returned
+class HilferModel < Gtk::TreeStore
+  def initialize( *args )
+    super
+  end
+
+  def ancestor?( iter, descendant )
+    print "testing #{iter[0]} against #{descendant}\n" if $options[:debug]
+    super
+  end
+end
+
+=begin rdoc
+Read and write configuration to ~/.hilfer in yaml.
+Currently only writes window position
+=end
+class HilferConfig
+
+  def initialize( file, window, count )
+    @file, @window = file, window
+
+    if File.file? CONFIG_FILE
+      config = YAML.load_file CONFIG_FILE
+      @window.set_default_size( *config[:size] )
+      @window.show_all
+      # move must be after show_all otherwise it
+      # gets overridden
+      @window.move( *config[:position] ) if count == 1
+    else
+      @window.set_default_size( 300,700 ).show_all
+    end
+  end
+
+  # save config
+  def save
+    config = {
+      :path => @window.title,
+      :position => @window.position,
+      :size => @window.size
+    }
+    File.open( CONFIG_FILE, 'w' ) { |file| file.print config.to_yaml }
+  end
+
+end
+
+=begin rdoc
+Layout of the Tree Viewer Window.
+=end
+class TreeViewerWindow
+  @@window_count = 0
+
+  def initialize( root_fs_path, editor )
+    @window = Gtk::Window.new
+
+    # initialize viewer with a path
+    @editor = editor
+
+    # location bar
+    @location = Gtk::Entry.new
+
+    @tv = TreeViewer.new( root_fs_path, editor, @window, @location )
+
+    # add scrollbars
+    @scroll = Gtk::ScrolledWindow.new( nil, nil )
+    @scroll.set_policy( Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC )
+    @scroll.add( @tv.view )
+
+    # expand and fill
+    @vbox = Gtk::VBox.new( false )
+    @vbox.pack_start( @location, false, false )
+    @vbox.pack_start( @scroll, true, true )
+    @vbox.focus_chain = [@scroll, @location]
+
+    icon_path = find_icon_path
+    if icon_path != nil
+      @window.icon = Gdk::Pixbuf.new( icon_path )
+    end
+    @window.title = 'Hilfer ' + @tv.root_item.path
+    @window.add( @vbox )
+
+    # read config. OK, the last parameter is a hack
+    # but we need it so that new windows aren't show in
+    # exactly the same position and it looks like nothing
+    # has happened
+    @@window_count += 1
+    @hc = HilferConfig.new( CONFIG_FILE, @window, @@window_count )
+
+    # set first line selected
+    @tv.select_first
+
+    # The program will directly end upon 'delete_event', ie window close
+    @window.signal_connect( 'delete_event' ) do
+      # unregister view from editor
+      @editor.unregister_view( @tv )
+      # finish
+      @@window_count -= 1
+      if @@window_count == 0
+        @hc.save
+        # this MUST come before cleanup, otherwise
+        # there will be no pipes to write the command to
+        @editor.quit
+        # delete command pipe files
+        @editor.cleanup
+        Gtk.main_quit
+        false
+      end
+    end
+    
+    # to allow the sd command to find the correct editor instance
+    @window.signal_connect 'focus-in-event' do |widget,event|
+      @editor.write_pipe_name
+      false
+    end
+
+    # to allow the sd command to find the correct editor instance
+    @window.signal_connect 'focus-out-event' do |widget,event|
+      @editor.write_pipe_name
+      false
+    end
+  end
+
+  def find_icon_path
+    $LOAD_PATH.grep( /hilfer/ ).each do |path|
+      png_file = Pathname.new( path ) + 'hilfer-icon.png'
+      return png_file.to_s if png_file.exist?
+    end
+    nil
+  end
+end
+
+
+################
+# Main script
+
+tvw = TreeViewerWindow.new(
+  File.expand_path( ARGV[0] || '.' ),
+  SciteEditor.new
+)
+
+# and off we go...
+Gtk.main

data/bin/sd

@@ -0,0 +1,17 @@
+#! /bin/bash
+pipe=`cat /tmp/$USER.hilfer.scite`
+director=/tmp/$USER.scite.director
+wd=`pwd`
+if [ -e $pipe ]; then
+	for name in $@; do
+		echo open:$wd/$name >$pipe;
+	done
+else
+	test -e $pipe && /bin/rm $pipe
+	test -e $director && /bin/rm $director
+	/usr/bin/mkfifo $director
+	/usr/bin/scite \
+		-ipc.director.name=$director \
+		-ipc.scite.name=$pipe \
+		$@ &
+fi

data/lib/hilfer/rails_locator.rb

@@ -0,0 +1,150 @@
+require 'active_support'
+
+=begin
+This handles various keypresses that jump to specific
+locations in a Rails project. If a specific file isn't
+selected, the jump will go to the directory. Otherwise
+it will go to a specific file.
+
+For example, if user_controller.rb is currently selected
+and Ctrl-Shift-T is pressed, user_controller_test.rb will
+be selected.
+
+TODO fix multiple selections
+=end
+class RailsLocator
+  attr_accessor :treeviewer
+  
+  def initialize( treeviewer )
+    @treeviewer = treeviewer
+    
+    @controller_re =       %r|^(.*?)/app/controllers/(.*?)/?(.*?)_controller.rb$|
+    @view_re =             %r|^(.*?)/app/views/(.*?)/?([^/.]*?\..*?)?$|
+    @model_re =            %r|^(.*?)/app/models/(.*?/?)([^/.]*?).rb$|
+    @unit_test_re =        %r|^(.*?)/test/unit/(.*?/?)(.*?)_test.rb$|
+    @functional_test_re =  %r|^(.*?)/test/functional/(.*?/?)(.*?)_controller_test.rb$|
+    @fixture_re =          %r|^(.*?)/test/fixtures/(.*?/?)(.*?).yml$|
+  end
+
+  # this does the common code for each keypress
+  # the block should return a related path for 
+  # the particular keypress on the currently selected
+  # item
+  def select_related_paths( widget, event, &block )
+    items = []
+    paths_to_select = []
+    widget.selection.selected_each do
+      |model, path, iter|
+      item = model.get_value( iter, 0 )
+      puts "item: #{item.path}" if $options[:debug]
+      new_rails_path = yield( item )
+      puts "new_rails_path #{new_rails_path}" if $options[:debug]
+      paths_to_select << rails_root + new_rails_path
+    end
+    
+    treeviewer.select_fs_paths( paths_to_select, true )
+  end
+  
+  def rails_root
+    treeviewer.root_item.path
+  end
+  
+  def goto_rails_path( fs_path )
+    treeviewer.select_fs_path( rails_root + fs_path, true )
+  end
+  
+  def handle_keypress( widget, event )
+    retval = true
+    case
+    # Shift-Ctrl-V - go to view, or view dir
+    when event.hardware_keycode == 55 && event.state.control_mask?  && event.state.shift_mask?
+      select_related_paths( widget, event ) do |item|
+        case
+          when @controller_re.match( item.path )
+            '/app/views/' + $2 + $3
+          when @functional_test_re.match( item.path )
+            '/app/views/' + $2 + $3
+          else
+            '/app/views'
+        end
+      end
+      
+    # Shift-Ctrl-C - go to controller, or controller dir
+    when event.hardware_keycode == 54 && event.state.control_mask?  && event.state.shift_mask?
+      select_related_paths( widget, event ) do |item|
+        case
+          when md = @view_re.match( item.path )
+            '/app/controllers/' + $2 + '_controller.rb'
+          when md = @functional_test_re.match( item.path )
+            '/app/controllers/' + $2 + $3 + '_controller.rb'
+          else
+            '/app/controllers'
+        end
+      end
+      
+    # Shift-Ctrl-M - go to model, or model dir
+    when event.hardware_keycode == 58 && event.state.control_mask? && event.state.shift_mask?
+      select_related_paths( widget, event ) do |item|
+        case
+        when md = @unit_test_re.match( item.path )
+          '/app/models' + $2 + '/' + $3 + '.rb'
+        when md = @fixture_re.match( item.path )
+          '/app/models' + $2 + '/' + $3.singularize + '.rb'
+        else
+          '/app/models'
+        end
+      end
+      
+    # Shift-Ctrl-T - go to test, or test dir
+    when event.hardware_keycode == 28 && event.state.control_mask?  && event.state.shift_mask?
+      select_related_paths( widget, event ) do |item|
+        case
+          when md = @model_re.match( item.path )
+            '/test/unit/' + $2 + $3 + '_test.rb'
+          when md = @view_re.match( item.path )
+            '/test/functional/' + $2 + '_controller_test.rb'
+          when md = @controller_re.match( item.path )
+            '/test/functional/' + $2 + $3 + '_controller_test.rb'
+          when md = @fixture_re.match( item.path )
+            '/test/unit/' + $2 + $3.singularize + '_test.rb'
+          else
+            '/test'
+        end
+      end
+    
+    # Shift-Ctrl-H - go to helpers dir
+    when event.hardware_keycode == 43 && event.state.control_mask? && event.state.shift_mask?
+      goto_rails_path '/app/helpers'
+      
+    # Shift-Ctrl-L - go to layouts dir
+    when event.hardware_keycode == 46 && event.state.control_mask? && event.state.shift_mask?
+      goto_rails_path '/app/views/layouts'
+      
+    # Shift-Ctrl-I - go to migrations
+    when event.hardware_keycode == 31 && event.state.control_mask?  && event.state.shift_mask?
+      goto_rails_path '/db/migrate'
+    
+    # Shift-Ctrl-S - go to stylesheets
+    when event.hardware_keycode == 39 && event.state.control_mask?  && event.state.shift_mask?
+      goto_rails_path '/public/stylesheets'
+      
+    # Shift-Ctrl-F - go to fixtures
+    when event.hardware_keycode == 41 && event.state.control_mask?  && event.state.shift_mask?
+      select_related_paths( widget, event ) do |item|
+        case
+          when md = @model_re.match( item.path )
+            '/test/fixtures' + $2 + '/' + $3.pluralize + '.yml'
+          when md = @unit_test_re.match( item.path )
+            '/test/fixtures' + $2 + '/' + $3.pluralize + '.yml'
+          else
+            '/test/fixtures'
+        end
+      end
+      
+    else
+      retval = false
+    end
+    retval
+  end
+
+end

data/lib/hilfer/scite_editor.rb

@@ -0,0 +1,182 @@
+# handle director interface to scite
+class SciteEditor
+
+	# options can contain :debug
+	# view is a GtkTreeView
+	def initialize( options = {} )
+		@scite_pipe_name = "/tmp/#{ENV['USER']}.#{Process.pid}.scite"
+		@director_pipe_name = "/tmp/#{ENV['USER']}.#{Process.pid}.director"
+		
+		# delete these if they already exist because we
+		# need to use their existence to determine if scite
+		# is running
+		File.exists?( @scite_pipe_name ) && File.unlink( @scite_pipe_name )
+		File.exists?( @director_pipe_name ) && File.unlink( @director_pipe_name )
+		
+		# this is an array of TreeViewer objects
+		@views = []
+		# the command-line options
+		@options = options
+	end
+  
+  def cleanup
+    FileUtils.rm @scite_pipe_name if File.exist? @scite_pipe_name 
+		FileUtils.rm @director_pipe_name if File.exist? @director_pipe_name
+    FileUtils.rm pipe_name_file if File.exist? pipe_name_file
+  end
+
+	# send some command
+	def send( cmd, arg = '' )
+		launch
+		File.open( @scite_pipe_name, 'a' ) do |file|
+			file.print( cmd + ":" + arg.to_s, "\n" )
+      puts "sending: #{cmd}:#{arg.to_s}" if $options[:debug]
+		end
+	end
+
+	# open files in scite
+	def open_action( files )
+		files.each { |x| send "open", x.path }
+    send 'identity',0
+	end
+  
+  def dump
+    %w{dyn local user base embed}.each {|x| send 'enumproperties', x}
+    #~ send 'askproperty','dyn:CurrentWord'
+  end
+
+  # fetch the current file in scite
+	def synchronize_path
+		send 'askfilename'
+	end
+  
+  # shut down editor
+  def quit
+    send 'quit'
+  end
+  
+  # insert text to editor, at current caret, or overwriting the current selection
+  def insert( arg )
+    value =
+    case
+      # note use of single quote - SciTE wants escaped characters
+      when arg.respond_to?( :join ); arg.join( '\\n' ) + '\\n'
+      else; arg.to_s
+    end
+    send 'insert', value
+  end
+
+	# send selection to all registered views
+	def set_selection ( fs_path )
+		@views.each { |v| v.synchronise_editor_path( fs_path ) }
+	end
+
+	def register_view( view )
+		@views << view
+	end
+
+	def unregister_view( view )
+		@views.delete( view )
+	end
+  
+  def pipe_name_file
+    @pipe_name_file ||= "/tmp/#{ENV['USER']}.hilfer.scite"
+  end
+  
+  def write_pipe_name
+    File.open( pipe_name_file, 'w' ) do |f|
+      f.write @scite_pipe_name
+      f.write "\n"
+    end
+  end
+
+protected
+
+	# start up the editor if there isn't already one
+	# calling it when the editor is already open does nothing
+	def launch
+		# create the director pipe if it isn't there already
+		if !File.exists?( @director_pipe_name )
+			system( "mkfifo #{@director_pipe_name}" )
+		end
+		
+		# scite already open, so don't launch another instance
+		return if File.exists?( @scite_pipe_name )
+		
+		cmd = <<EOF
+/usr/bin/scite
+-ipc.director.name=#{@director_pipe_name}
+-ipc.scite.name=#{@scite_pipe_name}
+EOF
+		oneline = cmd.gsub( "\n", " ")
+		child_pid = fork
+		if child_pid.nil?
+			system( oneline )
+			
+			# scite ended, so delete the pipes
+			File.unlink @director_pipe_name if File.exist? @director_pipe_name
+			File.unlink @scite_pipe_name if File.exist? @scite_pipe_name
+			
+			# unfork, don't trigger a SystemException
+			exit! true
+		else
+			# start the listener thread
+			start_listener
+		end
+	end
+	
+	def start_listener
+		
+		sleep 0.1 while !File.exists? @scite_pipe_name
+		
+		Thread.new( self ) do |arg|
+			begin
+				arg.listen
+			rescue Errno::ENOENT
+				break
+			rescue Exception => e
+				print "listener thread ended: ", e.inspect, "\n"
+				e.backtrace.each { |x| print x, "\n" }
+			end
+		end
+		
+	end
+
+	# respond to strings from scite
+	def listen
+		File.open( @director_pipe_name ).each( "\x0" ) do |line|
+			begin
+				line = line.slice(0...-1) if line[-1] = 0
+				print "heard #{line}\n" if $options[:debug]
+				case line
+					# scite sends one of these for each file opened
+					when /^opened:(.*)$/
+						set_selection( $1 )
+
+					# scite sends one of these each time the buffer is switched
+					when /^switched:(.*)$/
+						set_selection( $1 )
+
+					# response to askfilename, as sent by synchronize_path
+					when /^filename:(.*)$/
+						set_selection( $1 )
+
+					# the specified file has just been saved. Do nothing.
+					# TODO could check that it exists and add it if not.
+					when /^saved:(.*)$/
+					
+					when /^closed$/
+            puts "SciTE closing"
+						break
+
+					# print it out
+					else
+						print "unknown: ", line, "\n" if $options[:debug]
+				end
+			rescue Exception => e
+				print "caught Exception in listen: ", e.inspect, "\n"
+			end
+		end
+	end
+
+end