activegraph 11.0.0.beta.1-java

data/lib/active_graph/node/validations.rb

@@ -0,0 +1,59 @@
+module ActiveGraph
+  module Node
+    # This mixin replace the original save method and performs validation before the save.
+    module Validations
+      extend ActiveSupport::Concern
+      include ActiveGraph::Shared::Validations
+
+
+      # @return [Boolean] true if valid
+      def valid?(context = nil)
+        context ||= (new_record? ? :create : :update)
+        super(context)
+        errors.empty?
+      end
+
+      module ClassMethods
+        def validates_uniqueness_of(*attr_names)
+          validates_with UniquenessValidator, _merge_attributes(attr_names)
+        end
+      end
+
+
+      class UniquenessValidator < ::ActiveModel::EachValidator
+        def initialize(options)
+          super(options.reverse_merge(case_sensitive: true))
+        end
+
+        def validate_each(record, attribute, value)
+          return unless found(record, attribute, value).exists?
+
+          record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(value: value))
+        end
+
+        def found(record, attribute, value)
+          conditions = scope_conditions(record)
+
+          # TODO: Added as find(:name => nil) throws error
+          value = '' if value.nil?
+
+          conditions[attribute] = options[:case_sensitive] ? value : /#{Regexp.escape(value.to_s)}/i
+
+          found = record.class.as(:result).where(conditions)
+          found = found.where_not(neo_id: record.neo_id) if record._persisted_obj
+          found
+        end
+
+        def message(instance)
+          super || 'has already been taken'
+        end
+
+        def scope_conditions(instance)
+          Array(options[:scope] || []).inject({}) do |conditions, key|
+            conditions.merge(key => instance[key])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_graph/paginated.rb

@@ -0,0 +1,27 @@
+module ActiveGraph
+  class Paginated
+    include Enumerable
+    attr_reader :items, :total, :current_page
+
+    def initialize(items, total, current_page)
+      @items = items
+      @total = total
+      @current_page = current_page
+    end
+
+    def self.create_from(source, page, per_page, order = nil)
+      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]
+                                        else
+                                          [partial, source.count]
+                                        end
+      Paginated.new(ordered_partial, ordered_source, page)
+    end
+
+    delegate :each, to: :items
+    delegate :pluck, to: :items
+    delegate :size, :[], to: :items
+  end
+end

data/lib/active_graph/railtie.rb

@@ -0,0 +1,108 @@
+require 'active_support/notifications'
+require 'rails/railtie'
+# Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
+require 'action_dispatch/railtie'
+require 'active_graph'
+
+module ActiveGraph
+  class Railtie < ::Rails::Railtie
+    def empty_config
+      ActiveSupport::OrderedOptions.new.tap do |cfg|
+        cfg.driver = ActiveSupport::OrderedOptions.new
+      end
+    end
+
+    config.neo4j = empty_config
+
+    if defined?(ActiveSupport::Reloader)
+      ActiveSupport::Reloader.to_prepare do
+        ActiveGraph::Node::Labels::Reloading.reload_models!
+      end
+    elsif const_defined?(:ActionDispatch)
+      ActionDispatch::Reloader.to_prepare do
+        ActiveGraph::Node::Labels::Reloading.reload_models!
+      end
+    end
+
+    # Rescue responses similar to ActiveRecord.
+    config.action_dispatch.rescue_responses.merge!(
+      'ActiveGraph::RecordNotFound' => :not_found,
+      'ActiveGraph::Node::Labels::RecordNotFound' => :not_found
+    )
+
+    # Add ActiveModel translations to the I18n load_path
+    initializer 'i18n' do
+      config.i18n.load_path += Dir[File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'locales', '*.{rb,yml}')]
+    end
+
+    console do
+      ActiveGraph::Config[:logger] = ActiveSupport::Logger.new(STDOUT)
+      ActiveGraph::Config[:verbose_query_logs] = false
+    end
+
+    # Starting Neo after :load_config_initializers allows apps to
+    # register migrations in config/initializers
+    initializer 'neo4j.start', after: :load_config_initializers do |app|
+      app.config.neo4j.skip_migration_check = true if Rails.env.test?
+
+      neo4j_config = ActiveSupport::OrderedOptions.new
+      app.config.neo4j.each { |k, v| neo4j_config[k] = v } if app.config.neo4j
+
+      ActiveGraph::Config.configuration.merge!(neo4j_config.to_h)
+
+      ActiveGraph::Base.on_establish_driver { setup! neo4j_config }
+
+      ActiveGraph::Config[:logger] ||= Rails.logger
+
+      if ActiveGraph::Config.fail_on_pending_migrations
+        config.app_middleware.insert_after ::ActionDispatch::Callbacks, ActiveGraph::Migrations::CheckPending
+      end
+    end
+
+    def setup!(config = empty_config)
+      config = final_driver_config!(config)
+      scheme = config.delete(:scheme) || 'bolt'
+      host = config.delete(:host) || 'localhost'
+      port = config.delete(:port) || 7687
+      url = config.delete(:url) || URI::Generic.build( scheme: scheme, host: host, port: port ).to_s
+      username = config.delete(:username)
+      password = config.delete(:password)
+      auth_token = config.delete(:auth_token)
+      auth_token ||= username ? Neo4j::Driver::AuthTokens.basic(username, password) : Neo4j::Driver::AuthTokens.none
+      register_neo4j_cypher_logging
+
+      method = url.is_a?(Enumerable) ? :routing_driver : :driver
+      Neo4j::Driver::GraphDatabase.send(method, url, auth_token, config)
+    end
+
+    def final_driver_config!(config)
+      { url: ENV['NEO4J_URL'] }.compact.merge(config[:driver]).merge(yaml_config_data)
+    end
+
+    def yaml_config_data
+      @yaml_config_data ||=
+        yaml_path ? YAML.load(ERB.new(yaml_path.read).result)[Rails.env].transform_keys!(&:to_sym) : {}
+    end
+
+    def yaml_path
+      return unless defined?(Rails)
+      @yaml_path ||= %w(config/neo4j.yml config/neo4j.yaml).map do |path|
+        Rails.root.join(path)
+      end.detect(&:exist?)
+    end
+
+    def register_neo4j_cypher_logging
+      return if @neo4j_cypher_logging_registered
+
+      ActiveGraph::Core::Query.pretty_cypher = ActiveGraph::Config[:pretty_logged_cypher_queries]
+
+      logger_proc = ->(message) do
+        (ActiveGraph::Config[:logger] ||= Rails.logger).debug message
+      end
+      ActiveGraph::Base.subscribe_to_query(&logger_proc)
+      ActiveGraph::Base.subscribe_to_request(&logger_proc)
+
+      @neo4j_cypher_logging_registered = true
+    end
+  end
+end

data/lib/active_graph/relationship.rb

@@ -0,0 +1,68 @@
+module ActiveGraph
+  # Makes Neo4j Relationships more or less act like ActiveRecord objects.
+  # See documentation at https://github.com/neo4jrb/neo4j/wiki/Neo4j%3A%3AActiveRel
+  module Relationship
+    extend ActiveSupport::Concern
+
+    MARSHAL_INSTANCE_VARIABLES = [:@attributes, :@type, :@_persisted_obj]
+
+    include ActiveGraph::Shared
+    include ActiveGraph::Relationship::Initialize
+    include ActiveGraph::Shared::Identity
+    include ActiveGraph::Shared::Marshal
+    include ActiveGraph::Shared::SerializedProperties
+    include ActiveGraph::Relationship::Property
+    include ActiveGraph::Relationship::Persistence
+    include ActiveGraph::Relationship::Validations
+    include ActiveGraph::Relationship::Callbacks
+    include ActiveGraph::Relationship::Query
+    include ActiveGraph::Relationship::Types
+    include ActiveGraph::Shared::Enum
+    include ActiveGraph::Shared::PermittedAttributes
+    include ActiveGraph::Transactions
+
+    class FrozenRelError < ActiveGraph::Error; end
+
+    def initialize(from_node = nil, to_node = nil, args = nil)
+      load_nodes(node_or_nil(from_node), node_or_nil(to_node))
+      resolved_args = hash_or_nil(from_node, args)
+      symbol_args = sanitize_input_parameters(resolved_args)
+      super(symbol_args)
+    end
+
+    def node_cypher_representation(node)
+      node_class = node.class
+      id_name = node_class.id_property_name
+      labels = ':' + node_class.mapped_label_names.join(':')
+
+      "(#{labels} {#{id_name}: #{node.id.inspect}})"
+    end
+
+    def neo4j_obj
+      _persisted_obj || fail('Tried to access native neo4j object on a non persisted object')
+    end
+
+    included do
+      include ActiveGraph::Timestamps if ActiveGraph::Config[:record_timestamps]
+
+      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
+
+    ActiveSupport.run_load_hooks(:relationship, self)
+
+    private
+
+    def node_or_nil(node)
+      node.is_a?(ActiveGraph::Node) || node.is_a?(Integer) ? node : nil
+    end
+
+    def hash_or_nil(node_or_hash, hash_or_nil)
+      hash_or_parameter?(node_or_hash) ? node_or_hash : hash_or_nil
+    end
+  end
+end

data/lib/active_graph/relationship/callbacks.rb

@@ -0,0 +1,21 @@
+module ActiveGraph
+  module Relationship
+    module Callbacks #:nodoc:
+      extend ActiveSupport::Concern
+      include ActiveGraph::Shared::Callbacks
+
+      def save(*args)
+        unless _persisted_obj || (from_node.respond_to?(:neo_id) && to_node.respond_to?(:neo_id))
+          fail ActiveGraph::Relationship::Persistence::RelInvalidError, 'from_node and to_node must be node objects'
+        end
+        super(*args)
+      end
+
+      def destroy
+        to_node.callbacks_from_relationship(self, :in, from_node).try(:last)
+        from_node.callbacks_from_relationship(self, :out, to_node).try(:last)
+        super
+      end
+    end
+  end
+end

data/lib/active_graph/relationship/initialize.rb

@@ -0,0 +1,28 @@
+module ActiveGraph::Relationship
+  module Initialize
+    extend ActiveSupport::Concern
+    include ActiveGraph::Shared::Initialize
+
+    # called when loading the rel from the database
+    # @param [ActiveGraph::Embedded::EmbeddedRelationship, Neo4j::Server::CypherRelationship] persisted_rel properties of this relationship
+    # @param [ActiveGraph::Relationship] from_node_id The neo_id of the starting node of this rel
+    # @param [ActiveGraph::Relationship] to_node_id The neo_id of the ending node of this rel
+    # @param [String] type the relationship type
+    def init_on_load(persisted_rel, from_node_id, to_node_id, type)
+      @type = type
+      @_persisted_obj = persisted_rel
+      changed_attributes_clear!
+      @attributes = convert_and_assign_attributes(persisted_rel.properties)
+      load_nodes(from_node_id, to_node_id)
+    end
+
+    def init_on_reload(unwrapped_reloaded)
+      @attributes = nil
+      init_on_load(unwrapped_reloaded,
+                   unwrapped_reloaded.start_node_id,
+                   unwrapped_reloaded.end_node_id,
+                   unwrapped_reloaded.type)
+      self
+    end
+  end
+end

data/lib/active_graph/relationship/persistence.rb

@@ -0,0 +1,133 @@
+module ActiveGraph::Relationship
+  module Persistence
+    extend ActiveSupport::Concern
+    include ActiveGraph::Shared::Cypher::RelIdentifiers
+    include ActiveGraph::Shared::Persistence
+
+    class RelInvalidError < RuntimeError; end
+    class ModelClassInvalidError < RuntimeError; end
+    class RelCreateFailedError < RuntimeError; end
+
+    def from_node_identifier
+      @from_node_identifier || :from_node
+    end
+
+    def to_node_identifier
+      @to_node_identifier || :to_node
+    end
+
+    def from_node_identifier=(id)
+      @from_node_identifier = id.to_sym
+    end
+
+    def to_node_identifier=(id)
+      @to_node_identifier = id.to_sym
+    end
+
+    def cypher_identifier
+      @cypher_identifier || :rel
+    end
+
+    def save(*)
+      create_or_update
+    end
+
+    def save!(*args)
+      save(*args) or fail(RelInvalidError, inspect) # rubocop:disable Style/AndOr
+    end
+
+    # Increments concurrently a numeric attribute by a centain amount
+    # @param [Symbol, String] attribute name of the attribute to increment
+    # @param [Integer, Float] by  amount to increment
+    def concurrent_increment!(attribute, by = 1)
+      increment_by_query! query_as(:r), attribute, by, :r
+    end
+
+    def create_model
+      validate_node_classes!
+      delete_has_one_rel
+      rel = _create_rel
+      return self unless rel.respond_to?(:properties)
+      init_on_load(rel, from_node, to_node, @type)
+      true
+    end
+
+    def delete_has_one_rel
+      to_node.delete_reverse_has_one_relationship(self, :in, from_node) if to_node.persisted?
+      from_node.delete_reverse_has_one_relationship(self, :out, to_node) if from_node.persisted?
+    end
+
+    def query_as(var)
+      # This should query based on the nodes, not the rel neo_id, I think
+      # Also, picky point: Should the var be `n`?
+      self.class.query_as(neo_id, var)
+    end
+
+    module ClassMethods
+      # Creates a new relationship between objects
+      # @param [Hash] args the properties the new relationship should have
+      def create(*args)
+        new(*args).tap(&:save)
+      end
+
+      # Same as #create, but raises an error if there is a problem during save.
+      def create!(*args)
+        new(*args).tap(&:save!)
+      end
+
+      def create_method
+        creates_unique? ? :create_unique : :create
+      end
+
+      def load_entity(id)
+        query_as(id).pluck(:r).first
+      end
+
+      def query_as(neo_id, var = :r)
+        ActiveGraph::Base.new_query.match("()-[#{var}]->()").where(var => {neo_id: neo_id})
+      end
+    end
+
+    def create_method
+      self.class.create_method
+    end
+
+    private
+
+    def destroy_query
+      query_as(:r).delete(:r)
+    end
+
+    def validate_node_classes!
+      [from_node, to_node].each do |node|
+        type = from_node == node ? :_from_class : :_to_class
+        type_class = self.class.send(type)
+
+        unless valid_type?(type_class, node)
+          fail ModelClassInvalidError, type_validation_error_message(node, type_class)
+        end
+      end
+    end
+
+    def valid_type?(type_object, node)
+      case type_object
+      when false, :any
+        true
+      when Array
+        type_object.any? { |c| valid_type?(c, node) }
+      else
+        node.class.mapped_label_names.include?(type_object.to_s.constantize.mapped_label_name)
+      end
+    end
+
+    def type_validation_error_message(node, type_class)
+      "Node class was #{node.class} (#{node.class.object_id}), expected #{type_class} (#{type_class.object_id})"
+    end
+
+    def _create_rel
+      factory = QueryFactory.new(from_node, to_node, self)
+      factory.build!
+      factory.unwrapped_rel
+    end
+  end
+end