vop 0.3.1 → 0.3.4

data/lib/vop/shell/shell.rb

@@ -0,0 +1,221 @@
+require "readline"
+require_relative "shell_formatter"
+require_relative "shell_input"
+require_relative "shell_input_readline"
+
+module Vop
+
+  class Shell
+
+    attr_reader :context
+
+    def initialize(op, input = nil)
+      @op = op
+      @context = {}
+
+      @formatter = ShellFormatter.new
+
+      # TODO for testing
+      if input.nil?
+        input = ShellInputReadline.new(method(:tab_completion))
+      end
+      @input = input
+
+      trap('INT') {
+        handle_interrupt
+      }
+
+      reset
+    end
+
+    def reset
+      @command = nil
+      @arguments = {}
+
+      @prompt = if @context.has_key?("prompt")
+        @context["prompt"]
+      else
+        ">> "
+      end
+    end
+
+    def handle_interrupt
+      if @command
+        reset
+        puts
+        print @prompt
+      else
+        puts "\nbye"
+        exit
+      end
+    end
+
+    def mix_arguments_and_context
+      result = @arguments
+      @context.each do |k,v|
+        param = @command.param(k)
+        if param && param.wants_context
+          result[k] = @context[k]
+        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) ||
+        (@context.keys.include?(param.name) && param.wants_context)
+      end
+
+      $logger.debug "missing params : #{missing_mandatory_params.map(&:name)}"
+
+      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.shell = self
+          response = @op.execute_request(request)
+
+          @context.merge! response.context
+
+          display_type = @formatter.analyze(request, response)
+          formatted = @formatter.format(request, response, display_type)
+          puts formatted
+        rescue => detail
+          puts "[ERROR] #{detail.message}\n#{detail.backtrace.join("\n")}"
+        end
+        reset
+      end
+    end
+
+    def accept_param(line)
+      current_param = @missing_params.shift
+      $logger.debug "value for param #{current_param.name} : #{line}"
+      @arguments[current_param.name] = line
+
+      maybe_execute
+    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
+        end
+      end
+      result
+    end
+
+    def parse_and_execute(command_line)
+      (command, *args) = command_line.split
+
+      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?"
+          end
+        else
+          if command.end_with?("?")
+            help_command = command[0..-2]
+            command = "help"
+            args << "name=#{help_command}"
+          end
+
+          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)
+
+              maybe_execute
+            else
+              puts "unknown command '#{command}'"
+            end
+          end
+        end
+      end
+
+    end
+
+    def tab_completion(s)
+      lookups = []
+
+      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}"
+          end
+        end
+      else
+        lookups = @op.commands.keys.sort
+      end
+
+      lookups.grep /^#{Regexp.escape(s)}/
+    end
+
+    def do_it(command_line = nil)
+      #Readline.completion_append_character = ""
+      #Readline.completion_proc = method(:tab_completion)
+
+      if 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
+            accept_param(line)
+          else
+            # otherwise input is treated as regular command line (command + args)
+            parse_and_execute(line)
+          end
+        end
+      end
+    end
+
+    def self.run(op = nil, command_line = nil)
+      if op.nil?
+        op = Vop.new
+      end
+      self.new(op).do_it(command_line)
+    end
+
+  end
+
+end

data/lib/vop/shell/shell_formatter.rb

@@ -0,0 +1,110 @@
+require "terminal-table"
+
+module Vop
+
+  class ShellFormatter
+
+    def analyze(request, response)
+      data = response.result
+
+      if request.command.show_options[:display_type]
+        # TODO check that display_type is valid
+        request.command.show_options[:display_type]
+      else
+        if data.is_a? Array
+          first_row = data.first
+          if first_row.is_a? Hash
+            :table
+          elsif first_row.is_a? Entity
+            :entity_list
+          else
+            :list
+          end
+        elsif data.is_a? Hash
+          :hash
+        elsif data.is_a? Entity
+          :entity
+        else
+          :raw
+        end
+      end
+    end
+
+    def format(request, response, display_type)
+      data = response.result
+      command = request.command
+      show_options = command.show_options
+
+      result = case display_type
+      when :table
+        columns_to_display =
+          if show_options[:columns]
+            show_options[:columns]
+          else
+            # TODO this is not optimal - what if the second row has more keys than the first?
+            first_row = data.first
+            first_row.keys
+          end
+
+        # add an index column
+        column_headers = [ '#' ] + columns_to_display
+
+        # array of hashes -> array of arrays
+        rearranged = []
+        data.each do |row|
+          values = [ ]
+          columns_to_display.each do |key|
+            values << (row[key.to_s] || row[key.to_sym])
+          end
+          rearranged << values
+        end
+
+        unless show_options.include?(:sort) && show_options[:sort] == false
+          rearranged.sort_by! { |row| row.first || "" }
+        end
+
+        # add the index column after sorting
+        rearranged.each_with_index do |row, index|
+          row.unshift index
+        end
+
+        Terminal::Table.new(
+          rows: rearranged,
+          headings: column_headers
+        )
+      when :list
+        data.join("\n")
+      when :hash
+        data.map do |k,v|
+          "#{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")
+      when :entity
+        entity = data
+        "[#{entity.type}] #{entity.id}"
+      when :raw
+        data
+      when :data
+        data.pretty_inspect
+      else
+        raise "unknown display type #{display_type}"
+      end
+
+      result
+    end
+
+  end
+
+end

data/lib/vop/shell/shell_input.rb

@@ -0,0 +1,14 @@
+module Vop
+
+  class ShellInput
+
+    def initialize(completion_method)
+    end
+
+    def read(prompt)
+      raise "read() not implemented in abstract base class ShellInput!"
+    end
+
+  end
+
+end

data/lib/vop/shell/shell_input_readline.rb

@@ -0,0 +1,20 @@
+module Vop
+
+  class ShellInputReadline
+
+    def initialize(completion_method)
+      Readline.completion_append_character = ""
+      Readline.completion_proc = completion_method
+    end
+
+    def read(prompt)
+      Readline.readline(prompt, true)
+    end
+
+    def exit
+      Kernel.exit
+    end
+
+  end
+
+end

data/lib/vop/shell/shell_input_testable.rb

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

data/lib/vop/syntax/command_syntax.rb

@@ -0,0 +1,90 @@
+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
+    end
+
+    def param(name, 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
+        if entity.nil?
+          raise "entity #{name.to_s} defined as param in #{@command.name} not found"
+        else
+          key = entity.key
+        end
+
+        options[:entity] = true
+        options[:lookup] = lambda do
+          list_command_name = name.to_s.carefully_pluralize
+          the_list = @op.execute(list_command_name, {})
+          the_list.map(&key.to_sym)
+        end
+        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)
+      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)
+    end
+
+    def block_param!(name = "block", options = {})
+      options = resolve_options_string(options)
+      options.merge! mandatory: true
+      block_param(name, options)
+    end
+
+    def read_only
+      @command.read_only = true
+    end
+
+    def allows_extra
+      @command.allows_extra = true
+    end
+
+    def show(options = {})
+      @command.show_options[:columns] = options.delete(:columns)
+      @command.show_options[:display_type] = options.delete(:display_type)
+      @command.show_options[:sort] = options.delete(:sort)
+
+      raise "unknown keyword #{options.keys.first}" if options.keys.length > 0
+    end
+
+    def contribute(options, &block)
+      @op.register_contributor(
+        command_name: options[:to] || @command.short_name,
+        contributor: @command.name
+      )
+      @command.block = block
+    end
+
+  end
+
+end

data/lib/vop/syntax/entity_syntax.rb

@@ -0,0 +1,35 @@
+module Vop
+
+  module EntitySyntax
+
+    def key(key)
+      @entity.key = key
+    end
+
+    def entity(options = { key: "name" }, &block)
+      if block
+        run(&block)
+      end
+    end
+
+    def run(&block)
+      @entity.block = block
+    end
+
+    def on(other_entity)
+      @entity.on = other_entity
+    end
+
+    def show(options = {})
+      column_options = options.delete(:columns)
+      display_type = options.delete(:display_type)
+
+      raise "unknown keyword #{options.keys.first}" if options.keys.length > 0
+
+      @entity.show_options[:columns] = column_options
+      @entity.show_options[:display_type] = display_type
+    end
+
+  end
+
+end

data/lib/vop/syntax/filter_syntax.rb

@@ -0,0 +1,11 @@
+module Vop
+
+  module FilterSyntax
+
+    def run(&block)      
+      @filter.block = block
+    end
+
+  end
+
+end

data/lib/vop/syntax/plugin_syntax.rb

@@ -0,0 +1,55 @@
+module Vop
+
+  module PluginSyntax
+
+    def resolve_options_string(options)
+      if options.is_a? String
+        options = {
+          description: options
+        }
+      end
+      options
+    end
+
+    def config_param(name, options = {})
+      options = resolve_options_string(options)
+
+      @plugin.params << CommandParam.new(name, options)
+    end
+
+    def config_param!(name, options = {})
+      options = resolve_options_string(options)
+      options.merge! mandatory: true
+      config_param(name, options)
+    end
+
+
+
+    def description(string)
+      @plugin.description = string
+    end
+
+    def auto_load(bool)
+      @plugin.options[:auto_load] = bool
+    end
+
+    def depends_on(others)
+      others = [ others ] unless others.is_a?(Array)
+
+      others.each do |other|
+        $logger.debug "plugin #{@plugin.name} depends on #{other}"
+        @plugin.dependencies << other.to_s
+      end
+    end
+
+    def on(hook_sym, &block)
+      @plugin.hook(hook_sym, &block)
+    end
+
+    def hook(hook_sym, &block)
+      @op.hook(hook_sym, &block)
+    end
+
+  end
+
+end

data/lib/vop/util/errors.rb

@@ -0,0 +1,45 @@
+module Vop
+
+  module Errors
+
+    class RunningInCircles < StandardError
+    end
+
+    class MissingPlugin < StandardError
+    end
+
+    # see http://www.virtuouscode.com/2013/12/25/exception-causes-in-ruby-2-1/
+    class NestedError < StandardError
+
+      def initialize(message, original = $!)
+        super(message + " : " + original.message)
+        set_backtrace(original.backtrace)
+      end
+
+    end
+
+    class CommandLoadError < NestedError
+    end
+
+    class PluginLoadError < StandardError
+    end
+
+    class EntityLoadError < LoadError
+
+    end
+
+    class LoadError < StandardError
+
+      attr_reader :message, :detail
+
+      def initialize(message = nil, detail = nil)
+        @message = message
+        @detail = detail
+        super(detail)
+      end
+
+    end
+
+  end
+
+end

data/lib/vop/util/pluralizer.rb

@@ -0,0 +1,26 @@
+begin
+  require "active_support/inflector"
+rescue Exception => e
+  message = "active_support inflector cannot be loaded - pluralization results may deviate : #{e.message}"
+  puts message
+end
+
+module Vop
+
+  module Pluralizer
+
+    class ::String
+
+      def carefully_pluralize
+        begin
+          self.pluralize(2)
+        rescue
+          "#{self}s"
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/vop/util/worker.rb

@@ -0,0 +1,24 @@
+require "sidekiq"
+require "json"
+
+module Vop
+
+  class AsyncExecutorWorker
+    include Sidekiq::Worker
+
+    def perform(request_json)
+      begin
+        op = ::Vop.boot
+        request = ::Vop::Request::from_json(op, request_json)
+        puts "performing #{request.pretty_inspect}"
+        response = op.execute_request(request)
+        puts "response : #{response.status}"
+        puts response.result
+      rescue => e
+        puts "[ERROR] #{e.message}\n#{e.backtrace.join("\n")}"
+      end
+    end
+
+  end
+
+end

data/lib/vop/version.rb

@@ -1,3 +1,3 @@
 module Vop
-  VERSION = "0.3.1"
+  VERSION = "0.3.4"
 end