neo4j-core 0.0.1-java

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

@@ -0,0 +1,112 @@
+module Neo4j
+  module Core
+    module Index
+
+      # 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
+
+        def initialize(entity_type)
+          @entity_type = entity_type
+          @index_type = {}
+          @numeric_types = []
+          @_trigger_on = {}
+          @decl_type = {}
+        end
+
+        # Specifies which property and values the index should be triggered on.
+        # Used in the Index DSL.
+        # @see Neo4j::Core::Index::ClassMethods#node_indexer
+        def trigger_on(hash)
+          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)
+        end
+
+        # Specifies an index with configuration
+        # Used in the Index DSL.
+        # @param [Hash] args the field and its configuration TODO
+        # @see Neo4j::Core::Index::ClassMethods#index
+        def index(args)
+          conf = args.last.kind_of?(Hash) ? args.pop : {}
+
+          args.uniq.each do |field|
+            @index_type[field.to_s] = conf[:type] || :exact
+            @numeric_types << field.to_s if conf[:numeric] == true
+          end
+        end
+
+        # @return [Class] the specified type of the property or String
+        # @see #decl_type
+        def decl_type_on(prop)
+          @decl_type[prop] || String
+        end
+
+        # @return [true, false] if the props can/should trigger an index operation
+        def trigger_on?(props)
+          @_trigger_on.each_pair { |k, v| break true if (a = props[k]) && (v.include?(a)) } == true
+        end
+
+        # @return the index name for the lucene index given a type
+        def index_name_for_type(type)
+          _prefix_index_name + @_index_names[type]
+        end
+
+        # Defines the
+        def prefix_index_name(&block)
+          @prefix_index_name_block = block
+        end
+
+        def _prefix_index_name
+          @prefix_index_name_block.nil? ? "" : @prefix_index_name_block.call
+        end
+
+        def index_names(hash)
+          @_index_names = hash
+        end
+
+
+        def rm_index_config
+          @index_type = {}
+          @numeric_types = []
+        end
+
+        def index_type(field)
+          @index_type[field.to_s]
+        end
+
+        def has_index_type?(type)
+          @index_type.values.include?(type)
+        end
+
+        def fields
+          @index_type.keys
+        end
+
+        def index?(field)
+          @index_type.include?(field.to_s)
+        end
+
+        def numeric?(field)
+          return true if @numeric_types.include?(field)
+          # TODO callback to numeric dsl for Neo4j::NodeMixin decl_props check
+        end
+
+        private
+
+        def merge_and_to_string(existing_hash, new_hash)
+          new_hash.each_pair do |k, v|
+            existing_hash[k.to_s] ||= Set.new
+            existing_hash[k.to_s].merge(v.is_a?(Array)? v : [v])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+module Neo4j
+  module Core
+    module Index
+
+      # This class is delegated from the Neo4j::Core::Index::ClassMethod
+      # @see Neo4j::Core::Index::ClassMethods
+      class Indexer
+        # @return [Neo4j::Core::Index::IndexConfig]
+        attr_reader :config
+
+        def initialize(config)
+          @config = config
+          @indexes = {} # key = type, value = java neo4j index
+                        # to enable subclass indexing to work properly, store a list of parent indexers and
+                        # whenever an operation is performed on this one, perform it on all
+        end
+
+
+        def to_s
+          "Indexer @#{object_id} index on: [#{@config.fields.map{|f| @config.numeric?(f)? "#{f} (numeric)" : f}.join(', ')}]"
+        end
+
+        # Add an index on a field so that it will be automatically updated by neo4j transactional events.
+        #
+        # The index method takes an optional configuration hash which allows you to:
+        #
+        # @example Add an index on an a property
+        #
+        #   class Person
+        #     include Neo4j::NodeMixin
+        #     index :name
+        #   end
+        #
+        # When the property name is changed/deleted or the node created it will keep the lucene index in sync.
+        # You can then perform a lucene query like this: Person.find('name: andreas')
+        #
+        # @example Add index on other nodes.
+        #
+        #   class Person
+        #     include Neo4j::NodeMixin
+        #     has_n(:friends).to(Contact)
+        #     has_n(:known_by).from(:friends)
+        #     index :user_id, :via => :known_by
+        #   end
+        #
+        # Notice that you *must* specify an incoming relationship with the via key, as shown above.
+        # In the example above an index <tt>user_id</tt> will be added to all Person nodes which has a <tt>friends</tt> relationship
+        # that person with that user_id. This allows you to do lucene queries on your friends properties.
+        #
+        # @example Set the type value to index
+        #
+        #   class Person
+        #     include Neo4j::NodeMixin
+        #     property :height, :weight, :type => Float
+        #     index :height, :weight
+        #   end
+        #
+        # 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> on the property.
+        #
+        # 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::Core::Index::LuceneQuery
+        # @see #find
+        #
+        def index(*args)
+          @config.index(args)
+        end
+
+        # @return [true,false] if there is an index on the given field.
+        def index?(field)
+          @config.index?(field)
+        end
+
+        # @return [true,false] if the
+        def trigger_on?(props)
+          @config.trigger_on?(props)
+        end
+
+        # @return [Symbol] the type of index for the given field (e.g. :exact or :fulltext)
+        def index_type(field)
+          @config.index_type(field)
+        end
+
+        # @return [true,false]  if there is an index of the given type defined.
+        def has_index_type?(type)
+          @config.has_index_type?(type)
+        end
+
+        # Adds an index on the given entity
+        # This is normally not needed since you can instead declare an index which will automatically keep
+        # the lucene index in sync.
+        # @see #index
+        def add_index(entity, field, value)
+          return false unless index?(field)
+          conv_value = indexed_value_for(field, value)
+          index = index_for_field(field.to_s)
+          index.add(entity, field, conv_value)
+        end
+
+
+        # Removes an index on the given entity
+        # This is normally not needed since you can instead declare an index which will automatically keep
+        # the lucene index in sync.
+        # @see #index
+        def rm_index(entity, field, value)
+          return false unless index?(field)
+          index_for_field(field).remove(entity, field, value)
+        end
+
+        # Performs a Lucene Query.
+        #
+        # In order to use this you have to declare an index on the fields first, see #index.
+        # Notice that you should close the lucene query after the query has been executed.
+        # You can do that either by provide an block or calling the Neo4j::Core::Index::LuceneQuery#close
+        # method. When performing queries from Ruby on Rails you do not need this since it will be automatically closed
+        # (by Rack).
+        #
+        # @example with a block
+        #
+        #   Person.find('name: kalle') {|query| puts "#{[*query].join(', )"}
+        #
+        # @example
+        #
+        #   query = Person.find('name: kalle')
+        #   puts "First item #{query.first}"
+        #   query.close
+        #
+        # @return [Neo4j::Core::Index::LuceneQuery] a query object
+        def find(query, params = {})
+          index = index_for_type(params[:type] || :exact)
+          if query.is_a?(Hash) && (query.include?(:conditions) || query.include?(:sort))
+            params.merge! query.reject { |k, _| k == :conditions }
+            query.delete(:sort)
+            query = query.delete(:conditions) if query.include?(:conditions)
+          end
+          query = (params[:wrapped].nil? || params[:wrapped]) ? LuceneQuery.new(index, @config, query, params) : index.query(query)
+
+          if block_given?
+            begin
+              ret = yield query
+            ensure
+              query.close
+            end
+            ret
+          else
+            query
+          end
+        end
+
+        # Delete all index configuration. No more automatic indexing will be performed
+        def rm_index_config
+          @config.rm_index_config
+        end
+
+        # delete the index, if no type is provided clear all types of indexes
+        def rm_index_type(type=nil)
+          if type
+            key = @config.index_name_for_type(type)
+            @indexes[key] && @indexes[key].delete
+            @indexes[key] = nil
+          else
+            @indexes.each_value { |index| index.delete }
+            @indexes.clear
+          end
+        end
+
+        # Called when the neo4j shutdown in order to release references to indexes
+        def on_neo4j_shutdown
+          @indexes.clear
+        end
+
+        # Called from the event handler when a new node or relationships is about to be committed.
+        def update_index_on(node, field, old_val, new_val)
+          if index?(field)
+            rm_index(node, field, old_val) if old_val
+            add_index(node, field, new_val) if new_val
+          end
+        end
+
+        # Called from the event handler when deleting a property
+        def remove_index_on(node, old_props)
+          @config.fields.each { |field| rm_index(node, field, old_props[field]) if old_props[field] }
+        end
+
+        # Creates a wrapped ValueContext for the given value. Checks if it's numeric value in the configuration.
+        # @return [Java::OrgNeo4jIndexLucene::ValueContext] a wrapped neo4j lucene value context
+        def indexed_value_for(field, value)
+          if @config.numeric?(field)
+            Java::OrgNeo4jIndexLucene::ValueContext.new(value).indexNumeric
+          else
+            Java::OrgNeo4jIndexLucene::ValueContext.new(value)
+          end
+        end
+
+        # @return [Java::OrgNeo4jGraphdb::Index] for the given field
+        def index_for_field(field)
+          type = @config.index_type(field)
+          index_name = index_name_for_type(type)
+          @indexes[index_name] ||= create_index_with(type, index_name)
+        end
+
+        # @return [Java::OrgNeo4jGraphdb::Index] for the given index type
+        def index_for_type(type)
+          index_name = index_name_for_type(type)
+          @indexes[index_name] ||= create_index_with(type, index_name)
+        end
+
+        # @return [String] the name of the index which are stored on the filesystem
+        def index_name_for_type(type)
+          @config.index_name_for_type(type)
+        end
+
+        # @return [Hash] the lucene config for the given index type
+        def lucene_config(type)
+          conf = Neo4j::Config[:lucene][type.to_s]
+          raise "unknown lucene type #{type}" unless conf
+          conf
+        end
+
+        # Creates a new lucene index using the lucene configuration for the given index_name
+        #
+        # @param [:node, :relationship] type relationship or node index
+        # @param [String] index_name the (file) name of the index
+        # @return [Java::OrgNeo4jGraphdb::Index] for the given index type
+        def create_index_with(type, index_name)
+          db = Neo4j.started_db
+          index_config = lucene_config(type)
+          if config.entity_type == :node
+            db.lucene.for_nodes(index_name, index_config)
+          else
+            db.lucene.for_relationships(index_name, index_config)
+          end
+        end
+
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Neo4j
+  module Core
+    module Index
+      class IndexerRegistry
+        def initialize
+          @indexers = []
+        end
+
+        def delete_all_indexes
+          @indexers.each { |i| i.rm_index_type }
+        end
+
+        def register(indexer)
+          @indexers << indexer
+          indexer
+        end
+
+        def indexers_for(props)
+          Enumerator.new(self, :each_indexer, props)
+        end
+
+        def each_indexer(props)
+          @indexers.each { |i| yield i if i.trigger_on?(props) }
+        end
+
+        def on_node_deleted(node, old_props, *)
+          each_indexer(old_props) { |indexer| indexer.remove_index_on(node, old_props) }
+        end
+
+        def on_property_changed(node, field, old_val, new_val)
+          each_indexer(node) { |indexer| indexer.update_index_on(node, field, old_val, new_val) }
+        end
+
+        def on_relationship_deleted(relationship, old_props, *)
+          each_indexer(old_props) { |indexer| indexer.remove_index_on(relationship, old_props) }
+        end
+
+        def on_rel_property_changed(rel, field, old_val, new_val)
+          each_indexer(rel) { |indexer| indexer.update_index_on(rel, field, old_val, new_val) }
+        end
+
+        def on_neo4j_shutdown(*)
+          @indexers.each { |indexer| indexer.on_neo4j_shutdown }
+        end
+
+        class << self
+          def instance
+            @@instance ||= IndexerRegistry.new
+          end
+        end
+      end
+      Neo4j.unstarted_db.event_handler.add(IndexerRegistry.instance) unless Neo4j.read_only?
+    end
+  end
+end

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

@@ -0,0 +1,264 @@
+module Neo4j
+  module Core
+
+    module Index
+      # This object is returned when you call the #find method on the Node, Relationship.
+      # The actual query is not executed until the first item is requested.
+      #
+      # You can perform a query in many different ways:
+      #
+      # @example By Hash
+      #
+      #  Person.find(:name => 'foo', :age => 3)
+      #
+      # @example By Range
+      #
+      #  Person.find(:age).between(15,35)
+      #
+      # @example By Lucene Query Syntax
+      #
+      #  Car.find('wheels:"4" AND colour: "blue")
+      #
+      # For more information about the syntax see http://lucene.apache.org/java/3_0_2/queryparsersyntax.html
+      #
+      # @example: By Compound Queries
+      #
+      #   Vehicle.find(:weight).between(5.0, 100000.0).and(:name).between('a', 'd')
+      #
+      # You can combine several queries by <tt>AND</tt>ing those together.
+      #
+      # @see Neo4j::Core::Index::Indexer#index
+      # @see Neo4j::Core::Index::Indexer#find - which returns an LuceneQuery
+      #
+      class LuceneQuery
+        include Enumerable
+        attr_accessor :left_and_query, :left_or_query, :right_not_query, :query, :order
+
+        def initialize(index, index_config, query, params={})
+          @index = index
+          @query = query
+          @index_config = index_config
+          @params = params
+
+          if params.include?(:sort)
+            @order = {}
+            params[:sort].each_pair { |k, v| @order[k] = (v == :desc) }
+          end
+        end
+
+        # Implements the Ruby +Enumerable+ interface
+        def each
+          hits.each { |x| yield x.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
+          @hits = nil
+        end
+
+        # @return [true, false] True if there is no search hits.
+        def empty?
+          hits.size == 0
+        end
+
+        # Does simply loop all search items till the n'th is found.
+        # @return[Neo4j::Node, Neo4j::Relationship] the n'th search item
+        def [](index)
+          i = 0
+          each { |x| return x if i == index; i += 1 }
+          nil # out of index
+        end
+
+        # @return[Fixnum] the number of search hits
+        def size
+          hits.size
+        end
+
+        # 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
+          # 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)
+          self
+        end
+
+        def range_query(field, lower, upper, lower_incusive, upper_inclusive)
+          lower = TypeConverters.convert(lower)
+          upper = TypeConverters.convert(upper)
+
+          case lower
+            when Fixnum
+              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_long_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
+            when Float
+              Java::OrgApacheLuceneSearch::NumericRangeQuery.new_double_range(field.to_s, lower, upper, lower_incusive, upper_inclusive)
+            else
+              Java::OrgApacheLuceneSearch::TermRangeQuery.new(field.to_s, lower, upper, lower_incusive, upper_inclusive)
+          end
+        end
+
+
+        # Create a compound lucene query.
+        #
+        # @param [String] query2 the query that should be AND together
+        # @return [Neo4j::Core::Index::LuceneQuery] a new query object
+        #
+        # @example
+        #
+        #  Person.find(:name=>'kalle').and(:age => 3)
+        #
+        def and(query2)
+          LuceneQuery.new(@index, @index_config, query2).tap { |new_query| new_query.left_and_query = self }
+        end
+
+        # Create an OR lucene query.
+        #
+        # @param [String] query2 the query that should be OR together
+        # @return [Neo4j::Core::Index::LuceneQuery] a new query object
+        #
+        # @example
+        #
+        #  Person.find(:name=>'kalle').or(:age => 3)
+        #
+        def or(query2)
+          LuceneQuery.new(@index, @index_config, query2).tap { |new_query| new_query.left_or_query = self }
+        end
+
+        # Create a NOT lucene query.
+        #
+        # @param [String] query2  the query that should exclude matching results
+        # @return [Neo4j::Core::Index::LuceneQuery] a new query object
+        #
+        # @example
+        #
+        #  Person.find(:age => 3).not(:name=>'kalle')
+        #
+        def not(query2)
+          LuceneQuery.new(@index, @index_config, query2).tap { |new_query| new_query.right_not_query = self }
+        end
+
+
+        # Sort descending the given fields.
+        # @param [Symbol] fields it should sort
+        def desc(*fields)
+          @order = fields.inject(@order || {}) { |memo, field| memo[field] = true; memo }
+          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 }
+          self
+        end
+
+        protected
+
+        def build_and_query(query)
+          build_composite_query(@left_and_query.build_query, query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::MUST)
+        end
+
+        def build_or_query(query)
+          build_composite_query(@left_or_query.build_query, query, Java::OrgApacheLuceneSearch::BooleanClause::Occur::SHOULD)
+        end
+
+        def build_not_query(query)
+          right_query = @right_not_query.build_query
+          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)
+          composite_query
+        end
+
+        def build_composite_query(left_query, right_query, operator) #:nodoc:
+          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)
+            type = case
+                     when Float == decl_type
+                       Java::OrgApacheLuceneSearch::SortField::DOUBLE
+                     when Fixnum == decl_type || DateTime == decl_type || Date == decl_type || Time == decl_type
+                       Java::OrgApacheLuceneSearch::SortField::LONG
+                     else
+                       Java::OrgApacheLuceneSearch::SortField::STRING
+                   end
+            memo << Java::OrgApacheLuceneSearch::SortField.new(field.to_s, type, @order[field])
+          end
+          sort = Java::OrgApacheLuceneSearch::Sort.new(*java_sort_fields)
+          Java::OrgNeo4jIndexLucene::QueryContext.new(query).sort(sort)
+        end
+
+        def build_hash_query(query) #:nodoc:
+          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
+              if Range === value
+                and_query.add(range_query(key, value.first, value.last, true, !value.exclude_end?), Java::OrgApacheLuceneIndex::BooleanClause::Occur::MUST)
+              else
+                and_query.add(range_query(key, value, value, true, true), Java::OrgApacheLuceneIndex::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)
+            end
+          end
+          and_query
+        end
+
+        def build_query #:nodoc:
+          query = @query
+          query = build_hash_query(query) if Hash === query
+          query = build_and_query(query) if @left_and_query
+          query = build_or_query(query) if @left_or_query
+          query = build_not_query(query) if @right_not_query
+          query = build_sort_query(query) if @order
+          query
+        end
+
+        def perform_query #:nodoc:
+          @index.query(build_query)
+        end
+
+
+        def hits #:nodoc:
+          close
+          @hits = perform_query
+        end
+
+
+      end
+    end
+  end
+end

data/lib/neo4j-core/lazy_map.rb

@@ -0,0 +1,21 @@
+module Neo4j
+  module Core
+    # A simple implementation of lazy map
+    # @notice since we must support ruby 1.8.7 we can't use the fancy Enumerator block constructor for this.
+    # @private
+    class LazyMap
+      include Enumerable
+
+      def initialize(stuff, &map_block)
+        @stuff = stuff
+        @map_block = map_block
+      end
+
+      def each
+        @stuff.each { |x| yield @map_block.call(x) }
+      end
+
+    end
+
+  end
+end