redcar 0.9.0 → 0.9.1

data/CHANGES

@@ -1,3 +1,8 @@
+Version 0.9.1 (2 December 2010)
+===============================
+
+ * Move rhino mirror (Dan Lucraft)
+
 Version 0.9 (25 November 2010)
 ==============================
 

data/Rakefile

@@ -1,4 +1,4 @@
-REDCAR_VERSION = "0.9.0" # also change in lib/redcar.rb!
+REDCAR_VERSION = "0.9.1" # also change in lib/redcar.rb!
 require 'rubygems'
 require 'fileutils'
 require 'spec/rake/spectask'
@@ -228,7 +228,6 @@ task :release => :gem do
   }
   
   s3_uploads.each do |source, target|
-    puts [source, target]
     AWS::S3::S3Object.store(target, open(source), 'redcar', :access => :public_read)
   end
 end

data/lib/redcar/installer.rb

@@ -63,7 +63,8 @@ module Redcar
           "http://redcar.s3.amazonaws.com/org-enclojure-repl-server.jar" => nil,
           "http://mirrors.ibiblio.org/pub/mirrors/maven2/org/codehaus/groovy/groovy-all/1.7.4/groovy-all-1.7.4.jar" => "/groovy-all.jar",
           "http://mirrors.ibiblio.org/pub/mirrors/maven2/org/tmatesoft/svnkit/svnkit/1.3.4/svnkit-1.3.4.jar" => "/svnkit.jar",
-          "http://mirrors.ibiblio.org/pub/mirrors/maven2/rhino/js/1.7R2/js-1.7R2.jar" => "/js.jar"
+          # "http://mirrors.ibiblio.org/pub/mirrors/maven2/rhino/js/1.7R2/js-1.7R2.jar" => "/js.jar",
+          "http://redcar.s3.amazonaws.com/deps/rhino-js-1.7R2.jar" => "/js.jar"
         },
         :windows => {
           "http://releases.mozilla.org/pub/mozilla.org/xulrunner/releases/#{xulrunner_version}/runtimes/xulrunner-#{xulrunner_version}.en-US.win32.zip" => "xulrunner-#{xulrunner_version}.en-US.win32.zip",

data/lib/redcar.rb

@@ -51,10 +51,10 @@ end
 #
 # and so on.
 module Redcar
-  VERSION         = '0.9.0' # also change in the Rakefile!
+  VERSION         = '0.9.1' # also change in the Rakefile!
   VERSION_MAJOR   = 0
   VERSION_MINOR   = 9
-  VERSION_RELEASE = 0
+  VERSION_RELEASE = 1
   
   ENVIRONMENTS = [:user, :debug, :test]
   

data/plugins/project_search/vendor/lucene/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/plugins/project_search/vendor/lucene/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/plugins/project_search/vendor/lucene/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/plugins/project_search/vendor/lucene/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    lucene (0.5.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    horo (1.0.2)
+      rdoc (~> 2.5)
+    rake (0.8.7)
+    rdoc (2.5.11)
+    rspec (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+      rspec-mocks (~> 2.0.1)
+    rspec-core (2.0.1)
+    rspec-expectations (2.0.1)
+      diff-lcs (>= 1.1.2)
+    rspec-mocks (2.0.1)
+      rspec-core (~> 2.0.1)
+      rspec-expectations (~> 2.0.1)
+
+PLATFORMS
+  java
+
+DEPENDENCIES
+  horo (>= 1.0.2)
+  lucene!
+  rake (>= 0.8.7)
+  rdoc (>= 2.5.10)
+  rspec (>= 2.0.0)

data/plugins/project_search/vendor/lucene/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Andreas Ronge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/plugins/project_search/vendor/lucene/README.rdoc

@@ -0,0 +1,283 @@
+= 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.
+
+== Status
+
+This library was once included in the neo4j.rb gem (version <= 0.4.6).
+The neo4j wrapper has now replaced this library with the included Java neo4j-lucene component. The main reason for this split was that neo4j now uses two phase commit to keep the databases in sync. 
+
+=== TODO
+* Upgrade to newer lucene 3.x
+* Check the thread synchronization and locking - is this needed ?
+
+== 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  
+
+== Lucene.rb
+
+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.
+

data/plugins/project_search/vendor/lucene/Rakefile

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+
+require 'rake'
+require 'rdoc/task'
+
+require "lucene/version"
+
+
+def assert_committed
+  status = %x{git status}
+  fail("Can't release gem unless everything is committed") unless status =~ /nothing to commit \(working directory clean\)|nothing added to commit but untracked files present/
+end
+desc "create the gemspec"
+task :build do
+  system "gem build lucene.gemspec"
+end
+
+desc "release gem to gemcutter"
+task :release => :build do
+  assert_committed
+  system "gem push lucene-#{Lucene::VERSION}.gem"
+end
+
+desc "Generate documentation for Neo4j.rb"
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = 'doc/rdoc'
+  rdoc.title    = "Lucene.rb Documentation #{Lucene::VERSION}"
+  rdoc.options << '-f' << 'horo'
+  rdoc.options << '-c' << 'utf-8'
+  rdoc.options << '-m' << 'README.rdoc'
+
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/plugins/project_search/vendor/lucene/examples/active_model/serializers.rb

@@ -0,0 +1,25 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../lib")
+
+require 'rubygems'
+require 'neo4j'
+require 'neo4j/extensions/activemodel'
+
+class Person
+  include Neo4j::NodeMixin
+  include ActiveModel::Serializers::JSON
+  include ActiveModel::Serializers::Xml
+
+  property :first_name
+  property :last_name
+
+end
+
+
+Neo4j::Transaction.run do
+  person = Person.new :first_name => 'jimmy', :last_name => 'smith'
+  
+  puts "HASH: #{person.serializable_hash}"
+  puts "JSON: #{person.to_json}"
+  puts "XML : #{person.to_xml}"
+
+end

data/plugins/project_search/vendor/lucene/examples/active_model/validation.rb

@@ -0,0 +1,26 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../lib")
+
+require 'rubygems'
+require 'neo4j'
+require 'neo4j/extensions/activemodel'
+
+class Person
+  include Neo4j::NodeMixin
+  include ActiveModel::Validations
+
+  property :first_name
+  property :last_name
+
+  validates_presence_of :first_name, :last_name
+end
+
+
+Neo4j::Transaction.run do
+  person = Person.new
+
+  puts person.valid?
+  puts  person.errors.inspect
+  person.first_name = "Hej"
+  person.last_name = "hop"
+  puts person.valid?
+end

data/plugins/project_search/vendor/lucene/examples/admin/Rakefile

@@ -0,0 +1,4 @@
+task :default => :spec
+task :spec do
+  system("spec --options spec/spec.opts spec/*_spec.rb") || raise
+end

data/plugins/project_search/vendor/lucene/examples/admin/admin.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../lib")
+require 'neo4j'
+require 'rubygems'
+require 'sinatra/base'
+require 'neo4j/extensions/rest'
+#require 'sinatra'
+
+Sinatra::Application.set(:public, File.dirname(__FILE__) + "/public")
+
+Sinatra::Application.get('/') do
+  erb :index
+end
+
+Sinatra::Application.post('/echo') do
+  puts request.body
+  request.body
+end
+Sinatra::Application.post('/jquery.js') do
+  puts request.body
+  request.body
+end
+
+Sinatra::Application.get('/echo') do
+  puts request.body
+  'pong get'
+end
+puts "HOST " + Sinatra::Application.host
+Sinatra::Application.run! :port => 9123
+#Neo4j.start_rest