hyperactive 0.2.2 → 0.2.3

data/tests/list_test.rb

@@ -1,6 +1,14 @@
 
 require File.join(File.dirname(__FILE__), 'test_helper')
 
+class Collector
+  attr_accessor :es
+  def call(e)
+    @es ||= []
+    @es << e
+  end
+end
+
 class ListTest < Test::Unit::TestCase
   
   def setup
@@ -23,19 +31,69 @@ class ListTest < Test::Unit::TestCase
 
   def teardown
     @c.stop!
-    @c.persistence_provider.unlink
+    @c.persistence_provider.unlink!
     @c2.stop!
-    @c2.persistence_provider.unlink
+    @c2.persistence_provider.unlink!
     @tm.stop!
-    @tm.persistence_provider.unlink
-    Archipelago::Disco::MC.clear!
-    Hyperactive::Record::CAPTAIN.update_services!
-    assert_within(10) do
-      Hyperactive::Record::CAPTAIN.chests.empty?
-    end
-    assert_within(10) do
-      Hyperactive::Record::CAPTAIN.trannies.empty?
-    end
+    @tm.persistence_provider.unlink!
+  end
+
+  def test_clear
+    l = Hyperactive::List::Head.get_instance
+    l << (r = Hyperactive::Record::Bass.get_instance)
+    assert_equal(1, l.size)
+    assert_equal(r, l.first)
+    assert_equal(r, l.last)
+    l.clear!
+    assert_equal(0, l.size)
+    assert_equal(nil, l.first)
+    assert_equal(nil, l.last)
+  end
+
+  def test_destroy
+    l = Hyperactive::List::Head.get_instance
+    l << (r = Hyperactive::Record::Bass.get_instance)
+    r1 = l.first_element.record_id
+    r2 = l.record_id
+    l.destroy!
+    assert(!Hyperactive::Record::CAPTAIN.include?(r1))
+    assert(!Hyperactive::Record::CAPTAIN.include?(r2))
+  end
+
+  def test_each
+    l = Hyperactive::List::Head.get_instance
+    l << (r = Hyperactive::Record::Bass.get_instance)
+    l << (r2 = Hyperactive::Record::Bass.get_instance)
+    l << (r3 = Hyperactive::Record::Bass.get_instance)
+    c = Collector.new
+    l.t_each(c)
+    assert_equal(3, c.es.size)
+    assert(c.es.include?(r))
+    assert(c.es.include?(r2))
+    assert(c.es.include?(r3))
+  end
+
+  def test_unlink
+    l = Hyperactive::List::Head.get_instance
+    l << (r = Hyperactive::Record::Bass.get_instance)
+    l << (r2 = Hyperactive::Record::Bass.get_instance)
+    e = l.last_element
+    l << (r3 = Hyperactive::Record::Bass.get_instance)
+    assert_equal([r, r2, r3].sort, l.t_collect do |ec| ec end.sort)
+    l.unlink!(e)
+    assert_equal(2, l.size)
+    assert_equal(r, l.first)
+    assert_equal(r3, l.last)
+    assert_equal(r3, l.first_element.next.value)
+    l.unlink!(l.last_element)
+    assert_equal(1, l.size)
+    assert_equal(r, l.first)
+    assert_equal(r, l.last)
+    l.unlink!(l.first_element)
+    assert_equal(0, l.size)
+    assert_equal(nil, l.first)
+    assert_equal(nil, l.last)
+    assert_equal([], l.t_collect do |e| e end)
   end
 
   def test_push_unshift_pop_shift

data/tests/record_test.rb

@@ -3,7 +3,9 @@ require File.join(File.dirname(__FILE__), 'test_helper')
 
 class MyRecord < Hyperactive::Record::Bass
   attr_accessor :bajs
-
+  def initialize
+    @bajs = nil
+  end
   def self.save_hook(instance, &block)
     $BEFORE_SAVE += 1
     yield
@@ -54,19 +56,11 @@ class RecordTest < Test::Unit::TestCase
 
   def teardown
     @c.stop!
-    @c.persistence_provider.unlink
+    @c.persistence_provider.unlink!
     @c2.stop!
-    @c2.persistence_provider.unlink
+    @c2.persistence_provider.unlink!
     @tm.stop!
-    @tm.persistence_provider.unlink
-    Archipelago::Disco::MC.clear!
-    Hyperactive::Record::CAPTAIN.update_services!
-    assert_within(10) do
-      Hyperactive::Record::CAPTAIN.chests.empty?
-    end
-    assert_within(10) do
-      Hyperactive::Record::CAPTAIN.trannies.empty?
-    end
+    @tm.persistence_provider.unlink!
   end
 
   def test_index_find
@@ -82,18 +76,18 @@ class RecordTest < Test::Unit::TestCase
     r4 = MyRecord.get_instance
     r4.bajs = "beige"
 
-    assert_equal(Set.new([r2.record_id,r1.record_id]), Set.new(MyRecord.find_by_bajs("brunt").collect(Proc.new do |k,v|
-                                                                                                        v.record_id
-                                                                                                      end)))
-    assert_equal([r3.record_id], MyRecord.find_by_bajs("gult").collect(Proc.new do |k,v|
-                                                               v.record_id
-                                                             end))
+    assert_equal(Set.new([r2.record_id,r1.record_id]), Set.new(MyRecord.find_by_bajs("brunt").t_collect(Proc.new do |k,v|
+                                                                                                          v.record_id
+                                                                                                        end)))
+    assert_equal([r3.record_id], MyRecord.find_by_bajs("gult").t_collect(Proc.new do |k,v|
+                                                                           v.record_id
+                                                                         end))
     
-    r1.destroy
+    r1.destroy!
 
-    assert_equal([r2.record_id], MyRecord.find_by_bajs("brunt").collect(Proc.new do |k,v|
-                                                                          v.record_id
-                                                                        end))
+    assert_equal([r2.record_id], MyRecord.find_by_bajs("brunt").t_collect(Proc.new do |k,v|
+                                                                            v.record_id
+                                                                          end))
     
   end
 
@@ -115,22 +109,22 @@ class RecordTest < Test::Unit::TestCase
     r4 = MyRecord.get_instance
     r4.bajs = "beige"
 
-    assert_equal(Set.new([r2.record_id,r1.record_id]), Set.new(MyRecord.brunt.collect(Proc.new do |k,v|
+    assert_equal(Set.new([r2.record_id,r1.record_id]), Set.new(MyRecord.brunt.t_collect(Proc.new do |k,v|
                                                                                         v.record_id
                                                                                       end)))
-    assert_equal(Set.new([r3.record_id,r4.record_id]), Set.new(MyRecord.not_brunt.collect(Proc.new do |k,v|
+    assert_equal(Set.new([r3.record_id,r4.record_id]), Set.new(MyRecord.not_brunt.t_collect(Proc.new do |k,v|
                                                                                             v.record_id
                                                                                           end)))
     
-    r1.destroy
-    r2.destroy
-    r3.destroy
-    r4.destroy
+    r1.destroy!
+    r2.destroy!
+    r3.destroy!
+    r4.destroy!
 
-    assert_equal(Set.new, Set.new(MyRecord.brunt.collect(Proc.new do |k,v|
+    assert_equal(Set.new, Set.new(MyRecord.brunt.t_collect(Proc.new do |k,v|
                                                            v.record_id
                                                          end)))
-    assert_equal(Set.new, Set.new(MyRecord.not_brunt.collect(Proc.new do |k,v|
+    assert_equal(Set.new, Set.new(MyRecord.not_brunt.t_collect(Proc.new do |k,v|
                                                                v.record_id
                                                              end)))
   end
@@ -149,7 +143,7 @@ class RecordTest < Test::Unit::TestCase
     assert_equal("brunt", Hyperactive::Record::CAPTAIN[r.record_id].bajs)
     i = r.record_id
     assert_equal(r, Hyperactive::Record::CAPTAIN[i])
-    r.destroy
+    r.destroy!
     assert_equal(1, $BEFORE_DESTROY)
     assert_equal(1, $AFTER_DESTROY)
     assert_equal(nil, Hyperactive::Record::CAPTAIN[i])

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: hyperactive
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
-date: 2006-11-28 00:00:00 +01:00
+  version: 0.2.3
+date: 2006-11-29 00:00:00 +01:00
 summary: A base class for persistent objects that uses archipelago for persistence. Useful for Ruby on Rails models for example.
 require_paths: 
 - lib
@@ -29,21 +29,22 @@ authors:
 - Martin Kihlgren
 files: 
 - lib/hyperactive.rb
+- lib/hyperactive/hash.rb
 - lib/hyperactive/hooker.rb
 - lib/hyperactive/list.rb
 - lib/hyperactive/record.rb
-- lib/hyperactive/tree.rb
+- tests/hash_benchmark.rb
+- tests/hash_test.rb
+- tests/list_benchmark.rb
 - tests/list_test.rb
 - tests/record_test.rb
 - tests/test_helper.rb
-- tests/tree_benchmark.rb
-- tests/tree_test.rb
 - GPL-2
 - README
 test_files: 
+- tests/hash_test.rb
 - tests/list_test.rb
 - tests/record_test.rb
-- tests/tree_test.rb
 - tests/test_helper.rb
 rdoc_options: 
 - --line-numbers

data/lib/hyperactive/tree.rb

@@ -1,241 +0,0 @@
-# Archipelago - a distributed computing toolkit for ruby
-# Copyright (C) 2006  Martin Kihlgren <zond at troja dot ath dot cx>
-#
-# This program is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License
-# as published by the Free Software Foundation; either version 2
-# of the License, or (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
-
-
-require 'rubygems'
-require 'archipelago'
-require 'rbtree'
-
-module Hyperactive
-
-  #
-  # The package containing the Hash-like Tree class that provides any
-  # kind of index for your Hyperactive classes.
-  #
-  module Tree
-
-    #
-    # A class suitable for storing large and often-changing datasets in 
-    # an Archipelago environment.
-    #
-    # Is constructed like a set of nested Hashes that automatically create
-    # new children on demand, and will thusly only have to check the path from
-    # the root node to the leaf for changes when method calls return (see Archipelago::Treasure::Chest)
-    # and will only have to actually store into database the leaf itself if it
-    # has changed.
-    #
-    class Root < Hyperactive::Record::Bass
-
-      attr_accessor :elements, :subtrees
-
-      WIDTH = 1 << 3
-
-      #
-      # Dont call this! Call <i>Root.get_instance(options)</i> instead!
-      #
-      def initialize(options = {})
-        @width = options[:width] || WIDTH
-        @elements = {}
-        @subtrees = nil
-      end
-      
-      #
-      # Deletes +key+ in this Root.
-      #
-      def delete(key)
-        if @elements
-          @elements.delete(key)
-        else
-          subtree_for(key).delete(key)
-        end
-      end
-
-      #
-      # Returns the size of this Root.
-      #
-      def size
-        if @elements
-          @elements.size
-        else
-          @subtrees.t_collect do |tree_id, tree|
-            tree.size
-          end.inject(0) do |sum, size|
-            sum + size
-          end
-        end
-      end
-      
-      #
-      # Returns all keys and values returning true for +callable+.call(key, value) in this Root.
-      #
-      def select(callable)
-        if @elements
-          @elements.select do |k,v|
-            callable.call(k,v)
-          end
-        else
-          @subtrees.t_collect do |tree_id, tree|
-            tree.select(callable)
-          end.inject([]) do |sum, match|
-            sum + match
-          end
-        end
-      end
-
-      #
-      # Returns all keys and values returning false for +callable+.call(key, value) in this Root.
-      #
-      def reject(callable)
-        if @elements
-          @elements.reject do |k,v|
-            callable.call(k,v)
-          end
-        else
-          @subtrees.t_collect do |tree_id, tree|
-            tree.reject(callable)
-          end.inject([]) do |sum, match|
-            sum + match
-          end
-        end
-      end
-
-      #
-      # Puts +value+ under +key+ in this Root.
-      #
-      def []=(key, value)
-        if @elements
-          if @elements.size < @width
-            @elements[key] = value
-          else
-            split!
-            subtree_for(key)[key] = value
-          end
-        else
-          subtree_for(key)[key] = value
-        end
-        return value
-      end
-
-      #
-      # Returns the value for +key+ in this Root.
-      #
-      def [](key)
-        if @elements
-          return @elements[key]
-        else
-          return subtree_for(key)[key]
-        end
-      end
-
-      #
-      # Returns an Array containing +callable+.call(key, value) from all values in this Root.
-      #
-      def collect(callable)
-        rval = []
-        self.each(Proc.new do |k,v|
-                    rval << callable.call(k,v)
-                  end)
-        return rval
-      end
-
-      #
-      # Does +callable+.call(key, value) on all values in this Root.
-      #
-      def each(callable)
-        if @elements
-          @elements.each do |key, value|
-            callable.call(key, value)
-          end
-        else
-          @subtrees.t_each do |tree_id, tree|
-            tree.each(callable)
-          end
-          nil
-        end
-      end
-
-      #
-      # Clear everything from this Tree and destroy it.
-      #
-      def destroy
-        if @elements
-          @elements.each do |key, value|
-            value.destroy if value.respond_to?(:destroy)
-          end
-        else
-          @subtrees.each do |tree_id, tree|
-            tree.destroy
-          end
-        end
-        freeze
-        super
-      end
-
-      #
-      # Clear everything from this Root.
-      #
-      def clear
-        unless @elements
-          @subtrees.each do |tree_id, tree|
-            tree.clear
-          end
-          @subtrees = nil
-        end
-        @elements = {}
-      end
-
-      private
-
-      #
-      # Finds the subtree responsible for +key+.
-      #
-      # Does it in this ugly way cause the nice way of just doing modulo gave
-      # really odd results since all hashes seem to give some modulo values
-      # a lot more often than expected.
-      #
-      def subtree_for(key)
-        key_id = Digest::SHA1.new("#{key.hash}#{self.record_id}").to_s
-        @subtrees.each do |tree_id, tree|
-          return tree if tree_id > key_id
-        end
-        return @subtrees.values.first
-      end
-
-      #
-      # Split this Tree by creating @subtrees,
-      # then putting all @elements in them and then emptying @elements.
-      #
-      def split!
-        raise "Cant split twice!" unless @elements
-
-        @subtrees = RBTree.new
-        @subtrees.extend(Archipelago::Current::ThreadedCollection)
-        step = (1 << 160) / @width
-        0.upto(@width - 1) do |n|
-          @subtrees["%x" % (n * step)] = Root.get_instance(:width => @width)
-        end
-        @elements.each do |key, value|
-          subtree_for(key)[key] = value
-        end
-        @elements = nil
-      end
-
-    end
-
-  end
-
-end