neo4j 1.0.0.beta.9 → 1.0.0.beta.10

data/lib/neo4j/mapping/class_methods/relationship.rb

@@ -35,7 +35,7 @@ module Neo4j::Mapping
                     Neo4j::Mapping::HasN.new(self, dsl).rels
       end}, __FILE__, __LINE__)
 
-        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, params)
+        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, false, params)
       end
 
 
@@ -84,7 +84,7 @@ module Neo4j::Mapping
                     [*r][0]
       end}, __FILE__, __LINE__)
 
-        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, params)
+        _decl_rels[rel_type.to_sym] = Neo4j::Mapping::DeclRelationshipDsl.new(rel_type, true, params)
       end
 
     end

data/lib/neo4j/mapping/decl_relationship_dsl.rb

@@ -35,15 +35,20 @@ module Neo4j::Mapping
     attr_reader :to_type, :to_class, :cascade_delete_prop_name, :counter, :rel_id, :direction
     CASCADE_DELETE_PROP_NAMES = {:outgoing => :_cascade_delete_outgoing, :incoming => :_cascade_delete_incoming}
 
-    def initialize(rel_id, params)
+    def initialize(rel_id, has_one, params)
       @direction = :outgoing
       @rel_id = rel_id
       @to_type = rel_id
+      @has_one = has_one
       @namespace_type = rel_id
       @cascade_delete_prop_name = CASCADE_DELETE_PROP_NAMES[params[:cascade_delete]]
       @counter = params[:counter] == true
     end
 
+    def has_one?
+      @has_one
+    end
+
     # If a counter was specified in the dsl for counting number of nodes in this relationship.
     #
     def counter?

data/lib/neo4j/mapping/has_n.rb

@@ -24,6 +24,22 @@ module Neo4j
         @traverser = Neo4j::NodeTraverser.new(node._java_node, @dsl.namespace_type, @direction)
       end
 
+      def size
+        [*self].size
+      end
+
+      alias_method :length, :size
+
+      def [](index)
+        each_with_index {|node,i| break node if index == i}
+      end
+
+      # Pretend we are an array - this is neccessarly 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
 
       # Returns the relationships instead of the nodes.
       #
@@ -43,7 +59,7 @@ module Neo4j
       #  morpheus.friends.depth(3).each { ... }
       #  
       # ==== Arguments
-      # d<Fixnum,Symbol>:: the depth or :all if traversing to the end of the network.
+      # d:: the depth or :all if traversing to the end of the network (symbol or fixnum)
       # ==== Return
       # self
       # 

data/lib/neo4j/node_traverser.rb

@@ -51,6 +51,9 @@ module Neo4j
     end
 
 
+    def to_s
+      "NodeTraverser [from: #{@from.neo_id} depth: #{@depth} type: #{@type} dir:#{@dir}"
+    end
 
     def <<(other_node)
       new(other_node)
@@ -118,10 +121,20 @@ module Neo4j
       [*self].size
     end
 
+    alias_method :length, :size
+
+    def [](index)
+      each_with_index {|node,i| break node if index == i}
+    end
+
+    def empty?
+      first == nil
+    end
+
     def each
       iter = iterator
       while (iter.hasNext) do
-        yield Neo4j::Node.wrapper(iter.next)
+        yield iter.next.wrapper
       end
     end
 

data/lib/neo4j/rails/model.rb

@@ -7,6 +7,8 @@ class Neo4j::Model
   extend ActiveModel::Naming
   extend ActiveModel::Callbacks
   extend Neo4j::Validations::ClassMethods
+  extend Neo4j::TxMethods
+
   define_model_callbacks :create, :save, :update, :destroy
 
 
@@ -39,7 +41,7 @@ class Neo4j::Model
   # --------------------------------------
 
   def id
-    self.neo_id
+    neo_id.nil? ? nil : neo_id.to_s
   end
 
   def to_param
@@ -83,7 +85,7 @@ class Neo4j::Model
 
 
   def read_attribute_for_validation(key)
-    respond_to?(key)? send(key) : self[key]
+    respond_to?(key) ? send(key) : self[key]
   end
 
   def attributes=(values)
@@ -98,26 +100,63 @@ class Neo4j::Model
 
 
   # Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
-  # If the saving fails because of a connection or remote service error, an exception will be raised.
   # If saving fails because the resource is invalid then false will be returned.
   def update_attributes(attributes)
-    Neo4j::Rails::Transaction.running? ? update_attributes_in_tx(attributes) : Neo4j::Rails::Transaction.run { update_attributes_in_tx(attributes) }
-  end
-
-  def update_attributes_in_tx(attributes)
     self.attributes=attributes
     save
   end
 
   def update_attributes!(attributes)
-    Neo4j::Rails::Transaction.running? ? update_attributes_in_tx!(attributes) : Neo4j::Rails::Transaction.run { update_attributes_in_tx!(attributes) }
-  end
-
-  def update_attributes_in_tx!(attributes)
     self.attributes=attributes
     save!
   end
 
+  def update_nested_attributes(rel_type, clazz, has_one, attr, options)
+    allow_destroy,reject_if = [options[:allow_destroy], options[:reject_if]] if options
+
+    if new?
+      # We are updating a node that was created with the 'new' method.
+      # The relationship will only be kept in the Value object.
+      outgoing(rel_type)<<clazz.new(attr) unless reject_if?(reject_if,attr)
+    else
+      # We have a node that was created with the #create method - has real Neo4j relationships
+      # does it exist ?
+      found = if has_one
+                # id == nil that means we have a has_one relationship
+                outgoing(rel_type).first
+              else
+                # do we have an ID ?
+                id = attr[:id]
+                # this is a has_n relationship, find which one we want to update
+                id && outgoing(rel_type).find { |n| n.id == id }
+              end
+
+      # Check if we want to destroy not found nodes (e.g. {..., :_destroy => '1' } ?
+      destroy = attr[:_destroy]
+      if found
+        if destroy
+          found.destroy if allow_destroy
+        else
+          found.update_attributes_in_tx(attr) # it already exist, so update that one
+        end
+      elsif !destroy && !reject_if?(reject_if,attr)
+        new_node = clazz.new(attr)
+        saved = new_node.save
+        outgoing(rel_type) << new_node if saved
+      end
+    end
+  end
+
+  def reject_if?(proc_or_symbol, attr)
+    return false if proc_or_symbol.nil?
+    if proc_or_symbol.is_a?(Symbol)
+      meth = method(proc_or_symbol)
+      meth.arity == 0 ? meth.call : meth.call(attr)
+    else
+      proc_or_symbol.call(attr)
+    end
+  end
+
   def delete
     super
     @_deleted = true
@@ -125,13 +164,10 @@ class Neo4j::Model
   end
 
   def save
-    if valid?
+    valid = valid?
+    if valid
       # if we are trying to save a value then we should create a real node
-      if Neo4j::Rails::Transaction.running?
-        _run_save_callbacks { save_in_tx }
-      else
-        Neo4j::Rails::Transaction.run { _run_save_callbacks { save_in_tx } }
-      end
+      valid = _run_save_callbacks { create_or_update_node }
       @_created_record = false
       true
     else
@@ -140,12 +176,14 @@ class Neo4j::Model
       Neo4j::Rails::Transaction.fail if Neo4j::Rails::Transaction.running? && !_java_node.kind_of?(Neo4j::Value)
       false
     end
+    valid
   end
 
-  def save_in_tx
-#    _run_save_callbacks do
+  def create_or_update_node
+    valid = true
     if _java_node.kind_of?(Neo4j::Value)
       node = Neo4j::Node.new(props)
+      valid = _java_node.save_nested(node)
       init_on_load(node)
       init_on_create
     end
@@ -155,6 +193,7 @@ class Neo4j::Model
     else
       _run_update_callbacks { clear_changes }
     end
+    valid
   end
 
   def clear_changes
@@ -178,7 +217,11 @@ class Neo4j::Model
   # Returns true if this object hasn’t been saved yet — that is, a record for the object doesn’t exist yet; otherwise, returns false.
   def new_record?()
     # it is new if the model has been created with either the new or create method
-    _java_node.kind_of?(Neo4j::Value) || @_created_record == true
+    new? || @_created_record == true
+  end
+
+  def new?
+    _java_node.kind_of?(Neo4j::Value)
   end
 
   def del
@@ -187,29 +230,53 @@ class Neo4j::Model
   end
 
   def destroy
-    Neo4j::Rails::Transaction.running? ? _run_update_callbacks { del } : Neo4j::Rails::Transaction.run { _run_update_callbacks { del } }
+    _run_update_callbacks { del }
   end
 
   def destroyed?()
     @_deleted
   end
 
+  tx_methods :destroy, :create_or_update_node, :update_attributes, :update_attributes!
 
   # --------------------------------------
   # Class Methods
   # --------------------------------------
 
   class << self
+    extend Neo4j::TxMethods
+
     # returns a value object instead of creating a new node
     def new(*args)
       value = Neo4j::Value.new
       wrapped = self.orig_new
       wrapped.init_on_load(value)
       wrapped.attributes=args[0] if args[0].respond_to?(:each_pair)
+
+      wrapped.class._decl_rels.each_pair do |field, dsl|
+
+        meta = class << wrapped;
+          self;
+        end
+
+        wrapped.class._decl_rels.each_pair do |field, dsl|
+          meta.send(:define_method, field) do
+            if new?
+              value.outgoing(dsl.namespace_type)
+            else
+              self.outgoing(dsl.namespace_type)
+            end
+          end if dsl.direction == :outgoing
+
+          meta.send(:define_method, field) do
+            raise "NOT IMPLEMENTED #{field} (incoming relationship) FOR #new method, please create a new model with the create method instead"
+          end if dsl.direction == :incoming
+        end
+      end
+
       wrapped
     end
 
-
     # Handle Model.find(params[:id])
     def find(*args)
       if args.length == 1 && String === args[0] && args[0].to_i != 0
@@ -236,26 +303,55 @@ class Neo4j::Model
     alias_method :_orig_create, :create
 
     def create(*)
-      Neo4j::Rails::Transaction.running? ? create_in_tx(super) : Neo4j::Rails::Transaction.run { create_in_tx(super) }
-    end
-
-    def create!(*args)
-      Neo4j::Rails::Transaction.running? ? create_in_tx!(_orig_create(*args)) : Neo4j::Rails::Transaction.run { create_in_tx!(_orig_create(*args)) }
-    end
-
-    def create_in_tx(model)
+      model = super
       model.save
       model
     end
 
-    def create_in_tx!(model)
+    def create!(*args)
+      model = _orig_create(*args)
       model.save!
       model
     end
 
+    tx_methods :create, :create!
+
+
     def transaction(&block)
       Neo4j::Rails::Transaction.run &block
     end
+
+    def accepts_nested_attributes_for(*attr_names)
+      options = attr_names.pop if attr_names[-1].is_a?(Hash)
+
+      attr_names.each do |association_name|
+        rel = self._decl_rels[association_name.to_sym]
+        raise "No relationship declared with has_n or has_one with type #{association_name}" unless rel
+        to_class = rel.to_class
+        raise "Can't use accepts_nested_attributes_for(#{association_name}) since it has not defined which class it has a relationship to, use has_n(#{association_name}).to(MyOtherClass)" unless to_class
+        type = rel.namespace_type
+        has_one = rel.has_one?
+
+        send(:define_method, "#{association_name}_attributes=") do |attributes|
+          if has_one
+            update_nested_attributes(type, to_class, true, attributes, options)
+          else
+            if attributes.is_a?(Array)
+              attributes.each do |attr|
+                update_nested_attributes(type, to_class, false, attr, options)
+              end
+            else
+              attributes.each_value do |attr|
+                update_nested_attributes(type, to_class, false, attr, options)
+              end
+            end
+          end
+        end
+        tx_methods("#{association_name}_attributes=")
+      end
+    end
+
   end
 
 end
+

data/lib/neo4j/rails/tx_methods.rb

@@ -0,0 +1,11 @@
+module Neo4j::TxMethods
+  def tx_methods(*methods)
+    methods.each do |method|
+      tx_method = "#{method}_in_tx"
+      send(:alias_method, tx_method, method)
+      send(:define_method, method) do |*args|
+        Neo4j::Rails::Transaction.running? ? send(tx_method, *args) : Neo4j::Rails::Transaction.run { send(tx_method, *args) }
+      end
+    end
+  end
+end

data/lib/neo4j/rails/value.rb

@@ -10,6 +10,7 @@ module Neo4j
       if args[0].respond_to?(:each_pair)
         args[0].each_pair { |k, v| set_property(k.to_s, v) }
       end
+      @rels = {}  # a hash of all relationship with key type
     end
 
     # override Neo4j::Property#props
@@ -38,6 +39,48 @@ module Neo4j
       @props.delete(key)
     end
 
-  end
+    def outgoing(type)
+      @rels[type.to_sym] ||= OutgoingRels.new
+    end
+
+    def save_nested(root_node)
+      valid = true
+      @rels.each_pair do |type, rel|
+        rel.each do |new_node|
+          if new_node.save
+            root_node.outgoing(type) << new_node
+          else
+            valid = false
+          end
+        end
+      end
+      valid
+    end
+
+    class OutgoingRels
+      include Enumerable
+      def initialize
+        @nodes = []
+      end
+
+      def <<(other)
+        @nodes << other
+      end
 
+      def each
+        @nodes.each {|n| yield n}
+      end
+
+      def empty?
+        @nodes.empty?
+      end
+
+      def is_a?(type)
+        # ActionView requires this for nested attributes to work
+        return true if Array == type
+        super
+      end
+    end
+
+  end
 end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.0.0.beta.9"
+  VERSION = "1.0.0.beta.10"
 end

data/lib/neo4j.rb

@@ -42,6 +42,7 @@ 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'

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
     - 0
     - 0
     - beta
-    - 9
-  version: 1.0.0.beta.9
+    - 10
+  version: 1.0.0.beta.10
 platform: ruby
 authors: 
   - Andreas Ronge
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-05 00:00:00 +02:00
+date: 2010-10-08 00:00:00 +02:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -101,62 +101,6 @@ extra_rdoc_files:
   - README.rdoc
 files: 
   - lib/neo4j.rb
-  - lib/neo4j.old/reference_node.rb
-  - lib/neo4j.old/event_handler.rb
-  - lib/neo4j.old/indexer.rb
-  - lib/neo4j.old/search_result.rb
-  - lib/neo4j.old/config.rb
-  - lib/neo4j.old/neo.rb
-  - lib/neo4j.old/transaction.rb
-  - lib/neo4j.old/node.rb
-  - lib/neo4j.old/jars.rb
-  - lib/neo4j.old/batch_inserter.rb
-  - lib/neo4j.old/version.rb
-  - lib/neo4j.old/relationship.rb
-  - lib/neo4j.old/relationships/node_traverser.rb
-  - lib/neo4j.old/relationships/decl_relationship_dsl.rb
-  - lib/neo4j.old/relationships/wrappers.rb
-  - lib/neo4j.old/relationships/has_n.rb
-  - lib/neo4j.old/relationships/relationship_dsl.rb
-  - lib/neo4j.old/relationships/has_list.rb
-  - lib/neo4j.old/relationships/traversal_position.rb
-  - lib/neo4j.old/mixins/java_node_mixin.rb
-  - lib/neo4j.old/mixins/java_relationship_mixin.rb
-  - lib/neo4j.old/mixins/migration_mixin.rb
-  - lib/neo4j.old/mixins/node_mixin.rb
-  - lib/neo4j.old/mixins/java_property_mixin.rb
-  - lib/neo4j.old/mixins/java_list_mixin.rb
-  - lib/neo4j.old/mixins/relationship_mixin.rb
-  - lib/neo4j.old/mixins/rel_class_methods.rb
-  - lib/neo4j.old/mixins/property_class_methods.rb
-  - lib/neo4j.old/jars/neo4j-kernel-1.0.jar
-  - lib/neo4j.old/jars/geronimo-jta_1.1_spec-1.1.1.jar
-  - lib/neo4j.old/extensions/aggregate.rb
-  - lib/neo4j.old/extensions/find_path.rb
-  - lib/neo4j.old/extensions/reindexer.rb
-  - lib/neo4j.old/extensions/graph_algo.rb
-  - lib/neo4j.old/extensions/rest.rb
-  - lib/neo4j.old/extensions/tx_tracker.rb
-  - lib/neo4j.old/extensions/rest_slave.rb
-  - lib/neo4j.old/extensions/activemodel.rb
-  - lib/neo4j.old/extensions/rest_master.rb
-  - lib/neo4j.old/extensions/rest/server.rb
-  - lib/neo4j.old/extensions/rest/rest.rb
-  - lib/neo4j.old/extensions/rest/rest_mixin.rb
-  - lib/neo4j.old/extensions/rest/stubs.rb
-  - lib/neo4j.old/extensions/graph_algo/neo4j-graph-algo-0.3.jar
-  - lib/neo4j.old/extensions/graph_algo/all_simple_paths.rb
-  - lib/neo4j.old/extensions/aggregate/node_aggregate.rb
-  - lib/neo4j.old/extensions/aggregate/node_aggregate_mixin.rb
-  - lib/neo4j.old/extensions/aggregate/props_aggregator.rb
-  - lib/neo4j.old/extensions/aggregate/prop_group.rb
-  - lib/neo4j.old/extensions/aggregate/node_aggregator.rb
-  - lib/neo4j.old/extensions/aggregate/props_aggregate.rb
-  - lib/neo4j.old/extensions/aggregate/props_aggregate_mixin.rb
-  - lib/neo4j.old/extensions/aggregate/property_enum.rb
-  - lib/neo4j.old/extensions/aggregate/aggregate_enum.rb
-  - lib/neo4j.old/extensions/aggregate/node_group.rb
-  - lib/neo4j.old/extensions/aggregate/ext/node_mixin.rb
   - lib/neo4j/event_handler.rb
   - lib/neo4j/node_traverser.rb
   - lib/neo4j/relationship_traverser.rb
@@ -179,6 +123,7 @@ files:
   - lib/neo4j/rails/railtie.rb
   - lib/neo4j/rails/lucene_connection_closer.rb
   - lib/neo4j/rails/transaction.rb
+  - lib/neo4j/rails/tx_methods.rb
   - lib/neo4j/rails/value.rb
   - lib/neo4j/rails/validations/uniqueness.rb
   - lib/neo4j/jars/lucene-core-3.0.1.jar

data/lib/neo4j.old/batch_inserter.rb

@@ -1,144 +0,0 @@
-module Neo4j
-
-  class BatchItem  # :nodoc:
-    attr_accessor :_wrapper, :neo_id
-
-    include Neo4j::JavaPropertyMixin
-
-    def initialize(neo_id, inserter)
-      @neo_id = neo_id
-      @inserter = inserter
-    end
-
-    def getId(); neo_id end
-
-    def has_property?(key)
-      props.include?(key.to_s)
-    end
-
-    def get_property(key)
-      props[key]
-    end
-    
-    def props
-      # not sure why I have to do it like this, Strange why I can't use the Java Hash ?
-      # gets java.lang.UnsupportedOperationException: null, in java/util/AbstractMap.java:186:in `put'
-      java_props = @inserter.getNodeProperties(neo_id)
-      ruby_props = {}
-      java_props.keySet().each{|k| ruby_props[k] = java_props[k]}
-      ruby_props
-    end
-
-
-    def setProperty(key, value)
-      ruby_props = props
-      ruby_props[key.to_s] = value
-      @inserter.setNodeProperties(neo_id, ruby_props)
-
-      if (wrapper_class and key[0, 1] != '_') # do not want events on internal properties
-        wrapper_class.indexer.on_property_changed(wrapper, key)
-      end
-    end
-  end
-
-  # Neo4j has a batch insert mode that drops support for transactions and concurrency in favor of insertion speed.
-  # This is useful when you have a big dataset that needs to be loaded once. In our experience, the batch inserter will
-  # typically inject data around five times faster than running in normal transactional mode.
-  #
-  # === Usage
-  #
-  # The initialize method takes a code block that will use the BatchInserter.
-  #
-  #  Neo4j::BatchInserter.new do |b|
-  #    a = Neo4j::Node.new :name => 'a'
-  #    b = Neo4j::Node.new :name => 'b'
-  #    c = Foo.new :key1 => 'val1', :key2 => 'val2'
-  #    c[:name] = "c"
-  #    Neo4j::Relationship.new(:friend, a, b, :since => '2001-01-01')
-  #    Neo4j::Relationship.new(:friend, Neo4j.ref_node, c, :since => '2001-01-01')
-  #  end
-  #
-  # After the code block the normal creation for nodes and relationship will be used.
-  # Traversals inside the batch inserter block is not possible.
-  # The BatchInserter can be used together with Neo4j Migrations (see Neo4j#migration)
-  #
-  class BatchInserter
-
-    # See class description for usage.
-    #
-    # === Parameters
-    # storage_path:: optional, the location of the neo4j dabase on file system, default Neo4j::Config[:storage_path]
-    # db_version:: optional, sets version number on reference node, default nil -> do not set this property
-    def initialize(storage_path = Neo4j::Config[:storage_path], db_version=nil)  # :yields: batch_inserter
-      # create the batch inserter
-      inserter = org.neo4j.kernel.impl.batchinsert.BatchInserterImpl.new(storage_path)
-
-      # save original methods
-      create_node_meth = Neo4j.method(:create_node)
-      create_rel_meth  = Neo4j.method(:create_rel)
-      ref_node_meth    = Neo4j.method(:ref_node)
-      instance_meth    = Neo4j.method(:instance)
-      
-      # replace methods
-      neo4j_meta = (class << Neo4j; self; end)
-      neo4j_meta.instance_eval do
-        define_method(:create_node) do |props|
-          props ||= {}
-          id = inserter.createNode(props.keys.inject({}) {|hash, key| hash[key.to_s] = props[key]; hash})
-          BatchItem.new(id, inserter)
-        end
-        define_method(:create_rel) do |type, from_node, to_node, props|
-          props = Hash[*props.map{|k, v| [k.to_s, v]}.flatten] if props
-          java_type = org.neo4j.graphdb.DynamicRelationshipType.withName(type.to_s)
-          id = inserter.createRelationship(from_node.neo_id, to_node.neo_id, java_type, props)
-          BatchItem.new(id, inserter)
-        end
-        define_method(:ref_node) do 
-          BatchItem.new(inserter.getReferenceNode, inserter)
-        end
-        define_method(:instance) do
-          Neo4j::BatchInstance.new
-        end
-      end
-
-      begin                     
-        yield inserter         
-        Neo4j.ref_node[:db_version] = db_version if db_version
-      ensure
-        inserter.shutdown
-        # restore old methods
-        neo4j_meta.instance_eval do
-          define_method(:create_node, create_node_meth)
-          define_method(:create_rel, create_rel_meth)
-          define_method(:ref_node, ref_node_meth)
-          define_method(:instance, instance_meth)
-        end
-      end
-    end
-
-    # This method is used if the batch inserter is used from the Migration API.
-    #
-    # === Parameters
-    # context:: the context on which the batch inserter code block is evaluated in, not used.
-    # version:: optional, if given then will set the property db_version on the context
-    def self.execute(context, version=nil, &block)
-      # Neo4j must not be running while using batch inserter, stop it just in case ...
-      Neo4j::Transaction.finish
-      Neo4j.stop
-
-      BatchInserter.new(Neo4j::Config[:storage_path], version, &block)
-
-      Neo4j.start
-    end
-  end
-
-  # Used instead of Neo4j.instance object - will happily accept any methods - like transaction methods.
-  class BatchInstance # :nodoc:
-    def method_missing(m, *args, &block)
-      return BatchInstance.new
-    end
-  end
-end
-
-
-