hprevalence 0.1.0

data/lib/transparent.rb

@@ -0,0 +1,218 @@
+
+module HPrevalence
+  
+  module Transparent
+    
+    module CustomBehavior
+      
+      def self.included(type)
+        class << type
+          def attr_proxy( *symbols )
+            @proxied_attributes ||= []
+            symbols.each do |symbol|
+              @proxied_attributes << symbol
+            end
+          end
+          
+          def attr_read_only( *symbols )
+            symbols.each do |symbol|
+              self.instance_eval {
+                @readonly_attributes ||= []
+                @readonly_attributes << symbol
+              }
+            end
+          end
+        end
+      end
+      
+      def _read_only_attributes()
+        self.class.instance_eval { @readonly_attributes ||= [] }
+      end
+
+      def _proxied_attributes()
+        self.class.instance_eval { @proxied_attributes ||= [] }
+      end
+      
+      def _should_proxy( symbol )
+        if _proxied_attributes().include?( symbol )
+          return true if _symbol2proxy(symbol).nil?
+        end
+        false
+      end
+      
+      def _symbol2proxy( symbol )
+        self.instance_eval { 
+          @symbol2proxy ||= {}
+          @symbol2proxy[symbol]
+        }
+      end
+
+      def _set_proxy( symbol, proxy )
+        self.instance_eval { 
+          @symbol2proxy ||= {}
+          @symbol2proxy[symbol] = proxy
+        }
+      end
+      
+    end
+    
+    class AutomaticCommand
+      
+      def initialize( proxy_id, symbol, *args )
+        @proxy_id, @symbol, @args = proxy_id, symbol, *args
+      end
+      
+      def execute(system)
+        TransparentEngine.current() { |engine|
+          proxy = engine.proxy_by_id(@proxy_id)
+          raise 'Could not obtain proxy' if proxy.nil? 
+          return proxy.send(@symbol, *arguments)
+        }
+      end
+      
+      protected
+      
+      def arguments()
+        @args ||= []
+      end
+      
+    end
+
+    class NestedAutomaticCommand < AutomaticCommand
+      
+      attr_reader :related_symbol, :parent_proxy_id
+      
+      def initialize( related_symbol, parent_proxy_id, proxy_id, symbol, *args )
+        super( proxy_id, symbol, *args )
+        raise 'Missing related_symbol' if related_symbol.nil?
+        raise 'Missing parent_proxy_id' if parent_proxy_id.nil?
+        @related_symbol, @parent_proxy_id = related_symbol, parent_proxy_id
+      end
+      
+      def execute(system)
+        TransparentEngine.current() { |engine|
+          proxy = engine.proxy_by_id(@proxy_id, @related_symbol, @parent_proxy_id)
+          raise 'Could not obtain proxy' if proxy.nil? 
+          return proxy.send(@symbol, *arguments)
+        }
+      end
+    end
+    
+    class TransparentProxy
+      attr_accessor :target, :proxy_id, :engine_id
+      
+      def initialize(target)
+        raise 'A proxy must have a target' if target.nil?
+        raise 'Strange. A proxy is supposed to exist within an engine' unless Thread.current[:engine]
+        @engine_id = Thread.current[:engine].engine_id
+        @proxy_id = Thread.current[:engine].register_proxy(self)
+        # puts  "New proxy with id #{@proxy_id.to_s} for #{target.class.to_s}"
+        @target = target
+        @is_custom = target.kind_of?(CustomBehavior)
+      end
+      
+      def method_missing(symbol, *args, &block)
+        # puts  "Sending #{symbol} to #{@target.to_s} args #{args.to_s}"
+        raise NoMethodError, "Undefined method" unless @target.respond_to?(symbol)
+        
+        if (@is_custom)
+          if (@target._read_only_attributes.include?(symbol) )
+            return @target.send(symbol, *args)
+          elsif (@target._should_proxy(symbol) )
+            return TransparentEngine.create_nested_proxy( @proxy_id, symbol, @engine_id )
+#            nested_target = @target.send(symbol, *args)
+#            return nil if nested_target.nil?
+#            TransparentEngine.within_engine( @engine_id ) { |engine|
+#              new_proxy = TransparentProxy.new( nested_target )
+#              @target._set_proxy( symbol, new_proxy )
+#              return new_proxy
+#            }
+          else
+            nested_proxy = @target._symbol2proxy(symbol)
+            # Returns the nested proxy associated with this symbol
+            # puts "Returning nested proxy for #{symbol} if #{nested_proxy.class.to_s}"
+            return nested_proxy unless nested_proxy.nil? 
+          end
+        end
+        
+        proceed(symbol, *args, &block)
+      end
+      
+      #       Custom marshalling - this adds the internal id (myid) and the system id to a marshall 
+      #       of the object we are the proxy for.
+      #       We take care to not marshal the same object twice, so circular references will work.
+      
+      def _dump(depth)
+        references = Thread.current[:references]
+        if (references)
+          if (references[self])
+            [@proxy_id.to_s, @engine_id.to_s].pack("A8A40")
+          else
+            references[self] = true
+            [@proxy_id.to_s, @engine_id.to_s].pack("A8A40") + Marshal.dump(@target, depth)
+          end
+        else
+          [@proxy_id.to_s, @engine_id.to_s].pack("A8A40")
+        end
+      end
+      
+      #       Custom marshalling - restore a Prox object.
+      
+      def TransparentProxy._load(buffer)
+        proxy = TransparentProxy.allocate
+        list = buffer.unpack("A8A40a*")
+        proxy.proxy_id = list[0].to_i
+        proxy.engine_id = Guid.from_s( list[1] )
+        TransparentEngine.current() { |engine|
+          proxy = engine.restore(proxy)
+          proxy.target = Marshal.load(list[2]) if (list[2] > "")
+        }
+        proxy
+      end   
+      
+      protected
+      
+      def build_command( symbol, *args )
+        AutomaticCommand.new( @proxy_id, symbol, *args )
+      end
+      
+      def proceed(symbol, *args, &block)
+        engine = TransparentEngine.current
+        result = nil
+        
+        if (engine.nil?)
+          # In this case the invocation happens on the object by user code
+          raise "Blocks are not supported... yet" if block_given?
+          
+          TransparentEngine.within_engine( @engine_id ) { |engine|
+            result = engine.execute_command( build_command(symbol, *args) )
+          }
+        else
+          # In this case the invocation is happening within an execute_command
+          result = @target.send(symbol, *args)
+        end
+        result 
+      end
+         
+    end
+
+    class NestedTransparentProxy < TransparentProxy
+      attr_reader :related_symbol, :parent_proxy_id
+      
+      def initialize(target, symbol, parent_proxy_id)
+        raise 'A nested-proxy must have a symbol' if symbol.nil?
+        super(target)
+        @related_symbol, @parent_proxy_id = symbol, parent_proxy_id
+      end
+
+      protected 
+      
+      def build_command( symbol, *args )
+        NestedAutomaticCommand.new( @related_symbol, @parent_proxy_id, @proxy_id, symbol, *args )
+      end
+
+    end
+    
+  end
+  
+end

data/rake.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require_gem 'rake'
+
+RakeApp.new.run

data/rakefile.rb

@@ -0,0 +1,62 @@
+
+require 'rake'
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+#$VERBOSE = nil
+#require 'code_statistics'
+
+#task :default => [ :test_units, :test_functional, :appdoc, :stats ]
+desc "Run all the tests"
+task :default => [ :test_units, :package ]
+
+desc "Run the unit tests in test/unit"
+Rake::TestTask.new("test_units") { |t|
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+}
+
+PKG_VERSION = '0.1.0'
+PKG_FILES = FileList['README', './**/*.rb'] 
+
+spec = Gem::Specification.new do |s|
+  s.name = 'hprevalence'
+  s.version = PKG_VERSION
+  s.summary = "Ruby based prevalence engine."
+  s.description = <<-EOF
+      HPrevalence is an prevalence engine for Ruby
+      which aims to provide non-intrusive capabilities to 
+      prevalent object models. 
+    EOF
+  #
+  s.files = PKG_FILES.to_a
+  #
+  s.require_path = 'lib'
+  s.autorequire = 'hprevalence'
+  #
+  s.has_rdoc = false
+  #
+  s.author = "Hamilton Verissimo"
+  s.email = "hammett@apache.org"
+  s.homepage = "http://www.digitalcraftsmen.com.br/~hammett"
+  s.rubyforge_project = "hprevalence"
+end
+
+desc "Creates the gem package for hprevalence"
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+desc "Generate documentation for the application"
+Rake::RDocTask.new("appdoc") { |rdoc|
+  rdoc.rdoc_dir = 'doc/app'
+  rdoc.title    = ""
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include('doc/README_FOR_APP')
+  rdoc.rdoc_files.include('**/*.rb')
+}
+

data/test/abstract_hprevalence_testcase.rb

@@ -0,0 +1,26 @@
+
+module AbstractHPrevalenceTestHelper
+  
+  def reset_dir( dir )
+    begin
+      current_dir = File.dirname(__FILE__)
+      @target_dir = File.join( current_dir, dir )
+      if File.exist?( @target_dir )
+        Dir.entries( @target_dir ).each do |file|
+          File.delete( File.join(@target_dir,file) ) unless File.directory?( file )
+        end
+      end
+      Dir.rmdir( @target_dir )
+    rescue
+#      puts 'could not reset dir ' + $!
+    end
+  end
+
+  def ensure_dir( dir = @target_dir )
+    begin
+      Dir.mkdir( dir )
+    rescue
+    end
+  end
+
+end

data/test/command_logger_test.rb

@@ -0,0 +1,39 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'internal/command_logger'
+require 'internal/iomanager'
+require 'abstract_hprevalence_testcase'
+require 'test/unit'
+
+class CommandLoggerTest < Test::Unit::TestCase
+  include AbstractHPrevalenceTestHelper
+  
+  def setup
+    reset_dir 'store/file_command_test'
+
+    @fc = CommandLogger.new( FileIOManager.new( @target_dir ) )    
+  end
+  
+  def test_available_logs
+    assert_equal 0, @fc.log_files.length
+    
+    ensure_dir
+    
+    assert_equal 0, @fc.log_files.length
+  end
+  
+  def test_new_log
+    ensure_dir
+    assert_equal 0, @fc.log_files.length
+    
+    command_store = @fc.create_command_store
+    assert_equal 1, @fc.log_files.length
+    assert_equal File.join(@target_dir, '000000000001.commandlog'), @fc.current_file_name
+    
+    command_store = @fc.create_command_store
+    assert_equal 2, @fc.log_files.length
+    assert_equal File.join(@target_dir, '000000000002.commandlog'), @fc.current_file_name
+  end
+  
+end
+

data/test/default_model_serializer_test.rb

@@ -0,0 +1,65 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'internal/iomanager'
+require 'internal/serializer'
+require 'abstract_hprevalence_testcase'
+require 'test/unit'
+require 'task_model'
+
+class DefaultModelSerializerTest < Test::Unit::TestCase
+  include AbstractHPrevalenceTestHelper
+  
+  def setup
+    reset_dir 'store/default_model_serializer'
+    ensure_dir 
+    
+    @serializer = DefaultModelSerializer.new( FileIOManager.new( @target_dir ) )
+  end
+  
+  def test_dump_and_load
+    
+    db = TaskDatabase.new()
+    db.add_task( Task.new( 'one', 'yada yada yada' ) )
+    db.add_task( Task.new( 'two', 'yada yada yada' ) )
+    db.add_task( Task.new( 'three', 'yada yada yada' ) )
+    db.priority_task = db.tasks[0]
+    
+    @serializer.dump( db )
+    db = @serializer.load
+    
+    assert_equal 3, db.tasks.length
+    assert_equal db.priority_task.id, db.tasks[0].id
+    
+    db.priority_task.contents = 'new content'
+
+    @serializer.dump( db )
+    db = @serializer.load
+
+    assert_equal db.priority_task.id, db.tasks[0].id
+    assert_equal db.priority_task.contents, db.tasks[0].contents
+    
+  end
+
+  def test_multiple_snapshots
+    
+    db = TaskDatabase.new()
+    db.add_task( Task.new( 'one', 'yada yada yada' ) )
+
+    @serializer.dump( db )
+
+    db.add_task( Task.new( 'two', 'yada yada yada' ) )
+
+    @serializer.dump( db )
+
+    db.add_task( Task.new( 'three', 'yada yada yada' ) )
+    
+    @serializer.dump( db )
+    
+    db = @serializer.load
+    
+    assert_equal 3, db.tasks.length
+    
+  end
+
+end
+

data/test/dvd_store_model.rb

@@ -0,0 +1,57 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'transparent'
+
+class DvdStore
+  include HPrevalence::Transparent::CustomBehavior
+  
+  attr_reader :available_items
+  attr_reader :available_categories
+  attr_reader :customers
+  
+  attr_proxy :available_items, :available_categories, :customers
+  attr_read_only :total_customers
+  
+  def initialize()
+    @available_items = []
+    @available_categories = []
+    @customers = []
+  end
+  
+  def total_customers
+    @customers.length
+  end
+  
+end
+
+class Category
+  attr_reader :name
+  
+  def initialize( name )
+    @name = name  
+  end
+
+end
+
+class Dvd
+  attr_accessor :name, :price, :categories
+  
+  def initialize( name, price, *categories )
+    @name, @price = name, price
+    @categories = *categories.dup()
+  end
+  
+end
+
+class Customer
+  attr_accessor :name, :items_bought, :prefered_categories
+  
+  def initialize( name )
+    @name = name
+    @items_bought = []
+    @prefered_categories = []
+  end
+  
+end
+
+

data/test/file_io_manager_test.rb

@@ -0,0 +1,129 @@
+$:.unshift(File.dirname(__FILE__) + "/../lib/")
+
+require 'internal/iomanager'
+require 'abstract_hprevalence_testcase'
+require 'test/unit'
+
+class FileIOManagerTest < Test::Unit::TestCase
+  include AbstractHPrevalenceTestHelper
+  
+  def setup
+    reset_dir 'store/file_io_manager_test'
+    ensure_dir 
+    
+    @filemanager = FileIOManager.new( @target_dir )
+  end
+
+  def test_create_new_stream
+    
+    output = @filemanager.create_new_stream( 'test_extension' )
+    assert_not_nil output
+    assert_equal '000000000001.test_extension', output.basename
+
+    output.puts 'Testing'
+    output.close
+
+  end
+
+  def test_create_new_stream_twice
+    
+    output1 = @filemanager.create_new_stream( 'test_extension' )
+    assert_not_nil output1
+    output2 = @filemanager.create_new_stream( 'test_extension' )
+    assert_not_nil output2
+
+    assert_equal '000000000001.test_extension', output1.basename
+    assert_equal '000000000002.test_extension', output2.basename
+    
+    output1.close
+    output2.close
+    
+  end
+
+  def test_list_simple_situation
+
+    @filemanager.create_new_stream( 'test' ).close
+    @filemanager.create_new_stream( 'test' ).close
+    @filemanager.create_new_stream( 'test' ).close
+    
+    files = @filemanager.list( 'test' )
+    
+    assert_not_nil files
+    assert_equal 3, files.length
+    
+    assert_equal '000000000001.test', files[0]
+    assert_equal '000000000002.test', files[1]
+    assert_equal '000000000003.test', files[2]
+    
+  end
+
+  def test_list_not_so_simple_situation
+
+    @filemanager.create_new_stream( 'test' ).close
+    @filemanager.create_new_stream( 'test' ).close
+    @filemanager.create_new_stream( 'test' ).close
+    @filemanager.create_new_stream( 'other' ).close
+    @filemanager.create_new_stream( 'other' ).close
+    
+    files = @filemanager.list( 'test' )
+    
+    assert_not_nil files
+    assert_equal 3, files.length
+    
+    assert_equal '000000000001.test', files[0]
+    assert_equal '000000000002.test', files[1]
+    assert_equal '000000000003.test', files[2]
+
+    files = @filemanager.list( 'other' )
+    
+    assert_not_nil files
+    assert_equal 2, files.length
+    
+    assert_equal '000000000001.other', files[0]
+    assert_equal '000000000002.other', files[1]
+    
+  end
+
+  def test_obtain_ordered_read_streams
+
+    output = @filemanager.create_new_stream( 'test' )
+    output.puts 'Testing 1'
+    output.close
+
+    output = @filemanager.create_new_stream( 'test' )
+    output.puts 'Testing 2'
+    output.close
+
+    streams = @filemanager.obtain_ordered_read_streams( 'test' )
+    assert_not_nil streams
+    assert_equal 2, streams.length
+    
+    stream = streams[0]
+    assert_equal "Testing 1\n", stream.readline
+    stream.close
+    
+    stream = streams[1]
+    assert_equal "Testing 2\n", stream.readline
+    stream.close
+    
+  end
+  
+  def test_obtain_latest_read_stream
+    
+    output = @filemanager.create_new_stream( 'test' )
+    output.puts 'Testing 1'
+    output.close
+
+    output = @filemanager.create_new_stream( 'test' )
+    output.puts 'Testing 2'
+    output.close
+
+    stream = @filemanager.obtain_latest_read_stream( 'test' )
+    assert_not_nil stream
+    assert_equal "Testing 2\n", stream.readline
+    stream.close
+    
+  end
+    
+end
+