vop 0.3.5 → 0.3.6

data/lib/vop/shell/shell.rb

@@ -1,4 +1,3 @@
-require "readline"
 require_relative "shell_formatter"
 require_relative "shell_input"
 require_relative "shell_input_readline"
@@ -8,6 +7,7 @@ module Vop
   class Shell
 
     attr_reader :context
+    attr_reader :last_response
 
     def initialize(op, input = nil)
       @op = op
@@ -15,7 +15,7 @@ module Vop
 
       @formatter = ShellFormatter.new
 
-      # TODO for testing
+      # override for testing
       if input.nil?
         input = ShellInputReadline.new(method(:tab_completion))
       end
@@ -45,43 +45,48 @@ module Vop
         puts
         print @prompt
       else
-        puts "\nbye"
+        puts "\n"
         exit
       end
     end
 
-    def mix_arguments_and_context
-      result = @arguments
+    def mix_arguments_and_context(command = nil, arguments = nil)
+      result = arguments || @arguments
       @context.each do |k,v|
-        param = @command.param(k)
-        if param && param.wants_context
-          result[k] = @context[k]
+        cmd = command || @command
+        if cmd
+          param = (cmd).param(k)
+          if param && param.wants_context
+            result[k] = @context[k]
+          end
         end
       end
       result
     end
 
-    def maybe_execute
-      mandatory = @command.mandatory_params
-
-      missing_mandatory_params = @command.mandatory_params.delete_if do |param|
-        @arguments.keys.include?(param.name) ||
+    def missing_mandatory_params(command = @command, arguments = @arguments)
+      command.mandatory_params.delete_if do |param|
+        arguments.keys.include?(param.name) ||
         (@context.keys.include?(param.name) && param.wants_context)
       end
+    end
 
-      if missing_mandatory_params.size > 0
-        $logger.debug "missing params : #{missing_mandatory_params.map(&:name)}"
-      end
-
+    def maybe_execute
       if missing_mandatory_params.size > 0
         @missing_params = missing_mandatory_params
         @prompt = "#{@command.short_name}.#{@missing_params.first.name} ? "
       else
         begin
-          request = Request.new(@op, @command.short_name, @arguments, @context)
+          request = @op.prepare_request(@command.short_name, @arguments, @context, @command.short_name)
           request.shell = self
           response = @op.execute_request(request)
 
+          # log the last response for the "detail" command
+          unless @command.short_name == "detail"
+            @last_response = response
+          end
+
+          # mix context changes from the response into the local context
           @context.merge! response.context
 
           display_type = @formatter.analyze(request, response)
@@ -95,65 +100,92 @@ module Vop
     end
 
     def accept_param(line)
-      current_param = @missing_params.shift
-      $logger.debug "value for param #{current_param.name} : #{line}"
-      @arguments[current_param.name] = line
+      unless line.nil?
+        current_param = @missing_params.shift
+        $logger.debug "value for param #{current_param.name} : #{line}"
+        @arguments[current_param.name] = line
 
-      maybe_execute
+        maybe_execute
+      end
     end
 
-    def parse_command_line(args)
-      result = {}
-      unless args.empty?
-        args.each do |token|
-          if token.include? "="
-            (key, value) = token.split("=")
-            result[key] = value
-          else
-            default_param = @command.default_param
-            if default_param
-              result[default_param.name] = args
-            end
-          end
+    def is_special?(command)
+      command.start_with?('$') || command.start_with?('@') || command.end_with?('?')
+    end
+
+    def handle_special(command)
+      if command.start_with?('$')
+        if command.start_with?('$vop')
+          puts "executing #{command}"
+          puts eval command
+        else
+          puts "unknown $-command #{command} - try '$vop' maybe?"
+        end
+      elsif command.start_with?('@')
+        if command.start_with?('@op')
+          puts "executing #{command}"
+          puts eval command
+        else
+          puts "unknown @-command #{command} - try '@op' maybe?"
         end
       end
-      result
     end
 
-    def parse_and_execute(command_line)
+    def parse(command_line)
       (command, *args) = command_line.split
 
+      arguments = {}
       if command
         $logger.debug "command : #{command}, args : #{args}"
-        if command.start_with?('$')
-          if command.start_with?('$vop')
-            puts "executing #{command}"
-            puts eval command
-          else
-            puts "unknown $-command #{command} - try '$vop' maybe?"
-          end
-        elsif command.start_with?('@')
-          if command.start_with?('@op')
-            puts "executing #{command}"
-            puts eval command
-          else
-            puts "unknown @-command #{command} - try '@op' maybe?"
+
+        if command.end_with?("??")
+          target_command = command[0..-3]
+          command = "source"
+          arguments["name"] = target_command
+        elsif command.end_with?("?")
+          target_command = command[0..-2]
+          command = "help"
+          arguments["name"] = target_command
+        end
+
+        known_commands = @op.commands.keys
+        if known_commands.include? command
+          cmd = @op.commands[command]
+
+          unless args.empty? || is_special?(command)
+            args.each do |token|
+              if token.include? "="
+                (key, value) = token.split("=")
+                arguments[key] = value
+              else
+                default_param = cmd.default_param(mix_arguments_and_context)
+                if default_param
+                  arguments[default_param.name] = args
+                end
+              end
+            end
           end
+          [command, cmd, arguments]
         else
-          if command.end_with?("?")
-            help_command = command[0..-2]
-            command = "help"
-            args << "name=#{help_command}"
-          end
+          [command, nil, arguments]
+        end
+      end
+    end
 
+    def parse_and_execute(command_line)
+      command, cmd, arguments = parse(command_line)
+
+      if command
+        $logger.debug "command : #{command}, args : #{arguments}"
+        if is_special?(command)
+          handle_special(command_line)
+        else
           if command == "exit"
             @input.exit
           else
-            known_commands = @op.commands.keys
-            if known_commands.include? command
-              @command = @op.commands[command]
-              @arguments = parse_command_line(args)
-
+            if cmd
+              @command = cmd
+              @arguments = arguments
               maybe_execute
             else
               puts "unknown command '#{command}'"
@@ -161,47 +193,62 @@ module Vop
           end
         end
       end
-
     end
 
-    def tab_completion(s)
-      lookups = []
+    def complete_for_command(s)
+      current_param = @missing_params.first
+      if current_param && current_param.options.has_key?(:lookup)
+        begin
+          lookup_block = current_param.options[:lookup]
 
-      if @command
-        current_param = @missing_params.first
-        if current_param && current_param.options.has_key?(:lookup)
-          begin
-            lookup_block = current_param.options[:lookup]
-
-            # the lookup block might want the previously collected params as input
-            lookups = if lookup_block.arity > 0
-              params_for_lookup = mix_arguments_and_context
-              lookup_block.call(params_for_lookup)
-            else
-              lookup_block.call()
-            end
-          rescue => detail
-            $logger.error "problem loading lookup values for #{current_param.name} : #{detail.message}"
+          # the lookup block might want the previously collected params as input
+          lookups = if lookup_block&.arity > 0
+            params_for_lookup = mix_arguments_and_context
+            lookup_block.call(params_for_lookup)
+          else
+            lookup_block.call()
           end
+          lookups.grep /^#{Regexp.escape(s)}/
+        rescue => detail
+          $logger.error "problem loading lookup values for #{current_param.name} : #{detail.message}"
+        end
+      end
+    end
+
+    def complete_command_line(s)
+      potential_command, potential_cmd, potential_args = parse(s)
+      #$logger.debug "? >>#{potential_cmd}<< (#{potential_args}) [#{Readline.line_buffer}]"
+      if potential_cmd
+        default_param = potential_cmd.default_param
+        if default_param
+          lookups = default_param.lookup(mix_arguments_and_context)
+          lookups
+            .grep(/^#{Regexp.escape(s.split.last)}/)
+            .map do |lookup|
+              "#{potential_command} #{lookup}"
+            end
         end
       else
-        lookups = @op.commands.keys.sort
+        lookups = @op.commands.keys.sort.grep /^#{Regexp.escape(s)}/
       end
 
-      lookups.grep /^#{Regexp.escape(s)}/
     end
 
-    def do_it(command_line = nil)
-      #Readline.completion_append_character = ""
-      #Readline.completion_proc = method(:tab_completion)
+    def tab_completion(s)
+      if @command
+        complete_for_command(s)
+      else
+        complete_command_line(s)
+      end
+    end
 
-      if command_line
+    def do_it(command_line = nil)
+      if command_line && command_line != ""
         parse_and_execute(command_line)
       else
         while line = @input.read(@prompt)
-        #while line = Readline.readline(@prompt, true)
           if @command
-            # if a command has already been selected, we ask for missing params
+            # if a command has already been selected, ask for missing params
             accept_param(line)
           else
             # otherwise input is treated as regular command line (command + args)
@@ -213,7 +260,7 @@ module Vop
 
     def self.run(op = nil, command_line = nil)
       if op.nil?
-        op = Vop.new
+        op = Vop.new(origin: "shell:#{Process.pid}@#{`hostname`.strip}")
       end
       self.new(op).do_it(command_line)
     end

data/lib/vop/shell/shell_formatter.rb

@@ -35,10 +35,11 @@ module Vop
       command = request.command
       show_options = command.show_options
 
-      result = case display_type
+      case display_type
       when :table
         columns_to_display =
           if show_options[:columns]
+            # TODO validate all columns exist?
             show_options[:columns]
           else
             # TODO this is not optimal - what if the second row has more keys than the first?
@@ -54,8 +55,9 @@ module Vop
         data.each do |row|
           values = [ ]
           columns_to_display.each do |key|
-            values << (row[key.to_s] || row[key.to_sym])
-          end
+            potential_value = row[key.to_s] || row[key.to_sym]
+            values << potential_value
+          end unless row.nil?
           rearranged << values
         end
 
@@ -79,18 +81,33 @@ module Vop
           "#{k} : #{v}"
         end.join("\n")
       when :entity_list
-        data.sort_by { |e| e.id }.map do |entity|
-          attributes = entity.data.sort_by do |x|
-
-          end.map do |key, value|
-            if key == entity.key
-              nil
-            else
-              "#{key} : #{value}"
-            end
-          end.compact.join("\n  ")
-          "[#{entity.type}] #{entity.id}\n  #{attributes}"
-        end.join("\n")
+        sorted = data.sort_by { |e| e.id }
+
+        columns = if show_options[:columns]
+          show_options[:columns]
+        else
+          blacklisted_keys = %w|name params plugin_name|
+          all_keys = sorted.map { |x| x.data.keys }.flatten.uniq
+          all_keys.delete_if { |x| blacklisted_keys.include? x }
+        end
+
+        headers = [ sorted.first.key ] + columns
+
+        rows = sorted.map do |entity|
+          row = [ entity.id ]
+
+          columns.each do |column|
+            value = entity.data[column] || ""
+            row << (value.respond_to?(to_s) ? value.to_s[0..49] : value)
+          end
+
+          row
+        end
+
+        Terminal::Table.new(
+          rows: rows,
+          headings: headers
+        )
       when :entity
         entity = data
         "[#{entity.type}] #{entity.id}"
@@ -101,8 +118,6 @@ module Vop
       else
         raise "unknown display type #{display_type}"
       end
-
-      result
     end
 
   end

data/lib/vop/shell/shell_input_readline.rb

@@ -1,3 +1,5 @@
+require "readline"
+
 module Vop
 
   class ShellInputReadline
@@ -5,6 +7,7 @@ module Vop
     def initialize(completion_method)
       Readline.completion_append_character = ""
       Readline.completion_proc = completion_method
+      Readline.completer_word_break_characters = "\t\n\"\\'\`@$><=;|&{(" # default, but without space
     end
 
     def read(prompt)

data/lib/vop/shell/shell_input_testable.rb

@@ -3,17 +3,23 @@ module Vop
   class TestableShellInput
 
     attr_accessor :answers
-    attr_reader :exit
+    attr_reader :exit, :prompt
+    attr_accessor :fail_if_out_of_answers
 
     def initialize
       @answers = []
       @exit = false
+      @prompt = nil
+      @fail_if_out_of_answers = true
     end
 
     def read(prompt)
+      @prompt = prompt
       answer = @answers.shift
-      if answer.nil?
-        raise "no more pre-defined answers (asked for '#{prompt}')"
+      if answer.nil? && @fail_if_out_of_answers
+        unless @exit
+          raise "no more pre-defined answers (asked for '#{prompt}')"
+        end
       end
       answer
     end

data/lib/vop/syntax/command_syntax.rb

@@ -2,24 +2,17 @@ module Vop
 
   module CommandSyntax
 
-    def run(&block)
-      @command.block = block
-    end
-
     def description(s)
       @command.description = s
     end
 
-    def resolve_options_string(options)
-      if options.is_a? String
-        options = {
-          description: options
-        }
-      end
-      options
+    def run(&block)
+      @command.block = block
     end
 
-    def param(name, options = {})
+    def param(name, options = {}, more_options = {})
+      options = resolve_options_string(options).merge(more_options)
+
       if name.is_a? Symbol
         key = "name" # default for select_machine
         entity = @op.entities.values.select { |x| x.short_name == name.to_s }.first
@@ -38,18 +31,15 @@ module Vop
         name = name.to_s
       end
 
-      options = resolve_options_string(options)
-
       @command.add_param(name, options)
     end
 
-    def param!(name, options = {})
-      options = resolve_options_string(options)
+    def param!(name, options = {}, more_options = {})
+      options = resolve_options_string(options).merge(more_options)
       options.merge! mandatory: true
       param(name, options)
     end
 
-    # TODO does not really work yet
     def block_param(name = "block", options = {})
       options.merge! block: true
       param(name, options)
@@ -69,6 +59,10 @@ module Vop
       @command.allows_extra = true
     end
 
+    def dont_log
+      @command.dont_log = true
+    end
+
     def show(options = {})
       @command.show_options[:columns] = options.delete(:columns)
       @command.show_options[:display_type] = options.delete(:display_type)
@@ -89,6 +83,17 @@ module Vop
       @command.invalidation_block = block
     end
 
+    private
+
+    def resolve_options_string(options)
+      if options.is_a? String
+        options = {
+          description: options
+        }
+      end
+      options
+    end
+
   end
 
 end

data/lib/vop/syntax/entity_syntax.rb

@@ -2,18 +2,20 @@ module Vop
 
   module EntitySyntax
 
+    def description(s)
+      @entity.description = s
+    end
+
     def key(key)
       @entity.key = key
     end
 
     def entity(options = { key: "name" }, &block)
-      if block
-        run(&block)
-      end
+      run(&block)
     end
 
     def run(&block)
-      @entity.block = block
+      @entity.block = block if block
     end
 
     def on(other_entity)
@@ -26,8 +28,21 @@ module Vop
 
       raise "unknown keyword #{options.keys.first}" if options.keys.length > 0
 
-      @entity.show_options[:columns] = column_options
-      @entity.show_options[:display_type] = display_type
+      @entity.show_options[:columns] = column_options if column_options
+      @entity.show_options[:display_type] = display_type if display_type
+    end
+
+    def invalidate(&block)
+      @entity.invalidation_block = block
+    end
+
+    def contribute(options, &block)
+      raise "missing option 'to'" unless options.has_key?(:to)
+      @op.register_contributor(
+        command_name: options[:to],
+        contributor: @entity.name.to_s.carefully_pluralize
+      )
+      run(&block)
     end
 
   end

data/lib/vop/syntax/plugin_syntax.rb

@@ -42,6 +42,12 @@ module Vop
       end
     end
 
+    # TODO: support version requirements
+    def depends_on_gem(gem, **options)
+      $logger.debug "plugin #{@plugin.name} depends on gem #{gem}"
+      @plugin.external_dependencies[:gem] << [gem, options]
+    end
+
     def on(hook_sym, &block)
       @plugin.hook(hook_sym, &block)
     end

data/lib/vop/util/pluralizer.rb

@@ -2,7 +2,7 @@ begin
   require "active_support/inflector"
 rescue Exception => e
   message = "active_support inflector cannot be loaded - pluralization results may deviate : #{e.message}"
-  puts message
+  #puts message
 end
 
 module Vop
@@ -19,6 +19,14 @@ module Vop
         end
       end
 
+      def carefully_singularize
+        begin
+          self.singularize
+        rescue
+          "#{self[0..-2]}"
+        end
+      end
+
     end
 
   end

data/lib/vop/version.rb

@@ -1,3 +1,3 @@
 module Vop
-  VERSION = "0.3.5"
+  VERSION = "0.3.6"
 end