neo4j 3.0.0.alpha.8 → 3.0.0.alpha.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d97243db16c4dce2d4e87eb9551116729065fe2a
-  data.tar.gz: 311559376e0de462bbde5d9dae2d348c041fd3f6
+  metadata.gz: c1f7216c885708e2f7b3f094a4ab4266e83c37a0
+  data.tar.gz: 7350f7cd2f95de57873b607bda7a7a6357b29643
 SHA512:
-  metadata.gz: 197a923f6617ced1dab9a81adea38fb13fe55b5bd7429b4e84c461b53c2d98b31ff053ee2eb6228541792ba58309b3058d9dee4a0cece6ec68dff79eae921ac4
-  data.tar.gz: c1a71b84e759fd55ab9040c6d357d08cbdf22710e5e7eacbb7b4ddff01a3b07834a4e52c2dc378feb20a6d5c9a01891839216da5918d6ac4559b9e24cfcf87f2
+  metadata.gz: cf800fb8a523e06f163e837985600bfa84109f74b2b548e18bd99961adb28e3ee5703963fe34e8939688af842eb2dc3b4d7ae3d529412ef2ce3791fa924bb922
+  data.tar.gz: 3f0e91124dbe00b6f102d82c9f69117ecd9f4268c87d3f30600e145078ae28e155f69927415d8e106f93015ed4c694a4df9da540330d7cf929e5abd4ff23b6a2

data/CHANGELOG

@@ -1,3 +1,11 @@
+== 3.0.0.alpha.9
+* Complete rewrite of the query api, see wiki page (#406, chris, brian)
+* Performance improvements (#382,#400, #402, chris)
+* idproperty - user defined primary keys (#396,#389)
+* Reimplementation of Neo4j::Config
+* Serialization of node properties (#381)
+* Better first,last syntax (#379)
+
 == 3.0.0.alpha.8
 * Integration with new Query API from neo4j-core including:
 * - .query_as and #query_as methods to get queries from models (#366)

data/Gemfile

@@ -3,7 +3,7 @@ source 'http://rubygems.org'
 gemspec
 
 #gem 'neo4j-core', :path => '../neo4j-core'
-
+#gem 'neo4j-core', :git => 'https://github.com/andreasronge/neo4j-core.git'
 #gem 'orm_adapter', :path => '../orm_adapter'
 
 gem 'coveralls', require: false

data/config/neo4j/config.yml

@@ -1,98 +1,33 @@
 #=== Neo4j.rb configuration settings
 
-# The folder location of the neo4j and lucene database
-storage_path: db
 
-# If enable neo4j.rb will create _all relationship to all instances inheriting from Neo4j::Rails::Model
-# If disabled all custom rules will also be unavailable.
-enable_rules: true
+# Examples of not using the Neo4j id (neo_id)
 
+# Generated UUID stored as a neo4j property on my_id
+#id_property: my_id
+#id_property_type: :auto
+#id_property_type_value: :uuid
+
+# Example, (probably more useful directly on Neo4j::ActiveNode classes instead as a global configuration)
+#id_property: title_id
+#id_property_type: :on
+#id_property_type_value: :some_method
+
+# TODO
 # if identity map should be on or not
 # It may impact the performance. Using the identity map will keep all loaded wrapper node/relationship
 # object in memory for each thread and transaction - which may speed up or slow down operations.
 identity_map: false
 
+# TODO
 # When using the Neo4j::Model you can let neo4j automatically set timestamps when updating/creating nodes.
 # If set to true neo4j.rb automatically timestamps create and update operations if the model has properties named created_at/created_on or updated_at/updated_on
 # (similar to ActiveRecord).
 timestamps: true
 
-# Configuration for lucene
-lucene: { fulltext: { provider: lucene,
-                      type: fulltext },
-          exact:    { provider: lucene,
-                       type: exact}
-}
-
-## If online backup should be available, if it is the Online JAR file will be loaded,
-## Notice it must be either 'true' or 'false' as string
-#enable_online_backup: 'false'
-#
-##use the clustered Neo4j GraphDatabase (org.neo4j.kernel.HighlyAvailableGraphDatabase)
-#ha.db: false
-#
-## Example of HA Configuration, see http://wiki.neo4j.org/content/High_Availability_Cluster
-## This is only used when ha.db is set to true
-#ha.server_id: 2
-#ha.server: 'localhost:6002'
-#ha.coordinators: 'localhost:2181,localhost:2182,localhost:2183'
-#
-## if enabled you can use the bin/neo4j-shell command to access the database
-#enable_remote_shell: "port=9332"
-#
-##===Memory mapped I/O settings===
-#
-##Each file in the Neo store can use memory mapped I/O for reading/writing.
-##Best performance is achived if the full file can be memory mapped but if
-##there isn't enough memory for that Neo will try and make the best use of
-##the memory it gets (regions of the file that get accessed often will more
-##likley be memory mapped).
-#
-##For high traversal speed it is important to have the nodestore.db and
-##relationshipstore.db files.
-#
-#neostore.nodestore.db.mapped_memory: 25M
-#neostore.relationshipstore.db.mapped_memory: 50M
-#neostore.propertystore.db.mapped_memory: 90M
-#neostore.propertystore.db.index.mapped_memory: 1M
-#neostore.propertystore.db.index.keys.mapped_memory: 1M
-#neostore.propertystore.db.strings.mapped_memory: 130M
-#neostore.propertystore.db.arrays.mapped_memory: 130M
-#
-#
-##: ": ": "Cache settings: ": ": "
-#
-##use adaptive caches YES|NO. Let Neo try make best use of available heap.
-#use_adaptive_cache: YES
-#
-##heap usage/max heap size ratio. Neo will increase caches while ratio
-##is less and decrease if greater. Default 0.77 seems to be a good over
-##all ratio of heap usage to avoid GC trashing. Larger heaps may allow for
-##a higher ratio while tiny heaps may need even less.
-#adaptive_cache_heap_ratio: 0.77
-#
-##how aggressive Neo will decrease caches once heap ratio reached
-#adaptive_cache_manager_decrease_ratio: 1.15
-#
-##how aggresive Neo will increase caches if ratio isn't yet reached
-#adaptive_cache_manager_increase_ratio: 1.1
-#
-##if no requests are made to Neo this is the amount of time in ms Neo will wait
-##before it checks the heap usage and adapts the caches if needed
-#adaptive_cache_worker_sleep_time: 3000
-#
-##minimum size (number of nodes) of node cache. If adaptive cache is in use
-##node cache will not be decreased under this value
-#min_node_cache_size: 0
-#
-##minimum size (number of relationships) of relationship cache. If adaptive
-##cache is in use relationship cache will not be decreased under this value
-#min_relationship_cache_size: 0
-#
-##maximum size (number of nodes) of node cache. If adaptive cache is not in
-##use the node cache will not be increased above this value
-#max_node_cache_size: 1500
-#
-##maximum size (number of relationship) of node cache. If adaptive cache is
-##not in use the relationship cache will not be increased above this value
-#max_relationship_cache_size: 3500
+# Store a property on objects to cache their ActiveNode/ActiveRel class. It prevents each object load from requiring two database queries.
+# Strings shorter than 44 characters are classified, so this will have almost no impact on disk footprint. See http://docs.neo4j.org/chunked/stable/short-strings.html.
+# Alternatively, call class method Neo4j::ActiveNode:cache_class to set this on specific models.
+# By default, this property is called _classname, set as symbol to override.
+cache_class_names: true
+# class_name_property:  :_classname

data/lib/neo4j.rb

@@ -15,10 +15,12 @@ require 'active_support/concern'
 require 'active_support/core_ext/class/attribute.rb'
 
 require 'active_attr'
+require 'neo4j/config'
 require 'neo4j/wrapper'
 require 'neo4j/type_converters'
 require "neo4j/active_node/labels"
 require 'neo4j/active_node/identity'
+require 'neo4j/active_node/id_property'
 require 'neo4j/active_node/callbacks'
 require 'neo4j/active_node/initialize'
 require 'neo4j/active_node/property'
@@ -26,11 +28,12 @@ require 'neo4j/active_node/persistence'
 require 'neo4j/active_node/validations'
 require 'neo4j/active_node/rels'
 require 'neo4j/active_node/has_n'
-require 'neo4j/active_node/has_n/decl_rel'
+require 'neo4j/active_node/has_n/association'
 require 'neo4j/active_node/has_n/nodes'
 require 'neo4j/active_node/query/query_proxy'
 require 'neo4j/active_node/query'
-require 'neo4j/active_node/quick_query'
+require 'neo4j/active_node/serialized_properties'
+require 'neo4j/paginated'
 require 'neo4j/active_node'
 
 require 'neo4j/active_node/orm_adapter'

data/lib/neo4j.rb~

@@ -0,0 +1,40 @@
+require 'neo4j/version'
+
+#require "delegate"
+#require "time"
+#require "set"
+#
+#require "active_support/core_ext"
+#require "active_support/json"
+#require "active_support/inflector"
+#require "active_support/time_with_zone"
+
+require "neo4j-core"
+require "active_model"
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute.rb'
+
+require 'active_attr'
+require 'neo4j/wrapper'
+require 'neo4j/type_converters'
+require "neo4j/active_node/labels"
+require 'neo4j/active_node/identity'
+require 'neo4j/active_node/callbacks'
+require 'neo4j/active_node/initialize'
+require 'neo4j/active_node/property'
+require 'neo4j/active_node/persistence'
+require 'neo4j/active_node/validations'
+require 'neo4j/active_node/rels'
+require 'neo4j/active_node/has_n'
+require 'neo4j/active_node/has_n/decl_rel'
+require 'neo4j/active_node/has_n/nodes'
+require 'neo4j/active_node'
+
+require 'neo4j/active_node/orm_adapter'
+
+if defined? Rails::Generators # defined in 'rails/generators.rb'
+  # TODO, not sure this is the correct way of adding rails generators
+  # See https://github.com/andreasronge/neo4j/blob/gh-pages/neo4j.rb
+  # It is required from the rails config/application file
+  require 'rails/generators/neo4j_generator'
+end

data/lib/neo4j/active_node.rb

@@ -31,14 +31,16 @@ module Neo4j
 
     include Neo4j::ActiveNode::Initialize
     include Neo4j::ActiveNode::Identity
+    include Neo4j::ActiveNode::IdProperty
     include Neo4j::ActiveNode::Persistence
+    include Neo4j::ActiveNode::SerializedProperties
     include Neo4j::ActiveNode::Property
+    include Neo4j::ActiveNode::Query
     include Neo4j::ActiveNode::Labels
     include Neo4j::ActiveNode::Validations
     include Neo4j::ActiveNode::Callbacks
     include Neo4j::ActiveNode::Rels
     include Neo4j::ActiveNode::HasN
-    include Neo4j::ActiveNode::Query
 
     def wrapper
       self
@@ -71,12 +73,28 @@ module Neo4j
       end
 
       def self.inherited(other)
+        inherited_indexes(other) if self.respond_to?(:indexed_properties)
         attributes.each_pair do |k,v|
           other.attributes[k] = v
         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
+
+      Neo4j::Session.on_session_available do |_|
+        name = Neo4j::Config[:id_property]
+        type = Neo4j::Config[:id_property_type]
+        value = Neo4j::Config[:id_property_type_value]
+        if (name && type && value)
+          id_property(name, type => value)
+        end
+      end
+
     end
   end
 end

data/lib/neo4j/active_node/has_n.rb

@@ -2,155 +2,95 @@ module Neo4j::ActiveNode
   module HasN
     extend ActiveSupport::Concern
 
-    def _decl_rels_for(rel_type)
-      self.class._decl_rels[rel_type]
-    end
-
     module ClassMethods
 
-
-      def has_relationship?(rel_type)
-        !!_decl_rels[rel_type]
-      end
-
-      def has_one_relationship?(rel_type)
-        has_relationship?(rel_type) && _decl_rels[rel_type].has_one?
-      end
-
-      def relationship_dir(rel_type)
-        has_relationship?(rel_type) && _decl_rels[rel_type].dir
+      def has_association?(name)
+        !!associations[name]
       end
 
-      def _decl_rels
-        @_decl_rels ||= {}
+      def associations
+        @associations || {}
       end
 
       # make sure the inherited classes inherit the <tt>_decl_rels</tt> hash
       def inherited(klass)
-        copy = _decl_rels.clone
-        copy.each_pair { |k, v| copy[k] = v.inherit_new }
-        klass.instance_variable_set(:@_decl_rels, copy)
+        klass.instance_variable_set(:@associations, associations.clone)
+
         super
       end
 
+      def has_many(direction, name, options = {})
+        name = name.to_sym
 
-      # Specifies a relationship between two node active node classes.
-      # Generates assignment and accessor methods for the given relationship.
-      # Both incoming and outgoing relationships can be declared, see {Neo4j::ActiveNode::HasN::DeclRel}
-      #
-      # @example has_n(:files)
-      #
-      #   class FolderNode
-      #      include Neo4j::ActiveNode
-      #      has_n(:files)
-      #   end
-      #
-      #   folder = FolderNode.new
-      #   folder.files << Neo4j::Node.new << Neo4j::Node.new
-      #   folder.files.inject {...}
-      #
-      #   FolderNode.files #=> 'files' the name of the relationship
-      #
-      # @example has_n(x).to(...)
-      #
-      #   # You can declare which class it has relationship to.
-      #   # The generated relationships will be prefixed with the name of that class.
-      #   class FolderNode
-      #      include Neo4j::ActiveNode
-      #      has_n(:files).to(File)
-      #      # Same as has_n(:files).to("File")
-      #   end
-      #
-      #   FolderNode.files #=> 'File#files' the name of the relationship
-      #
-      # @example has_one(x).from(class, has_one_name)
-      #
-      #   # generate accessor method for traversing and adding relationship on incoming nodes.
-      #   class FileNode
-      #      include Neo4j::ActiveNode
-      #      has_one(:folder).from(FolderNode.files)
-      #      # or same as
-      #      has_one(:folder).from(FolderNode, :files)
-      #   end
-      #
-      #
-      # @return [Neo4j::ActiveNode::HasN::DeclRel] a DSL object where the has_n relationship can be further specified
-      def has_n(rel_type, *callbacks)
-        clazz = self
-        module_eval(%Q{def #{rel_type}=(values)
-                  #{rel_type}_rels.each {|rel| rel.del }
-
-                  dsl = _decl_rels_for('#{rel_type}'.to_sym)
-                  values.each do |value|
-                    dsl.create_relationship_to(self, value)
-                  end
-              end}, __FILE__, __LINE__)
+        association = Neo4j::ActiveNode::HasN::Association.new(:has_many, direction, name, options)
+        name = name.to_sym
 
-        module_eval(%Q{
-                def #{rel_type}()
-                    dsl = _decl_rels_for('#{rel_type}'.to_sym)
-                    Neo4j::ActiveNode::HasN::Nodes.new(self, dsl)
-                end}, __FILE__, __LINE__)
+        @associations ||= {}
+        @associations[name] = association
 
+        target_class_name = association.target_class_name || 'nil'
+
+        # TODO: Make assignment more efficient? (don't delete nodes when they are being assigned)
         module_eval(%Q{
-                def #{rel_type}_rels
-                    dsl = _decl_rels_for('#{rel_type}'.to_sym)
-                    dsl.all_relationships(self)
-                end}, __FILE__, __LINE__)
+          def #{name}(node = nil, rel = nil)
+            Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name}, self.class.associations[#{name.inspect}], session: self.class.neo4j_session, start_object: self, node: node, rel: rel)
+          end
+
+          def #{name}=(other_nodes)
+            #{name}(nil, :r).query_as(:n).delete(:r).exec
 
+            other_nodes.each do |node|
+              #{name} << node
+            end
+          end
+
+          def #{name}_rels
+            #{name}(nil, :r).pluck(:r)
+          end}, __FILE__, __LINE__)
 
         instance_eval(%Q{
-          def #{rel_type}
-            _decl_rels[:#{rel_type}].rel_type
+          def #{name}(node = nil, rel = nil)
+            Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name}, @associations[#{name.inspect}], session: self.neo4j_session, query_proxy: self.query_proxy, node: node, rel: rel)
           end}, __FILE__, __LINE__)
-        _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, false, clazz, *callbacks)
       end
 
+      def has_one(direction, name, options = {})
+        name = name.to_sym
 
-      # Specifies a relationship between two node classes.
-      # Generates assignment and accessor methods for the given relationship
-      # Old relationship is deleted when a new relationship is assigned.
-      # Both incoming and outgoing relationships can be declared, see {Neo4j::Wrapper::HasN::DeclRel}
-      #
-      # @example
-      #
-      #   class FileNode
-      #      include Neo4j::ActiveNode
-      #      has_one(:folder)
-      #   end
-      #
-      #   file = FileNode.create
-      #   file.folder = Neo4j::Node.create
-      #   file.folder # => the node above
-      #   file.folder_rel # => the relationship object between those nodes
-      #
-      # @return [Neo4j::ActiveNode::HasN::DeclRel] a DSL object where the has_one relationship can be futher specified
-      def has_one(rel_type, *callbacks)
-        clazz = self
-        module_eval(%Q{def #{rel_type}=(value)
-                  return if !value
-                  dsl = _decl_rels_for(:#{rel_type})
-                  rel = dsl.single_relationship(self)
-                  rel && rel.del
-                  dsl.create_relationship_to(self, value)
-              end}, __FILE__, __LINE__)
-
-        module_eval(%Q{def #{rel_type}
-                  dsl = _decl_rels_for('#{rel_type}'.to_sym)
-                  dsl.single_node(self)
-              end}, __FILE__, __LINE__)
-
-        module_eval(%Q{def #{rel_type}_rel
-                  dsl = _decl_rels_for(:#{rel_type})
-                  dsl.single_relationship(self)
-               end}, __FILE__, __LINE__)
+        association = Neo4j::ActiveNode::HasN::Association.new(:has_one, direction, name, options)
+        name = name.to_sym
 
-        instance_eval(%Q{
-          def #{rel_type}
-            _decl_rels[:#{rel_type}].rel_type
+        @associations ||= {}
+        @associations[name] = association
+
+        target_class_name = association.target_class_name || 'nil'
+
+        module_eval(%Q{
+          def #{name}=(other_node)
+            #{name}_query_proxy(rel: :r).query_as(:n).delete(:r).exec
+            #{name}_query_proxy << other_node
+          end
+
+          def #{name}_query_proxy(options = {})
+            self.class.#{name}_query_proxy({start_object: self}.merge(options))
+          end
+
+          def #{name}_rel
+            #{name}_query_proxy(rel: :r).pluck(:r).first
+          end
+
+          def #{name}(node = nil, rel = nil)
+            #{name}_query_proxy(node: node, rel: rel).first
           end}, __FILE__, __LINE__)
 
-        _decl_rels[rel_type.to_sym] = DeclRel.new(rel_type, true, clazz, *callbacks)
+        instance_eval(%Q{
+          def #{name}_query_proxy(options = {})
+            Neo4j::ActiveNode::Query::QueryProxy.new(#{target_class_name}, @associations[#{name.inspect}], {session: self.neo4j_session}.merge(options))
+          end
+
+          def #{name}(node = nil, rel = nil)
+            #{name}_query_proxy(query_proxy: self.query_proxy, node: node, rel: rel)
+          end}, __FILE__, __LINE__)
       end