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

data/lib/neo4j/node_mixin.rb

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

data/lib/neo4j/node_relationship.rb

@@ -1,149 +0,0 @@
-module Neo4j
-
-
-  module NodeRelationship
-    include ToJava
-
-
-    # Returns the outgoing nodes for this node.
-    #
-    # ==== Returns
-    # a Neo4j::NodeTraverser which can be used to further specify which nodes should be included
-    # in traversal by using the <tt>depth</tt>, <tt>filter</tt> and <tt>prune</tt> methods.
-    #
-    # ==== Examples
-    #   # Find all my friends (nodes of depth 1 of type <tt>friends</tt>)
-    #   me.outgoing(:friends).each {|friend| puts friend[:name]}
-    #
-    #   # Find all my friends and their friends (nodes of depth 1 of type <tt>friends</tt>)
-    #   # me.outgoing(:friends).depth(2).each {|friend| puts friend[:name]}
-    #
-    #   # Find all my friends and include my self in the result
-    #   me.outgoing(:friends).depth(4).include_start_node.each {...}
-    #
-    #   # Find all my friends friends friends, etc. at any depth
-    #   me.outgoing(:friends).depth(:all).each {...}
-    #
-    #   # Find all my friends friends but do not include my friends (only depth == 2)
-    #   me.outgoing(:friends).depth(2).filter{|path| path.length == 2}
-    #
-    #   # Find all my friends but 'cut off' some parts of the traversal path
-    #   me.outgoing(:friends).depth(42).prune(|path| an_expression_using_path_returning_true_false }
-    #
-    #   # Find all my friends and work colleges
-    #   me.outgoing(:friends).outgoing(:work).each {...}
-    #
-    # Of course all the methods <tt>outgoing</tt>, <tt>incoming</tt>, <tt>both</tt>, <tt>depth</tt>, <tt>include_start_node</tt>, <tt>filter</tt>, and <tt>prune</tt> can be combined.
-    #
-    def outgoing(type)
-      if type
-        NodeTraverser.new(self).outgoing(type)
-      else
-        raise "not implemented yet"
-        NodeTraverser.new(self)
-      end
-    end
-
-
-    # Returns the incoming nodes of given type(s).
-    #
-    # See #outgoing
-    #
-    def incoming(type)
-      if type
-        NodeTraverser.new(self).incoming(type)
-      else
-        raise "not implemented yet"
-        NodeTraverser.new(self)
-      end
-    end
-
-    # Returns both incoming and outgoing nodes of given types(s)
-    #
-    # If a type is not given then it will return all types of relationships.
-    #
-    # See #outgoing
-    #
-    def both(type=nil)
-      if type
-        NodeTraverser.new(self).both(type)
-      else
-        NodeTraverser.new(self) # default is both
-      end
-    end
-
-
-    # Returns an enumeration of relationship objects.
-    # It always returns relationship of depth one.
-    #
-    # See Neo4j::Relationship
-    #
-    # ==== Examples
-    #   # Return both incoming and outgoing relationships
-    #   me.rels(:friends, :work).each {|relationship|...}
-    #
-    #   # Only return outgoing relationship of given type
-    #   me.rels(:friends).outgoing.first.end_node # => my friend node
-    #
-    def rels(*type)
-      RelationshipTraverser.new(self, type, :both)
-    end
-
-
-    # Returns the only relationship of a given type and direction that is attached to this node, or null.
-    # This is a convenience method that is used in the commonly occuring situation where a node has exactly zero or
-    # one relationships of a given type and direction to another node.
-    # Typically this invariant is maintained by the rest of the code: if at any time more than one such relationships
-    # exist, it is a fatal error that should generate an unchecked exception. This method reflects that semantics and
-    # returns either:
-    #
-    # * nil if there are zero relationships of the given type and direction,
-    # * the relationship if there's exactly one, or
-    # * raise an exception in all other cases.
-    def rel(dir, type)
-      result = _rel(dir, type)
-      result && result.wrapper
-    end
-
-    # Same as rel but does not return a ruby wrapped object but instead returns the Java object.
-    def _rel(dir, type)
-      get_single_relationship(type_to_java(type), dir_to_java(dir))
-    end
-
-    # Returns the raw java neo4j relationship object.
-    def _rels(dir=:both, *types)
-      if types.size > 1
-        java_types = types.inject([]) { |result, type| result << type_to_java(type) }.to_java(:'org.neo4j.graphdb.RelationshipType')
-        get_relationships(java_types)
-      elsif types.size == 1
-        get_relationships(type_to_java(types[0], dir_to_java(dir)))
-      elsif dir == :both
-        get_relationships(dir_to_java(dir))
-      else
-        raise "illegal argument, does not accept #{dir} #{types.join(',')} - only dir=:both for any relationship types"
-      end
-    end
-
-    # Check if the given relationship exists
-    # Returns true if there are one or more relationships from this node to other nodes
-    # with the given relationship.
-    #
-    # ==== Parameters
-    # type:: the key and value to be set, default any type
-    # dir:: optional default :both (either, :outgoing, :incoming, :both)
-    #
-    # ==== Returns
-    # true if one or more relationships exists for the given type and dir
-    # otherwise false
-    #
-    def rel? (type=nil, dir=:both)
-      if type
-        hasRelationship(type_to_java(type), dir_to_java(dir))
-      else
-        hasRelationship
-      end
-    end
-
-  end
-
-end

data/lib/neo4j/node_traverser.rb

@@ -1,157 +0,0 @@
-module Neo4j
-
-  class PruneEvaluator  # :nodoc:
-    include org.neo4j.graphdb.traversal.PruneEvaluator
-    def initialize(proc)
-      @proc = proc
-    end
-
-    def prune_after(path)
-      @proc.call(path)
-    end
-  end
-
-  class FilterPredicate # :nodoc:
-    include org.neo4j.helpers.Predicate
-    def initialize
-      @procs = []
-    end
-
-    def add(proc)
-      @procs << proc
-    end
-
-    def include_start_node
-      @include_start_node = true
-    end
-
-    def accept(path)
-      return false if @include_start_node && path.length == 0
-      # find the first filter which returns false
-      # if not found then we will accept this path
-      @procs.find {|p| !p.call(path)}.nil?
-    end
-  end
-
-
-  class NodeTraverser
-    include Enumerable
-    include ToJava
-
-    def initialize(from, type = nil, dir=nil)
-      @from  = from
-      @depth = 1
-      if type.nil? || dir.nil?
-        @td    = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first()
-      else
-        @type  = type_to_java(type)
-        @dir   = dir_to_java(dir)
-        @td    = org.neo4j.kernel.impl.traversal.TraversalDescriptionImpl.new.breadth_first().relationships(@type, @dir)
-      end
-    end
-
-
-    def to_s
-      "NodeTraverser [from: #{@from.neo_id} depth: #{@depth} type: #{@type} dir:#{@dir}"
-    end
-
-    def <<(other_node)
-      new(other_node)
-      self
-    end
-
-    def new(other_node)
-      case @dir
-        when org.neo4j.graphdb.Direction::OUTGOING
-          @from.create_relationship_to(other_node, @type)
-        when org.neo4j.graphdb.Direction::INCOMING
-          other_node._java_node.create_relationship_to(@from, @type)
-        else
-          raise "Only allowed to create outgoing or incoming relationships (not #@dir)"
-      end
-    end
-
-    def both(type)
-      @type  = type_to_java(type) if type
-      @dir   = dir_to_java(:both)
-      @td = @td.relationships(type_to_java(type), @dir)
-      self
-    end
-
-    def outgoing(type)
-      @type  = type_to_java(type) if type
-      @dir   = dir_to_java(:outgoing)
-      @td = @td.relationships(type_to_java(type), @dir)
-      self
-    end
-
-    def incoming(type)
-      @type  = type_to_java(type) if type
-      @dir   = dir_to_java(:incoming)
-      @td = @td.relationships(type_to_java(type), @dir)
-      self
-    end
-
-    def filter_method(name, &proc)
-      # add method name
-      singelton = class << self; self; end
-      singelton.send(:define_method, name) {filter &proc}
-      self
-    end
-
-    def prune(&block)
-      @td = @td.prune(PruneEvaluator.new(block))
-      self
-    end
-
-    def filter(&block)
-      # we keep a reference to filter predicate since only one filter is allowed and we might want to modify it
-      @filter_predicate ||= FilterPredicate.new
-      @filter_predicate.add(block)
-      @td = @td.filter(@filter_predicate)
-      self
-    end
-
-    # Sets depth, if :all then it will traverse any depth
-    def depth(d)
-      @depth = d
-      self
-    end
-
-    def include_start_node
-      @include_start_node = true
-      self
-    end
-
-    def size
-      [*self].size
-    end
-
-    alias_method :length, :size
-
-    def [](index)
-      each_with_index {|node,i| break node if index == i}
-    end
-
-    def empty?
-      first == nil
-    end
-
-    def each
-      iterator.each {|i| yield i.wrapper}
-    end
-
-    def iterator
-      unless @include_start_node
-        if @filter_predicate
-          @filter_predicate.include_start_node
-        else
-          @td = @td.filter(org.neo4j.kernel.Traversal.return_all_but_start_node)
-        end
-      end
-      @td = @td.prune(org.neo4j.kernel.Traversal.pruneAfterDepth( @depth ) ) unless @depth == :all
-      @td.traverse(@from).nodes
-    end
-  end
-
-end

data/lib/neo4j/property.rb

@@ -1,111 +0,0 @@
-module Neo4j
-  module Property
-
-    # Returns a hash of all properties
-    # It also include the id of the node with the key <tt>_neo_id</tt>
-    #
-    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
-
-    # Returns the unique id of this node.
-    # Ids are garbage collected over time so they are only guaranteed to be unique during a specific time span:
-    # if the node is deleted, it's likely that a new node at some point will get the old id. Note:
-    # this makes node ids brittle as public APIs.
-    def neo_id
-      getId
-    end
-
-    # Returns a hash of properties with keys not starting with <tt>_</tt>
-    # That means that the neo_id will not be included in the returned hash.
-    #
-    def attributes
-      attr = props
-      ret = {}
-      attr.each_pair { |k, v| ret[k] = wrapper.respond_to?(k) ? wrapper.send(k) : v unless k.to_s[0] == ?_ }
-      ret
-    end
-
-    # Checks if the given key exist as a property.
-    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:: the key and value to be set, should respond to <tt>each_pair</tt>
-    # 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
-
-
-    # Returns the value of the given key or nil if the property does not exist.
-    def [](key)
-      return unless property?(key)
-      val = get_property(key.to_s)
-      val.class.superclass == ArrayJavaProxy ? val.to_a : val
-    end
-
-    # Sets the property of this node.
-    # Property keys are always strings. Valid property value types are the primitives(<tt>String</tt>, <tt>Fixnum</tt>, <tt>Float</tt>, <tt>FalseClass</tt>, <tt>TrueClass</tt>) or array of those primitives.
-    #
-    # ==== Gotchas
-    # * Values in the array must be of the same type.
-    # * You can *not* delete or add one item in the array (e.g. person.phones.delete('123')) but instead you must create a new array instead.
-    #
-    def []=(key, value)
-      k = key.to_s
-      if value.nil?
-        remove_property(k)
-      elsif (Array === value)
-        case value[0]
-          when NilClass
-            set_property(k, [].to_java(:string))
-          when String
-            set_property(k, value.to_java(:string))
-          when Float
-            set_property(k, value.to_java(:double))
-          when FalseClass, TrueClass
-            set_property(k, value.to_java(:boolean))
-          when Fixnum
-            set_property(k, value.to_java(:long))
-          when Boolean
-            set_property(k, value.to_java(:boolean))
-          else
-            raise "Not allowed to store array with value #{value[0]} type #{value[0].class}"
-        end
-      else
-        set_property(k, value)
-      end
-    end
-
-  end
-end

data/lib/neo4j/rails/finders.rb

@@ -1,121 +0,0 @@
-module Neo4j
-	module Rails
-		module Finders
-			extend ActiveSupport::Concern
-			
-			included do
-				rule :_all
-			end
-			
-			module ClassMethods
-				# overwrite the index method to add find_by_xxx class methods
-				def index(*args)
-					field = args.first
-					module_eval <<-RUBY, __FILE__, __LINE__
-						def self.all_by_#{field}(value)
-							find_with_indexer("#{field}: \\"\#{value}\\"")
-						end
-						
-						def self.find_by_#{field}(value)
-							all_by_#{field}(value).first
-						end
-					RUBY
-					
-					super
-				end
-				
-				# load an id or array of ids from the database
-				def load(*ids)
-          result = ids.map { |id| Neo4j::Node.load(id) }
-          if ids.length == 1
-            result.first
-          else
-            result
-          end
-        end
-        
-				# Behave like the ActiveRecord query interface
-				
-				# Handle Model.find(params[:id])
-				
-				# Model.find
-				# Model.find(:first)
-				
-				# Model.find("1")
-				# Model.find(1)
-				
-				# Model.find("name: test")
-				# Model.find(:name => "test")
-				
-				# Model.find(:first, "name: test")
-				# Model.find(:first, { :name => "test" })
-				
-				# Model.find(:first, :conditions => "name: test")
-				# Model.find(:first, :conditions => { :name => "test" })
-				
-				# Model.find(:all, "name: test")
-				# Model.find(:all, { :name => "test" })
-				
-				# Model.find(:all, :conditions => "name: test")
-				# Model.find(:all, :conditions => { :name => "test" })
-        def find(*args)
-        	case args.first
-        	when :all, :first
-        		kind = args.shift
-        		send(kind, *args)
-        	else
-        		find_with_ids(*args) or first(*args)
-        	end
-        end
-        
-				def all(*args)
-					if args.empty?
-						# use the _all rule to recover all the stored instances of this node
-						_all
-					else
-						args = normalize_args(*args)
-						# handle the special case of a search by id
-						if args.first.is_a?(Hash) && args.first[:id]
-							[find_with_ids(args.first[:id])].flatten
-						else
-							find_with_indexer(*args)
-						end
-					end
-				end
-				
-				def first(*args)
-					all(*args).first
-				end
-				
-				protected
-				def find_with_ids(*args)
-					if ((args.first.is_a?(String) || args.first.is_a?(Integer)) && args.first.to_i > 0)
-						load(*args.map { |p| p.to_i })
-					end
-				end
-				
-				def find_with_indexer(*args)
-					hits = _indexer.find(*args)
-					# 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
-				
-				def normalize_args(*args)
-					options = args.extract_options!
-					
-					if options.present?
-						if options[:conditions]
-							args << options[:conditions]
-						else
-							args << options
-						end
-					end
-					args
-				end
-      end
-		end
-	end
-end
-