rumx 0.0.1

data/lib/rumx/bean.rb

@@ -0,0 +1,484 @@
+module Rumx
+  # Defines a Rumx bean that allows access to the defined attributes and operations.
+  # All public instance methods are prefixed with "bean_" to try to avoid collisions.
+  module Bean
+    module ClassMethods
+
+      def bean_reader(name, type, description, options={})
+        bean_add_attribute(Attribute.new(name, type, description, true, false, options))
+      end
+
+      # options
+      #   max_size - the max size the list can be indexed for setting.  Can be an integer or
+      #     a symbol that represents an attribute or method of the bean.  Defaults to the
+      #     current size of the list.
+      def bean_list_reader(name, type, description, options={})
+        bean_add_list_attribute(Attribute.new(name, type, description, true, false, options))
+      end
+
+      def bean_attr_reader(name, type, description, options={})
+        attr_reader(name)
+        bean_reader(name, type, description, options)
+      end
+
+      def bean_list_attr_reader(name, type, description, options={})
+        attr_reader(name)
+        bean_list_reader(name, type, description, options)
+      end
+
+      def bean_writer(name, type, description, options={})
+        bean_add_attribute(Attribute.new(name, type, description, false, true, options))
+      end
+
+      def bean_list_writer(name, type, description, options={})
+        bean_add_list_attribute(Attribute.new(name, type, description, false, true, options))
+      end
+
+      def bean_attr_writer(name, type, description, options={})
+        attr_writer(name)
+        bean_writer(name, type, description, options)
+      end
+
+      def bean_list_attr_writer(name, type, description, options={})
+        attr_writer(name)
+        bean_list_writer(name, type, description, options)
+      end
+
+      def bean_accessor(name, type, description, options={})
+        bean_add_attribute(Attribute.new(name, type, description, true, true, options))
+      end
+
+      def bean_list_accessor(name, type, description, options={})
+        bean_add_list_attribute(Attribute.new(name, type, description, true, true, options))
+      end
+
+      def bean_attr_accessor(name, type, description, options={})
+        attr_accessor(name)
+        bean_accessor(name, type, description, options)
+      end
+
+      def bean_list_attr_accessor(name, type, description, options={})
+        attr_accessor(name)
+        bean_list_accessor(name, type, description, options)
+      end
+
+      def bean_embed(name, description)
+        # We're going to ignore description (for now)
+        bean_embeds << name.to_sym
+      end
+      
+      def bean_attr_embed(name, description)
+        attr_reader(name)
+        bean_embed(name, description)
+      end
+
+      def bean_embed_list(name, description)
+        # We're going to ignore description (for now)
+        bean_embed_lists << name.to_sym
+      end
+
+      def bean_attr_embed_list(name, description)
+        attr_reader(name)
+        bean_embed_list(name, description)
+      end
+
+      #bean_operation     :my_operation,       :string,  'My operation', [
+      #    [ :arg_int,    :int,    'An int argument'   ],
+      #    [ :arg_float,  :float,  'A float argument'  ],
+      #    [ :arg_string, :string, 'A string argument' ]
+      #]
+      def bean_operation(name, type, description, args)
+        arguments = args.map do |arg|
+          raise 'Invalid bean_operation format' unless arg.kind_of?(Array) && arg.size == 3
+          Argument.new(*arg)
+        end
+        @operations ||= []
+        @operations << Operation.new(name, type, description, arguments)
+      end
+
+      #######
+      # private - TODO: Local helper methods, how should I designate them as private or just nodoc them?
+      #######
+      
+      def bean_add_attribute(attribute)
+        @attributes ||= []
+        @attributes << attribute
+      end
+
+      def bean_add_list_attribute(attribute)
+        @list_attributes ||= []
+        @list_attributes << attribute
+      end
+
+      def bean_attributes
+        attributes = []
+        self.ancestors.reverse_each do |mod|
+          attributes += mod.bean_attributes_local if mod.include?(Rumx::Bean)
+        end
+        return attributes
+      end
+
+      def bean_list_attributes
+        attributes = []
+        self.ancestors.reverse_each do |mod|
+          attributes += mod.bean_list_attributes_local if mod.include?(Rumx::Bean)
+        end
+        return attributes
+      end
+
+      def bean_attributes_local
+        @attributes ||= []
+      end
+
+      def bean_list_attributes_local
+        @list_attributes ||= []
+      end
+
+      def bean_operations
+        operations = []
+        self.ancestors.reverse_each do |mod|
+          operations += mod.bean_operations_local if mod.include?(Rumx::Bean)
+        end
+        return operations
+      end
+
+      def bean_operations_local
+        @operations ||= []
+      end
+
+      def bean_embeds
+        @embeds ||= []
+      end
+
+      def bean_embed_lists
+        @embed_lists ||= []
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def self.root
+      @root ||= Beans::Folder.new
+    end
+
+    def self.find(name_array)
+      bean = root
+      until name_array.empty?
+        name = name_array.shift.to_sym
+        child_bean = bean.bean_children[name]
+        if !child_bean && bean.class.bean_embeds.include?(name)
+          child_bean = bean.send(name)
+        end
+        if !child_bean && bean.class.bean_embed_lists.include?(name)
+          list = bean.send(name)
+          if list
+            index = name_array.shift
+            child_bean = list[index.to_i] if index && index.match(/\d+/)
+          end
+        end
+        return nil unless child_bean
+        bean = child_bean
+      end
+      return bean
+    end
+
+    # Return [bean, attribute, param_name, value] list or nil if not found
+    def self.find_attribute(name_array)
+      name = name_array.pop
+      # If it's a list attribute
+      if name.match(/^\d+$/)
+        index = name.to_i
+        name = name_array.pop
+        bean = Bean.find(name_array)
+        return nil unless bean
+        name = name.to_sym
+        bean.class.bean_list_attributes.each do |attribute|
+          if name == attribute.name
+            obj = bean.send(attribute.name)
+            if obj
+              param_name = "#{attribute.name}[#{index}]"
+              return [bean, attribute, param_name, attribute.get_index_value(obj, index)]
+            end
+          end
+        end
+      # else just a regular attribute
+      else
+        bean = Bean.find(name_array)
+        return nil unless bean
+        name = name.to_sym
+        bean.class.bean_attributes.each do |attribute|
+          if name == attribute.name
+            return [bean, attribute, attribute.name, attribute.get_value(bean)]
+          end
+        end
+      end
+      return nil
+    end
+
+    # Return [bean, operation] pair or nil if not found
+    def self.find_operation(name_array)
+      name = name_array.pop
+      bean = Bean.find(name_array)
+      return nil unless bean
+      name = name.to_sym
+      bean.class.bean_operations.each do |operation|
+        return [bean, operation] if name == operation.name
+      end
+      return nil
+    end
+
+    # Mutex for synchronization of attributes/operations
+    def bean_mutex
+      # TBD: How to initialize this in a module and avoid race condition?
+      @mutex || Mutex.new
+    end
+
+    # Synchronize access to attributes and operations
+    def bean_synchronize
+      bean_mutex.synchronize do
+        yield
+      end
+    end
+
+    def bean_children
+      @bean_children ||= {}
+    end
+
+    def bean_add_child(name, child_bean)
+      # TBD - Should I mutex protect this?  All beans would normally be registered during the code initialization process
+      raise "Error trying to add #{name} to embedded bean" if @bean_is_embedded
+      bean_children[name.to_sym] = child_bean
+    end
+
+    def bean_remove_child(name)
+      bean_children.delete(name.to_sym)
+    end
+
+    def bean_has_attributes?
+      return true unless self.class.bean_attributes.empty? && self.class.bean_list_attributes.empty?
+      self.class.bean_embeds.each do |name|
+        bean = send(name)
+        return true if bean && bean.bean_has_attributes?
+      end
+      self.class.bean_embed_lists.each do |list_name|
+        list = send(list_name)
+        if list 
+          list.each do |bean|
+            return true if bean.bean_has_attributes?
+          end
+        end
+      end
+      return false
+    end
+
+    def bean_get_attributes(rel_path=nil, param_name=nil, &block)
+      bean_synchronize do
+        do_bean_get_attributes(rel_path, param_name, &block)
+      end
+    end
+
+    def bean_set_attributes(params)
+      bean_synchronize do
+        do_bean_set_attributes(params)
+      end
+    end
+
+    def bean_get_and_set_attributes(params, rel_path=nil, param_name=nil, &block)
+      bean_synchronize do
+        val = do_bean_get_attributes(rel_path, param_name, &block)
+        do_bean_set_attributes(params)
+        val
+      end
+    end
+
+    def bean_set_and_get_attributes(params, rel_path=nil, param_name=nil, &block)
+      bean_synchronize do
+        do_bean_set_attributes(params)
+        do_bean_get_attributes(rel_path, param_name, &block)
+      end
+    end
+
+    def bean_has_operations?
+      return true unless self.class.bean_operations.empty?
+      self.class.bean_embeds.each do |name|
+        bean = send(name)
+        return true if bean && bean.bean_has_operations?
+      end
+      self.class.bean_embed_lists.each do |list_name|
+        list = send(list_name)
+        if list 
+          list.each do |bean|
+            return true if bean.bean_has_operations?
+          end
+        end
+      end
+      return false
+    end
+
+    def bean_each_operation(rel_path=nil, &block)
+      self.class.bean_operations.each do |operation|
+        yield operation, bean_join_rel_path(rel_path, operation.name.to_s)
+      end
+      self.class.bean_embeds.each do |name|
+        bean = send(name)
+        bean.bean_each_operation(bean_join_rel_path(rel_path, name), &block) if bean
+      end
+      self.class.bean_embed_lists.each do |name|
+        list = send(name)
+        if list 
+          list_rel_path = bean_join_rel_path(rel_path, name)
+          list.each_with_index do |bean, i|
+            bean.bean_each_operation(bean_join_rel_path(list_rel_path, i.to_s), &block)
+          end
+        end
+      end
+    end
+
+    #########
+    protected
+    #########
+
+    # Allow extenders to save changes, etc. if attribute values change
+    def bean_attributes_changed
+    end
+
+    #######
+    private
+    #######
+
+    # Separate call in case we're already mutex locked
+    def do_bean_get_attributes(rel_path, param_name, &block)
+      return do_bean_get_attributes_json unless block_given?
+      self.class.bean_attributes.each do |attribute|
+        yield attribute, attribute.get_value(self), bean_join_rel_path(rel_path, attribute.name.to_s), bean_join_param_name(param_name, attribute.name.to_s)
+      end
+      self.class.bean_list_attributes.each do |attribute|
+        obj = send(attribute.name)
+        if obj
+          new_rel_path   = bean_join_rel_path(rel_path, attribute.name.to_s)
+          new_param_name = bean_join_param_name(param_name, attribute.name.to_s)
+          obj.each_index do |i|
+            yield attribute, attribute.get_index_value(obj, i), "#{new_rel_path}/#{i}", "#{new_param_name}[#{i}]"
+          end
+        end
+      end
+      self.class.bean_embeds.each do |name|
+        bean = send(name)
+        bean.bean_get_attributes(bean_join_rel_path(rel_path, name), bean_join_param_name(param_name, name), &block) if bean
+      end
+      self.class.bean_embed_lists.each do |name|
+        list = send(name)
+        if list 
+          list_rel_path   = bean_join_rel_path(rel_path, name)
+          list_param_name = bean_join_param_name(param_name, name)
+          list.each_with_index do |bean, i|
+            bean.bean_get_attributes(bean_join_rel_path(list_rel_path, i.to_s), bean_join_param_name(list_param_name, i.to_s), &block)
+          end
+        end
+      end
+    end
+
+    def do_bean_get_attributes_json
+      hash = {}
+      self.class.bean_attributes.each do |attribute|
+        hash[attribute.name] = attribute.get_value(self)
+      end
+      self.class.bean_list_attributes.each do |attribute|
+        hash[attribute.name] = attribute.get_value(self)
+      end
+      self.class.bean_embeds.each do |name|
+        bean = send(name)
+        hash[name] = bean.bean_get_attributes if bean
+      end
+      self.class.bean_embed_lists.each do |name|
+        list = send(name)
+        if list 
+          hash[name] = list.map {|bean| bean.bean_get_attributes}
+        end
+      end
+      return hash
+    end
+
+    # Separate call in case we're already mutex locked
+    def do_bean_set_attributes(params)
+      return if !params || params.empty?
+      changed = false
+      self.class.bean_attributes.each do |attribute|
+        if attribute.allow_write
+          if params.has_key?(attribute.name)
+            attribute.set_value(self, params[attribute.name])
+            changed = true
+          elsif params.has_key?(attribute.name.to_s)
+            attribute.set_value(self, params[attribute.name.to_s])
+            changed = true
+          end
+        end
+      end
+      self.class.bean_list_attributes.each do |attribute|
+        if attribute.allow_write
+          obj = send(attribute.name)
+          sub_params = params[attribute.name] || params[attribute.name.to_s]
+          raise "Can't assign value for nil list attribute" if !obj && sub_params
+          if sub_params
+            # TODO: Allow array?
+            raise "Invalid param for #{attribute.name}" unless sub_params.kind_of?(Hash)
+            max_size = attribute[:max_size]
+            if max_size
+              if max_size.kind_of?(Symbol)
+                max_size = send(max_size)
+              end
+            else
+              # Default to current size of the list if unset
+              max_size = obj.size
+            end
+            sub_params.each do |index, value|
+              if index.to_i < max_size
+                attribute.set_index_value(obj, index.to_i, value)
+                changed = true
+              end
+            end
+          end
+        end
+      end
+      self.class.bean_embeds.each do |name|
+        bean = send(name)
+        if bean
+          embedded_params = params[name]
+          bean.bean_set_attributes(embedded_params)
+          changed = true
+        end
+      end
+      self.class.bean_embed_lists.each do |name|
+        list = send(name)
+        if list 
+          list_params = params[name]
+          if list_params
+            list.each_with_index do |bean, i|
+              bean.bean_set_attributes(list_params[i] || list_params[i.to_s])
+            end
+            changed = true
+          end
+        end
+      end
+      bean_attributes_changed if changed
+    end
+
+    def bean_join_rel_path(parent_rel_path, name)
+      if parent_rel_path
+        "#{parent_rel_path}/#{name}"
+      else
+        name.to_s
+      end
+    end
+
+    def bean_join_param_name(parent_param_name, name)
+      if parent_param_name
+        "#{parent_param_name}[#{name}]"
+      else
+        name.to_s
+      end
+    end
+  end
+end

data/lib/rumx/beans/folder.rb

@@ -0,0 +1,9 @@
+module Rumx
+  module Beans
+    # Bean that contains child beans.  Since all beans have this functionality, this is
+    # essentially just a Bean that has no attributes or operations.
+    class Folder
+      include Bean
+    end
+  end
+end

data/lib/rumx/beans/message.rb

@@ -0,0 +1,16 @@
+module Rumx
+  module Beans
+    class Message
+      include ::Rumx::Bean
+
+      bean_attr_reader :message, :string,  'Message'
+      # TODO: create time and date types
+      bean_attr_reader :time,    :string,  'Time that the message occurred'
+
+      def initialize(message, time=nil)
+        @message = message
+        @time = (time || Time.now).to_s
+      end
+    end
+  end
+end

data/lib/rumx/beans/timer.rb

@@ -0,0 +1,75 @@
+module Rumx
+  module Beans
+    class Timer
+      include Bean
+
+      bean_attr_reader     :total_count, :integer, 'Number of times the measured block has run'
+      bean_attr_reader     :error_count, :integer, 'Number of times the measured block has raised an exception'
+      bean_attr_reader     :total_time,  :float,   'Total time in msec for all the runs of the timed instruction'
+      bean_attr_reader     :max_time,    :float,   'The maximum time for all the runs of the timed instruction'
+      bean_attr_reader     :min_time,    :float,   'The minimum time for all the runs of the timed instruction'
+      bean_attr_reader     :last_time,   :float,   'The time for the last run of the timed instruction'
+      bean_reader          :avg_time,    :float,   'The average time for all runs of the timed instruction'
+      bean_writer          :reset,       :boolean, 'Reset the times and counts to zero (Note that last_time and errors are not reset)'
+      bean_attr_embed_list :errors,                'List of the last occurring errors'
+
+      def initialize(opts={})
+        # Force initialization of Bean#bean_mutex to avoid race condition (See bean.rb)
+        bean_mutex
+        @last_time = 0.0
+        self.reset = true
+        @errors = []
+        @max_errors = (opts[:max_errors] || 1).to_i
+      end
+
+      def reset=(val)
+        if val
+          @total_count = 0
+          @error_count = 0
+          @min_time    = nil
+          @max_time    = 0.0
+          @total_time  = 0.0
+        end
+      end
+
+      def measure(prefix='')
+        start_time = Time.now
+        begin
+          yield
+        ensure
+          current_time = Time.now.to_f - start_time.to_f
+          bean_synchronize do
+            @last_time    = current_time
+            @total_count += 1
+            @total_time  += current_time
+            @min_time     = current_time if !@min_time || current_time < @min_time
+            @max_time     = current_time if current_time > @max_time
+          end
+        end
+        return current_time
+      rescue Exception => e
+        bean_synchronize do
+          @error_count += 1
+          @errors << Message.new(e.message)
+          @errors.shift while @errors.size > @max_errors
+        end
+        raise
+      end
+
+      def min_time
+        @min_time || 0.0
+      end
+
+      def avg_time
+        # Do the best we can w/o mutexing
+        count, time = @total_count, @total_time
+        return 0.0 if count == 0
+        time / count
+      end
+
+      def to_s
+        "total_count=#{@total_count} min=#{('%.1f' % min_time)}ms max=#{('%.1f' % max_time)}ms avg=#{('%.1f' % avg_time)}ms"
+      end
+    end
+  end
+end

data/lib/rumx/beans.rb

@@ -0,0 +1,3 @@
+require 'rumx/beans/folder'
+require 'rumx/beans/message'
+require 'rumx/beans/timer'

data/lib/rumx/operation.rb

@@ -0,0 +1,26 @@
+module Rumx
+  class Operation
+    attr_reader :name, :type, :description, :arguments
+
+    def initialize(name, type_name, description, arguments)
+      @name        = name.to_sym
+      @type        = Type.find(type_name)
+      @description = description
+      @arguments   = arguments
+    end
+
+    def run(bean, argument_hash)
+      args = @arguments.map do |argument|
+        if argument_hash.has_key?(argument.name)
+          value = argument_hash[argument.name]
+        elsif argument_hash.has_key?(argument.name.to_s)
+          value = argument_hash[argument.name.to_s]
+        else
+          raise "No value for argument #{argument.name}"
+        end
+        argument.type.string_to_value(value)
+      end
+      bean.send(self.name, *args)
+    end
+  end
+end