neo4j_legacy 7.2.0.1

data/lib/neo4j/config.rb

@@ -0,0 +1,124 @@
+module Neo4j
+  # == Keeps configuration for neo4j
+  #
+  # == Configurations keys
+  class Config
+    DEFAULT_FILE = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'config', 'neo4j', 'config.yml'))
+    CLASS_NAME_PROPERTY_KEY = 'class_name_property'
+
+    class << self
+      # In keeping with the Rails convention, this class writer lets you globally configure
+      # the incluse of timestamps on your nodes and rels. It defaults to false, requiring manual
+      # timestamp inclusion.
+      # @return [Boolean] the true/false value specified.
+
+      # @return [Fixnum] The location of the default configuration file.
+      def default_file
+        @default_file ||= DEFAULT_FILE
+      end
+
+      # Sets the location of the configuration YAML file and old deletes configurations.
+      # @param [String] file_path represent the path to the file.
+      def default_file=(file_path)
+        delete_all
+        @defaults = nil
+        @default_file = File.expand_path(file_path)
+      end
+
+      # @return [Hash] the default file loaded by yaml
+      def defaults
+        require 'yaml'
+        @defaults ||= ActiveSupport::HashWithIndifferentAccess.new(YAML.load_file(default_file))
+      end
+
+      # Reads from the default_file if configuration is not set already
+      # @return [Hash] the configuration
+      def configuration
+        return @configuration if @configuration
+
+        @configuration = ActiveSupport::HashWithIndifferentAccess.new
+        @configuration.merge!(defaults)
+        @configuration
+      end
+
+      # Yields the configuration
+      #
+      # @example
+      #   Neo4j::Config.use do |config|
+      #     config[:storage_path] = '/var/neo4j'
+      #   end
+      #
+      # @return nil
+      # @yield config
+      # @yieldparam [Neo4j::Config] config - this configuration class
+      def use
+        @configuration ||= ActiveSupport::HashWithIndifferentAccess.new
+        yield @configuration
+        nil
+      end
+
+      # Sets the value of a config entry.
+      #
+      # @param [Symbol] key the key to set the parameter for
+      # @param val the value of the parameter.
+      def []=(key, val)
+        configuration[key.to_s] = val
+      end
+
+      # @param [Symbol] key The key of the config entry value we want
+      # @return the the value of a config entry
+      def [](key)
+        configuration[key.to_s]
+      end
+
+      # Remove the value of a config entry.
+      #
+      # @param [Symbol] key the key of the configuration entry to delete
+      # @return The value of the removed entry.
+      def delete(key)
+        configuration.delete(key)
+      end
+
+      # Remove all configuration. This can be useful for testing purpose.
+      #
+      # @return nil
+      def delete_all
+        @configuration = nil
+      end
+
+      # @return [Hash] The config as a hash.
+      def to_hash
+        configuration.to_hash
+      end
+
+      # @return [String] The config as a YAML
+      def to_yaml
+        configuration.to_yaml
+      end
+
+      def include_root_in_json
+        # we use ternary because a simple || will always evaluate true
+        Neo4j::Config[:include_root_in_json].nil? ? true : Neo4j::Config[:include_root_in_json]
+      end
+
+      def module_handling
+        Neo4j::Config[:module_handling] || :none
+      end
+
+      # @return [Class] The configured timestamps type (e.g. Integer) or the default DateTime.
+      def timestamp_type
+        Neo4j::Config[:timestamp_type] || DateTime
+      end
+
+      def association_model_namespace
+        Neo4j::Config[:association_model_namespace] || nil
+      end
+
+      def association_model_namespace_string
+        namespace = Neo4j::Config[:association_model_namespace]
+        return nil if namespace.nil?
+        "::#{namespace}"
+      end
+    end
+  end
+end

data/lib/neo4j/core/query.rb

@@ -0,0 +1,22 @@
+module Neo4j::Core
+  class Query
+    # Creates a Neo4j::ActiveNode::Query::QueryProxy object that builds off of a Core::Query object.
+    #
+    # @param [Class] model An ActiveNode model to be used as the start of a new QueryuProxy chain
+    # @param [Symbol] var The variable to be used to refer to the object from within the new QueryProxy
+    # @param [Boolean] optional Indicate whether the new QueryProxy will use MATCH or OPTIONAL MATCH.
+    # @return [Neo4j::ActiveNode::Query::QueryProxy] A QueryProxy object.
+    def proxy_as(model, var, optional = false)
+      # TODO: Discuss whether it's necessary to call `break` on the query or if this should be left to the user.
+      Neo4j::ActiveNode::Query::QueryProxy.new(model, nil, node: var, optional: optional, starting_query: self, chain_level: @proxy_chain_level)
+    end
+
+    # Calls proxy_as with `optional` set true. This doesn't offer anything different from calling `proxy_as` directly but it may be more readable.
+    def proxy_as_optional(model, var)
+      proxy_as(model, var, true)
+    end
+
+    # For instances where you turn a QueryProxy into a Query and then back to a QueryProxy with `#proxy_as`
+    attr_accessor :proxy_chain_level
+  end
+end

data/lib/neo4j/errors.rb

@@ -0,0 +1,28 @@
+module Neo4j
+  # Neo4j.rb Errors
+  # Generic Neo4j.rb exception class.
+  class Error < StandardError
+  end
+
+  # Raised when Neo4j.rb cannot find record by given id.
+  class RecordNotFound < Error
+    attr_reader :model, :primary_key, :id
+
+    def initialize(message = nil, model = nil, primary_key = nil, id = nil)
+      @primary_key = primary_key
+      @model = model
+      @id = id
+
+      super(message)
+    end
+  end
+
+  class InvalidPropertyOptionsError < Error; end
+
+  class InvalidParameterError < Error; end
+
+  class UnknownTypeConverterError < Error; end
+
+  class DangerousAttributeError < ScriptError; end
+  class UnknownAttributeError < NoMethodError; end
+end

data/lib/neo4j/migration.rb

@@ -0,0 +1,127 @@
+require 'benchmark'
+
+module Neo4j
+  class Migration
+    def migrate
+      fail 'not implemented'
+    end
+
+    def output(string = '')
+      puts string unless !!ENV['silenced']
+    end
+
+    def print_output(string)
+      print string unless !!ENV['silenced']
+    end
+
+    def default_path
+      Rails.root if defined? Rails
+    end
+
+    def joined_path(path)
+      File.join(path.to_s, 'db', 'neo4j-migrate')
+    end
+
+    class AddIdProperty < Neo4j::Migration
+      attr_reader :models_filename
+
+      def initialize(path = default_path)
+        @models_filename = File.join(joined_path(path), 'add_id_property.yml')
+      end
+
+      def migrate
+        models = ActiveSupport::HashWithIndifferentAccess.new(YAML.load_file(models_filename))[:models]
+        output 'This task will add an ID Property every node in the given file.'
+        output 'It may take a significant amount of time, please be patient.'
+        models.each do |model|
+          output
+          output
+          output "Adding IDs to #{model}"
+          add_ids_to model.constantize
+        end
+      end
+
+      def setup
+        FileUtils.mkdir_p('db/neo4j-migrate')
+
+        return if File.file?(models_filename)
+
+        File.open(models_filename, 'w') do |file|
+          message = <<MESSAGE
+# Provide models to which IDs should be added.
+# # It will only modify nodes that do not have IDs. There is no danger of overwriting data.
+# # models: [Student,Lesson,Teacher,Exam]\nmodels: []
+MESSAGE
+          file.write(message)
+        end
+      end
+
+      private
+
+      def add_ids_to(model)
+        max_per_batch = (ENV['MAX_PER_BATCH'] || default_max_per_batch).to_i
+
+        label = model.mapped_label_name
+        last_time_taken = nil
+
+        until (nodes_left = idless_count(label, model.primary_key)) == 0
+          print_status(last_time_taken, max_per_batch, nodes_left)
+
+          count = [nodes_left, max_per_batch].min
+          last_time_taken = Benchmark.realtime do
+            max_per_batch = id_batch_set(label, model.primary_key, count.times.map { new_id_for(model) }, count)
+          end
+        end
+      end
+
+      def idless_count(label, id_property)
+        Neo4j::Session.query.match(n: label).where("NOT EXISTS(n.#{id_property})").pluck('COUNT(n) AS ids').first
+      end
+
+      def print_status(last_time_taken, max_per_batch, nodes_left)
+        time_per_node = last_time_taken / max_per_batch if last_time_taken
+        message = if time_per_node
+                    eta_seconds = (nodes_left * time_per_node).round
+                    "#{nodes_left} nodes left.  Last batch: #{(time_per_node * 1000.0).round(1)}ms / node (ETA: #{eta_seconds / 60} minutes)\r"
+                  else
+                    "Running first batch...\r"
+                  end
+
+        print_output message
+      end
+
+
+      def id_batch_set(label, id_property, new_ids, count)
+        tx = Neo4j::Transaction.new
+
+        Neo4j::Session.query("MATCH (n:`#{label}`) WHERE NOT EXISTS(n.#{id_property})
+          with COLLECT(n) as nodes, #{new_ids} as ids
+          FOREACH(i in range(0,#{count - 1})|
+            FOREACH(node in [nodes[i]]|
+              SET node.#{id_property} = ids[i]))
+          RETURN distinct(true)
+          LIMIT #{count}")
+
+        count
+      rescue Neo4j::Server::CypherResponse::ResponseError, Faraday::TimeoutError
+        new_max_per_batch = (max_per_batch * 0.8).round
+        output "Error querying #{max_per_batch} nodes.  Trying #{new_max_per_batch}"
+        new_max_per_batch
+      ensure
+        tx.close
+      end
+
+      def default_max_per_batch
+        900
+      end
+
+      def new_id_for(model)
+        if model.id_property_info[:type][:auto]
+          SecureRandom.uuid
+        else
+          model.new.send(model.id_property_info[:type][:on])
+        end
+      end
+    end
+  end
+end

data/lib/neo4j/paginated.rb

@@ -0,0 +1,27 @@
+module Neo4j
+  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/neo4j/railtie.rb

@@ -0,0 +1,169 @@
+require 'active_support/notifications'
+require 'rails/railtie'
+# Need the action_dispatch railtie to have action_dispatch.rescue_responses initialized correctly
+require 'action_dispatch/railtie'
+
+module Neo4j
+  class Railtie < ::Rails::Railtie
+    config.neo4j = ActiveSupport::OrderedOptions.new
+
+    if defined?(ActiveSupport::Reloader)
+      ActiveSupport::Reloader.to_prepare do
+        Neo4j::ActiveNode::Labels::Reloading.reload_models!
+      end
+    elsif const_defined?(:ActionDispatch)
+      ActionDispatch::Reloader.to_prepare do
+        Neo4j::ActiveNode::Labels::Reloading.reload_models!
+      end
+    end
+
+    # Rescue responses similar to ActiveRecord.
+    # For rails 3.2 and 4.0
+    if config.action_dispatch.respond_to?(:rescue_responses)
+      config.action_dispatch.rescue_responses.merge!(
+        'Neo4j::RecordNotFound' => :not_found,
+        'Neo4j::ActiveNode::Labels::RecordNotFound' => :not_found
+      )
+    else
+      # For rails 3.0 and 3.1
+      ActionDispatch::ShowExceptions.rescue_responses['Neo4j::RecordNotFound'] = :not_found
+      ActionDispatch::ShowExceptions.rescue_responses['Neo4j::ActiveNode::Labels::RecordNotFound'] = :not_found
+    end
+
+    # 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
+
+    rake_tasks do
+      load 'neo4j/tasks/migration.rake'
+    end
+
+    class << self
+      def java_platform?
+        RUBY_PLATFORM =~ /java/
+      end
+
+      def setup_default_session(cfg)
+        setup_config_defaults!(cfg)
+
+        return if !cfg.sessions.empty?
+
+        cfg.sessions << {type: cfg.session_type, path: cfg.session_path, options: cfg.session_options.merge(default: true)}
+      end
+
+      def setup_config_defaults!(cfg)
+        cfg.session_type ||= default_session_type
+        cfg.session_path ||= default_session_path
+        cfg.session_options ||= {}
+        cfg.sessions ||= []
+      end
+
+      def config_data
+        @config_data ||= if yaml_path
+                           HashWithIndifferentAccess.new(YAML.load(ERB.new(yaml_path.read).result)[Rails.env])
+                         else
+                           {}
+                         end
+      end
+
+      def yaml_path
+        @yaml_path ||= %w(config/neo4j.yml config/neo4j.yaml).map do |path|
+          Rails.root.join(path)
+        end.detect(&:exist?)
+      end
+
+      def default_session_type
+        type = ENV['NEO4J_TYPE'] || config_data[:type] || :server_db
+        type.to_sym
+      end
+
+      def default_session_path
+        ENV['NEO4J_URL'] || ENV['NEO4J_PATH'] ||
+          config_data[:url] || config_data[:path] ||
+          'http://localhost:7474'
+      end
+
+      def start_embedded_session(session)
+        # See https://github.com/jruby/jruby/wiki/UnlimitedStrengthCrypto
+        security_class = java.lang.Class.for_name('javax.crypto.JceSecurity')
+        restricted_field = security_class.get_declared_field('isRestricted')
+        restricted_field.accessible = true
+        restricted_field.set nil, false
+        session.start
+      end
+
+      def open_neo4j_session(options, wait_for_connection = false)
+        type, name, default, path = options.values_at(:type, :name, :default, :path)
+
+        if !java_platform? && type == :embedded_db
+          fail "Tried to start embedded Neo4j db without using JRuby (got #{RUBY_PLATFORM}), please run `rvm jruby`"
+        end
+
+        session = wait_for_value(wait_for_connection) do
+          if options.key?(:name)
+            Neo4j::Session.open_named(type, name, default, path)
+          else
+            Neo4j::Session.open(type, path, options[:options])
+          end
+        end
+
+        start_embedded_session(session) if type == :embedded_db
+      end
+    end
+
+    def wait_for_value(wait)
+      session = nil
+      Timeout.timeout(60) do
+        until session
+          begin
+            if session = yield
+              puts
+              return session
+            end
+          rescue Faraday::ConnectionFailed => e
+            raise e if !wait
+
+            putc '.'
+            sleep(1)
+          end
+        end
+      end
+    end
+
+    def register_neo4j_cypher_logging
+      return if @neo4j_cypher_logging_registered
+
+      Neo4j::Core::Query.pretty_cypher = Neo4j::Config[:pretty_logged_cypher_queries]
+
+      Neo4j::Server::CypherSession.log_with do |message|
+        (Neo4j::Config[:logger] || Rails.logger).debug message
+      end
+
+      @neo4j_cypher_logging_registered = true
+    end
+
+    console do
+      Neo4j::Config[:logger] = ActiveSupport::Logger.new(STDOUT)
+
+      register_neo4j_cypher_logging
+    end
+
+    # Starting Neo after :load_config_initializers allows apps to
+    # register migrations in config/initializers
+    initializer 'neo4j.start', after: :load_config_initializers do |app|
+      cfg = app.config.neo4j
+      # Set Rails specific defaults
+      Neo4j::Railtie.setup_default_session(cfg)
+
+      cfg.sessions.each do |session_opts|
+        Neo4j::Railtie.open_neo4j_session(session_opts, cfg.wait_for_connection)
+      end
+      Neo4j::Config.configuration.merge!(cfg.to_hash)
+
+      Neo4j::Config[:logger] ||= Rails.logger
+
+      register_neo4j_cypher_logging
+    end
+  end
+end

data/lib/neo4j/schema/operation.rb

@@ -0,0 +1,91 @@
+module Neo4j
+  module Schema
+    class Operation
+      attr_reader :label_name, :property, :options
+
+      def initialize(label_name, property, options = default_options)
+        @label_name = label_name.to_sym
+        @property = property.to_sym
+        @options = options
+      end
+
+      def self.incompatible_operation_classes
+        []
+      end
+
+      def create!
+        drop_incompatible!
+        return if exist?
+        label_object.send(:"create_#{type}", property, options)
+      end
+
+      def label_object
+        @label_object ||= Neo4j::Label.create(label_name)
+      end
+
+      def incompatible_operation_classes
+        self.class.incompatible_operation_classes
+      end
+
+      def drop!
+        label_object.send(:"drop_#{type}", property, options)
+      end
+
+      def drop_incompatible!
+        incompatible_operation_classes.each do |clazz|
+          operation = clazz.new(label_name, 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
+    end
+
+    class ExactIndexOperation < Neo4j::Schema::Operation
+      def self.incompatible_operation_classes
+        [UniqueConstraintOperation]
+      end
+
+      def type
+        'index'
+      end
+
+      def exist?
+        label_object.indexes[:property_keys].include?([property])
+      end
+    end
+
+    class UniqueConstraintOperation < Neo4j::Schema::Operation
+      def self.incompatible_operation_classes
+        [ExactIndexOperation]
+      end
+
+      def type
+        'constraint'
+      end
+
+      def create!
+        return if exist?
+        super
+      end
+
+      def exist?
+        Neo4j::Label.constraint?(label_name, property)
+      end
+
+      def default_options
+        {type: :unique}
+      end
+    end
+  end
+end