vop 0.3.1 → 0.3.4

data/lib/core/structure/commands/disable_contributor.rb

@@ -0,0 +1,16 @@
+param! "command_name", "command for which a contributor should be disabled"
+param! "contributor", "name of the contributor to disable"
+
+run do |plugin, command_name, contributor|
+  registry = plugin.state[:contributions] || {}
+  unless registry.has_key? command_name
+    raise "no contributors found for command #{command_name}"
+  end
+
+  contributors = registry[command_name]
+  unless contributors.include? contributor
+    raise "no contributor found with name #{contributor} for command #{command_name}"
+  end
+
+  contributors.delete(contributor)
+end

data/lib/core/structure/commands/generate_entity_commands.rb

@@ -0,0 +1,52 @@
+description "each entity gets a command called <entities> automagically"
+
+run do
+  result = []
+
+  @op.entities.each do |entity_name, definition|
+    list_command_name = definition.name.carefully_pluralize
+    $logger.debug "generating entity list command #{list_command_name} (#{definition.plugin.name})"
+
+    plugin = definition.plugin
+
+    list_command = Command.new(plugin, list_command_name)
+    # TODO list_command.read_only = true
+
+    if definition.on
+      list_command.add_param(definition.on.to_s, mandatory: true)
+    end
+
+    list_command.block = lambda do |params, request, context, plugin|
+      ex = Executor.new(@op)
+      block_param_names = definition.block.parameters.map { |x| x.last }
+      payload = ex.prepare_payload(request, context, block_param_names)
+
+      hash_array = definition.block.call(*payload)
+      if hash_array.nil?
+        $logger.warn "list block of entity '#{definition.name}' returned nil (?!)"
+      else
+        unless hash_array.is_a? Array
+          raise "unexpected data type : found #{hash_array.class}, expected Array"
+        end
+        entity_array = []
+        unless hash_array.empty?
+          first = hash_array.first
+          unless first.is_a? Hash
+            raise "entity '#{definition.name}' returned unexpected data type : found #{first.class}, expected Hash"
+          end
+          entity_array = hash_array.map do |row|
+            Entity.new(@op, definition.short_name, definition.key, row)
+          end
+        end
+
+        # wrap the resulting array of entities to add syntactic sugar
+        ::Vop::Entities.new(entity_array)
+      end
+    end
+    result << list_command
+  end
+
+  @op << result
+
+  result
+end

data/lib/core/structure/commands/generate_invalidation_commands.rb

@@ -0,0 +1,26 @@
+description "all read-only commands get <command>! commands that invalidate automagically"
+
+run do
+  count = 0
+  @op.commands.values.each do |command|
+    if command.read_only
+      invalidation_command_name = "#{command.short_name}!"
+      $logger.debug "generating invalidation command #{invalidation_command_name}"
+
+      invalidation_command = Command.new(command.plugin, invalidation_command_name)
+      invalidation_command.params = command.params
+
+      invalidation_command.block = lambda do |params|
+        @op.invalidate_cache(
+          "command" => command.short_name,
+          "raw_params" => params
+        )
+        @op.execute(command.short_name, params)
+      end
+
+      @op << invalidation_command
+      count += 1
+    end
+  end
+  count
+end

data/lib/core/structure/commands/list_commands.rb

@@ -0,0 +1,11 @@
+param "plugin_filter", description: "name of a plugin by which commands should be filtered"
+
+run do |plugin_filter|
+  result = @op.commands.values
+
+  unless plugin_filter.nil?
+    result.delete_if { |command| command.plugin.name != plugin_filter }
+  end
+
+  result.map { |command| command.name }.sort
+end

data/lib/core/structure/commands/list_contributors.rb

@@ -0,0 +1,10 @@
+param "command_name", description: "command for which contributors should be displayed"
+
+run do |plugin, command_name|
+  registry = plugin.state[:contributions] || {}
+  if command_name
+    registry[command_name]
+  else
+    registry
+  end
+end

data/lib/core/structure/commands/list_entities.rb

@@ -0,0 +1,3 @@
+run do |plugin|
+  @op.entities.keys
+end

data/lib/core/structure/commands/list_plugins.rb

@@ -0,0 +1,3 @@
+run do |plugin|
+  @op.plugins.map { |x| x.name }.sort
+end

data/lib/core/structure/commands/register_contributor.rb

@@ -0,0 +1,14 @@
+param! "command_name", description: "the target of the contribution"
+param! "contributor", description: "the command that contributes"
+
+run do |command_name, contributor, plugin|
+  # TODO verify that +command+ exists - cannot do it here because of
+  # 'machines.rails_machines' tries to contribute to unknown command 'machine'
+  # unless @op.commands.keys.include? command
+  #   raise "'#{contributor}' tries to contribute to unknown command '#{command}'"
+  # end
+
+  # TODO initialize in init_hook (not here and in list_contributors)
+  registry = plugin.state[:contributions] ||= Hash.new { |h,k| h[k] = [] }
+  registry[command_name] << contributor
+end

data/lib/core/structure/structure.plugin

@@ -0,0 +1,4 @@
+hook :loading_finished do
+  @op.generate_entity_commands
+  @op.generate_invalidation_commands
+end

data/lib/vop/objects/chain.rb

@@ -0,0 +1,25 @@
+module Vop
+
+  class Chain
+
+    attr_reader :links
+
+    def initialize(op, links)
+      @op = op
+      @links = links
+    end
+
+    def next
+      @links.shift
+    end
+
+    def execute(request)
+      next_link = self.next
+      response = nil
+      response = next_link.execute(request) if next_link
+      response
+    end
+
+  end
+
+end

data/lib/vop/objects/command.rb

@@ -0,0 +1,86 @@
+require_relative "command_param"
+
+module Vop
+
+  class Command
+
+    attr_accessor :plugin
+    attr_accessor :name
+
+    attr_accessor :block
+    attr_accessor :params
+    attr_accessor :description
+
+    attr_accessor :show_options
+    attr_accessor :dont_register
+    attr_accessor :read_only
+    attr_accessor :allows_extra
+
+    def initialize(plugin, name)
+      @plugin = plugin
+      @name = name
+      @description = nil
+
+      @block = lambda { |params| $logger.warn "#{name} not yet implemented!" }
+
+      @params = []
+      @show_options = {}
+
+      @dont_register = false
+      @read_only = false
+      @allows_extra = false
+    end
+
+    def short_name
+      @name.split(".").last
+    end
+
+    def source
+      plugin.sources[:commands][name]
+    end
+
+    def param(name)
+      @params.select { |x| x.name == name }.first
+    end
+
+    def add_param(name, options = {})
+      @params << CommandParam.new(name, options)
+    end
+
+    def params_with(&filter)
+      params.select do |param|
+        filter.call(param)
+      end
+    end
+
+    def mandatory_params
+      params_with { |x| x.options[:mandatory] == true }
+    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
+      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
+            result = mandatory.first
+          end
+        end
+        result
+      end
+    end
+
+    def execute(payload)
+      self.block.call(*payload)
+    end
+
+  end
+
+end

data/lib/vop/objects/command_param.rb

@@ -0,0 +1,39 @@
+module Vop
+
+  class CommandParam
+
+    attr_reader :name, :options
+
+    def initialize(name, options = {})
+      @name = name
+
+      unless options.is_a? Hash
+        raise "[CommandParam] sanity check failed: unexpected options object class #{options.class}, expected Hash"
+      end
+
+      # auto-detect boolean parameters
+      if options.has_key? :default
+        if options[:default] == true || options[:default] == false
+          options[:boolean] = true
+        end
+      end
+
+      defaults = {
+        multi: false,
+        mandatory: false,
+        default_param: false
+      }
+      @options = defaults.merge(options)
+    end
+
+    # some params do not want to prefilled from the context
+    def wants_context
+      !(
+        options.has_key?(:use_context) &&
+        options[:use_context] == false
+       )
+    end
+
+  end
+
+end

data/lib/vop/objects/entities.rb

@@ -0,0 +1,21 @@
+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
+        else
+          raise "no element with key '#{key}'"
+        end
+      # end
+    end
+
+  end
+
+end

data/lib/vop/objects/entity.rb

@@ -0,0 +1,75 @@
+module Vop
+
+  class Entity
+
+    attr_reader :type, :data, :key
+
+    def initialize(op, type, key, data)
+      @op = op
+      @type = type
+      @key = key
+      @data = data
+
+      unless @data.has_key? @key
+        raise "key #{key} not found in data : #{data.keys.sort}"
+      end
+
+      make_methods_for_commands
+      make_method_for_id
+    end
+
+    def id
+      @data[@key]
+    end
+
+    def [](key)
+      @data[key]
+    end
+
+    def plugin
+      if @data.has_key? "plugin_name"
+        @op.plugin(@data["plugin_name"])
+      end
+    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
+    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?})"
+          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 })
+        end
+      end
+    end
+
+    def make_method_for_id
+      self.class.send(:define_method, @key) do |*args|
+        id
+      end
+    end
+
+    def to_s
+      "Vop::Entity (#{@type})"
+    end
+
+  end
+
+end

data/lib/vop/objects/entity_definition.rb

@@ -0,0 +1,33 @@
+module Vop
+
+  class EntityDefinition
+
+    attr_reader :plugin, :name
+    attr_accessor :key
+    attr_accessor :block
+    attr_accessor :on
+    attr_accessor :show_options
+
+    def initialize(plugin, name)
+      @plugin = plugin
+      @name = name
+      @key = "name"
+      @data = {}
+
+      @block = lambda { |params| $logger.warn "entity #{name} does not have a run block" }
+
+      @on = nil
+      @show_options = {}
+    end
+
+    def short_name
+      @name.split(".").last
+    end
+
+    def source
+      plugin.sources[:entities][name]
+    end
+
+  end
+
+end

data/lib/vop/objects/filter.rb

@@ -0,0 +1,48 @@
+module Vop
+
+  class Filter
+
+    attr_reader :name, :plugin
+
+    attr_accessor :description
+    attr_accessor :block
+
+    def initialize(plugin, name)
+      @plugin = plugin
+      @name = name
+    end
+
+    def short_name
+      @name.split(".").last
+    end
+
+    def execute(request)
+      # this executor is just to prepare payload
+      ex = Executor.new(@plugin.op)
+      context = {}
+      block_param_names = self.block.parameters.map { |x| x.last }
+      payload = ex.prepare_payload(request, context, block_param_names)
+
+      response = nil
+      begin
+        response = self.block.call(*payload)
+      rescue InterruptChain => ic
+        response = ic.response
+      end
+
+      response
+    end
+
+  end  
+
+  class InterruptChain < Exception
+
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+    end
+
+  end
+
+end

data/lib/vop/objects/plugin.rb

@@ -0,0 +1,208 @@
+require "json"
+require_relative "../parts/entity_loader"
+require_relative "../parts/command_loader"
+require_relative "../parts/filter_loader"
+require_relative "thing_with_params"
+
+module Vop
+
+  class Plugin < ThingWithParams
+
+    attr_reader :op
+    attr_reader :name
+    attr_accessor :description
+    attr_reader :options
+    attr_reader :commands
+
+    attr_reader :sources
+    attr_reader :state
+    attr_reader :config
+    attr_accessor :dependencies
+
+    def initialize(op, plugin_name, plugin_path, options = {})
+      super()
+
+      @op = op
+      @name = plugin_name
+      @path = plugin_path
+
+      defaults = {
+        auto_load: true
+      }
+      @options = defaults.merge(options)
+
+      @description = nil
+
+      @state = {}
+
+      @config_file_name = File.join(op.plugin_config_path, plugin_name + ".json")
+      @config = {}
+
+      @dependencies = []
+
+      @hooks = {}
+    end
+
+    def to_s
+      "Vop::Plugin #{name}"
+    end
+
+    def init
+      $logger.debug "plugin init : #{@name}"
+
+      @sources = Hash.new { |h, k| h[k] = {} }
+
+      @config = {}
+
+      # call_hook :preload ?
+      load_helpers
+      load_default_config
+      load_config
+
+      # TODO proceed only if auto_load
+      call_hook :init
+      load_entities
+      load_commands
+      load_filters
+
+      #@op.call_global_hook :plugin_loaded, self
+    end
+
+    def plugin_dir(name)
+      File.join(@path, name.to_s)
+    end
+
+    def load_default_config
+      params.each do |param|
+        if param.options.has_key?(:default)
+          @config[param.name] = param.options[:default]
+        end
+      end
+    end
+
+    def load_config
+      $logger.debug "looking for config at #{@config_file_name}"
+      if File.exists? @config_file_name
+        raw = nil
+        begin
+          raw = IO.read(@config_file_name)
+          config_from_file = JSON.parse(raw)
+          @config.merge! config_from_file
+          $logger.debug "plugin config loaded from #{@config_file_name}"
+        rescue => e
+          $logger.error "could not read JSON config from #{@config_file_name} (#{e.message}), ignoring:\n#{raw}"
+        end
+      end
+    end
+
+    def write_config
+      $logger.info "writing config into #{@op.plugin_config_path}"
+      unless Dir.exists?(@op.plugin_config_path)
+        FileUtils.mkdir_p @op.plugin_config_path
+      end
+      File.open(@config_file_name, "w") do |file|
+        file.write @config.to_json()
+      end
+    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].join(".")
+          $logger.debug("  #{type_name} << #{full_name}")
+
+          @sources[type_name][full_name] = {
+            :file_name => file_name,
+            :code => File.read(file_name)
+          }
+        end
+      end
+    end
+
+    def load_entities
+      loader = EntityLoader.new(self)
+
+      load_code_from_dir :entities
+      @entities = loader.read_sources @sources[:entities]
+      @op << @entities unless @entities.empty?
+    end
+
+    def load_commands
+      loader = CommandLoader.new(self)
+
+      load_code_from_dir :commands
+      @commands = loader.read_sources @sources[:commands]
+      @op << @commands unless @commands.empty?
+    end
+
+    def load_filters
+      loader = FilterLoader.new(self)
+
+      load_code_from_dir :filters
+      @filters = loader.read_sources @sources[:filters]
+      @op << @filters unless @filters.empty?
+    end
+
+    def load_helpers
+      #load_code_from_dir :helpers
+      load_code_from_dir("helpers") # TODO unify (symbol vs. string) with load_commands above
+    end
+
+    def inject_helpers(target, sub_type_name = nil)
+      type_name = 'helpers'
+
+      plugins_to_load_helpers_from = [ self ]
+
+      self.dependencies.each do |name|
+        other = @op.plugin(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|
+        helper_sources = other_plugin.sources[type_name]
+
+        next if helper_sources.size == 0
+
+        helper_module = Module.new()
+
+        helper_sources.each do |name, helper|
+          begin
+            helper_module.class_eval helper[:code]
+          rescue Exception => e
+            $stderr.puts("could not read helper #{name} : #{e.message}")
+            raise e
+          end
+        end
+
+        target.extend helper_module
+      end
+    end
+
+    def hook(name, &block)
+      @hooks[name.to_sym] = block
+    end
+
+    def call_hook(name, *args)
+      result = nil
+      if @hooks.has_key? name
+        result = @hooks[name].call(self, *args)
+      end
+      result
+    end
+
+    def template_path(name)
+      name += ".erb" unless name.end_with? ".erb"
+      File.join(plugin_dir(:templates), name)
+    end
+
+    def template(name)
+      @op.read_template(template_path(name))
+    end
+
+  end
+
+end