rsence 2.0.9.23 → 2.1.0

data/lib/plugins/guiparser.rb

@@ -28,12 +28,10 @@ module RSence
       
       # include ::RSence
       
-      # Use this method to send the client all commands required to construct the GUI Tree using JSONRenderer.
-      # @param [Message] msg The +Message+ instance +msg+ used all over the place.
-      # @param [Hash] params Containing all parameters referred from the YAML file, see: {GUIPlugin__#gui_params GUIPlugin#gui_params}
-      def init( msg, params )
+      def struct( msg, params )
         gui_data = YAML.load( @yaml_src )
         parse_gui( gui_data, params )
+        return gui_data if gui_data.class == Array
         if gui_data.has_key?('dependencies')
           @parent.include_js( msg, gui_data['dependencies'] )
           gui_data.delete('dependencies')
@@ -44,9 +42,36 @@ module RSence
             msg.reply( js_src )
           end
         end
-        gui_name = @parent.name
+        return gui_data
+      end
+      
+      # Use this method to send the client all commands required to construct the GUI Tree using JSONRenderer.
+      # @param [Message] msg The +Message+ instance +msg+ used all over the place.
+      # @param [Hash] params Containing all parameters referred from the YAML file, see: {GUIPlugin__#gui_params GUIPlugin#gui_params}
+      def init( msg, params )
+        gui_data = struct( msg, params )
+        if gui_data.class == Array
+          gui_data = {
+            'type' => 'GUITree',
+            'version' => 0.7,
+            'class' => 'RSence.GUIApp',
+            'options' => {
+              'priority' => 0,
+              'label' => "#{@gui_name.capitalize} (autogenerated)"
+            },
+            'subviews' => gui_data
+          }
+        end
         json_data = JSON.dump( gui_data )
-        msg.reply( "JSONRenderer.nu(#{json_data});", true )
+        msg.reply( "RSence.guiTrees[#{@gui_name.to_json}]=JSONRenderer.nu(#{json_data});", true )
+      end
+      
+      def kill( msg )
+        gui_name = @parent.name
+        gui_ns = "RSence.guiTrees[#{@gui_name.to_json}]"
+        msg.reply( "#{gui_ns}.die();", true )
+        msg.reply( "#{gui_ns}=null;", true )
+        msg.reply( "delete #{gui_ns};", true )
       end
       
       # Use this method to extract all the value id's of the +ses+ hash.
@@ -113,8 +138,13 @@ module RSence
       # = Parameters
       # +parent+::    The Plugin instance called from, use +self+ when constructing in a Plugin method.
       # +yaml_src+::  The YAML source template for the GUI
-      def initialize( parent, yaml_src )
+      def initialize( parent, yaml_src, gui_name=false )
         @parent = parent
+        if gui_name
+          @gui_name = gui_name.to_s
+        else
+          @gui_name = parent.name.to_s
+        end
         @yaml_src = yaml_src
       end
       

data/lib/plugins/plugin.rb

@@ -178,20 +178,31 @@ module RSence
           @inited = true
         end
       end
-  
+      
+      def name_with_manager_s
+        if @info[:manager]
+          return "#{@info[:manager].to_s}:#{@name.to_s}"
+        else
+          return @name.to_s
+        end
+      end
+      
       # This method returns (or creates and returns) the entry in the session based on the name your plugin is registered as. It's advised to use this call instead of manually managing {Message#session msg#session} in most cases.
       #
       # Uses the first name registered for the plugin and converts it to a symbol.
       #
       # @param [Message] msg The message is supplied by the system.
+      # @param [Symbol] key (optional) returns a ses key, if defined.
       #
       # @return [Hash] Plugin-specific session hash
-      def get_ses( msg )
-        name_sym = name.to_sym
+      def get_ses( msg, key=false )
+        name_sym = name_with_manager_s.to_sym
         unless msg.session.has_key?( name_sym )
           msg.session[ name_sym ] = {}
         end
-        return msg.session[ name_sym ]
+        ses = msg.session[ name_sym ]
+        return ses[key] if key
+        return ses
       end
   
       # Returns the source code of the javascript file +js_name+ in the 'js' subdirectory of the plugin bundle. Use it to send raw javascript command code to the client. Use {#read_js_once} for libraries.
@@ -278,13 +289,155 @@ module RSence
         end
       end
       
+      # @private  Returns a hash with valid symbol keys for +#value_call+.
+      def sanitize_value_call_hash( hash_dirty )
+        if hash_dirty.class == Symbol
+          return { :method => hash_dirty }
+        elsif hash_dirty.class == String
+          if hash_dirty.include?('.')
+            last_dot_index = hash_dirty.rindex('.')
+            call_plugin = hash_dirty[0..(last_dot_index-1)].to_sym
+            call_method = hash_dirty[(last_dot_index+1)..-1].to_sym
+            return { :method => call_method, :plugin => call_plugin }
+          else
+            return { :method => hash_dirty.to_sym }
+          end
+        end
+        hash_clean = {}
+        hash_dirty.each do | key, value |
+          if key.to_sym == :method
+            hash_clean[:method] = value.to_sym
+          elsif key.to_sym == :plugin
+            hash_clean[:plugin] = value.to_sym
+          elsif key.to_sym == :args
+            if value.class == Array
+              hash_clean[:args] = value
+            else
+              warn "Invalid arguments (#{value.inspect}). Expected Array."
+            end
+          elsif key.to_sym == :uses_msg
+            value == false if value == nil
+            if value.class == TrueClass or value.class == FalseClass
+              hash_clean[:uses_msg] = value
+            else
+              warn "Invalid argument for :uses_msg (#{value.inspect}), expected boolean."
+            end
+          else
+            warn "Undefined value_call key: #{key.inspect}"
+          end
+        end
+        return hash_clean
+      end
+      
+      # @private  Returns a sanitized copy of a single responder specification.
+      def sanitize_value_responders( responders_dirty )
+        if responders_dirty.class != Array
+          warn "Unsupported responders type: #{responders_dirty.inspect} (expected Array or Hash). Trying work-around.." if responders_dirty.class != Hash and RSence.args[:debug]
+          responders_dirty = [ responders_dirty ]
+        end
+        responders_clean = []
+        responders_dirty.each do |responder_dirty|
+          if responder_dirty.class != Hash
+            if responder_dirty.class == Symbol
+              responder_dirty = { :method => responder_dirty }
+            elsif responder_dirty.class == String
+              if responder_dirty.include?('.')
+                last_dot_index = responder_dirty.rindex('.')
+                responder_plugin = responder_dirty[0..(last_dot_index-1)].to_sym
+                responder_method = responder_dirty[(last_dot_index+1)..-1].to_sym
+                responder_dirty = { :method => responder_method, :plugin => responder_plugin }
+              else
+                responder_dirty = { :method => responder_dirty.to_sym }
+              end
+            else
+              warn "Unsupported responder type: #{responder_dirty.inspect}. Skipping.."
+              next
+            end
+          end
+          responder_clean = {}
+          responder_dirty.each do |key, value|
+            if key.to_sym == :method
+              responder_clean[ :method ] = value.to_sym
+            elsif key.to_sym == :plugin
+              responder_clean[ :plugin ] = value.to_sym
+            else
+              warn "Unsupported responder key: #{key.inspect} => #{value.inspect}. Ignoring.."
+            end
+          end
+          if responder_clean.has_key?( :method )
+            responders_clean.push( responder_clean )
+          else
+            warn "Responder (#{responder_clean.inspect}) is missing a :method specification. Skipping.."
+          end
+        end
+        return responders_clean
+      end
+      
+      # @private  Returns a sanitized copy of a single value item.
+      def sanitize_value_item( value_item_dirty )
+        value_item_clean = {}
+        value_item_dirty.each do | key, value |
+          if key.to_sym == :value or key.to_sym == :data
+            if [Array, Hash, String, TrueClass, FalseClass, Fixnum, Bignum, Float, NilClass].include? value.class
+              value_item_clean[:value] = value
+            else
+              warn "Unsupported value class (#{value.class.inspect}) for value: #{value.inspect}. Using 0 instead."
+              value_item_clean[:value] = 0
+            end
+          elsif key.to_sym == :value_call or key.to_sym == :call
+            value_item_clean[:value_call] = sanitize_value_call_hash( value )
+          elsif key.to_sym == :msg_call
+            value_item_clean[:value_call] = sanitize_value_call_hash( value )
+            value_item_clean[:value_call][:uses_msg] = true unless value_item_clean[:value_call].has_key?(:uses_msg)
+          elsif key.to_sym == :restore_default or key.to_sym == :restore
+            if [TrueClass, FalseClass].include? value.class
+              value_item_clean[:restore_default] = value
+            else
+              warn "Unsupported type of restore (expected true or false): #{value.inspect}. Using true instead."
+              value_item_clean[:restore_default] = true
+            end
+          elsif key.to_sym == :responders or key.to_sym == :responder
+            sanitized_responders = sanitize_value_responders( value )
+            value_item_clean[:responders] = sanitized_responders unless sanitized_responders.empty?
+          else
+            warn "Unsupported value specification key: #{key.inspect}."
+          end
+        end
+        return value_item_clean
+      end
+      
+      # @private  Returns sanitized hash of the structure specified in values.yaml
+      def sanitize_values_yaml( values_path )
+        values_dirty = yaml_read( values_path )
+        return false if values_dirty == false
+        if values_dirty.class == Hash
+          values_clean = {}
+          values_dirty.each do |key, value|
+            values_clean[ key.to_sym ] = sanitize_value_item( value )
+          end
+          return values_clean unless values_clean.empty?
+        elsif values_dirty.class == Array
+          values_clean = []
+          values_dirty.each do |values_dirty_segment|
+            values_clean_segment = {}
+            values_dirty_segment.each do |key, value|
+              values_clean_segment[ key.to_sym ] = sanitize_value_item( value )
+            end
+            values_clean.push( values_clean_segment )
+          end
+          return values_clean unless values_clean.empty?
+        else
+          warn "Unsupported format of values.yaml, got: #{values_dirty.inspect}, expected Hash or Array."
+        end
+        return false
+      end
       
       # @private  This method looks looks for a file called "values.yaml" in the plugin's bundle directory.
       #           If this file is found, it loads it for initial value definitions.
       #           These definitions are accessible as the +@values+ attribute.
       def init_values
         values_path = bundle_path( 'values.yaml' )
-        return yaml_read( values_path )
+        return sanitize_values_yaml( values_path )
       end
       
       # @private  Creates a new instance of HValue, assigns it as +value_name+ into the
@@ -333,27 +486,88 @@ module RSence
         else
           default_value = 0
         end
-        ses[value_name] = HValue.new( msg, default_value, { :name => "#{@name}.#{value_name}" } )
+        name = name_with_manager_s
+        ses[value_name] = HValue.new( msg, default_value, { :name => "#{name}.#{value_name}" } )
         if value_properties.has_key?(:responders)
-          value_properties[:responders].each do |responder|
-            if responder.has_key?(:plugin)
-              responder_plugin = responder[:plugin]
-            else
-              responder_plugin = @name
+          init_responders( msg, ses[value_name], value_properties[:responders] )
+        end
+      end
+      
+      # @private  Initialize a responder for a value.
+      def init_responder( msg, value, responder )
+        name = name_with_manager_s
+        if responder.has_key?(:plugin)
+          responder_plugin = responder[:plugin]
+        else
+          responder_plugin = name
+        end
+        if responder.has_key?(:method)
+          responder_method = responder[:method]
+          if not value.bound?( responder_plugin, responder_method )
+            value.bind( responder_plugin, responder[:method] )
+          end
+        end
+      end
+      
+      # @private  Initialize several responders for a value
+      def init_responders( msg, value, responders )
+        members = value.members
+        release_list = []
+        members.each_key do |pre_plugin|
+          members[pre_plugin].each do |pre_method|
+            found = false
+            responders.each do |responder|
+              name = name_with_manager_s
+              if responder.has_key?(:plugin)
+                responder_plugin = responder[:plugin]
+              else
+                responder_plugin = name
+              end
+              if responder.has_key?(:method)
+                responder_method = responder[:method]
+                if responder_plugin == pre_plugin and responder_method == pre_method
+                  found = true
+                  break
+                end
+              end
             end
-            if responder.has_key?(:method)
-              ses[value_name].bind( responder_plugin, responder[:method] )
+            unless found
+              release_list.push( [ pre_plugin, pre_method ] )
             end
           end
         end
+        release_list.each do | rel_plugin, rel_method |
+          value.release( rel_plugin, rel_method )
+        end
+        responders.each do |responder|
+          init_responder( msg, value, responder )
+        end
+      end
+      
+      # @private  Releases all responders of a value
+      def release_responders( msg, value )
+        members = value.members
+        members.each_key do |responder_plugin|
+          members.each do |responder_method|
+            value.release( responder_plugin, responder_method )
+          end
+        end
       end
       
       # @private  Initializes session values, if the contents of the +values.yaml+ 
       #           file is defined in the bundle directory and loaded in +#init_values+.
       def init_ses_values( msg )
         return unless @values
-        @values.each do | value_name, value_properties |
-          init_ses_value( msg, value_name, value_properties )
+        if @values.class == Array
+          @values.each do | value_item |
+            value_item.each do | value_name, value_properties |
+              init_ses_value( msg, value_name, value_properties )
+            end
+          end
+        elsif @values.class == Hash
+          @values.each do | value_name, value_properties |
+            init_ses_value( msg, value_name, value_properties )
+          end
         end
       end
       
@@ -409,26 +623,44 @@ module RSence
         end
       end
       
+      def restore_ses_value( msg, value_name, value_properties )
+        ses = get_ses( msg )
+        if ses.has_key?( value_name ) and ses[ value_name ].class == HValue
+          if value_properties.has_key?(:responders)
+            init_responders( msg, ses[value_name], value_properties[:responders] )
+          else
+            release_responders( msg, ses[value_name] )
+          end
+          unless value_properties[:restore_default] == false
+            if value_properties.has_key?(:value_call)
+              default_value = init_value_call( msg, value_properties[:value_call] )
+            elsif value_properties.has_key?(:value)
+              default_value = value_properties[:value]
+            else
+              default_value = 0
+            end
+            ses[value_name].set( msg, default_value )
+          end
+        else
+          init_ses_value( msg, value_name, value_properties )
+        end
+      end
+      
       # @private  Restores session values to default, unless specified otherwise.
       #
       # Called from +#restore_ses+
       def restore_ses_values( msg )
         return unless @values
         ses = get_ses( msg )
-        @values.each do | value_name, value_properties |
-          if ses.has_key?( value_name ) and ses[ value_name ].class == HValue
-            unless value_properties[:restore_default] == false
-              if value_properties.has_key?(:value_call)
-                default_value = init_value_call( msg, value_properties[:value_call] )
-              elsif value_properties.has_key?(:value)
-                default_value = value_properties[:value]
-              else
-                default_value = 0
-              end
-              ses[value_name].set( msg, default_value )
+        if @values.class == Array
+          @values.each do | value_item |
+            value_item.each do | value_name, value_properties |
+              restore_ses_value( msg, value_name, value_properties )
             end
-          else
-            init_ses_value( msg, value_name, value_properties )
+          end
+        elsif @values.class == Hash
+          @values.each do | value_name, value_properties |
+            restore_ses_value( msg, value_name, value_properties )
           end
         end
       end

data/lib/plugins/plugin_base.rb

@@ -36,6 +36,11 @@ module RSence
     # * {GUIPlugin__ GUIPlugin} -- The GUIPlugin base class
     module PluginBase
       
+      # When a method is missing, tries a call via pluginmanager. (Eliminates plugins.plugin_name.method_name calls -> plugin_name.method_name)
+      def method_missing( sym, *args, &block )
+        @plugins.method_missing( sym, *args, &block )
+      end
+      
       # @private External accessor for @plugins
       # @return [PluginManager] The PluginManager the instance belongs to.
       attr_reader :plugins
@@ -124,6 +129,15 @@ module RSence
       end
       alias file_save file_write
       
+      # Yaml writer utility.
+      #
+      # Wrapper for #file_write
+      # Converts +data+ to yaml and then calls file_write with the result.
+      def yaml_write( path, data )
+        file_write( path, data.to_yaml )
+      end
+      
+      
       # Path utility
       #
       # Makes a full, absolute path using the plugin bundle as the default path when a relative path is given. Returns just the bundle's local path, if no parameters given.

data/lib/plugins/plugin_plugins.rb

@@ -22,10 +22,19 @@ module RSence
     # Install your sub-plugins into a directory named +plugins+ inside your plugin bundle.
     module PluginPlugins
       
+      # Makes @plugin_plugins accessible
+      attr :plugin_plugins
+      
       # Extended {#init}, delegates calls to the sub-plugins.
       def init
         super
-        @plugin_plugins = RSence::PluginManager.new( [ bundle_path('plugins') ] )
+        @plugin_plugins = RSence::PluginManager.new({
+          :plugin_paths => [ bundle_path('plugins') ],
+          :autoreload => false,
+          :name_prefix => name_with_manager_s.to_sym,
+          :parent_manager => @plugins,
+          :resolved_deps => [:system]
+        })
       end
       
       # Extended {#open}, delegates calls to the sub-plugins.
@@ -38,6 +47,7 @@ module RSence
       def close
         super
         @plugin_plugins.delegate(:close)
+        @plugin_plugins.shutdown
       end
       
       # Extended {#flush}, delegates calls to the sub-plugins.