lucene 0.5.0.beta.1

data/CHANGELOG

@@ -0,0 +1,147 @@
+== 0.4.6 / 2010-08-31
+* Bug fix: Using a has_one - should only delete the relationship to the old node, NOT delete the old node (#123)
+
+== 0.4.5 / 2010-08-18
+* Bug fix: When setting an indexed property = nil, raises an undefined method "root_class" exception (#122)
+
+== 0.4.4 / 2010-08-01
+* Fixed bug on traversing when using the RelationshipMixin (#121)
+* BatchInserter and JRuby 1.6 - Fix iteration error with trying to modify in-place hash
+
+== 0.4.3 / 2010-04-10
+* Fixed .gitignore - make sure that we do not include unnecessarily files like neo4j databases. Release 0.4.2 contained test data.
+* Added synchronize around Index.new so that two thread can't modify the same index at the same time.
+
+== 0.4.2 / 2010-04-08
+*  No index on properties for the initialize method bug (#116)
+*  Tidy up Thread Synchronization in Lucene wrapper - lucene indexing performance improvement (#117)
+*  Permission bug loading neo4j jar file (#118)
+*  Spike: Make NodeMixin ActiveModel complient - experimental (#115)
+
+== 0.4.1 / 2010-03-11
+* Migrations (#108)
+* BatchInserter (#111)
+* Neo4j::Relationship.new should take a hash of properties (#110)
+* Upgrade to neo4j-1.0 (#114)
+* Bigfix: has_one should replace old relationship (#106)
+* Bugfix: custom accessors for NodeMixin#update (#113)
+* Bugfix: Indexed properties problem on extented ruby classes critical "properties indexer" (#112)
+
+== 0.4.0 / 2010-02-06
+* Performance improvements and Refactoring: Use and Extend Neo4j Java Classes (#97)
+* Support for Index and Declaration of Properties on Relationships (#91)
+* Upgrade to neo4j-1.0 rc (#100)
+* All internal properties should be prefix with a '_',0.4.0 (#105)
+* Generate relationship accessor methods for declared has_n and has_one relationships (#104)
+* New way of creating relationship - Neo4j::Relationship.new (#103)
+* Neo4j#init_node method should take one or more args (#98)
+* Namespaced relationships: has_one...from using the wrong has_n...to(#92)
+* Neo4j::NodeMixin and Neo4j::Node should allow a hash for initialization (#99)
+
+== 0.3.3 / 2009-11-25
+* Support for a counter property on has_lists (#75)
+* Support for Cascade delete. On has_n, had_one and has_list (#81)
+* NodeMixin#all should work with inheritance - Child classes should have a relationship of their own. (#64)
+* Support for other lucene analyzer then StandardAnalyzer (#87)
+* NodeMixin initialize should accept block like docs (#82)
+* Add incoming relationship should work as expected: n1.relationships.incoming(:foo) << n2 (#80)
+* Delete node from a has_list relationship should work as expected (#79)
+* Improve stacktraces (#94)
+* Removed sideeffect of rspecs (#90)
+* Add debug method on NodeMixin to print it self (#88)
+* Removed to_a method (#73)
+* Upgrade to neo4j-1.0b10 (#95)
+* Upgrade to lucene 2.9.0 (#83)
+* Refactoring: RSpecs (#74)
+* Refactoring: aggregate each, renamed to property aggregator (#72)
+* BugFix: neo4j gem cannot be built  from the source (#86)
+* BugFix: Neo4j::relationship should not raise Exception if there are no relationships (#78)
+
+== 0.3.2 / 2009-09-17
+* Added support for aggregating nodes (#65)
+* Wrapped Neo4j GraphAlgo AllSimplePath (#70)
+* Added traversal with traversal position (#71)
+* Removed DynamicAccessors mixin, replaced by [] operator (#67)
+* Impl Neo4j.all_nodes (#69)
+* Upgrated Neo4j jar file to 1.0-b9
+* The Neo4j#relationship method now allows a filter parameter (#66)
+* Neo4j.rb now can read database not created by Neo4j.rb - does not require classname property (#63)
+* REST - added an "all" value for the depth traversal query parameter (#62)
+* REST - Performance improvments using the Rest Mixin (#60)
+
+== 0.3.1 / 2009-07-25
+* Feature, extension -	find path between given pair of nodes (#58)
+* Fix a messy exception on GET /nodes/UnknownClassName (#57)
+* Bug  - exception on GET /nodes/classname/rel if rel is a has_one relationship (#56)
+* Bug: GET /nodes/classname missing out nodes with no properties (#55)
+* Bug: Lucene sorting caused exception if there were no documents (#54)
+* Bug:	reindexer fails to connect nodes to the IndexNode (#53)
+
+== 0.3.0 / 2009-06-25
+* Neo4j should track node changes
+* RESTful support for lucene queries, sorting and paging
+* RESTful support for Relationships
+* RESTful support for Node and properties
+* Experimental support for Master-Slave	Replication via REST
+* RESTful Node representation should contain hyperlinks to relationships
+* Added some handy method like first and empty? on relationships
+* Use new neo4j: neo-1.0-b8
+* Add an event handler for create/delete nodes start/stop neo, update property/relationship
+* The NodeMixin should behave like a hash, added [] and []= methods
+* Support list topology - has_list and belongs_to_list Neo4j::NodeMixin Classmethods
+* Should be possible to add relationships without declaring them (Neo4j#relationships.outgoing(:friends) << node)
+* Neo4j extensions file structure, should be easy to create your own extensions
+* Rename relation to relationship (Neo4j::Relations => Neo4j::Relationships, DynamicRelation => Relationship) [data incompatible change]
+* Auto Transaction is now optional
+* Setting Float properties fails under JRuby1.2.0
+* Bug: Indexing relationships does not work
+* Make the ReferenceNode include Neo4j::NodeMixin
+* Added handy Neo4j class that simply includes the Neo4j::NodeMixin
+* Neo4j::IndexNode now holds references to all nodes (Neo4j.ref_node -> Neo4j::IndexNode -> ...)
+
+
+== 0.2.1 / 2009-03-15
+* Refactoring of lucene indexing of the node space (28)
+* Fixed bug on Neo4j::Nodemixin#property? (#22)
+
+
+== 0.2.0 / 2009-01-20
+* Impl. Neo4j::Node#traverse - enables traversal and filtering using TraversalPosition info (#17,#19)
+* Impl. traversal to any depth (#15)
+* Impl. traversal several relationships type at the same time (#16)
+* Fixed a Lucene timezone bug (#20)
+* Lots of refactoring of the neo4j.rb traversal code and RSpecs
+
+== 0.1.0 / 2008-12-18
+* Property can now be of any type (and not only String, Fixnum, Float)
+* Indexing and Query with Date and DateTime
+* YARD documentation
+* Properties can be removed
+* A property can be set to nil (it will then be removed).
+
+== 0.0.7 / 2008-12-10
+* Added method to_param and methods on the value object needed for Ruby on Rails
+* Impl. update from a value object/hash for a node
+* Impl. generation of value object classes/instances from a node.
+* Refactoring the Transaction handling (reuse PlaceboTransaction instances if possible)
+* Removed the need to start and stop neo. It will be done automatically when needed.
+
+
+== 0.0.6 / 2008-12-03
+* Removed the configuration from the Neo4j.start method. Now exist in Neo4j::Config and Lucene::Config.
+* Implemented sort_by method.
+* Lazy loading of search result. Execute the query and load the nodes only if needed.
+* Added support to use lucene query language, example: Person.find("name:foo AND age:42")
+* All test now uses RAM based lucene indexes.
+
+== 0.0.5 / 2008-11-17
+* Supports keeping lucene index in memory instead of on disk
+* Added support for lucene full text search
+* Fixed so neo4j runs on JRuby 1.1.5
+* Implemented support for reindex all instances of a node class. This is needed if the lucene index is kept in memory or if the index is changed.
+* Added ReferenceNode. All nodes now have a relationship from this reference node.
+* Lots of refactoring
+* Added the IMDB example. It shows how to create a neo database, lucene queries and node traversals.
+
+== 0.0.4 / 2008-10-23
+* First release to rubyforge

data/CONTRIBUTORS

@@ -0,0 +1,17 @@
+Maintainer:
+  Andreas Ronge <andreas dot ronge at gmail dot com>
+
+Contributors:
+* Martin Kleppmann
+* Peter Neubauer
+* Jan-Felix Wittmann
+* Marius Mårnes Mathiesen
+* Bert Fitié
+* Jan Berkel
+* David Beckwith
+* Johny Ho
+* Carlo Cabanilla
+* Anders Janmyr
+* Nick Sieger
+* Sean Bowman
+* BrilliantArc

data/Gemfile

@@ -0,0 +1,9 @@
+source :gemcutter
+
+gemspec
+
+gem "rake",  ">= 0.8.7"
+gem "rdoc",  ">= 2.5.10"
+gem "horo",  ">= 1.0.2"
+gem "rspec", ">= 2.0.0"
+

data/README.rdoc

@@ -0,0 +1,274 @@
+= Lucene.rb
+
+Lucene.rb is JRuby wrapper for the Lucene document database.
+ 
+* Lucene (http://lucene.apache.org/java/docs/index.html) for querying and indexing.
+
+== Installation
+
+==== Install JRuby
+The easiest way to install JRuby is by using RVM, see http://rvm.beginrescueend.com. Otherwise check: http://kenai.com/projects/jruby/pages/GettingStarted#Installing_JRuby  
+
+== The Lucene Module
+
+Lucene provides:
+* Flexible Queries - Phrases, Wildcards, Compound boolean expressions etc...
+* Field-specific Queries eg. title, artist, album
+* Sorting
+* Ranked Searching
+
+The Lucene index will be updated after the transaction commits. It is not possible to
+query for something that has been created inside the same transaction as where the query is performed.
+
+=== Lucene Document
+
+In Lucene everything is a Document. A document can represent anything textual:
+A Word Document, a DVD (the textual metadata only), or a Neo4j.rb node.
+A document is like a record or row in a relationship database.
+
+The following example shows how a document can be created by using the ''<<'' operator
+on the Lucene::Index class and found using the Lucene::Index#find method.
+
+Example of how to write a document and find it:
+
+    require 'lucene'
+
+    include Lucene
+
+    # the var/myindex parameter is either a path where to store the index or
+    # just a key if index is kept in memory (see below)
+    index = Index.new('var/myindex')
+
+    # add one document (a document is like a record or row in a relationship database)
+    index << {:id=>'1', :name=>'foo'}
+
+    # write to the index file
+    index.commit
+
+    # find a document with name foo
+    # hits is a ruby Enumeration of documents
+    hits = index.find{name == 'foo'}
+
+    # show the id of the first document (document 0) found
+    # (the document contains all stored fields - see below)
+    hits[0][:id]   # => '1'
+
+Notice that you have to call the commit method in order to update the index (both disk and in memory indexes).
+Performing several update and delete operations before a commit will give much
+better performance than committing after each operation.
+
+=== Keep indexing on disk
+
+By default Neo4j::Lucene keeps indexes in memory. That means that when the application restarts
+the index will be gone and you have to reindex everything again.
+
+To store indexes on file:
+
+   Lucene::Config[:store_on_file] = true
+   Lucene::Config[:storage_path] => '/home/neo/lucene-db'
+
+When creating a new index the location of the index will be the Lucene::Config[:storage_path] + index path
+Example:
+
+   Lucene::Config[:store_on_file] = true
+   Lucene::Config[:storage_path] => '/home/neo/lucene-db'
+   index = Index.new('/foo/lucene')
+
+The example above will store the index at /home/neo/lucene-db/foo/lucene
+
+=== Indexing several values with the same key
+
+Let say a person can have several phone numbers. How do we index that?
+
+  index << {:id=>'1', :name=>'adam', :phone => ['987-654', '1234-5678']}
+
+
+=== Id field
+
+All Documents must have one id field. If an id is not specified, the default will be: :id of type String.
+A different id can be specified using the field_infos id_field property on the index:
+
+  index = Index.new('some/path/to/the/index')
+  index.field_infos.id_field = :my_id
+
+To change the type of the my_id from String to a different type see below.
+
+=== Conversion of types
+
+Lucene.rb can handle type conversion for you. (The Java Lucene library stores all
+the fields as Strings)
+For example if you want the id field to be a Fixnum
+
+    require 'lucene'
+    include Lucene
+
+    index = Index.new('var/myindex')  # store the index at dir: var/myindex
+    index.field_infos[:id][:type] = Fixnum
+
+    index << {:id=>1, :name=>'foo'} # notice 1 is not a string now
+
+    index.commit
+
+    # find that document, hits is a ruby Enumeration of documents
+    hits = index.find(:name => 'foo')
+
+    # show the id of the first document (document 0) found
+    # (the document contains all stored fields - see below)
+    doc[0][:id]   # => 1
+
+If the field_info type parameter is not set then it has a default value of String.
+
+=== Storage of fields
+
+By default only the id field will be stored.
+That means that in the example above the :name field will not be included in the document.
+
+Example
+    doc = index.find('name' => 'foo')
+    doc[:id]   # => 1
+    doc[:name] # => nil
+
+Use the field info :store=true if you want a field to be stored in the index
+(otherwise it will only be searchable).
+
+Example
+
+    require 'lucene'
+    include Lucene
+
+    index = Index.new('var/myindex')  # store the index at dir: var/myindex
+    index.field_infos[:id][:type] = Fixnum
+    index.field_infos[:name][:store] = true # store this field
+
+    index << {:id=>1, :name=>'foo'} # notice 1 is not a string now
+
+    index.commit
+
+    # find that document, hits is a ruby Enumeration of documents
+    hits = index.find('name' => 'foo')
+
+    # let say hits only contains one document so we can use doc[0] for that one
+    # that document contains all stored fields (see below)
+    doc[0][:id]   # => 1
+    doc[0][:name] # => 'foo'
+
+=== Setting field infos
+
+As shown above you can set field infos like this
+
+  index.field_infos[:id][:type] = Fixnum
+
+Or you can set several properties like this:
+
+  index.field_infos[:id] = {:type => Fixnum, :store => true}
+
+==== Tokenized
+
+Field infos can be used to specify if the should be tokenized.
+If this value is not set then the entire content of the field will be considered as a single term.
+
+Example
+
+  index.field_infos[:text][:tokenized] = true
+
+If not specified, the default is 'false'
+
+==== Analyzer
+
+Field infos can also be used to set which analyzer should be used.
+If none is specified, the default analyzer - org.apache.lucene.analysis.standard.StandardAnalyzer (:standard) will be used.
+
+
+  index.field_infos[:code][:tokenized] = false
+  index.field_infos[:code][:analyzer] = :standard
+
+The following analyzer is supported
+ * :standard (default) - org.apache.lucene.analysis.standard.StandardAnalyzer
+ * :keyword - org.apache.lucene.analysis.KeywordAnalyzer
+ * :simple  - org.apache.lucene.analysis.SimpleAnalyzer
+ * :whitespace - org.apache.lucene.analysis.WhitespaceAnalyzer
+ * :stop       - org.apache.lucene.analysis.StopAnalyzer
+
+For more info, check the Lucene documentation, http://lucene.apache.org/java/docs/
+
+
+=== Simple Queries
+
+Lucene.rb support search in several fields:
+Example:
+
+    # finds all document having both name 'foo' and age 42
+    hits = index.find('name' => 'foo', :age=>42)
+
+Range queries:
+
+    # finds all document having both name 'foo' and age between 3 and 30
+    hits = index.find('name' => 'foo', :age=>3..30)
+
+=== Lucene Queries
+
+If the query is string then the string is a Lucene query.
+
+  hits = index.find('name:foo')
+
+For more information see:
+http://lucene.apache.org/java/2_4_0/queryparsersyntax.html
+
+=== Advanced Queries (DSL)
+
+The queries above can also be written in a lucene.rb DSL:
+
+    hits = index.find { (name == 'andreas') & (foo == 'bar')}
+
+Expression with OR (|) is supported, example
+
+   # find all documents with name 'andreas' or age between 30 and 40
+    hits = index.find { (name == 'andreas') | (age == 30..40)}
+
+=== Sorting
+
+Sorting is specified by the 'sort_by' parameter
+Example:
+
+  hits = index.find(:name => 'foo', :sort_by=>:category)
+
+To sort by several fields:
+
+  hits = index.find(:name => 'foo', :sort_by=>[:category, :country])
+
+Example sort order:
+
+  hits = index.find(:name => 'foo', :sort_by=>[Desc[:category, :country], Asc[:city]])
+
+=== Thread-safety
+
+The Lucene::Index is thread safe.
+It guarantees that an index is not updated from two threads at the same time.
+
+
+=== Lucene Transactions
+
+Use the Lucene::Transaction in order to do atomic commits.
+By using a transaction you do not need to call the Index.commit method.
+
+Example:
+
+    Transaction.run do |t|
+      index = Index.new('var/index/foo')
+      index << { id=>42, :name=>'andreas'}
+      t.failure  # rollback
+    end
+
+    result = index.find('name' => 'andreas')
+    result.size.should == 0
+
+You can find uncommitted documents with the uncommitted index property.
+
+Example:
+
+      index = Index.new('var/index/foo')
+      index.uncommited #=> [document1, document2]
+
+Notice that even if it looks like a new Index instance object was created the index.uncommitted
+may return a non-empty array. This is because Index.new is a singleton - a new instance object is not created.
+