neo4j-core 0.0.3-java → 0.0.4-java

data/README.rdoc

@@ -1,11 +1,11 @@
 == Neo4j-core {<img src="https://secure.travis-ci.org/andreasronge/neo4j-core.png" />}[http://travis-ci.org/andreasronge/neo4j-core]
 
 This gem only contains the JRuby mapping of the Neo4j graph database.
-The neo4j.rb gem will be split up into two gems, neo4j-core and neo4j.
+The neo4j.rb gem will be split up into three gems, neo4j-core, {neo4j-wrapper}[http://github.com/andreasronge/neo4j-wrapper] and {neo4j}[http://github.com/andreasronge/neo4j].
 This gem will be included by neo4j 2.0.0 gem.
 
 This gem contains two modules: Neo4j and Neo4j::Core
-The Neo4j module is public and the Neo4j::Core(::*) are private modules.
+The Neo4j module is public and the Neo4j::Core(::*) are internal modules.
 
 == Documentation
 
@@ -23,7 +23,7 @@ The Neo4j module is public and the Neo4j::Core(::*) are private modules.
 
 == Custom Index
 
-You can create your own indexer
+You can create your own indexer.
 
   class MyIndex
     extend Neo4j::Core::Index::ClassMethods

data/lib/neo4j-core.rb

@@ -50,8 +50,6 @@ require 'neo4j-core/node/class_methods'
 
 require 'neo4j/transaction'
 
-require 'neo4j/type_converters/type_converters'
-
 require 'neo4j-core/traversal/evaluator'
 require 'neo4j-core/traversal/filter_predicate'
 require 'neo4j-core/traversal/prune_evaluator'

data/lib/neo4j-core/index/class_methods.rb

@@ -41,7 +41,7 @@ module Neo4j
         # @return [Neo4j::Core::Index::Indexer] The indexer that should be used to index the given class
         # @see Neo4j::Core::Index::IndexConfig for possible configuration values in the +config_dsl+ block
         # @yield evaluated in the a Neo4j::Core::Index::IndexConfig object to configure it.
-        def node_indexer(config = IndexConfig.new(:node), &config_dsl)
+        def node_indexer(config = _config || IndexConfig.new(:node), &config_dsl)
           config.instance_eval(&config_dsl)
           indexer(config)
         end
@@ -51,11 +51,14 @@ module Neo4j
         #
         # @param (see #node_indexer)
         # @return (see #node_indexer)
-        def rel_indexer(config = IndexConfig.new(:rel), &config_dsl)
+        def rel_indexer(config = _config || IndexConfig.new(:rel), &config_dsl)
           config.instance_eval(&config_dsl)
           indexer(config)
         end
 
+        def _config
+          @_indexer && @_indexer.config
+        end
 
         def indexer(index_config)
           @_indexer ||= IndexerRegistry.instance.register(Indexer.new(index_config))

data/lib/neo4j-core/index/index.rb

@@ -16,8 +16,7 @@ module Neo4j
       # @see Neo4j::Core::Index::ClassMethods#add_index
       #
       def add_index(field, value=self[field])
-        converted_value = Neo4j::TypeConverters.convert(value, field, self.class)
-        self.class.add_index(wrapped_entity, field.to_s, converted_value)
+        self.class.add_index(wrapped_entity, field.to_s, value)
       end
 
       # Removes an index on the given property.

data/lib/neo4j-core/index/index_config.rb

@@ -5,23 +5,25 @@ module Neo4j
       # Responsible for holding the configuration for one index
       # Is used in a DSL to configure the index.
       class IndexConfig
-        attr_reader :_trigger_on, :_index_names, :entity_type, :_index_type, :_numeric_types, :_decl_type
+        attr_reader :_trigger_on, :_index_names, :entity_type, :_index_type, :_field_types
 
         # @param [:rel, :node] entity_type the type of index
         def initialize(entity_type)
           @entity_type = entity_type
           @_index_type = {}
-          @_numeric_types = []
+          @_field_types = {}
           @_trigger_on = {}
-          @_decl_type = {}
+        end
+
+        def to_s
+          "IndexConfig [#@entity_type, _index_type: #{@_index_type.inspect}, _field_types: #{@_field_types.inspect}, _trigger_on: #{@_trigger_on.inspect}]"
         end
 
         def inherit_from(clazz)
           c = clazz._indexer.config
           raise "Can't inherit from different index type #{@entity_type} != #{c.entity_type}" if @entity_type != c.entity_type
           @_index_type.merge!(c._index_type)
-          @_numeric_types += c._numeric_types
-          @_decl_type.merge!(c._decl_type)
+          @_field_types.merge!(c._field_types)
         end
 
         # Specifies which property and values the index should be triggered on.
@@ -31,11 +33,8 @@ module Neo4j
           merge_and_to_string(@_trigger_on, hash)
         end
 
-        # Specifies the types of the properties being indexed so that the proper sort order can be applied.
-        # Used in the Index DSL.
-        # @see Neo4j::Core::Index::ClassMethods#node_indexer
-        def decl_type(prop_and_type_hash)
-          merge_and_to_string(@_decl_type, prop_and_type_hash)
+        def field_type(key)
+          @_field_types[key.to_s]
         end
 
         # Specifies an index with configuration
@@ -47,14 +46,14 @@ module Neo4j
 
           args.uniq.each do |field|
             @_index_type[field.to_s] = conf[:type] || :exact
-            @_numeric_types << field.to_s if conf[:numeric] == true
+            @_field_types[field.to_s] = conf[:field_type] || String
           end
         end
 
-        # @return [Class] the specified type of the property or String
+        # @return [Class,nil] the specified type of the property or nil
         # @see #decl_type
         def decl_type_on(prop)
-          @_decl_type[prop] || String
+          @_field_types[prop]
         end
 
         # @return [true, false] if the props can/should trigger an index operation
@@ -83,7 +82,7 @@ module Neo4j
 
         def rm_index_config
           @_index_type = {}
-          @_numeric_types = []
+          @_field_types = {}
         end
 
         def index_type(field)
@@ -103,7 +102,8 @@ module Neo4j
         end
 
         def numeric?(field)
-          return true if @_numeric_types.include?(field)
+          raise "No index on #{field.inspect}, has fields: #{@field_types.inspect}" unless @_field_types[field]
+          @_field_types[field] != String
         end
 
         private

data/lib/neo4j-core/index/lucene_query.rb

@@ -39,11 +39,7 @@ module Neo4j
           @query = query
           @index_config = index_config
           @params = params
-
-          if params.include?(:sort)
-            @order = {}
-            params[:sort].each_pair { |k, v| @order[k] = (v == :desc) }
-          end
+          @order = params[:sort] if params.include?(:sort)
         end
 
         # Implements the Ruby +Enumerable+ interface
@@ -85,30 +81,26 @@ module Neo4j
         # 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)
+        def between(lower, upper, lower_inclusive=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
-          # check that we perform a range query on the same values as we have declared with the property :key, :type => ...
-          type = @index_config.decl_type_on(@query)
-          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
-          @query = range_query(@query, lower, upper, lower_incusive, upper_inclusive)
+          @query = range_query(@query, lower, upper, lower_inclusive, upper_inclusive)
           self
         end
 
-        def range_query(field, lower, upper, lower_incusive, upper_inclusive)
-          lower = TypeConverters.convert(lower)
-          upper = TypeConverters.convert(upper)
+        def range_query(field, lower, upper, lower_inclusive, upper_inclusive)
+          type = @index_config.field_type(field)
+          raise "no index on field #{field}" unless type
+          # check that we perform a range query on the same values as we have declared with the property :key, :type => ...
+          raise "find(#{field}).between(#{lower}, #{upper}): #{lower} not a #{type}" unless type == lower.class
+          raise "find(#{field}).between(#{lower}, #{upper}): #{upper} not a #{type}" unless type == upper.class
 
           case lower
             when Fixnum
-              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_long_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
+              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_long_range(field.to_s, lower, upper, lower_inclusive, upper_inclusive)
             when Float
-              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_double_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
+              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_double_range(field.to_s, lower, upper, lower_inclusive, upper_inclusive)
             else
-              Java::OrgApacheLuceneSearch::TermRangeQuery.new(field.to_s, lower, upper, lower_incusive, upper_inclusive)
+              Java::OrgApacheLuceneSearch::TermRangeQuery.new(field.to_s, lower, upper, lower_inclusive, upper_inclusive)
           end
         end
 
@@ -156,19 +148,28 @@ module Neo4j
         # Sort descending the given fields.
         # @param [Symbol] fields it should sort
         def desc(*fields)
-          @order = fields.inject(@order || {}) { |memo, field| memo[field] = true; memo }
+          @order ||= []
+          @order += fields.map { |f| [f, :desc] }
           self
         end
 
         # Sort ascending the given fields.
         # @param [Symbol] fields it should sort
         def asc(*fields)
-          @order = fields.inject(@order || {}) { |memo, field| memo[field] = false; memo }
+          @order ||= []
+          @order += fields.map { |f| [f, :asc] }
           self
         end
 
         protected
 
+        def parse_query(query)
+          version = Java::OrgApacheLuceneUtil::Version::LUCENE_30
+          analyzer = Java::OrgApacheLuceneAnalysisStandard::StandardAnalyzer.new(version)
+          parser = Java::org.apache.lucene.queryParser.QueryParser.new(version, 'name', analyzer)
+          parser.parse(query)
+        end
+
         def build_and_query(query)
           build_composite_query(@left_and_query.build_query, query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
         end
@@ -179,6 +180,9 @@ module Neo4j
 
         def build_not_query(query)
           right_query = @right_not_query.build_query
+          query = parse_query(query) if query.is_a?(String)
+          right_query = parse_query(right_query) if right_query.is_a?(String)
+
           composite_query = Java::OrgApacheLuceneSearch::BooleanQuery.new
           composite_query.add(query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST_NOT)
           composite_query.add(right_query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
@@ -186,31 +190,27 @@ module Neo4j
         end
 
         def build_composite_query(left_query, right_query, operator) #:nodoc:
+          left_query = parse_query(left_query) if left_query.is_a?(String)
+          right_query = parse_query(right_query) if right_query.is_a?(String)
           composite_query = Java::OrgApacheLuceneSearch::BooleanQuery.new
-          version = Java::OrgApacheLuceneUtil::Version::LUCENE_35
-          analyzer = org.apache.lucene.analysis.standard::StandardAnalyzer.new(version)
-          parser = Java::org.apache.lucene.queryParser.QueryParser.new(version,'name', analyzer )
-
-          left_query = parser.parse(left_query) if left_query.is_a?(String)
-          right_query = parser.parse(right_query) if right_query.is_a?(String)
-
           composite_query.add(left_query, operator)
           composite_query.add(right_query, operator)
           composite_query
         end
 
         def build_sort_query(query) #:nodoc:
-          java_sort_fields = @order.keys.inject([]) do |memo, field|
-            decl_type = @index_config.decl_type_on(field)
+          java_sort_fields = @order.inject([]) do |memo, val|
+            field = val[0]
+            field_type = @index_config.field_type(field)
             type = case
-                     when Float == decl_type
+                     when Float == field_type
                        Java::OrgApacheLuceneSearch::SortField::DOUBLE
-                     when Fixnum == decl_type || DateTime == decl_type || Date == decl_type || Time == decl_type
+                     when Fixnum == field_type
                        Java::OrgApacheLuceneSearch::SortField::LONG
                      else
                        Java::OrgApacheLuceneSearch::SortField::STRING
                    end
-            memo << Java::OrgApacheLuceneSearch::SortField.new(field.to_s, type, @order[field])
+            memo << Java::OrgApacheLuceneSearch::SortField.new(field.to_s, type, val[1] == :desc)
           end
           sort = Java::OrgApacheLuceneSearch::Sort.new(*java_sort_fields)
           Java::OrgNeo4jIndexLucene::QueryContext.new(query).sort(sort)
@@ -220,18 +220,17 @@ module Neo4j
           and_query = Java::OrgApacheLuceneSearch::BooleanQuery.new
 
           query.each_pair do |key, value|
-            type = @index_config && @index_config[key.to_sym] && @index_config[key.to_sym][:type]
-            if !type.nil? && type != String
+            type = @index_config.field_type(key)
+            if type != String
               if Range === value
-                and_query.add(range_query(key, value.first, value.last, true, !value.exclude_end?), Java::OrgApacheLuceneIndex::BooleanClause::Occur::MUST)
+                and_query.add(range_query(key, value.first, value.last, true, !value.exclude_end?), Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
               else
-                and_query.add(range_query(key, value, value, true, true), Java::OrgApacheLuceneIndex::BooleanClause::Occur::MUST)
+                and_query.add(range_query(key, value, value, true, true), Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
               end
             else
-              conv_value = type ? TypeConverters.convert(value) : value.to_s
-              term = Java::OrgApacheLuceneIndex::Term.new(key.to_s, conv_value)
-              term_query = Java::OrgApacheLuceneIndex::TermQuery.new(term)
-              and_query.add(term_query, Java::OrgApacheLuceneIndex::BooleanClause::Occur::MUST)
+              term = Java::OrgApacheLuceneIndex::Term.new(key.to_s, value.to_s)
+              term_query = Java::OrgApacheLuceneSearch::TermQuery.new(term)
+              and_query.add(term_query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
             end
           end
           and_query

data/lib/neo4j-core/rels/rels.rb

@@ -116,11 +116,11 @@ module Neo4j
       # @return [Enumerable] of Neo4j::Relationship objects
       def _rels(dir=:both, *types)
         if types.size > 1
-          get_relationships(ToJava.dir_to_java(dir), ToJava.types_to_java(types))
+          get_relationships(ToJava.dir_to_java(dir), ToJava.types_to_java(types)).iterator
         elsif types.size == 1
-          get_relationships(ToJava.type_to_java(types[0]), ToJava.dir_to_java(dir))
+          get_relationships(ToJava.type_to_java(types[0]), ToJava.dir_to_java(dir)).iterator
         else
-          get_relationships(ToJava.dir_to_java(dir))
+          get_relationships(ToJava.dir_to_java(dir)).iterator
         end
       end
 

data/lib/neo4j-core/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Core
-    VERSION = "0.0.3"
+    VERSION = "0.0.4"
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: neo4j-core
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.3
+  version: 0.0.4
 platform: java
 authors: 
   - Andreas Ronge
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-03-22 00:00:00 Z
+date: 2012-03-26 00:00:00 Z
 dependencies: 
   - !ruby/object:Gem::Dependency 
     name: neo4j-community
@@ -45,7 +45,6 @@ files:
   - lib/neo4j/neo4j.rb~
   - lib/neo4j/node.rb
   - lib/neo4j/relationship.rb
-  - lib/neo4j/type_converters/type_converters.rb
   - lib/neo4j-core/event_handler.rb
   - lib/neo4j-core/lazy_map.rb
   - lib/neo4j-core/database.rb

data/lib/neo4j/type_converters/type_converters.rb

@@ -1,287 +0,0 @@
-module Neo4j
-
-  # Responsible for converting values from and to Java Neo4j and Lucene.
-  # You can implement your own converter by implementing the method <tt>convert?</tt>
-  # <tt>to_java</tt> and <tt>to_ruby</tt> in this module.
-  #
-  # There are currently three default converters that are triggered when a Time, Date or a DateTime is read or written
-  # if there is a type declared for the property.
-  #
-  # ==== Example
-  #
-  # Example of writing your own marshalling converter:
-  #
-  #  class Foo
-  #     include Neo4j::NodeMixin
-  #     property :thing, :type => MyType
-  #  end
-  #
-  #  module Neo4j::TypeConverters
-  #    class MyTypeConverter
-  #      class << self
-  #        def convert?(type)
-  #          type == MyType
-  #        end
-  #
-  #        def to_java(val)
-  #          "silly:#{val}"
-  #        end
-  #
-  #        def to_ruby(val)
-  #          val.sub(/silly:/, '')
-  #        end
-  #      end
-  #    end
-  #  end
-  #
-  module TypeConverters
-
-    # The default converter to use if there isn't a specific converter for the type
-    class DefaultConverter
-      class << self
-
-        def to_java(value)
-          value
-        end
-
-        def to_ruby(value)
-          value
-        end
-      end
-    end
-
-
-    class BooleanConverter
-      class << self
-
-        def convert?(class_or_symbol)
-          :boolean == class_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          !!value && value != '0'
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          !!value && value != '0'
-        end
-      end
-    end
-
-    class SymbolConverter
-      class << self
-
-        def convert?(class_or_symbol)
-          :symbol == class_or_symbol || Symbol == class_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          value.to_s
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          value.to_sym
-        end
-      end
-    end
-
-
-    class StringConverter
-      class << self
-
-        def convert?(class_or_symbol)
-          [String, :string, :text].include? class_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          value.to_s
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          value.to_s
-        end
-      end
-    end
-
-
-
-    class FixnumConverter
-      class << self
-
-        def convert?(class_or_symbol)
-          Fixnum == class_or_symbol || :fixnum == class_or_symbol || :numeric == class_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          value.to_i
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          value.to_i
-        end
-      end
-    end
-
-    class FloatConverter
-      class << self
-
-        def convert?(clazz_or_symbol)
-          Float == clazz_or_symbol || :float == clazz_or_symbol
-        end
-
-        def to_java(value)
-          return nil if value.nil?
-          value.to_f
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          value.to_f
-        end
-      end
-    end
-
-    # Converts Date objects to Java long types. Must be timezone UTC.
-    class DateConverter
-      class << self
-
-        def convert?(clazz_or_symbol)
-          Date == clazz_or_symbol || :date == clazz_or_symbol
-        end
-
-        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.to_date
-        end
-      end
-    end
-
-    # Converts DateTime objects to and from Java long types. Must be timezone UTC.
-    class DateTimeConverter
-      class << self
-
-        def convert?(clazz_or_symbol)
-          DateTime == clazz_or_symbol || :datetime == clazz_or_symbol
-        end
-
-        # Converts the given DateTime (UTC) value to an Fixnum.
-        # Only utc times are supported !
-        def to_java(value)
-          return nil if value.nil?
-          if value.class == Date
-            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
-          else
-            Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec).to_i
-          end
-        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
-
-    class TimeConverter
-      class << self
-
-        def convert?(clazz_or_symbol)
-          Time == clazz_or_symbol || :time == clazz_or_symbol
-        end
-
-        # Converts the given DateTime (UTC) value to an Fixnum.
-        # Only utc times are supported !
-        def to_java(value)
-          return nil if value.nil?
-          if value.class == Date
-            Time.utc(value.year, value.month, value.day, 0, 0, 0).to_i
-          else
-            value.utc.to_i
-          end
-        end
-
-        def to_ruby(value)
-          return nil if value.nil?
-          Time.at(value).utc
-        end
-      end
-    end
-
-    class << self
-
-      # Mostly for testing purpose, You can use this method in order to
-      # add a converter while the neo4j has already started.
-      def converters=(converters)
-        @converters = converters
-      end
-      
-      # Always returns a converter that handles to_ruby or to_java
-      # if +enforce_type+ is set to false then it will raise in case of unknown type
-      # otherwise it will return the DefaultConverter.
-      def converter(type = nil, enforce_type = true)
-        return DefaultConverter unless type
-        @converters ||= begin
-          Neo4j::TypeConverters.constants.find_all do |c|
-            Neo4j::TypeConverters.const_get(c).respond_to?(:convert?)
-          end.map do  |c|
-            Neo4j::TypeConverters.const_get(c)
-          end
-        end
-        found = @converters.find {|c| c.convert?(type) }
-        raise "The type #{type.inspect} is unknown. Use one of #{@converters.map{|c| c.name }.join(", ")} or create a custom type converter." if !found && enforce_type
-        found or DefaultConverter
-      end
-
-      # Converts the given value to a Java type by using the registered converters.
-      # It just looks at the class of the given value unless an attribute name is given.
-      def convert(value, attribute = nil, klass = nil, enforce_type = true)
-        converter(attribute_type(value, attribute, klass), enforce_type).to_java(value)
-      end
-
-      # Converts the given property (key, value) to Java if there is a type converter for given type.
-      # The type must also be declared using Neo4j::NodeMixin#property property_name, :type => clazz
-      # If no Converter is defined for this value then it simply returns the given value.
-      def to_java(clazz, key, value)
-        type = clazz._decl_props[key.to_sym] && clazz._decl_props[key.to_sym][:type]
-        converter(type).to_java(value)
-      end
-
-      # Converts the given property (key, value) to Ruby if there is a type converter for given type.
-      # If no Converter is defined for this value then it simply returns the given value.
-      def to_ruby(clazz, key, value)
-        type = clazz._decl_props[key.to_sym] && clazz._decl_props[key.to_sym][:type]
-        converter(type).to_ruby(value)
-      end
-
-      private
-      def attribute_type(value, attribute = nil, klass = nil)
-        type = (attribute && klass) ? attribute_type_from_attribute_and_klass(value, attribute, klass) : nil
-        type || attribute_type_from_value(value)
-      end
-
-      def attribute_type_from_attribute_and_klass(value, attribute, klass)
-        if klass.respond_to?(:_decl_props)
-          (klass._decl_props.has_key?(attribute) && klass._decl_props[attribute][:type]) ? klass._decl_props[attribute][:type] : nil
-        end
-      end
-
-      def attribute_type_from_value(value)
-        value.class
-      end
-    end
-  end
-end