rubyhaze 0.0.1-jruby

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Adrian Madrid
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,67 @@
+= rubyhaze-0.0.1
+
+JRuby convenience library to connect with {Hazelcast}[http://hazelcast.com]. According to the website:
+
+Hazelcast is an open source clustering and highly scalable data distribution platform for Java, which is:
+
+* Lightning-fast; thousands of operations/sec.
+* Fail-safe; no losing data after crashes.
+* Dynamically scales as new servers added.
+* Super-easy to use; include a single jar.
+
+== Getting started
+
+Let's get the gem installed and test out the interactive console.
+
+  rvm jruby
+  gem install rubyhaze
+  export HAZELCAST_JAR_PATH=/my/own/path/hazelcast-1.8.5.jar
+  rh_console
+
+  hash = RH::Hash[:test]
+  hash[:a] = 1
+  hash[:b] = 2
+
+Let's open another console to check how this distributed hash works:
+
+  rh_console
+
+  hash = RH::Hash[:test]
+  hash[:a]
+
+  >> 1
+
+== Distributed Objects
+
+Now let's share our own objects:
+
+  rh_console
+
+  class Foo
+    include RubyHaze::Stored
+    field :name, :string
+    field :age, :int
+  end
+
+  a = Foo.create :name => "Leonardo", :age => 65
+  b = Foo.create :name => "Michelangelo", :age => 45
+  c = Foo.create :name => "Raffaello", :age => 32
+
+  found = Foo.find 'age BETWEEN 40 AND 50'
+  found.first.name
+
+  >> "Michelangelo"
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Adrian Madrid. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rubyhaze"
+    gem.summary = %Q{JRuby convenience library to connect with Hazelcast}
+    gem.description = %Q{JRuby convenience library to connect with Hazelcast}
+    gem.email = "aemadrid@gmail.com"
+    gem.homepage = "http://github.com/aemadrid/rubyhaze"
+    gem.authors = ["Adrian Madrid"]
+    gem.files = FileList['bin/*', 'lib/**/*.rb', 'test/**/*.rb', '[A-Z]*'].to_a
+    gem.test_files = Dir["test/test*.rb"]
+    gem.platform = "jruby"
+    gem.add_dependency "bitescript"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+Rake::TestTask.new :test do |t|
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test*.rb"]
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |spec|
+    spec.libs << 'spec'
+    spec.pattern = 'spec/**/*_spec.rb'
+    spec.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rubyhaze #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/rh_console

@@ -0,0 +1,7 @@
+#!/usr/bin/env jruby
+path = "/../lib/rubyhaze/#{ARGV.include?('client') ? :client : :node}"
+require File.expand_path(File.dirname(__FILE__) + path)
+
+require 'irb'
+ARGV.clear
+IRB.start(__FILE__)

data/lib/rubyhaze/base_mixin.rb

@@ -0,0 +1,40 @@
+module RubyHaze::BaseMixin
+
+  java_import 'com.hazelcast.core.Hazelcast'
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  attr_reader :name
+
+  def crc
+    @crc ||= RubyHaze.crc @name
+  end
+
+  def respond_to?(meth)
+    @hco.respond_to?(meth) || super
+  end
+
+  def method_missing(meth, *args, &blk)
+    if @hco.respond_to? meth
+      @hco.send meth, *args, &blk
+    else
+      super
+    end
+  end
+
+  def ==(other)
+    return false unless other.class.name == self.class.name
+    name == other.name
+  end
+
+  module ClassMethods
+
+    def [](name)
+      new(name)
+    end
+
+  end
+
+end

data/lib/rubyhaze/client.rb

@@ -0,0 +1,12 @@
+require 'java'
+
+module RubyHaze
+
+  MODE         = "client" unless defined? MODE
+  GEM_JAR_PATH = File.expand_path(File.dirname(__FILE__) + '/../../jars/hazelcast-client-1.8.5.jar')  unless defined? GEM_JAR_PATH
+  JAR_PATH     = ENV['HAZELCAST_JAR_PATH'] || GEM_JAR_PATH  unless defined? JAR_PATH
+
+end
+
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
+

data/lib/rubyhaze/core_ext.rb

@@ -0,0 +1,76 @@
+# 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) although changed to NOT look for private methods
+
+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, true)
+  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 lines
+    self.split("\n").size
+  end
+
+  def valid_uuid_str(uuid)
+  end
+
+  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

data/lib/rubyhaze/list.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
+
+class RubyHaze::List
+
+  include RubyHaze::BaseMixin
+
+  def initialize(name)
+    @name = name.to_s
+    @hco = Hazelcast.get_list @name
+  end
+
+end

data/lib/rubyhaze/lock.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
+
+class RubyHaze::Lock
+
+  include RubyHaze::BaseMixin
+
+  def initialize(name)
+    @name = name.to_s
+    @hco = Hazelcast.get_lock @name
+  end
+
+end

data/lib/rubyhaze/map.rb

@@ -0,0 +1,96 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
+
+class RubyHaze::Map
+
+  include RubyHaze::BaseMixin
+
+  java_import 'com.hazelcast.query.SqlPredicate'
+
+  def initialize(name)
+    @name = name.to_s
+    @hco = Hazelcast.get_map @name
+  rescue => e
+    puts e.errmsg
+  end
+
+  def each
+    @hco.each do |(key, value)|
+      yield key, value
+    end
+  rescue => e
+    puts e.errmsg
+  end
+  
+  def [](key)
+    @hco[key.to_s]
+  rescue NativeException => x
+    x = x.cause while x.cause
+    x.print_stack_trace
+  rescue => e
+    puts e.errmsg
+  end
+  
+  def []=(key,value)
+    @hco[key.to_s] = value
+  rescue NativeException => x
+    x = x.cause while x.cause
+    x.print_stack_trace
+  rescue => e
+    puts e.errmsg
+  end
+
+  def keys(predicate = nil)
+    @hco.key_set(prepare_predicate(predicate)).map
+  rescue NativeException => x
+    x = x.cause while x.cause
+    x.print_stack_trace
+  rescue => e
+    puts e.errmsg
+  end
+
+  def values(predicate = nil)
+    @hco.values(prepare_predicate(predicate)).map
+  rescue NativeException => x
+    x = x.cause while x.cause
+    x.print_stack_trace
+  rescue => e
+    puts e.errmsg
+  end
+
+  def local_keys(predicate = nil)
+    @hco.local_key_set(prepare_predicate(predicate)).map
+  rescue NativeException => x
+    x = x.cause while x.cause
+    x.print_stack_trace
+  rescue => e
+    puts e.errmsg
+  end
+
+  def local_stats
+    lsm = @hco.local_map_stats
+    { :backup_count => lsm.backup_entry_count, :backup_memory => lsm.backup_entry_memory_cost,
+      :created => lsm.creation_time, :last_accessed => lsm.last_access_time,  }
+  rescue => e
+    puts e.errmsg
+  end
+
+  private
+  
+  def prepare_predicate(predicate)
+    return if predicate.nil?
+    case predicate
+      when String
+        SqlPredicate.new predicate
+      when Hash
+        SqlPredicate.new predicate.map{|k,v| "#{k} = #{v}"}.join(' AND ')
+      when SqlPredicate
+        predicate
+      else
+        raise "Unknown predicate type"
+    end
+  end
+end
+
+RubyHaze::Hash = RubyHaze::Map unless defined? RubyHaze::Hash
+
+

data/lib/rubyhaze/multi_map.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
+
+class RubyHaze::MultiMap
+
+  include RubyHaze::BaseMixin
+
+  def initialize(name)
+    @name = name.to_s
+    @hco = Hazelcast.get_multi_map @name
+  end
+
+end

data/lib/rubyhaze/node.rb

@@ -0,0 +1,12 @@
+require 'java'
+
+module RubyHaze
+
+  MODE         = "node" unless defined? MODE
+  GEM_JAR_PATH = File.expand_path(File.dirname(__FILE__) + '/../../jars/hazelcast-1.8.5.jar')  unless defined? GEM_JAR_PATH
+  JAR_PATH     = ENV['HAZELCAST_JAR_PATH'] || GEM_JAR_PATH  unless defined? JAR_PATH
+
+end
+
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
+

data/lib/rubyhaze/queue.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
+
+class RubyHaze::Queue
+
+  include RubyHaze::BaseMixin
+
+  def initialize(name)
+    @name = name.to_s
+    @hco = Hazelcast.get_queue @name
+  end
+
+end

data/lib/rubyhaze/set.rb

@@ -0,0 +1,12 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
+
+class RubyHaze::Set
+
+  include RubyHaze::BaseMixin
+
+  def initialize(name)
+    @name = name.to_s
+    @hco = Hazelcast.get_set @name
+  end
+
+end

data/lib/rubyhaze/stored.rb

@@ -0,0 +1,184 @@
+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 = {})
+      puts "Defining :#{name}, :#{type}, #{options.inspect}..."
+      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

@@ -0,0 +1,25 @@
+class RubyHaze::FakeStore
+
+  java_import 'com.hazelcast.core.MapStore'
+
+  include MapStore
+
+  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/lib/rubyhaze/topic.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../lib/rubyhaze')
+
+class RubyHaze::Topic
+
+  include RubyHaze::BaseMixin
+
+  java_import 'com.hazelcast.core.MessageListener'
+
+  def initialize(name)
+    @name = name.to_s
+    @hco = Hazelcast.get_topic @name
+  end
+
+  def on_message(&blk)
+    klass = Class.new
+    klass.send :include, MessageListener
+    klass.send :define_method, :on_message, &blk
+    @hco.add_message_listener klass.new
+  end
+
+end

data/lib/rubyhaze.rb

@@ -0,0 +1,52 @@
+require 'java'
+
+module RubyHaze
+
+  class Exception < StandardError; end
+
+  ROOT     = File.expand_path File.join(File.dirname(__FILE__), '..') unless defined? ROOT
+  LIB_PATH = ROOT + "/lib/rubyhaze" unless defined? LIB_PATH
+  TMP_PATH = (ENV['RUBYHAZE_TMP_PATH'] || ROOT + '/tmp')
+
+  $CLASSPATH << TMP_PATH
+
+  unless defined? MODE
+    require LIB_PATH + '/' + (ENV['RUBYHAZE_MODE'] || 'node')
+  end
+
+  puts ">> Loading Hazelcast #{MODE} library..."
+  if File.file?(JAR_PATH)
+    require JAR_PATH
+    java_import 'com.hazelcast.core.Hazelcast'
+    Hazelcast.get_cluster
+    puts ">> ... loaded!"
+  else
+    puts "ERROR! Could not find the Hazelcast JAR file in [#{JAR_PATH}]."
+    abort
+  end
+
+  %w{core_ext base_mixin map multi_map set list queue topic lock stored}.each do |name|
+    require LIB_PATH + '/' + name
+  end
+
+  class << self
+
+    java_import 'com.hazelcast.core.Hazelcast'
+
+    def instances
+      Hazelcast.get_instances
+    end
+
+    def cluster
+      Hazelcast.get_cluster
+    end
+
+    def config
+      Hazelcast.get_config
+    end
+
+  end
+
+end
+
+RH = RubyHaze unless defined? RH

data/test/test_stored.rb

@@ -0,0 +1,85 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/rubyhaze')
+require 'test/unit'
+
+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

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: rubyhaze
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 0
+    - 1
+  version: 0.0.1
+platform: jruby
+authors: 
+  - Adrian Madrid
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-05 00:00:00 -06:00
+default_executable: rh_console
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: bitescript
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ">="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 0
+            version: "0"
+    type: :runtime
+    version_requirements: *id001
+description: JRuby convenience library to connect with Hazelcast
+email: aemadrid@gmail.com
+executables: 
+  - rh_console
+extensions: []
+
+extra_rdoc_files: 
+  - LICENSE
+  - README.rdoc
+files: 
+  - LICENSE
+  - README.rdoc
+  - Rakefile
+  - VERSION
+  - bin/rh_console
+  - lib/rubyhaze.rb
+  - lib/rubyhaze/base_mixin.rb
+  - lib/rubyhaze/client.rb
+  - lib/rubyhaze/core_ext.rb
+  - lib/rubyhaze/list.rb
+  - lib/rubyhaze/lock.rb
+  - lib/rubyhaze/map.rb
+  - lib/rubyhaze/multi_map.rb
+  - 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/test_stored.rb
+has_rdoc: true
+homepage: http://github.com/aemadrid/rubyhaze
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --charset=UTF-8
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: JRuby convenience library to connect with Hazelcast
+test_files: 
+  - test/test_stored.rb