neo4j 1.0.0.beta.20 → 3.0.0.alpha.2

data/lib/neo4j/rails/tx_methods.rb

@@ -1,15 +0,0 @@
-module Neo4j
-  module Rails
-    module TxMethods
-      def tx_methods(*methods)
-        methods.each do |method|
-          tx_method = "#{method}_in_tx"
-          send(:alias_method, tx_method, method)
-          send(:define_method, method) do |*args|
-            Neo4j::Rails::Transaction.running? ? send(tx_method, *args) : Neo4j::Rails::Transaction.run { send(tx_method, *args) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neo4j/rails/validations/non_nil.rb

@@ -1,11 +0,0 @@
-module Neo4j
-	module Rails
-		module Validations
-			class NonNilValidator < ActiveModel::EachValidator
-				def validate_each(record, attribute, value)
-					record.errors.add(attribute, :nil, options.merge(:value => value)) if value.nil?
-				end
-			end
-		end
-  end
-end

data/lib/neo4j/rails/validations/uniqueness.rb

@@ -1,31 +0,0 @@
-module Neo4j
-	module Rails
-		module Validations
-			class UniquenessValidator < ActiveModel::EachValidator
-				def initialize(options)
-					super(options.reverse_merge(:case_sensitive => true))
-				end
-	
-				def setup(klass)
-					@attributes.each do |attribute|
-						if klass.index_type_for(attribute) != :exact
-							raise "Can't validate property #{attribute} on class #{klass} since there is no :exact lucene index on that property or the index declaration #{attribute} comes after the validation declaration in #{klass} (try to move it before the validation rules)"
-						end
-					end
-				end
-	
-				def validate_each(record, attribute, value)
-					if record.class.find("#{attribute}: \"#{value}\"")
-						record.errors.add(attribute, :taken, options.except(:case_sensitive, :scope).merge(:value => value))
-					end
-				end
-			end
-	
-			module ClassMethods
-				def validates_uniqueness_of(*attr_names)
-					validates_with UniquenessValidator, _merge_attributes(attr_names)
-				end
-			end
-		end
-	end
-end

data/lib/neo4j/rails/value.rb

@@ -1,124 +0,0 @@
-module Neo4j::Rails
-
-  class Value
-    include ValueProperties
-    include org.neo4j.graphdb.Node
-
-    def initialize(wrapper)
-      @wrapper = wrapper
-      @outgoing_rels = {}  # a hash of all relationship with key type
-    end
-
-    def getId
-      nil
-    end
-
-    def create_relationship_to(other_java_node, java_type)
-      outgoing(java_type.name).new(other_java_node)
-    end
-
-    def rel(dir, type)
-      # TODO incoming not implemented, needed ?
-      @outgoing_rels[type.to_s] && @outgoing_rels[type.to_s].rels.first
-    end
-
-    def getRelationships(*args)
-      type = args[0].name
-      outgoing = @outgoing_rels[type]
-      return [] unless outgoing
-      outgoing.rels
-    end
-
-    def wrapper
-      @wrapper
-    end
-
-    def outgoing(type)
-      @outgoing_rels[type.to_s] ||= OutgoingRels.new(self)
-    end
-
-    def save_nested(root_node)
-      valid = true
-      @outgoing_rels.each_pair do |type, rel|
-        rel.each_with_index do |new_node, i|
-        	wrapper = new_node.respond_to?(:wrapper) ? new_node.wrapper : new_node
-          if wrapper.save
-            new_rel = Neo4j::Relationship.new(type.to_sym, root_node, wrapper)
-            rel.rels[i].props.each_pair { |property, value| new_rel[property] = value }
-          else
-            valid = false
-          end
-        end
-      end
-      valid
-    end
-    
-    # this node doesn't exist in the DB yet
-    def exist?
-      false
-    end
-
-    class Relationship
-    	include org.neo4j.graphdb.Relationship
-      include ValueProperties
-      
-      attr_reader :end_node, :start_node
-
-      def initialize(from, to)
-        @end_node = to
-        @start_node = from
-      end
-
-      def wrapper
-        self
-      end
-
-      def other_node(other)
-        other == @end_node ? @start_node : @end_node
-      end
-
-      alias_method :getOtherNode, :other_node
-    end
-
-
-    class OutgoingRels
-      include Enumerable
-      attr_reader :rels
-
-      def initialize(start_node)
-        @rels = []
-        @start_node = start_node
-      end
-
-      def <<(other)
-        new(other)
-        self
-      end
-
-      def new(other)
-        new_rel = Relationship.new(@start_node, other)
-        @rels << new_rel
-        new_rel
-      end
-
-      def each
-        @rels.each {|n| yield n.end_node}
-      end
-
-      def clear
-        @rels.clear
-      end
-
-      def empty?
-        @rels.empty?
-      end
-
-      def is_a?(type)
-        # ActionView requires this for nested attributes to work
-        return true if Array == type
-        super
-      end
-    end
-
-  end
-end

data/lib/neo4j/rails/value_properties.rb

@@ -1,29 +0,0 @@
-# provide some properties before we have a real node or relationship
-module Neo4j
-	module Rails
-		module ValueProperties
-			include Neo4j::Property
-			
-			# override Neo4j::Property#props
-			def props
-				@props ||= {}
-			end
-			
-			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
-end

data/lib/neo4j/relationship.rb

@@ -1,169 +0,0 @@
-module Neo4j
-
-  org.neo4j.kernel.impl.core.RelationshipProxy.class_eval do
-    include Neo4j::Property
-    include Neo4j::Equal
-
-    alias_method :_end_node, :getEndNode
-    alias_method :_start_node, :getStartNode
-    alias_method :_other_node, :getOtherNode
-
-
-    def del
-      delete
-    end
-
-    def end_node # :nodoc:
-      getEndNode.wrapper
-    end
-
-    def start_node # :nodoc:
-      getStartNode.wrapper
-    end
-
-    def other_node(node) # :nodoc:
-      getOtherNode(node._java_node).wrapper
-    end
-
-
-    # same as _java_rel
-    # Used so that we have same method for both relationship and nodes
-    def wrapped_entity
-      self
-    end
-
-    def _java_rel
-      self
-    end
-
-
-    # Returns true if the relationship exists
-    def exist?
-      Neo4j::Relationship.exist?(self)
-    end
-
-    # Loads the Ruby wrapper for this node
-    # If there is no _classname property for this node then it will simply return itself.
-    # Same as Neo4j::Node.load_wrapper(node)
-    def wrapper
-      self.class.wrapper(self)
-    end
-
-
-    # Returns the relationship name
-    #
-    # ====Example
-    #   a = Neo4j::Node.new
-    #   a.outgoing(:friends) << Neo4j::Node.new
-    #   a.rels.first.rel_type # => 'friends'
-    #
-    def rel_type
-      getType().name()
-    end
-
-    def class
-      Neo4j::Relationship
-    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
-    extend Neo4j::Index::ClassMethods
-
-    self.rel_indexer self
-
-    class << self
-      include Neo4j::Load
-      include Neo4j::ToJava
-
-
-      # 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=nil)
-        java_type = type_to_java(type)
-        rel = from_node._java_node.create_relationship_to(to_node._java_node, java_type)
-        props.each_pair {|k,v| rel[k] = v} if props
-        rel
-      end
-
-      # create is the same as new
-      alias_method :create, :new
-
-      # Loads a relationship or wrapped relationship given a native java relationship or an id.
-      # If there is a Ruby wrapper for the node then it will create a Ruby object that will
-      # wrap the java node (see Neo4j::RelationshipMixin).
-      #
-      # If the relationship does not exist it will return nil
-      #
-      def load(rel_id, db = Neo4j.started_db)
-        rel = _load(rel_id, db)
-        return nil if rel.nil?
-        rel.wrapper
-      end
-
-      # Same as load but does not return the node as a wrapped Ruby object.
-      #
-      def _load(rel_id, db)
-        rel = db.graph.get_relationship_by_id(rel_id.to_i)
-        rel.hasProperty('_classname')  # since we want a IllegalStateException which is otherwise not triggered
-        rel
-      rescue java.lang.IllegalStateException
-        nil # the node has been deleted
-      rescue org.neo4j.graphdb.NotFoundException
-        nil
-      end
-
-    end
-
-  end
-
-end
-
-

data/lib/neo4j/relationship_mixin.rb

@@ -1,4 +0,0 @@
-module Neo4j
-  # make an alias so that we don't have to write the long name Neo4j::Mapping::Relationship
-  RelationshipMixin = Neo4j::Mapping::RelationshipMixin
-end

data/lib/neo4j/relationship_traverser.rb

@@ -1,92 +0,0 @@
-module Neo4j
-
-  class RelationshipTraverser
-    include Enumerable
-    include ToJava
-
-    def initialize(node, types, direction)
-      @node      = node
-      if types.size > 1
-        @types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
-      elsif types.size == 1
-        @type = type_to_java(types[0])
-      end
-      @direction = direction
-    end
-
-    def to_s
-      if @type
-        "#{self.class} [type: #{@type} dir:#{@direction}]"
-      elsif @types
-        "#{self.class} [types: #{@types.join(',')} dir:#{@direction}]"
-      else
-        "#{self.class} [types: ANY dir:#{@direction}]"
-      end
-    end
-
-    def each
-      iter = iterator
-      while (iter.hasNext())
-        rel = iter.next
-        yield rel.wrapper if match_to_other?(rel)
-      end
-    end
-
-    def empty?
-      first == nil
-    end
-    
-    def iterator
-      if @types
-        @node.get_relationships(@types).iterator
-      elsif @type
-        @node.get_relationships(@type, dir_to_java(@direction))
-      else
-        @node.get_relationships(dir_to_java(@direction))
-      end
-    end
-
-    def match_to_other?(rel)
-      if @to_other.nil?
-        true
-      elsif @direction == :outgoing
-        rel._end_node == @to_other
-      elsif @direction == :incoming
-        rel._start_node == @to_other
-      else
-        rel._start_node == @to_other || rel._end_node == @to_other
-      end
-    end
-
-    def to_other(to_other)
-      @to_other = to_other
-      self
-    end
-
-    def del
-      each { |rel| rel.del }
-    end
-
-    def size
-      [*self].size
-    end
-
-    def both
-      @direction = :both
-      self
-    end
-
-    def incoming
-      raise "Not allowed calling incoming when finding several relationships types" if @types
-      @direction = :incoming
-      self
-    end
-
-    def outgoing
-      raise "Not allowed calling outgoing when finding several relationships types" if @types
-      @direction = :outgoing
-      self
-    end
-
-  end
-end