neo4j 3.0.4 → 4.0.0.rc.1

data/lib/neo4j/active_rel.rb

@@ -1,17 +1,20 @@
 module Neo4j
 
   # Makes Neo4j Relationships more or less act like ActiveRecord objects.
+  # See documentation at https://github.com/neo4jrb/neo4j/wiki/Neo4j%3A%3AActiveRel
   module ActiveRel
     extend ActiveSupport::Concern
 
     include Neo4j::Shared
     include Neo4j::ActiveRel::Initialize
     include Neo4j::Shared::Identity
+    include Neo4j::Shared::SerializedProperties
     include Neo4j::ActiveRel::Property
     include Neo4j::ActiveRel::Persistence
     include Neo4j::ActiveRel::Validations
     include Neo4j::ActiveRel::Callbacks
     include Neo4j::ActiveRel::Query
+    include Neo4j::ActiveRel::Types
 
     class FrozenRelError < StandardError; end
 
@@ -28,8 +31,8 @@ module Neo4j
       def self.inherited(other)
         super
       end
-
-      cache_class unless cached_class?
     end
+
+    ActiveSupport.run_load_hooks(:active_rel, self)
   end
 end

data/lib/neo4j/paginated.rb

@@ -8,7 +8,7 @@ module Neo4j
     end
 
     def self.create_from(source, page, per_page, order = nil)
-      target = source.node_var
+      target = source.node_var || source.identity
       partial = source.skip((page - 1) * per_page).limit(per_page)
       ordered_partial, ordered_source = if order
                                           [partial.order_by(order), source.query.with("#{target} as #{target}").pluck("COUNT(#{target})").first]

data/lib/neo4j/shared/persistence.rb

@@ -2,7 +2,9 @@ module Neo4j::Shared
   module Persistence
 
     extend ActiveSupport::Concern
-    include Neo4j::TypeConverters
+    include Neo4j::Shared::TypeConverters
+
+    USES_CLASSNAME = []
 
     def update_model
       if changed_attributes && !changed_attributes.empty?
@@ -153,16 +155,50 @@ module Neo4j::Shared
     end
 
     def update_magic_properties
-      self.updated_at = DateTime.now if respond_to?(:updated_at=) && changed?
+      self.updated_at = DateTime.now if respond_to?(:updated_at=) && changed? && !updated_at_changed?
     end
 
-    def set_classname(props)
-      props[:_classname] = self.class.name if self.class.cached_class?
+    # Inserts the _classname property into an object's properties during object creation.
+    def set_classname(props, check_version = true)
+      props[:_classname] = self.class.name if self.class.cached_class?(check_version)
     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=)
+      now = DateTime.now
+      self.created_at ||= now if respond_to?(:created_at=)
+      self.updated_at ||= now if respond_to?(:updated_at=)
+    end
+
+    module ClassMethods
+      # Determines whether a model should insert a _classname property. This can be used to override the automatic matching of returned
+      # objects to models.
+      def cached_class?(check_version = true)
+        uses_classname? || (!!Neo4j::Config[:cache_class_names] && (check_version ? neo4j_session.version < '2.1.5' : true))
+      end
+
+      # @return [Boolean] status of whether this model will add a _classname property
+      def uses_classname?
+        Neo4j::Shared::Persistence::USES_CLASSNAME.include?(self.name)
+      end
+
+      # Adds this model to the USES_CLASSNAME array. When new rels/nodes are created, a _classname property will be added. This will override the
+      # automatic matching of label/rel type to model.
+      #
+      # You'd want to do this if you have multiple models for the same label or relationship type. When it comes to labels, there isn't really any
+      # reason to do this because you can have multiple labels; on the other hand, an argument can be made for doing this with relationships since
+      # rel type is a bit more restrictive.
+      #
+      # It could also be speculated that there's a slight performance boost to using _classname since the gem immediately knows what model is responsible
+      # for a returned object. At the same time, it is a bit restrictive and changing it can be a bit of a PITA. Use carefully!
+      def set_classname
+        Neo4j::Shared::Persistence::USES_CLASSNAME << self.name
+      end
+
+      # Removes this model from the USES_CLASSNAME array. When new rels/nodes are create, no _classname property will be injected. Upon returning of
+      # the object from the database, it will be matched to a model using its relationship type or labels.
+      def unset_classname
+        Neo4j::Shared::Persistence::USES_CLASSNAME.delete self.name
+      end
     end
   end
-end
+end

data/lib/neo4j/shared/property.rb

@@ -184,16 +184,12 @@ module Neo4j::Shared
       def attribute!(name, options={})
         super(name, options)
         define_method("#{name}=") do |value|
-          typecast_value = typecast_attribute(typecaster_for(self.class._attribute_type(name)), value)
+          typecast_value = typecast_attribute(_attribute_typecaster(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)
@@ -220,7 +216,7 @@ module Neo4j::Shared
       end
 
       def set_stamp_type(name, options)
-        options[:type] = DateTime if (name.to_sym == :created_at || name.to_sym == :updated_at)
+        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

data/lib/neo4j/shared/rel_type_converters.rb

@@ -0,0 +1,44 @@
+module Neo4j::Shared
+
+  # This module controls changes to relationship type based on Neo4j::Config.transform_rel_type.
+  # It's used whenever a rel type is automatically determined based on ActiveRel model name or
+  # association type.
+  module RelTypeConverters
+
+    def decorated_rel_type(type)
+      @decorated_rel_type ||= Neo4j::Shared::RelTypeConverters.decorated_rel_type(type)
+    end
+
+    class << self
+      # Determines how relationship types should look when inferred based on association or ActiveRel model name.
+      # With the exception of `:none`, all options will call `underscore`, so `ThisClass` becomes `this_class`, with capitalization
+      # determined by the specific option passed.
+      # Valid options:
+      # * :upcase - `:this_class`, `ThisClass`, `thiS_claSs` (if you don't like yourself) becomes `THIS_CLASS`
+      # * :downcase - same as above, only... downcased.
+      # * :legacy - downcases and prepends `#`, so ThisClass becomes `#this_class`
+      # * :none - uses the string version of whatever is passed with no modifications
+      def rel_transformer
+        @rel_transformer ||= Neo4j::Config[:transform_rel_type].nil? ? :upcase : Neo4j::Config[:transform_rel_type]
+      end
+
+      # @param [String,Symbol] type The raw string or symbol to be used as the basis of the relationship type
+      # @return [String] A string that conforms to the set rel type conversion setting.
+      def decorated_rel_type(type)
+        type = type.to_s
+        case rel_transformer
+        when :upcase
+          type.underscore.upcase
+        when :downcase
+          type.underscore.downcase
+        when :legacy
+          "##{type.underscore.downcase}"
+        when :none
+          type
+        else
+          type.underscore.upcase
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/shared/serialized_properties.rb

@@ -0,0 +1,29 @@
+module Neo4j::Shared
+  # This module adds the `serialize` class method. It lets you store hashes and arrays in Neo4j properties.
+  # Be aware that you won't be able to search within serialized properties and stuff use indexes. If you do a regex search for portion of a string
+  # property, the search happens in Cypher and you may take a performance hit.
+  #
+  # See type_converters.rb for the serialization process.
+  module SerializedProperties
+    extend ActiveSupport::Concern
+
+    def serialized_properties
+      self.class.serialized_properties
+    end
+
+    module ClassMethods
+      def serialized_properties
+        @serialize || {}
+      end
+
+      def serialized_properties=(serialize_hash)
+        @serialize = serialize_hash.clone
+      end
+
+      def serialize(name, coder = JSON)
+        @serialize ||= {}
+        @serialize[name] = coder
+      end
+    end
+  end
+end

data/lib/neo4j/shared/type_converters.rb

@@ -0,0 +1,177 @@
+module Neo4j::Shared
+  module TypeConverters
+
+    # Converts Date objects to Java long types. Must be timezone UTC.
+    class DateConverter
+      class << self
+
+        def convert_type
+          Date
+        end
+
+        def to_db(value)
+          return nil if value.nil?
+          Time.utc(value.year, value.month, value.day).to_i
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Time.at(value).utc.to_date
+        end
+
+      end
+    end
+
+    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
+    class DateTimeConverter
+      class << self
+
+        def convert_type
+          DateTime
+        end
+
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # DateTime values are automatically converted to UTC.
+        def to_db(value)
+          return nil if value.nil?
+          value = value.new_offset(0) if value.respond_to?(:new_offset)
+          if value.class == Date
+            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          else
+            Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec).to_i
+          end
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          t = case value
+              when Fixnum
+                Time.at(value).utc
+              when String
+                DateTime.strptime(value, '%Y-%m-%d %H:%M:%S %z')
+              else
+                raise ArgumentError, "Invalid value type for DateType property: #{value.inspect}"
+              end
+
+          DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
+        end
+
+      end
+    end
+
+    class TimeConverter
+      class << self
+
+        def convert_type
+          Time
+        end
+
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_db(value)
+          return nil if value.nil?
+          if value.class == Date
+            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
+          else
+            value.utc.to_i
+          end
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Time.at(value).utc
+        end
+
+      end
+    end
+
+    # Converts hash to/from YAML
+    class YAMLConverter
+      class << self
+
+        def convert_type
+          Hash
+        end
+
+        def to_db(value)
+          return nil if value.nil?
+          Psych.dump(value)
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Psych.load(value)
+        end
+      end
+    end
+
+    # Converts hash to/from JSON
+    class JSONConverter
+      class << self
+
+        def convert_type
+          JSON
+        end
+
+        def to_db(value)
+          return nil if value.nil?
+          value.to_json
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          JSON.parse(value, quirks_mode: true)
+        end
+      end
+    end
+
+
+
+    def convert_properties_to(medium, properties)
+      # Perform type conversion
+      serialize = self.respond_to?(:serialized_properties) ? self.serialized_properties : {}
+      properties = properties.inject({}) do |new_attributes, key_value_pair|
+        attr, value = key_value_pair
+
+        # skip "secret" undeclared attributes such as uuid
+        next new_attributes unless self.class.attributes[attr]
+
+        type = serialize.has_key?(attr.to_sym) ? serialize[attr.to_sym] : self.class._attribute_type(attr)
+        new_attributes[attr] = if TypeConverters.converters[type].nil?
+                                  value
+                                else
+                                  TypeConverters.send "to_#{medium}", value, type
+                                end
+        new_attributes
+      end
+    end
+
+    class << self
+
+      # Converts the value to ruby from a Neo4j database value if there is a converter for given type
+      def to_ruby(value, type = nil)
+        found_converter = converters[type]
+        found_converter ? found_converter.to_ruby(value) : value
+      end
+
+      # Converts the value to a Neo4j database value from ruby if there is a converter for given type
+      def to_db(value, type = nil)
+        found_converter = converters[type]
+        found_converter ? found_converter.to_db(value) : value
+      end
+
+      def converters
+        @converters ||= begin
+          Neo4j::Shared::TypeConverters.constants.find_all do |c|
+            Neo4j::Shared::TypeConverters.const_get(c).respond_to?(:convert_type)
+          end.map do  |c|
+            Neo4j::Shared::TypeConverters.const_get(c)
+          end.inject({}) do |ack, t|
+            ack[t.convert_type] = t
+            ack
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/type_converters.rb

@@ -1,170 +1,7 @@
 module Neo4j
-
   module TypeConverters
-
-    # Converts Date objects to Java long types. Must be timezone UTC.
-    class DateConverter
-      class << self
-
-        def convert_type
-          Date
-        end
-
-        def to_db(value)
-          return nil if value.nil?
-          Time.utc(value.year, value.month, value.day).to_i
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          Time.at(value).utc.to_date
-        end
-
-      end
-    end
-
-    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
-    class DateTimeConverter
-      class << self
-
-        def convert_type
-          DateTime
-        end
-
-        # Converts the given DateTime (UTC) value to an Fixnum.
-        # DateTime values are automatically converted to UTC.
-        def to_db(value)
-          return nil if value.nil?
-          value = value.new_offset(0) if value.respond_to?(:new_offset)
-          if value.class == Date
-            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
-          else
-            Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec).to_i
-          end
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          t = Time.at(value).utc
-          DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
-        end
-
-      end
-    end
-
-    class TimeConverter
-      class << self
-
-        def convert_type
-          Time
-        end
-
-        # Converts the given DateTime (UTC) value to an Fixnum.
-        # Only utc times are supported !
-        def to_db(value)
-          return nil if value.nil?
-          if value.class == Date
-            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
-          else
-            value.utc.to_i
-          end
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          Time.at(value).utc
-        end
-
-      end
-    end
-
-    # Converts hash to/from YAML
-    class YAMLConverter
-      class << self
-
-        def convert_type
-          Hash
-        end
-
-        def to_db(value)
-          return nil if value.nil?
-          Psych.dump(value)
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          Psych.load(value)
-        end
-      end
-    end
-
-    # Converts hash to/from JSON
-    class JSONConverter
-      class << self
-
-        def convert_type
-          JSON
-        end
-
-        def to_db(value)
-          return nil if value.nil?
-          value.to_json
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          JSON.parse(value, quirks_mode: true)
-        end
-      end
-    end
-
-
-
-    def convert_properties_to(medium, properties)
-      # Perform type conversion
-      serialize = self.respond_to?(:serialized_properties) ? self.serialized_properties : {}
-      properties = properties.inject({}) do |new_attributes, key_value_pair|
-        attr, value = key_value_pair
-
-        # skip "secret" undeclared attributes such as uuid
-        next new_attributes unless self.class.attributes[attr]
-
-        type = serialize.has_key?(attr.to_sym) ? serialize[attr.to_sym] : self.class._attribute_type(attr)
-        new_attributes[attr] = if TypeConverters.converters[type].nil?
-                                  value
-                                else
-                                  TypeConverters.send "to_#{medium}", value, type
-                                end
-        new_attributes
-      end
-    end
-
-    class << self
-
-      # Converts the value to ruby from a Neo4j database value if there is a converter for given type
-      def to_ruby(value, type = nil)
-        found_converter = converters[type]
-        found_converter ? found_converter.to_ruby(value) : value
-      end
-
-      # Converts the value to a Neo4j database value from ruby if there is a converter for given type
-      def to_db(value, type = nil)
-        found_converter = converters[type]
-        found_converter ? found_converter.to_db(value) : value
-      end
-
-      def converters
-        @converters ||= begin
-          Neo4j::TypeConverters.constants.find_all do |c|
-            Neo4j::TypeConverters.const_get(c).respond_to?(:convert_type)
-          end.map do  |c|
-            Neo4j::TypeConverters.const_get(c)
-          end.inject({}) do |ack, t|
-            ack[t.convert_type] = t
-            ack
-          end
-        end
-      end
-    end
+    # This exists for legacy purposes. Some gems (*coughDevisecough*) that the Neo4jrb project does not own
+    # may contain references to this file. We will remove it once that has been dealt with.
+    include Neo4j::Shared::TypeConverters
   end
 end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "3.0.4"
+  VERSION = "4.0.0.rc.1"
 end

data/lib/neo4j.rb

@@ -19,6 +19,8 @@ require 'neo4j/config'
 require 'neo4j/wrapper'
 require 'neo4j/active_rel/rel_wrapper'
 require 'neo4j/active_node/node_wrapper'
+require 'neo4j/shared/type_converters'
+require 'neo4j/shared/rel_type_converters'
 require 'neo4j/type_converters'
 require 'neo4j/paginated'
 
@@ -27,6 +29,7 @@ require 'neo4j/shared/property'
 require 'neo4j/shared/persistence'
 require 'neo4j/shared/validations'
 require 'neo4j/shared/identity'
+require 'neo4j/shared/serialized_properties'
 require 'neo4j/shared'
 
 require 'neo4j/active_rel/callbacks'
@@ -36,6 +39,7 @@ require 'neo4j/active_rel/persistence'
 require 'neo4j/active_rel/validations'
 require 'neo4j/active_rel/query'
 require 'neo4j/active_rel/related_node'
+require 'neo4j/active_rel/types'
 require 'neo4j/active_rel'
 
 require 'neo4j/active_node/query_methods'
@@ -54,11 +58,11 @@ require 'neo4j/active_node/has_n'
 require 'neo4j/active_node/has_n/association'
 require 'neo4j/active_node/query/query_proxy'
 require 'neo4j/active_node/query'
-require 'neo4j/active_node/serialized_properties'
 require 'neo4j/active_node/scope'
 require 'neo4j/active_node'
 
 require 'neo4j/active_node/orm_adapter'
-require 'rails/generators'
-require 'rails/generators/neo4j_generator'
-
+if defined?(Rails)
+  require 'rails/generators'
+  require 'rails/generators/neo4j_generator'
+end

data/neo4j.gemspec

@@ -31,7 +31,7 @@ A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks h
   s.add_dependency("activesupport", "~> 4")
   s.add_dependency("railties", "~> 4")
   s.add_dependency('active_attr', "~> 0.8")
-  s.add_dependency("neo4j-core", "~> 3.0.8")
+  s.add_dependency("neo4j-core", "~> 3.1.0")
 
   if RUBY_PLATFORM =~ /java/
     s.add_dependency("neo4j-community", '~> 2.0')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neo4j
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 4.0.0.rc.1
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-15 00:00:00.000000000 Z
+date: 2014-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: orm_adapter
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.8
+        version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.8
+        version: 3.1.0
 description: |
   A Neo4j OGM (Object-Graph-Mapper) for use in Ruby on Rails and Rack frameworks heavily inspired by ActiveRecord.
 email: andreas.ronge@gmail.com
@@ -131,7 +131,6 @@ files:
 - lib/neo4j/active_node/reflection.rb
 - lib/neo4j/active_node/rels.rb
 - lib/neo4j/active_node/scope.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
@@ -141,6 +140,7 @@ files:
 - lib/neo4j/active_rel/query.rb
 - lib/neo4j/active_rel/rel_wrapper.rb
 - lib/neo4j/active_rel/related_node.rb
+- lib/neo4j/active_rel/types.rb
 - lib/neo4j/active_rel/validations.rb
 - lib/neo4j/config.rb
 - lib/neo4j/migration.rb
@@ -151,6 +151,9 @@ files:
 - lib/neo4j/shared/identity.rb
 - lib/neo4j/shared/persistence.rb
 - lib/neo4j/shared/property.rb
+- lib/neo4j/shared/rel_type_converters.rb
+- lib/neo4j/shared/serialized_properties.rb
+- lib/neo4j/shared/type_converters.rb
 - lib/neo4j/shared/validations.rb
 - lib/neo4j/tasks/migration.rake
 - lib/neo4j/type_converters.rb
@@ -182,12 +185,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.1
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: neo4j
-rubygems_version: 2.4.2
+rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
 summary: A graph database for Ruby