neo4j 3.0.0.alpha.9 → 3.0.0.alpha.10

data/lib/neo4j/active_rel/property.rb

@@ -0,0 +1,64 @@
+
+module Neo4j::ActiveRel
+  module Property
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Property
+
+    %w[to_node from_node].each do |direction|
+      define_method("#{direction}") { instance_variable_get("@#{direction}") }
+      define_method("#{direction}=") do |argument|
+        raise FrozenRelError, "Relationship start/end nodes cannot be changed once persisted" if self.persisted?
+        instance_variable_set("@#{direction}", argument)
+      end
+    end
+
+    alias_method :start_node, :from_node
+    alias_method :end_node,   :to_node
+
+    def type
+      self.class._type
+    end
+
+    module ClassMethods
+
+      # Extracts keys from attributes hash which are relationships of the model
+      # TODO: Validate separately that relationships are getting the right values?  Perhaps also store the values and persist relationships on save?
+      def extract_association_attributes!(attributes)
+        attributes.keys.inject({}) do |relationship_props, key|
+          relationship_props[key] = attributes.delete(key) if key == :from_node || key == :to_node
+
+          relationship_props
+        end
+      end
+
+      %w[to_class from_class].each do |direction|
+        define_method("#{direction}") { |argument| instance_variable_set("@#{direction}", argument) }
+        define_method("_#{direction}") { instance_variable_get "@#{direction}" }
+      end
+
+      alias_method :start_class,  :from_class
+      alias_method :end_class,    :to_class
+
+      def type(type = nil)
+        @rel_type = type
+      end
+
+      def _type
+        @rel_type
+      end
+
+      def load_entity(id)
+        Neo4j::Node.load(id)
+      end
+
+    end
+
+    private
+
+    def load_nodes(start_node=nil, end_node=nil)
+      @from_node = RelatedNode.new(end_node)
+      @to_node = RelatedNode.new(start_node)
+    end
+
+  end
+end

data/lib/neo4j/active_rel/query.rb

@@ -0,0 +1,66 @@
+module Neo4j::ActiveRel
+  module Query
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      include Enumerable
+
+      # Returns the object with the specified neo4j id.
+      # @param [String,Fixnum] id of node to find
+      # @param [Neo4j::Session] session optional
+      def find(id, session = self.neo4j_session)
+        raise "Unknown argument #{id.class} in find method (expected String or Fixnum)" if not [String, Fixnum].include?(id.class)
+        find_by_id(id, session)
+      end
+
+      def find_by_id(key, session = Neo4j::Session.current!)
+        Neo4j::Relationship.load(key.to_i, session)
+      end
+
+      # TODO make this not awful
+      def where(args={})
+        @query = if self._from_class == :any
+          Neo4j::Session.query("MATCH n1-[r1:`#{self._type}`]->(#{cypher_node_string(:inbound)}) WHERE #{where_string(args)} RETURN r1")
+        else
+          self._from_class.query_as(:n1).match("(#{cypher_node_string(:outbound)})-[r1:`#{self._type}`]->(#{cypher_node_string(:inbound)})").where(Hash["r1" => args])
+        end
+        return self
+      end
+
+      def each
+        if self._from_class == :any
+          @query.map(&:r1)
+        else
+          @query.pluck(:r1)
+        end.each {|r| yield r }
+      end
+
+      def first
+        if self._from_class == :any
+          @query.map(&:r1)
+        else
+          @query.pluck(:r1)
+        end.first
+      end
+
+      def cypher_node_string(dir)
+        case dir
+        when :outbound
+          node_identifier, dir_class = 'n1', self._from_class
+        when :inbound
+          node_identifier, dir_class = 'n2', self._to_class
+        end
+        dir_class == :any ? node_identifier : "#{node_identifier}:`#{dir_class.name}`"
+      end
+
+      private
+
+      def where_string(args)
+        args.map do |k, v|
+          v.is_a?(Integer) ? "r1.#{k} = #{v}" : "r1.#{k} = '#{v}'"
+        end.join(', ')
+      end
+
+    end
+  end
+end

data/lib/neo4j/active_rel/rel_wrapper.rb

@@ -0,0 +1,18 @@
+class Neo4j::Relationship
+
+  module Wrapper
+    def wrapper
+      props.symbolize_keys!
+      return self unless props.is_a?(Hash) && props.has_key?(Neo4j::Config.class_name_property)
+      begin
+      found_class = props[Neo4j::Config.class_name_property].constantize
+      rescue NameError
+        return self
+      end
+      wrapped_rel = found_class.new
+      wrapped_rel.init_on_load(self, self._start_node_id, self._end_node_id, self.rel_type)
+      wrapped_rel
+    end
+  end
+
+end

data/lib/neo4j/active_rel/related_node.rb

@@ -0,0 +1,42 @@
+module Neo4j::ActiveRel
+  # A container for ActiveRel's :inbound and :outbound methods. It provides lazy loading of nodes.
+  class RelatedNode
+
+    class InvalidParameterError < StandardError
+      def message
+        'RelatedNode must be initialized with either a node ID or node'
+      end
+    end
+
+    def initialize(node = nil)
+      @node = valid_node_param?(node) ? node : (raise InvalidParameterError.new(self))
+    end
+
+    def == (obj)
+      loaded if @node.is_a?(Fixnum)
+      @node == obj
+    end
+
+    def loaded
+      @node = @node.respond_to?(:neo_id) ? @node : Neo4j::Node.load(@node)
+    end
+
+    def loaded?
+      @node.respond_to?(:neo_id)
+    end
+
+    def method_missing(*args, &block)
+      loaded.send(*args, &block)
+    end
+
+    def class
+      loaded.send(:class)
+    end
+
+    private
+
+    def valid_node_param?(node)
+      node.nil? || node.is_a?(Integer) || node.respond_to?(:neo_id)
+    end
+  end
+end

data/lib/neo4j/active_rel/validations.rb

@@ -0,0 +1,9 @@
+module Neo4j
+  module ActiveRel
+    module Validations
+      extend ActiveSupport::Concern
+      include Neo4j::Shared::Validations
+
+    end
+  end
+end

data/lib/neo4j/shared.rb

@@ -0,0 +1,34 @@
+module Neo4j
+  module Shared
+    extend ActiveSupport::Concern
+    extend ActiveModel::Naming
+
+    include ActiveModel::Conversion
+    include ActiveModel::Serializers::Xml
+    include ActiveModel::Serializers::JSON
+
+    include Neo4j::Shared::Identity
+
+    module ClassMethods
+      def neo4j_session_name (name)
+        @neo4j_session_name = name
+      end
+
+      def neo4j_session
+        if @neo4j_session_name
+          Neo4j::Session.named(@neo4j_session_name) || raise("#{self.name} is configured to use a neo4j session named #{@neo4j_session_name}, but no such session is registered with Neo4j::Session")
+        else
+          Neo4j::Session.current
+        end
+      end
+    end
+
+    included do
+      self.include_root_in_json = true
+
+      def self.i18n_scope
+        :neo4j
+      end
+    end
+  end
+end

data/lib/neo4j/shared/callbacks.rb

@@ -0,0 +1,40 @@
+module Neo4j
+  module Shared
+    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 → shared}/identity.rb

@@ -1,4 +1,4 @@
-module Neo4j::ActiveNode
+module Neo4j::Shared
   module Identity
     def ==(o)
       o.class == self.class && o.id == id
@@ -13,12 +13,16 @@ module Neo4j::ActiveNode
 
     # @return [Fixnum, nil] the neo4j id of the node if persisted or nil
     def neo_id
-      _persisted_node ? _persisted_node.neo_id : nil
+      _persisted_obj ? _persisted_obj.neo_id : nil
     end
 
     def id
       id = neo_id
       id.is_a?(Integer) ? id : nil
     end
+
+    def hash
+      id.hash
+    end
   end
 end

data/lib/neo4j/shared/persistence.rb

@@ -0,0 +1,214 @@
+module Neo4j::Shared
+  module Persistence
+
+    class RecordInvalidError < RuntimeError
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+        super(@record.errors.full_messages.join(", "))
+      end
+    end
+
+    extend ActiveSupport::Concern
+    include Neo4j::TypeConverters
+
+    # 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(*)
+      update_magic_properties
+      create_or_update
+    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 update_model
+      if changed_attributes && !changed_attributes.empty?
+        changed_props = attributes.select{|k,v| changed_attributes.include?(k)}
+        changed_props = convert_properties_to :db, changed_props
+        _persisted_obj.update_props(changed_props)
+        changed_attributes.clear
+      end
+    end
+
+
+    # Convenience method to set attribute and #save at the same time
+    # @param [Symbol, String] attribute of the attribute to update
+    # @param [Object] value to set
+    def update_attribute(attribute, value)
+      send("#{attribute}=", value)
+      self.save
+    end
+
+    # Convenience method to set attribute and #save! at the same time
+    # @param [Symbol, String] attribute of the attribute to update
+    # @param [Object] value to set
+    def update_attribute!(attribute, value)
+      send("#{attribute}=", value)
+      self.save!
+    end
+
+    # Convenience method to set multiple attributes and #save at the same time
+    # @param [Hash] attributes of names and values of attributes to set
+    def update_attributes(attributes)
+      assign_attributes(attributes)
+      self.save
+    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
+
+    # 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_obj
+    end
+
+    alias :new? :new_record?
+
+    def destroy
+      _persisted_obj && _persisted_obj.del
+      @_deleted = true
+    end
+
+    def exist?
+      _persisted_obj && _persisted_obj.exist?
+    end
+
+    # Returns +true+ if the object was destroyed.
+    def destroyed?
+      @_deleted || (!new_record? && !exist?)
+    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!
+
+    def cache_key
+      if self.new_record?
+        "#{self.class.model_name.cache_key}/new"
+      elsif self.respond_to?(:updated_at) && !self.updated_at.blank?
+        "#{self.class.model_name.cache_key}/#{neo_id}-#{self.updated_at.utc.to_s(:number)}" 
+      else
+        "#{self.class.model_name.cache_key}/#{neo_id}"
+      end
+    end
+
+    private
+
+    def create_magic_properties
+    end
+
+    def update_magic_properties
+      self.updated_at = DateTime.now if respond_to?(:updated_at=) && changed?
+    end
+
+    def set_classname(props)
+      props[:_classname] = self.class.name if self.class.cached_class?
+    end
+
+    # def assign_attributes(attributes)
+    #   attributes.each do |attribute, value|
+    #     send("#{attribute}=", value)
+    #   end
+    # end
+
+    def set_timestamps
+      self.created_at = DateTime.now if respond_to?(:created_at=)
+      self.updated_at = self.created_at if respond_to?(:updated_at=)
+    end
+
+  end
+end