neo4j-wrapper 0.0.1-java

data/lib/neo4j-wrapper/rule/rule_node.rb

@@ -0,0 +1,205 @@
+module Neo4j
+  module Wrapper
+    module Rule
+
+      # This is the node that has relationships to all nodes of a given class.
+      # For example if the PersonNode has a rule then it will also have one RuleNode
+      # from where it will create relationships to each created node of type PersonNode.
+      # The RuleNode can also be used to hold properties for functions, like sum and count.
+      #
+      class RuleNode
+        include Neo4j::Core::ToJava
+        attr_reader :rules
+        attr_reader :model_class
+        @@rule_nodes = {}
+
+        def initialize(clazz)
+          classname = clazz.to_s
+          @model_class = Neo4j::Wrapper.to_class(classname)
+          @classname = clazz
+          @rules = []
+          @ref_node_key = ("rule_ref_for_" + clazz.to_s).to_sym
+        end
+
+        def to_s
+          "RuleNode #{@classname}, @@rule_nodes #{@@rule_nodes.size} #rules: #{@rules.size}"
+        end
+
+        def rule_node
+          ref_node._java_node.synchronized do
+            @@rule_nodes[key] ||= find_node || create_node
+          end
+        end
+
+        def rule_node?(node)
+          @@rule_nodes[key] == node
+        end
+
+        def key
+          "#{ref_node.neo_id}#{@ref_node_key}".to_sym
+        end
+
+        def ref_node
+          if @model_class.respond_to? :ref_node_for_class
+            @model_class.ref_node_for_class
+          else
+            Neo4j.ref_node
+          end
+        end
+
+        def create_node
+          Neo4j::Transaction.run do
+            node = Neo4j::Node.new
+            ref_node.create_relationship_to(node, type_to_java(@classname))
+            node
+          end
+        end
+
+        def inherit(subclass)
+          @rules.each do |rule|
+            subclass.rule rule.rule_name, rule.props, &rule.filter
+          end
+        end
+
+        def find_node
+          ref_node.rel?(:outgoing, @classname.to_s) && ref_node._node(:outgoing, @classname.to_s)
+        end
+
+        def ref_node_changed?
+          if ref_node != Thread.current[@ref_node_key]
+            Thread.current[@ref_node_key] = ref_node
+            true
+          else
+            false
+          end
+        end
+
+        def clear_rule_node
+          @@rule_nodes[key] = nil
+        end
+
+        def rule_names
+          @rules.map { |r| r.rule_name }
+        end
+
+        def find_rule(rule_name)
+          @rules.find { |rule| rule.rule_name == rule_name }
+        end
+
+        def add_rule(rule)
+          @rules << rule
+        end
+
+        def remove_rule(rule_name)
+          r = find_rule(rule_name)
+          r && @rules.delete(r)
+        end
+
+        # Return a traversal object with methods for each rule and function.
+        # E.g. Person.all.old or Person.all.sum(:age)
+        def traversal(rule_name)
+          traversal = rule_node.outgoing(rule_name)
+          @rules.each do |rule|
+            traversal.filter_method(rule.rule_name) do |path|
+              path.end_node.rel?(:incoming, rule.rule_name)
+            end
+            rule.functions && rule.functions.each do |func|
+              traversal.functions_method(func, self, rule_name)
+            end
+          end
+          traversal
+        end
+
+        def find_function(rule_name, function_name, function_id)
+          rule = find_rule(rule_name)
+          rule.find_function(function_name, function_id)
+        end
+
+        def execute_rules(node, *changes)
+          @rules.each do |rule|
+            execute_rule(rule, node, *changes)
+            execute_other_rules(rule, node)
+          end
+        end
+
+        def execute_other_rules(rule, node)
+          rule.triggers && rule.triggers.each do |rel_type|
+            node.incoming(rel_type).each { |n| n.trigger_rules }
+          end
+        end
+
+        def execute_rule(rule, node, *changes)
+          if rule.execute_filter(node)
+            if connected?(rule.rule_name, node)
+              # it was already connected - the node is in the same rule group but a property has changed
+              execute_update_functions(rule, *changes)
+            else
+              # the node has changed or is in a new rule group
+              connect(rule.rule_name, node)
+              execute_add_functions(rule, *changes)
+            end
+          else
+            if break_connection(rule.rule_name, node)
+              # the node has been removed from a rule group
+              execute_delete_functions(rule, *changes)
+            end
+          end
+        end
+
+        def execute_update_functions(rule, *changes)
+          if functions = find_functions_for_changes(rule, *changes)
+            functions && functions.each { |f| f.update(rule.rule_name, rule_node, changes[1], changes[2]) }
+          end
+        end
+
+        def execute_add_functions(rule, *changes)
+          if functions = find_functions_for_changes(rule, *changes)
+            functions && functions.each { |f| f.add(rule.rule_name, rule_node, changes[2]) }
+          end
+        end
+
+        def execute_delete_functions(rule, *changes)
+          if functions = find_functions_for_changes(rule, *changes)
+            functions.each { |f| f.delete(rule.rule_name, rule_node, changes[1]) }
+          end
+        end
+
+        def find_functions_for_changes(rule, *changes)
+          !changes.empty? && rule.functions_for(changes[0])
+        end
+
+        # work out if two nodes are connected by a particular relationship
+        # uses the end_node to start with because it's more likely to have less relationships to go through
+        # (just the number of superclasses it has really)
+        def connected?(rule_name, end_node)
+          end_node.nodes(:incoming, rule_name).find { |n| n == rule_node }
+        end
+
+        def connect(rule_name, end_node)
+          rule_node._java_node.create_relationship_to(end_node._java_node, type_to_java(rule_name))
+        end
+
+        # sever a direct one-to-one relationship if it exists
+        def break_connection(rule_name, end_node)
+          rel = end_node._rels(:incoming, rule_name).find { |r| r._start_node == rule_node }
+          rel && rel.del
+          !rel.nil?
+        end
+
+        def bulk_update?
+          @rules.size == 1 && @rules.first.bulk_update?
+        end
+
+        def classes_changed(total)
+          @rules.each do |rule|
+            if rule.bulk_update?
+              rule.functions.first.classes_changed(rule.rule_name, rule_node, total)
+              total.added.each { |node| connect(rule.rule_name, node) }
+              total.deleted.each { |node| break_connection(rule.rule_name, node) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j-wrapper/version.rb

@@ -0,0 +1,5 @@
+module Neo4j
+  module Wrapper
+    VERSION = '0.0.1'
+  end
+end

data/lib/neo4j-wrapper/wrapper.rb

@@ -0,0 +1,38 @@
+module Neo4j
+  module Wrapper
+
+    # This method is used when loading Neo4j::Node objects
+    #
+    # Reads the <tt>_classname</tt> property and tries to load the ruby class.
+    # The Neo4j::Core gem will use this method, because the following:
+    #  Neo4j::Node.wrapper_proc=method(:wrapper)
+    #
+    # @param [Neo4j::Node, Neo4j:Relationship] entity the entity which might be wrapped
+    # @return [Object] a Ruby class wrapping the given entity
+    # @see Neo4j::Core::Wrapper.wrapper_proc=
+    def wrapper(entity)
+      return entity unless entity.property?(:_classname)
+      existing_instance = Neo4j::IdentityMap.get(entity)
+      return existing_instance if existing_instance
+      new_instance = to_class(entity[:_classname])._load_wrapper(entity)
+      Neo4j::IdentityMap.add(entity, new_instance)
+      new_instance
+    end
+
+    # @param [String] class_name the name we want the Class for
+    # @return [Class] the class corresponding to the given name
+    def to_class(class_name)
+      class_name.split("::").inject(Kernel) { |container, name| container.const_get(name.to_s) }
+    end
+
+    extend self
+
+    Neo4j::Node.wrapper_proc=method(:wrapper)
+    Neo4j::Relationship.wrapper_proc=method(:wrapper)
+
+
+  end
+
+
+end
+

data/lib/neo4j-wrapper.rb

@@ -0,0 +1,35 @@
+require 'neo4j-core'
+
+require 'neo4j-wrapper/wrapper'
+require 'neo4j-wrapper/class_methods'
+require 'neo4j-wrapper/version'
+require 'neo4j-wrapper/node_mixin/delegates'
+require 'neo4j-wrapper/node_mixin/class_methods'
+require 'neo4j-wrapper/node_mixin/initialize'
+
+require 'neo4j-wrapper/properties/class_methods'
+
+require 'neo4j-wrapper/has_n/class_methods'
+require 'neo4j-wrapper/has_n/decl_rel'
+require 'neo4j-wrapper/has_n/nodes'
+require 'neo4j-wrapper/has_n/instance_methods'
+
+require 'neo4j-wrapper/relationship_mixin/class_methods'
+require 'neo4j-wrapper/relationship_mixin/initialize'
+require 'neo4j-wrapper/relationship_mixin/delegates'
+require 'neo4j-wrapper/find'
+
+require 'neo4j-wrapper/rule/neo4j_core_ext/traverser'
+require 'neo4j-wrapper/rule/class_methods'
+require 'neo4j-wrapper/rule/instance_methods'
+require 'neo4j-wrapper/rule/event_listener'
+require 'neo4j-wrapper/rule/rule'
+require 'neo4j-wrapper/rule/rule_node'
+require 'neo4j-wrapper/rule/functions/function'
+require 'neo4j-wrapper/rule/functions/count'
+require 'neo4j-wrapper/rule/functions/sum'
+
+require 'neo4j/type_converters/type_converters'
+require 'neo4j/node_mixin'
+require 'neo4j/relationship_mixin'
+require 'neo4j/identity_map'

data/lib/test.rb

@@ -0,0 +1,61 @@
+def calc(x)
+  x + 1
+end
+
+p = method(:calc)
+t = Time.now
+(0..10000).each { |x| calc(x) }
+total = Time.now - t
+puts "1. total = #{total}"
+
+#p = Proc.new {|x| x + 1}
+t = Time.now
+(0..10000).each { |x| p.call(x) }
+total = Time.now - t
+puts "2. total = #{total}"
+
+puts "================="
+t = Time.now
+(0..10000).each { |x| calc(x) }
+total = Time.now - t
+puts "1. total = #{total}"
+
+t = Time.now
+(0..10000).each { |x| p.call(x) }
+total = Time.now - t
+puts "2. total = #{total}"
+
+puts "================="
+t = Time.now
+(0..10000).each { |x| calc(x) }
+total = Time.now - t
+puts "1. total = #{total}"
+
+t = Time.now
+(0..10000).each { |x| p.call(x) }
+total = Time.now - t
+puts "2. total = #{total}"
+
+p = method(:calc).to_proc
+
+puts "================= TO PROC"
+t = Time.now
+(0..10000).each { |x| calc(x) }
+total = Time.now - t
+puts "1. total = #{total}"
+
+t = Time.now
+(0..10000).each { |x| p.call(x) }
+total = Time.now - t
+puts "2. total = #{total}"
+
+puts "================= TO PROC"
+t = Time.now
+(0..10000).each { |x| calc(x) }
+total = Time.now - t
+puts "1. total = #{total}"
+
+t = Time.now
+(0..10000).each { |x| p.call(x) }
+total = Time.now - t
+puts "2. total = #{total}"

data/neo4j-wrapper.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'neo4j-wrapper/version'
+
+Gem::Specification.new do |s|
+  s.name     = "neo4j-wrapper"
+  s.version  = Neo4j::Wrapper::VERSION
+  s.platform = 'java'
+  s.required_ruby_version = ">= 1.8.7"
+
+  s.authors  = "Andreas Ronge"
+  s.email    = 'andreas.ronge@gmail.com'
+  s.homepage = "http://github.com/andreasronge/neo4j-wrapper/tree"
+  s.rubyforge_project = 'neo4j-wrapper'
+  s.summary = "A graph database for JRuby"
+  s.description = <<-EOF
+You can think of Neo4j as a high-performance graph engine with all the features of a mature and robust database.
+The programmer works with an object-oriented, flexible network structure rather than with strict and static tables 
+yet enjoys all the benefits of a fully transactional, enterprise-strength database.
+It comes included with the Apache Lucene document database.
+  EOF
+
+  s.require_path = 'lib'
+  s.files = Dir.glob("{bin,lib,config}/**/*") + %w(README.rdoc Gemfile neo4j-wrapper.gemspec)
+  s.has_rdoc = true
+  s.extra_rdoc_files = %w( README.rdoc )
+  s.rdoc_options = ["--quiet", "--title", "Neo4j.rb", "--line-numbers", "--main", "README.rdoc", "--inline-source"]
+
+  s.add_dependency("neo4j-core", "0.0.6")
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification 
+name: neo4j-wrapper
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: java
+authors: 
+  - Andreas Ronge
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-03 00:00:00 Z
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: neo4j-core
+    prerelease: false
+    requirement: &id001 !ruby/object:Gem::Requirement 
+      none: false
+      requirements: 
+        - - "="
+          - !ruby/object:Gem::Version 
+            version: 0.0.6
+    type: :runtime
+    version_requirements: *id001
+description: |
+  You can think of Neo4j as a high-performance graph engine with all the features of a mature and robust database.
+  The programmer works with an object-oriented, flexible network structure rather than with strict and static tables 
+  yet enjoys all the benefits of a fully transactional, enterprise-strength database.
+  It comes included with the Apache Lucene document database.
+
+email: andreas.ronge@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - README.rdoc
+files: 
+  - lib/test.rb
+  - lib/neo4j-wrapper.rb
+  - lib/example.rb
+  - lib/neo4j-wrapper/find.rb
+  - lib/neo4j-wrapper/wrapper.rb
+  - lib/neo4j-wrapper/class_methods.rb
+  - lib/neo4j-wrapper/version.rb
+  - lib/neo4j-wrapper/relationship_mixin/initialize.rb
+  - lib/neo4j-wrapper/relationship_mixin/delegates.rb
+  - lib/neo4j-wrapper/relationship_mixin/class_methods.rb
+  - lib/neo4j-wrapper/properties/class_methods.rb
+  - lib/neo4j-wrapper/has_n/nodes.rb
+  - lib/neo4j-wrapper/has_n/instance_methods.rb
+  - lib/neo4j-wrapper/has_n/decl_rel.rb
+  - lib/neo4j-wrapper/has_n/class_methods.rb
+  - lib/neo4j-wrapper/node_mixin/initialize.rb
+  - lib/neo4j-wrapper/node_mixin/delegates.rb
+  - lib/neo4j-wrapper/node_mixin/class_methods.rb
+  - lib/neo4j-wrapper/rule/rule.rb
+  - lib/neo4j-wrapper/rule/rule_node.rb
+  - lib/neo4j-wrapper/rule/instance_methods.rb
+  - lib/neo4j-wrapper/rule/class_methods.rb
+  - lib/neo4j-wrapper/rule/event_listener.rb
+  - lib/neo4j-wrapper/rule/functions/function.rb
+  - lib/neo4j-wrapper/rule/functions/count.rb
+  - lib/neo4j-wrapper/rule/functions/sum.rb
+  - lib/neo4j-wrapper/rule/neo4j_core_ext/traverser.rb
+  - lib/neo4j/identity_map.rb
+  - lib/neo4j/node_mixin.rb
+  - lib/neo4j/relationship_mixin.rb
+  - lib/neo4j/type_converters/type_converters.rb
+  - lib/db/neostore.relationshiptypestore.db.names
+  - lib/db/neostore.id
+  - lib/db/neostore.relationshiptypestore.db.names.id
+  - lib/db/neostore.nodestore.db.id
+  - lib/db/neostore.propertystore.db.index
+  - lib/db/neostore.propertystore.db.strings.id
+  - lib/db/nioneo_logical.log.active
+  - lib/db/neostore.propertystore.db.strings
+  - lib/db/neostore.relationshiptypestore.db.id
+  - lib/db/neostore
+  - lib/db/neostore.nodestore.db
+  - lib/db/neostore.propertystore.db.index.keys.id
+  - lib/db/neostore.propertystore.db.arrays.id
+  - lib/db/messages.log
+  - lib/db/neostore.relationshipstore.db.id
+  - lib/db/neostore.propertystore.db.arrays
+  - lib/db/neostore.relationshipstore.db
+  - lib/db/neostore.propertystore.db.index.id
+  - lib/db/neostore.propertystore.db.id
+  - lib/db/index.db
+  - lib/db/neostore.propertystore.db
+  - lib/db/tm_tx_log.1
+  - lib/db/neostore.relationshiptypestore.db
+  - lib/db/active_tx_log
+  - lib/db/neostore.propertystore.db.index.keys
+  - lib/db/index/lucene-store.db
+  - lib/db/index/lucene.log.active
+  - lib/db/index/lucene/node/Person_exact/_1.prx
+  - lib/db/index/lucene/node/Person_exact/_1.tii
+  - lib/db/index/lucene/node/Person_exact/_0.fdx
+  - lib/db/index/lucene/node/Person_exact/segments.gen
+  - lib/db/index/lucene/node/Person_exact/_0.frq
+  - lib/db/index/lucene/node/Person_exact/_2.tii
+  - lib/db/index/lucene/node/Person_exact/_1.nrm
+  - lib/db/index/lucene/node/Person_exact/_0.nrm
+  - lib/db/index/lucene/node/Person_exact/_1.tis
+  - lib/db/index/lucene/node/Person_exact/_2.frq
+  - lib/db/index/lucene/node/Person_exact/_2.nrm
+  - lib/db/index/lucene/node/Person_exact/_2.fdt
+  - lib/db/index/lucene/node/Person_exact/_0.fdt
+  - lib/db/index/lucene/node/Person_exact/_0.tis
+  - lib/db/index/lucene/node/Person_exact/_1.fnm
+  - lib/db/index/lucene/node/Person_exact/_1.frq
+  - lib/db/index/lucene/node/Person_exact/_0.tii
+  - lib/db/index/lucene/node/Person_exact/_2.tis
+  - lib/db/index/lucene/node/Person_exact/_2.prx
+  - lib/db/index/lucene/node/Person_exact/_2.fdx
+  - lib/db/index/lucene/node/Person_exact/_0.prx
+  - lib/db/index/lucene/node/Person_exact/_2.fnm
+  - lib/db/index/lucene/node/Person_exact/_1.fdt
+  - lib/db/index/lucene/node/Person_exact/_0.fnm
+  - lib/db/index/lucene/node/Person_exact/_1.fdx
+  - lib/db/index/lucene/node/Person_exact/segments_3
+  - README.rdoc
+  - Gemfile
+  - neo4j-wrapper.gemspec
+homepage: http://github.com/andreasronge/neo4j-wrapper/tree
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --quiet
+  - --title
+  - Neo4j.rb
+  - --line-numbers
+  - --main
+  - README.rdoc
+  - --inline-source
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: neo4j-wrapper
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: A graph database for JRuby
+test_files: []
+
+has_rdoc: true