neo4j 1.0.0.beta.20 → 3.0.0.alpha.2

data/lib/neo4j.rb

@@ -1,70 +1,30 @@
-include Java
-
-require 'enumerator'
-require 'forwardable'
-require 'time'
-require 'date'
-
-require 'neo4j/jars/neo4j-index-1.2-1.2.M03.jar'
-require 'neo4j/jars/neo4j-kernel-1.2-1.2.M03.jar'
-require 'neo4j/jars/neo4j-lucene-index-0.2-1.2.M03.jar'
-require 'neo4j/jars/geronimo-jta_1.1_spec-1.1.1.jar'
-require 'neo4j/jars/lucene-core-3.0.2.jar'
-require 'neo4j/to_java'
 require 'neo4j/version'
-require 'neo4j/equal'
-
-require 'neo4j/event_handler'
-require 'neo4j/database'
-require 'neo4j/neo4j'
-
-require 'neo4j/index/index'
-require 'neo4j/index/class_methods'
-require 'neo4j/index/indexer_registry'
-require 'neo4j/index/indexer'
-require 'neo4j/index/lucene_query'
-require 'neo4j/relationship_traverser'
-require 'neo4j/node_traverser'
-require 'neo4j/property'
-require 'neo4j/transaction'
-require 'neo4j/node_relationship'
-require 'neo4j/load'
-require 'neo4j/relationship'
-require 'neo4j/node'
-require 'neo4j/config'
-require 'neo4j/type_converters'
-require 'neo4j/mapping/class_methods/init_node'
-require 'neo4j/mapping/class_methods/init_rel'
-require 'neo4j/mapping/class_methods/root'
-require 'neo4j/mapping/class_methods/property'
-require 'neo4j/mapping/class_methods/relationship'
-require 'neo4j/mapping/decl_relationship_dsl'
-require 'neo4j/mapping/has_n'
-require 'neo4j/mapping/node_mixin'
-require 'neo4j/mapping/relationship_mixin'
-require 'neo4j/node_mixin'
-require 'neo4j/relationship_mixin'
-require 'neo4j/mapping/class_methods/rule'
-
-# rails
-require 'rails/railtie'
-require 'active_model'
-require 'neo4j/rails/tx_methods'
-require 'neo4j/rails/transaction'
-require 'neo4j/rails/railtie'
-require 'neo4j/rails/validations/uniqueness'
-require 'neo4j/rails/validations/non_nil'
-require 'neo4j/rails/finders'
-require 'neo4j/rails/mapping/property'
-require 'neo4j/rails/model'
-require 'neo4j/rails/value_properties'
-require 'neo4j/rails/value'
-require 'neo4j/rails/lucene_connection_closer'
-
-require 'neo4j/model'
-
-
-
-# hmm, looks like Enumerator have been moved in some ruby versions
-Enumerator = Enumerable::Enumerator unless defined? Enumerator
 
+#require "delegate"
+#require "time"
+#require "set"
+#
+#require "active_support/core_ext"
+#require "active_support/json"
+#require "active_support/inflector"
+#require "active_support/time_with_zone"
+
+require "neo4j-core"
+require "active_model"
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute.rb'
+
+require 'active_attr'
+require 'neo4j/wrapper'
+require "neo4j/active_node/labels"
+require 'neo4j/active_node/identity'
+require 'neo4j/active_node/callbacks'
+require 'neo4j/active_node/initialize'
+require 'neo4j/active_node/property'
+require 'neo4j/active_node/persistence'
+require 'neo4j/active_node/validations'
+require 'neo4j/active_node/rels'
+require 'neo4j/active_node/has_n'
+require 'neo4j/active_node/has_n/decl_rel'
+require 'neo4j/active_node/has_n/nodes'
+require 'neo4j/active_node'

data/lib/neo4j/active_node.rb

@@ -0,0 +1,60 @@
+module Neo4j
+
+  # Makes Neo4j nodes and relationships behave like active record objects.
+  # By including this module in your class it will create a mapping for the node to your ruby class
+  # by using a Neo4j Label with the same name as the class. When the node is loaded from the database it
+  # will check if there is a ruby class for the labels it has.
+  # If there Ruby class with the same name as the label then the Neo4j node will be wrapped
+  # in a new object of that class.
+  #
+  # = ClassMethods
+  # * {Neo4j::ActiveNode::Labels::ClassMethods} defines methods like: <tt>index</tt> and <tt>find</tt>
+  # * {Neo4j::ActiveNode::Persistence::ClassMethods} defines methods like: <tt>create</tt> and <tt>create!</tt>
+  # * {Neo4j::ActiveNode::Property::ClassMethods} defines methods like: <tt>property</tt>.
+  #
+  # @example Create a Ruby wrapper for a Neo4j Node
+  #   class Company
+  #      include Neo4j::ActiveNode
+  #      property :name
+  #   end
+  #   company = Company.new
+  #   company.name = 'My Company AB'
+  #   Company.save
+  #
+  module ActiveNode
+    extend ActiveSupport::Concern
+    extend ActiveModel::Naming
+
+    include ActiveModel::Conversion
+    include ActiveModel::Serializers::Xml
+    include ActiveModel::Serializers::JSON
+    include Neo4j::ActiveNode::Initialize
+    include Neo4j::ActiveNode::Identity
+    include Neo4j::ActiveNode::Persistence
+    include Neo4j::ActiveNode::Property
+    include Neo4j::ActiveNode::Labels
+    include Neo4j::ActiveNode::Callbacks
+    include Neo4j::ActiveNode::Validations
+    include Neo4j::ActiveNode::Rels
+    include Neo4j::ActiveNode::HasN
+
+    def wrapper
+      self
+    end
+
+    def neo4j_obj
+      _persisted_node || raise("Tried to access native neo4j object on a none persisted object")
+    end
+
+
+    included do
+      def self.inherited(other)
+        attributes.each_pair do |k,v|
+          other.attributes[k] = v
+        end
+        Neo4j::ActiveNode::Labels.add_wrapped_class(other)
+        super
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/callbacks.rb

@@ -0,0 +1,41 @@
+module Neo4j
+  module ActiveNode
+    module Callbacks #:nodoc:
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        include ActiveModel::Callbacks
+      end
+
+      included do
+        include ActiveModel::Validations::Callbacks
+
+        define_model_callbacks :initialize, :find, :only => :after
+        define_model_callbacks :save, :create, :update, :destroy
+      end
+
+      def destroy #:nodoc:
+        run_callbacks(:destroy) { super }
+      end
+
+      def touch(*) #:nodoc:
+        run_callbacks(:touch) { super }
+      end
+
+      private
+
+      def create_or_update #:nodoc:
+        run_callbacks(:save) { super }
+      end
+
+      def create_model #:nodoc:
+        run_callbacks(:create) { super }
+      end
+
+      def update_model(*) #:nodoc:
+        run_callbacks(:update) { super }
+      end
+    end
+
+  end
+end

data/lib/neo4j/active_node/has_n.rb

@@ -0,0 +1,138 @@
+module Neo4j::ActiveNode
+  module HasN
+    extend ActiveSupport::Concern
+
+    def _decl_rels_for(rel_type)
+      self.class._decl_rels[rel_type]
+    end
+
+    module ClassMethods
+
+      def _decl_rels
+        @_decl_rels ||= {}
+      end
+
+      # make sure the inherited classes inherit the <tt>_decl_rels</tt> hash
+      def inherited(klass)
+        copy = _decl_rels.clone
+        copy.each_pair { |k, v| copy[k] = v.inherit_new }
+        klass.instance_variable_set(:@_decl_rels, copy)
+        super
+      end
+
+
+      # Specifies a relationship between two node active node classes.
+      # Generates assignment and accessor methods for the given relationship.
+      # Both incoming and outgoing relationships can be declared, see {Neo4j::ActiveNode::HasN::DeclRel}
+      #
+      # @example has_n(:files)
+      #
+      #   class FolderNode
+      #      include Neo4j::ActiveNode
+      #      has_n(:files)
+      #   end
+      #
+      #   folder = FolderNode.new
+      #   folder.files << Neo4j::Node.new << Neo4j::Node.new
+      #   folder.files.inject {...}
+      #
+      #   FolderNode.files #=> 'files' the name of the relationship
+      #
+      # @example has_n(x).to(...)
+      #
+      #   # You can declare which class it has relationship to.
+      #   # The generated relationships will be prefixed with the name of that class.
+      #   class FolderNode
+      #      include Neo4j::ActiveNode
+      #      has_n(:files).to(File)
+      #      # Same as has_n(:files).to("File")
+      #   end
+      #
+      #   FolderNode.files #=> 'File#files' the name of the relationship
+      #
+      # @example has_n(x).from(class, has_n_name)
+      #
+      #   # generate accessor method for traversing and adding relationship on incoming nodes.
+      #   class FileNode
+      #      include Neo4j::ActiveNode
+      #      has_one(:folder).from(FolderNode.files)
+      #      # or same as
+      #      has_one(:folder).from(FolderNode, :files)
+      #   end
+      #
+      #
+      # @return [Neo4j::ActiveNode::HasN::DeclRel] a DSL object where the has_n relationship can be further specified
+      def has_n(rel_type)
+        clazz = self
+        module_eval(%Q{
+                def #{rel_type}()
+                    dsl = _decl_rels_for('#{rel_type}'.to_sym)
+                    Neo4j::ActiveNode::HasN::Nodes.new(self, dsl)
+                end}, __FILE__, __LINE__)
+
+
+        module_eval(%Q{
+                def #{rel_type}_rels
+                    dsl = _decl_rels_for('#{rel_type}'.to_sym)
+                    dsl.all_relationships(self)
+                end}, __FILE__, __LINE__)
+
+        instance_eval(%Q{
+          def #{rel_type}
+            _decl_rels[:#{rel_type}].rel_type
+          end}, __FILE__, __LINE__)
+
+        _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, false, clazz)
+      end
+
+
+      # Specifies a relationship between two node classes.
+      # Generates assignment and accessor methods for the given relationship
+      # Old relationship is deleted when a new relationship is assigned.
+      # Both incoming and outgoing relationships can be declared, see {Neo4j::Wrapper::HasN::DeclRel}
+      #
+      # @example
+      #
+      #   class FileNode
+      #      include Neo4j::ActiveNode
+      #      has_one(:folder)
+      #   end
+      #
+      #   file = FileNode.create
+      #   file.folder = Neo4j::Node.create
+      #   file.folder # => the node above
+      #   file.folder_rel # => the relationship object between those nodes
+      #
+      # @return [Neo4j::ActiveNode::HasN::DeclRel] a DSL object where the has_one relationship can be futher specified
+      def has_one(rel_type)
+        clazz = self
+        module_eval(%Q{def #{rel_type}=(value)
+                  dsl = _decl_rels_for(:#{rel_type})
+                  rel = dsl.single_relationship(self)
+                  rel && rel.del
+                  dsl.create_relationship_to(self, value) if value
+              end}, __FILE__, __LINE__)
+
+        module_eval(%Q{def #{rel_type}
+                  dsl = _decl_rels_for('#{rel_type}'.to_sym)
+                  dsl.single_node(self)
+              end}, __FILE__, __LINE__)
+
+        module_eval(%Q{def #{rel_type}_rel
+                  dsl = _decl_rels_for(:#{rel_type})
+                  dsl.single_relationship(self)
+               end}, __FILE__, __LINE__)
+
+        instance_eval(%Q{
+          def #{rel_type}
+            _decl_rels[:#{rel_type}].rel_type
+          end}, __FILE__, __LINE__)
+
+        _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, true, clazz)
+      end
+
+
+    end
+  end
+
+end

data/lib/neo4j/active_node/has_n/decl_rel.rb

@@ -0,0 +1,236 @@
+module Neo4j
+  module ActiveNode
+    module HasN
+
+
+      # A DSL for declared relationships has_n and has_one
+      # This DSL will be used to create accessor methods for relationships.
+      # Instead of using the 'raw' Neo4j::ActiveNode#rels method where one needs to know
+      # the name of relationship and direction one can use the generated accessor methods.
+      #
+      # @example
+      #
+      #   class Folder
+      #      include Neo4j::ActiveNode
+      #      property :name
+      #      # Declaring a Many relationship to any other node
+      #      has_n(:files)
+      #    end
+      #
+      #   class File
+      #     include Neo4j::ActiveNode
+      #     # declaring a incoming relationship from Folder's relationship files
+      #     has_one(:folder).from(Folder, :files)
+      #   end
+      #
+      # The following methods will be generated:
+      # <b>Folder#files</b> ::      returns an Enumerable of outgoing nodes for relationship 'files'
+      # <b>Folder#files_rels</b> :: returns an Enumerable of outgoing relationships for relationship 'files'
+      # <b>File#folder</b> ::       for adding one node for the relationship 'files' from the outgoing Folder node
+      # <b>File#folder_rel</b> ::   for accessing relationship 'files' from the outgoing Folder node
+      # <b>File#folder</b> ::       for accessing nodes from relationship 'files' from the outgoing Folder node
+      #
+      class DeclRel
+        attr_reader :source_class, :dir, :rel_type, :method_id
+
+        def initialize(method_id, has_one, source_class)
+          @method_id = method_id
+          @has_one = has_one
+          @dir = :outgoing
+          @rel_type = method_id.to_sym
+          @source_class = source_class
+        end
+
+        def inherit_new
+          base = self
+          dr = DeclRel.new(@method_id, @has_one, @source_class)
+          dr.instance_eval do
+            @dir = base.dir
+            @rel_type = base.rel_type
+            @target_name = base.target_name if base.target_name
+            @source_class = base.source_class
+          end
+          dr
+        end
+
+        def to_s
+          "DeclRel #{object_id} dir: #{@dir} rel_id: #{@method_id}, rel_type: #{@rel_type}, target_class:#{@target_name}"
+        end
+
+        # @return [true, false]
+        def has_one?
+          @has_one
+        end
+
+        # @return [true, false]
+        def has_n?
+          !@has_one
+        end
+
+        # @return [true,false]
+        def incoming? #:nodoc:
+          @dir == :incoming
+        end
+
+
+        # Declares an outgoing relationship type.
+        # It is possible to prefix relationship types so that it's possible to distinguish different incoming relationships.
+        # There is no validation that the added node is of the specified class.
+        #
+        # @example Example
+        #   class FolderNode
+        #     include Neo4j::ActiveNode
+        #     has_n(:files).to(FileNode)
+        #     has_one(:root).to("FileSystem") # also possible, if the class is not defined yet
+        #   end
+        #
+        #  folder = FolderNode.new
+        #  # generate a relationship between folder and file of type 'FileNode#files'
+        #  folder.files << FileNode.new
+        #
+        # @example relationship with a hash, user defined relationship
+        #
+        #   class FolderNode
+        #     include Neo4j::ActiveNode
+        #     has_n(:files).to('FolderNode#files')
+        #   end
+        #
+        # @example without prefix
+        #
+        #   class FolderNode
+        #     include Neo4j::ActiveNode
+        #     has_n(:files).to(:contains)
+        #   end
+        #
+        #   file = FileNode.new
+        #   # create an outgoing relationship of type 'contains' from folder node to file
+        #   folder.files << FolderNode.new
+        #
+        # @param [Class, String, Symbol] target the other class to which this relationship goes (if String or Class) or the relationship (if Symbol)
+        # @param [String, Symbol] rel_type the rel_type postfix for the relationships, which defaults to the same as the has_n/one method id
+        # @return self
+        def to(target, rel_type = @method_id)
+          @dir = :outgoing
+
+          case target
+            when /#/
+              @target_name, _ = target.to_s.split("#")
+              @rel_type = target.to_sym
+            when Class, String
+              @target_name = target.to_s
+              @rel_type = "#{@source_class}##{rel_type}".to_sym
+            when Symbol
+              @target_name = nil
+              @rel_type = target.to_sym
+            else
+              raise "Expected a class or a symbol for, got #{target}/#{target.class}"
+          end
+          self
+        end
+
+        # Specifies an incoming relationship.
+        # Will use the outgoing relationship given by the from class.
+        #
+        # @example with prefix FileNode
+        #   class FolderNode
+        #     include Neo4j::NodeMixin
+        #     has_n(:files).to(FileNode)
+        #   end
+        #
+        #   class FileNode
+        #     include Neo4j::NodeMixin
+        #     # will only traverse any incoming relationship of type files from node FileNode
+        #     has_one(:folder).from(FolderNode.files)
+        #     # alternative: has_one(:folder).from(FolderNode, :files) 
+        #   end
+        #
+        #   file = FileNode.new
+        #   # create an outgoing relationship of type 'FileNode#files' from folder node to file (FileNode is the prefix).
+        #   file.folder = FolderNode.new
+        #
+        # @example without prefix
+        #
+        #   class FolderNode
+        #     include Neo4j::NodeMixin
+        #     has_n(:files)
+        #   end
+        #
+        #   class FileNode
+        #     include Neo4j::NodeMixin
+        #     has_one(:folder).from(:files)  # will traverse any incoming relationship of type files
+        #   end
+        #
+        #   file = FileNode.new
+        #   # create an outgoing relationship of type 'files' from folder node to file
+        #   file.folder = FolderNode.new
+        #
+        #
+        def from(target, rel_type=@method_id)
+          @dir = :incoming
+
+          case target
+            when /#/
+              @target_name, _ = target.to_s.split("#")
+              @rel_type = target
+            when Class, String
+              @target_name = target.to_s
+              @rel_type = "#{@target_name}##{rel_type}".to_sym
+            when Symbol
+              @target_name = nil
+              @rel_type = target.to_sym
+            else
+              raise "Expected a class or a symbol for, got #{target}/#{target.class}"
+          end
+          self
+        end
+
+
+        # @private
+        def target_name
+          @target_name
+        end
+
+        def target_class
+          @target_name && @target_name.split("::").inject(Kernel) { |container, name| container.const_get(name.to_s) }
+        end
+
+
+        # @private
+        def each_node(node, &block)
+          node.nodes(dir: dir, type: rel_type).each { |n| block.call(n)}
+        end
+
+        def all_relationships(node)
+          # TODO fix ruby warning - warning: Enumerator.new without a block is deprecated; use Object#to_enum
+          Enumerator.new(self, :each_rel, node)
+        end
+
+        def each_rel(node, &block) #:nodoc:
+          node.rels(dir: dir, type: rel_type).each { |rel| block.call(rel) }
+        end
+
+        def single_relationship(node)
+          node.rel(dir: dir, type: rel_type)
+        end
+
+        def single_node(node)
+          node.node(dir: dir, type: rel_type)
+        end
+
+        # @private
+        def _each_node(node, &block) #:nodoc:
+          node._rels(dir: dir, type: rel_type).each do |rel|
+            block.call rel._other_node(node)
+          end
+        end
+
+        # @private
+        def create_relationship_to(node, other) # :nodoc:
+          from, to = incoming? ? [other, node] : [node, other]
+          from.create_rel(@rel_type, to)
+        end
+
+      end
+    end
+  end
+end