vop 0.3.5 → 0.3.6

data/lib/vop/objects/chain.rb

@@ -15,9 +15,12 @@ module Vop
 
     def execute(request)
       next_link = self.next
-      response = nil
-      response = next_link.execute(request) if next_link
-      response
+
+      if next_link
+        next_link.execute(request)
+      else
+        nil
+      end
     end
 
   end

data/lib/vop/objects/command.rb

@@ -13,7 +13,7 @@ module Vop
     attr_accessor :invalidation_block
 
     attr_accessor :show_options
-    attr_accessor :dont_register
+    attr_accessor :dont_register, :dont_log
     attr_accessor :read_only
     attr_accessor :allows_extra
 
@@ -29,6 +29,8 @@ module Vop
       @show_options = {}
 
       @dont_register = false
+      @dont_log = false
+
       @read_only = false
       @allows_extra = false
     end
@@ -55,23 +57,30 @@ module Vop
       end
     end
 
-    def mandatory_params
+    def mandatory_params(values = {})
       params_with { |x| x.options[:mandatory] == true }
     end
 
+    def missing_mandatory_params(values = {})
+      mandatory_params.select do |param|
+        ! values.keys.include?(param.name.to_sym) &&
+        ! values.keys.include?(param.name.to_s)
+      end
+    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 is only a single param, it is the default param by default
     # Also, if there is only one mandatory param, it is considered to be the default param
-    def default_param
+    def default_param(values = {})
       if params.size == 1
         params.first
       else
         result = params_with { |x| x.options[:default_param] == true }.first
         if result.nil?
-          mandatory = mandatory_params
-          if mandatory_params.size == 1
+          mandatory = missing_mandatory_params(values)
+          if mandatory.size == 1
             result = mandatory.first
           end
         end

data/lib/vop/objects/command_param.rb

@@ -26,6 +26,21 @@ module Vop
       @options = defaults.merge(options)
     end
 
+    def lookup(current_values = {})
+      begin
+        return [] unless lookup_block = options[:lookup]
+
+        # the lookup block might want the previously collected params as input
+        lookups = if lookup_block.arity > 0
+          lookup_block.call(current_values)
+        else
+          lookup_block.call()
+        end
+      rescue => detail
+        $logger.error "problem loading lookup values for #{name} : #{detail.message}"
+      end
+    end
+
     # some params do not want to prefilled from the context
     def wants_context
       !(
@@ -34,6 +49,13 @@ module Vop
        )
     end
 
+    def to_json(options)
+      {
+        name: @name,
+        options: @options
+      }.to_json(options)
+    end
+
   end
 
 end

data/lib/vop/objects/entities.rb

@@ -3,17 +3,17 @@ module Vop
   class Entities < Array
 
     def [](key)
-      # if key.is_a? Numeric
-      #   super(key)
-      # else
-        $logger.debug "accessing entity with key '#{key}'"
-        found = select { |x| x.id == key }.first
-        if found
-          found
+      $logger.debug "accessing entity with key '#{key}'"
+      found = select { |x| x.id == key }.first
+      if found
+        found
+      else
+        if key.to_i.to_s == key.to_s
+          super(key.to_i)
         else
           raise "no element with key '#{key}'"
         end
-      # end
+      end
     end
 
   end

data/lib/vop/objects/entity.rb

@@ -4,10 +4,11 @@ module Vop
 
     attr_reader :type, :data, :key
 
-    def initialize(op, type, key, data)
+    def initialize(op, definition, data)
       @op = op
-      @type = type
-      @key = key
+      @type = definition.short_name
+      @key = definition.key
+      @definition = definition
       @data = data
 
       unless @data.has_key? @key
@@ -15,6 +16,7 @@ module Vop
       end
 
       make_methods_for_commands
+      make_methods_for_data
       make_method_for_id
     end
 
@@ -32,40 +34,79 @@ module Vop
       end
     end
 
+    def ancestor_names
+      # TODO : would be nice if this operation was transitive
+      @op.list_contribution_targets(source_command: @definition.name)
+    end
+
     # all commands that have a parameter with the same name as the entity
     # are considered eligible for this entity (TODO that's too broad, isn't it?)
     def entity_commands
-      result = @op.commands.values.select do |command|
-        command.params.select do |param|
-          param.name == @type
-        end.count > 0
-      end
-      @command_count = result.count
-      result
+      namified = ancestor_names.map { |x| x.carefully_singularize }
+      similar_names = [ @type.to_s ] + namified
+      # TODO [performance] this is probably expensive, move into definition time?
+      @op.commands.values.flat_map do |command|
+        similar_names.map do |similar_name|
+          # TODO we might also want to check if param.entity?
+          next unless command.params.any? { |param| param.name == similar_name }
+          [command.short_name, similar_name]
+        end.compact
+      end.to_h
     end
 
     def make_methods_for_commands
-      entity_commands.each do |command|
-        # TODO this is very similar to code in Vop.<<
-        self.class.send(:define_method, command.short_name) do |*args, &block|
-          $logger.debug "[#{@type}:#{id}] #{command.short_name} (#{args.pretty_inspect}, block? #{block_given?})"
+      entity_commands.each do |command_name, similar_name|
+        # TODO this used to be very similar to code in Vop.<<
+        define_singleton_method command_name.to_sym do |*args, &block|
+          $logger.debug "[#{@type}:#{id}] #{command_name} (#{args.pretty_inspect}, block? #{block_given?})"
           ruby_args = args.length > 0 ? args[0] : {}
           # TODO we might want to do this only if there's a block param defined
           # TODO this does not work if *args comes with a scalar default param
           if block
             ruby_args["block"] = block
           end
-          @op.execute(command.short_name, ruby_args, { @type.to_s => id })
+          extra = { similar_name => id }
+          if @definition.on
+            if @data[@definition.on.to_s]
+              extra[@definition.on.to_s] = @data[@definition.on.to_s]
+            else
+              $logger.warn "entity #{id} does not seem to have data with key #{@definition.on}, though that's required through the 'on' keyword"
+            end
+          end
+          @op.execute(command_name, ruby_args, extra)
+        end
+      end
+    end
+
+    def make_methods_for_data
+      @data.each do |k,v|
+        define_singleton_method k.to_sym do |*args|
+          v
         end
       end
     end
 
     def make_method_for_id
-      self.class.send(:define_method, @key) do |*args|
+      define_singleton_method @key.to_sym do |*args|
         id
       end
     end
 
+    def to_json(options = nil)
+      {
+          entity: type,
+          key: key,
+          data: data
+      }.to_json(options)
+    end
+
+    def self.from_json(op, json_data)
+      parsed = JSON.parse(json_data)
+      entity_name = parsed["entity"]
+      definition = op.entities[entity_name]
+      new(op, definition, parsed["data"])
+    end
+
     def to_s
       "Vop::Entity (#{@type})"
     end

data/lib/vop/objects/entity_definition.rb

@@ -3,11 +3,16 @@ module Vop
   class EntityDefinition
 
     attr_reader :plugin, :name
+    attr_accessor :description
+
     attr_accessor :key
     attr_accessor :block
     attr_accessor :on
     attr_accessor :show_options
 
+    attr_accessor :invalidation_block
+    attr_accessor :read_only
+
     def initialize(plugin, name)
       @plugin = plugin
       @name = name
@@ -15,9 +20,11 @@ module Vop
       @data = {}
 
       @block = lambda { |params| $logger.warn "entity #{name} does not have a run block" }
+      @invalidation_block = nil
 
       @on = nil
       @show_options = {}
+      @read_only = true
     end
 
     def short_name
@@ -28,6 +35,21 @@ module Vop
       plugin.sources[:entities][name]
     end
 
+    def list_command_name
+      short_name.carefully_pluralize
+    end
+
+    # this would be necessary if invalidation commands were generated for entities
+    # def params
+    #   result = []
+    #
+    #   if @on
+    #     result << CommandParam.new(@on.to_s, mandatory: true)
+    #   end
+    #
+    #   result
+    # end
+
   end
 
 end

data/lib/vop/objects/plugin.rb

@@ -1,4 +1,5 @@
 require "json"
+
 require_relative "../parts/entity_loader"
 require_relative "../parts/command_loader"
 require_relative "../parts/filter_loader"
@@ -9,6 +10,7 @@ module Vop
   class Plugin < ThingWithParams
 
     attr_reader :op
+
     attr_reader :name
     attr_accessor :description
     attr_reader :options
@@ -17,7 +19,9 @@ module Vop
     attr_reader :sources
     attr_reader :state
     attr_reader :config
+
     attr_accessor :dependencies
+    attr_accessor :external_dependencies
 
     def initialize(op, plugin_name, plugin_path, options = {})
       super()
@@ -39,28 +43,44 @@ module Vop
       @config = {}
 
       @dependencies = []
+      @external_dependencies = Hash.new { |h, k| h[k] = [] }
 
       @hooks = {}
     end
 
+    def auto_load?
+      @options[:auto_load]
+    end
+
     def to_s
       "Vop::Plugin #{name}"
     end
 
-    def init
+    def inspect
+      {
+        name: name,
+        path: @path
+      }.to_json()
+    end
+
+    def load
       $logger.debug "plugin init : #{@name}"
 
       @sources = Hash.new { |h, k| h[k] = {} }
 
       @config = {}
 
-      # call_hook :preload ?
       load_helpers
       load_default_config
       load_config
 
+      load_gem_dependencies unless ENV["VOP_IGNORE_PLUGINS"]
+    end
+
+    def init
       # TODO proceed only if auto_load
       call_hook :init
+
       load_entities
       load_commands
       load_filters
@@ -105,6 +125,18 @@ module Vop
       end
     end
 
+    def load_gem_dependencies
+      gems = @external_dependencies[:gem]
+      return unless gems.any?
+      $logger.debug "loading gem dependencies : #{gems}"
+
+      gems.each do |g|
+        gem, options = g
+        gem_name = options[:require] || gem
+        require gem_name
+      end
+    end
+
     def load_code_from_dir(type_name)
       dir = plugin_dir(type_name)
 
@@ -186,15 +218,25 @@ module Vop
       @hooks[name.to_sym] = block
     end
 
+    def has_hook?(name)
+      ! @hooks[name.to_sym].nil?
+    end
+
     def call_hook(name, *args)
       result = nil
       if @hooks.has_key? name
-        result = @hooks[name].call(self, *args)
+        begin
+          result = @hooks[name].call(self, *args)
+        rescue => e
+          $logger.error "hit a problem while running hook #{name} on #{self.name}"
+          raise e
+        end
       end
       result
     end
 
-    def template_path(name)
+    def template_path(name_or_sym)
+      name = name_or_sym.to_s
       name += ".erb" unless name.end_with? ".erb"
       File.join(plugin_dir(:templates), name)
     end

data/lib/vop/objects/request.rb

@@ -8,8 +8,10 @@ module Vop
 
     attr_reader :command_name, :param_values, :extra
     attr_accessor :shell
+    attr_accessor :origin
+    attr_accessor :dont_log
 
-    def initialize(op, command_name, param_values = {}, extra = {})
+    def initialize(op, command_name, param_values = {}, extra = {}, origin = nil)
       @op = op
       @command_name = command_name
       raise "unknown command '#{command_name}'" if command.nil?
@@ -19,6 +21,10 @@ module Vop
 
       @current_filter = nil
       @filter_chain = @op.filter_chain.clone
+      # TODO not sure if this is really a hash out in the wild
+      @origin = origin || {}
+
+      @dont_log = false
     end
 
     def command
@@ -40,13 +46,14 @@ module Vop
 
     def self.from_json(op, json)
       hash = JSON.parse(json)
-      self.new(op, hash["command"], hash["params"], hash["extra"])
+      self.new(op, hash["command"], hash["params"], hash["extra"], hash["origin"])
     end
 
     def to_json
       {
           command: @command_name,
           params: @param_values,
+          origin: @origin,
           extra: @extra
       }.to_json
     end
@@ -56,9 +63,6 @@ module Vop
     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]

data/lib/vop/parts/dependency_resolver.rb

@@ -18,8 +18,6 @@ module Vop
       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 }
 
@@ -27,11 +25,9 @@ module Vop
     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

data/lib/vop/parts/entity_loader.rb

@@ -13,8 +13,6 @@ module Vop
 
       @plugin.inject_helpers(self)
 
-      #@command = @entity
-      #extend CommandSyntax
       extend EntitySyntax
     end
 
@@ -26,7 +24,6 @@ module Vop
     end
 
     def read_sources(named_sources)
-      # reads a hash of <name> => <source string>
       named_sources.each do |name, source|
 
         prepare(name)

data/lib/vop/parts/executor.rb

@@ -17,7 +17,7 @@ module Vop
         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
+          dp = request.command.default_param(request.extra)
           if dp
             result = {
               dp.name => ruby_args
@@ -118,12 +118,36 @@ module Vop
             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
+              list_command_params = {}
+              if entity.on
+                on_name = prepared[entity.on] || prepared[entity.on.to_s]
+                if on_name.nil?
+                  raise "missing parameter #{entity.on} for stacked entity #{name}"
+                else
+                  list_command_params[entity.on] = on_name
+                end
+              end
+              the_list = @op.execute(list_command_name, list_command_params)
+
+              # param might be :multi, autobox if necessary
+              autobox = ! command_param.options[:multi] && ! param.is_a?(Array)
+              inflatables = autobox ? [ param ] : param
+              inflated = []
+              inflatables.each do |inflatable|
+                i = the_list.select { |x| x[entity.key] == inflatable }.first
+                if i.nil?
+                  $logger.warn "problem auto-inflating entity with key #{inflatable}"
+                else
+                  $logger.debug "auto-inflated #{name.to_s} entity : #{i}"
+                  inflated << i
+                end
+              end
+              if autobox
+                param = inflated.first
+              else
+                param = inflated
+              end
             end
           end
 
@@ -135,13 +159,14 @@ module Vop
     end
 
     def execute(request)
-      blacklist = %w|list_contributors collect_contributions machines rails_machines|
+      # TODO: use command.dont_log instead?
+      blacklist = %w|list_contributors list_contribution_targets 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 = {}
+      context = request.extra
       block_param_names = request.command.block.parameters.map { |x| x.last }
       payload = prepare_payload(request, context, block_param_names)
       result = command.execute(payload)

data/lib/vop/parts/plugin_finder.rb

@@ -19,24 +19,14 @@ module Vop
       reset
 
       $logger.debug "scanning #{paths} for plugins..."
+
       paths = [ paths ] unless paths.is_a? Array
+      paths.each do |path|
+        next unless File.exists? path
 
-      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
+        @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 unless paths.size.zero?
 
       self
     end

data/lib/vop/search_path.rb

@@ -0,0 +1,12 @@
+require_relative "vop"
+
+module Vop
+
+  def self.gem_dependencies
+    @cached_gem_dependencies ||= begin
+      vop = ::Vop::Vop.new(no_init: true)
+      vop.plugins.flat_map { |p| p.external_dependencies[:gem].map(&:first) }.uniq
+    end
+  end
+
+end