neo4j 1.0.0.beta.18 → 1.0.0.beta.19

data/lib/neo4j.rb

@@ -5,11 +5,11 @@ require 'forwardable'
 require 'time'
 require 'date'
 
-require 'neo4j/jars/neo4j-index-1.2-1.2.M02.jar'
-require 'neo4j/jars/neo4j-kernel-1.2-1.2.M02.jar'
-require 'neo4j/jars/neo4j-lucene-index-0.2-1.2.M02.jar'
+require 'neo4j/jars/neo4j-index-1.2-1.2.M03.jar'
+require 'neo4j/jars/neo4j-kernel-1.2-1.2.M03.jar'
+require 'neo4j/jars/neo4j-lucene-index-0.2-1.2.M03.jar'
 require 'neo4j/jars/geronimo-jta_1.1_spec-1.1.1.jar'
-require 'neo4j/jars/lucene-core-3.0.1.jar'
+require 'neo4j/jars/lucene-core-3.0.2.jar'
 require 'neo4j/to_java'
 require 'neo4j/version'
 require 'neo4j/equal'
@@ -32,6 +32,7 @@ require 'neo4j/load'
 require 'neo4j/relationship'
 require 'neo4j/node'
 require 'neo4j/config'
+require 'neo4j/type_converters'
 require 'neo4j/mapping/class_methods/init_node'
 require 'neo4j/mapping/class_methods/init_rel'
 require 'neo4j/mapping/class_methods/root'

data/lib/neo4j/config.rb

@@ -2,13 +2,19 @@
 module Neo4j
 
 
-  # == Keeps configuration for neo4j.
+  # == Keeps configuration for neo4j
   #
   # The most important configuration is <tt>Neo4j::Config[:storage_path]</tt> which is used to
   # locate where the neo4j database is stored on the filesystem.
   # If this directory is empty then a new database will be created, otherwise it will use the
   # database from that directory.
   #
+  # ==== Default Configurations
+  # <tt>:storage_path</tt>::   default <tt>tmp/neo4j</tt> where the database is stored
+  # <tt>:timestamps</tt>::     default <tt>true</tt> for Rails Neo4j::Model - if timestamps should be used when saving the model
+  # <tt>:lucene</tt>::         default hash keys: <tt>:fulltext</tt>, <tt>:exact</tt> configuration how the lucene index is stored
+  # <tt>:converters</tt>::     defines which converters should be used before writing and reading to neo4j, see Neo4j::TypeConverters
+  #
   class Config
     # This code is copied from merb-core/config.rb.
     class << self
@@ -19,6 +25,7 @@ module Neo4j
       def defaults
         @defaults ||= {
           :storage_path => 'tmp/neo4j',
+          :timestamps => true,
           :lucene => {
                   :fulltext =>  {"provider" => "lucene", "type" => "fulltext" },
                   :exact =>  {"provider" => "lucene", "type" => "exact" }}
@@ -29,11 +36,11 @@ module Neo4j
       # Yields the configuration.
       #
       # ==== Block parameters
-      # c<Hash>:: The configuration parameters.
+      # c :: The configuration parameters, a hash.
       #
       # ==== Examples
       # Neo4j::Config.use do |config|
-      # config[:storage_path] = '/var/neo4j'
+      #   config[:storage_path] = '/var/neo4j'
       # end
       #
       # ==== Returns
@@ -48,8 +55,8 @@ module Neo4j
       # Set the value of a config entry.
       #
       # ==== Parameters
-      # key:: The key to set the parameter for.
-      # val:: The value of the parameter.
+      # key :: The key to set the parameter for.
+      # val :: The value of the parameter.
       #
       def []=(key, val)
         (@configuration ||= setup)[key] = val

data/lib/neo4j/index/indexer.rb

@@ -63,15 +63,16 @@ module Neo4j
       # === Set the type value to index
       # By default all values will be indexed as Strings.
       # If you want for example to do a numerical range query you must tell Neo4j.rb to index it as a numeric value.
-      # You do that with the key <tt>type</tt>
+      # You do that with the key <tt>type</tt> on the property.
       #
       # Example:
       #   class Person
       #     include Neo4j::NodeMixin
-      #     index :weight, :type => Float
+      #     property :weight, :type => Float
+      #     index :weight
       #   end
       #
-      # Supported values for <tt>:type</tt> is <tt>String</tt>, <tt>Float</tt> and <tt>Fixnum</tt>
+      # Supported values for <tt>:type</tt> is <tt>String</tt>, <tt>Float</tt>, <tt>Date</tt>, <tt>DateTime</tt> and <tt>Fixnum</tt>
       #
       # === For more information
       # * See Neo4j::Index::LuceneQuery
@@ -189,13 +190,11 @@ module Neo4j
 
         type = @decl_props && @decl_props[field.to_sym] && @decl_props[field.to_sym][:type]
         if type
-          raise "Can't index #{type} with value #{value} since it is not a #{type}" unless type === value
           value = if String != type
                     org.neo4j.index.impl.lucene.ValueContext.new(value).indexNumeric
                   else
                     org.neo4j.index.impl.lucene.ValueContext.new(value)
                   end
-
         end
 
         index_for_field(field.to_s).add(entity, field, value)

data/lib/neo4j/index/lucene_query.rb

@@ -45,64 +45,99 @@ module Neo4j
         @decl_props = decl_props
       end
 
+      # Since we include the Ruby Enumerable mixin we need this method.
       def each
         hits.each { |n| yield n.wrapper }
       end
 
+      # Close hits
+      #
+      # Closes the underlying search result. This method should be called whenever you've got what you wanted from the result and won't use it anymore.
+      # It's necessary to call it so that underlying indexes can dispose of allocated resources for this search result.
+      # You can however skip to call this method if you loop through the whole result, then close() will be called automatically.
+      # Even if you loop through the entire result and then call this method it will silently ignore any consequtive call (for convenience).
+      #
+      # This must be done according to the Neo4j Java Documentation:
       def close
         @hits.close if @hits
       end
 
+      # True if there is no search hits.
       def empty?
         hits.size == 0
       end
 
+      # returns the n'th search item
+      # Does simply loop all search items till the n'th is found.
+      #
       def [](index)
         each_with_index {|node,i| break node if index == i}
       end
 
+      # Returns the number of search hits
       def size
         hits.size
       end
 
-      def hits
+      def hits #:nodoc:
         @hits ||= perform_query
       end
 
-      def between(lower, upper)
+      # Performs a range query
+      # Notice that if you don't specify a type when declaring a property a String range query will be performed.
+      # 
+      def between(lower, upper, lower_incusive=false, upper_inclusive=false)
         raise "Expected a symbol. Syntax for range queries example: index(:weight).between(a,b)" unless Symbol === @query
         raise "Can't only do range queries on Neo4j::NodeMixin, Neo4j::Model, Neo4j::RelationshipMixin" unless @decl_props
-        type = @decl_props[@query] && @decl_props[@query][:type] 
-        raise "Missing type declaration of property #{@query}. E.g. property :#{@query}, :type => Float; index :#{@query}" unless type
-        if type != String
-          raise "find(#{@query}).between(#{lower}, #{upper}) to allowed since #{lower} is not a Float or Fixnum" if lower === Float or lower === Fixnum
-          raise "find(#{@query}).between(#{lower}, #{upper}) to allowed since #{upper} is not a Float or Fixnum" if upper === Float or upper === Fixnum
-          @query = org.apache.lucene.search.NumericRangeQuery.new_double_range(@query.to_s, lower, upper, false, false)
-        else
-          raise "find(#{@query}).between(#{lower}, #{upper}) to allowed since #{lower} is not a String" if lower === String
-          raise "find(#{@query}).between(#{lower}, #{upper}) to allowed since #{upper} is not a String" if upper === String
-          @query = org.apache.lucene.search.TermRangeQuery.new(@query.to_s, lower, upper, false, false)
-        end
+        # check that we perform a range query on the same values as we have declared with the property :key, :type => ...
+        type   = @decl_props[@query] && @decl_props[@query][:type]
+        raise "find(#{@query}).between(#{lower}, #{upper}): #{lower} not a #{type}" if type && !type === lower.class
+        raise "find(#{@query}).between(#{lower}, #{upper}): #{upper} not a #{type}" if type && !type === upper.class
+
+        # Make it possible to convert those values
+        lower  = TypeConverters.convert(lower)
+        upper  = TypeConverters.convert(upper)
+
+        @query = case lower
+                   when Fixnum
+                     org.apache.lucene.search.NumericRangeQuery.new_long_range(@query.to_s, lower, upper, lower_incusive, upper_inclusive)
+                   when Float
+                     org.apache.lucene.search.NumericRangeQuery.new_double_range(@query.to_s, lower, upper, lower_incusive, upper_inclusive)
+                   else
+                     org.apache.lucene.search.TermRangeQuery.new(@query.to_s, lower, upper, lower_incusive, upper_inclusive)
+                 end
         self
       end
 
+      # Create a compound lucene query.
+      #
+      # ==== Parameters
+      # query2 :: the query that should be AND together
+      #
+      # ==== Example
+      #
+      #  Person.find(:name=>'kalle').and(:age => 3)
+      #
       def and(query2)
         new_query = LuceneQuery.new(@index, @decl_props, query2)
         new_query.left_and_query = self
         new_query
       end
 
+
+      # Sort descending the given fields.
       def desc(*fields)
         @order = fields.inject(@order || {}) { |memo, field| memo[field] = true; memo }
         self
       end
 
+      # Sort ascending the given fields.
       def asc(*fields)
         @order = fields.inject(@order || {}) { |memo, field| memo[field] = false; memo }
         self
       end
 
-      def build_and_query(query)
+      def build_and_query(query) #:nodoc:
         left_query = @left_and_query.build_query
         and_query  = org.apache.lucene.search.BooleanQuery.new
         and_query.add(left_query, org.apache.lucene.search.BooleanClause::Occur::MUST)
@@ -110,7 +145,7 @@ module Neo4j
         and_query
       end
 
-      def build_sort_query(query)
+      def build_sort_query(query)  #:nodoc:
         java_sort_fields = @order.keys.inject([]) do |memo, field|
           decl_type = @decl_props && @decl_props[field] && @decl_props[field][:type]
           type      = case
@@ -127,7 +162,7 @@ module Neo4j
         org.neo4j.index.impl.lucene.QueryContext.new(query).sort(sort)
       end
 
-      def build_hash_query(query)
+      def build_hash_query(query)  #:nodoc:
         and_query  = org.apache.lucene.search.BooleanQuery.new
 
         query.each_pair do |key, value|
@@ -139,7 +174,7 @@ module Neo4j
         and_query
       end
       
-      def build_query
+      def build_query  #:nodoc:
         query = @query
         query = build_hash_query(query) if Hash === query
         query = build_and_query(query) if @left_and_query
@@ -147,7 +182,7 @@ module Neo4j
         query
       end
 
-      def perform_query
+      def perform_query  #:nodoc:
         @index.query(build_query)
       end
     end

data/lib/neo4j/mapping/class_methods/property.rb

@@ -49,15 +49,14 @@ module Neo4j::Mapping
         props.each do |prop|
           pname = prop.to_sym
           _decl_props[pname] ||= {}
-          _decl_props[pname][:defined] = true
 
           define_method(pname) do
-            self[pname]
+            Neo4j::TypeConverters.to_ruby(self.class, pname, self[pname])
           end
 
           name = (pname.to_s() +"=").to_sym
           define_method(name) do |value|
-            self[pname] = value
+            self[pname] = Neo4j::TypeConverters.to_java(self.class, pname, value)
           end
         end
       end

data/lib/neo4j/mapping/node_mixin.rb

@@ -46,7 +46,7 @@ module Neo4j::Mapping
     def init_on_create(*args) # :nodoc:
       self[:_classname] = self.class.to_s
       if args[0].respond_to?(:each_pair)
-        args[0].each_pair { |k, v| @_java_node.set_property(k.to_s, v) }
+        args[0].each_pair { |k, v| respond_to?("#{k}=")? self.send("#{k}=", v) : @_java_node[k] = v }
       end
     end
 

data/lib/neo4j/node.rb

@@ -96,7 +96,7 @@ module Neo4j
         db = (!props && args[0]) || args[1] || Neo4j.started_db
 
         node = db.graph.create_node
-        props.each_pair { |k, v| node.set_property(k.to_s, v) } if props
+        props.each_pair { |k, v| node[k]= v } if props
         node
       end
 

data/lib/neo4j/property.rb

@@ -69,20 +69,42 @@ module Neo4j
     # Returns the value of the given key or nil if the property does not exist.
     def [](key)
       return unless property?(key)
-      get_property(key.to_s)
+      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>Boolean</tt>).
+    # 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
 end

data/lib/neo4j/rails/model.rb

@@ -181,6 +181,7 @@ module Neo4j
                 return false unless _java_node.save_nested(node)
                 init_on_load(node)
                 init_on_create
+                self.created_at = DateTime.now if Neo4j::Config[:timestamps] && respond_to?(:created_at)
                 clear_changes
                 true
               end
@@ -189,6 +190,7 @@ module Neo4j
             _run_update_callbacks do
               if valid?(:update)
                 clear_changes
+                self.updated_at = DateTime.now if Neo4j::Config[:timestamps] && respond_to?(:updated_at)
                 true
               end
             end

data/lib/neo4j/type_converters.rb

@@ -0,0 +1,84 @@
+module Neo4j
+
+  # Responsible for converting values from and to Java Neo4j and Lucene.
+  # You can implement your own converter by implementing the method <tt>to_java</tt> and <tt>to_ruby</tt>
+  # and add it to the Neo4j::Config with the key <tt>:converters</tt>
+  #
+  # There are currently two default converters that are triggered when a Date or a DateTime is read or written.
+  #
+  module TypeConverters
+
+    # Converts Date objects to Java long types. Must be timezone UTC.
+    class DateConverter
+      class << self
+        def to_java(value)
+          return nil if value.nil?
+          Time.utc(value.year, value.month, value.day).to_i
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          Time.at(value).utc
+        end
+      end
+    end
+
+    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
+    class DateTimeConverter
+      class << self
+        # Converts the given DateTime (UTC) value to an Fixnum.
+        # Only utc times are supported !
+        def to_java(value)
+          return nil if value.nil?
+          Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec).to_i
+        end
+
+        def to_ruby(value)
+          return nil if value.nil?
+          t = Time.at(value).utc
+          DateTime.civil(t.year, t.month, t.day, t.hour, t.min, t.sec)
+        end
+      end
+    end
+
+    # Converts the given value to a Java type by using the registered converters.
+    # It just looks at the class of the given value and will convert it if there is a converter
+    # registered (in Neo4j::Config) for this value.
+    def self.convert(value)
+      type      = value.class
+      converter = Neo4j::Config[:converters][type]
+      return value unless converter
+      converter.to_java(value)
+    end
+
+    # Converts the given property (key, value) to Java by using configuration from the given class.
+    # If no Converter is defined for this value then it simply returns the given value.
+    def self.to_java(clazz, key, value)
+      type = clazz._decl_props[key] && clazz._decl_props[key][:type]
+      if type
+        converter = Neo4j::Config[:converters][type]
+        converter ? converter.to_java(value) : value
+      elsif clazz.superclass != Object
+        to_java(clazz.superclass, key, value)
+      else
+        value
+      end
+    end
+
+    # Converts the given property (key, value) to Ruby by using configuration from the given class.
+    # If no Converter is defined for this value then it simply returns the given value.
+    def self.to_ruby(clazz, key, value)
+      type = clazz._decl_props[key] && clazz._decl_props[key][:type]
+      if type
+        converter = Neo4j::Config[:converters][type]
+        converter ? converter.to_ruby(value) : value
+      elsif clazz.superclass != Object
+        to_ruby(clazz.superclass, key, value)
+      else
+        value
+      end
+    end
+
+    Neo4j::Config[:converters] = {Date => DateConverter, DateTime => DateTimeConverter}
+  end
+end

data/lib/neo4j/version.rb

@@ -1,3 +1,3 @@
 module Neo4j
-  VERSION = "1.0.0.beta.18"
+  VERSION = "1.0.0.beta.19"
 end

metadata

@@ -7,8 +7,8 @@ version: !ruby/object:Gem::Version
     - 0
     - 0
     - beta
-    - 18
-  version: 1.0.0.beta.18
+    - 19
+  version: 1.0.0.beta.19
 platform: ruby
 authors: 
   - Andreas Ronge
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-04 00:00:00 +01:00
+date: 2010-11-05 00:00:00 +01:00
 default_executable: 
 dependencies: 
   - !ruby/object:Gem::Dependency 
@@ -64,6 +64,7 @@ files:
   - lib/generators/neo4j/model/templates/model.rb
   - lib/neo4j/event_handler.rb
   - lib/neo4j/model.rb
+  - lib/neo4j/type_converters.rb
   - lib/neo4j/node_traverser.rb
   - lib/neo4j/relationship_traverser.rb
   - lib/neo4j/config.rb
@@ -88,11 +89,11 @@ files:
   - lib/neo4j/rails/properties.rb
   - lib/neo4j/rails/value.rb
   - lib/neo4j/rails/validations/uniqueness.rb
-  - lib/neo4j/jars/lucene-core-3.0.1.jar
   - lib/neo4j/jars/geronimo-jta_1.1_spec-1.1.1.jar
-  - lib/neo4j/jars/neo4j-lucene-index-0.2-1.2.M02.jar
-  - lib/neo4j/jars/neo4j-kernel-1.2-1.2.M02.jar
-  - lib/neo4j/jars/neo4j-index-1.2-1.2.M02.jar
+  - lib/neo4j/jars/lucene-core-3.0.2.jar
+  - lib/neo4j/jars/neo4j-index-1.2-1.2.M03.jar
+  - lib/neo4j/jars/neo4j-lucene-index-0.2-1.2.M03.jar
+  - lib/neo4j/jars/neo4j-kernel-1.2-1.2.M03.jar
   - lib/neo4j/mapping/decl_relationship_dsl.rb
   - lib/neo4j/mapping/node_mixin.rb
   - lib/neo4j/mapping/has_n.rb