rubyhaze 0.0.3-jruby → 0.0.4-jruby

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/rubyhaze.rb

@@ -68,8 +68,6 @@ module RubyHaze
 
 end
 
-require 'rubyhaze/core_ext'
-
 require 'rubyhaze/mixins/proxy'
 require 'rubyhaze/mixins/compare'
 require 'rubyhaze/mixins/native_exception'
@@ -89,6 +87,4 @@ require 'rubyhaze/configs/network'
 require 'rubyhaze/configs/queue'
 require 'rubyhaze/configs/config'
 
-require 'rubyhaze/stored'
-
 RH = RubyHaze unless defined? RH

data/test/helper.rb

@@ -1,6 +1,7 @@
 require File.expand_path(File.dirname(__FILE__) + '/../lib/rubyhaze')
 require 'test/unit'
 require 'forwardable'
+require 'date'
 
 RubyHaze.init :group => { :username => "test", :password => "test" }
 

data/test/test_hash.rb

@@ -0,0 +1,31 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class TestRubyHazeHash < Test::Unit::TestCase
+
+  def test_same_object
+    hash = RubyHaze::Hash[:test_same_object]
+    map = RubyHaze::Map[:test_same_object]
+    assert_equal hash.name, map.name
+    hash[:a] = 1
+    assert_equal hash[:a], map[:a]
+  end
+
+  def test_string_keys
+    hash = RubyHaze::Hash[:test_string_keys]
+
+    hash[:a] = 1
+    assert_equal hash['a'], 1
+    assert_equal hash[:a], 1
+
+    hash['b'] = 2
+    assert_equal hash[:b], 2
+
+    hash[Date.new(2010, 3, 18)] = 3
+    assert_equal hash['2010-03-18'], 3
+
+    hash[4] = 4
+    assert_equal hash['4'], 4
+    assert_equal hash[4], 4
+  end
+
+end

data/test/test_queue.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+class TestRubyHazeQueue < Test::Unit::TestCase
+
+  def test_single_queing
+    tasks = RubyHaze::Queue[:test_single]
+    50.times { |idx| tasks.put [idx, Process.pid] }
+    found = []
+    while !tasks.empty? do
+      task = tasks.poll 5, java.util.concurrent.TimeUnit::SECONDS
+      found << task
+    end
+    assert !found.empty?
+    assert_equal found.size, 50
+  end
+
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 0
-    - 3
-  version: 0.0.3
+    - 4
+  version: 0.0.4
 platform: jruby
 authors: 
   - Adrian Madrid
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-24 00:00:00 -06:00
+date: 2010-08-30 00:00:00 -06:00
 default_executable: rubyhaze_console
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -54,7 +54,6 @@ files:
   - lib/rubyhaze/configs/network.rb
   - lib/rubyhaze/configs/queue.rb
   - lib/rubyhaze/configs/topic.rb
-  - lib/rubyhaze/core_ext.rb
   - lib/rubyhaze/list.rb
   - lib/rubyhaze/lock.rb
   - lib/rubyhaze/map.rb
@@ -66,11 +65,10 @@ files:
   - lib/rubyhaze/node.rb
   - lib/rubyhaze/queue.rb
   - lib/rubyhaze/set.rb
-  - lib/rubyhaze/stored.rb
-  - lib/rubyhaze/stores/fake_store.rb
   - lib/rubyhaze/topic.rb
   - test/helper.rb
-  - test/test_stored.rb
+  - test/test_hash.rb
+  - test/test_queue.rb
   - test/test_topic.rb
 has_rdoc: true
 homepage: http://github.com/aemadrid/rubyhaze
@@ -103,5 +101,6 @@ signing_key:
 specification_version: 3
 summary: JRuby wrapper to play with Hazelcast
 test_files: 
-  - test/test_stored.rb
+  - test/test_hash.rb
+  - test/test_queue.rb
   - test/test_topic.rb

data/lib/rubyhaze/core_ext.rb

@@ -1,97 +0,0 @@
-# Taken from http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/100177
-class Exception
-  def errmsg
-    "%s: %s\n%s" % [self.class, message, (backtrace || []).join("\n") << "\n"]
-  end
-end
-
-# Taken from Active Support
-class Array
-  # Extracts options from a set of arguments. Removes and returns the last
-  # element in the array if it's a hash, otherwise returns a blank hash.
-  #
-  #   def options(*args)
-  #     args.extract_options!
-  #   end
-  #
-  #   options(1, 2)           # => {}
-  #   options(1, 2, :a => :b) # => {:a=>:b}
-  def extract_options!
-    last.is_a?(::Hash) ? pop : {}
-  end
-end
-
-# Extracted from truthy (http://github.com/ymendel/truthy/tree/master/lib/truthy.rb)
-# and Rails (http://github.com/rails/rails/commit/823b623fe2de8846c37aa13250010809ac940b57)
-
-class Object
-
-  # Tricky, tricky! (-:
-  def truthy?
-    !!self
-  end
-
-  # Tries to send the method only if object responds to it. Return +nil+ otherwise.
-  # It will also forward any arguments and/or block like Object#send does.
-  #
-  # ==== Example :
-  #
-  # # Without try
-  # @person ? @person.name : nil
-  #
-  # With try
-  # @person.try(:name)
-  #
-  # # try also accepts arguments/blocks for the method it is trying
-  # Person.try(:find, 1)
-  # @people.try(:map) {|p| p.name}
-  #
-  def try(method, *args, &block)
-    send(method, *args, &block) if respond_to?(method)
-  end
-
-  # List unique local methods
-  # Taken from http://giantrobots.thoughtbot.com/2008/12/23/script-console-tips
-  def local_methods
-    (methods - Object.instance_methods).sort
-  end
-
-end
-
-class String
-  def self.random_uuid
-    java.util.UUID.randomUUID.toString
-  end
-
-  def valid_uuid?
-    !!(size == 36 && self =~ %r{^([A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12})$}i)
-  end
-end
-
-# Taken from ActiveSupport
-class Hash
-  def slice(*keys)
-    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
-    hash = self.class.new
-    keys.each { |k| hash[k] = self[k] if has_key?(k) }
-    hash
-  end
-
-  def slice!(*keys)
-    keys = keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
-    omit = slice(*self.keys - keys)
-    hash = slice(*keys)
-    replace(hash)
-    omit
-  end
-
-  def except(*keys)
-    dup.except!(*keys)
-  end
-
-  def except!(*keys)
-    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key)
-    keys.each { |key| delete(key) }
-    self
-  end
-end

data/lib/rubyhaze/stored.rb

@@ -1,183 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
-require 'bitescript'
-
-module RubyHaze::Stored
-
-  def self.included(base)
-    base.extend ClassMethods
-  end
-
-  def initialize(*args)
-    return if args.empty?
-    hash = args.extract_options!
-    set hash if hash
-    unless args.empty?
-      args.each_with_index do |value, idx|
-        set self.class.field_names[idx], value
-      end
-    end
-  end
-
-  def set(*args)
-    if args.size == 2
-      instance_variable_set "@#{args.first}", args.last
-    elsif args.size == 1 && args.first.is_a?(Hash)
-      args.first.each { |k,v| set k, v }
-    else
-      raise "Unknown parameters #{args.inspect} for set"
-    end
-  end
-
-  def get(*args)
-    if args.size == 1
-      instance_variable_get "@#{args.first}"
-    else
-      args.map { |k| get k }
-    end
-  end
-
-  def attributes
-    self.class.field_names.map{ |name| [ name, instance_variable_get("@#{name}") ] }
-  end
-
-  def values
-    self.class.field_names.map{ |name| instance_variable_get("@#{name}") }
-  end
-
-  def to_ary
-    attributes.unshift [ 'class', self.class.name ]
-  end
-
-  def ==(other)
-    return false unless other.respond_to? :to_ary
-    to_ary == other.to_ary
-  end
-
-  def shadow_object
-    self.class.store_java_class.new *values
-  end
-
-  def load_shadow_object(shadow)
-    self.class.field_names.each do |name|
-      instance_variable_set "@#{name}", shadow.send(name)
-    end
-    self
-  end
-
-  attr_accessor :uid
-
-  def save
-    @uid ||= String.random_uuid
-    self.class.store[uid] = shadow_object
-  end
-
-  def load
-    raise "Missing uid for load" if uid.nil?
-    found = self.class.store[uid]
-    raise "Record not found" unless found
-    load_shadow_object(found)
-    self
-  end
-
-  alias :reload :load
-
-  def to_s
-    "<" + self.class.name + " " + attributes[1..-1].inspect + " >"
-  end
-
-  module ClassMethods
-
-    def create(*args)
-      obj = new(*args)
-      obj.save
-      obj
-    end
-
-    def store
-      @store ||= RubyHaze::Map.new store_java_class_name
-    end
-
-    def fields
-      @fields ||= [
-        [ :uid, :string, {} ]
-      ]
-    end
-
-    def field_names()   fields.map { |ary| ary[0] } end
-    def field_types()   fields.map { |ary| ary[1] } end
-    def field_options() fields.map { |ary| ary[2] } end
-
-    def field(name, type, options = {})
-      raise "Field [#{name} already defined" if field_names.include?(name)
-      fields << [ name, type, options ]
-      attr_accessor name
-    end
-
-    def field_loads
-      {
-        :string => :aload,
-        :int => :iload,
-        :boolean => :iload,
-        :double => :dload,
-      }
-    end
-
-    def store_java_class_name
-      'RubyHaze_Shadow__' + name 
-    end
-
-    def store_java_class
-      RubyHaze.const_defined?(store_java_class_name) ?
-        RubyHaze.const_get(store_java_class_name) :
-        generate_java_class
-    end
-
-    def generate_java_class
-      builder = BiteScript::FileBuilder.new store_java_class_name + '.class'
-      class_dsl = []
-      class_dsl << %{public_class "#{store_java_class_name}", object, Java::JavaIo::Serializable do}
-      fields.each do |name, type, options|
-        class_dsl << %{  public_field :#{name}, send(:#{type})}
-      end
-      class_dsl << %{  public_constructor [], #{field_types.map{|x| x.to_s}.join(', ')} do}
-      class_dsl << %{    aload 0}
-      class_dsl << %{    invokespecial object, "<init>", [void]}
-      index = 1
-      fields.each do |name, type, options|
-        class_dsl << %{    aload 0}
-        class_dsl << %{    #{field_loads[type]} #{index}}
-        index += 1
-        class_dsl << %{    putfield this, :#{name}, send(:#{type})}
-      end
-      class_dsl << %{    returnvoid}
-      class_dsl << %{  end}
-      class_dsl << %{end}
-      class_dsl = class_dsl.join("\n")
-      if $DEBUG
-        FileUtils.mkdir_p RubyHaze::TMP_PATH
-        filename = RubyHaze::TMP_PATH + '/' + store_java_class_name + '.bc'
-        File.open(filename, 'w') { |file| file.write class_dsl }
-      end
-      builder.instance_eval class_dsl, __FILE__, __LINE__
-      builder.generate do |builder_filename, class_builder|
-        bytes = class_builder.generate
-        klass = JRuby.runtime.jruby_class_loader.define_class store_java_class_name, bytes.to_java_bytes
-        if $DEBUG
-          filename = RubyHaze::TMP_PATH + '/' + builder_filename
-          File.open(filename, 'w') { |file| file.write class_builder.generate }
-        end
-        RubyHaze.const_set store_java_class_name, JavaUtilities.get_proxy_class(klass.name)
-      end
-      RubyHaze.const_get store_java_class_name
-    end
-
-    def find(predicate)
-      store.values(predicate).map { |shadow| new.load_shadow_object shadow }
-    end
-
-    def find_uids(predicate)
-      store.keys(predicate)
-    end
-  end
-
-end

data/lib/rubyhaze/stores/fake_store.rb

@@ -1,36 +0,0 @@
-class RubyHaze::FakeStore
-
-  java_import 'com.hazelcast.core.MapLoader'
-  java_import 'com.hazelcast.core.MapStore'
-
-  include MapStore
-  include MapLoader
-
-  def load(key)
-    puts "[FakeStore] Loading key [#{key}]"
-  end
-
-  def load_all(keys)
-    puts "[FakeStore] Loading #{keys.size} keys"
-    keys.each { |key| load key }
-  end
-
-  def delete(key)
-    puts "[FakeStore] Deleting key [#{key}]"
-  end
-
-  def delete_all(keys)
-    puts "[FakeStore] Deleting #{keys.size} keys"
-    keys.each { |key| delete key }
-  end
-
-  def store(key, value)
-    puts "[FakeStore] Storing key [#{key}] value [#{value}]"
-  end
-
-  def store_all(map)
-    puts "[FakeStore] Storing #{map.size} key/values"
-    map.each { |key, value| store key, value }    
-  end
-  
-end

data/test/test_stored.rb

@@ -1,84 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class Foo
-  include RubyHaze::Stored
-  field :name, :string
-  field :age, :int
-end unless defined? Foo
-
-class TestRubyHazeStoredClassMethods < Test::Unit::TestCase
-
-  def test_right_store
-    store = Foo.store
-    assert_equal store.class.name, "RubyHaze::Map"
-    assert_equal store.name, "RubyHaze_Shadow__Foo"
-    assert_equal store.name, RubyHaze::Map.new("RubyHaze_Shadow__Foo").name
-  end
-
-  def test_right_fields
-    fields = Foo.fields
-    assert_equal fields, [[:uid, :string, {}], [:name, :string, {}], [:age, :int, {}]]
-    assert_equal Foo.field_names, [:uid, :name, :age]
-    assert_equal Foo.field_types, [:string, :string, :int]
-    assert_equal Foo.field_options, [{}, {}, {}]
-  end
-
-  def test_right_shadow_class
-    assert_equal Foo.store_java_class_name, "RubyHaze_Shadow__Foo"
-    assert_equal Foo.store_java_class.name, "Java::Default::RubyHaze_Shadow__Foo"
-
-  end
-
-end
-
-class TestRubyHazeStoredStorage < Test::Unit::TestCase
-
-  def test_store_reload_objects
-    Foo.store.clear
-    assert_equal Foo.store.size, 0
-    @a = Foo.create :name => "Leonardo", :age => 65
-    assert_equal Foo.store.size, 1
-    @b = Foo.create :name => "Michelangelo", :age => 45
-    assert_equal Foo.store.size, 2
-    @b.age = 47
-    @b.reload
-    assert_equal Foo.store.size, 2
-    assert_equal @b.age, 45
-    Foo.store.clear
-    assert_equal Foo.store.size, 0
-  end
-
-  def test_find_through_predicates
-    Foo.store.clear
-    @a = Foo.create :name => "Leonardo", :age => 65
-    @b = Foo.create :name => "Michelangelo", :age => 45
-    @c = Foo.create :name => "Raffaello", :age => 32
-
-    res = Foo.find 'age < 40'
-    assert_equal res.size, 1
-    assert_equal res.first, @c
-    assert_equal res.first.name, @c.name
-
-    res = Foo.find 'age BETWEEN 40 AND 50'
-    assert_equal res.size, 1
-    assert_equal res.first, @b
-    assert_equal res.first.name, @b.name
-
-    res = Foo.find "name LIKE 'Leo%'"
-    assert_equal res.size, 1
-    assert_equal res.first, @a
-    assert_equal res.first.name, @a.name
-
-#    res = Foo.find "age IN (32, 65)"
-#    assert_equal res.size, 2
-#    names = res.map{|x| x.name }.sort
-#    assert_equal names.first, @a.name
-#    assert_equal names.last, @b.name
-
-    res = Foo.find "age < 40 AND name LIKE '%el%'"
-    assert_equal res.size, 1
-    assert_equal res.first, @c
-    assert_equal res.first.name, @c.name
-  end
-
-end