activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/active_node/id_property.rb

@@ -0,0 +1,224 @@
+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)
+        return if name == :neo_id
+
+        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)
+        find_by(neo_id: 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 = {}, inherited = false)
+        self.manual_id_property = true
+
+        @id_property_info = {name: name, type: conf, inherited: inherited}
+        TypeMethods.define_id_methods(self, name, conf)
+      end
+
+      # rubocop:disable Naming/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 Naming/PredicateName
+
+      def id_property?
+        id_property_info && !id_property_info.empty?
+      end
+
+      def id_property_info
+        ensure_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 primary_key id_property_name
+
+      # Since there's no way to know when a class is done being described, we wait until the id_property
+      # information is requested and use that as the opportunity to set up the defaults if no others are specified
+      def ensure_id_property_info!
+        if !manual_id_property? && !@id_property_info
+          name, type, value = id_property_name_type_value
+          id_property(name, type => value)
+        end
+
+        handle_model_schema!
+      end
+
+      private
+
+      def handle_model_schema!
+        id_property_name = @id_property_info[:name]
+
+        return if id_property_name == :neo_id || @id_property_info[:inherited]
+
+        if @id_property_info[:type][:constraint] == false &&
+           !@id_property_info[:warned_of_constraint]
+          @id_property_info[:warned_of_constraint] = true
+          warn_constraint_option_false!(id_property_name)
+          return
+        end
+
+        Neo4j::ModelSchema.add_defined_constraint(self, id_property_name)
+      end
+
+      def warn_constraint_option_false!(id_property_name)
+        Neo4j::ActiveBase.logger.warn <<MSG
+        WARNING: The constraint option for id_property is no longer supported (Used on #{self.name}.#{id_property_name}).
+        Since you specified `constraint: false` this option can simply be removed.
+MSG
+      end
+
+      def id_property_name_type_value
+        name, type, value = Neo4j::Config.to_hash.values_at('id_property', 'id_property_type', 'id_property_type_value')
+
+        unless name == :neo_id || (name && type && value)
+          name = :uuid
+          type = :auto
+          value = :uuid
+        end
+
+        [name, type, value]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Neo4j::ActiveNode::IdProperty
+  # Provides get/set of the Id Property values.
+  # Some methods
+  module Accessor
+    extend ActiveSupport::Concern
+
+    attr_reader :default_property_value
+
+    def default_properties=(properties)
+      @default_property_value = properties[default_property_key]
+    end
+
+    def default_property(key)
+      return nil unless key == default_property_key
+      default_property_value
+    end
+
+    def default_property_key
+      self.class.default_property_key
+    end
+
+    def default_properties
+      @default_properties ||= Hash.new(nil)
+    end
+
+    module ClassMethods
+      def default_property_key
+        @default_property_key ||= default_properties_keys.first
+      end
+
+      # 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
+      end
+
+      # @return [Hash<Symbol,Proc>]
+      def default_properties
+        @default_property ||= {}
+      end
+
+      def default_properties_keys
+        @default_properties_keys ||= default_properties.keys
+      end
+
+      def reset_default_properties(name_to_keep)
+        default_properties.each_key do |property|
+          @default_properties_keys = nil
+          undef_method(property) unless property == name_to_keep
+        end
+        @default_properties_keys = nil
+        @default_property = {}
+      end
+
+      def default_property_values(instance)
+        default_properties.each_with_object({}) do |(key, block), result|
+          result[key] = block.call(instance)
+        end
+      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_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.rb

@@ -0,0 +1,207 @@
+require 'neo4j/core/label'
+
+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_labels(*labels)
+        labels.inject(query_as(:n)) do |query, label|
+          query.set("n:`#{label}`")
+        end.exec
+        @_persisted_obj.labels.concat(labels)
+        @_persisted_obj.labels.uniq!
+      end
+
+      # Removes one or more labels
+      # Be careful, don't remove the label representing the Ruby class.
+      # @see Neo4j-core
+      def remove_labels(*labels)
+        labels.inject(query_as(:n)) do |query, label|
+          query.remove("n:`#{label}`")
+        end.exec
+        labels.each(&@_persisted_obj.labels.method(:delete))
+      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)
+        labels.sort!
+        return MODELS_FOR_LABELS_CACHE[labels] if MODELS_FOR_LABELS_CACHE[labels]
+
+        models = WRAPPED_CLASSES.select do |model|
+          (model.mapped_label_names - labels).empty?
+        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::NodeWrapping::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.inspect}",
+            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.new("#{self.query_as(:n).where(n: values).limit(1).to_cypher} returned no results", name))
+        end
+
+        # Deletes all nodes and connected relationships from Cypher.
+        def delete_all
+          neo4j_query("MATCH (n:`#{mapped_label_name}`) OPTIONAL MATCH (n)-[r]-() DELETE n,r")
+        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::Core::Label.new(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 Naming/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 Naming/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