vop 0.3.1 → 0.3.4

data/lib/vop/objects/request.rb

@@ -0,0 +1,73 @@
+require_relative "response"
+require_relative "chain"
+require_relative "../parts/executor"
+
+module Vop
+
+  class Request
+
+    attr_reader :command_name, :param_values, :extra
+    attr_accessor :shell
+
+    def initialize(op, command_name, param_values = {}, extra = {})
+      @op = op
+      @command_name = command_name
+      raise "unknown command '#{command_name}'" if command.nil?
+      @param_values = param_values
+      @extra = extra
+      @shell = nil
+
+      @current_filter = nil
+      @filter_chain = @op.filter_chain.clone
+    end
+
+    def command
+      @op.commands[@command_name]
+    end
+
+    def cache_key
+      blacklist = %w|shell raw_params|
+
+      ex = Executor.new(@op)
+      prepared = ex.prepare_params(self)
+
+      param_string = prepared.map { |k,v|
+        next if blacklist.include? k
+        [k.to_s,v].join("=")
+      }.sort.compact.join(":")
+      "vop/request:#{command.name}:" + param_string + ":v1"
+    end
+
+    def self.from_json(op, json)
+      hash = JSON.parse(json)
+      self.new(op, hash["command"], hash["params"], hash["extra"])
+    end
+
+    def to_json
+      {
+          command: @command_name,
+          params: @param_values,
+          extra: @extra
+      }.to_json
+    end
+
+    def next_filter
+       @chain.next()
+    end
+
+    def execute
+      result = nil
+      context = nil
+
+      # build a chain out of all filters + the command itself
+      filter_chain = @op.filter_chain.clone.map {
+        |filter_name| @op.filters[filter_name.split(".").first]
+      }
+      filter_chain << Executor.new(@op)
+      @chain = Chain.new(@op, filter_chain)
+      @chain.execute(self)
+    end
+
+  end
+
+end

data/lib/vop/objects/response.rb

@@ -0,0 +1,17 @@
+module Vop
+
+  class Response
+
+    attr_reader :result, :context, :timestamp
+    attr_accessor :status
+
+    def initialize(result, context, timestamp = nil)
+      @result = result
+      @context = context
+      @timestamp = timestamp || Time.now
+      @status = "ok"
+    end
+
+  end
+
+end

data/lib/vop/objects/thing_with_params.rb

@@ -0,0 +1,17 @@
+module Vop
+
+  class ThingWithParams
+
+    attr_reader :params
+
+    def initialize
+      @params = []
+    end
+
+    def param(name)
+      @params.select { |x| x.name == name }.first
+    end
+
+  end
+
+end

data/lib/vop/{command_loader.rb → parts/command_loader.rb}

@@ -1,4 +1,5 @@
-require 'vop/command'
+require_relative "../syntax/command_syntax"
+require_relative "../objects/command"
 
 module Vop
 
@@ -8,24 +9,19 @@ module Vop
       @plugin = plugin
       @op = plugin.op
 
-      @commands = {}
+      @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')
+
+      extend CommandSyntax
     end
 
     def new_command(name)
       @command = Command.new(@plugin, name)
-      @commands[@command.name] = @command
+      @commands << @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|
@@ -34,8 +30,8 @@ module Vop
 
         begin
           self.instance_eval(source[:code], source[:file_name])
-        rescue => detail
-          raise "problem loading plugin #{name} : #{detail.message}\n#{detail.backtrace.join("\n")}"
+        rescue Exception
+          raise Errors::CommandLoadError.new("problem loading command #{name}")
         end
       end
 

data/lib/vop/parts/dependency_resolver.rb

@@ -0,0 +1,56 @@
+module Vop
+
+  class DependencyResolver
+
+    def initialize(op)
+      @op = op
+    end
+
+    def sort(plugins)
+      @plugins = {}
+      plugins.each do |plugin|
+        @plugins[plugin.name] = plugin
+      end
+
+      resolved = []
+      unresolved = []
+
+      root_plugin = Plugin.new(@op, "__root__", nil)
+      root_plugin.dependencies = @plugins.keys
+
+      $logger.debug "root dummy : #{root_plugin}"
+
+      resolve(root_plugin, resolved, unresolved)
+      resolved.delete_if { |x| x == root_plugin.name }
+
+      resolved.map { |x| @plugins[x] }
+    end
+
+    def resolve(plugin, resolved, unresolved, level = 0)
+      $logger.debug "#{' ' * level}checking dependencies for #{plugin.name}"
+      unresolved << plugin.name
+
+      plugin.dependencies.each do |dep|
+        $logger.debug "#{' ' * level}resolving #{dep}"
+        already_loaded = @op.plugins.map(&:name).include? dep
+        unless already_loaded
+          unless resolved.include? dep
+            if unresolved.include? dep
+              raise ::Vop::Errors::RunningInCircles, "circular dependency #{plugin.name} -> #{dep}"
+            else
+              unless @plugins.has_key? dep
+                raise ::Vop::Errors::MissingPlugin, "dependency not met: #{plugin.name} depends on #{dep}"
+              end
+              dependency = @plugins[dep]
+              resolve(dependency, resolved, unresolved, level + 1)
+            end
+          end
+        end
+      end
+
+      resolved << plugin.name
+    end
+
+  end
+
+end

data/lib/vop/parts/entity_loader.rb

@@ -0,0 +1,46 @@
+require_relative "../syntax/entity_syntax"
+require_relative "../objects/entity_definition"
+
+module Vop
+
+  class EntityLoader
+
+    def initialize(plugin)
+      @plugin = plugin
+      @op = plugin.op
+
+      @loaded = []
+
+      @plugin.inject_helpers(self)
+
+      #@command = @entity
+      #extend CommandSyntax
+      extend EntitySyntax
+    end
+
+    def prepare(name)
+      @entity = EntityDefinition.new(@plugin, name)
+      @command = @entity
+      @loaded << @entity
+      @entity
+    end
+
+    def read_sources(named_sources)
+      # reads a hash of <name> => <source string>
+      named_sources.each do |name, source|
+
+        prepare(name)
+
+        begin
+          self.instance_eval(source[:code], source[:file_name])
+        rescue SyntaxError => detail
+          raise Errors::EntityLoadError.new("problem loading entity #{name} : #{detail.message}")
+        end
+      end
+
+      @loaded
+    end
+
+  end
+
+end

data/lib/vop/parts/executor.rb

@@ -0,0 +1,155 @@
+module Vop
+
+  class Executor
+
+    def initialize(vop)
+      @op = vop
+    end
+
+    # accepts arguments as handed in by :define_method and prepares them
+    # into the +params+ structure expected by command blocks
+    def prepare_params(request)
+      (ruby_args, extra) = request.param_values, request.extra
+      result = {}
+      if ruby_args
+        if ruby_args.is_a? Hash
+          result = ruby_args
+        else
+          # if there is a default param, it can be passed to execute as "scalar"
+          # param, but it will be converted into a "normal" named param
+          dp = request.command.default_param
+          if dp
+            result = {
+              dp.name => ruby_args
+            }
+          end
+        end
+      end
+
+      if extra.keys.size > 0
+        extra.each do |k,v|
+          param = request.command.param(k)
+          # TODO actually, this is not always context - it's used from the entities as well
+          if param && param.wants_context
+            result[k] = extra[k]
+          end
+        end
+      end
+
+      # add in defaults (for all params that have not been specified)
+      request.command.params.each do |p|
+        param_name = p.name.to_sym
+        unless result.has_key? param_name
+          if p.options.has_key? :default
+            result[param_name] = p.options[:default]
+          end
+        end
+      end
+
+      result.each do |k,v|
+        param = request.command.param(k.to_s)
+        if param.nil? && ! request.command.allows_extra
+          raise "no such param #{k.to_s} (in #{request.command.name})"
+        end
+        p = param && param.options
+        if p
+          # values are auto-boxed into an array if the param expects multiple values
+          if p[:multi] && ! v.is_a?(Array) then
+            v = [ v ]
+          # array values are auto-unboxed if the param does not want multi
+          elsif ! p[:multi] && v.is_a?(Array) && v.length == 1
+            v = v.first
+          end
+
+          # convert booleans
+          if p[:boolean] && ! v.nil?
+            unless [true, false].include? v
+              #$logger.debug("converting #{param.name} (#{v}) into boolean")
+              v = !! /[tT]rue|[yY]es|[oO]n/.match(v)
+            end
+          end
+        end
+        result[k] = v
+      end
+
+      result
+    end
+
+    def prepare_payload(request, context, block_param_names)
+      payload = []
+
+      prepared = prepare_params(request)
+      param_names = request.command.params.map { |x| x.name }
+
+      block_param_names.each do |name|
+        param = nil
+
+        case name.to_s
+        when "params"
+          param = prepared
+        when "plugin"
+          param = request.command.plugin
+        when "command"
+          param = request.command
+        when "request"
+          param = request
+        when "context"
+          param = context
+        when "shell"
+          raise "shell not supported" if request.shell.nil?
+          param = request.shell
+        else
+          if prepared.has_key? name.to_s
+            param = prepared[name.to_s]
+          elsif prepared.has_key? name
+            param = prepared[name]
+          else
+            unless param_names.include? name.to_s
+              raise "unknown block param name : >>#{name}<<"
+            end
+          end
+        end
+
+        unless param.nil?
+          command_param = request.command.param(name.to_s)
+          if command_param && command_param.options[:entity]
+            # auto-inflate entities
+            entity_list = @op.entities.values
+            entity = entity_list.select { |x| x.short_name == name.to_s }.first
+
+            unless entity.nil?
+              #$logger.debug "auto-inflating entity #{name.to_s} (#{param})"
+
+              list_command_name = entity.short_name.carefully_pluralize
+              the_list = @op.execute(list_command_name, {})
+              #$logger.debug "inflated entity list : #{the_list.size} entities"
+              param = the_list.select { |x| x[entity.key] == param }.first
+            end
+          end
+
+          payload << param
+        end
+      end
+
+      payload
+    end
+
+    def execute(request)
+      blacklist = %w|list_contributors collect_contributions machines rails_machines|
+      unless blacklist.include? request.command.short_name
+        $logger.debug "+++ #{request.command.short_name} (#{request.param_values}) +++"
+      end
+      command = request.command
+
+      context = {}
+      block_param_names = request.command.block.parameters.map { |x| x.last }
+      payload = prepare_payload(request, context, block_param_names)
+      result = command.execute(payload)
+
+      Response.new(result, context)
+    end
+
+  end
+
+
+end

data/lib/vop/parts/filter_loader.rb

@@ -0,0 +1,41 @@
+require_relative "../syntax/filter_syntax"
+require_relative "../objects/filter"
+
+module Vop
+
+  class FilterLoader
+
+    def initialize(plugin)
+      @plugin = plugin
+      @op = @plugin.op
+
+      @filters = []
+
+      @plugin.inject_helpers(self)
+      extend FilterSyntax
+    end
+
+    def new_filter(name)
+      @filter = Filter.new(@plugin, name)
+      @filters << @filter
+      @filter
+    end
+
+    def read_sources(named_sources)
+      # reads a hash of <name> => <source string>
+      named_sources.each do |name, source|
+        new_filter(name)
+
+        begin
+          self.instance_eval(source[:code], source[:file_name])
+        rescue => detail
+          raise Errors::LoadError.new("problem loading filter #{name}", detail)
+        end
+      end
+
+      @filters
+    end
+
+  end
+
+end

data/lib/vop/parts/plugin_finder.rb

@@ -0,0 +1,46 @@
+require "pathname"
+
+module Vop
+
+  class PluginFinder
+
+    attr_reader :plugins, :templates
+
+    def initialize
+      reset
+    end
+
+    def reset
+      @plugins = []
+      @templates = []
+    end
+
+    def find(paths)
+      reset
+
+      $logger.debug "scanning #{paths} for plugins..."
+      paths = [ paths ] unless paths.is_a? Array
+
+      if paths.size > 0
+        paths.each do |path|
+          begin
+            next unless File.exists? path
+          rescue => e
+            if e.message =~ /Fixnum/
+              $logger.warn "unexpected Fixnum path : #{path}"
+            end
+            raise e
+          end
+
+
+          @plugins += Dir.glob("#{path}/**/*.plugin").map { |x| Pathname.new(File.dirname(x)).realpath.to_s }
+          @templates += Dir.glob("#{path}/**/plugin.vop").map { |x| Pathname.new(x).realpath.to_s }
+        end
+      end
+
+      self
+    end
+
+  end
+
+end

data/lib/vop/parts/plugin_loader.rb

@@ -0,0 +1,72 @@
+require_relative "../objects/plugin"
+require_relative "../syntax/plugin_syntax"
+require_relative "../util/errors"
+
+module Vop
+
+  class PluginLoader
+
+    attr_reader :loaded
+
+    def initialize(op)
+      @op = op
+
+      extend PluginSyntax
+    end
+
+    def reset
+      @loaded = []
+    end
+
+    def new_plugin(plugin_name, plugin_path, plugin_options = {})
+      @plugin = Plugin.new(@op, plugin_name, plugin_path, plugin_options)
+      @plugin
+    end
+
+    def read_plugin(code, source_file = nil)
+      begin
+        instance_eval(code, source_file)
+      rescue => detail
+        $logger.warn "problem loading plugin #{@plugin.name} : #{detail.message}\n#{detail.backtrace.join("\n")}"
+        raise Errors::PluginLoadError.new(detail)
+      end
+    end
+
+    def load(found, plugin_options = {})
+      reset
+
+      (plugins, templates) = [found.plugins, found.templates]
+
+      plugins.each do |plugin_path|
+        name = File.basename(plugin_path)
+
+        $logger.debug "loading #{name} from #{plugin_path}"
+        plugin = new_plugin(name, plugin_path, plugin_options)
+
+        templates.each do |template|
+          template_path = File.dirname(template)
+          if plugin_path.start_with? template_path
+            $logger.debug "  (applying template #{template_path})"
+            template_file = File.join(template_path, "plugin.vop")
+            code = File.read(template_file)
+            read_plugin(code, template_file)
+          end
+        end
+
+        plugin_file = File.join(plugin_path, "#{name}.plugin")
+        next unless File.exists?(plugin_file)
+        $logger.debug "reading plugin '#{name}' from '#{plugin_file}'"
+
+        code = File.read(plugin_file)
+        read_plugin(code, plugin_file)
+        @loaded << @plugin
+
+        $logger.debug "loaded plugin #{@plugin.name}"
+      end
+
+      self
+    end
+
+  end
+
+end