neo4j 2.0.0.alpha.5-java → 2.0.0.alpha.6-java

data/lib/neo4j/paginated.rb

@@ -1,23 +0,0 @@
-module Neo4j
-
-  # The class provides the pagination based on the given source.
-  # The source must be an Enumerable implementing methods drop, first and count (or size).
-  # This can be used to paginage any Enumerable collection and
-  # provides the integration point for other gems, like will_paginate and kaminari.
-  class Paginated
-    include Enumerable
-    attr_reader :items, :total, :current_page
-
-    def initialize(items, total, current_page)
-      @items, @total, @current_page = items, total, current_page
-    end
-
-    def self.create_from(source, page, per_page)
-      partial = source.drop((page-1) * per_page).first(per_page)
-      Paginated.new(partial, source.count, page)
-    end
-
-    delegate :each, :to => :items
-    delegate :size, :[], :to => :items
-  end
-end

data/lib/neo4j/property/class_methods.rb

@@ -1,79 +0,0 @@
-module Neo4j
-  module Property
-
-    module ClassMethods
-
-      # Generates accessor method and sets configuration for Neo4j node properties.
-      # The generated accessor is a simple wrapper around the #[] and
-      # #[]= operators.
-      #
-      # ==== Types
-      # If a property is set to nil the property will be removed.
-      # A property can be of any primitive type (Boolean, String, Fixnum, Float) and does not
-      # even have to be the same. Arrays of primitive types is also supported. Array values must
-      # be of the same type and are mutable, e.g. you have to create a new array if you want to change one value.
-      #
-      # Example:
-      #   class Foo
-      #     include Neo4j::NodeMixin
-      #     property :age
-      #   end
-      #
-      # Example:
-      #   foo = Foo.new
-      #   foo.age = "hej" # first set it to string
-      #   foo.age = 42  # change it to a Fixnum
-      #
-      # However, you can specify an type for the index, see Neo4j::Index::Indexer#index
-      #
-      # ==== Conversions
-      #
-      # It is possible to do conversions between types in order to support none primitive types
-      # Example:
-      #
-      #   class Foo
-      #     include Neo4j::NodeMixin
-      #     property :since, :type => DateTime  # will be converted into a fixnum
-      #   end
-      #
-      # You can write your own converter by writing a class that respond to :convert?, :to_ruby and
-      # :to_java in the Neo4j::TypeConverters module.
-      #
-      def property(*props)
-        options = props.last.kind_of?(Hash) ? props.pop : {}
-
-        props.uniq.each do |prop|
-          pname = prop.to_sym
-          _decl_props[pname] ||= {}
-          options.each do |key, value|
-            _decl_props[pname][key] = value
-          end
-
-          define_method(pname) do
-            Neo4j::TypeConverters.to_ruby(self.class, pname, self[pname])
-          end
-
-          name = (pname.to_s() +"=").to_sym
-          define_method(name) do |value|
-            self[pname] = Neo4j::TypeConverters.to_java(self.class, pname, value)
-          end
-        end
-      end
-
-
-      # Returns true if the given property name has been defined with the class
-      # method property or properties.
-      #
-      # Notice that the node may have properties that has not been declared.
-      # It is always possible to set an undeclared property on a node.
-      #
-      # ==== Returns
-      # true or false
-      #
-      def property?(prop_name)
-        return false if _decl_props[prop_name.to_sym].nil?
-        !_decl_props[prop_name.to_sym].nil?
-      end
-    end
-  end
-end

data/lib/neo4j/property/property.rb

@@ -1,111 +0,0 @@
-require 'neo4j/property/class_methods'
-
-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| remove_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))
-          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/mapping/property.rb

@@ -1,183 +0,0 @@
-module Neo4j
-  module Rails
-    module Mapping
-      module Property
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-
-          # Create two new methods: rel_name and rel_name_rels
-          # The first one returns an Neo4j::Rails::Relationships::NodesDSL
-          # the second generate method (with the _rels postfix) returns a
-          # Neo4j::Rails::Relationships::RelsDSL
-          #
-          # See also Neo4j::NodeMixin#has_n which only work with persisted relationships.
-          #
-          def has_n(*args)
-            options = args.extract_options!
-            define_has_n_methods_for(args.first, options)
-          end
-
-          # See #has_n
-          def has_one(*args)
-            options = args.extract_options!
-            define_has_one_methods_for(args.first, options)
-          end
-
-          # Returns all defined properties
-          def columns
-            self._decl_props.keys
-          end
-
-          def define_has_one_methods_for(rel_type, options) #:nodoc:
-            unless method_defined?(rel_type)
-              class_eval <<-RUBY, __FILE__, __LINE__
-                def #{rel_type}
-                    dsl = _decl_rels_for(:'#{rel_type}')
-                    storage = _create_or_get_storage_for_decl_rels(dsl)
-                    storage.single_node(dsl.dir)
-                end
-              RUBY
-            end
-
-            unless method_defined?("#{rel_type}_rel")
-              class_eval <<-RUBY, __FILE__, __LINE__
-                def #{rel_type}_rel
-                    dsl = _decl_rels_for(:'#{rel_type}')
-                    storage = _create_or_get_storage_for_decl_rels(dsl)
-                    storage.single_relationship(dsl.dir)
-                end
-              RUBY
-            end
-
-            unless method_defined?("#{rel_type}=".to_sym)
-              class_eval <<-RUBY, __FILE__, __LINE__
-                def #{rel_type}=(other)
-                    dsl = _decl_rels_for(:'#{rel_type}')
-                    storage = _create_or_get_storage_for_decl_rels(dsl)
-                    storage.destroy_single_relationship(dsl.dir)
-                    storage.create_relationship_to(other, dsl.dir)
-                end
-              RUBY
-            end
-            _decl_rels[rel_type.to_sym] = Neo4j::HasN::DeclRelationshipDsl.new(rel_type, true, self)
-          end
-
-          def define_has_n_methods_for(rel_type, options) #:nodoc:
-            unless method_defined?(rel_type)
-              class_eval <<-RUBY, __FILE__, __LINE__
-                def #{rel_type}
-                    dsl = _decl_rels_for(:'#{rel_type}')
-                    storage = _create_or_get_storage_for_decl_rels(dsl)
-                    NodesDSL.new(storage, dsl.dir)
-                end
-              RUBY
-            end
-
-            unless method_defined?("#{rel_type}=".to_sym)
-
-              # TODO: This is a temporary fix for allowing running neo4j with Formtastic, issue 109
-              # A better solution might be to implement accept_ids for has_n relationship and
-              # make sure (somehow) that Formtastic uses the _ids methods.
-
-              class_eval <<-RUBY, __FILE__, __LINE__
-                def #{rel_type}=(nodes)
-                    if nodes.is_a?(Array) && nodes.first.is_a?(String)
-                      if nodes.first.blank?
-                        self.#{rel_type}_rels.destroy_all
-                        nodes.shift
-                      end
-                    else
-                      self.#{rel_type}_rels.destroy_all
-                    end
-                    association = self.#{rel_type}
-                    nodes.each { |node| association << node }
-                end
-              RUBY
-            end
-
-            unless method_defined?("#{rel_type}_rels".to_sym)
-              class_eval <<-RUBY, __FILE__, __LINE__
-                def #{rel_type}_rels
-                    dsl = _decl_rels_for(:'#{rel_type}')
-                    storage = _create_or_get_storage_for_decl_rels(dsl)
-                  RelsDSL.new(storage, dsl.dir)
-                end
-              RUBY
-            end
-
-            instance_eval <<-RUBY, __FILE__, __LINE__
-              def #{rel_type}
-                _decl_rels[:'#{rel_type}'].rel_type.to_s
-              end
-            RUBY
-
-            _decl_rels[rel_type.to_sym] = Neo4j::HasN::DeclRelationshipDsl.new(rel_type, false, self)
-          end
-
-          # Handles options for the property
-          #
-          # Set the property type         :type => Time
-          # Set a default                  :default => "default"
-          # Property must be there        :null => false
-          # Property has a length limit    :limit => 128
-          def property(*args)
-            options = args.extract_options!
-            args.each do |property_sym|
-              property_setup(property_sym, options)
-            end
-          end
-
-          protected
-          def property_setup(property, options)
-            _decl_props[property] = options
-            handle_property_options_for(property, options)
-            define_property_methods_for(property, options)
-            define_property_before_type_cast_methods_for(property, options)
-          end
-
-          def handle_property_options_for(property, options)
-            attribute_defaults[property.to_s] = options[:default] if options.has_key?(:default)
-
-            if options.has_key?(:null) && options[:null] === false
-              validates(property, :non_nil => true, :on => :create)
-              validates(property, :non_nil => true, :on => :update)
-            end
-            validates(property, :length => { :maximum => options[:limit] }) if options[:limit]
-          end
-
-          def define_property_methods_for(property, options)
-            unless method_defined?(property)
-              class_eval <<-RUBY, __FILE__, __LINE__
-                def #{property}
-                  send(:[], "#{property}")
-                end
-              RUBY
-            end
-
-            unless method_defined?("#{property}=".to_sym)
-              class_eval <<-RUBY, __FILE__, __LINE__
-                def #{property}=(value)
-                  send(:[]=, "#{property}", value)
-                end
-              RUBY
-            end
-          end
-
-          def define_property_before_type_cast_methods_for(property, options)
-            property_before_type_cast = "#{property}_before_type_cast"
-            class_eval <<-RUBY, __FILE__, __LINE__
-              def #{property_before_type_cast}=(value)
-                @properties_before_type_cast[:#{property}]=value
-              end
-
-              def #{property_before_type_cast}
-                @properties_before_type_cast.has_key?(:#{property}) ? @properties_before_type_cast[:#{property}] : self.#{property}
-              end
-            RUBY
-          end
-        end
-      end
-    end
-  end
-end

data/lib/neo4j/rails/rel_persistence.rb

@@ -1,237 +0,0 @@
-module Neo4j
-	module Rails
-		module RelPersistence
-			extend ActiveSupport::Concern
-
-      included do
-        extend TxMethods
-        tx_methods :destroy, :create, :update, :delete
-      end
-
-
-			# Persist the object to the database.  Validations and Callbacks are included
-			# by default but validation can be disabled by passing :validate => false
-			# to #save.
-      def save(*)
-      	create_or_update
-      end
-
-      # Persist the object to the database.  Validations and Callbacks are included
-			# by default but validation can be disabled by passing :validate => false
-			# to #save!.
-			#
-			# Raises a RecordInvalidError if there is a problem during save.
-      def save!(*args)
-				unless save(*args)
-					raise RecordInvalidError.new(self)
-				end
-			end
-
-			# Updates a single attribute and saves the record.
-			# This is especially useful for boolean flags on existing records. Also note that
-			#
-			# * Validation is skipped.
-			# * Callbacks are invoked.
-			# * Updates all the attributes that are dirty in this object.
-			#
-			def update_attribute(name, value)
-				respond_to?("#{name}=") ? send("#{name}=", value) : self[name] = value
-				save(:validate => false)
-			end
-
-			# Removes the node from Neo4j and freezes the object.
-			def destroy
-				delete
-				freeze
-			end
-
-			# Same as #destroy but doesn't run destroy callbacks and doesn't freeze
-			# the object
-			def delete
-				del unless new_record?
-				set_deleted_properties
-			end
-
-			# Returns true if the object was destroyed.
-			def destroyed?()
-        @_deleted || Neo4j::Relationship._load(id).nil?
-      end
-
-			# Updates this resource with all the attributes from the passed-in Hash and requests that the record be saved.
-      # If saving fails because the resource is invalid then false will be returned.
-      def update_attributes(attributes)
-        self.attributes = attributes
-        save
-      end
-
-      # Same as #update_attributes, but raises an exception if saving fails.
-      def update_attributes!(attributes)
-        self.attributes = attributes
-        save!
-      end
-
-      # Reload the object from the DB.
-      def reload(options = nil)
-        clear_changes
-        reset_attributes
-        unless reload_from_database
-          set_deleted_properties
-          freeze
-        end
-        self
-      end
-
-      # Returns if the record is persisted, i.e. it’s not a new record and it was not destroyed
-      def persisted?
-        !new_record? && !destroyed?
-      end
-
-      # Returns true if the record hasn't been saved to Neo4j yet.
-      def new_record?
-        _java_rel.nil?
-      end
-
-      alias :new? :new_record?
-
-      # Freeze the properties hash.
-			def freeze
-				@properties.freeze; self
-			end
-
-      # Returns +true+ if the properties hash has been frozen.
-      def frozen?
-        reload
-        @properties.frozen?
-      end
-
-      module ClassMethods
-        # Initialize a model and set a bunch of attributes at the same time.  Returns
-        # the object whether saved successfully or not.
-        def create(*args)
-          new(*args).tap do |o|
-            yield o if block_given?
-            o.save
-          end
-        end
-
-        # Same as #create, but raises an error if there is a problem during save.
-        # Returns the object whether saved successfully or not.
-        def create!(*args)
-          new(*args).tap do |o|
-            yield o if block_given?
-            o.save!
-          end
-        end
-
-        # Destroy each node in turn.  Runs the destroy callbacks for each node.
-        def destroy_all
-          all.each do |n|
-            n.destroy
-          end
-        end
-      end
-
-      protected
-      def create_or_update
-        result = persisted? ? update : create
-        unless result != false
-          Neo4j::Rails::Transaction.fail if Neo4j::Rails::Transaction.running?
-          false
-        else
-          true
-        end
-      end
-
-      def update
-        write_changed_attributes
-        clear_changes
-        true
-      end
-
-      def create()
-        begin
-          # prevent calling create twice
-          @start_node.add_unpersisted_outgoing_rel(type, self)
-          @end_node.add_unpersisted_incoming_rel(type, self)
-
-          return unless _persist_start_node && _persist_end_node
-
-          @_java_rel = Neo4j::Relationship.new(type, start_node, end_node)
-          Neo4j::IdentityMap.add(@_java_rel, self)
-          init_on_create
-          clear_changes
-
-          @start_node.rm_unpersisted_outgoing_rel(type, self)
-          @end_node.rm_unpersisted_incoming_rel(type, self)
-
-        end unless @end_node.nil? or @start_node.nil?
-        true
-      end
-
-      def _load(id)
-        Neo4j::Relationship.load(id)
-      end
-
-      def _persist_start_node
-        (!@start_node.persisted? || @start_node.relationships_changed?) ? @start_node.save : true
-      end
-
-      def _persist_end_node
-        (!@end_node.persisted? || @end_node.relationships_changed?) ? @end_node.save : true
-      end
-
-
-      def init_on_create(*)
-        #self["_classname"] = self.class.to_s
-        write_default_attributes
-        write_changed_attributes
-        @_java_rel[:_classname] = self.class.to_s
-      end
-
-      def reset_attributes
-        @properties = {}
-      end
-
-      def reload_from_database
-        Neo4j::IdentityMap.remove_rel_by_id(id) if persisted?
-        Neo4j::IdentityMap.remove_node_by_id(@end_node.id) if @end_node && @end_node.persisted?
-        Neo4j::IdentityMap.remove_node_by_id(@start_node.id) if @start_node && @start_node.persisted?
-
-        if reloaded = self.class.load(id)
-          send(:attributes=, reloaded.attributes, false)
-        end
-        reloaded
-      end
-
-      def set_deleted_properties
-        @_deleted   = true
-        @_persisted = false
-      end
-
-      # Ensure any defaults are stored in the DB
-      def write_default_attributes
-        attribute_defaults.each do |attribute, value|
-          write_attribute(attribute, Neo4j::TypeConverters.convert(value, attribute, self.class)) unless changed_attributes.has_key?(attribute) || _java_rel.has_property?(attribute)
-        end
-      end
-
-      # Write attributes to the Neo4j DB only if they're altered
-      def write_changed_attributes
-        @properties.each do |attribute, value|
-          write_attribute(attribute, value) if changed_attributes.has_key?(attribute)
-        end
-      end
-
-      class RecordInvalidError < RuntimeError
-        attr_reader :record
-
-        def initialize(record)
-          @record = record
-          super(@record.errors.full_messages.join(", "))
-        end
-      end
-      
-    end
-
-  end
-end