neo4j-wrapper 0.0.9-java → 0.0.10-java

data/lib/neo4j/type_converters/type_converters.rb

@@ -115,12 +115,12 @@ module Neo4j
 
         def to_java(value)
           return nil if value.nil?
-          value.to_s
+          Array === value ? value.map(&:to_s)  : value.to_s
         end
 
         def to_ruby(value)
           return nil if value.nil?
-          value.to_s
+          value
         end
 
         def index_as
@@ -141,12 +141,12 @@ module Neo4j
 
         def to_java(value)
           return nil if value.nil?
-          value.to_i
+          Array === value ? value.map(&:to_i) : value.to_i
         end
 
         def to_ruby(value)
           return nil if value.nil?
-          value.to_i
+          value#.to_i
         end
 
         def index_as
@@ -165,12 +165,12 @@ module Neo4j
 
         def to_java(value)
           return nil if value.nil?
-          value.to_f
+          Array === value ? value.map(&:to_f) : value.to_f
         end
 
         def to_ruby(value)
           return nil if value.nil?
-          value.to_f
+          value
         end
 
         def index_as

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

@@ -41,6 +41,7 @@ module Neo4j
         #   class FolderNode
         #      include Ne4j::NodeMixin
         #      has_n(:files).to(File)
+        #      # Same as has_n(:files).to("File")
         #   end
         #
         #   FolderNode.files #=> 'File#files' the name of the relationship
@@ -50,6 +51,8 @@ module Neo4j
         #   # generate accessor method for traversing and adding relationship on incoming nodes.
         #   class FileNode
         #      include Ne4j::NodeMixin
+        #      has_one(:folder).from(FolderNode.files)
+        #      # or same as
         #      has_one(:folder).from(FolderNode, :files)
         #   end
         #
@@ -79,7 +82,7 @@ module Neo4j
 
           instance_eval(%Q{
           def #{rel_type}
-            _decl_rels[:#{rel_type}].rel_type.to_s
+            _decl_rels[:#{rel_type}].rel_type
           end}, __FILE__, __LINE__)
 
           _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, false, clazz)
@@ -125,7 +128,7 @@ module Neo4j
 
           instance_eval(%Q{
           def #{rel_type}
-            _decl_rels[:#{rel_type}].rel_type.to_s
+            _decl_rels[:#{rel_type}].rel_type
           end}, __FILE__, __LINE__)
 
           _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, true, clazz)

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

@@ -33,30 +33,30 @@ module Neo4j
       # <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
+        attr_reader :source_class, :dir, :rel_type
 
-        def initialize(method_id, has_one, target_class)
+        def initialize(method_id, has_one, source_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
+          @rel_type = method_id.to_sym
+          @source_class = source_class
         end
 
         def inherit_new
           base = self
-          dr = DeclRel.new(@method_id, @has_one, @target_class)
+          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_class} rel_class:#{@relationship}"
+          "DeclRel #{object_id} dir: #{@dir} rel_id: #{@method_id}, rel_type: #{@rel_type}, target_class:#{@target_name} rel_class:#{@relationship}"
         end
 
         # @return [true, false]
@@ -75,13 +75,15 @@ module Neo4j
         end
 
 
-        # Specifies an outgoing relationship.
-        # The name of the outgoing class will be used as a prefix for the relationship used.
+        # 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::NodeMixin
         #     has_n(:files).to(FileNode)
+        #     has_one(:root).to("FileSystem") # also possible, if the class is not defined yet
         #   end
         #
         #  folder = FolderNode.new
@@ -99,18 +101,20 @@ module Neo4j
         #   # 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
+        # @param [Class, String, Symbol] target the other class to which this relationship goes (if String or Class) or the relationship (if Symbol)
+        # @param [Class, 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)
+        def to(target, rel_type = @method_id)
           @dir = :outgoing
 
-          if Class === target
+          if Class === target || String === target
             # handle e.g. has_n(:friends).to(class)
-            @target_class = target
-            @rel_type = "#{@source_class}##{@method_id}"
+            @target_name = target
+            @rel_type = "#{@source_class}##{rel_type}".to_sym
           elsif Symbol === target
-            # handle e.g. has_n(:friends).to(:knows)
-            @rel_type = target.to_s
+            # handle e.g. has_n(:friends).to(:knows) or to("Person#friends")
+            @target_name = target.to_s.split("#")[0] if target.to_s.include?("#")
+            @rel_type = target.to_sym
           else
             raise "Expected a class or a symbol for, got #{target}/#{target.class}"
           end
@@ -129,7 +133,8 @@ module Neo4j
         #   class FileNode
         #     include Neo4j::NodeMixin
         #     # will only traverse any incoming relationship of type files from node FileNode
-        #     has_one(:folder).from(FolderNode, :files)
+        #     has_one(:folder).from(FolderNode.files)
+        #     # alternative: has_one(:folder).from(FolderNode, :files) 
         #   end
         #
         #   file = FileNode.new
@@ -158,14 +163,18 @@ module Neo4j
 
           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]}"
+            @target_name = args[0]
             @relationship_name = args[1].to_sym
+            @rel_type = "#{@target_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
+            name = args[0].to_s
+            if name.include?("#")
+              @target_name, @relationship_name = name.split("#").map(&:to_sym)
+            end
+            @rel_type = args[0]
           else
-            raise "Expected a symbol for, got #{args[0]}"
+            raise "Expected a symbol for, got #{args[0].inspect}"
           end
           self
         end
@@ -195,20 +204,29 @@ module Neo4j
           self
         end
 
+        # @private
+        def target_name
+          @target_name
+        end
 
         # @private
         def relationship_class # :nodoc:
-          if !@relationship_name.nil? && @relationship.nil?
-            other_class_dsl = @target_class._decl_rels[@relationship_name]
+          if @dir == :incoming
+            other_class_dsl = target_class && 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}"
+              Neo4j.logger.warn "Unknown outgoing relationship #{@relationship_name} on #{@target_name}"
             end
           end
           @relationship
         end
 
+        def target_class
+          @target_name && (@target_name.is_a?(Class) ? @target_name : Neo4j::Wrapper.to_class(@target_name.to_s))
+        end
+
+
         # @private
         def each_node(node, &block)
           node.rels(dir, rel_type).each do |rel|

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

@@ -48,6 +48,38 @@ module Neo4j
 
         alias_method :create, :new
 
+
+        # Get the indexed entity, creating it (exactly once) if no indexed entity exist.
+        #
+        # @example Creating a Unique node
+        #
+        #   class MyNode
+        #     include Neo4j::NodeMixin
+        #     property :email, :index => :exact, :unique => true
+        #   end
+        #
+        #   node = MyNode.get_or_create(:email =>'jimmy@gmail.com', :name => 'jimmy')
+        #
+        # @see #put_if_absent
+        def get_or_create(*args)
+          props = args.first
+          raise "Can't get or create entity since #{props.inspect} does not included unique key #{props[unique_factory_key]}'" unless props[unique_factory_key]
+          index = index_for_type(_decl_props[unique_factory_key][:index])
+          Neo4j::Core::Index::UniqueFactory.new(unique_factory_key, index) { |*| new(*args) }.get_or_create(unique_factory_key, props[unique_factory_key])
+        end
+
+        # @throws Exception if there are more then one property having unique index
+        # @return [Symbol,nil] the property which has an unique index or nil
+        def unique_factory_key
+          @unique_factory_key ||= begin
+            unique = []
+            _decl_props.each_pair { |k, v| unique << k if v[:unique] }
+            return nil if unique.empty?
+            raise "Only one property can be unique, got #{unique.join(', ')}" if unique.size > 1
+            unique.first
+          end
+        end
+
         # Loads a wrapped node from the database given a neo id.
         # @param [#to_i, nil] neo_id
         # @return [Object, nil] If the node does not exist it will return nil otherwise the loaded node or wrapped node.

data/lib/neo4j-wrapper/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Wrapper
-    VERSION = '0.0.9'
+    VERSION = '0.0.10'
   end
 end

data/neo4j-wrapper.gemspec

@@ -27,5 +27,5 @@ It comes included with the Apache Lucene document database.
   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.13")
+  s.add_dependency("neo4j-core", "0.0.14")
 end

metadata

@@ -2,7 +2,7 @@
 name: neo4j-wrapper
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.9
+  version: 0.0.10
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-04-23 00:00:00 Z
+date: 2012-04-24 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: neo4j-core
@@ -20,7 +20,7 @@ dependencies:
       requirements: 
         - - "="
           - !ruby/object:Gem::Version 
-            version: 0.0.13
+            version: 0.0.14
     type: :runtime
     version_requirements: *id001
 description: |