vop 0.3.0

data/lib/vop/plugin_loader.rb

@@ -0,0 +1,88 @@
+require 'vop/plugin'
+require 'pp'
+
+module Vop
+
+  class PluginLoader
+
+    attr_reader :op
+    attr_reader :dir
+
+    def initialize(op, dir)
+      @op = op
+      @dir = dir
+    end
+
+    def new_plugin(plugin_name, plugin_path)
+      @plugin = Plugin.new(@op, plugin_name, plugin_path)
+
+      # TODO activate plugin_loader helpers?
+      # (this will allow plugins to define helpers that can be used in plugins)
+      #@plugin.inject_helpers(self)
+      #@plugin.inject_helpers(self, 'plugin_loader')
+
+      @op.plugins[plugin_name] = @plugin
+      @plugin
+    end
+
+    def on(hook_sym, &block)
+      @plugin.hook(hook_sym, &block)
+
+      core_hooks = %i|before_execute after_execute|
+      if core_hooks.include? hook_sym
+        @op.hook(hook_sym, @plugin.name)
+      end
+    end
+
+    def dependency(sym)
+      @plugin.dependencies << sym.to_s
+    end
+    alias_method :depends, :dependency
+
+    def read_plugin_template
+      template_path = File.join(@dir, 'plugin.vop')
+      plugin_template = nil
+      if File.exists?(template_path)
+        plugin_template = IO.read(template_path)
+      end
+      if plugin_template
+        begin
+          self.instance_eval plugin_template
+        rescue => e
+          $stderr.puts "could not load plugin #{template_path} : " + e.message
+          $stderr.puts e.backtrace.join("\n")
+          raise e
+        end
+      end
+    end
+
+    def self.read(op, dir)
+      $logger.debug("scanning dir #{dir} for plugins...")
+
+      loader = new(op, dir)
+      loader.read_plugin_template
+
+      Dir.new(dir).each do |plugin_name|
+        next if /^\./.match(plugin_name)
+
+        plugin_path = File.join(dir, plugin_name)
+        file_name = File.join(plugin_path, "#{plugin_name}.plugin")
+        next unless File.exists?(file_name)
+        $logger.debug("reading plugin '#{plugin_name}' from '#{file_name}'")
+
+        plugin = loader.new_plugin(plugin_name, plugin_path)
+
+        code = File.read(file_name)
+        begin
+          loader.instance_eval(code, file_name)
+        rescue => detail
+          raise "problem loading plugin #{plugin_name} : #{detail.message}\n#{detail.backtrace.join("\n")}"
+        end
+
+        $logger.debug "loaded plugin #{plugin_name}"
+      end
+    end
+
+  end
+
+end

data/lib/vop/plugins/core/commands/clear_context.rb

@@ -0,0 +1,3 @@
+run do |shell|
+  shell.context.clear
+end

data/lib/vop/plugins/core/commands/collect_contributions.rb

@@ -0,0 +1,31 @@
+param! "name"
+param "except", :multi => true
+param! "raw_params"
+
+run do |name, raw_params, params|
+  result = []
+
+  registry = @op.plugins["core"].state[:contributions]
+  if registry.has_key? name
+    contributors = registry[name]
+    contributors.each do |contributor|
+      except = params["except"] || []
+      if except.include? contributor
+        puts "skipping contributor #{contributor} because of except"
+        next
+      end
+
+      $logger.debug "calling #{contributor} for contribution to #{name}"
+      #puts caller[0..10]
+      if caller.grep(/eval.*block in entity/).size > 2
+        $logger.debug "skipping contribution from #{contributor} because of loop"
+      else
+        $logger.debug "raw params: " + raw_params.inspect
+        short_name = contributor.to_s.split(".").last
+        result += @op.send(short_name.to_sym, raw_params)
+      end
+    end
+  end
+
+  result
+end

data/lib/vop/plugins/core/commands/edit.rb

@@ -0,0 +1,12 @@
+param! "name", :lookup => lambda { @op.list_commands.map { |x| x[:name] } }
+
+run do |params, name|
+  editor = ENV["EDITOR"]
+  editor = "vim" # TODO if "config.default_editor"
+  raise "please set the EDITOR environment variable" unless editor
+
+  command_file = @op.command(name).source[:file_name]
+  system("#{editor} #{command_file}")
+
+  @op.reset
+end

data/lib/vop/plugins/core/commands/help.rb

@@ -0,0 +1,38 @@
+param! "name", :lookup => lambda { @op.list_commands.map { |x| x[:name] } }
+
+run do |params|
+  puts
+  puts params["name"]
+  command = @op.commands[params["name"]]
+  if command.description
+    puts "  #{command.description}"
+  end
+
+  puts
+  puts "syntax:"
+
+  minimal_syntax = command.short_name
+  maximal_syntax = command.short_name
+  command.params.each do |p|
+    example = if p == command.default_param
+      "<#{p[:name]}>"
+    else
+      "#{p[:name]}=<#{p[:name]}>"
+    end
+    minimal_syntax << " #{example}" if p[:mandatory]
+    maximal_syntax << " #{example}"
+  end
+  puts "  #{minimal_syntax}"
+  puts "  #{maximal_syntax}" unless minimal_syntax == maximal_syntax
+
+  if command.params.size > 0
+    puts
+    puts "parameters:"
+    max_param_length = command.params.map { |p| p[:name].length }.max
+    command.params.each do |p|
+      puts "  %-#{max_param_length}s\t%s" % [p[:name], p[:description]]
+    end
+  end
+
+  nil
+end

data/lib/vop/plugins/core/commands/identity.rb

@@ -0,0 +1,4 @@
+run do
+  foo()  
+  config(:identity) || 'localhost'
+end

data/lib/vop/plugins/core/commands/list_contributors.rb

@@ -0,0 +1,8 @@
+param! "name"
+
+run do |name|
+  registry = @op.plugins["core"].state[:contributions]
+  if registry.has_key? name
+    registry[name]
+  end
+end

data/lib/vop/plugins/core/commands/list_entities.rb

@@ -0,0 +1,3 @@
+run do
+  @plugin.state[:entities].map { |x| x[:name] }
+end

data/lib/vop/plugins/core/commands/pry.rb

@@ -0,0 +1,9 @@
+require "pry"
+
+run do |params|
+  @op._pry
+  # pry messes up the terminal completion setup by the vop shell backend,
+  # so currently this is a one-call command:
+  @op.system_call("bin/vop.sh")
+  Kernel.exit(42)
+end

data/lib/vop/plugins/core/commands/reset.rb

@@ -0,0 +1,5 @@
+description "reloads plugins and commands"
+
+run do
+  @op._reset
+end

data/lib/vop/plugins/core/commands/show_context.rb

@@ -0,0 +1,3 @@
+run do |shell|
+  shell.context
+end

data/lib/vop/plugins/core/commands/source.rb

@@ -0,0 +1,5 @@
+param! "name", :lookup => lambda { |_| @op.list_commands.map { |x| x[:name] } }
+
+run do |params, name|
+  @op.command(name).source[:code]
+end

data/lib/vop/plugins/core/commands/system_call.rb

@@ -0,0 +1,5 @@
+param! "command"
+
+run do |command|
+  `#{command}`
+end

data/lib/vop/plugins/core/core.plugin

@@ -0,0 +1,4 @@
+on :init do |plugin|
+  plugin.state[:entities] ||= []
+  plugin.state[:contributions] ||= Hash.new { |h,k| h[k] = [] }
+end

data/lib/vop/plugins/core/helpers/command_loader/command_syntax.rb

@@ -0,0 +1,45 @@
+def config(sym)
+  @plugin.config[sym]
+end
+
+def description(s)
+  @command.description = s
+end
+
+def param(name, options = {})
+  p = {
+    :name => name.to_s,
+    :multi => false,
+    :mandatory => false,
+    :default_param => false
+  }
+
+  if name.is_a? Symbol
+    # parameters whose names are symbols are resolved into entities
+    op = @plugin.op
+
+    entity_names = op.core.state[:entities].map { |entity| entity[:name] }
+    if entity_names.include? name.to_s
+      list_command_name = "list_#{name.to_s.pluralize(42)}"
+      p[:lookup] = lambda do |params|
+        # TODO :name is probably specific to the entity (key?)
+        op.send(list_command_name.to_sym).map { |x| x[:name] }
+      end
+    end
+  end
+
+  @command.params << p.merge(options)
+end
+
+def param!(name, options = {})
+  options.merge! :mandatory => true
+  param(name, options)
+end
+
+def show(options = {})
+  column_options = options.delete(:columns)
+
+  raise "unknown keyword #{options.keys.first}" if options.keys.length > 0
+
+  @command.show_options[:columns] = column_options
+end

data/lib/vop/plugins/core/helpers/command_loader/contributions.rb

@@ -0,0 +1,28 @@
+# TODO remove?
+def accept_contributions
+  #puts "#{@command.name} accepts contributions"
+  # TODO this init should happen earlier
+  #@op.plugins['core'].state[:contributions] ||= Hash.new { |h,k| h[k] = [] }
+end
+
+def contribute(options = {}, &block)
+  target = options[:to] || @command.short_name
+  #puts "#{@command.name} contributes to #{target}"
+  # TODO check that the command exists
+  @op.plugins['core'].state[:contributions][target] << @command.name
+  @command.block = block
+end
+
+def with_contributions(options = {}, &block)
+  raise "untested"
+  collected = @op.collect_contributions('name' => command_name, 'raw_params' => params)
+  params_with_contributions = params.merge(:contributions => collected)
+  list = block.call(params_with_contributions)
+
+  found = list.select { |x| x[key.to_sym] == params[key] }
+  if found && found.size > 0
+    Entity.new(@op, command_name, key, found.first)
+  else
+    raise "no such entity : #{params[key]} [#{command_name}]"
+  end
+end

data/lib/vop/plugins/core/helpers/command_loader/entities.rb

@@ -0,0 +1,57 @@
+require 'vop/entity'
+require 'pp'
+
+# if an entity doesn't define a block, by default
+# it just passes through all contributions
+def default_entity_block(params)
+  params['contributions']
+end
+
+def define_entity(name, key, options)
+  @op.plugins['core'].state[:entities] << {
+    name: name,
+    key: key,
+    options: options
+  }
+end
+
+def entity(key, options = {}, &block)
+  command_name = @command.short_name
+
+  # the entity command gets a mandatory param automatically, using the
+  # block defined by the entity as lookup
+  # TODO make the default block work
+  #list_block = block || default_entity_block
+  list_block = block
+
+  if options[:on]
+    param! options[:on]
+  end
+
+  param! key, :lookup => lambda { |params|
+    collected = @op.collect_contributions('name' => command_name, 'raw_params' => params)
+    params_with_contributions = params.merge(:contributions => collected)
+    the_list = list_block.call(params_with_contributions)
+    the_list
+  }
+
+  define_entity(command_name, key, options)
+
+  # entities generally accept contributions...
+  accept_contributions
+
+  # ...and they have a special run block that filters the correct row from
+  # the lookup list and returns an entity populated from that row
+  @command.block = lambda do |params|
+    collected = @op.collect_contributions('name' => command_name, 'raw_params' => params)
+    params_with_contributions = params.merge(:contributions => collected)
+    list = list_block.call(params_with_contributions)
+
+    found = list.select { |x| x[key.to_sym] == params[key] }
+    if found && found.size > 0
+      Entity.new(@op, command_name, key, found.first)
+    else
+      raise "no such entity : #{params[key]} [#{command_name}]"
+    end
+  end
+end

data/lib/vop/plugins/core/helpers/helper.rb

@@ -0,0 +1,3 @@
+def foo
+  puts "call for mr. beeblebrox!"
+end

data/lib/vop/plugins/meta/commands/add_search_path.rb

@@ -0,0 +1,6 @@
+param! 'path'
+
+run do |params|
+  @op.config[:search_path] << params['path']
+  @op.reset
+end

data/lib/vop/plugins/meta/commands/delete_plugin.rb

@@ -0,0 +1,13 @@
+require 'fileutils'
+
+param! 'name'
+
+run do |params|
+  name = params['name']
+
+  plugin = @op.plugins[name]
+  raise "no such plugin : #{name}" unless plugin
+
+  FileUtils.rm_r plugin.path
+  @op.reset
+end

data/lib/vop/plugins/meta/commands/list_commands.rb

@@ -0,0 +1,17 @@
+description "returns a list of commands with descriptions"
+
+param 'plugin', :description => 'list of plugins to filter by',
+  :multi => true,
+  :lookup => lambda { |params| @op.list_plugins.map { |x| x[:name] } },
+  :default_param => true
+
+run do |params|
+  @op.commands.select do |name, command|
+    not params.has_key?('plugin') or params['plugin'].include?(command.plugin.name)
+  end.map do |name, command|
+    {
+      :name => name,
+      :description => command.description || ''
+    }
+  end
+end

data/lib/vop/plugins/meta/commands/list_plugins.rb

@@ -0,0 +1,8 @@
+run do
+  @op.plugins.map do |name, plugin|
+    {
+      :name => name,
+      :path => plugin.path
+    }
+  end
+end

data/lib/vop/plugins/meta/commands/new_command.rb

@@ -0,0 +1,14 @@
+param! 'name'
+param! 'plugin', :lookup => lambda { @op.list_plugins.map { |x| x[:name] } }
+
+run do |params|
+  pp params
+  plugin = @op.list_plugins.select { |x| x[:name] == params['plugin'] }.first
+
+  command_file = File.join(plugin[:path], 'commands', "#{params['name']}.rb")
+  File.write(command_file, "run { 42 }")
+
+  @op.reset
+
+  nil
+end