neo4j 1.0.0.beta.21-java

data/lib/neo4j/node_traverser.rb

@@ -0,0 +1,157 @@
+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

@@ -0,0 +1,111 @@
+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/attributes.rb

@@ -0,0 +1,155 @@
+# This module handles the getting, setting and updating of attributes or properties
+# in a Railsy way.  This typically means not writing anything to the DB until the
+# object is saved (after validation).
+#
+# Externally, when we talk about properties (e.g. #property?, #property_names, #properties),
+# we mean all of the stored properties for this object include the 'hidden' props
+# with underscores at the beginning such as _neo_id and _classname.  When we talk
+# about attributes, we mean all the properties apart from those hidden ones.
+module Neo4j
+  module Rails
+    module Attributes
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Dirty # track changes to attributes
+        include ActiveModel::MassAssignmentSecurity # handle attribute hash assignment
+
+        class_inheritable_hash :attribute_defaults
+        self.attribute_defaults ||= {}
+
+        # save the original [] and []= to use as read/write to Neo4j
+        alias_method :read_attribute, :[]
+        alias_method :write_attribute, :[]=
+
+        # wrap the read/write in type conversion
+        alias_method_chain :read_local_property, :type_conversion
+        alias_method_chain :write_local_property, :type_conversion
+
+        # whenever we refer to [] or []=. use our local properties store
+        alias_method :[], :read_local_property
+        alias_method :[]=, :write_local_property
+      end
+
+      # The behaviour of []= changes with a Rails Model, where nothing gets written
+      # to Neo4j until the object is saved, during which time all the validations
+      # and callbacks are run to ensure correctness
+      def write_local_property(key, value)
+        key_s = key.to_s
+        if @properties[key_s] != value
+          attribute_will_change!(key_s)
+          @properties[key_s] = value
+        end
+        value
+      end
+
+      # Returns the locally stored value for the key or retrieves the value from
+      # the DB if we don't have one
+      def read_local_property(key)
+        key = key.to_s
+        if @properties.has_key?(key)
+          @properties[key]
+        else
+          @properties[key] = (persisted? && _java_node.has_property?(key)) ? read_attribute(key) : attribute_defaults[key]
+        end
+      end
+
+      # Mass-assign attributes.  Stops any protected attributes from being assigned.
+      def attributes=(attributes, guard_protected_attributes = true)
+        attributes = sanitize_for_mass_assignment(attributes) if guard_protected_attributes
+        attributes.each { |k, v| respond_to?("#{k}=") ? send("#{k}=", v) : self[k] = v }
+      end
+
+      # Tracks the current changes and clears the changed attributes hash.  Called
+      # after saving the object.
+      def clear_changes
+        @previously_changed = changes
+        @changed_attributes.clear
+      end
+
+      # Return the properties from the Neo4j Node, merged with those that haven't
+      # yet been saved
+      def props
+        ret = {}
+        property_names.each do |property_name|
+          ret[property_name] = respond_to?(property_name) ? send(property_name) : send(:[], property_name)
+        end
+        ret
+      end
+
+      # Return all the attributes for this model as a hash attr => value.  Doesn't
+      # include properties that start with <tt>_</tt>.
+      def attributes
+        ret = {}
+        attribute_names.each do |attribute_name|
+          ret[attribute_name] = respond_to?(attribute_name) ? send(attribute_name) : send(:[], attribute_name)
+        end
+        ret
+      end
+
+      # Known properties are either in the @properties, the declared
+      # attributes or the property keys for the persisted node.
+      def property_names
+        keys = @properties.keys + self.class._decl_props.keys.map { |k| k.to_s }
+        keys += _java_node.property_keys.to_a if persisted?
+        keys.flatten.uniq
+      end
+
+      # Known attributes are either in the @properties, the declared
+      # attributes or the property keys for the persisted node.  Any attributes
+      # that start with <tt>_</tt> are rejected
+      def attribute_names
+        property_names.reject { |property_name| property_name[0] == ?_ }
+      end
+
+      # Known properties are either in the @properties, the declared
+      # properties or the property keys for the persisted node
+      def property?(name)
+        @properties.keys.include?(name) ||
+            self.class._decl_props.map { |k| k.to_s }.include?(name) ||
+            begin
+              super
+            rescue org.neo4j.graphdb.NotFoundException
+              set_deleted_properties
+              nil
+            end
+      end
+
+      # Return true if method_name is the name of an appropriate attribute
+      # method
+      def attribute?(name)
+        name[0] != ?_ && property?(name)
+      end
+
+      # To get ActiveModel::Dirty to work, we need to be able to call undeclared
+      # properties as though they have get methods
+      def method_missing(method_id, *args, &block)
+        method_name = method_id.to_s
+        if property?(method_name)
+          self[method_name]
+        else
+          super
+        end
+      end
+
+      def respond_to?(method_id, include_private = false)
+        method_name = method_id.to_s
+        if property?(method_name)
+          true
+        else
+          super
+        end
+      end
+
+      # Wrap the getter in a conversion from Java to Ruby
+      def read_local_property_with_type_conversion(property)
+        Neo4j::TypeConverters.to_ruby(self.class, property, read_local_property_without_type_conversion(property))
+      end
+
+      # Wrap the setter in a conversion from Ruby to Java
+      def write_local_property_with_type_conversion(property, value)
+        write_local_property_without_type_conversion(property, Neo4j::TypeConverters.to_java(self.class, property, value))
+      end
+    end
+  end
+end

data/lib/neo4j/rails/callbacks.rb

@@ -0,0 +1,34 @@
+module Neo4j
+	module Rails
+		module Callbacks
+			extend ActiveSupport::Concern
+			
+			included do
+				[:create_or_update, :create, :update, :destroy].each do |method|
+					alias_method_chain method, :callbacks
+				end
+				
+				extend ActiveModel::Callbacks
+				
+				define_model_callbacks :create, :save, :update, :destroy
+			end
+			
+			def destroy_with_callbacks #:nodoc:
+				_run_destroy_callbacks { destroy_without_callbacks }
+			end
+			
+			private
+			def create_or_update_with_callbacks #:nodoc:
+				_run_save_callbacks { create_or_update_without_callbacks }
+			end
+	
+			def create_with_callbacks #:nodoc:
+				_run_create_callbacks { create_without_callbacks }
+			end
+	
+			def update_with_callbacks(*) #:nodoc:
+				_run_update_callbacks { update_without_callbacks }
+			end
+		end
+	end
+end