diru 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 909b1ab4f9f1edcafd5b5a7e0e9f025663dc753c
+  data.tar.gz: 2d6cee00599bc252645141e237cf9a51e092ba2c
+SHA512:
+  metadata.gz: cba95aeefd39cf86ed3c6ecce6413d8ff995bc2d85431b23f1bf8a32faa1d0ed173a5dc5f8b4569ab9001f74e695151ff4ad49d2c74d5f97feae832435b42586
+  data.tar.gz: f462f73de40bf425a332cacd7ac32d74e227e64a318bb9e97c877872e6e8b5740bb17f2f03f33d4ea0e1c67a88a04a9c28df15bc001735bb4771775ebe22ab5a

data/CHANGELOG.rdoc

@@ -0,0 +1,3 @@
+= Version history
+
+[0.0.1] Initial version.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2017 tero.isannainen@gmail.com
+
+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/README.rdoc

@@ -0,0 +1,260 @@
+= Diru
+
+* Introduction
+* Getting started
+* Client commands
+* Configuration
+* Practical usage
+
+= Introduction
+
+Diru is a Change Directory (cd) utility for augmenting Unix Shell
+functionality. Diru uses server/client architecture, which enables
+sharing of directory info between terminal sessions.
+
+Each Server serves one Project, which is a tree of related directories
+where user wants to jump around and which has a logical root. There
+can be multiple Servers, if user needs to access multiple Projects
+concurrently.
+
+Client queries directory info from Server and directory change is
+pushed to Shell in order to change the current directory within
+Shell. Diru is not able to change the Shell directory by itself. User
+must define a Shell function which can actually change the state of
+the Shell.
+
+Diru features:
+
+* Support for multiple concurrent Projects.
+* User and Project specific options (configuration).
+* Jump to Project root.
+* Find and jump to dir under Project root (regexp match).
+* Find and jump to dir under current dir (regexp match).
+* Favorite directories in options (configuration), for permanent
+  favorites.
+* Bookmark saving and referencing, for current favorites.
+* Directory change history and history referencing.
+* Scratch Pad for directory copy/paste.
+* Peer directory jumping, i.e. peer of current (regexp match).
+* Online help.
+
+
+= Getting started
+
+The first thing to do is to start Diru Hub. Hub is a server process
+that enables the Project specific Servers to be started. Hub will give
+each new Server an unique port to operate with, starting from Hub Port
+plus one.
+
+Start Hub to port 42323:
+
+    shell> diru --hub --hport 42323
+
+Start Server for a Project:
+
+    shell> cd <project_root_dir>
+    shell> diru --hport 42323 -s
+
+Server will be listening to port "42324" (HubPort + 1). Following
+Servers will get "42325", "42326" etc. Server displays the Port at
+startup.
+
+Server is a thread in Hub process. Servers can be started and killed
+at will. Complete list of running Servers can be seen with:
+
+    shell> diru --hport 42323 -l
+
+When Server starts, it will detect the Project root. It can be a file
+or defined as environment variable. If ".diru_root_dir" file or a
+".diru.yml" file is found from current dir or some dir above, the dir
+containing either of the files will become the Project root. If no files
+are found, then DIRU_ROOT environment variable is used.
+
+Client communicates with the Server in order to get and save directory
+info. As mentioned above, Diru is more or less useless unless user has
+defined a Shell function to realize directory changing.
+
+Here is an example of such function for Bourne Shell based shells:
+
+    dr()
+    {
+      ret=`diru -p 42324 -c $*`
+      if test $? -eq 0; then
+        cd $ret
+      fi
+    }
+
+Diru Client command is called now "dr". We specify with "-p" that port
+"42324" is used towards the Server and with "-c" that we want to issue
+directory "change" commands. In practice only part of the commands
+will change directory, since some commands are only for queries.
+
+If you want to see all Diru options, perform:
+
+    shell> diru -h
+
+To jump to Project root, we do:
+
+    shell> dr r
+
+If we want to jump to a subdir called "dir_0_0" (under root), we do:
+
+    shell> dr r dir_0_0
+
+Note that "dir_0_0" does not have to be directly under Project root,
+the directory is searched from the complete tree of directories under
+Project root using regexp matching.
+
+Now that we have changed directory for a couple of times, we can look
+at the directory change history:
+
+    shell> dr h
+
+We can reference the history by listed numbers. In order to jump back
+to previous dir, we do:
+
+    shell> dr h 0
+
+
+= Client commands
+
+Client commands either change the current directory or query directory
+info from Server.
+
+Search commands:
+
+* "dr r" - change to Project root dir.
+* "dr r <dir>" - change to <dir> (somewhere) under Project root dir.
+* "dr t <dir>" - change to <dir> (somewhere) under current dir.
+
+Search can match to multiple directories. First match is used and the
+rest (Left-overs) are displayed to the user. Left-overs are also
+stored, and they can be referenced and used in order of appearance
+with simply issuing "dr".
+
+Search pattern can also be constructed from multiple pieces.
+
+    shell> dr r dir 1_0_1
+
+See "dr i" for alternatives for single letter commands. For example
+"r" can be replaced with "/".
+
+
+Bookmark commands:
+
+* "dr b" - display bookmarks.
+* "dr b ." - add current dir to bookmarks.
+* "dr b !" - reset (clear) bookmarks.
+* "dr b s <file>" - store bookmarks to <file>.
+* "dr b l <file>" - load  bookmarks from <file>.
+* "dr b d <num>" - delete bookmark with <num>.
+* "dr b <num>" - change dir to bookmark <num>.
+
+History commands:
+
+* "dr h" - display history.
+* "dr h ." - add current dir to history.
+* "dr h !" - reset (clear) historys.
+* "dr h ," - reference last history item.
+* "dr h <num>" - change dir to history <num>.
+
+Scratch Pad commands:
+
+* "dr s ." - store current dir to Scratch Pad.
+* "dr s <dir>" - store <dir> to Scratch Pad.
+* "dr s" - change dir to Scratch Pad dir.
+
+Misc commands:
+
+* "dr p" - jump to peer dir, i.e. the peer of current (from options).
+* "dr c <cmd>" - issue RPC command to server (reset etc., see below).
+* "dr f" - list favorites dirs (from options).
+* "dr f <dir>" - change dir to favorite <dir>.
+* "dr i" - show command info.
+* "dr <dir>" - change to given dir (must be under current).
+* "dr" - change to next "Left-over" directory.
+
+RPC (Remote Procedure Call) commands:
+
+* "reset" - Reset Server state, i.e. History, Boorkmarks, Left-overs.
+* "abook" - Add current dir to Bookmarks.
+* "lbook" - List Bookmarks.
+* "rbook" - Reset Bookmarks.
+* "doc"   - Show command documentation.
+
+
+= Configuration
+
+Diru uses several environment variables, which are optional, and
+provides thereby backup values for non-specified command line info.
+
+* DIRU_HUB_PORT - Hub Port, if nothing, 41114 is used.
+* DIRU_PORT - Server Port, if nothing, ~/.diru.prt is used (Port File).
+* DIRU_OPTS - options file, if nothing, ~/.diru.yml is used. 
+* DIRU_ROOT - Project root, used if ".diru_root_dir" and ".diru.yml"
+  are missing.
+
+If Hub is started without "--hport" option, Diru checks if
+DIRU_HUB_PORT is defined. If not, port 41114 is used.
+
+If Client is used without "-p" option, Diru checks if DIRU_PORT is
+defined. If not, Port File, i.e. "~/.diru.prt", is used. Client does
+not work if no port info is given.
+
+If Server is started in a directory where (or above) a file called
+".diru_root_dir" is found, then Project root is the directory
+containing ".diru_root_dir". If ".diru_root_dir" is not found, but
+".diru.yml" is found, then Project root is the directory containing
+".diru.yml", and Options for Project are taken from that file. Last
+resort for defining Project root, is DIRU_ROOT definition.
+
+If ".diru_root_dir" or DIRU_ROOT is used to define Project root, then
+DIRU_OPTS is used to define Options File. However, if not defined,
+then "~/.diru.yml" is used for options.
+
+An example Options file can be displayed with:
+
+    shell> diru -t
+
+
+Available options in Options File:
+
+* :sync - Options File and Project directory hierarchy polling period
+  (for Server).
+* :hist - number of entries in history (max).
+* :favs - tagged favorite dirs.
+* :peers - <regexp>,<str> pairs for peer matching (String#sub method).
+
+
+= Practical usage
+
+After Hub has been started, user can start Server for each
+Project. Each Server runs on its own Port, and user can either define
+a Shell function for each Server with specific name, or define
+environment variable (DIRU_PORT) and change it according to
+Project. Depending on the usage pattern, user might also want to use
+the Port File.
+
+Each Project might benefit from specific Options File, and thus user
+could mark the Project Root with ".diru.yml" and specify the Project
+setup there.
+
+If user is working with a programming project, it is fairly common to
+have separate sub-directories for source code and build targets. Let's
+assume user starts with editing source code and has a terminal for
+accessing files. When program is ready for running, user opens a new
+terminal for handling the compile-run-debug iterations.
+
+User can copy source terminal directory to Scratch Pad. Then in the
+new terminal, user can refer to Scratch Pad and change to same
+directory as in source terminal. Finally user can change to a Peer of
+current dir, i.e. where program running and debugging takes place.
+
+If programming project is big enough, there might be several sub-dirs
+where source files reside. User might setup favorites to Options File,
+in order to easily reference the popular source code directories.
+
+Options File can be edited while Server is running. Server reads the
+Options File every 5 seconds (configurable with ":sync") and refreshes
+its internal state. Server also updates its internal cache of Project
+directory content at each refresh cycle.

data/bin/diru

@@ -0,0 +1,1010 @@
+#!/usr/bin/env ruby
+
+# diru is a tool for moving around in the users directory
+# structure. diru provides input for the shell cd command for entering
+# a new directory. However some commands do not produce input for cd.
+#
+# diru has hub (daemon) which creates new service (server) threads for
+# diru clients. Before user can start using diru, a server should be
+# created.
+#
+# diru has server side and client side. The server maintains
+# information about users directories and also the state of the
+# queries issued by the client. Client is what the end user uses.
+#
+# diru client command has to be integrated to the currently used
+# shell in order to force the shell to change the current
+# directory. Lets assume that the shell alias/function that user is
+# actually using is "dr" for now. If diru returns success, then the
+# diru output should be used as new directory. If diru status is
+# failure, then directory should not be changed.
+#
+# Example of diru use:
+#   shell> dr / build src
+#
+# This command means that the client sends to the server a request for
+# directory search. The search starts from Diru root ("/") and the
+# rest of the path should include the words "build", and
+# "src". If path with this spec is found, the shell directory gets
+# updated.
+#
+# Perform:
+#   shell> dr @ doc
+#     or
+#   shell> dr i
+#
+# for some documentation.
+#
+# Diru setup:
+#
+# Start hub (deamon)
+# * shell> diru --hub
+#
+# Open server for client.
+# * shell> diru -s
+#
+# Use client
+# * shell> diru -p 41115 -c r
+#
+#
+# Feature list:
+# * User root dir (downwards) search
+# * Current directory (downwards) dir search
+# * Bookmarking directories
+# * Left-over search with multiple matches
+# * Fast jump to specific common directories
+# * Peer dir jump
+# * Server state reset
+# * Revert mode, unknown commands to cd
+#
+
+
+require 'como'
+include Como
+require 'drb'
+require 'yaml'
+
+# require 'byebug'
+
+
+Spec.command( 'diru', 'Tero Isannainen', '2017',
+    [
+        [ :switch,        'hub',      nil,    "H:   Start hub." ],
+        [ :opt_single,    'hport',    nil,    "H:   Hub port (default: DIRU_HUB_PORT or 41114)." ],
+        [ :switch,        'hkill',    nil,    "H:   Kill hub." ],
+        [ :switch,        'nodaemon', nil,    "H:   No daemon for server." ],
+        [ :switch,        'server',   '-s',   "S:   Open server for client." ],
+        [ :opt_single,    'kill',     '-k',   "S:   Close server for client." ],
+        [ :switch,        'list',     '-l',   "S:   List servers." ],
+        [ :opt_single,    'options',  '-o',   "SC:  Options File." ],
+        [ :opt_single,    'port',     '-p',   "SC:  Server port for client (default: DIRU_PORT or ~/.diru.prt)." ],
+        [ :switch,        'change',   '-c',   "C:   Change dir (i.e. target is to change dir)." ],
+        [ :exclusive,     'template', '-t',   "C:   Display Options File template." ],
+        [ :default,       nil,         nil,   "C:   Client commands (try: diru i)." ],
+    ] )
+
+
+
+# ------------------------------------------------------------
+# Common:
+# ------------------------------------------------------------
+
+
+# Diru common features.
+module Diru
+
+    # Default port.
+    DIRU_HUB_PORT = ENV['DIRU_HUB_PORT'] || 41114
+
+    # Load yaml configuration file (if exists).
+    def Diru.load_conf( conf_file )
+        conf = {}
+        if File.exist?( conf_file )
+            conf = YAML.load( File.read( conf_file ) )
+        end
+        conf
+    end
+
+
+    # See: Diru.load_conf
+    def load_conf( conf_file )
+        @conf = Diru.load_conf( conf_file )
+    end
+
+
+    # Error message display.
+    def Diru.error( msg )
+        STDERR.puts "Diru Error: #{msg}"
+        exit( false )
+    end
+
+
+    # List the dir content (default: pwd).
+    def Diru.list( dir = '.', glob = '*' )
+        Dir.glob( "#{dir}/#{glob}" )
+    end
+
+    # List the dir files (default: pwd).
+    def Diru.list_files( dir = '.', glob = '*' )
+        Diru.list( dir, glob ).select do |i| File.file?(i) == true end
+    end
+
+    # Find file entry from directory hierarchy upwards.
+    def Diru.find_upper_file( file, dir = Dir.pwd )
+        found = Diru.list_files( dir, file )
+        if found.empty?
+            dir = File.dirname( dir )
+            if dir == "/"
+                raise RuntimeError, "Could not find file \"#{file}\"!"
+            else
+                return Diru.find_upper_file( file, dir )
+            end
+        else
+            return found[0]
+        end
+    end
+
+
+    # Find file entry from directory hierarchy upwards, exit if not found.
+    def Diru.must_find_upper_file( file, dir = Dir.pwd )
+        begin
+            Diru.find_upper_file( file, dir )
+        rescue RuntimeError
+            STDERR.puts "Could not find file \"#{file}\"!"
+            exit( false )
+        end
+    end
+
+    def Diru.get_opts_file( file = nil )
+        opts_file = nil
+        if Opt['options'].given
+            opts_file = Opt['options'].value
+        elsif file
+            opts_file = file
+        elsif ENV['DIRU_OPTS']
+            opts_file = ENV['DIRU_OPTS']
+        else
+            opts_file = "#{ENV['HOME']}/.diru.yml"
+        end
+
+        opts_file
+    end
+
+end
+
+
+# Diru Server State.
+class Search
+
+    include Diru
+
+    def initialize( root, opts_file = nil )
+
+        # Server root.
+        @root = root
+
+        # Change directory to DIRU root.
+        Dir.chdir( @root )
+
+        # List of old matches.
+        @old = []
+
+        # Numbered bookmarks.
+        @book = []
+
+        # Numbered history.
+        @hist = []
+
+        # Favorites.
+        @fav = {}
+
+        # History limit.
+        @histlimit = 20
+
+        # Sync period.
+        @sync = 5
+
+        # Options File.
+        @opts_file = opts_file
+
+        # Temporary storage (scratch pad).
+        @scratch = nil
+
+        # Glob pattern for DB build.
+        @glob = "**/*"
+
+        @logging = false
+        # if Opt['log'].given
+        #     @logging = true
+        # end
+
+        # Initial data update.
+        update_data
+        update_conf
+
+        # Lock for DB access.
+        @datalock = Mutex.new
+
+        # Start periodic DB updates.
+        periodic_update
+    end
+
+
+    def opts_file
+        @opts_file
+    end
+
+    # Return root.
+    def root
+        @root
+    end
+
+
+    # Add bookmark (if not already).
+    def abook( dir )
+        idx = @book.index dir
+        unless idx
+            @book.push dir
+        end
+    end
+
+
+    # Delete bookmark.
+    def dbook( idx )
+        @book.delete_at idx
+    end
+
+
+    # Get bookmark.
+    def gbook( idx )
+        @book[ idx ]
+    end
+
+
+    # Get all bookmarks.
+    def book
+        @book
+    end
+
+
+    # Reset bookmarks.
+    def rbook
+        @book = []
+    end
+
+
+    # Save bookmarks to file.
+    def savebook( file )
+        File.write( file, @book.join("\n") + "\n" )
+    end
+
+
+    # Load bookmarks from file.
+    def loadbook( file )
+        @book = File.read( file ).split("\n")
+    end
+
+
+    # Add history.
+    def ahist( dir )
+        if dir != @hist[0]
+            if @hist.length >= @histlimit
+                @hist = [ dir ] + @hist[ 0..(@histlimit-2) ]
+            else
+                @hist = [ dir ] + @hist
+            end
+        end
+    end
+
+
+    # Get history.
+    def ghist( idx )
+        @hist[ idx ]
+    end
+
+
+    # Get all historys.
+    def hist
+        @hist
+    end
+
+
+    # Reset history.
+    def rhist
+        @hist = []
+    end
+
+
+    # Get (and update) favorite.
+    def gfav( tag )
+        "#{@root}/#{@fav[ tag ]}"
+    end
+
+
+    # Return the whole fav.
+    def fav
+        @fav
+    end
+
+
+    # Update options.
+    def update_conf
+        if @opts_file
+
+            load_conf( @opts_file )
+
+            if @conf[:sync] && @conf[:sync] >= 1
+                @sync = @conf[:sync]
+            end
+
+            if @conf[:hist] && ( @conf[:hist] >= 2 )
+                @histlimit = @conf[:hist]
+            else
+                @histlimit = 20
+            end
+
+            if @conf[ :favs ]
+                @fav = @conf[ :favs ]
+            end
+
+        end
+    end
+
+
+    # Set scratch dir.
+    def settmp( dir )
+        @scratch = dir
+    end
+
+
+    # Get scratch dir.
+    def gettmp
+        @scratch
+    end
+
+
+    # Match dir/pattern from DB.
+    def match( dir, pattern )
+        list = []
+
+        if dir
+            rem = "#{@root}/"
+            begin
+                dir[rem] = ''
+            rescue
+                return []
+            end
+            r = dir + '.*' + pattern
+        else
+            r = pattern
+        end
+
+        @datalock.synchronize do
+            @data.each do |i|
+                if i.match( r )
+                    list.push "#{@root}/#{i}"
+                end
+            end
+        end
+
+        # Update old list.
+        @old = list.rotate
+
+        list
+    end
+
+
+    # Get next match from old.
+    def next
+        ret = @old[0]
+        @old.rotate!
+        ret
+    end
+
+
+    # Update directory DB.
+    def update_data
+        @data = Dir.glob( @glob ).select{|ent| File.directory?( ent )}
+        @data = @data.sort
+    end
+
+
+    # Update DB with MT sync.
+    def update_data_sync
+        @datalock.synchronize do
+            update_data
+            update_conf
+        end
+    end
+
+
+    # Reset dynamic state.
+    def reset 
+        log "reset"
+        @old = []
+        @book = []
+        @hist = []
+        update_data_sync
+    end
+
+
+    # Update DB periodically with background thread.
+    def periodic_update
+        # Spawn More data updates.
+        @th = Thread.new do
+            loop do
+                # puts "data update..."
+                sleep @sync
+                update_data_sync
+            end
+        end
+    end
+
+
+    # Enable logging.
+    def logon
+        @logging = true
+    end
+
+    # Disable logging.
+    def logoff
+        @logging = false
+    end
+
+
+    # Log events.
+    def log( msg )
+        if @logging
+            fh = File.open( "#{ENV['HOME']}/.diru.log", "a" )
+            fh.puts "#{Time.timestamp()}: #{msg}"
+            fh.close
+        end
+    end
+end
+
+
+
+# ------------------------------------------------------------
+# Server program.
+# ------------------------------------------------------------
+
+# Diru hub.
+class Hub
+
+    # Start in daemon or direct mode.
+    def Hub.start( port, daemon = true )
+        if daemon
+            p = fork do
+                Hub.new( port )
+            end
+            Process.detach( p )
+        else
+            Hub.new( port )
+        end
+    end
+
+
+    # Server collection.
+    @@servers = {}
+
+    attr_reader :port
+
+    def initialize( port )
+        @port = port
+
+        # Start the service
+        @hub = DRb.start_service( "druby://localhost:#{@port}", self )
+        DRb.thread.join
+    end
+
+
+    # Kill hub.
+    def kill
+        @th = Thread.new do
+            STDERR.puts "Diru Hub: Exiting sooooon..."
+            sleep 3
+            kill_servers
+            sleep 3
+            STDERR.puts "Diru Hub: Exit done..."
+            @hub.stop_service
+            exit( false )
+        end
+    end
+
+
+    # Create new server and return port for the server.
+    def get_server( root, opts_file )
+
+        50.times do |i|
+            if @@servers[ @port+1+i ] == nil
+                port = @port+1+i
+                s = Service.new( root, port, opts_file )
+                @@servers[ port ] = s
+                return port
+            end
+        end
+
+        0
+    end
+
+
+    # List all server ports.
+    def list_servers
+        @@servers.keys.map{ |i| [ i, @@servers[i].root ] }
+    end
+
+
+    # Kill all servers.
+    def kill_servers
+        @@servers.keys.each do |s|
+            kill_server( s )
+        end
+        @@servers = {}
+    end
+
+    # Kill server with the given port.
+    def kill_server( s_port )
+        s = @@servers[ s_port ]
+        if s
+            s.kill
+            @@servers.delete( s_port )
+        else
+            nil
+        end
+    end
+
+end
+
+
+
+# diru client service (server) thread.
+class Service
+
+    attr_reader :root
+
+    # Initialize and start service.
+    def initialize( root, port, opts_file )
+        @root = root
+        @port = port
+        @drb = nil
+        @opts_file = opts_file
+        start
+        self
+    end
+
+    # Kill service.
+    def kill
+        @drb.stop_service
+        Thread.kill( @th )
+    end
+
+    # Start service.
+    def start
+        @th = Thread.new do
+
+            # Create "front" object.
+            @search = Search.new( @root, @opts_file )
+
+            # Start the service
+            @drb = DRb::DRbServer.new( "druby://localhost:#{@port}", @search )
+            @drb.thread.join
+        end
+    end
+
+end
+
+
+if Opt['template'].given
+    puts %q{---
+:hist: 20
+:sync: 10
+:favs:
+  f: dir_0/dir_0_4/dir_0_4_0
+  g: dir_1/dir_1_2
+:peers:
+  - - "(.*/dir_0/.*)/dir_0_2_0"
+    - "\\1"
+  - - "(.*/dir_0/.*)/dir_0_1_0"
+    - "\\1/dir_0_1_1"
+}
+    exit( false )
+end
+
+
+hport = nil
+if Opt['hport'].given
+    hport = Opt['hport'].value.to_i
+else
+    hport = Diru::DIRU_HUB_PORT
+end
+
+
+if Opt['hub'].given
+
+    # Hub:
+    h = Hub.start( hport, !Opt['nodaemon'].given )
+    exit( true )
+end
+
+
+if false
+    # For hub maintenance (irb):
+    require 'drb'
+    hub = DRbObject.new( nil, "druby://localhost:41114" )
+    hub.list_servers
+end
+
+
+if false
+    # Test client
+    require 'drb'
+    @port = 41115
+    @search = DRbObject.new( nil, "druby://localhost:#{@port}" )
+end
+
+
+if Opt['hkill'].given
+    hub = DRbObject.new( nil, "druby://localhost:#{hport}" )
+    hub.kill
+    exit( true )
+end
+
+
+if Opt['server'].given
+
+    # Setup client server.
+    hub = DRbObject.new( nil, "druby://localhost:#{hport}" )
+
+    root = nil
+    opts_file = nil
+    
+    if ENV['DIRU_ROOT']
+        root = ENV['DIRU_ROOT']
+    else
+        # First search for .diru_root_dir file.
+        begin
+            root = File.dirname( Diru.find_upper_file( '.diru_root_dir' ) )
+        rescue
+            root = nil
+        end
+
+        unless root
+            # Next search for .diru.yml file.
+            begin
+                yml_file = Diru.find_upper_file( '.diru.yml' )
+                root = File.dirname( yml_file )
+                opts_file = yml_file
+            rescue
+                Diru.error "Could not find user directory root!"
+            end
+        end
+    end
+
+    opts_file = Diru.get_opts_file( opts_file )
+
+    begin
+        s_port = hub.get_server( root, opts_file )
+    rescue
+        Diru.error "Access to Hub failed!"
+    end
+
+    if s_port == 0
+        Diru.error "Could not start server!"
+    else
+        # File.write( port_file, s_port.to_s ) if port_file
+        puts "Using server port: #{s_port}..."
+    end
+
+    exit( true )
+end
+
+
+if Opt['kill'].given
+
+    hub = DRbObject.new( nil, "druby://localhost:#{hport}" )
+    port = Opt['kill'].value.to_i
+    begin
+        hub.kill_server port
+    rescue
+        Diru.error "Access to Hub failed!"
+    end
+
+    exit( true )
+end
+
+
+if Opt['list'].given
+
+    hub = DRbObject.new( nil, "druby://localhost:#{hport}" )
+    begin
+        hub.list_servers.each do |i|
+            puts format( "%-12.d  %s", i[0], i[1] )
+        end
+    rescue
+        Diru.error "Access to Hub failed!"
+    end
+
+    exit( true )
+end
+
+
+
+# ------------------------------------------------------------
+# Client program.
+# ------------------------------------------------------------
+
+
+class Client
+
+    include Diru
+
+    def initialize( port )
+
+        @port = port
+
+        # Create a DRbObject instance that is connected to server. All methods
+        # executed on this object will be executed to the remote one.
+        @search = DRbObject.new( nil, "druby://localhost:#{@port}" )
+
+        load_conf( @search.opts_file )
+    end
+
+
+    # Perform cd (i.e. return true) and store current dir to history.
+    def do_cd
+        @search.ahist( Dir.pwd )
+        true
+    end
+
+
+    # No directory change, i.e. return false.
+    def no_cd
+        false
+    end
+
+
+    # Process command.
+    def command( input )
+
+        if input.empty?
+
+            # Refer to last search list.
+            puts @search.next
+            do_cd
+
+        else
+
+            cmd = input[0]
+            arg = input[1..-1]
+
+            # Shell specials chars to prevent:
+            #   * ? [ ] ' " \ $ ; & ( ) | ^ < >
+
+            # Thus allowed:
+            #   ! % + , - . / : = @ _ ~
+            #   ^ ^   ^   ^ ^ ^ ^ ^ ^
+
+            # Decode user command.
+            ret = \
+            case cmd
+
+            when '/', 'r';
+                if arg.empty?
+                    disp @search.root
+                else
+                    disp @search.match( nil, arg.join('.*') )
+                end
+
+            when ':', 't'; disp @search.match( Dir.pwd, arg.join('.*') )
+
+            when '.', 'b';
+                if arg[0] == nil
+                    lbook( @search.book )
+                    no_cd
+                elsif arg[0] == '.'
+                    @search.abook( Dir.pwd )
+                    no_cd
+                elsif arg[0] == '!'
+                    @search.rbook
+                    no_cd
+                elsif arg[0] == 's'
+                    @search.savebook( arg[1] )
+                    no_cd
+                elsif arg[0] == 'l'
+                    @search.loadbook( arg[1] )
+                    no_cd
+                elsif arg[0] == 'd'
+                    @search.dbook( arg[1].to_i )
+                    no_cd
+                else
+                    disp @search.gbook( arg[0].to_i )
+                end
+
+            when ',', 'h';
+                if arg[0] == nil
+                    lbook( @search.hist )
+                    no_cd
+                elsif arg[0] == '.'
+                    @search.ahist( Dir.pwd )
+                    no_cd
+                elsif arg[0] == '!'
+                    @search.rhist
+                    no_cd
+                elsif arg[0] == ','
+                    disp @search.ghist( 0 )
+                else
+                    disp @search.ghist( arg[0].to_i )
+                end
+
+            when '_', 's';
+                if arg[0] == nil
+                    disp @search.gettmp
+                elsif arg[0]
+                    if arg[0] == '.'
+                        dir = Dir.pwd
+                    else
+                        dir = arg[0]
+                    end
+                    disp @search.settmp( dir )
+                    no_cd
+                else
+                    no_cd
+                end
+
+            when '=', 'p'; disp peer
+
+            when '@', 'c'; rpc( arg )
+
+            when 'f';
+                if arg[0] == nil
+                    @search.fav.each do |k,v|
+                        STDERR.puts format( "%-6s %s", k, v )
+                    end
+                    no_cd
+                else
+                    fav_map( arg )
+                end
+
+            when 'i';
+                rpc( [ 'doc' ] )
+
+            else
+
+                if Opt['change'].given
+                    all = [cmd] + arg
+                    puts "#{all.join(' ')}"
+                    do_cd
+                else
+                    no_cd
+                end
+
+            end
+
+            exit( ret )
+        end
+
+    end
+
+
+    # Display directories. One to STDOUT and others to STDERR.
+    def disp( resp )
+        if resp == nil
+            no_cd
+        elsif resp.kind_of? Array
+            puts resp[0]
+            if resp.length > 1
+                resp[1..-1].each do |i|
+                    STDERR.puts i
+                end
+            end
+            do_cd
+        else
+            puts resp
+            do_cd
+        end
+    end
+
+
+    # Get peer directory. Search list of re-pairs. Match either of the
+    # pair, and switch to the pair dir.
+    #
+    def peer
+        cur = Dir.pwd
+        peers = @conf[ :peers ]
+        peers.each do |pair|
+            re = Regexp.new( pair[0] )
+            if ( re.match( cur ) )
+                return cur.sub( re, pair[1] )
+            end
+        end
+        nil
+    end
+
+
+    # Display short command doc.
+    def doc
+        STDERR.puts "
+    r /   - search from root (or to root)
+    t :   - search from this (current)
+    b .   - bookmark access
+    h ,   - history access
+    s _   - scratch pad access
+    p =   - peer of current
+    c @   - command (reset, doc etc.)
+    f     - favorites
+    i     - short info
+    "
+    end
+
+
+    # List bookmarks with index number (in reverse order).
+    def lbook( book )
+        idx = book.length-1
+        (0..idx).to_a.reverse.each do |i|
+            STDERR.puts format( "%2d: %s", i, book[i] )
+        end
+    end
+
+
+    # Remove Procedure Call towards server.
+    #
+    # Example:
+    #   shell> dr @ rbook
+    #
+    def rpc( arg )
+        case arg[0]
+        when 'reset'; @search.reset
+        when 'abook'; @search.abook( Dir.pwd )
+        when 'lbook'; lbook( @search.book )
+        when 'rbook'; @search.rbook
+        when 'doc'; doc
+        else return no_cd
+        end
+        no_cd
+    end
+
+
+    # Direct directory jump.
+    def fav_map( arg )
+        ret = @search.gfav( arg[0] )
+        if ret
+            disp ret
+            do_cd
+        else
+            no_cd
+        end
+    end
+
+end
+
+
+if Opt['port'].given
+    port = Opt['port'].value.to_i
+elsif ENV['DIRU_PORT']
+    port = ENV['DIRU_PORT'].to_i
+elsif File.exist?( "#{ENV['HOME']}/.diru.prt" )
+    port = File.read( "#{ENV['HOME']}/.diru.prt" ).to_i
+else
+    Diru.error "Server port info missing..."
+end    
+
+
+# User command content.
+input = Opt[nil].value
+
+begin
+    client = Client.new( port )
+rescue
+    Diru.error "Server not available!"
+    exit( false )
+end    
+
+ret = false
+begin
+    ret = client.command( input )
+rescue
+    Diru.error "Command failure!"
+    exit( false )
+end
+
+exit( ret )