activegraph 10.0.0.pre.alpha.6

data/lib/neo4j/shared/typecasted_attributes.rb

@@ -0,0 +1,98 @@
+module Neo4j::Shared
+  # TypecastedAttributes allows types to be declared for your attributes
+  #
+  # Types are declared by passing the :type option to the attribute class
+  # method. After a type is declared, attribute readers will convert any
+  # assigned attribute value to the declared type. If the assigned value
+  # cannot be cast, nil will be returned instead. You can access the original
+  # assigned value using the before_type_cast methods.
+  #
+  # See {Typecasting} for the currently supported types.
+  #
+  # @example Usage
+  #   class Person
+  #     include Neo4j::Shared::TypecastedAttributes
+  #     attribute :age, :type => Integer
+  #   end
+  #
+  #   person = Person.new
+  #   person.age = "29"
+  #   person.age #=> 29
+  #   person.age_before_type_cast #=> "29"
+  #
+  # Originally part of ActiveAttr, https://github.com/cgriego/active_attr
+  module TypecastedAttributes
+    extend ActiveSupport::Concern
+    include Neo4j::Shared::Attributes
+
+    included do
+      attribute_method_suffix '_before_type_cast'
+    end
+
+    # Read the raw attribute value
+    #
+    # @example Reading a raw age value
+    #   person.age = "29"
+    #   person.attribute_before_type_cast(:age) #=> "29"
+    #
+    # @param [String, Symbol, #to_s] name Attribute name
+    #
+    # @return [Object, nil] The attribute value before typecasting
+    def attribute_before_type_cast(name)
+      @attributes ||= {}
+      @attributes[name.to_s]
+    end
+
+    private
+
+    # Reads the attribute and typecasts the result
+    def attribute(name)
+      typecast_attribute(_attribute_typecaster(name), super)
+    end
+
+    def typecast_attribute(typecaster, value)
+      self.class.typecast_attribute(typecaster, value)
+    end
+
+    # Calculates an attribute type
+    #
+    # @private
+    def _attribute_type(attribute_name)
+      self.class._attribute_type(attribute_name)
+    end
+
+    # Resolve an attribute typecaster
+    #
+    # @private
+    def _attribute_typecaster(attribute_name)
+      type = _attribute_type(attribute_name)
+      caster = self.class.attributes[attribute_name].typecaster || Neo4j::Shared::TypeConverters.typecaster_for(type)
+      caster || fail(Neo4j::UnknownTypeConverterError, "Unable to cast to type #{type}")
+    end
+
+    module ClassMethods
+      # Returns the class name plus its attribute names and types
+      #
+      # @example Inspect the model's definition.
+      #   Person.inspect
+      #
+      # @return [String] Human-readable presentation of the attributes
+      def inspect
+        inspected_attributes = attribute_names.sort.map { |name| "#{name}: #{_attribute_type(name)}" }
+        attributes_list = "(#{inspected_attributes.join(', ')})" unless inspected_attributes.empty?
+        "#{name}#{attributes_list}"
+      end
+
+      # Calculates an attribute type
+      #
+      # @private
+      def _attribute_type(attribute_name)
+        attributes[attribute_name].type || Object
+      end
+
+      def typecast_attribute(typecaster, value)
+        Neo4j::Shared::TypeConverters.typecast_attribute(typecaster, value)
+      end
+    end
+  end
+end

data/lib/neo4j/shared/typecaster.rb

@@ -0,0 +1,53 @@
+module Neo4j
+  module Shared
+    # This module provides a convenient way of registering a custom Typecasting class. Custom Typecasters all follow a simple pattern.
+    #
+    # EXAMPLE:
+    #
+    # .. code-block:: ruby
+    #
+    #   class RangeConverter
+    #     class << self
+    #       def primitive_type
+    #         String
+    #       end
+    #
+    #       def convert_type
+    #         Range
+    #       end
+    #
+    #       def to_db(value)
+    #         value.to_s
+    #       end
+    #
+    #       def to_ruby(value)
+    #         ends = value.to_s.split('..').map { |d| Integer(d) }
+    #         ends[0]..ends[1]
+    #       end
+    #       alias_method :call, :to_ruby
+    #     end
+    #
+    #     include Neo4j::Shared::Typecaster
+    #   end
+    #
+    # This would allow you to use `property :my_prop, type: Range` in a model.
+    # Each method and the `alias_method` call is required. Make sure the module inclusion happens at the end of the file.
+    #
+    # `primitive_type` is used to fool ActiveAttr's type converters, which only recognize a few basic Ruby classes.
+    #
+    # `convert_type` must match the constant given to the `type` option.
+    #
+    # `to_db` provides logic required to transform your value into the class defined by `primitive_type`
+    #
+    # `to_ruby` provides logic to transform the DB-provided value back into the class expected by code using the property.
+    # In other words, it should match the `convert_type`.
+    #
+    # Note that `alias_method` is used to make `to_ruby` respond to `call`. This is to provide compatibility with ActiveAttr.
+
+    module Typecaster
+      def self.included(other)
+        Neo4j::Shared::TypeConverters.register_converter(other)
+      end
+    end
+  end
+end

data/lib/neo4j/shared/validations.rb

@@ -0,0 +1,44 @@
+module Neo4j
+  module Shared
+    module Validations
+      extend ActiveSupport::Concern
+      include ActiveModel::Validations
+      # Implements the ActiveModel::Validation hook method.
+      # @see http://rubydoc.info/docs/rails/ActiveModel/Validations:read_attribute_for_validation
+      def read_attribute_for_validation(key)
+        respond_to?(key) ? send(key) : self[key]
+      end
+
+      # The validation process on save can be skipped by passing false. The regular Model#save method is
+      # replaced with this when the validations module is mixed in, which it is by default.
+      # @param [Hash] options the options to create a message with.
+      # @option options [true, false] :validate if false no validation will take place
+      # @return [Boolean] true if it saved it successfully
+      def save(options = {})
+        perform_validations(options) ? super : false
+      end
+
+      # @return [Boolean] true if valid
+      def valid?(context = nil)
+        context ||= (new_record? ? :create : :update)
+        super(context)
+        errors.empty?
+      end
+
+      private
+
+      def perform_validations(options = {})
+        perform_validation = case options
+                             when Hash
+                               options[:validate] != false
+                             end
+
+        if perform_validation
+          valid?(options.is_a?(Hash) ? options[:context] : nil)
+        else
+          true
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/tasks/migration.rake

@@ -0,0 +1,202 @@
+require 'rake'
+require 'active_support/concern'
+require 'neo4j/migration'
+
+if !defined?(Rails) && !Rake::Task.task_defined?('environment')
+  desc 'Run a script against the database to perform system-wide changes'
+  task :environment do
+    require 'neo4j/session_manager'
+    require 'ostruct'
+    neo4j_url = ENV['NEO4J_URL'] || 'http://localhost:7474'
+    $LOAD_PATH.unshift File.dirname('./')
+    Neo4j::ActiveBase.on_establish_session do
+      Neo4j::ActiveBase.new_driver(neo4j_url)
+    end
+  end
+end
+
+namespace :neo4j do
+  task :allow_migrations do
+    Neo4j::Migrations.currently_running_migrations = true
+  end
+  desc 'Run a script against the database to perform system-wide changes'
+  task :legacy_migrate, [:task_name, :subtask] => :environment do |_, args|
+    path = Rake.original_dir
+    migration_task = args[:task_name]
+    task_name_constant = migration_task.split('_').map(&:capitalize).join('')
+    begin
+      migration_class = "Neo4j::Migration::#{task_name_constant}".constantize
+    rescue NameError
+      load File.join(path, 'db', 'neo4j-migrate', "#{migration_task}.rb")
+      migration_class = task_name_constant.to_s.constantize
+    end
+    migration = migration_class.new(path)
+
+    subtask = args[:subtask]
+    if subtask
+      migration.send(subtask)
+    else
+      migration.migrate
+    end
+  end
+
+  desc 'A shortcut for neo4j::migrate::all'
+  task :migrate do
+    Rake::Task['neo4j:migrate:all'].invoke
+  end
+
+  # TODO: Make sure these tasks don't run in versions of Neo4j before 3.0
+  namespace :schema do
+    SCHEMA_YAML_PATH = 'db/neo4j/schema.yml'
+    SCHEMA_YAML_COMMENT = <<COMMENT
+# This file is auto-generated from the current state of the database. Instead
+# of editing this file, please use the migrations feature of ActiveNode to
+# incrementally modify your database, and then regenerate this schema definition.
+#
+# Note that this schema.yml definition is the authoritative source for your
+# database schema. If you need to create the application database on another
+# system, you should be using neo4j:schema:load, not running all the migrations
+# from scratch. The latter is a flawed and unsustainable approach (the more migrations
+# you'll amass, the slower it'll run and the greater likelihood for issues).
+#
+# It's strongly recommended that you check this file into your version control system.
+
+COMMENT
+
+    def check_neo4j_version_3
+      if Neo4j::ActiveBase.transaction.version > '3.0.0'
+        yield
+      else
+        puts 'WARNING: This task does not work for versions of Neo4j before 3.0.0'
+      end
+    end
+
+    desc 'Creates a db/neo4j/schema.yml file which represents the indexes / constraints in the Neo4j DB'
+    task dump: :environment do
+      check_neo4j_version_3 do
+        require 'neo4j/migrations/schema'
+
+        schema_data = Neo4j::Migrations::Schema.fetch_schema_data(Neo4j::ActiveBase.transaction)
+
+        runner = Neo4j::Migrations::Runner.new
+        schema_data[:versions] = runner.complete_migration_versions.sort
+
+        FileUtils.mkdir_p(File.dirname(SCHEMA_YAML_PATH))
+        File.open(SCHEMA_YAML_PATH, 'w') { |file| file << SCHEMA_YAML_COMMENT + schema_data.to_yaml }
+
+        puts "Dumped updated schema file to #{SCHEMA_YAML_PATH}"
+      end
+    end
+
+    desc "Loads a db/neo4j/schema.yml file into the database\nOptionally removes schema elements which aren't in the schema.yml file (defaults to false)"
+    task :load, [:remove_missing] => :environment do |_t, args|
+      check_neo4j_version_3 do
+        require 'neo4j/migrations/schema'
+
+        args.with_defaults(remove_missing: false)
+
+        schema_data = YAML.safe_load(File.read(SCHEMA_YAML_PATH), [Symbol])
+
+        Neo4j::Core::CypherSession::Adaptors::Base.subscribe_to_query(&method(:puts))
+
+        Neo4j::ActiveBase.run_transaction do
+          Neo4j::Migrations::Schema.synchronize_schema_data(Neo4j::ActiveBase.transaction, schema_data, args[:remove_missing])
+
+          runner = Neo4j::Migrations::Runner.new
+          runner.mark_versions_as_complete(schema_data[:versions]) # Run in test mode?
+        end
+      end
+    end
+  end
+
+  namespace :migrate do
+    desc 'Run all pending migrations'
+    task all: [:allow_migrations, :environment] do
+      runner = Neo4j::Migrations::Runner.new
+      runner.all
+
+      Rake::Task['neo4j:schema:dump'].invoke
+    end
+
+    desc 'Run a migration given its VERSION'
+    task up: [:allow_migrations, :environment] do
+      version = ENV['VERSION'] || fail(ArgumentError, 'VERSION is required')
+      runner = Neo4j::Migrations::Runner.new
+      runner.up version
+
+      Rake::Task['neo4j:schema:dump'].invoke
+    end
+
+    desc 'Revert a migration given its VERSION'
+    task down: [:allow_migrations, :environment] do
+      version = ENV['VERSION'] || fail(ArgumentError, 'VERSION is required')
+      runner = Neo4j::Migrations::Runner.new
+      runner.down version
+
+      Rake::Task['neo4j:schema:dump'].invoke
+    end
+
+    desc 'Print a report of migrations status'
+    task status: [:allow_migrations, :environment] do
+      runner = Neo4j::Migrations::Runner.new
+      runner.status
+    end
+
+    desc 'Resolve an incomplete version state'
+    task resolve: [:allow_migrations, :environment] do
+      version = ENV['VERSION'] || fail(ArgumentError, 'VERSION is required')
+      runner = Neo4j::Migrations::Runner.new
+      runner.resolve version
+    end
+
+    desc 'Resolve an incomplete version state'
+    task reset: [:allow_migrations, :environment] do
+      version = ENV['VERSION'] || fail(ArgumentError, 'VERSION is required')
+      runner = Neo4j::Migrations::Runner.new
+      runner.reset version
+    end
+  end
+
+  desc 'Rollbacks migrations given a STEP number'
+  task rollback: [:allow_migrations, :environment] do
+    steps = (ENV['STEP'] || 1).to_i
+    runner = Neo4j::Migrations::Runner.new
+    runner.rollback(steps)
+
+    Rake::Task['neo4j:schema:dump'].invoke
+  end
+
+  # Temporary to help people change to 8.0
+  desc 'Generates a migration for the specified constraint/index and label/property combination.'
+  task :generate_schema_migration, :index_or_constraint, :label, :property_name do |_t, args|
+    index_or_constraint, label, property_name = args.values_at(:index_or_constraint, :label, :property_name)
+
+    if !%w(index constraint).include?(index_or_constraint)
+      fail "Invalid schema element type: #{index_or_constraint} (should be either `index` or `constraint`)"
+    end
+    fail 'Label must be specified' if label.blank?
+    fail 'Property name must be specified' if property_name.blank?
+
+    migration_class_name = "ForceCreate#{label.camelize}#{property_name.camelize}#{index_or_constraint.capitalize}".gsub('::', '').underscore.camelize
+
+    require 'fileutils'
+    FileUtils.mkdir_p('db/neo4j/migrate')
+    path = File.join('db/neo4j/migrate', "#{DateTime.now.utc.strftime('%Y%m%d%H%M%S')}_#{migration_class_name.underscore}.rb")
+
+    content = <<-CONTENT
+class #{migration_class_name} < Neo4j::Migrations::Base
+  def up
+    add_#{index_or_constraint} #{label.to_sym.inspect}, #{property_name.to_sym.inspect}, force: true
+  end
+
+  def down
+    drop_#{index_or_constraint} #{label.to_sym.inspect}, #{property_name.to_sym.inspect}
+  end
+end
+CONTENT
+
+    File.open(path, 'w') { |f| f << content }
+
+    puts "Generated #{path}"
+  end
+end

data/lib/neo4j/timestamps.rb

@@ -0,0 +1,11 @@
+require 'neo4j/timestamps/created'
+require 'neo4j/timestamps/updated'
+
+module Neo4j
+  # This mixin includes timestamps in the included class
+  module Timestamps
+    extend ActiveSupport::Concern
+    include Created
+    include Updated
+  end
+end

data/lib/neo4j/timestamps/created.rb

@@ -0,0 +1,9 @@
+module Neo4j
+  module Timestamps
+    # This mixin includes a created_at timestamp property
+    module Created
+      extend ActiveSupport::Concern
+      included { property :created_at }
+    end
+  end
+end

data/lib/neo4j/timestamps/updated.rb

@@ -0,0 +1,9 @@
+module Neo4j
+  module Timestamps
+    # This mixin includes a updated_at timestamp property
+    module Updated
+      extend ActiveSupport::Concern
+      included { property :updated_at }
+    end
+  end
+end

data/lib/neo4j/transaction.rb

@@ -0,0 +1,139 @@
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/attribute_accessors_per_thread'
+require 'neo4j/core/querable'
+require 'neo4j/core/schema'
+
+module Neo4j
+  class Transaction
+    include Neo4j::Core::Querable
+    extend Neo4j::Core::Schema
+
+    thread_mattr_accessor :stack
+    attr_reader :root
+    attr_reader :driver_tx, :driver_session
+
+    class << self
+      # Runs the given block in a new transaction.
+      # @param [Boolean] run_in_tx if true a new transaction will not be created, instead if will simply yield to the given block
+      # @@yield [Neo4j::Transaction::Instance]
+      def run(driver, run_in_tx)
+        return yield(nil) unless run_in_tx
+
+        tx = Neo4j::Transaction.new
+        yield tx
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        tx.mark_failed unless tx.nil?
+        raise e
+      ensure
+        tx.close unless tx.nil?
+      end
+
+      def root
+        initialized_stack.first
+      end
+
+      def initialized_stack
+        self.stack ||= []
+      end
+    end
+
+    def initialize(_options = {})
+      self.class.initialized_stack << self
+      @root = stack.first
+      return unless root?
+      @driver_session = ActiveBase.current_driver.driver.session(Neo4j::Driver::AccessMode::WRITE)
+      @driver_tx = @driver_session.begin_transaction
+    rescue StandardError => e
+      self.stack = []
+      @driver_tx.close if @driver_tx
+      @driver_session.close if @driver_session
+      raise e
+    end
+
+    # Commits or marks this transaction for rollback, depending on whether #mark_failed has been previously invoked.
+    def close
+      fail 'Tried closing when transaction stack is empty (maybe you closed too many?)' if stack.empty?
+      fail "Closed transaction which wasn't the most recent on the stack (maybe you forgot to close one?)" if stack.pop != self
+
+      post_close! if stack.empty?
+    end
+
+    # Marks this transaction as failed,
+    # which means that it will unconditionally be rolled back
+    # when #close is called.
+    # Aliased for legacy purposes.
+    def mark_failed
+      root.mark_failed if root && root != self
+      @failure = true
+    end
+
+    alias failure mark_failed
+
+    # If it has been marked as failed.
+    # Aliased for legacy purposes.
+    def failed?
+      !!@failure
+    end
+
+    alias failure? failed?
+
+    def root?
+      @root == self
+    end
+
+    def query(*args)
+      options = if args[0].is_a?(::Neo4j::Core::Query)
+                  args[1] ||= {}
+                else
+                  args[1] ||= {}
+                  args[2] ||= {}
+                end
+      options[:transaction] ||= self
+
+      self.class.query(*args)
+    end
+
+    def queries(options = {}, &block)
+      self.class.queries({ transaction: self }.merge(options), &block)
+    end
+
+    def after_commit_registry
+      @after_commit_registry ||= []
+    end
+
+    def after_commit(&block)
+      after_commit_registry << block
+    end
+
+    def commit
+      return unless root?
+      begin
+        @driver_tx.success
+        @driver_tx.close
+      ensure
+        @driver_session.close
+      end
+    end
+
+    def delete
+      root.driver_tx.failure
+      root.driver_tx.close
+      root.driver_session.close
+    end
+
+    def root_tx
+      root.driver_tx
+    end
+
+    private
+
+    def post_close!
+      if failed?
+        delete
+      else
+        commit
+        after_commit_registry.each(&:call)
+      end
+    end
+  end
+end