vop 0.3.0

data/lib/vop/command.rb

@@ -0,0 +1,168 @@
+module Vop
+
+  class Command
+
+    attr_reader :name
+    attr_reader :plugin
+
+    attr_accessor :block
+    attr_accessor :description
+    attr_accessor :show_options
+
+    attr_reader :params
+
+    def initialize(plugin, name)
+      @plugin = plugin
+      @name = name
+      @block = lambda { |params| $logger.warn "#{name} not yet implemented!" }
+      @params = []
+      @show_options = {}
+    end
+
+    def inspect
+      "Vop::Command #{@name}"
+    end
+
+    def source
+      @plugin.command_source(name)
+    end
+
+    def short_name
+      name.split(".").last
+    end
+
+    def param(name)
+      params.select { |param| param[:name] == name }.first || nil
+    end
+
+    # the default param is the one used when a command is called with a single "scalar" param only, like
+    #   @op.foo("zaphod")
+    # if a parameter is marked as default, it will be assigned the value "zaphod" in this case.
+    # if there's only a single param, it's the default param by default (ha!)
+    def default_param
+      if params.size == 1
+        params.first
+      else
+        params.select { |param| param[:default_param] == true }.first || nil
+      end
+    end
+
+    def mandatory_params
+      params.select do |p|
+        p[:mandatory]
+      end
+    end
+
+    def lookup(param_name, params)
+      p = param(param_name)
+      raise "no such param : #{param_name} in command #{name}" unless p
+
+      if p.has_key? :lookup
+        p[:lookup].call(params)
+      else
+        $logger.debug "no lookups for #{param_name}"
+        []
+      end
+    end
+
+    # accepts arguments as handed in by :define_method and prepares them
+    # into the +params+ structure expected by command blocks
+    def prepare_params(ruby_args, extra = {})
+      result = {}
+      if ruby_args
+        if ruby_args.is_a? Hash
+          result = ruby_args
+          ruby_args.each do |k,v|
+            p = param(k)
+            if p
+              # values are auto-boxed into an array if the param expects multiple values
+              if p[:multi] && ! v.is_a?(Array) then
+                $logger.debug("autoboxing for #{p[:name]}")
+                v = [ v ]
+              # array values are auto-unboxed if the param doesn't want multi
+              elsif ! p[:multi] && v.is_a?(Array) && v.length == 1
+                $logger.debug("autounboxing for #{p[:name]}")
+                v = v.first
+              end
+            end
+            result[k] = v
+          end
+        else
+          # if there's a default param, it can be passed as "scalar" param
+          # (as opposed to the usual hash) to execute, but will be converted
+          # into a "normal" named param
+          dp = default_param
+          if dp
+            result = {dp[:name] => ruby_args}
+          end
+        end
+      end
+
+      if extra.keys.size > 0
+        result.merge! extra
+      end
+
+      # add in defaults (for all params that have not been specified)
+      params.each do |p|
+        unless result.has_key? p[:name]
+          if p[:default]
+            result[p[:name]] = p[:default]
+          end
+        end
+      end
+
+      result
+    end
+
+    def execute(param_values, extra = {})
+      prepared = prepare_params(param_values, extra)
+
+      block_param_names = self.block.parameters.map { |x| x.last }
+
+      #puts "executing #{self.name} : prepared : #{prepared.inspect}"
+
+      payload = []
+      context = {} # TODO should this be initialized?
+
+      block_param_names.each do |name|
+        param = nil
+
+        case name.to_s
+        when 'params'
+          param = prepared
+        when 'plugin'
+          param = self.plugin
+        when 'context'
+          param = context
+        when 'shell'
+          raise "shell not supported" unless extra.has_key? 'shell'
+          param = extra['shell']
+        else
+          if prepared.has_key? name.to_s
+            param = prepared[name.to_s]
+          elsif prepared.has_key? name
+            param = prepared[name]
+          else
+            raise "unknown block param name : >>#{name}<<"
+          end
+        end
+
+        # from the black magick department: block parameters with the
+        # same name as an entity get auto-inflated
+        if param
+          entity_names = @plugin.op.core.state[:entities].map { |entity| entity[:name] }
+          if entity_names.include? name.to_s
+            resolved = @plugin.op.send(name, param)
+            param = resolved
+          end
+          payload << param
+        end
+      end
+
+      result = self.block.call(*payload)
+      [result, context]
+    end
+
+  end
+
+end

data/lib/vop/command_loader.rb

@@ -0,0 +1,47 @@
+require 'vop/command'
+
+module Vop
+
+  class CommandLoader
+
+    def initialize(plugin)
+      @plugin = plugin
+      @op = plugin.op
+
+      @commands = {}
+
+      # we need to load both the general helpers of the plugin because they are
+      # used inside commands as well as the helpers specific to the command_loader
+      @plugin.inject_helpers(self)
+      @plugin.inject_helpers(self, 'command_loader')
+    end
+
+    def new_command(name)
+      @command = Command.new(@plugin, name)
+      @commands[@command.name] = @command
+      @command
+    end
+
+    def run(&block)
+      @command.block = block
+    end
+
+    def read_sources(named_commands)
+      # reads a hash of <command_name> => <source string>
+      named_commands.each do |name, source|
+
+        new_command(name)
+
+        begin
+          self.instance_eval(source[:code], source[:file_name])
+        rescue => detail
+          raise "problem loading plugin #{name} : #{detail.message}\n#{detail.backtrace.join("\n")}"
+        end
+      end
+
+      @commands
+    end
+
+  end
+
+end

data/lib/vop/entity.rb

@@ -0,0 +1,61 @@
+module Vop
+
+  # An entity is something that is identifiable through a key, e.g. a name.
+  # Also, it groups commands that accept the same parameter: When a command
+  # is called on an entity, the parameter with the same name is filled, so
+  #   @op.machine("localhost").processes()
+  # is equivalent to
+  #   @op.processes(machine: "localhost")
+  class Entity
+
+    def initialize(op, name, key, hash)
+      @op = op
+      @name = name
+      @key = key
+      @data = {}
+      hash.each do |k,v|
+        @data[k.to_s] = v
+      end
+
+      make_methods_for_hash_keys
+      make_methods_for_commands
+    end
+
+    def inspect
+      "Vop::Entity #{@name} (#{@command_count} commands)"
+    end
+
+    def make_methods_for_hash_keys
+      @data.keys.each do |key|
+        #next if ['name', 'key'].include? key.to_s
+        next if ['key'].include? key.to_s
+        self.class.send(:define_method, key) do |*args|
+          ruby_args = args.length > 0 ? args[0] : {}
+          @data[key]
+        end
+      end
+    end
+
+    def entity_commands
+      result = @op.commands.values.select do |command|
+        command.params.select do |param|
+          param[:name] == @name
+        end.count > 0
+      end
+      @command_count = result.count
+      result
+    end
+
+    def make_methods_for_commands
+      entity_commands.each do |command|
+        value = @data[@key]
+        self.class.send(:define_method, command.short_name) do |*args|
+          ruby_args = args.length > 0 ? args[0] : {}
+          @op.execute(command.short_name, ruby_args, { @name => value })
+        end
+      end
+    end
+
+  end
+
+end

data/lib/vop/loader.rb

@@ -0,0 +1,35 @@
+class Loader
+
+  attr_reader :loaded
+
+  def initialize(op, plugin)
+    @op = op
+    @plugin = plugin
+    @loaded = []
+
+    # TODO plugin.load_helper_classes(self) unless plugin == nil
+  end
+
+  def from_scratch(name)
+    fresh = { "name" => name }
+    @loaded << fresh
+  end
+
+  def self.read(op, plugin, name, source, file_name = nil)
+    loader = new(op, plugin)
+
+    loader.from_scratch(name)
+    begin
+      if file_name
+        loader.instance_eval source, file_name
+      else
+        loader.instance_eval source
+      end
+    rescue => detail
+      raise "could not read '#{name}' : #{detail.message}\n#{detail.backtrace[0..9].join("\n")}"
+    end
+
+    loader
+  end
+
+end

data/lib/vop/plugin.rb

@@ -0,0 +1,141 @@
+require 'vop/command_loader'
+
+module Vop
+
+  class Plugin
+
+    attr_reader :op
+    attr_reader :name
+    attr_reader :path
+
+    attr_reader :commands
+    attr_reader :config
+    attr_reader :dependencies
+
+    attr_reader :state
+
+    def initialize(op, plugin_name, plugin_path)
+      @op = op
+      @name = plugin_name
+      @path = plugin_path
+      @config = {}
+      @dependencies = []
+
+      # all plugins depend on 'core' (unless they are core or some murky dummy)
+      independents = %w|core __root__|
+      @dependencies << 'core' unless independents.include? plugin_name
+
+      @state = {}
+      @hooks = {}
+
+      @sources = Hash.new { |h, k| h[k] = {} }
+    end
+
+    def inspect
+      "Vop::Plugin #{@name}"
+    end
+
+    def hook(name, &block)
+      @hooks[name.to_sym] = block
+    end
+
+    def call_hook(name, *args)
+      if @hooks.has_key? name
+        $logger.debug "plugin #{self.name} calling hook #{name}"
+        @hooks[name].call(self, *args)
+      end
+    end
+
+    def init
+      $logger.debug "plugin init #{@name}"
+      call_hook :preload
+      load_helpers
+      load_config
+      # TODO we might want to activate/register only plugins with enough config
+      call_hook :init
+      load_commands
+      call_hook :activate
+    end
+
+    def plugin_dir(name)
+      @path + '/' + name.to_s
+    end
+
+    def load_code_from_dir(type_name)
+      dir = plugin_dir type_name
+      if File.exists?(dir)
+        Dir.glob(File.join(dir, '*.rb')).each do |file_name|
+          name_from_file = /#{dir}\/(.+).rb$/.match(file_name).captures.first
+          full_name = @name + '.' + name_from_file
+          $logger.debug("  #{type_name} << #{full_name}")
+
+          code = File.read(file_name)
+          @sources[type_name][full_name] = {
+            :file_name => file_name,
+            :code => code
+          }
+        end
+      else
+        #$logger.debug "no #{type_name} dir found - checked for #{dir}"
+      end
+    end
+
+    def load_helpers
+      load_code_from_dir 'helpers'
+      load_code_from_dir 'helpers/command_loader'
+      load_code_from_dir 'helpers/plugin_loader'
+    end
+
+    def helper_sources(type_name = 'helpers')
+      @sources[type_name].map do |name, source|
+        source[:code]
+      end
+    end
+
+    def command_source(command_name)
+      @sources[:commands][command_name]
+    end
+
+    def inject_helpers(target, sub_type_name = nil)
+      type_name = 'helpers'
+      if sub_type_name
+        type_name += '/' + sub_type_name
+      end
+
+      plugins_to_load_helpers_from = [ self ]
+
+      self.dependencies.each do |name|
+        other = @op.plugins[name]
+        raise "can not resolve plugin dependency #{name}" unless other
+        plugins_to_load_helpers_from << other
+      end
+
+      plugins_to_load_helpers_from.each do |other_plugin|
+        next if other_plugin.helper_sources(type_name).size == 0
+        #$logger.debug "loading helper from #{other_plugin.name} into #{target} : #{other_plugin.helper_sources.size}"
+
+        helper_module = Module.new()
+        other_plugin.helper_sources(type_name).each do |source|
+          helper_module.class_eval source
+        end
+        target.extend helper_module
+      end
+    end
+
+    def load_commands
+      load_code_from_dir :commands
+
+      loader = CommandLoader.new(self)
+      @commands = loader.read_sources @sources[:commands]
+      @commands.each do |name, command|
+        # TODO might want to warn/debug about overrides here
+        @op.eat(command)
+      end
+    end
+
+    def load_config
+    end
+
+  end
+
+end