neo4j-wrapper 0.0.1-java

data/lib/neo4j-wrapper/find.rb

@@ -0,0 +1,65 @@
+module Neo4j
+  module Wrapper
+    module Find
+      Neo4j::Core::Index::ClassMethods.send(:alias_method, :_orig_find, :find)
+
+      # If the #ref_node_for_class returns an object implementing the method #_index_prefix it
+      # will use that as prefix, otherwise the empty string.
+      # @return [String] the prefix name of the index
+      def index_prefix
+        return "" unless Neo4j.running?
+        return "" unless respond_to?(:ref_node_for_class)
+        ref_node = ref_node_for_class.wrapper
+        prefix = ref_node.send(:index_prefix) if ref_node.respond_to?(:index_prefix)
+        prefix ? prefix + "_" : ""
+      end
+
+
+      # @return [String] the name of the index, with index prefix
+      def _index_name
+        to_s.gsub("::", '_')
+      end
+
+      # Fall back to the threadlocal ref node by default.
+      # You can set your own reference node using the #ref_node method
+      # @return [Neo4j::Node] returns the Neo4j.ref_node
+      def ref_node_for_class
+        Neo4j.ref_node
+      end
+
+      # Assigns the reference node for a class via a supplied block.
+      #
+      # @example of usage:
+      #   class Person
+      #     include Neo4j::NodeMixin
+      #     ref_node { Neo4j.default_ref_node }
+      #   end
+      #
+      def ref_node(&block)
+        singleton = class << self;
+          self;
+        end
+        singleton.send(:define_method, :ref_node_for_class) { block.call }
+      end
+
+      # Overrides the Neo4j::Core::Index::ClassMethods#find method to check
+      # if any of the query parameters needs to be converted, (e.g. DateTime to Fixnum)
+      #
+      # @example
+      #   Person.find(:since => (1.year.ago .. Time.now))
+      # @see http://rdoc.info/github/andreasronge/neo4j-core/Neo4j/Core/Index/Indexer#find-instance_method Neo4j::Core::Index::ClassMethods#find
+      def find(*query_params)
+        query = query_params.first
+        if query.is_a?(Hash)
+          query.each_pair do |k, v|
+            converter = _converter(k)
+            value = v.is_a?(Range) ? Range.new(converter.to_java(v.begin), converter.to_java(v.end), v.exclude_end?) : converter.to_java(v)
+            query[k] = value
+          end
+        end
+        _orig_find(*query_params)
+      end
+
+    end
+  end
+end

data/lib/neo4j-wrapper/has_n/class_methods.rb

@@ -0,0 +1,131 @@
+module Neo4j
+  module Wrapper
+    module HasN
+      module ClassMethods
+
+        # @return [Hash] a hash of all relationship and its configuration defined by has_n and has_one
+        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 classes.
+        # Generates assignment and accessor methods for the given relationship.
+        # Both incoming and outgoing relationships can be declared, see {Neo4j::Wrapper::HasN::DeclRel}
+        #
+        # @example has_n(:files)
+        #
+        #   class FolderNode
+        #      include Ne4j::NodeMixin
+        #      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 Ne4j::NodeMixin
+        #      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 Ne4j::NodeMixin
+        #      has_one(:folder).from(FolderNode, :files)
+        #   end
+        #
+        #
+        # @return [Neo4j::Wrapper::HasN::DeclRel] a DSL object where the has_n relationship can be futher specified
+        def has_n(rel_type)
+          clazz = self
+          module_eval(%Q{
+                def #{rel_type}
+                    dsl = _decl_rels_for('#{rel_type}'.to_sym)
+                    Neo4j::Wrapper::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.to_s
+          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 Ne4j::NodeMixin
+        #      has_one(:folder)
+        #   end
+        #
+        #   file = FileNode.new
+        #   file.folder = Neo4j::Node.new
+        #   file.folder # => the node above
+        #   file.folder_rel # => the relationship object between those nodes
+        #
+        # @return [Neo4j::Wrapper::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.del unless rel.nil?
+                  dsl.create_relationship_to(self, value) if value
+              end}, __FILE__, __LINE__)
+
+          module_eval(%Q{def #{rel_type}
+                  dsl = _decl_rels_for(:#{rel_type})
+                  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.to_s
+          end}, __FILE__, __LINE__)
+
+          _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, true, clazz)
+        end
+
+      end
+    end
+  end
+
+end

data/lib/neo4j-wrapper/has_n/decl_rel.rb

@@ -0,0 +1,261 @@
+module Neo4j
+  module Wrapper
+    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::NodeMixin#rels method where one needs to know
+      # the name of relationship and direction one can use the generated accessor methods.
+      #
+      # The DSL can also be used to specify a mapping to a Ruby class for a relationship, see Neo4j::HasN::DeclRelationshipDsl#relationship
+      #
+      # @example
+      #
+      #   class Folder
+      #      include Neo4j::NodeMixin
+      #      property :name
+      #      # Declaring a Many relationship to any other node
+      #      has_n(:files)
+      #    end
+      #
+      #   class File
+      #     include Neo4j::NodeMixin
+      #     # 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 :target_class, :source_class, :dir, :rel_type
+
+        def initialize(method_id, has_one, target_class)
+          @method_id = method_id
+          @has_one = has_one
+          @target_class = target_class
+          @dir = :outgoing
+          @rel_type = method_id.to_s
+          @source_class = target_class
+        end
+
+        def inherit_new
+          base = self
+          dr = DeclRel.new(@method_id, @has_one, @target_class)
+          dr.instance_eval do
+            @dir = base.dir
+            @rel_type = base.rel_type
+            @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_class} rel_class:#{@relationship}"
+        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
+
+
+        # Specifies an outgoing relationship.
+        # The name of the outgoing class will be used as a prefix for the relationship used.
+        #
+        # @example Example
+        #   class FolderNode
+        #     include Neo4j::NodeMixin
+        #     has_n(:files).to(FileNode)
+        #   end
+        #
+        #  folder = FolderNode.new
+        #  # generate a relationship between folder and file of type 'FileNode#files'
+        #  folder.files << FileNode.new
+        #
+        # @example without prefix
+        #
+        #   class FolderNode
+        #     include Neo4j::NodeMixin
+        #     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] target the other class to which this relationship goes
+        # @return self
+        def to(target)
+          @dir = :outgoing
+
+          if Class === target
+            # handle e.g. has_n(:friends).to(class)
+            @target_class = target
+            @rel_type = "#{@source_class}##{@method_id}"
+          elsif Symbol === target
+            # handle e.g. has_n(:friends).to(:knows)
+            @rel_type = target.to_s
+          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)
+        #   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(*args)
+          @dir = :incoming
+
+          if args.size > 1
+            # handle specified (prefixed) relationship, e.g. has_n(:known_by).from(clazz, :type)
+            @target_class = args[0]
+            @rel_type = "#{@target_class}##{args[1]}"
+            @relationship_name = args[1].to_sym
+          elsif Symbol === args[0]
+            # handle unspecified (unprefixed) relationship, e.g. has_n(:known_by).from(:type)
+            @rel_type = args[0].to_s
+          else
+            raise "Expected a symbol for, got #{args[0]}"
+          end
+          self
+        end
+
+        # Specifies which relationship ruby class to use for the relationship
+        #
+        # @example
+        #
+        #   class OrderLine
+        #     include Neo4j::RelationshipMixin
+        #     property :units
+        #     property :unit_price
+        #   end
+        #
+        #   class Order
+        #     property :total_cost
+        #     property :dispatched
+        #     has_n(:products).to(Product).relationship(OrderLine)
+        #   end
+        #
+        #  order = Order.new
+        #  order.products << Product.new
+        #  order.products_rels.first # => OrderLine
+        #
+        def relationship(rel_class)
+          @relationship = rel_class
+          self
+        end
+
+
+        # @private
+        def relationship_class # :nodoc:
+          if !@relationship_name.nil? && @relationship.nil?
+            other_class_dsl = @target_class._decl_rels[@relationship_name]
+            if other_class_dsl
+              @relationship = other_class_dsl.relationship_class
+            else
+              Neo4j.logger.warn "Unknown outgoing relationship #{@relationship_name} on #{@target_class}"
+            end
+          end
+          @relationship
+        end
+
+        # @private
+        def each_node(node, &block)
+          node.rels(dir, rel_type).each do |rel|
+            block.call(rel.other_node(node))
+          end
+        end
+
+        # @private
+        def _each_node(node, &block) #:nodoc:
+          node._rels(dir, rel_type).each do |rel|
+            block.call rel._other_node(node)
+          end
+        end
+
+        # @private
+        def single_node(node)
+          rel = single_relationship(node)
+          rel && rel.other_node(node)
+        end
+
+        # @private
+        def single_relationship(node) #:nodoc:
+          node.rel(dir, rel_type)
+        end
+
+        # @private
+        def _all_relationships(node) #:nodoc:
+          node._rels(dir, rel_type)
+        end
+
+        # @private
+        def all_relationships(node)
+          node.rels(dir, rel_type)
+        end
+
+        # @private
+        def create_relationship_to(node, other) # :nodoc:
+          from, to = incoming? ? [other, node] : [node, other]
+
+          if relationship_class
+            relationship_class.new(@rel_type, from._java_node, to._java_node)
+          else
+            Neo4j::Relationship.new(@rel_type, from, to)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/neo4j-wrapper/has_n/instance_methods.rb

@@ -0,0 +1,12 @@
+module Neo4j
+  module Wrapper
+    module HasN
+      # The {Neo4j::Wrapper::HasN::ClassMethods} generates has_n relationship accessor methods.
+      module InstanceMethods
+        def _decl_rels_for(rel_type)
+          self.class._decl_rels[rel_type]
+        end
+      end
+    end
+  end
+end

data/lib/neo4j-wrapper/has_n/nodes.rb

@@ -0,0 +1,83 @@
+module Neo4j
+  module Wrapper
+    module HasN
+
+      # The object created by a has_n or has_one Neo4j::NodeMixin class method which enables creating and traversal of nodes.
+      #
+      # @see Neo4j::Wrapper::HasN::ClassMethods
+      class Nodes
+        include Enumerable
+        include Neo4j::Core::ToJava
+
+        def initialize(node, decl_rel) # :nodoc:
+          @node = node
+          @decl_rel = decl_rel
+        end
+
+        def to_s
+          "HasN::Nodes [#{@decl_rel.dir}, id: #{@node.neo_id} type: #{@decl_rel && @decl_rel.rel_type} decl_rel:#{@decl_rel}]"
+        end
+
+        # Traverse the relationship till the index position
+        # @return [Neo4j::NodeMixin,Neo4j::Node,nil] the node at the given position
+        def [](index)
+          i = 0
+          each { |x| return x if i == index; i += 1 }
+          nil # out of index
+        end
+
+        # Pretend we are an array - this is necessarily for Rails actionpack/actionview/formhelper to work with this
+        def is_a?(type)
+          # ActionView requires this for nested attributes to work
+          return true if Array == type
+          super
+        end
+
+        # Required by the Enumerable mixin.
+        def each
+          @decl_rel.each_node(@node) { |n| yield n } # Should use yield here as passing &block through doesn't always work (why?)
+        end
+
+        # returns none wrapped nodes, you may get better performance using this method
+        def _each
+          @decl_rel._each_node(@node) { |n| yield n }
+        end
+
+        # Returns an real ruby array.
+        def to_ary
+          self.to_a
+        end
+
+        # Returns true if there are no node in this type of relationship
+        def empty?
+          first == nil
+        end
+
+
+        # Creates a relationship instance between this and the other node.
+        # Returns the relationship object
+        def new(other)
+          @decl_rel.create_relationship_to(@node, other)
+        end
+
+
+        # Creates a relationship between this and the other node.
+        #
+        # @example Person includes the Neo4j::NodeMixin and declares a has_n :friends
+        #
+        #   p = Person.new # Node has declared having a friend type of relationship
+        #   n1 = Node.new
+        #   n2 = Node.new
+        #
+        #   p.friends << n2 << n3
+        #
+        # @return self
+        def <<(other)
+          @decl_rel.create_relationship_to(@node, other)
+          self
+        end
+      end
+
+    end
+  end
+end

data/lib/neo4j-wrapper/node_mixin/class_methods.rb

@@ -0,0 +1,53 @@
+module Neo4j
+  module Wrapper
+    module NodeMixin
+      module ClassMethods
+
+        # Creates a new node or loads an already existing Neo4j node.
+        #
+        # You can use two callback method to initialize the node
+        # init_on_load - this method is called when the node is loaded from the database
+        # init_on_create - called when the node is created, will be provided with the same argument as the new method
+        #
+        # == Does
+        # * sets the neo4j property '_classname' to self.class.to_s
+        # * creates a neo4j node java object (in @_java_node)
+        #
+        # If you want to provide your own initialize method you should instead implement the
+        # method init_on_create method.
+        #
+        # @example Create your own Ruby wrapper around a Neo4j::Node java object
+        #   class MyNode
+        #     include Neo4j::NodeMixin
+        #   end
+        #
+        #   node = MyNode.new(:name => 'jimmy', :age => 23)
+        #
+        # @example Using your own initialize method
+        #   class MyNode
+        #     include Neo4j::NodeMixin
+        #
+        #     def init_on_create(name, age)
+        #        self[:name] = name
+        #        self[:age] = age
+        #     end
+        #   end
+        #
+        #   node = MyNode.new('jimmy', 23)
+        #
+        # @param args typically a hash of properties, but could be anything which will be handled in the super method
+        # @return the object return from the super method
+        def new(*args)
+          node = Neo4j::Node.create
+          wrapped_node = super()
+          Neo4j::IdentityMap.add(node, wrapped_node)
+          wrapped_node.init_on_load(node)
+          wrapped_node.init_on_create(*args)
+          wrapped_node
+        end
+
+        alias_method :create, :new
+      end
+    end
+  end
+end