pms 0.0.1

data/ChangeLog

@@ -0,0 +1,5 @@
+= Revision history for pms
+
+== 0.0.1 [2008-12-06]
+
+* Birthday :-)

data/README

@@ -0,0 +1,71 @@
+= pms - Poor Man's Search
+
+== VERSION
+
+This documentation refers to pms version 0.0.1
+
+
+== DESCRIPTION
+
+Provides a simple searching facility for (nearly) arbitrary input. It allows
+searching by Strings (exact match) or Regexps (full control, but slower).
+Boolean operators AND, OR, and NOT are supported, as well as proximity
+operators NEAR (with configurable distance) and ADJACENT (taking order into
+account). You can chain operators and also group them into sub-queries.
+
+Inspiration came from a discussion on ruby-talk, starting with message
+ruby-talk:322014[http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/322014],
+but PMS has a more document-centric attitude (everything that <tt>input#each</tt>
+yields is considered a document of its own).
+
+Example:
+
+  require 'pms/ext'
+
+  text = <<EOT
+  Hello world, how are you today? I said "Hello"
+  to the other guy but he would not answer although
+  all the world could hear me.
+  EOT
+
+  search = text.search('hello').near('world', 3)
+
+  p search.results
+  #=> [0]
+
+  p search.results_with_positions
+  #=> {0=>[0, 8]}
+
+  p search.matches
+  #=> ["Hello world, how are you today? I said \"Hello\"\n"]
+
+You can find more examples in the <tt>spec/</tt> directory.
+
+
+== LINKS
+
+* <http://pms.rubyforge.org/>
+* <http://rubyforge.org/projects/pms>
+* <http://github.com/blackwinter/pms>
+
+
+== AUTHORS
+
+* Jens Wille <mailto:jens.wille@uni-koeln.de>
+
+
+== LICENSE AND COPYRIGHT
+
+Copyright (C) 2008 Jens Wille
+
+pms is free software: you can redistribute it and/or modify it under the
+terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+
+pms is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with
+pms. If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,26 @@
+require %q{lib/pms/version}
+
+begin
+  require 'hen'
+
+  Hen.lay! {{
+    :rubyforge => {
+      :project  => %q{pms},
+      :package  => %q{pms},
+      :rdoc_dir => nil
+    },
+
+    :gem => {
+      :version      => PMS::VERSION,
+      :summary      => %q{Poor Man's Search},
+      :homepage     => %q{http://pms.rubyforge.org/},
+      :files        => FileList['lib/**/*.rb'].to_a,
+      :extra_files  => FileList['[A-Z]*', 'spec/**/*.rb', 'test_data/**/*'].to_a,
+      :dependencies => %w[]
+    }
+  }}
+rescue LoadError
+  abort "Please install the 'hen' gem first."
+end
+
+### Place your custom Rake tasks here.

data/lib/pms.rb

@@ -0,0 +1,51 @@
+#--
+###############################################################################
+#                                                                             #
+# pms - Poor Man's Search.                                                    #
+#                                                                             #
+# Copyright (C) 2008 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# pms is free software; you can redistribute it and/or modify it under the    #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# pms is distributed in the hope that it will be useful, but WITHOUT ANY      #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with pms. If not, see <http://www.gnu.org/licenses/>.                       #
+#                                                                             #
+###############################################################################
+#++
+
+require 'pms/index'
+require 'pms/proxy'
+
+class PMS
+
+  attr_reader :input, :index
+
+  def initialize(input)
+    @input = input
+    @index = Index.new(input)
+  end
+
+  def search(token = nil)
+    token ? TokenProxy.new(self, token) : Proxy.new(self).and { |*a| yield(*a) }
+  end
+
+  def results
+    @index.entries
+  end
+
+  def matches
+    @index.matches
+  end
+
+end

data/lib/pms/ext.rb

@@ -0,0 +1,49 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of pms, Poor Man's Search.                                      #
+#                                                                             #
+# Copyright (C) 2008 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# pms is free software; you can redistribute it and/or modify it under the    #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# pms is distributed in the hope that it will be useful, but WITHOUT ANY      #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with pms. If not, see <http://www.gnu.org/licenses/>.                       #
+#                                                                             #
+###############################################################################
+#++
+
+require 'pms'
+
+module PMS::Ext
+
+  RECEIVERS = [String, IO, Array].freeze
+
+  def search(*args)
+    PMS.new(self).search(*args)
+  end
+
+  RECEIVERS.each { |klass|
+    klass.send(:include, self)
+  }
+
+end
+
+class File
+
+  def self.search(file, *args)
+    File.open(file.respond_to?(:path) ? file.path : file) { |f| f.search(*args) }
+  end
+
+end

data/lib/pms/index.rb

@@ -0,0 +1,112 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of pms, Poor Man's Search.                                      #
+#                                                                             #
+# Copyright (C) 2008 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# pms is free software; you can redistribute it and/or modify it under the    #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# pms is distributed in the hope that it will be useful, but WITHOUT ANY      #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with pms. If not, see <http://www.gnu.org/licenses/>.                       #
+#                                                                             #
+###############################################################################
+#++
+
+class PMS
+
+  class Index
+
+    TOKEN_RE = %r{\w+}o
+
+    attr_reader :input, :index, :entries
+
+    def initialize(input)
+      raise ArgumentError, "input must implement #each" unless input.respond_to?(:each)
+
+      @input = input
+      @index = Hash.new { |h, k| h[k] = Hash.new { |i, j| i[j] = [] } }
+
+      build_index
+    end
+
+    def doc_nums_with_positions(token)
+      case token
+        when String
+          index[mangle_token(token)]
+        when Regexp
+          res = {}
+
+          index.each { |key, value|
+            res.update(value) { |_, old, new| old | new } if key =~ token
+          }
+
+          res
+        else
+          raise TypeError, "expected String or Regexp, got #{token.class}"
+      end
+    end
+
+    alias_method :results_with_positions, :doc_nums_with_positions
+
+    def doc_nums(token)
+      doc_nums_with_positions(token).keys
+    end
+
+    alias_method :results, :doc_nums
+
+    def documents(doc_nums = default = Object.new)
+      @documents ||= get_documents
+      default ? @documents : doc_nums.map { |doc_num| @documents[doc_num] }
+    end
+
+    alias_method :matches, :documents
+
+    def doc(doc_num)
+      documents([doc_num]).first
+    end
+
+    alias_method :[], :doc
+
+    private
+
+    def build_index
+      @documents, @entries = nil, []
+      doc_num = -1
+
+      input.each { |doc|
+        @entries << doc_num += 1
+        pos = -1
+
+        doc.scan(TOKEN_RE) { |token|
+          index[mangle_token(token)][doc_num] << pos += 1
+        }
+      }
+    end
+
+    def get_documents
+      input.rewind if input.respond_to?(:rewind)
+
+      docs = []
+      input.each { |doc| docs << doc }
+      docs
+    end
+
+    def mangle_token(token)
+      token.downcase
+    end
+
+  end
+
+end

data/lib/pms/proxy.rb

@@ -0,0 +1,133 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of pms, Poor Man's Search.                                      #
+#                                                                             #
+# Copyright (C) 2008 Jens Wille                                               #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# pms is free software; you can redistribute it and/or modify it under the    #
+# terms of the GNU General Public License as published by the Free Software   #
+# Foundation; either version 3 of the License, or (at your option) any later  #
+# version.                                                                    #
+#                                                                             #
+# pms is distributed in the hope that it will be useful, but WITHOUT ANY      #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more       #
+# details.                                                                    #
+#                                                                             #
+# You should have received a copy of the GNU General Public License along     #
+# with pms. If not, see <http://www.gnu.org/licenses/>.                       #
+#                                                                             #
+###############################################################################
+#++
+
+class PMS
+
+  class Proxy
+
+    attr_reader :pms, :index, :results
+
+    def initialize(pms)
+      @pms     = pms
+      @index   = pms.index
+      @results = pms.results
+    end
+
+    def and(token = nil)
+      token ? apply_operator_with_token('and', token) :
+              apply_operator_with_block('and') { |*a| yield(*a) }
+    end
+
+    def or(token = nil)
+      token ? apply_operator_with_token('or', token) :
+              apply_operator_with_block('or') { |*a| yield(*a) }
+    end
+
+    def not(token = nil)
+      token ? apply_operator_with_token('not', token) :
+              apply_operator_with_block('not') { |*a| yield(*a) }
+    end
+
+    def matches
+      index.matches(results)
+    end
+
+    private
+
+    def apply_operator_with_token(op, token)
+      apply_operator(op, index.results(token))
+    end
+
+    def apply_operator_with_block(op)
+      case sub = yield(pms)
+        when Proxy
+          apply_operator(op, sub.results)
+        else
+          raise "sub-query must return a PMS::Proxy object (got #{sub.class})"
+      end
+    end
+
+    def apply_operator(op, doc_nums)
+      case op = op.to_s.downcase
+        when 'and'
+          @results &= doc_nums
+        when 'or'
+          @results |= doc_nums
+        when 'not'
+          @results -= doc_nums
+        else
+          raise ArgumentError, "invalid operator '#{op}'"
+      end
+
+      self  # allow chaining!
+    end
+
+  end
+
+  class TokenProxy < Proxy
+
+    attr_reader :token, :results_with_positions
+
+    def initialize(pms, token)
+      super(pms)
+
+      @token = token
+
+      @results_with_positions = index.results_with_positions(token)
+      @results = @results_with_positions.keys
+    end
+
+    def near(token, distance = 1, order = false)
+      results1 = results_with_positions
+      results2 = index.results_with_positions(token)
+
+      doc_nums = results1.keys & results2.keys
+
+      # TODO: i'm sure this can be simplified...
+      doc_nums.delete_if { |doc_num|
+        positions = results2[doc_num]
+
+        !results1[doc_num].any? { |pos1|
+          positions.find { |pos2|
+            diff = pos2 - pos1
+
+            break if order && diff < 0
+
+            diff.abs <= distance
+          }
+        }
+      }
+
+      apply_operator('and', doc_nums)
+    end
+
+    def adjacent(token, distance = 1)
+      near(token, distance, true)
+    end
+
+  end
+
+end