neo4j_legacy 7.2.0.1

data/lib/neo4j/active_node/id_property.rb

@@ -0,0 +1,187 @@
+module Neo4j::ActiveNode
+  # This module makes it possible to use other IDs than the build it neo4j id (neo_id)
+  #
+  # @example using generated UUIDs
+  #   class Person
+  #     include Neo4j::ActiveNode
+  #     # creates a 'secret' neo4j property my_uuid which will be used as primary key
+  #     id_property :my_uuid, auto: :uuid
+  #   end
+  #
+  # @example using user defined ids
+  #   class Person
+  #     include Neo4j::ActiveNode
+  #     property :title
+  #     validates :title, :presence => true
+  #     id_property :title_id, on: :title_to_url
+  #
+  #     def title_to_url
+  #       self.title.urlize # uses https://github.com/cheef/string-urlize gem
+  #     end
+  #   end
+  #
+  # @example using already exsting ids that you don't want a constraint added to
+  #   class Person
+  #     include Neo4j::ActiveNode
+  #     property :title
+  #     validates :title, :presence => true
+  #     id_property :id, on: :id_builder, constraint: false
+  #
+  #     def id_builder
+  #       # only need to fill this out if you're gonna write to the db
+  #     end
+  #   end
+  #
+  module IdProperty
+    extend ActiveSupport::Concern
+    include Accessor
+
+    module TypeMethods
+      def define_id_methods(clazz, name, conf)
+        validate_conf!(conf)
+
+        if conf[:on]
+          define_custom_method(clazz, name, conf[:on])
+        elsif conf[:auto]
+          define_uuid_method(clazz, name)
+        elsif conf.empty?
+          define_property_method(clazz, name)
+        end
+      end
+
+      private
+
+      def validate_conf!(conf)
+        fail "Expected a Hash, got #{conf.class} (#{conf}) for id_property" if !conf.is_a?(Hash)
+
+        return if conf[:on]
+
+        if conf[:auto]
+          fail "only :uuid auto id_property allowed, got #{conf[:auto]}" if conf[:auto] != :uuid
+          return
+        end
+
+        return if conf.empty?
+
+        fail "Illegal value #{conf.inspect} for id_property, expected :on or :auto"
+      end
+
+      def define_property_method(clazz, name)
+        clear_methods(clazz, name)
+
+        clazz.module_eval(%(
+          def id
+            _persisted_obj ? #{name.to_sym == :id ? 'attribute(\'id\')' : name} : nil
+          end
+
+          property :#{name}
+                ), __FILE__, __LINE__)
+      end
+
+
+      def define_uuid_method(clazz, name)
+        clear_methods(clazz, name)
+
+        clazz.module_eval(%(
+          default_property :#{name} do
+             ::SecureRandom.uuid
+          end
+
+          def #{name}
+             default_property_value
+          end
+
+          alias_method :id, :#{name}
+                ), __FILE__, __LINE__)
+      end
+
+      def define_custom_method(clazz, name, on)
+        clear_methods(clazz, name)
+
+        clazz.module_eval(%{
+          default_property :#{name} do |instance|
+            raise "Specifying custom id_property #{name} on non-existent method #{on}" unless instance.respond_to?(:#{on})
+            instance.#{on}
+          end
+
+          def #{name}
+            default_property_value
+          end
+
+          alias_method :id, :#{name}
+        }, __FILE__, __LINE__)
+      end
+
+      def clear_methods(clazz, name)
+        clazz.module_eval(%(undef_method :#{name}), __FILE__, __LINE__) if clazz.method_defined?(name)
+        clazz.module_eval(%(undef_property :#{name}), __FILE__, __LINE__) if clazz.attribute_names.include?(name.to_s)
+      end
+
+      extend self
+    end
+
+
+    module ClassMethods
+      attr_accessor :manual_id_property
+
+      def find_by_neo_id(id)
+        Neo4j::Node.load(id)
+      end
+
+      def find_by_id(id)
+        all.where(id_property_name => id).first
+      end
+
+      def find_by_ids(ids)
+        all.where(id_property_name => ids).to_a
+      end
+
+      def id_property(name, conf = {})
+        self.manual_id_property = true
+        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
+        end
+      end
+
+      # rubocop:disable Style/PredicateName
+      def has_id_property?
+        ActiveSupport::Deprecation.warn 'has_id_property? is deprecated and may be removed from future releases, use id_property? instead.', caller
+
+        id_property?
+      end
+      # rubocop:enable Style/PredicateName
+
+      def id_property?
+        id_property_info && !id_property_info.empty?
+      end
+
+      def id_property_info
+        @id_property_info ||= {}
+      end
+
+      def id_property_name
+        id_property_info[:name]
+      end
+
+      def manual_id_property?
+        !!manual_id_property
+      end
+
+      alias_method :primary_key, :id_property_name
+
+      private
+
+      def id_property_constraint(name)
+        if id_property?
+          unless mapped_label.uniqueness_constraints[:property_keys].include?([name])
+            # Neo4j Embedded throws a crazy error when a constraint can't be dropped
+            drop_constraint(id_property_name, type: :unique) if constraint?(mapped_label_name, id_property_name)
+          end
+        end
+      rescue Neo4j::Server::CypherResponse::ResponseError, Java::OrgNeo4jCypher::CypherExecutionException
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/initialize.rb

@@ -0,0 +1,21 @@
+module Neo4j::ActiveNode::Initialize
+  extend ActiveSupport::Concern
+  include Neo4j::Shared::Initialize
+
+  attr_reader :called_by
+
+  # called when loading the node from the database
+  # @param [Neo4j::Node] persisted_node the node this class wraps
+  # @param [Hash] properties of the persisted node.
+  def init_on_load(persisted_node, properties)
+    self.class.extract_association_attributes!(properties)
+    @_persisted_obj = persisted_node
+    changed_attributes && changed_attributes.clear
+    @attributes = convert_and_assign_attributes(properties)
+  end
+
+  def init_on_reload(reloaded)
+    @attributes = nil
+    init_on_load(reloaded, reloaded.props)
+  end
+end

data/lib/neo4j/active_node/labels/index.rb

@@ -0,0 +1,87 @@
+module Neo4j::ActiveNode::Labels
+  module Index
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      extend Forwardable
+
+      def_delegators :declared_properties, :indexed_properties
+
+      # 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
+      #
+      # @example
+      #   class Person
+      #      include Neo4j::ActiveNode
+      #      property :name
+      #      index :name
+      #    end
+      def index(property)
+        Neo4j::Session.on_next_session_available do |_|
+          declared_properties.index_or_fail!(property, id_property_name)
+          schema_create_operation(:index, property)
+        end
+      end
+
+      # Creates a neo4j constraint on this class for given property
+      #
+      # @example
+      #   Person.constraint :name, type: :unique
+      def constraint(property, constraints = {type: :unique})
+        Neo4j::Session.on_next_session_available do
+          declared_properties.constraint_or_fail!(property, id_property_name)
+          schema_create_operation(:constraint, property, constraints)
+        end
+      end
+
+      # @param [Symbol] property The name of the property index to be dropped
+      def drop_index(property, options = {})
+        Neo4j::Session.on_next_session_available do
+          declared_properties[property].unindex! if declared_properties[property]
+          schema_drop_operation(:index, property, options)
+        end
+      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_next_session_available do
+          declared_properties[property].unconstraint! if declared_properties[property]
+          schema_drop_operation(:constraint, property, constraint)
+        end
+      end
+
+      def index?(property)
+        mapped_label.indexes[:property_keys].include?([property])
+      end
+
+      def constraint?(property)
+        mapped_label.unique_constraints[:property_keys].include?([property])
+      end
+
+      private
+
+      def schema_create_operation(type, property, options = {})
+        new_schema_class(type, property, options).create!
+      end
+
+      def schema_drop_operation(type, property, options = {})
+        new_schema_class(type, property, options).drop!
+      end
+
+      def new_schema_class(type, property, options)
+        case type
+        when :index
+          Neo4j::Schema::ExactIndexOperation
+        when :constraint
+          Neo4j::Schema::UniqueConstraintOperation
+        else
+          fail "Unknown Schema Operation class #{type}"
+        end.new(mapped_label_name, property, options)
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/labels/reloading.rb

@@ -0,0 +1,21 @@
+module Neo4j::ActiveNode::Labels
+  module Reloading
+    extend ActiveSupport::Concern
+
+    MODELS_TO_RELOAD = []
+
+    def self.reload_models!
+      MODELS_TO_RELOAD.each(&:constantize)
+      MODELS_TO_RELOAD.clear
+    end
+
+    module ClassMethods
+      def before_remove_const
+        associations.each_value(&:queue_model_refresh!)
+        MODELS_FOR_LABELS_CACHE.clear
+        WRAPPED_CLASSES.each { |c| MODELS_TO_RELOAD << c.name }
+        WRAPPED_CLASSES.clear
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/labels.rb

@@ -0,0 +1,198 @@
+module Neo4j
+  module ActiveNode
+    # 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 = []
+      MODELS_FOR_LABELS_CACHE = {}
+      MODELS_FOR_LABELS_CACHE.clear
+
+      included do |model|
+        Neo4j::ActiveNode::Labels.clear_wrapped_models
+
+        Neo4j::ActiveNode::Labels.add_wrapped_class(model) unless Neo4j::ActiveNode::Labels._wrapped_classes.include?(model)
+      end
+
+      class RecordNotFound < Neo4j::RecordNotFound; end
+
+      # @return the labels
+      # @see Neo4j-core
+      def labels
+        @_persisted_obj.labels
+      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
+      def add_label(*label)
+        @_persisted_obj.add_label(*label)
+      end
+
+      # Removes one or more labels
+      # Be careful, don't remove the label representing the Ruby class.
+      # @see Neo4j-core
+      def remove_label(*label)
+        @_persisted_obj.remove_label(*label)
+      end
+
+      def self._wrapped_classes
+        WRAPPED_CLASSES
+      end
+
+      def self.add_wrapped_class(model)
+        _wrapped_classes << model
+      end
+
+      # Finds an appropriate matching model given a set of labels
+      # which are assigned to a node
+      def self.model_for_labels(labels)
+        return MODELS_FOR_LABELS_CACHE[labels] if MODELS_FOR_LABELS_CACHE[labels]
+
+        models = WRAPPED_CLASSES.select do |model|
+          (model.mapped_label_names - labels).size == 0
+        end
+
+        MODELS_FOR_LABELS_CACHE[labels] = models.max_by do |model|
+          (model.mapped_label_names & labels).size
+        end
+      end
+
+      def self.clear_wrapped_models
+        MODELS_FOR_LABELS_CACHE.clear
+        Neo4j::Node::Wrapper::CONSTANTS_FOR_LABELS_CACHE.clear
+      end
+
+      module ClassMethods
+        include Neo4j::ActiveNode::QueryMethods
+
+        delegate :update_all, to: :all
+
+        # Returns the object with the specified neo4j id.
+        # @param [String,Integer] id of node to find
+        def find(id)
+          map_id = proc { |object| object.respond_to?(:id) ? object.send(:id) : object }
+
+          result = find_by_id_or_ids(map_id, id)
+
+          fail RecordNotFound.new(
+            "Couldn't find #{name} with '#{id_property_name}'=#{id}",
+            name, id_property_name, id) if result.blank?
+          result.tap { |r| find_callbacks!(r) }
+        end
+
+        # Finds the first record matching the specified conditions. There is no implied ordering so if order matters, you should specify it yourself.
+        # @param values Hash args of arguments to find
+        def find_by(values)
+          all.where(values).limit(1).query_as(:n).pluck(:n).first
+        end
+
+        # Like find_by, except that if no record is found, raises a RecordNotFound error.
+        def find_by!(values)
+          find_by(values) || fail(RecordNotFound, "#{self.query_as(:n).where(n: values).limit(1).to_cypher} returned no results")
+        end
+
+        # Deletes all nodes and connected relationships from Cypher.
+        def delete_all
+          self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`) OPTIONAL MATCH (n)-[r]-() DELETE n,r")
+          self.neo4j_session._query("MATCH (n:`#{mapped_label_name}`) DELETE n")
+        end
+
+        # Returns each node to Ruby and calls `destroy`. Be careful, as this can be a very slow operation if you have many nodes. It will generate at least
+        # one database query per node in the database, more if callbacks require them.
+        def destroy_all
+          all.each(&:destroy)
+        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 }
+        end
+
+        # @return [Symbol] the label that this class has which corresponds to a Ruby class
+        def mapped_label_name
+          @mapped_label_name || label_for_model
+        end
+
+        # @return [Neo4j::Label] the label for this class
+        def mapped_label
+          Neo4j::Label.create(mapped_label_name)
+        end
+
+        def base_class
+          unless self < Neo4j::ActiveNode
+            fail "#{name} doesn't belong in a hierarchy descending from ActiveNode"
+          end
+
+          if superclass == Object
+            self
+          else
+            superclass.base_class
+          end
+        end
+
+        protected
+
+        def mapped_labels
+          mapped_label_names.map { |label_name| Neo4j::Label.create(label_name) }
+        end
+
+        def mapped_label_name=(name)
+          @mapped_label_name = name.to_sym
+        end
+
+        # rubocop:disable Style/AccessorMethodName
+        def set_mapped_label_name(name)
+          ActiveSupport::Deprecation.warn 'set_mapped_label_name is deprecated, use self.mapped_label_name= instead.', caller
+
+          self.mapped_label_name = name
+        end
+        # rubocop:enable Style/AccessorMethodName
+
+        private
+
+        def find_by_id_or_ids(map_id, id)
+          if id.is_a?(Array)
+            find_by_ids(id.map(&map_id))
+          else
+            find_by_id(map_id.call(id))
+          end
+        end
+
+        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
+
+        def decorated_label_name
+          name =  case Neo4j::Config[:module_handling]
+                  when :demodulize
+                    self.name.demodulize
+                  when Proc
+                    Neo4j::Config[:module_handling].call self.name
+                  else
+                    self.name
+                  end
+
+          name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/active_node/node_wrapper.rb

@@ -0,0 +1,52 @@
+require 'active_support/inflector'
+
+class Neo4j::Node
+  # The wrapping process is what transforms a raw CypherNode or EmbeddedNode from Neo4j::Core into a healthy ActiveNode (or ActiveRel) object.
+  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
+      found_class = class_to_wrap
+      return self if not found_class
+
+      found_class.new.tap do |wrapped_node|
+        wrapped_node.init_on_load(self, self.props)
+      end
+    end
+
+    def class_to_wrap
+      load_classes_from_labels
+      Neo4j::ActiveNode::Labels.model_for_labels(labels).tap do |model_class|
+        Neo4j::Node::Wrapper.populate_constants_for_labels_cache(model_class, labels)
+      end
+    end
+
+    private
+
+    def load_classes_from_labels
+      labels.each { |label| Neo4j::Node::Wrapper.constant_for_label(label) }
+    end
+
+    # Only load classes once for performance
+    CONSTANTS_FOR_LABELS_CACHE = {}
+
+    def self.constant_for_label(label)
+      CONSTANTS_FOR_LABELS_CACHE[label] || CONSTANTS_FOR_LABELS_CACHE[label] = constantized_label(label)
+    end
+
+    def self.constantized_label(label)
+      "#{association_model_namespace}::#{label}".constantize
+    rescue NameError
+      nil
+    end
+
+    def self.populate_constants_for_labels_cache(model_class, labels)
+      labels.each do |label|
+        CONSTANTS_FOR_LABELS_CACHE[label] = model_class if CONSTANTS_FOR_LABELS_CACHE[label].nil?
+      end
+    end
+
+    def self.association_model_namespace
+      Neo4j::Config.association_model_namespace_string
+    end
+  end
+end

data/lib/neo4j/active_node/orm_adapter.rb

@@ -0,0 +1,82 @@
+require 'orm_adapter'
+
+module Neo4j
+  module ActiveNode
+    module ClassMethods
+      include OrmAdapter::ToAdapter
+    end
+
+    class OrmAdapter < ::OrmAdapter::Base
+      module ClassMethods
+        include ActiveModel::Callbacks
+      end
+
+      def column_names
+        klass._decl_props.keys
+      end
+
+      def i18n_scope
+        :neo4j
+      end
+
+      # Get an instance by id of the model
+      def get!(id)
+        klass.find(wrap_key(id)).tap do |node|
+          fail 'No record found' if node.nil?
+        end
+      end
+
+      # Get an instance by id of the model
+      def get(id)
+        klass.find_by(klass.id_property_name => wrap_key(id))
+      end
+
+      # Find the first instance matching conditions
+      def find_first(options = {})
+        conditions, order = extract_conditions!(options)
+        extract_id!(conditions)
+        order = hasherize_order(order)
+
+        result = klass.where(conditions)
+        result = result.order(order) unless order.empty?
+        result.first
+      end
+
+      # Find all models matching conditions
+      def find_all(options = {})
+        conditions, order, limit, offset = extract_conditions!(options)
+        extract_id!(conditions)
+        order = hasherize_order(order)
+
+        result = klass.where(conditions)
+        result = result.order(order) unless order.empty?
+        result = result.skip(offset) if offset
+        result = result.limit(limit) if limit
+        result.to_a
+      end
+
+      # Create a model using attributes
+      def create!(attributes = {})
+        klass.create!(attributes)
+      end
+
+      # @see OrmAdapter::Base#destroy
+      def destroy(object)
+        object.destroy && true if valid_object?(object)
+      end
+
+      private
+
+      def hasherize_order(order)
+        (order || []).map { |clause| Hash[*clause] }
+      end
+
+      def extract_id!(conditions)
+        id = conditions.delete(:id)
+        return if not id
+
+        conditions[klass.id_property_name.to_sym] = id
+      end
+    end
+  end
+end