neo4j 5.2.15 → 6.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38cd85964af293a07fd75a42606a47264cd51690
-  data.tar.gz: a27b352ae9e88488999eb092b3770c2178128e5f
+  metadata.gz: cb4da367af9c6c6253c1d7f744ea39807a8c15b7
+  data.tar.gz: 17b6b00c6b522b83aa27ca9ba1780542a15ae8bc
 SHA512:
-  metadata.gz: 7e473d4a8e2073ea4ff6431367ae091b2edfe1efdd0ce10732fefc81d89fb8dbb214b4e90595acc5e76cb347a61f61a329db039e17e7cb8913ed7af30c36be57
-  data.tar.gz: 16b1783907ac3e73ef5fd9f0dadae744c38da72906e6c49d15d5cc3e6439633298e0ff33e0b5e9a7d0b237e0e5e9e31a0d0715c30ad39c52e62ddb4f66093191
+  metadata.gz: 97d79f821bf11cb74a5b53a964a5796c74a266775a2cebc6669bfa104f727dddf654fca104cc2c1dcd3cf9eb6f6e2babb8f0a625144bf360383f5343f6f6c76f
+  data.tar.gz: f2c614f9b21c87942f0f50ae0bf0131edc3a6a41023d551594d1cb8e0cf7f7dca7480d2ca8fdd4e6da9f4a1333b9e376a547572b87ae9d4e8e81736dd8e1a769

data/CHANGELOG.md

@@ -3,32 +3,30 @@ All notable changes to this project will be documented in this file.
 This file should follow the standards specified on [http://keepachangelog.com/]
 This project adheres to [Semantic Versioning](http://semver.org/).
 
-## [5.2.15] - 10-27-2015
+## [6.0.0.alpha.1] - 10-12-2015
 
-### Fixed
-
-- `#with_associations` should use multiple `OPTIONAL MATCH` clauses instead of one so that matches are independent (behavior changed in Neo4j 2.3.0)
-
-## [5.2.13] - 10-26-2015
-
-### Fixed
-- Fixed `#after_initialize` and `#after_find` callbacks.
-- The `#touch` method should to raise errors when unsuccessful and avoid `#attributes` for performance.
+### Changed
 
-## [5.2.12] - 10-25-2015
+- Refactoring around indexing and constraints in `Neo4j::ActiveNode`. The public interfaces are unchanged.
+- `Neo4j::Shared::DeclaredPropertyManager` was renamed `Neo4j::Shared::DeclaredProperties`. All methods referencing the old name were updated to reflect this.
+- Methods that were using `Neo4j::Session#on_session_available` were updated to reflect the upstream change to `on_next_session_available`.
+- `rel_where` will now use ActiveRel classes for type conversion, when possible.
+- Converters will look for a `converted?` method to determine whether an object is of the appropriate type for the database. This allows converters to be responsible for multiple types, if required.
+- Removed the ability to set both an exact index and unique constraint on the same property in a model. Unique constraints also provide exact indexes.
+- Deprecated all methods in ActiveRel's Query module except for those that allow finding by id.
+- Return `true` on successful `#save!` calls (Thanks to jmdeldin)
 
-### Fixed
-- Fix the `#touch` method for `ActiveNode` and `ActiveRel`
+### Added
 
-## [5.2.11] - 10-18-2015
+- New classes for schema operations, predictably called `Neo4j::Schema::Operation` and subclasses `UniqueConstraintOperation` and `ExactIndexOperation`. These provide methods to aid in the additional, removal, and presence checking of indexes and constraints.
+- A few methods were added to `Neo4j::Shared::DeclaredProperties` to make it easier to work with. In particular, `[key]` acts as a shortcut for `DeclaredProperties#registered_properties`.
+- Type Converters were added for String, Integer, Fixnum, BigDecimal, and Boolean to provide type conversion for these objects in QueryProxy.
+- Support for Array arguments to ActiveRel's `from_class` and `to_class`.
 
 ### Fixed
-- Unable to give additional options as first argument to chained QueryProxy method
 
-## [5.2.10] - 10-14-2015
-
-### Fixed
-- `has_one` does not define `_id` methods if they are already defined.  Also use `method_defined?` instead of `respond_to?` since it is at the class level
+- Certain actions that were intended as once-in-the-app's-lifetime events, notably schema operations, will only occur immediately upon the first session's establishment.
+- Context now set for Model.all QueryProxy so that logs can reflect that it wasn't just a raw Cypher query
 
 ## [5.2.9] - 09-30-2015
 

data/Gemfile

@@ -2,7 +2,7 @@ source 'http://rubygems.org'
 
 gemspec
 
-# gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: '5.1.x'
+gem 'neo4j-core', github: 'neo4jrb/neo4j-core', branch: 'master'
 # gem 'neo4j-core', path: '../neo4j-core'
 
 # gem 'active_attr', github: 'neo4jrb/active_attr', branch: 'performance'

data/lib/neo4j.rb

@@ -25,12 +25,14 @@ require 'neo4j/shared/type_converters'
 require 'neo4j/shared/rel_type_converters'
 require 'neo4j/type_converters'
 require 'neo4j/paginated'
+require 'neo4j/schema/operation'
 
 require 'neo4j/timestamps'
 
 require 'neo4j/shared/callbacks'
+require 'neo4j/shared/declared_property/index'
 require 'neo4j/shared/declared_property'
-require 'neo4j/shared/declared_property_manager'
+require 'neo4j/shared/declared_properties'
 require 'neo4j/shared/property'
 require 'neo4j/shared/persistence'
 require 'neo4j/shared/validations'
@@ -60,6 +62,7 @@ require 'neo4j/active_node/query/query_proxy_enumerable'
 require 'neo4j/active_node/query/query_proxy_find_in_batches'
 require 'neo4j/active_node/query/query_proxy_eager_loading'
 require 'neo4j/active_node/query/query_proxy_link'
+require 'neo4j/active_node/labels/index'
 require 'neo4j/active_node/labels/reloading'
 require 'neo4j/active_node/labels'
 require 'neo4j/active_node/id_property/accessor'

data/lib/neo4j/active_node.rb

@@ -59,25 +59,16 @@ module Neo4j
 
       def self.inherited(other)
         inherit_id_property(other)
-        inherited_indexes(other) if self.respond_to?(:indexed_properties)
-        attributes.each_pair { |k, v| other.attributes[k] = v }
-        inherit_serialized_properties(other) if self.respond_to?(:serialized_properties)
-        Neo4j::ActiveNode::Labels.add_wrapped_class(other)
+        attributes.each_pair do |k, v|
+          other.inherit_property k.to_sym, v.clone, declared_properties[k].options
+        end
 
+        Neo4j::ActiveNode::Labels.add_wrapped_class(other)
         super
       end
 
-      def self.inherited_indexes(other)
-        return if indexed_properties.nil?
-        self.indexed_properties.each { |property| other.index property }
-      end
-
-      def self.inherit_serialized_properties(other)
-        other.serialized_properties = self.serialized_properties
-      end
-
       def self.inherit_id_property(other)
-        Neo4j::Session.on_session_available do |_|
+        Neo4j::Session.on_next_session_available do |_|
           next if other.manual_id_property? || !self.id_property?
           id_prop = self.id_property_info
           conf = id_prop[:type].empty? ? {auto: :uuid} : id_prop[:type]
@@ -85,7 +76,7 @@ module Neo4j
         end
       end
 
-      Neo4j::Session.on_session_available do |_|
+      Neo4j::Session.on_next_session_available do |_|
         next if manual_id_property?
         id_property :uuid, auto: :uuid unless self.id_property?
 

data/lib/neo4j/active_node/has_n.rb

@@ -22,7 +22,7 @@ module Neo4j::ActiveNode
       # Default
       def inspect
         if @cached_result
-          @cached_result.inspect
+          result_nodes.inspect
         else
           "#<AssociationProxy @query_proxy=#{@query_proxy.inspect}>"
         end
@@ -36,7 +36,15 @@ module Neo4j::ActiveNode
       include Enumerable
 
       def each(&block)
-        result.each(&block)
+        result_nodes.each(&block)
+      end
+
+      def ==(other)
+        self.to_a == other.to_a
+      end
+
+      def +(other)
+        self.to_a + other
       end
 
       def result
@@ -47,11 +55,30 @@ module Neo4j::ActiveNode
         @cached_result
       end
 
+      def result_nodes
+        return result if !@query_proxy.model
+
+        @cached_result = result.map do |object|
+          object.is_a?(Neo4j::ActiveNode) ? object : @query_proxy.model.find(object)
+        end
+      end
+
+      def result_ids
+        result.map do |object|
+          object.is_a?(Neo4j::ActiveNode) ? object.id : object
+        end
+      end
+
       def cache_result(result)
         @cached_result = result
         @enumerable = (@cached_result || @query_proxy)
       end
 
+      def add_to_cache(object)
+        @cached_result ||= []
+        @cached_result << object
+      end
+
       def cache_query_proxy_result
         @query_proxy.to_a.tap do |result|
           cache_result(result)
@@ -74,7 +101,7 @@ module Neo4j::ActiveNode
         super if target.nil?
 
         cache_query_proxy_result if !cached? && !target.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
-        clear_cache_result if target.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
+        clear_cache_result if !QUERY_PROXY_METHODS.include?(method_name) && target.is_a?(Neo4j::ActiveNode::Query::QueryProxy)
 
         target.public_send(method_name, *args, &block)
       end
@@ -123,9 +150,13 @@ module Neo4j::ActiveNode
       self.class.send(:association_query_proxy, name, {start_object: self}.merge!(options))
     end
 
+    def association_proxy_hash(name, options = {})
+      [name.to_sym, options.values_at(:node, :rel, :labels, :rel_length)].hash
+    end
+
     def association_proxy(name, options = {})
       name = name.to_sym
-      hash = [name, options.values_at(:node, :rel, :labels, :rel_length)].hash
+      hash = association_proxy_hash(name, options)
       association_proxy_cache_fetch(hash) do
         if result_cache = self.instance_variable_get('@source_query_proxy_result_cache')
           result_by_previous_id = previous_proxy_results_by_previous_id(result_cache, name)
@@ -301,7 +332,10 @@ module Neo4j::ActiveNode
         define_method(name) do |node = nil, rel = nil, options = {}|
           # return [].freeze unless self._persisted_obj
 
-          options, node = node, nil if node.is_a?(Hash)
+          if node.is_a?(Hash)
+            options = node
+            node = nil
+          end
 
           association_proxy(name, {node: node, rel: rel, source_object: self, labels: options[:labels]}.merge!(options))
         end
@@ -311,8 +345,6 @@ module Neo4j::ActiveNode
         define_has_many_id_methods(name)
 
         define_class_method(name) do |node = nil, rel = nil, options = {}|
-          options, node = node, nil if node.is_a?(Hash)
-
           association_proxy(name, {node: node, rel: rel, labels: options[:labels]}.merge!(options))
         end
       end
@@ -327,7 +359,7 @@ module Neo4j::ActiveNode
 
       def define_has_many_id_methods(name)
         define_method_unless_defined("#{name.to_s.singularize}_ids") do
-          association_proxy(name).pluck(:uuid)
+          association_proxy(name).result_ids
         end
 
         define_method_unless_defined("#{name.to_s.singularize}_ids=") do |ids|
@@ -340,7 +372,7 @@ module Neo4j::ActiveNode
       end
 
       def define_method_unless_defined(method_name, &block)
-        define_method(method_name, block) unless method_defined?(method_name)
+        define_method(method_name, block) unless respond_to?(method_name)
       end
 
       def define_has_one_methods(name)
@@ -351,38 +383,37 @@ module Neo4j::ActiveNode
         define_has_one_id_methods(name)
 
         define_class_method(name) do |node = nil, rel = nil, options = {}|
-          options, node = node, nil if node.is_a?(Hash)
-
           association_proxy(name, {node: node, rel: rel, labels: options[:labels]}.merge!(options))
         end
       end
 
       def define_has_one_id_methods(name)
-        define_method_unless_defined("#{name}_id") do
-          association_proxy(name).pluck(:uuid).first
+        define_method("#{name}_id") do
+          association_proxy(name).result_ids.first
         end
 
         define_method_unless_defined("#{name}_id=") do |id|
           association_proxy(name).replace_with(id)
         end
 
-        define_method_unless_defined("#{name}_neo_id") do
+        define_method("#{name}_neo_id") do
           association_proxy(name).pluck(:neo_id).first
         end
       end
 
       def define_has_one_getter(name)
         define_method(name) do |node = nil, rel = nil, options = {}|
-          return nil unless self._persisted_obj
-
-          options, node = node, nil if node.is_a?(Hash)
+          if node.is_a?(Hash)
+            options = node
+            node = nil
+          end
 
           # Return all results if a variable-length relationship length was given
-          results = association_proxy(name, {node: node, rel: rel}.merge!(options))
+          association_proxy = association_proxy(name, {node: node, rel: rel}.merge!(options))
           if options[:rel_length] && !options[:rel_length].is_a?(Fixnum)
-            results
+            association_proxy
           else
-            results.result.first
+            association_proxy.result_nodes.first
           end
         end
       end
@@ -395,7 +426,7 @@ module Neo4j::ActiveNode
             Neo4j::Transaction.run { association_proxy(name).replace_with(other_node) }
             # handle_non_persisted_node(other_node)
           else
-            association_proxy(name).defer_create(other_node, {}, :'=')
+            association_proxy(name).defer_create(other_node)
           end
         end
       end

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

@@ -179,7 +179,7 @@ module Neo4j
 
         def apply_vars_from_options(options)
           @relationship_class_name = options[:rel_class] && options[:rel_class].to_s
-          @relationship_type  = options[:type] && options[:type].to_sym
+          @relationship_type = options[:type] && options[:type].to_sym
 
           @model_class = options[:model_class]
           @callbacks = {before: options[:before], after: options[:after]}

data/lib/neo4j/active_node/id_property.rb

@@ -140,7 +140,7 @@ module Neo4j::ActiveNode
 
       def id_property(name, conf = {})
         self.manual_id_property = true
-        Neo4j::Session.on_session_available do |_|
+        Neo4j::Session.on_next_session_available do |_|
           @id_property_info = {name: name, type: conf}
           TypeMethods.define_id_methods(self, name, conf)
           constraint(name, type: :unique) unless conf[:constraint] == false

data/lib/neo4j/active_node/id_property/accessor.rb

@@ -28,7 +28,7 @@ module Neo4j::ActiveNode::IdProperty
         @default_property_key ||= default_properties_keys.first
       end
 
-      # TODO: Move this to the DeclaredPropertyManager
+      # TODO: Move this to the DeclaredProperties
       def default_property(name, &block)
         reset_default_properties(name) if default_properties.respond_to?(:size)
         default_properties[name] = block

data/lib/neo4j/active_node/labels.rb

@@ -3,6 +3,7 @@ module Neo4j
     # Provides a mapping between neo4j labels and Ruby classes
     module Labels
       extend ActiveSupport::Concern
+      include Neo4j::ActiveNode::Labels::Index
       include Neo4j::ActiveNode::Labels::Reloading
 
       WRAPPED_CLASSES = []
@@ -84,13 +85,13 @@ module Neo4j
         def find(id)
           map_id = proc { |object| object.respond_to?(:id) ? object.send(:id) : object }
 
-          result =  if id.is_a?(Array)
-                      find_by_ids(id.map { |o| map_id.call(o) })
-                    else
-                      find_by_id(map_id.call(id))
-                    end
+          result = if id.is_a?(Array)
+                     find_by_ids(id.map { |o| map_id.call(o) })
+                   else
+                     find_by_id(map_id.call(id))
+                   end
           fail Neo4j::RecordNotFound if result.blank?
-          result.tap { |r| find_callbacks!(r) }
+          result
         end
 
         # Finds the first record matching the specified conditions. There is no implied ordering so if order matters, you should specify it yourself.
@@ -116,71 +117,6 @@ module Neo4j
           all.each(&:destroy)
         end
 
-        # Creates a Neo4j index on given property
-        #
-        # This can also be done on the property directly, see Neo4j::ActiveNode::Property::ClassMethods#property.
-        #
-        # @param [Symbol] property the property we want a Neo4j index on
-        # @param [Hash] conf optional property configuration
-        #
-        # @example
-        #   class Person
-        #      include Neo4j::ActiveNode
-        #      property :name
-        #      index :name
-        #    end
-        #
-        # @example with constraint
-        #   class Person
-        #      include Neo4j::ActiveNode
-        #      property :name
-        #
-        #      # below is same as: index :name, index: :exact, constraint: {type: :unique}
-        #      index :name, constraint: {type: :unique}
-        #    end
-        def index(property, conf = {})
-          Neo4j::Session.on_session_available do |_|
-            drop_constraint(property, type: :unique) if Neo4j::Label.constraint?(mapped_label_name, property)
-            _index(property, conf)
-          end
-          indexed_properties.push property unless indexed_properties.include? property
-        end
-
-        # Creates a neo4j constraint on this class for given property
-        #
-        # @example
-        #   Person.constraint :name, type: :unique
-        #
-        def constraint(property, constraints)
-          Neo4j::Session.on_session_available do |session|
-            unless Neo4j::Label.constraint?(mapped_label_name, property)
-              label = Neo4j::Label.create(mapped_label_name)
-              drop_index(property, label) if index?(property)
-              label.create_constraint(property, constraints, session)
-            end
-          end
-        end
-
-        # @param [Symbol] property The name of the property index to be dropped
-        # @param [Neo4j::Label] label An instance of label from Neo4j::Core
-        def drop_index(property, label = nil)
-          label_obj = label || Neo4j::Label.create(mapped_label_name)
-          label_obj.drop_index(property)
-        end
-
-        # @param [Symbol] property The name of the property constraint to be dropped
-        # @param [Hash] constraint The constraint type to be dropped.
-        def drop_constraint(property, constraint = {type: :unique})
-          Neo4j::Session.on_session_available do |session|
-            label = Neo4j::Label.create(mapped_label_name)
-            label.drop_constraint(property, constraint, session)
-          end
-        end
-
-        def index?(index_def)
-          mapped_label.indexes[:property_keys].include?([index_def])
-        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 }
@@ -196,10 +132,6 @@ module Neo4j
           Neo4j::Label.create(mapped_label_name)
         end
 
-        def indexed_properties
-          @_indexed_properties ||= []
-        end
-
         def base_class
           unless self < Neo4j::ActiveNode
             fail "#{name} doesn't belong in a hierarchy descending from ActiveNode"
@@ -212,23 +144,8 @@ module Neo4j
           end
         end
 
-
         protected
 
-        def _index(property, conf)
-          mapped_labels.each do |label|
-            # make sure the property is not indexed twice
-            existing = label.indexes[:property_keys]
-
-            # In neo4j constraint automatically creates an index
-            if conf[:constraint]
-              constraint(property, conf[:constraint])
-            else
-              label.create_index(property) unless existing.flatten.include?(property)
-            end
-          end
-        end
-
         def mapped_labels
           mapped_label_names.map { |label_name| Neo4j::Label.create(label_name) }
         end
@@ -247,17 +164,6 @@ module Neo4j
 
         private
 
-        def find_callbacks!(result)
-          case result
-          when Neo4j::ActiveNode
-            result.run_callbacks(:find)
-          when Array
-            result.each { |r| find_callbacks!(r) }
-          else
-            result
-          end
-        end
-
         def label_for_model
           (self.name.nil? ? object_id.to_s.to_sym : decorated_label_name)
         end