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

data/lib/neo4j/active_node/property.rb

@@ -1,183 +1,10 @@
 module Neo4j::ActiveNode
   module Property
     extend ActiveSupport::Concern
-
-    include ActiveAttr::Attributes
-    include ActiveAttr::MassAssignment
-    include ActiveAttr::TypecastedAttributes
-    include ActiveAttr::AttributeDefaults
-    include ActiveAttr::QueryAttributes
-    include ActiveModel::Dirty
-
-    class UndefinedPropertyError < RuntimeError; end
-    class MultiparameterAssignmentError < StandardError; end
-
-    def initialize(attributes={}, options={})
-      attributes = process_attributes(attributes)
-
-      writer_method_props = extract_writer_methods!(attributes)
-      validate_attributes!(attributes)
-      writer_method_props.each do |key, value|
-        self.send("#{key}=", value)
-      end
-
-      super(attributes, options)
-    end
-
-    # Returning nil when we get ActiveAttr::UnknownAttributeError from ActiveAttr
-    def read_attribute(name)
-      super(name)
-    rescue ActiveAttr::UnknownAttributeError
-      nil
-    end
-    alias_method :[], :read_attribute
-
-    def default_properties=(properties)
-      keys = self.class.default_properties.keys
-      @default_properties = properties.reject{|key| !keys.include?(key)}
-    end
-
-    def default_property(key)
-      keys = self.class.default_properties.keys
-      keys.include?(key.to_sym) ? default_properties[key.to_sym] : nil
-    end
-
-    def default_properties
-      @default_properties ||= {}
-      # keys = self.class.default_properties.keys
-      # _persisted_node.props.reject{|key| !keys.include?(key)}
-    end
-
-
-    private
-
-    # Changes attributes hash to remove relationship keys
-    # Raises an error if there are any keys left which haven't been defined as properties on the model
-    def validate_attributes!(attributes)
-      invalid_properties = attributes.keys.map(&:to_s) - self.attributes.keys
-      raise UndefinedPropertyError, "Undefined properties: #{invalid_properties.join(',')}" if invalid_properties.size > 0
-    end
-
-    def extract_writer_methods!(attributes)
-      attributes.keys.inject({}) do |writer_method_props, key|
-        writer_method_props[key] = attributes.delete(key) if self.respond_to?("#{key}=")
-
-        writer_method_props
-      end
-    end
-
-    # Gives support for Rails date_select, datetime_select, time_select helpers.
-    def process_attributes(attributes = nil)
-      multi_parameter_attributes = {}
-      new_attributes = {}
-      attributes.each_pair do |key, value|
-        if key =~ /\A([^\(]+)\((\d+)([if])\)$/
-          found_key, index = $1, $2.to_i
-          (multi_parameter_attributes[found_key] ||= {})[index] = value.empty? ? nil : value.send("to_#{$3}")
-        else
-          new_attributes[key] = value
-        end
-      end
-
-      multi_parameter_attributes.empty? ? new_attributes : process_multiparameter_attributes(multi_parameter_attributes, new_attributes)
-    end
-
-    def process_multiparameter_attributes(multi_parameter_attributes, new_attributes)
-      multi_parameter_attributes.each_pair do |key, values|
-        begin
-          values = (values.keys.min..values.keys.max).map { |i| values[i] }
-          field = self.class.attributes[key.to_sym]
-          new_attributes[key] = instantiate_object(field, values)
-        rescue => e
-          raise MultiparameterAssignmentError, "error on assignment #{values.inspect} to #{key}"
-        end
-      end
-      new_attributes
-    end
-
-    def instantiate_object(field, values_with_empty_parameters)
-      return nil if values_with_empty_parameters.all? { |v| v.nil? }
-      values = values_with_empty_parameters.collect { |v| v.nil? ? 1 : v }
-      klass = field[:type]
-      if klass
-        klass.new(*values)
-      else
-        values
-      end
-    end
+    include Neo4j::Shared::Property
 
     module ClassMethods
 
-      # Defines a property on the class
-      #
-      # See active_attr gem for allowed options, e.g which type
-      # Notice, in Neo4j you don't have to declare properties before using them, see the neo4j-core api.
-      #
-      # @example Without type
-      #    class Person
-      #      # declare a property which can have any value
-      #      property :name
-      #    end
-      #
-      # @example With type and a default value
-      #    class Person
-      #      # declare a property which can have any value
-      #      property :score, type: Integer, default: 0
-      #    end
-      #
-      # @example With an index
-      #    class Person
-      #      # declare a property which can have any value
-      #      property :name, index: :exact
-      #    end
-      #
-      # @example With a constraint
-      #    class Person
-      #      # declare a property which can have any value
-      #      property :name, constraint: :unique
-      #    end
-      def property(name, options={})
-        magic_properties(name, options)
-        attribute(name, options)
-
-        # either constraint or index, do not set both
-        if options[:constraint]
-          raise "unknown constraint type #{options[:constraint]}, only :unique supported" if options[:constraint] != :unique
-          constraint(name, type: :unique)
-        elsif options[:index]
-          raise "unknown index type #{options[:index]}, only :exact supported" if options[:index] != :exact
-          index(name, options) if options[:index] == :exact
-        end
-      end
-
-      def default_property(name, &block)
-        default_properties[name] = block
-      end
-
-      # @return [Hash<Symbol,Proc>]
-      def default_properties
-        @default_property ||= {}
-      end
-
-      def default_property_values(instance)
-        default_properties.inject({}) do |result,pair|
-          result.tap{|obj| obj[pair[0]] = pair[1].call(instance)}
-        end
-      end
-
-      def attribute!(name, options={})
-        super(name, options)
-        define_method("#{name}=") do |value|
-          typecast_value = typecast_attribute(typecaster_for(self.class._attribute_type(name)), value)
-          send("#{name}_will_change!") unless typecast_value == read_attribute(name)
-          super(value)
-        end
-      end
-
-      def cached_class?
-        !!Neo4j::Config[:cache_class_names]
-      end
-
       # 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)
@@ -187,26 +14,6 @@ module Neo4j::ActiveNode
           association_props
         end
       end
-
-      private
-
-      # Tweaks properties
-      def magic_properties(name, options)
-        set_stamp_type(name, options)
-        set_time_as_datetime(options)
-      end
-
-      def set_stamp_type(name, options)
-        options[:type] = DateTime if (name.to_sym == :created_at || name.to_sym == :updated_at)
-      end
-
-      # ActiveAttr does not handle "Time", Rails and Neo4j.rb 2.3 did
-      # Convert it to DateTime in the interest of consistency
-      def set_time_as_datetime(options)
-        options[:type] = DateTime if options[:type] == Time
-      end
-
     end
   end
-
 end

data/lib/neo4j/active_node/rels.rb

@@ -4,8 +4,8 @@ module Neo4j::ActiveNode
     def_delegators :_rels_delegator, :rel?, :rel, :rels, :node, :nodes, :create_rel
 
     def _rels_delegator
-      raise "Can't access relationship on a non persisted node" unless _persisted_node
-      _persisted_node
+      raise "Can't access relationship on a non persisted node" unless _persisted_obj
+      _persisted_obj
     end
   end
 end

data/lib/neo4j/active_node/validations.rb

@@ -3,33 +3,8 @@ module Neo4j
     # This mixin replace the original save method and performs validation before the save.
     module Validations
       extend ActiveSupport::Concern
+      include Neo4j::Shared::Validations
 
-      include ActiveModel::Validations
-
-      module ClassMethods
-        def validates_uniqueness_of(*attr_names)
-          validates_with UniquenessValidator, _merge_attributes(attr_names)
-        end
-      end
-
-      # Implements the ActiveModel::Validation hook method.
-      # @see http://rubydoc.info/docs/rails/ActiveModel/Validations:read_attribute_for_validation
-      def read_attribute_for_validation(key)
-        respond_to?(key) ? send(key) : self[key]
-      end
-
-      # The validation process on save can be skipped by passing false. The regular Model#save method is
-      # replaced with this when the validations module is mixed in, which it is by default.
-      # @param [Hash] options the options to create a message with.
-      # @option options [true, false] :validate if false no validation will take place
-      # @return [Boolean] true if it saved it successfully
-      def save(options={})
-        result = perform_validations(options) ? super : false
-        if !result
-          Neo4j::Transaction.current.failure if Neo4j::Transaction.current
-        end
-        result
-      end
 
       # @return [Boolean] true if valid
       def valid?(context = nil)
@@ -38,6 +13,13 @@ module Neo4j
         errors.empty?
       end
 
+      module ClassMethods
+        def validates_uniqueness_of(*attr_names)
+          validates_with UniquenessValidator, _merge_attributes(attr_names)
+        end
+      end
+
+
       class UniquenessValidator < ::ActiveModel::EachValidator
         def initialize(options)
           super(options.reverse_merge(:case_sensitive => true))
@@ -57,8 +39,7 @@ module Neo4j
 
           # prevent that same object is returned
           # TODO: add negative condtion to not return current record
-          found = record.class.where(conditions).to_a
-          found.delete(record)
+          found = record.class.where(conditions).to_a.select{|f| f.neo_id != record.neo_id}
 
           if found.count > 0
             record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
@@ -76,19 +57,6 @@ module Neo4j
         end
       end
 
-      private
-      def perform_validations(options={})
-        perform_validation = case options
-                               when Hash
-                                 options[:validate] != false
-                             end
-
-        if perform_validation
-          valid?(options.is_a?(Hash) ? options[:context] : nil)
-        else
-          true
-        end
-      end
     end
   end
 end

data/lib/neo4j/active_rel.rb

@@ -0,0 +1,34 @@
+module Neo4j
+
+  # Makes Neo4j Relationships more or less act like ActiveRecord objects.
+  module ActiveRel
+    extend ActiveSupport::Concern
+
+    include Neo4j::Shared
+    include Neo4j::ActiveRel::Initialize
+    include Neo4j::ActiveRel::Property
+    include Neo4j::ActiveRel::Persistence
+    include Neo4j::ActiveRel::Validations
+    include Neo4j::ActiveRel::Callbacks
+    include Neo4j::ActiveRel::Query
+
+    class FrozenRelError < StandardError; end
+
+    def initialize(*args)
+      load_nodes
+      super
+    end
+
+    def neo4j_obj
+      _persisted_obj || raise("Tried to access native neo4j object on a non persisted object")
+    end
+
+    included do
+      def self.inherited(other)
+        super
+      end
+
+      cache_class unless cached_class?
+    end
+  end
+end

data/lib/neo4j/active_rel/callbacks.rb

@@ -0,0 +1,13 @@
+module Neo4j
+  module ActiveRel
+    module Callbacks #:nodoc:
+      extend ActiveSupport::Concern
+      include Neo4j::Shared::Callbacks
+
+      def save(*args)
+        raise Neo4j::ActiveRel::Persistence::RelInvalidError.new(self) unless self.persisted? || (from_node.respond_to?(:neo_id) && to_node.respond_to?(:neo_id))
+        super(*args)
+      end
+    end
+  end
+end

data/lib/neo4j/active_rel/initialize.rb

@@ -0,0 +1,30 @@
+module Neo4j::ActiveRel
+  module Initialize
+    extend ActiveSupport::Concern
+    include Neo4j::TypeConverters
+
+    attr_reader :_persisted_obj
+
+    # called when loading the rel from the database
+    # @param [Hash] properties properties of this relationship
+    # @param [Neo4j::Relationship] start_node the starting node in the relationship.
+    # @param [Neo4j::Relationship] end_node the ending node in the relationship
+    # @param [String] type the relationship type
+    def init_on_load(persisted_rel, start_node_id, end_node_id, type)
+      @_persisted_obj = persisted_rel
+      @rel_type = type
+      changed_attributes && changed_attributes.clear
+      @attributes = attributes.merge(persisted_rel.props.stringify_keys)
+      load_nodes(start_node_id, end_node_id)
+      self.default_properties = persisted_rel.props
+      @attributes = convert_properties_to :ruby, @attributes
+    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
+end

data/lib/neo4j/active_rel/persistence.rb

@@ -0,0 +1,80 @@
+module Neo4j::ActiveRel
+  module Persistence
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Persistence
+
+    class RelInvalidError < RuntimeError
+      attr_reader :record
+
+      def initialize(record)
+        @record = record
+        super(@record.errors.full_messages.join(", "))
+      end
+    end
+
+    class ModelClassInvalidError < RuntimeError; end
+
+    def save(*)
+      update_magic_properties
+      create_or_update
+    end
+
+    def save!(*args)
+      unless save(*args)
+        raise RelInvalidError.new(self)
+      end
+    end
+
+    def create_model(*)
+      confirm_node_classes
+      create_magic_properties
+      set_timestamps
+      properties = convert_properties_to :db, props
+      rel = _create_rel(properties)
+      init_on_load(rel, to_node, from_node, @rel_type)
+      true
+    end
+
+    module ClassMethods
+
+      # Creates a new relationship between objects
+      # @param [Hash] props the properties the new relationship should have
+      def create(props = {})
+        relationship_props = extract_association_attributes!(props) || {}
+        new(props).tap do |obj|
+          relationship_props.each do |prop, value|
+            obj.send("#{prop}=", value)
+          end
+          obj.save
+        end
+      end
+
+      # Same as #create, but raises an error if there is a problem during save.
+      def create!(*args)
+        unless create(*args)
+          raise RelInvalidError.new(self)
+        end
+      end
+    end
+
+    private 
+
+    def confirm_node_classes
+      [from_node, to_node].each do |node|
+        check = from_node == node ? :_from_class : :_to_class
+        next if self.class.send(check) == :any
+        unless self.class.send(check) == node.class        
+          raise ModelClassInvalidError, "Node class was #{node.class}, expected #{self.class.send(check)}" 
+        end
+      end
+    end
+
+    def _create_rel(*args)
+      session = self.class.neo4j_session
+      props = self.class.default_property_values(self)
+      props.merge!(args[0]) if args[0].is_a?(Hash)
+      set_classname(props)
+      from_node.create_rel(type, to_node, props)
+    end
+  end
+end