neo4j 3.0.4 → 4.0.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf2546cbe829d338babc703fcecdeff5650e8fd5
-  data.tar.gz: 094b2019bb62cb8e9f5e510eb54cf00f51c6131f
+  metadata.gz: 122872ebd58702ee7d868124092285e8907cfbfd
+  data.tar.gz: 11989c0af301ccb1305df5deb26e9c55a20313f6
 SHA512:
-  metadata.gz: b7552de25d876bd2b98038637c517ae77c47c04ae5d3fbd0a14852710998a3549d1ce981a9c35eea94e84cf1dcc04f469497ae7c7eb9be45a76b77f813900bd8
-  data.tar.gz: ba45f543a6cbce758ccfba472789cfb41ba78ce8ee6fe70db8e187371a1a638e83c86a6dae316a4ff786046a61b2ab3a984001993d4150b30e9eee57c4b89fcd
+  metadata.gz: e9433059f7d5dd25d4bd22be97af295f98cbd1340f5bdf1c1869c01111b22d61bf8cf6e260d08de528c3cb90735984d069234fafe32556cd6b200c415b0d7243
+  data.tar.gz: c894497b7e00362c8145bdbf61bdd8b50f772f108b839ae068971bd32e888f502897ecfc03c4284bfd1f838815b75fe8dc41d3222ea61b0d1157d371a3ff325e

data/CHANGELOG

@@ -1,3 +1,25 @@
+== 4.0.0.rc.1
+This release introduces API changes that may be considered breaking under certain conditions. See See https://github.com/neo4jrb/neo4j/wiki/Neo4j.rb-v4-Introduction.
+Please use https://github.com/neo4jrb/neo4j/issues for support regarding this update! You can also reach us on Twitter: @neo4jrb (Brian) and @subvertallmedia (Chris).
+* Default behavior changed: relationship types default to all caps, no prepending of "#". This behavior can be changed.
+* ActiveRel models no longer require explicit calling of `type`. When missing, the model will infer a type using the class name following the same rules used to determine automatic relationship types from ActiveNode models.
+* _classname properties will not be added automatically if you are using a version Neo4j >= 2.1.5. Instead, models are found using labels or relationship type. This is a potentially breaking change, particularly where ActiveRel is concerned. See the link at the beginning of this message for the steps required to work around this.
+* Query scopes are now chainable! Call `all` at the start of your scope or method to take advantage of this.
+* Changes required for Neo4j 2.2.
+* Support for custom typecasters.
+* New method `rel_where`, expanded behavior of `match_to` and `first_rel_to`
+* Implemented ActiveSupport load hooks.
+* Assorted performance improvements and refactoring.
+
+== 3.0.4
+* Gemspec requires the latest neo4j-core.
+* Fixed a pagination bug — thanks, @chrisgogreen!
+* New QueryProxy methods `match_to` and `first_rel_to` are pretty cool.
+* include_root_in_json is now configurable through config.neo4j.include_root_in_json or Neo4j::Config[:include_root_in_json]. Also cool.
+* There's a new `delete_all` method for QueryProxy, too.
+* @codebeige removed the `include?` class method, which was smart.
+* Did I mention we won an award from Neo Tech? Check it out. https://github.com/neo4jrb/neo4j#welcome-to-neo4jrb
+
 == 3.0.3
 * Gemspec has been updated to require neo4j-core 3.0.5
 * Added `find_in_batches`

data/README.md

@@ -6,6 +6,10 @@ Neo4j.rb is an Active Model compliant Ruby/JRuby wrapper for [the Neo4j graph da
 Winner of a 2014 Graphie for "Best Community Contribution" at Neo4j's [Graph Connect](http://graphconnect.com) conference!
 ![2014 Graphie](http://i.imgur.com/CkOoTTYm.jpg)
 
+## Coming Soon: v4!
+
+The master branch of this repo now holds stable builds of the v4 version of the gem. Its changes are outlined at [here](https://github.com/neo4jrb/neo4j/wiki/Neo4j.rb-v4-Introduction). Unless otherwise noted, all 3.X documentation is totally valid. v4 discussion will happen [https://github.com/neo4jrb/neo4j/issues/596](https://github.com/neo4jrb/neo4j/issues/596) but if you have any concerns, please contact us directly.
+
 ## Modern (3.X) Documentation
 
 * [Wiki](https://github.com/neo4jrb/neo4j/wiki/Neo4j.rb-v3-Introduction)

data/config/neo4j/config.yml

@@ -30,4 +30,6 @@ timestamps: true
 # 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
+# class_name_property:  :_classname
+
+transform_rel_type: :upcase

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

@@ -4,6 +4,7 @@ module Neo4j
   module ActiveNode
     module HasN
       class Association
+        include Neo4j::Shared::RelTypeConverters
         attr_reader :type, :name, :relationship, :direction
 
         def initialize(type, direction, name, options = {})
@@ -60,7 +61,7 @@ module Neo4j
           when @origin
             origin_type
           else
-            (create || exceptional_target_class?) && "##{@name}"
+            (create || exceptional_target_class?) && decorated_rel_type(@name)
           end
         end
 
@@ -136,8 +137,8 @@ module Neo4j
 
         def validate_option_combinations(options)
           raise ArgumentError, "Cannot specify both :type and :origin (#{base_declaration})" if options[:type] && options[:origin]
-          # raise ArgumentError, "Cannot specify both :type and :rel_class (#{base_declaration})" if options[:type] && options[:rel_class] see issue #494
-          # raise ArgumentError, "Cannot specify both :origin and :rel_class (#{base_declaration}" if options[:origin] && options[:rel_class]
+          raise ArgumentError, "Cannot specify both :type and :rel_class (#{base_declaration})" if options[:type] && options[:rel_class]
+          raise ArgumentError, "Cannot specify both :origin and :rel_class (#{base_declaration}" if options[:origin] && options[:rel_class]
         end
 
         # Determine if model class as derived from the association name would be different than the one specified via the model_class key

data/lib/neo4j/active_node/id_property.rb

@@ -47,7 +47,7 @@ module Neo4j::ActiveNode
 
         clazz.module_eval(%Q{
           def id
-            persisted? ? #{name} : nil
+            persisted? ? #{name.to_sym == :id ? 'attribute(\'id\')' : name} : nil
           end
 
           validates_uniqueness_of :#{name}

data/lib/neo4j/active_node/initialize.rb

@@ -1,6 +1,6 @@
 module Neo4j::ActiveNode::Initialize
   extend ActiveSupport::Concern
-  include Neo4j::TypeConverters
+  include Neo4j::Shared::TypeConverters
 
   # called when loading the node from the database
   # @param [Neo4j::Node] persisted_node the node this class wraps

data/lib/neo4j/active_node/labels.rb

@@ -13,17 +13,13 @@ module Neo4j
       # @return the labels
       # @see Neo4j-core
       def labels
-        if @_persisted_obj.labels.nil?
-          r = queried_labels
-          @_persisted_obj.labels = r
-        else
-          @_persisted_obj.labels
-        end
+        @_persisted_obj.labels
       end
 
-      def queried_labels
-        self.class.query_as(:result).where("ID(result)" => self.neo_id).return("LABELS(result) as result_labels").first.result_labels.map(&:to_sym)
-      end
+      # this is handled by core, leaving it now for posterity
+      # def queried_labels
+      #   self.class.query_as(:result).where("ID(result)" => self.neo_id).return("LABELS(result) as result_labels").first.result_labels.map(&:to_sym)
+      # end
 
       # adds one or more labels
       # @see Neo4j-core
@@ -72,7 +68,7 @@ module Neo4j
 
         # Find all nodes/objects of this class
         def all
-          self.as(:n)
+          Neo4j::ActiveNode::Query::QueryProxy.new(self, nil, {})
         end
 
         # Returns the object with the specified neo4j id.
@@ -131,8 +127,7 @@ module Neo4j
           Neo4j::Session.on_session_available do |_|
             _index(property, conf)
           end
-          @_indexed_properties ||= []
-          @_indexed_properties.push property unless @_indexed_properties.include? property
+          indexed_properties.push property unless indexed_properties.include? property
         end
 
         # Creates a neo4j constraint on this class for given property
@@ -174,7 +169,19 @@ module Neo4j
         end
 
         def indexed_properties
-          @_indexed_properties
+          @_indexed_properties ||= []
+        end
+
+        def base_class
+          unless self < Neo4j::ActiveNode
+            raise "#{name} doesn't belong in a hierarchy descending from ActiveNode"
+          end
+
+          if superclass == Object
+            self
+          else
+            superclass.base_class
+          end
         end
 
 

data/lib/neo4j/active_node/query/query_proxy.rb

@@ -9,7 +9,7 @@ module Neo4j
 
         # The most recent node to start a QueryProxy chain.
         # Will be nil when using QueryProxy chains on class methods.
-        attr_reader :caller
+        attr_reader :caller, :association, :model
 
         # QueryProxy is ActiveNode's Cypher DSL. While the name might imply that it creates queries in a general sense,
         # it is actually referring to <tt>Neo4j::Core::Query</tt>, which is a pure Ruby Cypher DSL provided by the <tt>neo4j-core</tt> gem.
@@ -50,6 +50,7 @@ module Neo4j
         def identity
           @node_var || :result
         end
+        alias_method :node_identity, :identity
 
         # The relationship identifier most recently used by the QueryProxy chain.
         def rel_identity
@@ -106,7 +107,7 @@ module Neo4j
           self.to_a == value
         end
 
-        METHODS = %w[where order skip limit]
+        METHODS = %w[where rel_where order skip limit]
 
         METHODS.each do |method|
           module_eval(%Q{
@@ -114,7 +115,8 @@ module Neo4j
               build_deeper_query_proxy(:#{method}, args)
             end}, __FILE__, __LINE__)
         end
-
+        # Since there is a rel_where method, it seems only natural for there to be node_where
+        alias_method :node_where, :where
         alias_method :offset, :skip
         alias_method :order_by, :order
 
@@ -139,7 +141,6 @@ module Neo4j
         # @param [String,Symbol] var The identifier to use for node at this link of the QueryProxy chain.
         #   student.lessons.query_as(:l).with('your cypher here...')
         def query_as(var)
-          var = @node_var if @node_var
           query = if @association
             chain_var = _association_chain_var
             label_string = @model && ":`#{@model.mapped_label_name}`"
@@ -154,6 +155,25 @@ module Neo4j
           end
         end
 
+
+        # Scope all queries to the current scope.
+        #
+        #   Comment.where(post_id: 1).scoping do
+        #     Comment.first
+        #   end
+        #
+        # TODO: unscoped
+        # Please check unscoped if you want to remove all previous scopes (including
+        # the default_scope) during the execution of a block.
+        def scoping
+          previous, @model.current_scope = @model.current_scope, self
+          yield
+        ensure
+          @model.current_scope = previous
+        end
+
+
+
         # Cypher string for the QueryProxy's query. This will not include params. For the full output, see <tt>to_cypher_with_params</tt>.
         def to_cypher
           query.to_cypher
@@ -203,7 +223,8 @@ module Neo4j
               start_object = @options[:start_object]
               start_object.clear_association_cache
               _session.query(context: @options[:context])
-                .start(start: "node(#{start_object.neo_id})", end: "node(#{other_node.neo_id})")
+                .match("(start#{match_string(start_object)}), (end#{match_string(other_node)})").where("ID(start) = {start_id} AND ID(end) = {end_id}")
+                .params(start_id: start_object.neo_id, end_id: other_node.neo_id)
                 .create("start#{_association_arrow(properties, true)}end").exec
 
               @association.perform_callback(@options[:start_object], other_node, :after)
@@ -213,9 +234,10 @@ module Neo4j
 
         # QueryProxy objects act as a representation of a model at the class level so we pass through calls
         # This allows us to define class functions for reusable query chaining or for end-of-query aggregation/summarizing
-        def method_missing(method_name, *args)
+        def method_missing(method_name, *args, &block)
           if @model && @model.respond_to?(method_name)
-            call_class_method(method_name, *args)
+            args[2] = self if @model.has_association?(method_name) || @model.has_scope?(method_name)
+            scoping { @model.public_send(method_name, *args, &block) }
           else
             super
           end
@@ -291,12 +313,6 @@ module Neo4j
 
         private
 
-        def call_class_method(method_name, *args)
-          args[2] = self
-          result = @model.send(method_name, *args)
-          result
-        end
-
         def build_deeper_query_proxy(method, args)
           self.dup.tap do |new_query|
             args.each do |arg|
@@ -319,7 +335,7 @@ module Neo4j
           node_num = 1
           result = []
           if arg.is_a?(Hash)
-            arg.map do |key, value|
+            arg.each do |key, value|
               if @model && @model.has_association?(key)
 
                 neo_id = value.try(:neo_id) || value
@@ -341,14 +357,23 @@ module Neo4j
           end
           result
         end
+        alias_method :links_for_node_where_arg, :links_for_where_arg
+
+        # We don't accept strings here. If you want to use a string, just use where.
+        def links_for_rel_where_arg(arg)
+          arg.each_with_object([]) do |(key, value), result|
+            result << [:where, ->(v) {{ rel_identity => { key => value }}}]
+          end
+        end
 
         def links_for_order_arg(arg)
           [[:order, ->(v) { arg.is_a?(String) ? arg : {v => arg} }]]
         end
 
-
+        def match_string(node)
+          ":`#{node.class.mapped_label_name}`" if node.class.respond_to?(:mapped_label_name)
+        end
       end
-
     end
   end
 end

data/lib/neo4j/active_node/query/query_proxy_methods.rb

@@ -21,7 +21,7 @@ module Neo4j
           raise(InvalidParameterError, ':count accepts `distinct` or nil as a parameter') unless distinct.nil? || distinct == :distinct
           query_with_target(target) do |target|
             q = distinct.nil? ? target : "DISTINCT #{target}"
-            self.query.pluck("count(#{q}) AS #{target}").first
+            self.query.reorder.pluck("count(#{q}) AS #{target}").first
           end
         end
 
@@ -64,15 +64,27 @@ module Neo4j
         end
 
         # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id}`
+        # The `node` param can be a persisted ActiveNode instance, any string or integer, or nil.
+        # When it's a node, it'll use the object's neo_id, which is fastest. When not nil, it'll figure out the
+        # primary key of that model. When nil, it uses `1 = 2` to prevent matching all records, which is the default
+        # behavior when nil is passed to `where` in QueryProxy.
         # @return [Neo4j::ActiveNode::Query::QueryProxy] A QueryProxy object upon which you can build.
         def match_to(node)
-          self.where(neo_id: node.neo_id)
+          if node.respond_to?(:neo_id)
+            self.where(neo_id: node.neo_id)
+          elsif !node.nil?
+            id_key = self.association.nil? ? model.primary_key : self.association.target_class.primary_key
+            self.where(id_key => node)
+          else
+            # support for null object pattern
+            self.where('1 = 2')
+          end
         end
 
         # Gives you the first relationship between the last link of a QueryProxy chain and a given node
         # Shorthand for `MATCH (start)-[r]-(other_node) WHERE ID(other_node) = #{other_node.neo_id} RETURN r`
         def first_rel_to(node)
-          self.where(neo_id: node.neo_id).limit(1).pluck(rel_identity).first
+          self.match_to(node).limit(1).pluck(rel_identity).first
         end
 
         private

data/lib/neo4j/active_node/scope.rb

@@ -1,3 +1,5 @@
+require 'active_support/per_thread_registry'
+
 module Neo4j::ActiveNode
   module Scope
     extend ActiveSupport::Concern
@@ -53,7 +55,9 @@ module Neo4j::ActiveNode
         }, __FILE__, __LINE__)
       end
 
-
+      def has_scope?(name)
+        _scope.has_key?(name.to_sym)
+      end
 
       def _scope
         @_scope ||= {}
@@ -68,6 +72,23 @@ module Neo4j::ActiveNode
       end
 
 
+      def current_scope #:nodoc:
+        ScopeRegistry.value_for(:current_scope, base_class.to_s)
+      end
+
+      def current_scope=(scope) #:nodoc:
+        ScopeRegistry.set_value_for(:current_scope, base_class.to_s, scope)
+      end
+
+
+      def all
+        if current_scope
+          current_scope.clone
+        else
+          self.as(:n)
+        end
+      end
+
     end
 
     class ScopeEvalContext
@@ -79,9 +100,45 @@ module Neo4j::ActiveNode
       Neo4j::ActiveNode::Query::QueryProxy::METHODS.each do |method|
         module_eval(%Q{
             def #{method}(params={})
-              (@query_proxy || @target).#{method}(params)
+              @target.all.scoping do
+                (@query_proxy || @target).#{method}(params)
+              end
             end}, __FILE__, __LINE__)
       end
     end
+
+
+    # Stolen from ActiveRecord
+    # https://github.com/rails/rails/blob/08754f12e65a9ec79633a605e986d0f1ffa4b251/activerecord/lib/active_record/scoping.rb#L57
+    class ScopeRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # Obtains the value for a given +scope_name+ and +variable_name+.
+      def value_for(scope_type, variable_name)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name]
+      end
+
+      # Sets the +value+ for a given +scope_type+ and +variable_name+.
+      def set_value_for(scope_type, variable_name, value)
+        raise_invalid_scope_type!(scope_type)
+        @registry[scope_type][variable_name] = value
+      end
+
+      private
+
+      def raise_invalid_scope_type!(scope_type)
+        if !VALID_SCOPE_TYPES.include?(scope_type)
+          raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+        end
+      end
+    end
+
   end
 end

data/lib/neo4j/active_node.rb

@@ -1,6 +1,6 @@
 module Neo4j
 
-  # Makes Neo4j nodes and relationships behave like active record objects.
+  # Makes Neo4j nodes and relationships behave like ActiveRecord objects.
   # By including this module in your class it will create a mapping for the node to your ruby class
   # by using a Neo4j Label with the same name as the class. When the node is loaded from the database it
   # will check if there is a ruby class for the labels it has.
@@ -28,7 +28,7 @@ module Neo4j
     include Neo4j::Shared::Identity
     include Neo4j::ActiveNode::Initialize
     include Neo4j::ActiveNode::IdProperty
-    include Neo4j::ActiveNode::SerializedProperties
+    include Neo4j::Shared::SerializedProperties
     include Neo4j::ActiveNode::Property
     include Neo4j::ActiveNode::Reflection
     include Neo4j::ActiveNode::Persistence
@@ -48,21 +48,24 @@ module Neo4j
       def self.inherited(other)
         inherit_id_property(other) if self.has_id_property?
         inherited_indexes(other) if self.respond_to?(:indexed_properties)
-        attributes.each_pair do |k,v|
-          other.attributes[k] = v
-        end
+        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)
         super
       end
 
       def self.inherited_indexes(other)
        return if indexed_properties.nil?
-       self.indexed_properties.each {|property| other.index property }
+       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)
         id_prop = self.id_property_info
-        conf = id_prop[:type].empty? ? {auto: :uuid} : id_prop[:type]
+        conf = id_prop[:type].empty? ? { auto: :uuid } : id_prop[:type]
         other.id_property id_prop[:name], conf
       end
 
@@ -72,11 +75,10 @@ module Neo4j
         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
+        id_property(name, type => value) if (name && type && value)
       end
-
     end
+
+    ActiveSupport.run_load_hooks(:active_node, self)
   end
 end

data/lib/neo4j/active_rel/initialize.rb

@@ -1,7 +1,7 @@
 module Neo4j::ActiveRel
   module Initialize
     extend ActiveSupport::Concern
-    include Neo4j::TypeConverters
+    include Neo4j::Shared::TypeConverters
 
     attr_reader :_persisted_obj
 

data/lib/neo4j/active_rel/persistence.rb

@@ -24,6 +24,7 @@ module Neo4j::ActiveRel
       set_timestamps
       properties = convert_properties_to :db, props
       rel = _create_rel(from_node, to_node, properties)
+      return self unless rel.respond_to?(:_persisted_obj)
       init_on_load(rel._persisted_obj, from_node, to_node, @rel_type)
       true
     end
@@ -61,7 +62,7 @@ module Neo4j::ActiveRel
     def _create_rel(from_node, to_node, *args)
       props = self.class.default_property_values(self)
       props.merge!(args[0]) if args[0].is_a?(Hash)
-      set_classname(props)
+      set_classname(props, true)
       _rel_creation_query(from_node, to_node, props)
     end
 
@@ -99,4 +100,4 @@ module Neo4j::ActiveRel
     end
 
   end
-end
+end

data/lib/neo4j/active_rel/property.rb

@@ -42,16 +42,6 @@ module Neo4j::ActiveRel
       alias_method :start_class,  :from_class
       alias_method :end_class,    :to_class
 
-      # @param type [String] sets the relationship type when creating relationships via this class
-      def type(type = nil)
-        @rel_type = type
-      end
-
-      # @return [String] a string representing the relationship type that will be created
-      def _type
-        @rel_type
-      end
-
       def load_entity(id)
         Neo4j::Node.load(id)
       end

data/lib/neo4j/active_rel/query.rb

@@ -26,10 +26,6 @@ module Neo4j::ActiveRel
         where_query.where(where_string(args)).pluck(:r1)
       end
 
-      def array_load(ids_array)
-        where_query.where("ID(r1) IN {ids_array}").params(ids_array: ids_array).pluck(:r1)
-      end
-
       # Performs a basic match on the relationship, returning all results.
       # This is not executed lazily, it will immediately return matching objects.
       def all

data/lib/neo4j/active_rel/rel_wrapper.rb

@@ -3,16 +3,27 @@ class Neo4j::Relationship
   module Wrapper
     def wrapper
       props.symbolize_keys!
-      return self unless props.is_a?(Hash) && props.has_key?(Neo4j::Config.class_name_property)
+      # return self unless props.is_a?(Hash)
       begin
-        found_class = props[Neo4j::Config.class_name_property].constantize
+        most_concrete_class = sorted_wrapper_classes
+        wrapped_rel = most_concrete_class.constantize.new
       rescue NameError
         return self
       end
-      wrapped_rel = found_class.new
+
       wrapped_rel.init_on_load(self, self._start_node_id, self._end_node_id, self.rel_type)
       wrapped_rel
     end
+
+    private
+
+    def sorted_wrapper_classes
+      props[Neo4j::Config.class_name_property] || class_from_type
+    end
+
+    def class_from_type
+      Neo4j::ActiveRel::Types::WRAPPED_CLASSES[rel_type] || rel_type.camelize
+    end
   end
 
-end
+end

data/lib/neo4j/active_rel/types.rb

@@ -0,0 +1,54 @@
+module Neo4j
+  module ActiveRel
+
+    # provides mapping of type to model name
+    module Types
+      extend ActiveSupport::Concern
+
+      # WRAPPED_CLASSES maps relationship types to ActiveRel models.
+      #
+      # Typically, it's a 1:1 relationship, with a type having a model of the same name. Sometimes, someone needs to be a precious
+      # snowflake and have a model name that doesn't match the rel type, so this comes in handy.
+      #
+      # As an example, Chris often finds it easier to name models after the classes that use the relationship: `StudentLesson` instead of
+      # `EnrolledIn`, because it's easier to remember "A student has a relationship to lesson" than "the type of relationship between Student
+      # and Lesson is 'EnrolledIn'." After all, that is a big part of why we have models, right? To make our lives easier?
+      #
+      # A model is added to WRAPPED_CLASSES when it is initalized AND when the `type` class method is called within a model. This means that
+      # it's possible a model will be added twice: once with the rel_type version of the model name, again with the custom type. deal_with_it.gif.
+      #
+      # As an alternative to this, you can call the `set_classname` class method to insert a `_classname` property into your relationship,
+      # which will completely bypass this whole process.
+      WRAPPED_CLASSES = {}
+
+      included do |klazz|
+        type self.name, true
+      end
+
+      module ClassMethods
+        include Neo4j::Shared::RelTypeConverters
+
+        # @param type [String] sets the relationship type when creating relationships via this class
+        def type(given_type = self.name, auto = false)
+          use_type = auto ? decorated_rel_type(given_type) : given_type
+          add_wrapped_class use_type
+          @rel_type = use_type
+        end
+
+        # @return [String] a string representing the relationship type that will be created
+        def _type
+          @rel_type
+        end
+
+        def add_wrapped_class(type)
+          #_wrapped_classes[type.to_sym.downcase] = self.name
+          _wrapped_classes[type.to_sym] = self.name
+        end
+
+        def _wrapped_classes
+          Neo4j::ActiveRel::Types::WRAPPED_CLASSES
+        end
+      end
+    end
+  end
+end