rhcp_shell 0.0.1

data/History.txt

@@ -0,0 +1,6 @@
+=== 1.0.0 / 2009-01-23
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,12 @@
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+README
+lib/base_shell.rb
+lib/rhcp_shell.rb
+lib/rhcp_shell_backend.rb
+lib/shell_backend.rb
+start_shell.sh
+test/rhcp_shell_backend_test.rb
+test/setup_test_registry.rb

data/README

@@ -0,0 +1,3 @@
+== rhcp_shell
+
+You should document your project here.

data/README.txt

@@ -0,0 +1,48 @@
+= sow_test
+
+* FIX (url)
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 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/Rakefile

@@ -0,0 +1,71 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+
+PKG_NAME = 'rhcp_shell'
+PKG_VERSION = '0.0.1'
+
+desc "Default Task"
+task :default => [ :test ]
+
+###############################################
+### TESTS
+Rake::TestTask.new() { |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+}
+
+###############################################
+### RDOC
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "RHCP Shell"
+  rdoc.options << '--line-numbers' << '--inline-source' <<
+    '--accessor' << 'cattr_accessor=object'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  #rdoc.rdoc_files.include('README', 'CHANGELOG')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+}
+
+###############################################
+### METRICS
+task :lines do
+  lines, codelines, total_lines, total_codelines = 0, 0, 0, 0
+
+  for file_name in FileList["lib/**/*.rb"]
+    f = File.open(file_name)
+
+    while line = f.gets
+      lines += 1
+      next if line =~ /^\s*$/
+      next if line =~ /^\s*#/
+      codelines += 1
+    end
+    puts "L: #{sprintf("%4d", lines)}, LOC #{sprintf("%4d", codelines)} | #{file_name}"
+    
+    total_lines     += lines
+    total_codelines += codelines
+    
+    lines, codelines = 0, 0
+  end
+
+  puts "Total: Lines #{total_lines}, LOC #{total_codelines}"
+end
+
+#rcov -I lib/ -I test/ -x rcov.rb -x var/lib -x lib/shell_backend.rb  test/*test.rb
+
+task :update_manifest do
+  system "rake check_manifest 2>/dev/null | grep -vE 'qooxdoo|nbproject|coverage' | grep -E '^\+' | grep -vE '^$' | grep -v '(in ' | grep -vE '^\+\+\+' | cut -b 2-200 | patch"
+end
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.new('rhcp_shell', PKG_VERSION) do |p|
+  p.rubyforge_name = 'rhcp' # if different than lowercase project name
+  p.developer('Philipp T.', 'philipp@hitchhackers.net')
+end
+   

data/lib/base_shell.rb

@@ -0,0 +1,100 @@
+# This class is an abstract implementation of a command shell
+# It handles command completion and history functions.
+# For the actual business logic, you need to pass it an implementation of ShellBackend
+class BaseShell
+  attr_reader :backend
+  
+  def initialize(backend)    
+    @logger = $logger
+    @backend = backend
+    
+    at_exit { console.close }
+    
+    trap("INT") { 
+      Thread.kill(@thread)
+      @backend.process_ctrl_c
+    }
+  end
+    
+  class SimpleConsole
+    def initialize(input = $stdin)
+      @input = input
+    end
+
+    def readline
+      begin
+        line = @input.readline
+        line.chomp! if line
+        line
+      rescue EOFError
+        nil
+      end
+    end
+
+    def close
+    end
+  end
+
+  class ReadlineConsole
+    HISTORY_FILE = ".jscmd_history"
+    MAX_HISTORY = 200
+
+    def history_path
+      File.join(ENV['HOME'] || ENV['USERPROFILE'], HISTORY_FILE)
+    end
+
+    def initialize(shell)
+      @shell = shell
+      if File.exist?(history_path)
+        hist = File.readlines(history_path).map{|line| line.chomp}
+        Readline::HISTORY.push(*hist)
+      end
+      if Readline.methods.include?("basic_word_break_characters=")        
+        #Readline.basic_word_break_characters = " \t\n\\`@><=;|&{([+-*/%"
+        Readline.basic_word_break_characters = " \t\n\\`@><=;|&{([+*%"
+      end
+      Readline.completion_append_character = nil
+      Readline.completion_proc = @shell.backend.method(:complete).to_proc
+    end
+
+    def close
+      open(history_path, "wb") do |f|
+        history = Readline::HISTORY.to_a
+        if history.size > MAX_HISTORY
+          history = history[history.size - MAX_HISTORY, MAX_HISTORY]
+        end
+        history.each{|line| f.puts(line)}
+      end
+    end
+
+    def readline
+      line = Readline.readline(@shell.backend.prompt, true)
+      Readline::HISTORY.pop if /^\s*$/ =~ line
+      line
+    end
+  end
+
+  def console
+    @console ||= $stdin.tty? ? ReadlineConsole.new(self) : SimpleConsole.new
+  end
+  
+  def run
+    backend.show_banner
+    loop do      
+      @thread = Thread.new {
+          break unless line = console.readline
+    
+          if line then
+            @logger.debug "got : #{line}"
+          else
+            @logger.debug "got an empty line"      
+          end
+          
+          backend.process_input line
+      }
+      @thread.join
+    end
+    $stderr.puts "Exiting shell..."      
+  end
+  
+end

data/lib/rhcp_shell.rb

@@ -0,0 +1,108 @@
+#!/usr/bin/env ruby
+
+require "readline"
+require "logger"
+require "getoptlong"
+
+require 'rubygems'
+
+require 'rhcp'
+
+require 'base_shell'
+require 'rhcp_shell_backend'
+
+# TODO version number
+SHELL_VERSION = "0.1"
+
+class RhcpShell
+
+HELP_STRING = <<EOF
+
+RHCP Command Shell v #{SHELL_VERSION} (using RHCP library v #{RHCP::Version.to_s})
+
+Usage:
+  rhcp_shell.rb [--hostname=<hostname>] [--username=<username> --password=<password>] 
+         [--help]
+         
+Options:
+  --hostname=<hostname> 
+    the URL to the RHCP server you want to connect against, e.g.
+      http://server.local.network/rhcp
+    If the specified hostname does not start with "http", it is automatically expanded to
+      http://<hostname>:42000/rhcp
+    You can optionally specify a port number to connect against like this:
+      http://myserver:42000
+    If you do not specify a hostname, the shell will try to connect against 
+      http://localhost:42000
+      
+  --username/--password       
+    the authentication data you want to use for connecting to the RHCP server
+    
+  --help
+    displays this help screen.      
+
+EOF
+
+  def run
+    opts = GetoptLong.new(
+      [ '--help', '-h', GetoptLong::NO_ARGUMENT ],
+      [ '--username', '-u', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--password', '-p', GetoptLong::REQUIRED_ARGUMENT ],
+      [ '--hostname', GetoptLong::REQUIRED_ARGUMENT ]
+    )
+    
+    options = Hash.new
+    opts.each do |opt, arg|
+      case opt
+        when '--help'
+          puts HELP_STRING
+          Kernel.exit(1)
+        else
+          opt =~ /--(.+)/
+          $logger.debug "setting #{arg} for #{$1}" unless $1 == "password"
+          options[$1] = arg
+      end
+    end
+    
+    host = options["hostname"]
+    if host == nil then
+      host = "http://localhost:42000"      
+    else
+      if host !~ /http:/ then
+        host = "http://#{host}:42000/rhcp"
+      end  
+    end
+    $logger.debug "now connecting to #{host}"
+    
+    # TODO add interactive query for password!
+    
+    begin
+      url = URI.parse(host)
+      @http_broker = RHCP::Client::HttpBroker.new(url)
+      
+      backend = RHCPShellBackend.new(@http_broker)
+      backend.banner = <<EOF
+Good morning, this is the generic RHCP Shell.
+Press <tab> for command completion or type "help" for a list of commands.
+If you want to exit this shell, please press Ctrl+C or type "exit".
+
+EOF
+      $logger.debug "backend has been instantiated : #{backend}"
+      
+      shell = BaseShell.new(backend)
+      shell.run
+    rescue => ex
+      puts "There occurred an HTTP error while connecting to the RHCP: #{ex}"
+      puts "Please connect against another server or fix the connection problem."
+      puts ex.backtrace.join("\n")
+    end
+  end
+end  
+  
+  
+# TODO introduce something like the RAILS_ENVs
+$logger = Logger.new("rhcp_shell.log")
+RHCP::ModuleHelper.instance().logger = $logger
+
+shell = RhcpShell.new
+shell.run

data/lib/rhcp_shell_backend.rb

@@ -0,0 +1,513 @@
+require 'shell_backend.rb'
+
+require 'rubygems'
+require 'rhcp'
+
+# This shell presents RHCP commands to the user and handles all the parameter
+# lookup, validation and command completion stuff
+#
+# It uses a RHCP registry/broker as a data backend and possibly for communication with
+# a server.
+#
+# This shell implementation handles two modes - one for entering/selecting
+# a command, another for entering/selecting parameter values.
+# If a command and all mandatory parameters are entered/selected, the command is
+# executed.
+class RHCPShellBackend < ShellBackend
+  
+  attr_reader :prompt
+  attr_accessor :banner
+  
+  def initialize(command_broker)
+    super()
+    
+    local_broker = setup_local_broker
+    @command_broker = RHCP::DispatchingBroker.new()
+    @command_broker.add_broker(command_broker)
+    @command_broker.add_broker(local_broker)
+    
+    reset_to_command_mode
+  end   
+  
+  def setup_local_broker    
+    broker = RHCP::Broker.new()
+    begin
+      broker.register_command RHCP::Command.new("exit", "closes the shell", 
+        lambda { |req,res| 
+          puts "Have a nice day"
+          Kernel.exit(0)
+        }
+      )
+      
+      def param_example(param, suffix = "")
+        result = ""
+        result += "<" if param.is_default_param
+
+        if param.is_default_param then
+          result += "#{param.name}#{suffix}"
+        else
+          result += "#{param.name}"
+          result += "=<value#{suffix}>"
+        end
+
+        result += ">" if param.is_default_param
+        result
+      end
+            
+      command = RHCP::Command.new("help", "displays help about this shell",
+        lambda { 
+          |req,res|
+            
+          if (req.has_param_value("command"))
+            command_name = req.get_param_value("command")
+            puts "Syntax:"
+            command_line = "  #{command_name}"
+            command = @command_broker.get_command(command_name)
+
+            command.params.values.sort { |a,b| a.name <=> b.name }.each do |param|
+              command_line += " "
+              command_line += "[" unless param.mandatory
+
+              command_line += param_example(param)  
+
+              if param.allows_multiple_values then
+                command_line += ", "
+                command_line += param_example(param, "2")
+                command_line += ", ..."
+              end
+
+              command_line += "]" unless param.mandatory
+            end
+            puts command_line
+            puts "Description:"
+            puts "  #{command.description}"
+            if command.params.size > 0 then
+              puts "Parameters:"
+              command.params.values.sort { |a,b| a.name <=> b.name }.each do |param|
+                puts sprintf("  %-20s %s\n", param.name, param.description)
+              end
+           end
+           puts ""
+          else
+            puts "The following commands are available:"
+            @command_broker.get_command_list.values.sort { |a,b| a.name <=> b.name }.each do |command|
+              # TODO calculate the maximum command name length dynamically
+              puts sprintf("  %-40s %s\n", command.name, command.description)
+            end
+            puts ""
+            puts "Type help <command name> for detailed information about a command."
+          end          
+        }
+        ).add_param(RHCP::CommandParam.new("command", "the name of the command to display help for", 
+            { 
+              :mandatory => false,
+              :is_default_param => true,
+              :lookup_method => lambda {
+                @command_broker.get_command_list.values.map { |c| c.name }
+              }
+            }
+        )
+      )
+      command.result_hints[:display_type] = "hidden"
+      broker.register_command command
+      
+      command = RHCP::Command.new("detail", "shows details about a single record of the last response (makes sense if you executed a command that returned a table)", 
+        lambda { |req,res| 
+          if @last_response == nil
+            puts "did not find any old response data...is it possible that you did not execute a command yet that returned a table?"
+            return
+          end
+          row_count = @last_response.data.length
+          begin
+            row_index = req.get_param_value("row_index").to_i
+            raise "invalid index" if (row_index < 1 || row_index > row_count)
+          rescue
+            puts "invalid row index - please specify a number between 1 and #{row_count}"  
+            return
+          end
+          puts "displaying details about row \# #{row_index}"          
+          @last_response.data[row_index - 1].each do |k,v|
+            puts "  #{k}\t#{v}"
+          end
+
+        }
+        ).add_param(RHCP::CommandParam.new("row_index", "the index of the row you want to see details about",
+          {
+            :is_default_param => true,
+            :mandatory => true            
+          }
+        )
+      )
+      command.result_hints[:display_type] = "hidden"
+      broker.register_command command
+      
+    rescue RHCP::RhcpException => ex
+      # TODO do we really want to catch this here?
+      raise ex unless /duplicate command name/ =~ ex.to_s
+    end
+    broker
+  end
+  
+  def reset_to_command_mode
+    set_prompt nil
+    
+    # this shell has two modes that determine the available tab completion proposals
+    # command_mode
+    #    we're waiting for the user to pick a command that should be executed
+    # parameter mode
+    #    the command to execute has already been selected, but the user needs to specify additional parameters
+    # we'll start in the mode where no command has been selected yet
+    @command_selected = nil
+    
+    # if the user selected a command already, we'll have to collect parameters for this command until
+    # we've got all mandatory parameters so that we can execute the command
+    @collected_params = Hash.new
+    
+    # the mandatory params that are still missing (valid in parameter mode only) 
+    @missing_params = Array.new    
+    
+    # the parameter that we're asking for right now
+    @current_param = nil
+  end
+  
+  def execute_command_if_possible
+    # check if we got all mandatory params now
+    mandatory_params = @command_selected.params.select { |name,param| param.mandatory }.map { |k,v| v }
+    @missing_params = mandatory_params.select { |p| ! @collected_params.include? p.name }
+    
+    if (@missing_params.size > 0) then
+      $logger.debug "got #{@missing_params.size} missing params : #{@missing_params.map{|param| param.name}}"    
+      @current_param = @missing_params[0]
+      set_prompt "#{@command_selected.name}.#{@current_param.name}"
+    else 
+      execute_command
+    end
+  end
+  
+  
+  def pre_process_param_value(new_value)
+    $logger.debug "resolving wildcards for param '#{@current_param.name}'"
+      
+    # we can only resolve wildcards if we have lookup values
+    if (@current_param.has_lookup_values)
+      # TODO this is only necessary if we've got multiple values, right?
+      # TODO maybe we want to check if 'new_value' holds suspicious characters that necessitate wildcard resolution?    
+      # TODO is the range handling possible only with lookup values?
+      # convert "*" into regexp notation ".*"
+      regex_str = new_value.gsub(/\*/, '.*')
+
+      # handle ranges (x..y)
+      result = /(.+?)(\d+)(\.{2})(\d+)(.*)/.match(regex_str)
+      ranged_regex = nil
+      if result then
+        $logger.debug "captures : #{result.captures.map { |v| " #{v} "}}"
+        result.captures[1].upto(result.captures[3]) do |loop|
+          regex_for_this_number = "#{result.captures[0]}#{loop}#{result.captures[4]}"
+          $logger.debug "regex for #{loop} : #{regex_for_this_number}"
+          if ranged_regex == nil then
+            ranged_regex = Regexp.new(regex_for_this_number)
+          else
+            ranged_regex = Regexp.union(ranged_regex, Regexp.new(regex_for_this_number))
+          end
+        end
+      else
+        ranged_regex = Regexp.new(regex_str)  
+      end
+
+      $logger.debug "wildcard regexp : #{ranged_regex}"
+
+      re = ranged_regex
+
+      # get lookup values, filter and return them
+      lookup_values = @current_param.get_lookup_values()
+      lookup_values.select { |lookup_value| re.match(lookup_value) }
+    else
+      [ new_value ]
+    end
+  end
+  
+  # checks param values for validity and adds them to our value collection
+  # expands wildcard parameters if appropriate
+  # returns the values that have been added (might be more than 'new_value' when wildcards are used)
+  def add_parameter_value(new_value)
+    # pre-process the value if necessary
+    processed_param_values = pre_process_param_value(new_value)
+    # TODO this check is already part of check_param_is_valid (which is called later in this method and when the request is created) - we do not want to check this three times...?
+    if processed_param_values.size == 0
+      raise RHCP::RhcpException.new("invalid value '#{new_value}' for parameter '#{@current_param.name}'")
+    end
+    #processed_param_values = [ new_value ]
+    processed_param_values.each do |value|
+      # TODO we need to pass a value array here, and we should include the already selected param values
+      @current_param.check_param_is_valid([ value ])
+      $logger.debug "accepted value #{value} for param #{@current_param.name}"
+
+      @collected_params[@current_param.name] = Array.new if @collected_params[@current_param.name] == nil
+      @collected_params[@current_param.name] << value      
+    end
+    processed_param_values
+  end
+  
+  def print_cell(col_name, the_value)
+    result = "| "
+    result += the_value.to_s
+    1.upto(@max_width[col_name] - the_value.to_s.length) { |i| 
+      result += " " 
+    }
+    result += " "
+    result
+  end
+  
+  def print_line
+    result = ""
+    @total_width.times { |i| result += "-" }
+    result += "\n"
+    result
+  end
+  
+  def execute_command
+    begin
+      command = @command_broker.get_command(@command_selected.name)      
+      request = RHCP::Request.new(command, @collected_params)
+      response = command.execute_request(request)      
+      if (response.status == RHCP::Response::Status::OK)
+        $logger.debug "raw result : #{response.data}"
+        $logger.debug "display_type : #{command.result_hints[:display_type]}"
+        if command.result_hints[:display_type] == "table"
+          @last_response = response  # we might want to access this response in further commands
+          # TODO make sure that the response really holds the correct data types and that we've got at least one column
+          # TODO check that all columns in overview_columns are valid
+          # TODO check that all columns in column_titles are valid and match overview_columns
+          output = ""         
+          
+          # let's find out which columns we want to display
+          $logger.debug "overview columns : #{command.result_hints[:overview_columns]}"          
+          columns_to_display = command.result_hints.has_key?(:overview_columns) ?
+            command.result_hints[:overview_columns].clone() :
+            # by default, we'll display all columns, sorted alphabetically
+            columns_to_display = response.data[0].keys.sort
+          
+          # and which titles they should have (default : column names)
+          column_title_list = command.result_hints.has_key?(:column_titles) ?
+            command.result_hints[:column_titles].clone() :
+            column_title_list = columns_to_display 
+          
+          # TODO the sorting column should be configurable
+          first_column = columns_to_display[0]
+          $logger.debug "sorting by #{first_column}"
+          response.data = response.data.sort { |a,b| a[first_column] <=> b[first_column] }          
+          
+          # add the index column
+          columns_to_display.unshift "__idx"
+          column_title_list.unshift "\#"
+          count = 1
+          response.data.each do |row|
+            row["__idx"] = count
+            count = count+1
+          end
+          
+          
+          column_titles = {}
+          0.upto(column_title_list.length - 1) do |i|
+            column_titles[columns_to_display[i]] = column_title_list[i]
+          end
+          $logger.debug "column title : #{column_titles}"
+          
+          # find the maximum column width for each column
+          @max_width = {}
+          response.data.each do |row|
+            row.each do |k,v|
+              if ! @max_width.has_key?(k) || v.to_s.length >  @max_width[k]
+                @max_width[k] = v.to_s.length
+              end
+            end
+          end
+          
+          # check the column_title
+          columns_to_display.each do |col_name|
+            if column_titles[col_name].length > @max_width[col_name]
+              @max_width[col_name] = column_titles[col_name].length
+            end
+          end
+          #@max_width["row_count"] = response.data.length.to_s.length
+          $logger.debug "max width : #{@max_width}"
+          
+          # and build headers
+          @total_width = 2 + columns_to_display.length-1 # separators at front and end of table and between the values
+          columns_to_display.each do |col|
+            @total_width += @max_width[col] + 2 # each column has a space in front and behind the value
+          end
+          output += print_line
+          
+          columns_to_display.each do |col|
+            output += print_cell(col, column_titles[col])
+          end
+          output += "|\n"
+
+          output += print_line
+          
+          # print the table values
+          response.data.each do |row|            
+            columns_to_display.each do |col|
+              output += print_cell(col, row[col])
+            end
+            output += "|\n"
+          end
+          output += print_line
+          
+          puts output
+        elsif command.result_hints[:display_type] == "list"
+          output = ""
+          response.data.each do |row|
+            output += "#{row}\n"
+          end
+          puts output
+        elsif command.result_hints[:display_type] == "hidden"
+          $logger.debug "suppressing output due to display_type 'hidden'"
+        else
+          puts "executed '#{@command_selected.name}' successfully : #{response.data}"
+        end
+      else
+        puts "could not execute '#{@command_selected.name}' : #{response.error_text}"
+        $logger.error "#{response.error_text} : #{response.error_detail}"
+      end
+      reset_to_command_mode
+    rescue
+      puts "got an error : #{$!}"
+      raise
+    end
+  end  
+  
+  ## the following methods are overridden from ShellBackend
+  
+  def process_input(command_line)
+    $logger.debug "processing input '#{command_line}'"
+    
+    if (@command_selected) then
+      # we're in parameter processing mode - so check which parameter 
+      # we've got now and switch modes if necessary
+
+      # we might have been waiting for multiple param values - check if the user finished
+      # adding values by selecting an empty string as value
+      if (@current_param.allows_multiple_values and command_line == "") then
+        $logger.debug "finished multiple parameter input mode for param #{@current_param.name}"
+        @missing_params.shift        
+        execute_command_if_possible
+      else       
+        accepted_params = add_parameter_value(command_line)
+        if accepted_params
+          # stop asking for more values if
+          # a) the parameter does not allow more than one value
+          # b) the user entered a wildcard parameter that has been expanded to multiple values
+          if (! @current_param.allows_multiple_values or accepted_params.length > 1) then
+            $logger.debug "finished parameter input mode for param #{@current_param.name}"
+            @missing_params.shift        
+            execute_command_if_possible
+          else
+            $logger.debug "param '#{@current_param.name}' expects multiple values...deferring mode switching"
+          end
+        end
+      end
+    else
+      # we're waiting for the user to enter a command
+      # we might have a command with params
+      command, *params = command_line.split
+      $logger.debug "got command '#{command}' (params: #{params})"
+
+      # remember what the user specified so far
+      begin
+        @command_selected = @command_broker.get_command(command)
+        #if (@command_selected != nil) then
+        $logger.debug "command_selected: #{@command_selected}"
+          
+        # apply the preset param values to this new command
+        # TODO reactivate parameter presets        
+#        @command_broker.get_global_parameter_presets().each do |name, values|
+#          # check if the selected command needs this param
+#          @current_param = @command_broker.get_param(command, name)
+#          if @current_param and not @current_param.ignore_global_presets then
+#            $logger.debug "presetting global parameter '#{name}' to '#{values}'"
+#            values.each do |value|
+#              add_parameter_value(value)
+#            end
+#          end
+#        end
+        
+        # process the params specified on the command line          
+        if (params != nil) then            
+          params.each do |param|
+            if param =~ /(.+?)=(.+)/ then
+              # --> named param
+              key = $1
+              value = $2
+            else
+              # TODO if there's only one param, we can always use this as default param (maybe do this in the command?)
+              # --> unnamed param
+              value = param
+              default_param = @command_selected.default_param
+              if default_param != nil then
+                key = default_param.name
+                $logger.debug "collecting value '#{value}' for default param '#{default_param.name}'"
+              else
+                $logger.info "ignoring param '#{value}' because there's no default param"
+              end
+            end
+
+            if key then
+              begin
+                @current_param = @command_selected.get_param(key)
+                add_parameter_value(value)
+              rescue RHCP::RhcpException => ex
+                puts ex.to_s
+              end
+            end
+          end
+        end
+                    
+        $logger.debug "selected command #{@command_selected.name}" 
+        execute_command_if_possible
+      rescue RHCP::RhcpException => ex
+        puts "#{ex}"
+      end
+    end
+ rescue => err
+   $logger.error err
+    puts "exception raised: #{err.to_s}"
+  end
+  
+  def complete(word = "")
+    $logger.debug "collection completion values for '#{word}'"
+
+    if (@command_selected) then
+      # TODO include partial_value here?
+      props = @command_selected.params[@current_param.name].get_lookup_values()
+      #props = @command_broker.get_lookup_values(@command_selected.name, @current_param.name)
+    else
+      props = @command_broker.get_command_list.values.map{|command| command.name}.sort
+    end
+    
+    proposal_list = props.map { |p| "'#{p}'" }.join(" ")
+    $logger.debug "completion proposals: #{proposal_list}"
+
+    prefix = word
+    props.select{|name|name[0...(prefix.size)] == prefix}
+  end
+  
+def show_banner
+    puts @banner
+  end
+  
+  def set_prompt(string)
+    @prompt = "#{string ? string + " " : ""}$ "
+  end
+  
+  def process_ctrl_c
+    puts ""
+    if @command_selected then
+      reset_to_command_mode
+    else
+      Kernel.exit
+    end
+  end  
+  
+end

data/lib/shell_backend.rb

@@ -0,0 +1,29 @@
+# responsible for what should happen when the user interacts with the shell
+# provides tab completion options and processes the user's input
+class ShellBackend
+
+  # is called whenever the user submits a command (hitting enter)
+  def process_input(command_line)
+    raise "not implemented in ShellBackend!"
+  end
+  
+  # is called whenever the user requests tab completion
+  # should return an array of completion proposals
+  def complete(word)
+    raise "not implemented in ShellBackend!"
+  end
+  
+  # is called by the shell to get the prompt that should be displayed
+  def prompt
+    ">"    
+  end
+  
+  def process_ctrl_c
+    
+  end
+  
+  def show_banner
+    
+  end
+  
+end

data/start_shell.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+ruby -Ilib lib/rhcp_shell.rb

data/test/rhcp_shell_backend_test.rb

@@ -0,0 +1,236 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'test/unit'
+require 'rhcp_shell_backend'
+
+require 'rubygems'
+require 'rhcp'
+require 'logger'
+
+require 'setup_test_registry'
+
+class RhcpShellBackendTest < Test::Unit::TestCase
+  
+  # Backend that "remembers" everything it ever printed to the user
+  class BackendMock < RHCPShellBackend
+
+      def initialize(broker, on_receive)
+        super(broker)
+        @on_receive = on_receive
+      end
+    
+      def process_input(line)
+        $stdout.puts "[user] #{line}"
+        super(line)
+      end
+      
+      def puts(what)
+        $stdout.puts "[shell] #{what}"
+        @on_receive.call(what)
+      end      
+      
+      def set_prompt(new_prompt)
+        $stdout.puts "[shell: switching prompt to '#{new_prompt}']"
+        super(new_prompt)
+      end
+
+      def complete(word = "")
+        result = super(word)
+        proposal_list = result.map { |p| "'#{p}'" }.join(" ")
+        $stdout.puts "[completion proposals : #{proposal_list}]"
+        result
+      end
+      
+  end  
+  
+  def setup
+    # set up a local broker that we'll use for testing
+    # TODO do something about this - it shouldn't be necessary to instantiate this beforehand
+    $logger = Logger.new($stdout)
+    @log = Array.new()
+    @backend = BackendMock.new($broker, self.method(:add_to_log))
+  end
+  
+  def add_to_log(new_line)
+    #puts "adding to log (old size : #{@log.size}): *****#{new_line}*****"
+    @log << new_line
+    # TODO CAREFUL: if you un-comment the following line, @log will get screwed up
+    #puts "log now : >>#{@log.join("\n")}<<"
+  end
+  
+  def assert_received(expected)    
+    assert_equal(expected, @log.slice(- expected.length, expected.length))
+    # clean the log so that assert_no_error works
+    #@log.clear
+  end
+
+  def assert_no_error
+    assert_equal 0, @log.select { |line| 
+      /error/i =~ line || /exception/i =~ line || /failed/i =~ line
+    }.size
+  end
+  
+  def assert_log_contains(stuff)
+    is_ok = @log.grep(/#{stuff}/).size > 0
+    puts "checking log for #{stuff}"
+    assert is_ok, "log should contain '#{stuff}', but it doesn't : >>#{@log.join("\n")}<<"
+  end
+  
+  def assert_prompt(expected)    
+    if (expected == '')
+      assert_equal "$ ", @backend.prompt
+    else
+      assert_equal "#{expected} $ ", @backend.prompt
+    end
+  end
+  
+  def test_banner
+    @backend.banner = "This is a test backend"
+    @backend.show_banner
+    assert_received [ "This is a test backend" ]
+  end
+  
+  def test_simple_execute  
+    @backend.process_input "test"
+    assert_received [ "executed 'test' successfully : 42" ]
+  end    
+  
+  def test_invalid_command
+    @backend.process_input "does not exist"
+    assert_received [ "no such command : does" ]
+  end
+  
+  def test_missing_mandatory_param
+    @backend.process_input "reverse"
+    assert_prompt 'reverse.input'
+    @backend.process_input "zaphod"
+    assert_received [ "executed 'reverse' successfully : dohpaz" ]
+  end
+  
+  def test_completion
+    @backend.process_input "reverse"
+    assert_prompt 'reverse.input'
+    assert_equal [ "zaphod", "beeblebrox" ], @backend.complete
+  end
+  
+  def test_command_completion
+    commands = $broker.get_command_list.values.map { |command| command.name }
+    # we should have all remote commands plus "help" and "exit"
+    commands << "help"
+    commands << "exit"
+    commands << "detail"
+    assert_equal commands.sort, @backend.complete.sort
+    assert_no_error
+  end
+  
+  def test_params_on_command_line
+    @backend.process_input "reverse input=zaphod"
+    assert_received [ "executed 'reverse' successfully : dohpaz" ]
+  end
+  
+  def test_invalid_param_value
+    @backend.process_input "reverse input=bla"
+    assert_received [ "invalid value 'bla' for parameter 'input'" ]
+  end
+  
+  def test_multi_params
+    @backend.process_input "cook"
+    assert_prompt 'cook.ingredient'
+    @backend.process_input "mascarpone"
+    @backend.process_input "chocolate"
+    @backend.process_input ""
+    assert_no_error    
+    assert_received [ "executed 'cook' successfully : mascarpone chocolate" ]
+  end
+  
+  # if the user is in command mode, he should be able to exit to command mode
+  # by pressing ctrl+c
+  def test_abort_param_mode
+    @backend.process_input "cook"
+    assert_prompt 'cook.ingredient'
+    @backend.process_ctrl_c
+    assert_prompt ''
+  end
+  
+  def test_failing_command
+    @backend.process_input "perpetuum_mobile"
+    assert_received [ "could not execute 'perpetuum_mobile' : don't know how to do this" ]
+  end
+  
+  def test_wildcard_support
+    @backend.process_input "cook ingredient=m*"
+    assert_received [ "executed 'cook' successfully : mascarpone marzipan" ]
+  end
+  
+  def test_preprocess_without_lookup_values
+    @backend.process_input "test thoroughly=yes"
+    assert_no_error
+  end
+  
+  def test_wildcard_ranges
+    @backend.process_input "echo input=string01..05"
+    assert_received [ "executed 'echo' successfully : string01 string02 string03 string04 string05" ]
+    
+    @backend.process_input "echo input=string17..20"
+    assert_received [ "executed 'echo' successfully : string17 string18 string19 string20" ]
+  end    
+  
+  def test_help
+    @backend.process_input "help"
+    assert_log_contains "The following commands are available"
+    $broker.get_command_list.values.each do |command|
+      assert_log_contains command.name
+    end
+  end
+    
+  def test_help_command
+    @log.clear
+    @backend.process_input "help cook"
+    puts "LOG >>#{@log}<<"
+    assert_log_contains "Syntax:"
+    assert_log_contains "cook ingredient=<value>, ingredient=<value2>, ..."
+  end
+  
+  def test_help_with_default_param
+    @backend.process_input "help help"
+    puts "LOG >>#{@log}<<"
+    assert_log_contains "Syntax:"
+    assert_log_contains "help [<command>]"
+  end
+  
+  def test_default_param
+    @backend.process_input "reverse zaphod"
+    assert_received [ "executed 'reverse' successfully : dohpaz" ]
+  end
+  
+  # unnamed params should be ignored if no default params are specified
+  def test_unnamed_param_without_default_param
+    @backend.process_input "echo bla"
+    assert_received [ "executed 'echo' successfully : hello world" ]
+  end
+  
+  def test_complete_without_lookup_values
+    @backend.process_input "length"
+    assert_prompt "length.input"
+    assert_equal [], @backend.complete
+  end
+  
+  def test_table
+    # TODO write a separate test for this stuff
+    p $broker.get_command("build_a_table")
+    @backend.process_input "build_a_table"
+#    assert_received [
+#      "Zaphod\tBeeblebrox",
+#      "Arthur\tDent",
+#      "Prostetnik\tYoltz(?)"
+#    ]
+  end
+  
+  # TODO test behaviour after an internal error occurred in the shell (e.g. some problem while formatting the result)
+  
+end

data/test/setup_test_registry.rb

@@ -0,0 +1,109 @@
+require 'rubygems'
+require 'rhcp'
+
+
+broker = RHCP::Broker.new()
+broker.clear()
+broker.register_command RHCP::Command.new("test", "just a test command", 
+  lambda { |req,res| 
+    42 
+  }
+  ).add_param(RHCP::CommandParam.new("thoroughly", "an optional param", 
+      { 
+        :mandatory => false
+      }
+  )
+)
+broker.register_command RHCP::Command.new("echo", "prints a string", 
+  lambda { |req,res| 
+    strings = req.has_param_value("input") ? req.get_param_value("input") : [ "hello world" ]
+    result = Array.new
+    strings.each do |s|
+      puts s
+      result << s
+    end
+    result.join(" ")
+  }
+  ).add_param(RHCP::CommandParam.new("input", "an optional param", 
+      { 
+        :mandatory => false,
+        :allows_multiple_values => true,
+        :lookup_method => lambda {
+          values = Array.new()
+          1.upto(20) do |i|
+            values << "string#{sprintf("%02d", i)}"
+          end
+          values
+        }
+      }
+  )
+)
+broker.register_command RHCP::Command.new("reverse", "reversing input strings", 
+  lambda { |req,res| 
+    req.get_param_value("input").reverse 
+  }
+  ).add_param(RHCP::CommandParam.new("input", "the string to reverse", 
+      { 
+        :lookup_method => lambda { [ "zaphod", "beeblebrox" ] },
+        :mandatory => true,
+        :is_default_param => true
+      }
+  )
+)
+broker.register_command RHCP::Command.new("cook", "cook something nice out of some ingredients", 
+  lambda { |req,res| 
+    ingredients = req.get_param_value("ingredient").join(" ")
+    puts "cooking something with #{ingredients}"
+    ingredients
+  }
+  ).add_param(RHCP::CommandParam.new("ingredient", "something to cook with", 
+      { 
+        :lookup_method => lambda { [ "mascarpone", "chocolate", "eggs", "butter", "marzipan" ] },
+        :allows_multiple_values => true,
+        :mandatory => true
+      }
+  )
+)
+broker.register_command RHCP::Command.new("perpetuum_mobile", "this command will fail", 
+  lambda { |req,res| 
+    raise "don't know how to do this"
+  }
+)
+broker.register_command RHCP::Command.new("length", "returns the length of a string", 
+  lambda { |req,res| 
+    req.get_param_value("input").length
+  }
+  ).add_param(RHCP::CommandParam.new("input", "the string to reverse", 
+      { 
+        :mandatory => true,
+        :is_default_param => true
+      }
+  )
+)
+
+command = RHCP::Command.new("list_stuff", "this command lists stuff", 
+  lambda { |req,res|
+    [ "peace", "aquaeduct", "education" ]
+  }
+)
+command.mark_as_read_only()
+command.result_hints[:display_type] = "list"
+broker.register_command command
+
+command2 = RHCP::Command.new("build_a_table", "this command returns tabular data", 
+  lambda { |req,res|
+    [ 
+      { :first_name => "Zaphod", :last_name => "Beeblebrox", :heads => 2, :character => "dangerous" },
+      { :first_name => "Arthur", :last_name => "Dent", :heads => 1, :character => "harmless (mostly)" },
+      { :first_name => "Prostetnik", :last_name => "Yoltz (?)", :heads => 1, :character => "ugly" }
+    ]
+  }
+)
+command2.mark_as_read_only()
+command2.result_hints[:display_type] = "table"
+command2.result_hints[:overview_columns] = [ "first_name", "last_name" ]
+broker.register_command command2
+
+p broker.get_command("build_a_table")
+
+$broker = broker

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: rhcp_shell
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Philipp T.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-23 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.3
+    version: 
+description: FIX (describe your package)
+email: 
+- philipp@hitchhackers.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- README
+- lib/base_shell.rb
+- lib/rhcp_shell.rb
+- lib/rhcp_shell_backend.rb
+- lib/shell_backend.rb
+- start_shell.sh
+- test/rhcp_shell_backend_test.rb
+- test/setup_test_registry.rb
+has_rdoc: true
+homepage: FIX (url)
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rhcp
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: FIX (describe your package)
+test_files: []
+