polecat 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+# comment out the gems, you don't want
+group :preferred do
+  gem "virtus"
+end
+
+group :development do
+  gem "rspec"
+  gem "rdoc"
+  gem "yard"
+  gem "bundler"
+  gem "jeweler"
+  gem "reek"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Gibheer
+
+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/README.rdoc

@@ -0,0 +1,23 @@
+= polecat
+
+This is my attempt to build a search library like lucene in native ruby.
+
+The idea formed, when I learned about the rubinius project and it's ability to tune parts of the ruby code with it's jit. It's a bit sad for MRI, that more and more ruby code get's converted to C, so it would be great, if rbx could be as performant as MRI, even if great parts of a application are written in ruby.
+
+More updates are to come, when it is further progessing.
+
+== Contributing to polecat
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Gibheer. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "polecat"
+  gem.homepage = "http://github.com/Gibheer/polecat"
+  gem.license = "MIT"
+  gem.summary = %Q{library for searching through documents}
+  gem.description = %Q{This is a search library for searching terms in documents}
+  gem.email = "gibheer@gmail.com"
+  gem.authors = ["Gibheer"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+require 'reek/rake/task'
+Reek::Rake::Task.new do |t|
+  t.fail_on_error = true
+  t.verbose = false
+  t.source_files = 'lib/**/*.rb'
+end
+
+task :default => :spec
+
+namespace :spec do
+  desc "with all ruby versions"
+  task :all do
+    puts `rvm 1.8.7@polecat,1.9.2@polecat,rbx@polecat,rbx-hydra@polecat rake spec`
+  end
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/polecat/document.rb

@@ -0,0 +1,61 @@
+require 'polecat/document_resource'
+
+class Polecat
+  module Document
+    OPTIONS = {
+      :index => true,
+      :lazy  => false,
+      :value => nil
+    }
+
+    # include the document
+    #
+    # This includes the document into the target class.
+    # @private
+    def self.included klass #:nodoc:
+      klass.extend(DocumentResource)
+      klass.instance_variable_set :@attributes, {}
+    end
+
+    # creates a new document
+    #
+    # It is possible to create a new document with a hash, which has all values
+    # of the fields.
+    # @example initializing a document
+    #   class Foo
+    #     include Polecat::Document
+    #
+    #     field :id
+    #     field :description
+    #   end
+    #   f = Foo.new :id => 1, :description => 'foo'
+    def initialize fields = {}
+      fields.each do |key, value|
+        attribute_set key, value
+      end
+    end
+
+    # get an attribute of the document
+    def attribute_get name
+      attributes[name.to_sym][:value]
+    end
+
+    # set an attribute of the document
+    def attribute_set name, value
+      name = name.to_sym
+      att = attributes
+      if att.has_key? name
+        att[name][:value] = value
+      else
+        raise ArgumentError, "attribute #{name} does not exist"
+      end
+    end
+
+    # get all attributes
+    def attributes
+      return @attributes if @attributes
+      @attributes = Marshal.load(Marshal.dump(
+        self.class.instance_variable_get :@attributes))
+    end
+  end
+end

data/lib/polecat/document_resource.rb

@@ -0,0 +1,37 @@
+class Polecat
+  module DocumentResource
+    def field name, options = {}
+      attributes = self.instance_variable_get :@attributes
+      attributes[name.to_sym] = Document::OPTIONS.merge(options)
+
+      create_reader_for name
+      create_writer_for name
+    end
+
+    def mod
+      if !@mod
+        @mod = Module.new
+        self.class_eval do
+          include @mod
+        end
+      end
+      @mod
+    end
+
+    def create_reader_for name
+      mod.module_eval <<-RUBYCODE
+        def #{name.to_s}
+          attribute_get :#{name}
+        end
+      RUBYCODE
+    end
+    
+    def create_writer_for name
+      mod.module_eval <<-RUBYCODE
+        def #{name.to_s}= o
+          attribute_set :#{name}, o
+        end
+      RUBYCODE
+    end
+  end
+end

data/lib/polecat/index_reader.rb

@@ -0,0 +1,47 @@
+class Polecat
+  # reads an index directory
+  #
+  # This class reads the content of an index directory and builds the
+  # necessary structures for the index type.
+  class IndexReader
+    attr_reader :path
+
+    # initialize a new reader
+    #
+    # Create a new reader for the given path. If the directory is empty, you
+    # will get an empty index, else all documents stored in that directory.
+    # @param [String] path the path to the index directory
+    def initialize path
+      @path = path
+      raise ArgumentError, 'no valid directory' unless File.directory? @path
+    end
+
+    # read the content of the directory
+    #
+    # Read all files of the directory and return an index object.
+    # @raise [IOError] raised when the directory is locked
+    # @return [Polecat::Index] the index with all documents
+    def read
+      raise IOError, 'index is locked' if locked?
+      files = Dir[@path + '/*']
+      if files.count > 0
+        documents = []
+        files.each do |file|
+          documents += Marshal.load(File.read(file))
+        end
+        documents
+      else
+        []
+      end
+    end
+
+    # checks whether the directory is locked or not
+    def locked?
+      if File.exists? @path + '/index.lock'
+        true
+      else
+        false
+      end
+    end
+  end
+end

data/lib/polecat/index_searcher.rb

@@ -0,0 +1,84 @@
+class Polecat
+  # interface for searching an index
+  #
+  # Build on top of an Polecat::IndexReader, this class let's you search through
+  # all documents stored in an index.
+  class IndexSearcher
+    attr_reader :reader
+    attr_reader :default_field
+
+    # creates a new Polecat::IndexSearcher
+    #
+    # Create a new Polecat::IndexSearcher to search documents. Either a path
+    # to a directory or a Polecat::IndexReader has to be given, to make this
+    # searcher work.
+    # @example
+    #   # the following has the same meaning
+    #   IndexSearcher.new 'index_dir'
+    #   IndexSearcher.new(IndexReader.new 'index_dir')
+    def initialize options
+      if options.has_key? :path
+        @reader = Polecat::IndexReader.new(options[:path])
+      elsif options.has_key? :reader 
+        @reader = options[:reader]
+        raise ArgumentError, 'no reader' unless @reader.kind_of?(Polecat::IndexReader)
+      end
+
+      if options.has_key? :default_field
+        @default_field = options[:default_field]
+      end
+    end
+
+    # returns the path of the index directory
+    # @return [String] path of the index directory
+    def path
+      @reader.path
+    end
+
+    # searches through all documents
+    #
+    # Run the query against the @default_field@ of every stored document to get
+    # a list of all matching documents.
+    # @param [String] query a String which get's matched against the documents
+    # @return [Array] a list of all matching documents
+    def search query
+      @reader.read.select do |doc|
+        #doc.attributes.fetch(@default_field).fetch(:value) == query
+        rs = []
+        query.terms.each do |term|
+          val = doc.send(term.field.to_sym)
+          if compare val, term.operator, term.value
+            rs << true
+          end
+        end
+        if query.relation == :and
+          rs.count == query.terms.count
+        else
+          rs.empty?
+        end
+      end
+    end
+
+    # compare the document value with the searched value
+    #
+    # This compares the two values with the operator
+    # @return [Any] trueish for matches or falsey
+    # @private
+    def compare ival, op, tval
+      if op == :eq
+        if tval.class == Regexp
+          ival.match tval
+        else
+          ival == tval
+        end
+      elsif op == :gt
+        ival < tval
+      elsif op == :lt
+        ival > tval
+      else
+        false
+      end
+    end
+    private :compare
+  end
+end

data/lib/polecat/index_writer.rb

@@ -0,0 +1,123 @@
+class Polecat
+  # handles the writing of new documents to the index.
+  #
+  # This class is responsible for writing the documents to the index. It takes
+  # a path on creation and checks, if it is an empty or a valid index directory.
+  #
+  # When the documents are getting written to the filesystem, a 'index.lock'
+  # file is written as an extra lock. It then writes a new file into the
+  # directory, which has all documents.
+  class IndexWriter
+    attr_reader :path
+
+    # create a new IndexWriter
+    #
+    # This creates a new IndexWriter set to the given path.
+    # @param [String] path the path to the index directory
+    def initialize path
+      if !File.directory? path
+        raise ArgumentError, 'not a directory'
+      elsif File.exists? path + '/index.lock'
+        raise IOError, 'index is locked'
+      else
+        @path = path
+        @documents = []
+      end
+    end
+
+    # returns the count of elements not flushed
+    #
+    # This method returns the count of all elements stored in the Writer, but
+    # not yet flushed to a file.
+    # @return [Fixnum] count of files
+    def count
+      @documents.count
+    end
+
+    # add a new document to the writer
+    #
+    # This adds a Document to the temporary storage. Call #write to write them
+    # to the filesystem.
+    # @param [Document] doc the document to store
+    def add doc
+      if doc.respond_to? :attributes
+        @documents << doc
+      else
+        raise ArgumentError, 'missing method attributes'
+      end
+    end
+
+    # write all documents to the disc
+    #
+    # Write all stored documents to the disc and clear the buffer.
+    # @return [Boolean] true when the write was a success
+    def write
+      return false unless set_lock
+      file_name = generate_filename
+              
+      File.open file_name, 'w' do |file|
+        file.write Marshal.dump(@documents)
+      end
+
+      @documents = []
+      release_lock
+    end
+
+    # creates an index reader with the writers path
+    #
+    # @returns [Polecat::IndexReader] an IndexReader with the same path
+    def create_reader
+      Polecat::IndexReader.new @path
+    end
+
+    # set the lock on the index
+    # @private
+    def set_lock
+      if File.exists? lock_file_name
+        false
+      else
+        FileUtils.touch lock_file_name
+        true
+      end
+    end
+    private :set_lock
+
+    # release the index lock
+    # @private
+    def release_lock
+      if File.exists? lock_file_name
+        FileUtils.rm lock_file_name
+        true
+      else
+        false
+      end
+    end
+    private :release_lock
+
+    # get the full path of the lock file
+    # @private
+    def lock_file_name
+      @path + '/index.lock'
+    end
+    private :lock_file_name
+
+    # generates a new file name for an index file
+    # @private
+    def generate_filename 
+      last_file = Dir[@path + '/*.ind'].sort.last
+      if last_file.nil?
+        file_name = @path + '/ind0.ind'
+      else
+        number = File.basename(last_file).match(/[0-9]+/)[0].to_i
+        # we have to match the complete name, because there can be
+        # numbers before the file too
+        file_name = last_file.gsub(
+          /ind#{number}\.ind/,
+          "ind#{(number + 1)}.ind"
+        )
+      end
+      file_name
+    end
+    private :generate_filename
+  end
+end

data/lib/polecat/query.rb

@@ -0,0 +1,35 @@
+class Polecat
+  # The Query manages a number of terms or queries which are set into a
+  # relation. A relation is needed to say, which documents shall be
+  # returned.
+  # In a @and@ relation only the documents, which are returned of the query
+  # parts get returned. For @or@ all documents found in a part get returned.
+  class Query
+    # returns the relation of the terms
+    # @return [Symbol] :and, :or
+    attr_accessor :relation
+
+    # returns the list of all terms
+    attr_reader :terms
+
+    # creates a new query object
+    #
+    # Create a new query object. As a default, the relation is set to @:and@
+    # (@see Query#relation)
+    def initialize relation = :and
+      if relation == :and || relation == :or
+        @relation = relation
+      else
+        raise ArgumentError, 'no valid relation'
+      end
+
+      @terms = []
+    end
+
+    # add a new term or query
+    def add term
+      @terms << term
+      self
+    end
+  end
+end

data/lib/polecat/term.rb

@@ -0,0 +1,21 @@
+class Polecat
+  class Term
+    # the field name which should be found
+    attr_reader :field
+    # the operator to match the field with the value
+    attr_reader :operator
+    # the search value which get's matched against the document field
+    attr_reader :value
+
+    # create a new Term for a query
+    def initialize field, operator, value
+      @field = field
+      @operator = operator
+      if @operator == :eq && value.class == String
+        @value = /^#{value}$/
+      else
+        @value = value
+      end
+    end
+  end
+end

data/lib/polecat.rb

@@ -0,0 +1,7 @@
+class Polecat
+  require 'polecat/index_writer'
+  require 'polecat/index_reader'
+  require 'polecat/index_searcher'
+  require 'polecat/query'
+  require 'polecat/term'
+end

data/polecat.gemspec

@@ -0,0 +1,85 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{polecat}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Gibheer"]
+  s.date = %q{2011-06-06}
+  s.description = %q{This is a search library for searching terms in documents}
+  s.email = %q{gibheer@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "lib/polecat.rb",
+    "lib/polecat/document.rb",
+    "lib/polecat/document_resource.rb",
+    "lib/polecat/index_reader.rb",
+    "lib/polecat/index_searcher.rb",
+    "lib/polecat/index_writer.rb",
+    "lib/polecat/query.rb",
+    "lib/polecat/term.rb",
+    "polecat.gemspec",
+    "spec/index_reader/locked_spec.rb",
+    "spec/index_reader/new_spec.rb",
+    "spec/index_reader/read_spec.rb",
+    "spec/index_searcher/new_spec.rb",
+    "spec/index_searcher/search_spec.rb",
+    "spec/index_writer/add_spec.rb",
+    "spec/index_writer/count_spec.rb",
+    "spec/index_writer/create_reader_spec.rb",
+    "spec/index_writer/new_spec.rb",
+    "spec/index_writer/write_spec.rb",
+    "spec/polecat_spec.rb",
+    "spec/query/add_spec.rb",
+    "spec/query/new_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/term/new_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/Gibheer/polecat}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.10}
+  s.summary = %q{library for searching through documents}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<reek>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<rdoc>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<bundler>, [">= 0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<reek>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<rdoc>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<bundler>, [">= 0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<reek>, [">= 0"])
+  end
+end
+

data/spec/index_reader/locked_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexReader#locked?" do
+  before do
+    @path = prepare_index_dir
+  end
+
+  it "returns false when the directory is not locked" do
+    r = Polecat::IndexReader.new @path
+    r.locked?.should == false
+  end
+
+  it "returns true when the directory is locked" do
+    FileUtils.touch @path + '/index.lock'
+    r = Polecat::IndexReader.new @path
+    r.locked?.should == true
+  end
+end

data/spec/index_reader/new_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexReader#new" do
+  before do
+    @path = prepare_index_dir
+  end
+
+  it "takes a directory path as an argument" do
+    r = Polecat::IndexReader.new @path
+    r.path.should == @path
+  end
+
+  it "raises an error when no path is given" do
+    lambda { Polecat::IndexReader.new }.should raise_error(ArgumentError)
+  end
+
+  it "raises an error when the path is not a directory" do
+    lambda { Polecat::IndexReader.new '/dev/null' }.should(
+      raise_error(ArgumentError))
+  end
+end

data/spec/index_reader/read_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexReader#read" do
+  before do
+    @path = prepare_index_dir
+  end
+
+  it "returns a array with all documents" do
+    r = Polecat::IndexReader.new @path
+    r.read.class.should == Array
+  end
+
+  it "returns an empty hash for a empty directory" do
+    r = Polecat::IndexReader.new @path
+    r.read.count.should == 0
+  end
+
+  it "returns the document count found in the index directory" do
+    w = Polecat::IndexWriter.new @path
+    w.add Spec::TestDocument.new(:id => 23)
+    w.write
+    r = Polecat::IndexReader.new @path
+    r.read.count.should == 1
+  end
+
+  it "returns an array of documents" do
+    w = Polecat::IndexWriter.new @path
+    w.add Spec::TestDocument.new(:id => 23)
+    w.write
+    w.create_reader.read[0].respond_to?(:attributes).should == true
+  end
+
+  it "merges all documents from different files together" do
+    w = Polecat::IndexWriter.new @path
+    w.add Spec::TestDocument.new(:id => 23)
+    w.write
+    w.add Spec::TestDocument.new(:id => 24)
+    w.write
+    w.create_reader.read.count.should == 2
+  end
+
+  it "raises an error when the directory is locked" do
+    FileUtils.touch @path + '/index.lock'
+    r = Polecat::IndexReader.new @path
+    lambda { r.read }.should raise_error(IOError)
+  end
+end

data/spec/index_searcher/new_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexSearcher#new" do
+  before do
+    @path = prepare_index_dir
+  end
+
+  it "takes a hash with options as an argument" do
+    s = Polecat::IndexSearcher.new(
+      :path          => @path,
+      :default_field => :description
+    )
+    s.path.should          == @path
+    s.default_field.should == :description
+  end
+
+  it "takes a reader in the options" do
+    r = Polecat::IndexReader.new(@path)
+    s = Polecat::IndexSearcher.new :reader => r
+    s.reader.should == r
+  end
+
+  it "raises an error, when the reader is not an IndexReader" do
+    lambda { Polecat::IndexSearcher.new(:reader => "foo") }.should(
+      raise_error(ArgumentError))
+  end
+end

data/spec/index_searcher/search_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexSearcher#search" do
+  let(:path) { prepare_index_dir }
+  let(:w) { Polecat::IndexWriter.new(path) }
+  let(:s) { Polecat::IndexSearcher.new :path => path }
+
+  it "returns an empty array when the query is empty" do
+    s.search(Polecat::Query.new).should == []
+  end
+
+  context "searching on a filled index" do
+    before do
+      w.add Spec::TestDocument.new(:id => 0, :name => 'foo')
+      w.add Spec::TestDocument.new(:id => 1, :name => 'bar')
+      w.add Spec::TestDocument.new(:id => 2, :name => 'baz')
+      w.add Spec::TestDocument.new(:id => 3, :name => 'foobar')
+      w.write
+    end
+
+    let :s do
+      Polecat::IndexSearcher.new(
+        :reader => w.create_reader,
+        :default_field => :name
+      )
+    end
+
+    let (:q1) { Polecat::Query.new.add(Polecat::Term.new(:id, :eq, 1)) }
+    it "returns an array of documents, when a document was found" do
+      s.search(q1).count.should == 1
+    end
+
+    let (:q2) { Polecat::Query.new.add(Polecat::Term.new(:name, :eq, 'foo')) }
+    it "returns only matches for a String query" do
+      s.search(q2).count.should == 1
+    end
+
+    let (:q3) { Polecat::Query.new.add(Polecat::Term.new(:name, :eq, /foo/)) }
+    it "returns all documents when an regexp is given" do
+      s.search(q3).count.should == 2
+    end
+
+    let (:q4) { Polecat::Query.new.add(Polecat::Term.new(:id, :eq, 33)) }
+    it "returns an empty array when no document matched" do
+      s.search(q4).count.should == 0
+    end
+
+    let (:q5) {
+      Polecat::Query.new.
+        add(Polecat::Term.new(:id, :eq, 3)).
+        add(Polecat::Term.new(:name, :eq, 'foobar'))
+    }
+    it "returns a document for a query with multiple terms" do
+      s.search(q5).count.should == 1
+    end
+  end
+end

data/spec/index_writer/add_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexWriter#add" do
+  let (:path) { prepare_index_dir }
+  let (:doc1) { Spec::TestDocument.new :id => 1 }
+  let (:doc2) { Spec::TestDocument.new :id => 2 }
+  let (:w) { w = Polecat::IndexWriter.new path }
+
+  it "adds the object to the list of objects" do
+    w.add doc1
+    w.count.should == 1
+  end
+
+  it "takes multiple documents and sotres them" do
+    w.add doc1
+    w.add doc2
+    w.count.should == 2
+  end
+
+  it "raises an error, when the object is not a document" do
+    lambda { Polecat::IndexWriter.new(path).add "foo" }.should(
+      raise_error(ArgumentError))
+  end
+end

data/spec/index_writer/count_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexWriter#count" do
+  before :all do
+    @path = prepare_index_dir
+  end
+
+  it "returns 0 on an empty writer" do
+    w = Polecat::IndexWriter.new @path
+    w.count.should == 0
+  end
+
+  it "returns the number of documents stored in the storage" do
+    w = Polecat::IndexWriter.new @path
+    w.add Spec::TestDocument.new
+    w.count.should == 1
+  end
+end

data/spec/index_writer/create_reader_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexReader#read" do
+  before do
+    @path = prepare_index_dir
+  end
+
+  it "returns a IndexReader" do
+    w = Polecat::IndexWriter.new @path
+    w.create_reader.class.should == Polecat::IndexReader
+  end
+
+  it "returns a different object everytime it is called" do
+    w = Polecat::IndexWriter.new @path
+    w.create_reader.should_not == w.create_reader
+  end
+
+  it "returns an IndexReader with the same path" do
+    w = Polecat::IndexWriter.new @path
+    w.create_reader.path.should == w.path
+  end
+end

data/spec/index_writer/new_spec.rb

@@ -0,0 +1,27 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexWriter#new" do
+  before :all do
+    @path = prepare_index_dir
+  end
+
+  it "takes a path as an argument" do
+    writer = Polecat::IndexWriter.new @path
+    writer.path.should == @path
+  end
+
+  it "raises an Argument when no path is given" do
+    lambda { Polecat::IndexWriter.new }.should raise_error(ArgumentError)
+  end
+
+  it "raises an error, when the path is not directory" do
+    lambda {
+      Polecat::IndexWriter.new "/dev/null" 
+    }.should raise_error(ArgumentError)
+  end
+
+  it "raises an error when a index.lock file is in the directory" do
+    FileUtils.touch @path + '/index.lock'
+    lambda { Polecat::IndexWriter.new @path }.should raise_error(IOError)
+  end
+end

data/spec/index_writer/write_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "IndexWriter#write" do
+  before do
+    @path = prepare_index_dir
+  end
+
+  it "sets count to 0" do
+    w = Polecat::IndexWriter.new @path
+    w.add Spec::TestDocument.new
+    w.write
+    w.count.should == 0
+  end
+
+  it "returns true when the write was a success" do
+    w = Polecat::IndexWriter.new @path
+    w.add Spec::TestDocument.new
+    w.write.should == true
+  end
+
+  it "removes the lock after a write" do
+    w = Polecat::IndexWriter.new @path
+    w.add Spec::TestDocument.new
+    w.write
+    File.exists?(@path + '/index.lock').should == false
+  end
+
+  it "takes a higher number for the index file, if there is already one" do
+    FileUtils.touch @path + '/ind0.ind'
+    w = Polecat::IndexWriter.new @path
+    w.add Spec::TestDocument.new
+    w.write
+    File.exists?(@path + '/ind1.ind').should == true
+  end
+
+  it "writes a marshalled representation of the document list" do
+    w = Polecat::IndexWriter.new @path
+    doc = Spec::TestDocument.new
+    w.add doc
+    w.write
+    File.read(@path + '/ind0.ind').should == Marshal.dump([doc])
+  end
+
+  it "returns false when the directory has an 'index.lock' file" do
+    w = Polecat::IndexWriter.new @path
+    FileUtils.touch @path + '/index.lock'
+    w.add Spec::TestDocument.new
+    w.write.should == false
+  end
+end

data/spec/polecat_spec.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Polecat" do
+  describe "#new" do
+    it "can be initialized" do
+      Polecat.new
+    end
+  end
+end

data/spec/query/add_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Query#add" do
+  let (:term1) { Polecat::Term.new(:id, :eq, 23) }
+  let (:term2) { Polecat::Term.new(:name, :eq, 'foo') }
+  let (:term3) { Polecat::Term.new(:lastname, :eq, /foo/) }
+  let (:query) { Polecat::Query.new }
+
+  it "returns the query object for chaining" do
+    query.add(term1).should be(query)
+  end
+
+  it "adds the term to the list of terms" do
+    query.add(term1).terms.count.should be(1)
+  end
+end

data/spec/query/new_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Query#new" do
+  it "uses 'and' as an default" do
+    q = Polecat::Query.new
+    q.relation.should be(:and)
+  end
+
+  it "takes a relation operator as an argument" do
+    q = Polecat::Query.new :or
+    q.relation.should be(:or)
+  end
+
+  it "raises an error, when the relation is not known" do
+    lambda { Polecat::Query.new :foo }.should raise_error(ArgumentError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'fileutils'
+require 'polecat'
+require 'virtus'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end
+
+def prepare_index_dir
+  path = File.expand_path(File.dirname(__FILE__) + '/index_dir')
+  begin
+    FileUtils.rm_r path
+  rescue SystemCallError
+    # the directory structure is not there, so just
+    # ignore it and print a hint
+    puts "error occured, but was ignored: $!"
+  end
+  Dir.mkdir path
+  return path
+end
+
+module Spec
+  class TestDocument
+    include Virtus
+
+    attribute :id, Integer
+    attribute :name, String
+    attribute :lastname, String
+    attribute :description, String, :analyze => true, :lazy => true
+  end
+end

data/spec/term/new_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Term#new" do
+  it "takes a field, a operator and a value" do
+    t = Polecat::Term.new :id, :eq, 23
+    t.field.should be(:id)
+    t.operator.should be(:eq)
+    t.value.should be(23)
+  end
+
+  it "converts Strings to Regexps, if the operator is :eq" do
+    t = Polecat::Term.new :name, :eq, "foo"
+    t.value.should == /^foo$/
+  end
+
+  it "raises an error if no argument is given" do
+    lambda { Polecat::Term.new }.should raise_error
+  end
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification 
+name: polecat
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Gibheer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-06 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: reek
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  prerelease: false
+  type: :development
+  version_requirements: *id006
+description: This is a search library for searching terms in documents
+email: gibheer@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/polecat.rb
+- lib/polecat/document.rb
+- lib/polecat/document_resource.rb
+- lib/polecat/index_reader.rb
+- lib/polecat/index_searcher.rb
+- lib/polecat/index_writer.rb
+- lib/polecat/query.rb
+- lib/polecat/term.rb
+- polecat.gemspec
+- spec/index_reader/locked_spec.rb
+- spec/index_reader/new_spec.rb
+- spec/index_reader/read_spec.rb
+- spec/index_searcher/new_spec.rb
+- spec/index_searcher/search_spec.rb
+- spec/index_writer/add_spec.rb
+- spec/index_writer/count_spec.rb
+- spec/index_writer/create_reader_spec.rb
+- spec/index_writer/new_spec.rb
+- spec/index_writer/write_spec.rb
+- spec/polecat_spec.rb
+- spec/query/add_spec.rb
+- spec/query/new_spec.rb
+- spec/spec_helper.rb
+- spec/term/new_spec.rb
+has_rdoc: true
+homepage: http://github.com/Gibheer/polecat
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.10
+signing_key: 
+specification_version: 3
+summary: library for searching through documents
+test_files: []
+