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

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

@@ -0,0 +1,82 @@
+module Neo4j
+  module ActiveNode
+    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::ActiveNode::HasN::ClassMethods
+      class Nodes
+        include Enumerable
+
+        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.rel_type} decl_rel:#{@decl_rel}]"
+        end
+
+        # Traverse the relationship till the index position
+        # @return [Neo4j::ActiveMixin,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 create(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/active_node/identity.rb

@@ -0,0 +1,28 @@
+module Neo4j::ActiveNode
+  module Identity
+
+    def ==(o)
+      o.class == self.class && o.id == id
+    end
+    alias_method :eql?, :==
+
+    # Returns an Enumerable of all (primary) key attributes
+    # or nil if model.persisted? is false
+    def to_key
+      persisted? ? [id] : nil
+    end
+
+    # @return [Fixnum, nil] the neo4j id of the node if persisted or nil
+    def neo_id
+      _persisted_node ? _persisted_node.neo_id : nil
+    end
+
+    # @return [String, nil] same as #neo_id
+    def id
+      persisted? ? neo_id.to_s : nil
+    end
+
+
+  end
+
+end

data/lib/neo4j/active_node/initialize.rb

@@ -0,0 +1,24 @@
+module Neo4j::ActiveNode::Initialize
+  extend ActiveSupport::Concern
+
+  attr_reader :_persisted_node
+
+  # called when loading the node from the database
+  # @param [Neo4j::Node] persisted_node the node this class wraps
+  # @param [Hash] properties properties of the persisted node.
+  def init_on_load(persisted_node, properties)
+    @_persisted_node = persisted_node
+    @changed_attributes && @changed_attributes.clear
+    @attributes = attributes.merge(properties.stringify_keys)
+  end
+
+  # Implements the Neo4j::Node#wrapper and Neo4j::Relationship#wrapper method
+  # so that we don't have to care if the node is wrapped or not.
+  # @return self
+  def wrapper
+    self
+  end
+
+end
+
+

data/lib/neo4j/active_node/labels.rb

@@ -0,0 +1,142 @@
+module Neo4j
+  module ActiveNode
+
+
+    # Provides a mapping between neo4j labels and Ruby classes
+    module Labels
+      extend ActiveSupport::Concern
+
+      WRAPPED_CLASSES = []
+
+      def labels
+        @_persisted_node.labels
+      end
+
+      def self.included(klass)
+        add_wrapped_class(klass)
+      end
+
+      def self.add_wrapped_class(klass)
+        _wrapped_classes << klass
+        @_wrapped_labels = nil
+      end
+
+
+      def self._wrapped_classes
+        Neo4j::ActiveNode::Labels::WRAPPED_CLASSES
+      end
+
+      protected
+
+      # Only for testing purpose
+      # @private
+      def self._wrapped_labels=(wl)
+        @_wrapped_labels=(wl)
+      end
+
+      def self._wrapped_labels
+        @_wrapped_labels ||=  _wrapped_classes.inject({}) do |ack, clazz|
+          ack.tap do |a|
+            a[clazz.mapped_label_name.to_sym] = clazz if clazz.respond_to?(:mapped_label_name)
+          end
+        end
+      end
+
+      module ClassMethods
+
+        # Find all nodes/objects of this class, with given search criteria
+        # @param [Hash, nil] args the search critera or nil if finding all
+        # @param [Neo4j::Session] session defaults to the current
+        def all(args = nil, session = Neo4j::Session.current)
+          if (args)
+            find_by_hash(args, session)
+          else
+            Neo4j::Label.find_all_nodes(mapped_label_name, session)
+          end
+        end
+
+        # @return [Fixnum] number of nodes of this class
+        def count(session = Neo4j::Session.current)
+          q = session.query("MATCH (n:`#{mapped_label_name}`) RETURN count(n) AS count")
+          q.to_a[0][:count]
+        end
+
+        # Same as #all but return only one object
+        # If given a String or Fixnum it will return the object with that neo4j id.
+        # @param [Hash,String,Fixnum] args search criteria
+        def find(args, session = Neo4j::Session.current)
+          case args
+            when Hash
+              find_by_hash(args, session).first
+            when String, Fixnum
+              Neo4j::Node.load(args)
+            else
+              raise "Unknown argument #{args.class} in find method"
+          end
+        end
+
+
+        # Destroy all nodes an connected relationships
+        def destroy_all
+          Neo4j::Session.current._query("MATCH (n:`#{mapped_label_name}`)-[r]-() DELETE n,r")
+          Neo4j::Session.current._query("MATCH (n:`#{mapped_label_name}`) DELETE n")
+        end
+
+        # Creates a Neo4j index on given property
+        # @param [Symbol] property the property we want a Neo4j index on
+        def index(property)
+          if Neo4j::Session.current
+            _index(property)
+          else
+            Neo4j::Session.add_listener do |event, _|
+              _index(property) if event == :session_available
+            end
+          end
+        end
+
+
+        # @return [Array{Symbol}] all the labels that this class has
+        def mapped_label_names
+          self.ancestors.find_all { |a| a.respond_to?(:mapped_label_name) }.map { |a| a.mapped_label_name.to_sym }
+        end
+
+        # @return [Symbol] the label that this class has which corresponds to a Ruby class
+        def mapped_label_name
+          @_label_name || self.to_s.to_sym
+        end
+
+        def indexed_labels
+
+        end
+
+        protected
+
+        def find_by_hash(hash, session)
+          Neo4j::Label.query(mapped_label_name, {conditions: hash}, session)
+        end
+
+        def _index(property)
+          mapped_labels.each do |label|
+            # make sure the property is not indexed twice
+            existing = label.indexes[:property_keys]
+            label.create_index(property) unless existing.flatten.include?(property)
+          end
+        end
+
+        def mapped_labels
+          mapped_label_names.map{|label_name| Neo4j::Label.create(label_name)}
+        end
+
+        def mapped_label
+          Neo4j::Label.create(mapped_label_name)
+        end
+
+        def set_mapped_label_name(name)
+          @_label_name = name.to_sym
+        end
+      end
+
+    end
+
+  end
+end

data/lib/neo4j/active_node/persistence.rb

@@ -0,0 +1,193 @@
+module Neo4j::ActiveNode
+  module Persistence
+    class RecordInvalidError < RuntimeError
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+        super(@record.errors.full_messages.join(", "))
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    # Saves the model.
+    #
+    # If the model is new a record gets created in the database, otherwise the existing record gets updated.
+    # If perform_validation is true validations run.
+    # If any of them fail the action is cancelled and save returns false. If the flag is false validations are bypassed altogether. See ActiveRecord::Validations for more information.
+    # There’s a series of callbacks associated with save. If any of the before_* callbacks return false the action is cancelled and save returns false.
+    def save(*)
+      create_or_update
+    end
+
+    # Creates a model with values matching those of the instance attributes and returns its id.
+    # @private
+    # @return true
+    def create_model(*)
+      node = _create_node(props)
+      init_on_load(node, node.props)
+      # Neo4j::IdentityMap.add(node, self)
+      # write_changed_relationships
+      true
+    end
+
+    # Persist the object to the database.  Validations and Callbacks are included
+    # by default but validation can be disabled by passing :validate => false
+    # to #save!  Creates a new transaction.
+    #
+    # @raise a RecordInvalidError if there is a problem during save.
+    # @param (see Neo4j::Rails::Validations#save)
+    # @return nil
+    # @see #save
+    # @see Neo4j::Rails::Validations Neo4j::Rails::Validations - for the :validate parameter
+    # @see Neo4j::Rails::Callbacks Neo4j::Rails::Callbacks - for callbacks
+    def save!(*args)
+      unless save(*args)
+        raise RecordInvalidError.new(self)
+      end
+    end
+
+    def create_or_update
+      # since the same model can be created or updated twice from a relationship we have to have this guard
+      @_create_or_updating = true
+      result = persisted? ? update_model : create_model
+      unless result != false
+        Neo4j::Transaction.current.fail if Neo4j::Transaction.current
+        false
+      else
+        true
+      end
+    rescue => e
+      Neo4j::Transaction.current.fail if Neo4j::Transaction.current
+      raise e
+    ensure
+      @_create_or_updating = nil
+    end
+
+    def exist?
+      _persisted_node && _persisted_node.exist?
+    end
+
+    # Returns +true+ if the object was destroyed.
+    def destroyed?
+      @_deleted || (!new_record? && !exist?)
+    end
+
+    # Returns +true+ if the record is persisted, i.e. it’s not a new record and it was not destroyed
+    def persisted?
+      !new_record? && !destroyed?
+    end
+
+    # Returns +true+ if the record hasn't been saved to Neo4j yet.
+    def new_record?
+      ! _persisted_node
+    end
+
+    alias :new? :new_record?
+
+    def destroy
+      _persisted_node && _persisted_node.del
+      @_deleted = true
+    end
+
+    def update_model
+      if @changed_attributes && !@changed_attributes.empty?
+        changed_props = attributes.select{|k,v| @changed_attributes.include?(k)}
+        _persisted_node.props = changed_props
+        @changed_attributes.clear
+      end
+    end
+
+    def _create_node(*args)
+      session = Neo4j::Session.current
+      props = args[0] if args[0].is_a?(Hash)
+      labels = self.class.mapped_label_names
+      session.create_node(props, labels)
+    end
+
+    # @return [Hash] all defined and none nil properties
+    def props
+      attributes.reject{|k,v| v.nil?}.symbolize_keys
+    end
+
+    # @return true if the attributes hash has been frozen
+    def frozen?
+      freeze_if_deleted
+      @attributes.frozen?
+    end
+
+    def freeze
+      @attributes.freeze
+      self
+    end
+
+    def freeze_if_deleted
+      unless new_record?
+        # TODO - Neo4j::IdentityMap.remove_node_by_id(neo_id)
+        unless self.class.load_entity(neo_id)
+          @_deleted = true
+          freeze
+        end
+      end
+    end
+
+    def reload
+      return self if new_record?
+      @changed_attributes && @changed_attributes.clear
+      unless reload_from_database
+        @_deleted = true
+        freeze
+      end
+      self
+    end
+
+    def reload_from_database
+      # TODO - Neo4j::IdentityMap.remove_node_by_id(neo_id)
+      if reloaded = self.class.load_entity(neo_id)
+        send(:attributes=, reloaded.attributes)
+      end
+      reloaded
+    end
+
+    # Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
+    # If saving fails because the resource is invalid then false will be returned.
+    def update(attributes)
+      self.attributes = attributes
+      save
+    end
+    alias_method :update_attributes, :update
+
+    # Same as {#update_attributes}, but raises an exception if saving fails.
+    def update!(attributes)
+      self.attributes = attributes
+      save!
+    end
+    alias_method :update_attributes!, :update!
+
+    module ClassMethods
+      # Creates a saves a new node
+      # @param [Hash] props the properties the new node should have
+      def create(props = {})
+        new(props).tap do |obj|
+          obj.save
+        end
+      end
+
+      # Same as #create, but raises an error if there is a problem during save.
+      def create!(*args)
+        new(*args).tap do |o|
+          yield o if block_given?
+          o.save!
+        end
+      end
+
+      def load_entity(id)
+        Neo4j::Node.load(id)
+      end
+
+    end
+
+  end
+
+end