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

data/lib/neo4j/shared/property.rb

@@ -0,0 +1,220 @@
+module Neo4j::Shared
+  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
+    class IllegalPropertyError < StandardError; end
+
+    ILLEGAL_PROPS = %w[from_node to_node start_node end_node]
+
+    def initialize(attributes={}, options={})
+      attributes = process_attributes(attributes)
+      relationship_props = self.class.extract_association_attributes!(attributes)
+      writer_method_props = extract_writer_methods!(attributes)
+      validate_attributes!(attributes)
+      send_props(writer_method_props) unless writer_method_props.nil?
+      send_props(relationship_props) unless relationship_props.nil?
+
+      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_obj.props.reject{|key| !keys.include?(key)}
+    end
+
+    def send_props(hash)
+      hash.each do |key, value|
+        self.send("#{key}=", value)
+      end
+    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
+
+    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={})
+        check_illegal_prop(name)
+        magic_properties(name, options)
+        attribute(name, options)
+        constraint_or_index(name, options)
+      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
+
+      private
+
+      def constraint_or_index(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 check_illegal_prop(name)
+        if ILLEGAL_PROPS.include?(name.to_s)
+          raise IllegalPropertyError, "#{name} is an illegal property"
+        end
+      end
+
+      # 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/shared/validations.rb

@@ -0,0 +1,48 @@
+module Neo4j
+  module Shared
+    module Validations
+      extend ActiveSupport::Concern
+      include ActiveModel::Validations
+      # 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)
+        context     ||= (new_record? ? :create : :update)
+        super(context)
+        errors.empty?
+      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/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "3.0.0.alpha.9"
+  VERSION = "3.0.0.alpha.10"
 end

data/lib/neo4j/wrapper.rb

@@ -1,52 +1,4 @@
-class Neo4j::Node
-
-  module Wrapper
-
-    # this is a plugin in the neo4j-core so that the Ruby wrapper will be wrapped around the Neo4j::Node objects
-    def wrapper
-      most_concrete_class = sorted_wrapper_classes
-      wrapped_node = most_concrete_class.new
-      wrapped_node.init_on_load(self, self.props)
-      wrapped_node
-    end
-
-    def checked_labels_set
-      @@_checked_labels_set ||= Set.new
-    end
-
-    def check_label(label_name)
-      unless checked_labels_set.include?(label_name)
-        load_class_from_label(label_name)
-        # do this only once
-        checked_labels_set.add(label_name)
-      end
-    end
-
-    def sorted_wrapper_classes
-      if self.props.is_a?(Hash) && self.props.has_key?(Neo4j::Config.class_name_property)
-        self.props[Neo4j::Config.class_name_property].constantize
-      else
-        wrappers = _class_wrappers
-        return self if wrappers.nil?
-        wrapper_classes = wrappers.map{|w| Neo4j::ActiveNode::Labels._wrapped_labels[w]}
-        wrapper_classes.sort.first
-      end
-    end
-
-    def load_class_from_label(label_name)
-      begin
-        label_name.to_s.split("::").inject(Kernel) {|container, name| container.const_get(name.to_s) }
-      rescue NameError
-        nil
-      end
-    end
-
-    def _class_wrappers
-      labels.find_all do |label_name|
-        check_label(label_name)
-        Neo4j::ActiveNode::Labels._wrapped_labels[label_name].class == Class
-      end
-    end
+module Neo4j
+  module ClassWrapper
   end
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 3.0.0.alpha.9
+  version: 3.0.0.alpha.10
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-14 00:00:00.000000000 Z
+date: 2014-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -119,23 +119,36 @@ files:
 - lib/neo4j/active_node/callbacks.rb
 - lib/neo4j/active_node/has_n.rb
 - lib/neo4j/active_node/has_n/association.rb
-- lib/neo4j/active_node/has_n/nodes.rb
 - lib/neo4j/active_node/id_property.rb
-- lib/neo4j/active_node/identity.rb
 - lib/neo4j/active_node/initialize.rb
 - lib/neo4j/active_node/labels.rb
+- lib/neo4j/active_node/node_wrapper.rb
 - lib/neo4j/active_node/orm_adapter.rb
 - lib/neo4j/active_node/persistence.rb
 - lib/neo4j/active_node/property.rb
 - lib/neo4j/active_node/query.rb
 - lib/neo4j/active_node/query/query_proxy.rb
-- lib/neo4j/active_node/quick_query.rb
 - lib/neo4j/active_node/rels.rb
 - lib/neo4j/active_node/serialized_properties.rb
 - lib/neo4j/active_node/validations.rb
+- lib/neo4j/active_rel.rb
+- lib/neo4j/active_rel/callbacks.rb
+- lib/neo4j/active_rel/initialize.rb
+- lib/neo4j/active_rel/persistence.rb
+- lib/neo4j/active_rel/property.rb
+- lib/neo4j/active_rel/query.rb
+- lib/neo4j/active_rel/rel_wrapper.rb
+- lib/neo4j/active_rel/related_node.rb
+- lib/neo4j/active_rel/validations.rb
 - lib/neo4j/config.rb
 - lib/neo4j/paginated.rb
 - lib/neo4j/railtie.rb
+- lib/neo4j/shared.rb
+- lib/neo4j/shared/callbacks.rb
+- lib/neo4j/shared/identity.rb
+- lib/neo4j/shared/persistence.rb
+- lib/neo4j/shared/property.rb
+- lib/neo4j/shared/validations.rb
 - lib/neo4j/type_converters.rb
 - lib/neo4j/version.rb
 - lib/neo4j/wrapper.rb

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

@@ -1,90 +0,0 @@
-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
-          "[#{@decl_rel.dir}, from: #{@node.neo_id} type: #{@decl_rel.rel_type} has_one #{@decl_rel.has_one?}]"
-        end
-
-        def inspect
-          to_s
-        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
-
-        def ==(other)
-          self.to_a == other.to_a
-        end
-        alias_method :eql?, :==
-
-        # 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, relationship_props = {})
-          @decl_rel.create_relationship_to(@node, other, relationship_props)
-        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) ? false : self
-        end
-      end
-
-    end
-  end
-end