neo4j 1.0.0.beta.1

data/lib/neo4j/property.rb

@@ -0,0 +1,72 @@
+module Neo4j
+  module Property
+
+    def props
+      ret = {"_neo_id" => neo_id}
+      iter = getPropertyKeys.iterator
+      while (iter.hasNext) do
+        key = iter.next
+        ret[key] = get_property(key)
+      end
+      ret
+    end
+
+    def neo_id
+      getId
+    end
+
+    def attributes
+      attr = props
+      attr.keys.each { |k| attr.delete k if k[0] == ?_ }
+      attr
+    end
+
+    def property?(key)
+      has_property?(key.to_s)
+    end
+
+    # Updates this node/relationship's properties by using the provided struct/hash.
+    # If the option <code>{:strict => true}</code> is given, any properties present on
+    # the node but not present in the hash will be removed from the node.
+    #
+    # === Parameters
+    # struct_or_hash<#each_pair>:: the key and value to be set, should respond to 'each_pair'
+    # options:: further options defining the context of the update, should be a Hash
+    #
+    # === Returns
+    # self
+    #
+    def update(struct_or_hash, options={})
+      strict = options[:strict]
+      keys_to_delete = props.keys - %w(_neo_id _classname) if strict
+      struct_or_hash.each_pair do |key, value|
+        next if %w(_neo_id _classname).include? key.to_s
+        # do not allow special properties to be mass assigned
+        keys_to_delete.delete(key) if strict
+        setter_meth = "#{key}=".to_sym
+        if @_wrapper && @_wrapper.respond_to?(setter_meth)
+          @_wrapper.send(setter_meth, value)
+        else
+          self[key] = value
+        end
+      end
+      keys_to_delete.each { |key| delete_property(key) } if strict
+      self
+    end
+
+    def [](key)
+      return unless property?(key)
+      get_property(key.to_s)
+    end
+
+    def []=(key, value)
+      k = key.to_s
+      if value.nil?
+        remove_property(k)
+      else
+        set_property(k, value)
+      end
+    end
+  end
+
+end

data/lib/neo4j/rails/lucene_connection_closer.rb

@@ -0,0 +1,19 @@
+module Neo4j
+  module Rails
+    class LuceneConnectionCloser
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      ensure
+        Thread.current[:neo4j_lucene_connection].each {|hits| hits.close} if Thread.current[:neo4j_lucene_connection]
+        Thread.current[:neo4j_lucene_connection] = nil
+      end
+    end
+  end
+
+end
+
+Thread.current

data/lib/neo4j/rails/model.rb

@@ -0,0 +1,210 @@
+class Neo4j::Model
+  include Neo4j::NodeMixin
+  include ActiveModel::Validations
+  include ActiveModel::Dirty
+  extend ActiveModel::Naming
+  extend ActiveModel::Callbacks
+  define_model_callbacks :create, :save, :update, :destroy
+
+  class RecordInvalidError < RuntimeError
+    attr_reader :record
+
+    def initialize(record)
+      @record = record
+      super(@record.errors.full_messages.join(", "))
+    end
+  end
+
+  # --------------------------------------
+  # Initialize
+  # --------------------------------------
+
+  def initialize(*)
+  end
+
+  def init_on_create(*args) # :nodoc:
+    _run_create_callbacks do
+      @_new_record = true
+      super
+    end
+  end
+
+  # --------------------------------------
+  # Identity
+  # --------------------------------------
+
+  def id
+    self.neo_id
+  end
+
+  def to_param
+    persisted? ?  neo_id.to_s : nil
+  end
+
+  # Returns an Enumerable of all (primary) key attributes
+  # or nil if model.persisted? is false
+  def to_key
+    persisted? ?  [:id] : nil
+  end
+
+
+  # --------------------------------------
+  # enables ActiveModel::Dirty and Validation
+  # --------------------------------------
+
+  def method_missing(method_id, *args, &block)
+    if !self.class.attribute_methods_generated?
+      self.class.define_attribute_methods(self.class.properties_info.keys)
+      # try again
+      send(method_id, *args, &block)
+    end
+  end
+
+  # redefine this methods so that ActiveModel::Dirty will work
+  def []=(key, new_value)
+    key = key.to_s
+    unless key[0] == ?_
+      old_value = self.send(:[], key)
+      attribute_will_change!(key) unless old_value == new_value
+      #changed_attributes[key] = new_value unless old_value == new_value
+    end
+    super
+  end
+
+  def attribute_will_change!(attr)
+    begin
+      value = __send__(:[], attr)
+      value = value.duplicable? ? value.clone : value
+    rescue TypeError, NoMethodError
+    end
+    changed_attributes[attr] = value
+  end
+
+
+  def read_attribute_for_validation(key)
+    self[key]
+  end
+
+  def attributes=(attrs)
+    attrs.each do |k, v|
+      if respond_to?("#{k}=")
+        send("#{k}=", v)
+      else
+        self[k] = v
+      end
+    end
+    end
+
+
+  # Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
+  # If the saving fails because of a connection or remote service error, an exception will be raised.
+  # If saving fails because the resource is invalid then false will be returned.
+  def update_attributes(attributes)
+    update(attributes) # TODO !!!
+    save
+  end
+
+  # --------------------------------------
+  # CRUD
+  # --------------------------------------
+
+  def delete
+    super
+    @_deleted = true
+  end
+
+  def save
+    if valid?
+      # if we are trying to save a value then we should create a real node
+      if persisted?
+        _run_update_callbacks do
+          @previously_changed = changes
+          @changed_attributes.clear
+        end
+      else
+        node = Neo4j::Node.new(props)
+        init_on_load(node)
+        init_on_create
+        @previously_changed = changes
+        @changed_attributes.clear
+      end
+      true
+    end
+  end
+
+  def save!
+    raise RecordInvalidError.new(self) unless save
+  end
+
+  # In neo4j all object are automatically persisted in the database when created (but the Transaction might get rollback)
+  # Only the Neo4j::Value object will never exist in the database
+  def persisted?
+    !_java_node.kind_of?(Neo4j::Value)
+  end
+
+  def to_model
+    self
+  end
+
+  def new_record?()
+    @_new_record
+  end
+
+  def del
+    @_deleted = true
+    super
+  end
+
+  def destroy
+    _run_update_callbacks { del }
+  end
+
+  def destroyed?()
+    @_deleted
+  end
+
+
+  # --------------------------------------
+  # Class Methods
+  # --------------------------------------
+
+  class << self
+    # returns a value object instead of creating a new node
+    def new(*args)
+      value = Neo4j::Value.new(*args)
+      wrapped = self.orig_new
+      wrapped.init_on_load(value)
+      wrapped
+    end
+
+
+    # Handle Model.find(params[:id])
+    def find(*args)
+      if args.length == 1 && String === args[0] && args[0].to_i != 0
+        load(*args)
+      else
+        hits = super
+        # We need to save this so that the Rack Neo4j::Rails:LuceneConnection::Closer can close it
+        Thread.current[:neo4j_lucene_connection] ||= []
+        Thread.current[:neo4j_lucene_connection] << hits
+        hits
+      end
+    end
+
+    def load(*ids)
+      result = ids.map { |id| Neo4j::Node.load(id) }
+      if ids.length == 1
+        result.first
+      else
+        result
+      end
+    end
+
+    def create!(*args)
+      model = create(*args)
+      raise RecordInvalidError.new(model) unless model.valid?
+      model
+    end
+  end
+
+end

data/lib/neo4j/rails/railtie.rb

@@ -0,0 +1,16 @@
+module Neo4j
+  class Railtie < ::Rails::Railtie
+    config.neo4j = ActiveSupport::OrderedOptions.new
+
+    initializer "neo4j.tx" do |app|
+      app.config.middleware.use Neo4j::Rails::LuceneConnectionCloser
+    end
+
+    # Starting Neo after :load_config_initializers allows apps to
+    # register migrations in config/initializers
+    initializer "neo4j.start", :after => :load_config_initializers do |app|
+      Neo4j::Config.setup.merge!(app.config.neo4j.to_hash)
+      Neo4j.start
+    end
+  end
+end

data/lib/neo4j/rails/transaction.rb

@@ -0,0 +1,29 @@
+module Neo4j
+  module Rails
+
+    # This method is typically used in an Rails ActionController as a filter method.
+    # It will guarantee that an transaction is create before your action is called,
+    # and that the transaction is finished after your action is called.
+    #
+    # Example:
+    #  class MyController < ActionController::Base
+    #      around_filter Neo4j::Rails::Transaction, :only => [:edit, :delete]
+    #      ...
+    #  end
+    class Transaction
+      def self.filter(*)
+        begin
+          tx = Neo4j::Transaction.new
+          yield
+          tx.success
+        rescue Exception
+          tx.failure unless tx.nil?
+          raise
+        ensure
+          tx.finish unless tx.nil?
+        end
+      end
+    end
+  end
+
+end

data/lib/neo4j/rails/value.rb

@@ -0,0 +1,43 @@
+module Neo4j
+
+  class Value
+    include Neo4j::Property
+    include org.neo4j.graphdb.Node
+
+    def initialize(*args)
+      # the first argument can be an hash of properties to set
+      @props = {}
+      if args[0].respond_to?(:each_pair)
+        args[0].each_pair { |k, v| set_property(k.to_s, v) }
+      end
+    end
+
+    # override Neo4j::Property#props
+    def props
+      @props
+    end
+
+    def getId
+      nil
+    end
+
+    # Pretend this object is a Java Node
+    def has_property?(key)
+      !@props[key].nil?
+    end
+
+    def set_property(key,value)
+      @props[key] = value
+    end
+
+    def get_property(key)
+      @props[key]
+    end
+
+    def remove_property(key)
+      @props.delete(key)
+    end
+
+  end
+
+end

data/lib/neo4j/relationship.rb

@@ -0,0 +1,88 @@
+module Neo4j
+
+  org.neo4j.kernel.impl.core.RelationshipProxy.class_eval do
+    include Neo4j::Property
+    include Neo4j::Equal
+
+    def del
+      delete
+    end
+
+    def end_node # :nodoc:
+      Neo4j::Node.load_wrapper(getEndNode)
+    end
+
+    def start_node # :nodoc:
+      Neo4j::Node.load_wrapper(getStartNode)
+    end
+
+    def other_node(node) # :nodoc:
+      java_node  = node.respond_to?(:_java_node)? node._java_node : node
+      other_node = getOtherNode(java_node)
+      Neo4j::Node.load_wrapper(other_node)
+    end
+  end
+
+  #
+  # A relationship between two nodes in the graph. A relationship has a start node, an end node and a type.
+  # You can attach properties to relationships with the API specified in Neo4j::JavaPropertyMixin.
+  #
+  # Relationship are created by invoking the << operator on the rels method on the node as follow:
+  #  node.outgoing(:friends) << other_node << yet_another_node
+  #
+  # or using the Neo4j::Relationship#new method (which does the same thing):
+  #  rel = Neo4j::Relationship.new(:friends, node, other_node)
+  #
+  # The fact that the relationship API gives meaning to start and end nodes implicitly means that all relationships have a direction.
+  # In the example above, rel would be directed from node to otherNode.
+  # A relationship's start node and end node and their relation to outgoing and incoming are defined so that the assertions in the following code are true:
+  #
+  #   a = Neo4j::Node.new
+  #   b = Neo4j::Node.new
+  #   rel = Neo4j::Relationship.new(:some_type, a, b)
+  #   # Now we have: (a) --- REL_TYPE ---> (b)
+  #
+  #    rel.start_node # => a
+  #    rel.end_node   # => b
+  #
+  # Furthermore, Neo4j guarantees that a relationship is never "hanging freely,"
+  # i.e. start_node, end_node and other_node are guaranteed to always return valid, non-null nodes.
+  #
+  # See also the Neo4j::RelationshipMixin if you want to wrap a relationship with your own Ruby class.
+  #
+  # === Included Mixins
+  # * Neo4j::Property
+  # * Neo4j::Equal
+  #
+  # (Those mixin are actually not included in the Neo4j::Relationship but instead directly included in the java class org.neo4j.kernel.impl.core.RelationshipProxy)
+  #
+  class Relationship
+    class << self
+      # Returns a org.neo4j.graphdb.Relationship java object (!)
+      # Will trigger a event that the relationship was created.
+      #
+      # === Parameters
+      # type :: the type of relationship
+      # from_node :: the start node of this relationship
+      # end_node  :: the end node of this relationship
+      # props :: optional properties for the created relationship
+      #
+      # === Returns
+      # org.neo4j.graphdb.Relationship java object
+      #
+      # === Examples
+      #
+      #  Neo4j::Relationship.new :friend, node1, node2, :since => '2001-01-02', :status => 'okey'
+      #
+      def new(type, from_node, to_node, props={})
+        rel = from_node.outgoing(type).new(to_node)
+        props.each_pair {|k,v| rel[k] = v}
+        rel
+      end
+    end
+
+  end
+
+end
+
+