rumx 0.0.8 → 0.1.0

data/lib/rumx/beans.rb

@@ -3,3 +3,5 @@ require 'rumx/beans/message'
 require 'rumx/beans/timer'
 require 'rumx/beans/error'
 require 'rumx/beans/timer_and_error'
+require 'rumx/beans/hash'
+require 'rumx/beans/timer_hash'

data/lib/rumx/beans/error.rb

@@ -4,7 +4,7 @@ module Rumx
       include Bean
 
       bean_attr_reader     :error_count, :integer, 'Number of times the measured block has raised an exception'
-      bean_attr_embed_list :errors,                'List of the last occurring errors'
+      bean_attr_reader     :errors,      :list,    'List of the last occurring errors', :list_type => :bean
 
       def initialize(opts={})
         @errors = []

data/lib/rumx/beans/hash.rb

@@ -0,0 +1,34 @@
+module Rumx
+  module Beans
+    class Hash
+      include Bean
+
+      def initialize(&block)
+        raise 'Must be given initialize instance to create the bean' unless block_given?
+        @block = block
+        # Hacks for potential race conditions
+        bean_children
+        bean_synchronize {}
+      end
+
+      def [](key)
+        child = bean_children[key]
+        return child if child
+        bean_synchronize do
+          # Try it again to prevent race
+          child = bean_children[key]
+          return child if child
+          child = @block.call(key)
+          bean_add_child(key, child)
+        end
+        return child
+      end
+
+      def delete(key)
+        bean_synchronize do
+          bean_remove_child(key)
+        end
+      end
+    end
+  end
+end

data/lib/rumx/beans/timer.rb

@@ -12,8 +12,8 @@ module Rumx
       bean_writer          :reset,       :boolean, 'Reset the times and counts to zero (Note that last_time is not reset)'
 
       def initialize(opts={})
-        # Force initialization of Bean#bean_mutex to avoid race condition (See bean.rb)
-        bean_mutex
+        # Force initialization of Bean#bean_monitor to avoid race condition (See bean.rb)
+        bean_monitor
         @last_time = 0.0
         self.reset = true
       end

data/lib/rumx/beans/timer_and_error.rb

@@ -3,7 +3,7 @@ module Rumx
     class TimerAndError < Timer
 
       bean_attr_reader     :error_count, :integer, 'Number of times the measured block has raised an exception'
-      bean_attr_embed_list :errors,                'List of the last occurring errors'
+      bean_attr_reader     :errors,      :list,    'List of the last occurring errors', :list_type => :bean
 
       def initialize(opts={})
         super

data/lib/rumx/beans/timer_hash.rb

@@ -0,0 +1,9 @@
+module Rumx
+  module Beans
+    class TimerHash < Hash
+      def initialize
+        super { Timer.new }
+      end
+    end
+  end
+end

data/lib/rumx/hash_attribute.rb

@@ -0,0 +1,39 @@
+module Rumx
+  class HashAttribute < Attribute
+
+    def initialize(name, type, description, allow_read, allow_write, options)
+      super
+      raise 'Hash attribute called without hash_type option' unless options[:hash_type]
+      @hash_type = Type.find(options[:hash_type])
+    end
+
+    def each_attribute_info(bean, ancestry, &block)
+      hash = bean.send(name)
+      child_ancestry = ancestry+[name]
+      index_index = child_ancestry.size
+      hash.each do |name, value|
+        value = nil unless allow_read
+        child_ancestry[index_index] = name
+        yield AttributeInfo.new(self, bean, child_ancestry, value)
+      end
+    end
+
+    def write?(bean, params)
+      #puts "hash write params=#{params.inspect}"
+      return false unless params.kind_of?(Hash)
+      is_written = false
+      if allow_write
+        hash = bean.send(name)
+        param_value(params) do |hash_params|
+          if hash && hash_params && hash_params.kind_of?(Hash)
+            hash_params.each do |name, value|
+              hash[name.to_sym] = @hash_type.string_to_value(value)
+              is_written = true
+            end
+          end
+        end
+      end
+      return is_written
+    end
+  end
+end

data/lib/rumx/hash_bean.rb

@@ -0,0 +1,55 @@
+module Rumx
+  class HashBean
+    include Bean
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    # Find the bean
+    def bean_find(name_array, index = 0)
+      return self if index == name_array.size
+      name = name_array[index].to_s
+      child = @hash[name] || @hash[name.to_sym]
+      return nil unless child
+      return child.bean_find(name_array, index+1)
+    end
+
+    def bean_each_embedded_child(&block)
+      @hash.each do |name, child|
+        yield name, child
+      end
+    end
+
+    protected
+
+    def do_bean_get_attributes(ancestry, &block)
+      return do_bean_get_attributes_json unless block_given?
+      child_ancestry = ancestry.dup
+      # Save some object creation
+      child_index = child_ancestry.size
+      @hash.each do |name, bean|
+        child_ancestry[child_index] = name
+        bean.bean_get_attributes(child_ancestry, &block)
+      end
+    end
+
+    def do_bean_get_attributes_json
+      json_hash = {}
+      @hash.each do |name, bean|
+        json_hash[name] = bean.bean_get_attributes
+      end
+      return json_hash
+    end
+
+    def do_bean_set_attributes(params)
+      return if !params || params.empty?
+      changed = false
+      @hash.each do |name, bean|
+        changed = true
+        bean.bean_set_attributes(params[name] || params[name.to_sym])
+      end
+      bean_attributes_changed if changed
+    end
+  end
+end

data/lib/rumx/list_attribute.rb

@@ -0,0 +1,65 @@
+module Rumx
+  class ListAttribute < Attribute
+
+    # options
+    #   list_type - any of the available types (required)
+    #   max_size  - max size of the list, can be a symbol representing a method or an integer (defaults to the current size of the list)
+    def initialize(name, type, description, allow_read, allow_write, options)
+      super
+      raise 'List attribute called without list_type option' unless options[:list_type]
+      @list_type = Type.find(options[:list_type])
+    end
+
+    def each_attribute_info(bean, ancestry, &block)
+      list = bean.send(name)
+      child_ancestry = ancestry+[name]
+      index_index = child_ancestry.size
+      list.each_with_index do |value, i|
+        value = nil unless allow_read
+        child_ancestry[index_index] = i
+        yield AttributeInfo.new(self, bean, child_ancestry, value)
+      end
+    end
+
+    def write?(bean, params)
+      #puts "list write params=#{params.inspect}"
+      is_written = false
+      if allow_write
+        list = bean.send(name)
+        return false unless list
+        max_size = self[:max_size]
+        if max_size
+          if max_size.kind_of?(Symbol)
+            max_size = bean.send(max_size)
+          end
+        else
+          # Default to current size of the list if unset
+          max_size = obj.size
+        end
+        param_value(params) do |sub_params|
+          each_param(sub_params) do |index, value|
+            if index < max_size
+              list[index] = @list_type.string_to_value(value)
+              is_written = true
+            end
+          end
+        end
+      end
+      return is_written
+    end
+
+    private
+
+    def each_param(params, &block)
+      if params.kind_of?(Hash)
+        params.each do |index, value|
+          yield index.to_i, value
+        end
+      elsif params.kind_of?(Array)
+        params.each_with_index do |value, index|
+          yield index, value
+        end
+      end
+    end
+  end
+end

data/lib/rumx/list_bean.rb

@@ -0,0 +1,52 @@
+module Rumx
+  class ListBean
+    include Bean
+
+    def initialize(list)
+      @list = list
+    end
+
+    # Find the bean
+    def bean_find(name_array, index = 0)
+      return self if index == name_array.size
+      name = name_array[index]
+      return nil unless name.match(/^\d+$/)
+      child = @list[name.to_i]
+      return nil unless child
+      return child.bean_find(name_array, index+1)
+    end
+
+    def bean_each_embedded_child(&block)
+      @list.each_with_index do |child, i|
+        yield i, child
+      end
+    end
+
+    protected
+
+    def do_bean_get_attributes(ancestry, &block)
+      return do_bean_get_attributes_json unless block_given?
+      child_ancestry = ancestry.dup
+      # Save some object creation
+      child_index = child_ancestry.size
+      @list.each_with_index do |bean, i|
+        child_ancestry[child_index] = i
+        bean.bean_get_attributes(child_ancestry, &block)
+      end
+    end
+
+    def do_bean_get_attributes_json
+      @list.map { |bean| bean.bean_get_attributes }
+    end
+
+    def do_bean_set_attributes(params)
+      return if !params || params.empty?
+      changed = false
+      @list.each_with_index do |bean, i|
+        changed = true
+        bean.bean_set_attributes(params[i] || params[i.to_s])
+      end
+      bean_attributes_changed if changed
+    end
+  end
+end

data/lib/rumx/server.rb

@@ -2,6 +2,9 @@ require 'sinatra/base'
 require 'json'
 require 'haml'
 require 'uri'
+require 'cgi'
+# See http://groups.google.com/group/sinatrarb/browse_thread/thread/87bf7613631e48aa
+require 'rack/file'
 
 module Rumx
   class Server < Sinatra::Base
@@ -26,7 +29,7 @@ module Rumx
 
       def render_tree_bean_children(parent_path, parent_bean)
         val = ''
-        parent_bean.bean_children.each do |name, bean|
+        parent_bean.bean_each_child do |name, bean|
           #puts "in child name=#{name} bean=#{bean}"
           path = "#{parent_path}/#{name}"
           val << partial(:tree_bean, :locals => {:path => path, :name =>name, :bean => bean})
@@ -77,20 +80,33 @@ module Rumx
         partial :link_to_content, :locals => {:href => attributes_path(path), :name => 'Attributes'}
       end
 
-      def link_to_attribute(parent_path, rel_path)
-        partial :link_to_content, :locals => {:href => attribute_path(parent_path+'/'+rel_path), :name => rel_path}
+      def link_to_attribute(parent_path, attribute_info)
+        path = rel_path(attribute_info.ancestry)
+        partial :link_to_content, :locals => {:href => attribute_path(parent_path+'/'+path), :name => path}
       end
 
       def link_to_operations(path)
         partial :link_to_content, :locals => {:href => operations_path(path), :name => 'Operations'}
       end
 
-      def link_to_operation(parent_path, rel_path)
-        partial :link_to_content, :locals => {:href => operation_path(parent_path+'/'+rel_path), :name => rel_path}
+      def link_to_operation(parent_path, operation)
+        partial :link_to_content, :locals => {:href => operation_path(parent_path+'/'+operation.name.to_s), :name => operation.name}
       end
 
-      def attribute_value_tag(attribute, param_name, value)
-        partial :attribute_value_tag, :locals => {:attribute => attribute, :param_name => param_name, :value => value}
+      def attribute_value_tag(attribute_info)
+        partial :attribute_value_tag, :locals => {:attribute_info => attribute_info}
+      end
+
+      def rel_path(ancestry)
+        ancestry.join('/')
+      end
+
+      def param_name(ancestry)
+        pname = ancestry[0].to_s
+        ancestry[1..-1].each do |name|
+          pname += "[#{name}]"
+        end
+        return pname
       end
     end
 
@@ -99,70 +115,23 @@ module Rumx
     end
 
     get '/*/attributes.?:format?' do
-      path = params[:splat][0]
-      bean = Bean.find(path.split('/'))
-      return 404 unless bean
       # For get we read, then write.  post is the other way around.
-      if params[:format]
-        handle_attributes(bean.bean_get_and_set_attributes(params), params[:format])
-      else
-        haml_for_ajax :content_attributes, :locals => {:get_set_method => :bean_get_and_set_attributes, :params => params, :path => path, :bean => bean}
-      end
+      do_get_or_post_splat_attributes(params, :bean_get_and_set_attributes)
     end
 
     post '/*/attributes.?:format?' do
-      path = params[:splat][0]
-      bean = Bean.find(path.split('/'))
-      return 404 unless bean
       # For post we write, then read.  get is the other way around.
-      if params[:format]
-        handle_attributes(bean.bean_set_and_get_attributes(params), params[:format])
-      else
-        haml_for_ajax :content_attributes, :locals => {:get_set_method => :bean_set_and_get_attributes, :params => params, :path => path, :bean => bean}
-      end
+      do_get_or_post_splat_attributes(params, :bean_set_and_get_attributes)
     end
 
     # Allow a monitor to get the attributes from multiple beans.
     # Use with params such as prefix_0=bean0&bean_0=MyFolder/MyBean&prefix_1=bean1&bean_1=MyOtherFolder/SomeOtherBean
     get '/attributes.?:format?' do
-      hash = {}
-      with_indexed_params(params) do |prefix, bean, new_params|
-        return 404 unless bean
-        hash[prefix.to_sym] = bean.bean_get_and_set_attributes(new_params)
-      end
-      handle_attributes(hash, params[:format])
+      do_get_or_post_attributes(params, :bean_get_and_set_attributes)
     end
 
     post '/attributes.?:format?' do
-      hash = {}
-      with_indexed_params(params) do |prefix, bean, new_params|
-        return 404 unless bean
-        hash[prefix.to_sym] = bean.bean_set_and_get_attributes(new_params)
-      end
-      handle_attributes(hash, params[:format])
-    end
-
-    get '/*/attribute.?:format?' do
-      path = params[:splat][0]
-      bean, attribute, param_name, value = Bean.find_attribute(path.split('/'))
-      return 404 unless bean
-      if params[:format] == 'json'
-      else
-        haml_for_ajax :content_attribute, :locals => {:path => '/' + path, :bean => bean, :attribute => attribute, :param_name => param_name, :value => value}
-      end
-    end
-
-    post '/*/attribute.?:format?' do
-      path = params[:splat][0]
-      bean, attribute, param_name, value = Bean.find_attribute(path.split('/'))
-      return 404 unless bean
-      bean.bean_set_attributes(params)
-      # Do it again to get the updated value
-      bean, attribute, param_name, value = Bean.find_attribute(path.split('/'))
-      if params[:format] == 'json'
-      else
-        haml_for_ajax :content_attribute, :locals => {:path => '/' + path, :bean => bean, :attribute => attribute, :param_name => param_name, :value => value}
-      end
+      do_get_or_post_attributes(params, :bean_set_and_get_attributes)
     end
 
     get '/*/operations' do
@@ -228,21 +197,48 @@ module Rumx
       return str
     end
 
-    def with_indexed_params(params)
-      i = 0
-      while (prefix = params[prefix_key = "prefix_#{i}"]) && (bean_name = params[bean_key = "bean_#{i}"])
+    def do_get_or_post_splat_attributes(params, get_set_method)
+      #puts "params=#{params.inspect}"
+      path = params[:splat][0]
+      bean = Bean.find(path.split('/'))
+      return 404 unless bean
+      if params[:format]
+        handle_attributes(bean.send(get_set_method, params), params[:format])
+      else
+        haml_for_ajax :content_attributes, :locals => {:get_set_method => get_set_method, :params => params, :path => path, :bean => bean}
+      end
+    end
+
+    def do_get_or_post_attributes(params, get_set_method)
+      hash = {}
+      index = 0
+      while query = params["query_#{index}"]
+        index += 1
+        uri = URI.parse(query)
+        prefix = nil
+        bean_path = uri.path
+        if i = bean_path.index('=')
+          prefix = bean_path[0,i]
+          bean_path = bean_path[(i+1)..-1]
+        end
+        bean = Bean.find(bean_path.split('/'))
+        return 404 unless bean
         new_params = {}
-        postfix = "_#{i}"
-        bean = Bean.find(bean_name.split('/'))
-        params.each do |key, value|
-          if key.end_with?(postfix) && key != prefix_key && key != bean_key
-            new_params[key[0...-(postfix.size)]] = value
+        if uri.query
+          cgi = CGI.parse(uri.query)
+          # We shouldn't have any dual params so let's turn this into a params object we can understand
+          cgi.each do |key, value|
+            new_params[key] = value[0]
           end
         end
-        yield prefix, bean, new_params
-        i += 1
+        bean_hash = bean.send(get_set_method, new_params)
+        if prefix
+          hash[prefix.to_sym] = bean_hash
+        else
+          hash = hash.merge(bean_hash)
+        end
       end
+      handle_attributes(hash, params[:format])
     end
-
   end
 end