activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/schema/operation.rb

@@ -0,0 +1,102 @@
+module Neo4j
+  module Schema
+    class Operation
+      attr_reader :label, :property, :options
+
+      def initialize(label, property, options = default_options)
+        @label = if label.is_a?(Neo4j::Core::Label)
+                   label
+                 else
+                   Neo4j::Core::Label.new(label)
+                 end
+
+        @property = property.to_sym
+        @options = options
+      end
+
+      def self.incompatible_operation_classes
+        []
+      end
+
+      def label_object
+        label
+      end
+
+      def create!
+        drop_incompatible!
+        return if exist?
+        schema_query(:"create_#{type}")
+      end
+
+      def incompatible_operation_classes
+        self.class.incompatible_operation_classes
+      end
+
+      def drop!
+        schema_query(:"drop_#{type}")
+      end
+
+      def drop_incompatible!
+        incompatible_operation_classes.each do |clazz|
+          operation = clazz.new(@label, property)
+          operation.drop! if operation.exist?
+        end
+      end
+
+      def exist?
+        fail 'Abstract class, not implemented'
+      end
+
+      def default_options
+        {}
+      end
+
+      def type
+        fail 'Abstract class, not implemented'
+      end
+
+      private
+
+      def schema_query(method)
+        label.send(method, property, options)
+      end
+    end
+
+    class ExactIndexOperation < Neo4j::Schema::Operation
+      def self.incompatible_operation_classes
+        [UniqueConstraintOperation]
+      end
+
+      def type
+        'index'
+      end
+
+      def exist?
+        label.index?(property)
+      end
+    end
+
+    class UniqueConstraintOperation < Neo4j::Schema::Operation
+      def self.incompatible_operation_classes
+        [ExactIndexOperation]
+      end
+
+      def type
+        'uniqueness_constraint'
+      end
+
+      def create!
+        return if exist?
+        super
+      end
+
+      def exist?
+        label.uniqueness_constraint?(property)
+      end
+
+      def default_options
+        {type: :unique}
+      end
+    end
+  end
+end

data/lib/neo4j/shared.rb

@@ -0,0 +1,60 @@
+module Neo4j
+  module Shared
+    extend ActiveSupport::Concern
+    extend ActiveModel::Naming
+
+    include ActiveModel::Conversion
+    begin
+    include ActiveModel::Serializers::Xml
+    rescue NameError; end # rubocop:disable Lint/HandleExceptions
+    include ActiveModel::Serializers::JSON
+
+    module ClassMethods
+      # TODO: Deprecate neo4j_session_name(name)
+
+      # remove?
+      def neo4j_session
+        Neo4j::ActiveBase.current_driver
+      end
+
+      # remove?
+      def current_transaction
+        Neo4j::ActiveBase.current_transaction
+      end
+
+      # This should be used everywhere.  Should make it easy
+      # to support a session-per-model system
+      def neo4j_query(*args)
+        Neo4j::ActiveBase.query(*args)
+      end
+
+      def new_query
+        Neo4j::ActiveBase.new_query
+      end
+    end
+
+    included do
+      self.include_root_in_json = Neo4j::Config.include_root_in_json
+      @_declared_properties ||= Neo4j::Shared::DeclaredProperties.new(self)
+
+      def self.i18n_scope
+        :neo4j
+      end
+
+      def self.inherited(other)
+        attributes.each_pair do |k, v|
+          other.inherit_property k.to_sym, v.clone, declared_properties[k].options
+        end
+        super
+      end
+    end
+
+    def declared_properties
+      self.class.declared_properties
+    end
+
+    def neo4j_query(*args)
+      self.class.neo4j_query(*args)
+    end
+  end
+end

data/lib/neo4j/shared/attributes.rb

@@ -0,0 +1,216 @@
+module Neo4j::Shared
+  # Attributes provides a set of class methods for defining an attributes
+  # schema and instance methods for reading and writing attributes.
+  #
+  # @example Usage
+  #   class Person
+  #     include Neo4j::Shared::Attributes
+  #     attribute :name
+  #   end
+  #
+  #   person = Person.new
+  #   person.name = "Ben Poweski"
+  #
+  # Originally part of ActiveAttr, https://github.com/cgriego/active_attr
+  module Attributes
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    # Methods deprecated on the Object class which can be safely overridden
+    DEPRECATED_OBJECT_METHODS = %w(id type)
+
+    included do
+      attribute_method_suffix '' if attribute_method_matchers.none? { |matcher| matcher.prefix == '' && matcher.suffix == '' }
+      attribute_method_suffix '='
+      attribute_method_suffix '?'
+    end
+
+    # Performs equality checking on the result of attributes and its type.
+    #
+    # @example Compare for equality.
+    #   model == other
+    #
+    # @param [ActiveAttr::Attributes, Object] other The other model to compare
+    #
+    # @return [true, false] True if attributes are equal and other is instance
+    #   of the same Class, false if not.
+    def ==(other)
+      return false unless other.instance_of? self.class
+      attributes == other.attributes
+    end
+
+    # Returns a Hash of all attributes
+    #
+    # @example Get attributes
+    #   person.attributes # => {"name"=>"Ben Poweski"}
+    #
+    # @return [Hash{String => Object}] The Hash of all attributes
+    def attributes
+      attributes_map { |name| send name }
+    end
+
+    # Write a single attribute to the model's attribute hash.
+    #
+    # @example Write the attribute with write_attribute
+    #   person.write_attribute(:name, "Benjamin")
+    # @example Write an attribute with bracket syntax
+    #   person[:name] = "Benjamin"
+    #
+    # @param [String, Symbol, #to_s] name The name of the attribute to update.
+    # @param [Object] value The value to set for the attribute.
+    #
+    # @raise [UnknownAttributeError] if the attribute is unknown
+    def write_attribute(name, value)
+      fail Neo4j::UnknownAttributeError, "unknown attribute: #{name}" if !respond_to? "#{name}="
+
+      send "#{name}=", value
+    end
+    alias []= write_attribute
+
+    def query_attribute(name)
+      fail Neo4j::UnknownAttributeError, "unknown attribute: #{name}" if !respond_to? "#{name}?"
+
+      send "#{name}?"
+    end
+
+    private
+
+    # Read an attribute from the attributes hash
+    def attribute(name)
+      @attributes ||= {}
+      @attributes[name]
+    end
+
+    # Write an attribute to the attributes hash
+    def attribute=(name, value)
+      @attributes ||= {}
+      @attributes[name] = value
+    end
+
+    # Maps all attributes using the given block
+    #
+    # @example Stringify attributes
+    #   person.attributes_map { |name| send(name).to_s }
+    #
+    # @yield [name] block called to return hash value
+    # @yieldparam [String] name The name of the attribute to map.
+    #
+    # @return [Hash{String => Object}] The Hash of mapped attributes
+    def attributes_map
+      Hash[self.class.attribute_names.map { |name| [name, yield(name)] }]
+    end
+
+    def attribute?(name)
+      Neo4j::Shared::TypeConverters::BooleanConverter.to_ruby(read_attribute(name))
+    end
+
+    module ClassMethods
+      # Defines an attribute
+      #
+      # For each attribute that is defined, a getter and setter will be
+      # added as an instance method to the model. An
+      # {AttributeDefinition} instance will be added to result of the
+      # attributes class method.
+      #
+      # @example Define an attribute.
+      #   attribute :name
+      #
+      # @param (see AttributeDefinition#initialize)
+      #
+      # @raise [DangerousAttributeError] if the attribute name conflicts with
+      #   existing methods
+      #
+      # @return [AttributeDefinition] Attribute's definition
+      def attribute(name)
+        fail Neo4j::DangerousAttributeError, %(an attribute method named "#{name}" would conflict with an existing method) if dangerous_attribute?(name)
+
+        attribute!(name)
+      end
+
+      # Returns an Array of attribute names as Strings
+      #
+      # @example Get attribute names
+      #   Person.attribute_names
+      #
+      # @return [Array<String>] The attribute names
+      def attribute_names
+        attributes.keys
+      end
+
+      # Returns a Hash of AttributeDefinition instances
+      #
+      # @example Get attribute definitions
+      #   Person.attributes
+      #
+      # @return [ActiveSupport::HashWithIndifferentAccess{String => Neo4j::Shared::AttributeDefinition}]
+      #   The Hash of AttributeDefinition instances
+      def attributes
+        @attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+
+      # Determine if a given attribute name is dangerous
+      #
+      # Some attribute names can cause conflicts with existing methods
+      # on an object. For example, an attribute named "timeout" would
+      # conflict with the timeout method that Ruby's Timeout library
+      # mixes into Object.
+      #
+      # @example Testing a harmless attribute
+      #   Person.dangerous_attribute? :name #=> false
+      #
+      # @example Testing a dangerous attribute
+      #   Person.dangerous_attribute? :nil #=> "nil?"
+      #
+      # @param name Attribute name
+      #
+      # @return [false, String] False or the conflicting method name
+      def dangerous_attribute?(name)
+        methods = instance_methods
+
+        attribute_methods(name).detect do |method_name|
+          !DEPRECATED_OBJECT_METHODS.include?(method_name.to_s) && methods.include?(method_name)
+        end unless attribute_names.include? name.to_s
+      end
+
+      # Returns the class name plus its attribute names
+      #
+      # @example Inspect the model's definition.
+      #   Person.inspect
+      #
+      # @return [String] Human-readable presentation of the attributes
+      def inspect
+        inspected_attributes = attribute_names.sort
+        attributes_list = "(#{inspected_attributes.join(', ')})" unless inspected_attributes.empty?
+        "#{name}#{attributes_list}"
+      end
+
+      protected
+
+      # Assign a set of attribute definitions, used when subclassing models
+      #
+      # @param [Array<Neo4j::Shared::DeclaredProperties>] The Array of
+      #   AttributeDefinition instances
+      def attributes=(attributes)
+        @attributes = attributes
+      end
+
+      # Overrides ActiveModel::AttributeMethods to backport 3.2 fix
+      def instance_method_already_implemented?(method_name)
+        generated_attribute_methods.method_defined?(method_name)
+      end
+
+      private
+
+      # Expand an attribute name into its generated methods names
+      def attribute_methods(name)
+        attribute_method_matchers.map { |matcher| matcher.method_name name }
+      end
+
+      # Ruby inherited hook to assign superclass attributes to subclasses
+      def inherited(subclass)
+        super
+        subclass.attributes = attributes.dup
+      end
+    end
+  end
+end

data/lib/neo4j/shared/callbacks.rb

@@ -0,0 +1,68 @@
+module Neo4j
+  module Shared
+    module Callbacks #:nodoc:
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        include ActiveModel::Callbacks
+      end
+
+      included do
+        include ActiveModel::Validations::Callbacks
+        # after_find is triggered by the `find` method defined in lib/neo4j/active_node/id_property.rb
+        define_model_callbacks :initialize, :find, only: :after
+        define_model_callbacks :create_commit, :update_commit, :destroy_commit, only: :after
+        define_model_callbacks :save, :create, :update, :destroy, :touch
+      end
+
+      def initialize(args = nil)
+        run_callbacks(:initialize) { super }
+      end
+
+      def destroy #:nodoc:
+        tx = Neo4j::ActiveBase.new_transaction
+        tx.root.after_commit { run_callbacks(:destroy_commit) {} }
+        run_callbacks(:destroy) { super }
+      rescue
+        @_deleted = false
+        @attributes = @attributes.dup
+        tx.mark_failed if tx
+        raise
+      ensure
+        tx.close if tx
+      end
+
+      def touch #:nodoc:
+        run_callbacks(:touch) { super }
+      end
+
+      # Allows you to perform a callback if a condition is not satisfied.
+      # @param [Symbol] kind The callback type to execute unless the guard is true
+      # @param [TrueClass,FalseClass] guard When this value is true, the block is yielded without executing callbacks.
+      def conditional_callback(kind, guard)
+        return yield if guard
+        run_callbacks(kind) { yield }
+      end
+
+      private
+
+      def create_or_update #:nodoc:
+        run_callbacks(:save) { super }
+      end
+
+      def create_model #:nodoc:
+        self.class.run_transaction do |tx|
+          tx.root.after_commit { run_callbacks(:create_commit) {} }
+          run_callbacks(:create) { super }
+        end
+      end
+
+      def update_model(*) #:nodoc:
+        self.class.run_transaction do |tx|
+          tx.root.after_commit { run_callbacks(:update_commit) {} }
+          run_callbacks(:update) { super }
+        end
+      end
+    end
+  end
+end