activegraph 11.0.0.beta.1-java

data/lib/active_graph/shared/typecasted_attributes.rb

@@ -0,0 +1,99 @@
+module ActiveGraph::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 ActiveGraph::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 ActiveGraph::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 ||= ActiveGraph::AttributeSet.new({}, self.class.attributes.keys)
+      @attributes.fetch_value(name.to_s)
+    end
+
+    private
+
+    # Reads the attribute and typecasts the result
+    def attribute(name)
+      Property::NEO4J_DRIVER_DATA_TYPES.include?(_attribute_type(name)) ? super : 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)
+      default_typecaster = self.class.attributes[attribute_name].typecaster
+      caster = default_typecaster || ActiveGraph::Shared::TypeConverters.typecaster_for(type)
+      caster || fail(ActiveGraph::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)
+        ActiveGraph::Shared::TypeConverters.typecast_attribute(typecaster, value)
+      end
+    end
+  end
+end

data/lib/active_graph/shared/typecaster.rb

@@ -0,0 +1,53 @@
+module ActiveGraph
+  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 ActiveGraph::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)
+        ActiveGraph::Shared::TypeConverters.register_converter(other)
+      end
+    end
+  end
+end

data/lib/active_graph/shared/validations.rb

@@ -0,0 +1,44 @@
+module ActiveGraph
+  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/active_graph/tasks/migration.rake

@@ -0,0 +1,204 @@
+require 'rake'
+require 'active_support/concern'
+require 'active_graph/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 'active_graph/session_manager'
+    require 'ostruct'
+    neo4j_url = ENV['NEO4J_URL'] || 'http://localhost:7474'
+    $LOAD_PATH.unshift File.dirname('./')
+    ActiveGraph::Base.on_establish_driver do
+      Neo4j::Driver::GraphDatabase.driver(neo4j_url)
+    end
+  end
+end
+
+namespace :neo4j do
+  task :allow_migrations do
+    ActiveGraph::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 = "ActiveGraph::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 Node 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 ActiveGraph::Base.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 'active_graph/migrations/schema'
+
+        schema_data = ActiveGraph::Migrations::Schema.fetch_schema_data
+
+        runner = ActiveGraph::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 'active_graph/migrations/schema'
+
+        args.with_defaults(remove_missing: false)
+
+        schema_data = YAML.safe_load(File.read(SCHEMA_YAML_PATH), [Symbol])
+
+        ActiveGraph::Base.subscribe_to_query(&method(:puts))
+
+        ActiveGraph::Base.transaction do
+          ActiveGraph::Migrations::Schema.synchronize_schema_data(schema_data, args[:remove_missing])
+        end
+
+        ActiveGraph::Base.transaction do
+          runner = ActiveGraph::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 = ActiveGraph::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 = ActiveGraph::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 = ActiveGraph::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 = ActiveGraph::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 = ActiveGraph::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 = ActiveGraph::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 = ActiveGraph::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} < ActiveGraph::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/active_graph/timestamps.rb

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

data/lib/active_graph/timestamps/created.rb

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

data/lib/active_graph/timestamps/updated.rb

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

data/lib/active_graph/transaction.rb

@@ -0,0 +1,22 @@
+module ActiveGraph
+  module Transaction
+    def rollback
+      super
+      @rolled_back = true
+    end
+
+    def after_commit(&block)
+      after_commit_registry << block
+    end
+
+    def apply_callbacks
+      after_commit_registry.each(&:call) unless @rolled_back
+    end
+
+    private
+
+    def after_commit_registry
+      @after_commit_registry ||= []
+    end
+  end
+end