rubyhaze-persisted 0.0.1-jruby → 0.0.3-jruby

data/README.rdoc

@@ -14,8 +14,8 @@ Let's get some distributed ruby objects going:
 
   class Foo
     include RubyHaze::Persisted
-    field :name, :string
-    field :age, :int
+    attribute :name, :string
+    attribute :age, :int
   end
 
   a = Foo.create :name => "Raffaello", :age => 32

data/Rakefile

@@ -6,14 +6,17 @@ begin
   Jeweler::Tasks.new do |gem|
     gem.name = "rubyhaze-persisted"
     gem.summary = %Q{ActiveRecord-like objects persisted with Hazelcast and RubyHaze}
-    gem.description = %Q{Have your distributed Ruby objects and search them too.}
-    gem.email = "aemadrid@alliancehealth.com"
+    gem.description = %Q{Have your in-mempry distributed JRuby objects and search them too.}
+    gem.email = "aemadrid@gmail.com"
     gem.homepage = "http://github.com/aemadrid/rubyhaze-persisted"
     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"
+    gem.add_dependency "rubyhaze", "~> 0.0.6"
+    gem.add_dependency "bitescript", "0.0.6"
+    gem.add_dependency "activesupport", "~> 3.0.0"
+    gem.add_dependency "activemodel", "~> 3.0.0"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.3

data/lib/rubyhaze-persisted.rb

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/../lib/rubyhaze/persisted')

data/lib/rubyhaze/persisted.rb

@@ -1,12 +1,13 @@
+begin
+  gem "rubyhaze", "~> 0.0.6"
+rescue NoMethodError
+  require 'rubygems'
+  gem "rubyhaze", "~> 0.0.6"
+ensure
+  require "rubyhaze"
+end
+
 $:.unshift File.expand_path(File.join(File.dirname(__FILE__), 'persisted'))
+
 require 'shadow_class_generator'
 require 'model'
-
-class D
-  include RubyHaze::Persisted
-  attribute :name, :string
-  attribute :age, :int 
-
-
-  validates_presence_of :name
-end

data/lib/rubyhaze/persisted/model.rb

@@ -1,36 +1,49 @@
-require "rubyhaze"
-
-gem "activesupport"
-
+gem "activesupport", "3.0.0"
 require "active_support/core_ext/module/attr_accessor_with_default"
 require "active_support/core_ext/object/blank"
 require "active_support/concern"
 require "active_support/callbacks"
 
+gem "activemodel", "3.0.0"
 require "active_model"
 
 module RubyHaze
+
   module Persisted
+    class Register
+      class << self
+        def classes
+          @classes ||= []
+        end
 
-    extend ActiveSupport::Concern
-    include ActiveSupport::Callbacks
+        def add(base)
+          return false if classes.include? base.name
+          classes << base.name
+          true
+        end
+      end
+    end
 
-    extend ActiveModel::Naming
-    extend ActiveModel::Translation
-    extend ActiveModel::Callbacks
+   def self.included(base)
+     return unless RubyHaze::Persisted::Register.add(base)
 
-    include ActiveModel::AttributeMethods
-    include ActiveModel::Conversion
-    include ActiveModel::Dirty
-    include ActiveModel::Serialization
-    include ActiveModel::Serializers::JSON
-    include ActiveModel::Serializers::Xml
-    include ActiveModel::Validations
+     base.send :extend, ClassMethods
+     base.send :extend, ActiveModel::Naming
+     base.send :extend, ActiveModel::Translation
+     base.send :extend, ActiveModel::Callbacks
 
-    included do
-      attribute_method_suffix '', '=', '?'
-      extend ClassMethods
-    end
+     base.send :include, ActiveModel::AttributeMethods
+     base.send :include, ActiveModel::Conversion
+     base.send :include, ActiveModel::Dirty
+     base.send :include, ActiveModel::Serialization
+     base.send :include, ActiveModel::Serializers::JSON
+     base.send :include, ActiveModel::Serializers::Xml
+     base.send :include, ActiveModel::Validations
+     base.send :include, InstanceMethods
+
+     base.attribute_method_suffix '', '=', '?'
+     base.define_model_callbacks :create, :update, :load, :destroy
+   end
 
     module InstanceMethods
 
@@ -121,35 +134,52 @@ module RubyHaze
         result != false
       end
 
-      def update
-        raise "Missing uid" unless uid?
-        self.class.map[uid] = shadow_object
-        @previously_changed = changes
-        @changed_attributes.clear
-        true
+      def create
+        _run_create_callbacks do
+          @uid ||= RubyHaze.random_uuid
+          self.class.map[uid] = shadow_object
+          @previously_changed = changes
+          @changed_attributes.clear
+          @new_record = false
+          uid
+        end
       end
 
-      def create
-        @uid ||= RubyHaze.random_uuid
-        self.class.map[uid] = shadow_object
-        @previously_changed = changes
-        @changed_attributes.clear
-        @new_record = false
-        uid
+      def update
+        _run_update_callbacks do
+          raise "Missing uid" unless uid?
+          self.class.map[uid] = shadow_object
+          @previously_changed = changes
+          @changed_attributes.clear
+          true
+        end
       end
 
       def load
-        raise "Missing uid for load" if uid.blank?
-        found = self.class.map[uid]
-        raise "Record not found" unless found
-        load_shadow_object(found)
-        @changed_attributes.clear
-        @new_record = false
-        self
+        _run_load_callbacks do
+          raise "Missing uid for load" if uid.blank?
+          found = self.class.map[uid]
+          raise "Record not found" unless found
+          load_shadow_object(found)
+          @changed_attributes.clear
+          @new_record = false
+          self
+        end
       end
       alias :reload :load
       alias :reset  :load
 
+      def destroy
+        _run_destroy_callbacks do
+          if persisted?
+            self.class.map.remove uid
+          end
+          @destroyed = true
+          freeze
+        end
+      end
+      alias :delete :destroy
+
       def to_s
         "<#{self.class.name}:#{object_id} #{to_ary[1..-1].map { |k, v| "#{k}=#{v}" }.join(" ")} >"
       end
@@ -170,16 +200,12 @@ module RubyHaze
         obj
       end
 
-      def map_java_class_name
-        'RubyHaze_Shadow__' + name
-      end
-
       def map_java_class
-        @java_class ||= RubyHaze::Persisted::ShadowClassGenerator.get map_java_class_name, attributes
+        @java_class ||= RubyHaze::Persisted::Shadow::Generator.get name, attributes
       end
 
       def map
-        @map ||= RubyHaze::Map.new map_java_class_name
+        @map ||= RubyHaze::Map.new "RubyHaze::Persisted #{name}"
       end
 
       def attributes
@@ -201,13 +227,21 @@ module RubyHaze
       def attribute(name, type, options = {})
         raise "Attribute [#{name}] already defined" if attribute_names.include?(name)
         @attributes << [name, type, options]
-#        attr_accessor name
+        @attribute_methods_generated = false
+        define_attribute_methods [ name ]
+        self
       end
 
       def find(predicate)
         map.values(predicate).map { |shadow| new.load_shadow_object shadow }
       end
 
+      def [](*args)
+        options = args.extract_options!
+        options[:uid] = args.first if RubyHaze.valid_uuid?(args.first)
+        find(options).first
+      end
+
       def find_uids(predicate)
         map.keys(predicate)
       end

data/lib/rubyhaze/persisted/shadow_class_generator.rb

@@ -1,64 +1,91 @@
+gem "bitescript", "0.0.6"
 require 'bitescript'
 
 module RubyHaze
   module Persisted
-    module ShadowClassGenerator
+    module Shadow
 
-      def self.get(name, attributes)
-        RubyHaze::Persisted.const_defined?(name) ?
-          RubyHaze::Persisted.const_get(name) :
-          generate(name, attributes)
+      module Classes
       end
 
-      def self.attribute_load_types
-        {
-          :string  => :aload,
-          :int     => :iload,
-          :boolean => :iload,
-          :double  => :dload,
-        }
-      end
+      class Generator
 
-      def self.generate(name, attributes)
-        tmp_path = (ENV['RUBYHAZE_PERSISTED_TMP_PATH'] || File.join(Dir.pwd, 'tmp'))
-        builder = BiteScript::FileBuilder.new name + '.class'
-        class_dsl = []
-        class_dsl << %{public_class "#{name}", object, Java::JavaIo::Serializable do}
-        attributes.each do |attr_name, type, options|
-          class_dsl << %{  public_field :#{attr_name}, send(:#{type})}
-        end
-        class_dsl << %{  public_constructor [], #{attributes.map { |ary| ary[1].to_s }.join(', ')} do}
-        class_dsl << %{    aload 0}
-        class_dsl << %{    invokespecial object, "<init>", [void]}
-        index = 1
-        attributes.each do |attr_name, type, options|
-          class_dsl << %{    aload 0}
-          class_dsl << %{    #{attribute_load_types[type]} #{index}}
-          index += 1
-          class_dsl << %{    putfield this, :#{attr_name}, send(:#{type})}
-        end
-        class_dsl << %{    returnvoid}
-        class_dsl << %{  end}
-        class_dsl << %{end}
-        class_dsl = class_dsl.join("\n")
-        if $DEBUG
-          FileUtils.mkdir_p tmp_path
-          filename = File.join tmp_path, 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 name, bytes.to_java_bytes
-          if $DEBUG
-            filename = File.join tmp_path, builder_filename
-            File.open(filename, 'w') { |file| file.write class_builder.generate }
+        class << self
+
+          def get(name, attributes)
+            safe_name = name.gsub '::', '__'
+            RubyHaze::Persisted::Shadow::Classes.const_defined?(safe_name) ?
+              RubyHaze::Persisted::Shadow::Classes.const_get(safe_name) :
+              generate(name, attributes)
+          end
+
+          def attribute_load_types
+            {
+              :string  => :aload,
+              :int     => :iload,
+              :boolean => :iload,
+              :double  => :dload,
+            }
           end
-          RubyHaze::Persisted.const_set name, JavaUtilities.get_proxy_class(klass.name)
+
+          def template(name, attributes)
+            str = []
+            packages = %w{org rubyhaze persisted shadow classes}
+            names = name.split '::'
+            name = names.pop
+            packages += names
+            str << "package '#{packages.join('.')}' do"
+            str << %{  public_class "#{name}", object, Java::JavaIo::Serializable do}
+            attributes.each do |attr_name, type, options|
+              str << %{    public_field :#{attr_name}, send(:#{type})}
+            end
+            str << %{    public_constructor [], #{attributes.map { |ary| ary[1].to_s }.join(', ')} do}
+            str << %{      aload 0}
+            str << %{      invokespecial object, "<init>", [void]}
+            index = 1
+            attributes.each do |attr_name, type, options|
+              str << %{      aload 0}
+              load_type = attribute_load_types[type]
+              raise "Unknown load type for attribute [#{attr_name}] on class [#{name}]" unless load_type
+              str << %{      #{load_type} #{index}}
+              index += 1
+              str << %{      putfield this, :#{attr_name}, send(:#{type})}
+            end
+            str << %{      returnvoid}
+            str << %{    end}
+            str << %{  end}
+            str << %{end}
+            str.join("\n")
+          end
+
+          def generate(name, attributes)
+            tmp_path = (ENV['RUBYHAZE_PERSISTED_TMP_PATH'] || File.join(Dir.pwd, 'tmp'))
+            builder = BiteScript::FileBuilder.new name + '.class'
+            str = template name, attributes
+            if $DEBUG
+              FileUtils.mkdir_p tmp_path
+              filename = File.join tmp_path, name + '.bc'
+              puts ">> Saving bitescript [#{filename}]..."
+              File.open(filename, 'w') { |file| file.write str }
+            end
+            builder.instance_eval str, __FILE__, __LINE__
+            safe_name = name.gsub '::', '__'
+            builder.generate do |builder_filename, class_builder|
+              bytes = class_builder.generate
+              klass = JRuby.runtime.jruby_class_loader.define_class builder_filename[0..-7].gsub('/', '.'), bytes.to_java_bytes
+              if $DEBUG
+                filename = File.join tmp_path, builder_filename
+                FileUtils.mkdir_p File.dirname(filename)
+                puts ">> Saving class [#{filename}]..."
+                File.open(filename, 'w') { |file| file.write class_builder.generate }
+              end
+              RubyHaze::Persisted::Shadow::Classes.const_set safe_name, JavaUtilities.get_proxy_class(klass.name)
+            end
+            RubyHaze::Persisted::Shadow::Classes.const_get safe_name
+          end
+
         end
-        RubyHaze::Persisted.const_get name
       end
-
     end
   end
-end
+end

data/test/helper.rb

@@ -1,11 +1,39 @@
-require 'test/unit'
-require 'forwardable'
+unless defined?(HELPER_LOADED)
 
-require File.expand_path(File.dirname(__FILE__) + '/../lib/rubyhaze/persisted')
+  require 'test/unit'
+  require 'forwardable'
 
-class Test::Unit::TestCase
-end
+  require File.expand_path(File.dirname(__FILE__) + '/../lib/rubyhaze/persisted')
+
+  class Notices
+    class << self
+      extend Forwardable
+      def all
+        @all ||= []
+      end
+      def_delegators :all, :size, :<<, :first, :last, :pop, :clear, :map
+    end
+  end
+
+  class Foo
+    include RubyHaze::Persisted
+    attribute :name, :string
+    attribute :age, :int
+  end
+
+  module Sub
+    class Foo
+      include RubyHaze::Persisted
+      attribute :name, :string
+    end
+  end
 
-# Start a new hazelcast cluster
-RubyHaze.init :group => { :username => "test_persisted", :password => "test_persisted" }
+  # Start a new hazelcast cluster
+  RubyHaze.init :group => { :username => "test_persisted", :password => "test_persisted" }
 
+  HELPER_LOADED = true
+
+  class Test::Unit::TestCase
+  end
+
+end

data/test/test_model.rb

@@ -1,14 +1,130 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
+require(File.expand_path(File.dirname(__FILE__) + '/helper'))
 
 class LintTest < ActiveModel::TestCase
   include ActiveModel::Lint::Tests
 
-  class PersistedTestModel
+  class Admin
+    class User
+      include RubyHaze::Persisted
+
+      attribute :name, :string
+      attribute :age, :integer
+      attribute :active, :boolean
+      attribute :salary, :double
+    end
+  end
+
+  class ImportantPerson
+    include RubyHaze::Persisted
+
+    attribute :name, :string
+
+    before_create :notice_create_before
+    after_update  :notice_update_after
+    around_load   :notice_load_around
+    after_destroy :notice_destroy_after
+
+    def notice_create_before
+      Notices.all << "ImportantPerson before create"
+    end
+
+    def notice_update_after
+      Notices.all << "ImportantPerson after update"
+    end
+
+    def notice_load_around
+      Notices.all << "ImportantPerson around load before"
+      yield
+      Notices.all << "ImportantPerson around load after"
+    end
+
+    def notice_destroy_after
+      Notices.all << "ImportantPerson after destroy"
+    end
+
+  end
+
+  class SimplePerson
     include RubyHaze::Persisted
+
     attribute :name, :string
   end
 
   def setup
-    @model = PersistedTestModel.new
+    @model = Admin::User.new
+  end
+
+  def test_naming
+    @model_name = Admin::User.model_name
+    assert_equal "lint_test_admin_user", @model_name.singular
+    assert_equal "lint_test_admin_users", @model_name.plural
+    assert_equal "user", @model_name.element
+    assert_equal "lint_test/admin/users", @model_name.collection
+    assert_equal "lint_test/admin/users/user", @model_name.partial_path
+  end
+
+  def test_translation
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend.store_translations 'en', :attributes => { :age => 'age default attribute' }
+    assert_equal 'age default attribute', Admin::User.human_attribute_name('age')
+    I18n.backend.store_translations 'en', :activemodel => {:attributes => {:foo => {:name => 'foo name attribute'} } }
+    assert_equal 'foo name attribute', Foo.human_attribute_name('name')
+    I18n.backend.store_translations 'en', :activemodel => {:models => {:foo => 'foo model'} }
+    assert_equal 'foo model', Foo.model_name.human
+  end
+
+  def test_callbacks
+    Notices.clear
+    assert_equal 0, Notices.size
+    important_person = ImportantPerson.create :name => "David"
+    ImportantPerson.attributes
+    assert_equal 1, Notices.size
+    assert_equal "ImportantPerson before create", Notices.pop
+    important_person.name = "David The Great"
+    important_person.update
+    assert_equal 1, Notices.size
+    assert_equal "ImportantPerson after update", Notices.pop
+    important_person.reload
+    assert_equal 2, Notices.size
+    assert_equal "ImportantPerson around load after", Notices.pop
+    assert_equal "ImportantPerson around load before", Notices.pop
+    important_person.destroy
+    assert_equal 1, Notices.size
+    assert_equal "ImportantPerson after destroy", Notices.pop
+    assert_equal 0, Notices.size
+  end
+
+  def test_attribute_methods
+    simple_person = SimplePerson.create :name => "David"
+    assert_equal simple_person.name, "David"
+    assert simple_person.name?
+    simple_person.name = "Joseph"
+    assert_equal simple_person.name, "Joseph"
+  end
+
+  def test_conversion
+    simple_person = SimplePerson.create :uid => '123', :name => "David"
+    assert_equal simple_person.to_model, simple_person
+    assert_nil simple_person.to_key
+    assert_nil simple_person.to_param
+    simple_person.save
+    assert_equal %w{123}, simple_person.to_key
+    assert_equal '123', simple_person.to_param
+  end
+
+  def test_dirty
+    uid = '456'
+    names = [ "David", "Bob", "James", "Earl" ]
+    SimplePerson.create :uid => uid, :name => names.first
+    simple_person = SimplePerson.find uid
+    assert_equal false, simple_person.changed?
+    simple_person.name = names[1]
+    assert simple_person.changed?
+    assert simple_person.name_changed?
+    assert_equal names[1], simple_person.name_was
+    assert_equal names[0,2], simple_person.name_change
+    exp_changes = { :name => names[0,2] }
+    assert_equal exp_changes, simple_person.changes
+
   end
-end
+end

data/test/test_persisted.rb

@@ -1,31 +1,29 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class Foo
-  include RubyHaze::Persisted
-  attribute :name, :string
-  attribute :age, :int
-end unless defined? Foo
+require(File.expand_path(File.dirname(__FILE__) + '/helper'))
 
 class TestRubyHazePersistedClassMethods < Test::Unit::TestCase
 
   def test_right_store
     store = Foo.map
     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
+    assert_equal store.name, "RubyHaze::Persisted Foo"
+    assert_equal store.name, RubyHaze::Map.new("RubyHaze::Persisted Foo").name
   end
 
   def test_right_fields
-    fields = Foo.attributes
-    assert_equal fields, [[:uid, :string, {}], [:name, :string, {}], [:age, :int, {}]]
+    assert_equal Foo.attributes, [[:uid, :string, {}], [:name, :string, {}], [:age, :int, {}]]
     assert_equal Foo.attribute_names, [:uid, :name, :age]
     assert_equal Foo.attribute_types, [:string, :string, :int]
     assert_equal Foo.attribute_options, [{}, {}, {}]
+
+    assert_equal Sub::Foo.attributes, [[:uid, :string, {}], [:name, :string, {}]]
+    assert_equal Sub::Foo.attribute_names, [:uid, :name]
+    assert_equal Sub::Foo.attribute_types, [:string, :string]
+    assert_equal Sub::Foo.attribute_options, [{}, {}]
   end
 
   def test_right_shadow_class
-    assert_equal Foo.map_java_class_name, "RubyHaze_Shadow__Foo"
-    assert_equal Foo.map_java_class.name, "Java::Default::RubyHaze_Shadow__Foo"
+    assert_equal Foo.map_java_class.name, "Java::OrgRubyhazePersistedShadowClasses::Foo"
+    assert_equal Sub::Foo.map_java_class.name, "Java::OrgRubyhazePersistedShadowClassesSub::Foo"
   end
 
 end
@@ -68,13 +66,14 @@ class TestRubyHazePersistedStorage < Test::Unit::TestCase
     assert_equal res.first, @a
     assert_equal res.first.name, @a.name
 
+#    # Throws an internal exception
 #    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 '%o'"
+    res = Foo.find "age < 60 AND name LIKE '%ae%'"
     assert_equal res.size, 1
     assert_equal res.first, @c
     assert_equal res.first.name, @c.name

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
     - 0
     - 0
-    - 1
-  version: 0.0.1
+    - 3
+  version: 0.0.3
 platform: jruby
 authors: 
   - Adrian Madrid
@@ -14,23 +14,67 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-30 00:00:00 -06:00
+date: 2010-09-08 00:00:00 -06:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
-    name: bitescript
+    name: rubyhaze
     prerelease: false
     requirement: &id001 !ruby/object:Gem::Requirement 
       requirements: 
-        - - ">="
+        - - ~>
           - !ruby/object:Gem::Version 
             segments: 
               - 0
-            version: "0"
+              - 0
+              - 6
+            version: 0.0.6
     type: :runtime
     version_requirements: *id001
-description: Have your distributed Ruby objects and search them too.
-email: aemadrid@alliancehealth.com
+  - !ruby/object:Gem::Dependency 
+    name: bitescript
+    prerelease: false
+    requirement: &id002 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - "="
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 0
+              - 0
+              - 6
+            version: 0.0.6
+    type: :runtime
+    version_requirements: *id002
+  - !ruby/object:Gem::Dependency 
+    name: activesupport
+    prerelease: false
+    requirement: &id003 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ~>
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 3
+              - 0
+              - 0
+            version: 3.0.0
+    type: :runtime
+    version_requirements: *id003
+  - !ruby/object:Gem::Dependency 
+    name: activemodel
+    prerelease: false
+    requirement: &id004 !ruby/object:Gem::Requirement 
+      requirements: 
+        - - ~>
+          - !ruby/object:Gem::Version 
+            segments: 
+              - 3
+              - 0
+              - 0
+            version: 3.0.0
+    type: :runtime
+    version_requirements: *id004
+description: Have your in-mempry distributed JRuby objects and search them too.
+email: aemadrid@gmail.com
 executables: []
 
 extensions: []
@@ -43,6 +87,7 @@ files:
   - README.rdoc
   - Rakefile
   - VERSION
+  - lib/rubyhaze-persisted.rb
   - lib/rubyhaze/persisted.rb
   - lib/rubyhaze/persisted/model.rb
   - lib/rubyhaze/persisted/shadow_class_generator.rb