searchable_record 0.0.2 → 0.0.3

data/spec/searchable_record_spec.rb

@@ -1,6 +1,6 @@
-require File.join(File.dirname(__FILE__) + '/searchable_record_spec_helper')
-require 'logger'
-require 'searchable_record'
+require File.join(File.dirname(__FILE__) + "/searchable_record_spec_helper")
+require "logger"
+require "searchable_record"
 
 class Record; include SearchableRecord; end
 
@@ -12,9 +12,9 @@ describe SearchableRecord, "for finding queried records" do
 
   it "should be able to modify default settings" do
     new_settings = {
-      :cast_since_as     => 'time',
-      :cast_until_as     => 'date',
-      :pattern_operator  => 'regexp',
+      :cast_since_as     => "time",
+      :cast_until_as     => "date",
+      :pattern_operator  => "regexp",
       :pattern_converter => lambda { |val| val }
     }
 
@@ -31,190 +31,190 @@ describe SearchableRecord, "for finding queried records" do
     Record.expects(:find).times(2).with(:all, { })
 
     Record.find_queried(:all, { }, { })
-    Record.find_queried(:all, { :foo => 'bar' }, { })
+    Record.find_queried(:all, { :foo => "bar" }, { })
   end
 
   it "should execute find with a positive offset parameter" do
     Record.expects(:find).times(1).with(:all, { :offset => 1 })
 
-    Record.find_queried(:all, { :offset => '1' }, { :offset => nil })
+    Record.find_queried(:all, { :offset => "1" }, { :offset => nil })
 
     Record.expects(:find).times(2).with(:all, { :offset => 4 })
 
-    Record.find_queried(:all, { :offset => '4' }, { :offset => nil })
-    Record.find_queried(:all, { :offset => '4', :limit => '3' }, { :offset => nil })
+    Record.find_queried(:all, { :offset => "4" }, { :offset => nil })
+    Record.find_queried(:all, { :offset => "4", :limit => "3" }, { :offset => nil })
   end
 
   it "should discard other than positive offset parameters" do
     Record.expects(:find).times(4).with(:all, { })
 
     Record.find_queried(:all, { },                  { :offset => nil })
-    Record.find_queried(:all, { :offset => 'aii' }, { :offset => nil })
-    Record.find_queried(:all, { :offset => '0' },   { :offset => nil })
-    Record.find_queried(:all, { :offset => '-1' },  { :offset => nil })
+    Record.find_queried(:all, { :offset => "aii" }, { :offset => nil })
+    Record.find_queried(:all, { :offset => "0" },   { :offset => nil })
+    Record.find_queried(:all, { :offset => "-1" },  { :offset => nil })
   end
 
   it "should execute find with a positive limit parameter" do
     Record.expects(:find).times(1).with(:all, { :limit => 1 })
 
-    Record.find_queried(:all, { :limit => '1' }, { :limit => nil })
+    Record.find_queried(:all, { :limit => "1" }, { :limit => nil })
 
     Record.expects(:find).times(2).with(:all, { :limit => 4 })
 
-    Record.find_queried(:all, { :limit => '4' }, { :limit => nil })
-    Record.find_queried(:all, { :limit => '4', :offset => '3' }, { :limit => nil })
+    Record.find_queried(:all, { :limit => "4" }, { :limit => nil })
+    Record.find_queried(:all, { :limit => "4", :offset => "3" }, { :limit => nil })
   end
 
   it "should discard other than positive limit parameters" do
     Record.expects(:find).times(4).with(:all, { })
 
     Record.find_queried(:all, { },                 { :limit => nil })
-    Record.find_queried(:all, { :limit => 'aii' }, { :limit => nil })
-    Record.find_queried(:all, { :limit => '0' },   { :limit => nil })
-    Record.find_queried(:all, { :limit => '-1' },  { :limit => nil })
+    Record.find_queried(:all, { :limit => "aii" }, { :limit => nil })
+    Record.find_queried(:all, { :limit => "0" },   { :limit => nil })
+    Record.find_queried(:all, { :limit => "-1" },  { :limit => nil })
   end
 
   it "should execute find with sort parameter" do
-    Record.expects(:find).times(1).with(:all, { :order => 'users.first_name' })
+    Record.expects(:find).times(1).with(:all, { :order => "users.first_name" })
 
-    Record.find_queried(:all, { :sort => 'first_name' },
-                              { :sort => { 'first_name' => 'users.first_name' } })
+    Record.find_queried(:all, { :sort => "first_name" },
+                              { :sort => { "first_name" => "users.first_name" } })
   end
 
   it "should execute find with reverse sort parameter" do
-    Record.expects(:find).times(1).with(:all, { :order  => 'users.first_name desc' })
+    Record.expects(:find).times(1).with(:all, { :order  => "users.first_name desc" })
 
-    Record.find_queried(:all, { :rsort => 'first_name' },
-                              { :sort  => { 'first_name' => 'users.first_name' },
+    Record.find_queried(:all, { :rsort => "first_name" },
+                              { :sort  => { "first_name" => "users.first_name" },
                                 :rsort => nil })
   end
 
   it "should raise an exception if rsort is specified without sort rule" do
-    lambda { Record.find_queried(:all, { :rsort => 'first_name' },
-             { :rsort  => { 'first_name' => 'users.first_name' } }) }.should raise_error(ArgumentError)
+    lambda { Record.find_queried(:all, { :rsort => "first_name" },
+             { :rsort  => { "first_name" => "users.first_name" } }) }.should raise_error(ArgumentError)
   end
 
-  it "should execute find with sort parameter, favoring 'sort' over 'rsort'" do
-    Record.expects(:find).times(1).with(:all, { :order  => 'users.first_name' })
+  it "should execute find with sort parameter, favoring \"sort\" over \"rsort\"" do
+    Record.expects(:find).times(1).with(:all, { :order  => "users.first_name" })
 
-    Record.find_queried(:all, { :sort => 'first_name', :rsort => 'last_name' },
-                              { :sort  => { 'first_name' => 'users.first_name',
-                                            'last_name'  => 'users.last_name' },
+    Record.find_queried(:all, { :sort => "first_name", :rsort => "last_name" },
+                              { :sort  => { "first_name" => "users.first_name",
+                                            "last_name"  => "users.last_name" },
                                 :rsort => nil })
   end
 
   it "should discard other than specified sort parameters" do
     Record.expects(:find).times(1).with(:all, {  })
 
-    Record.find_queried(:all, { :sort => 'first' },
-                              { :sort => { 'first_name' => 'users.first_name' } })
+    Record.find_queried(:all, { :sort => "first" },
+                              { :sort => { "first_name" => "users.first_name" } })
 
-    Record.expects(:find).times(1).with(:all, { :order => 'users.last_name desc' })
+    Record.expects(:find).times(1).with(:all, { :order => "users.last_name desc" })
 
-    Record.find_queried(:all, { :sort  => 'last', :rsort => 'last_name' },
-                              { :sort  => { 'first_name' => 'users.first_name',
-                                            'last_name'  => 'users.last_name' },
+    Record.find_queried(:all, { :sort  => "last", :rsort => "last_name" },
+                              { :sort  => { "first_name" => "users.first_name",
+                                            "last_name"  => "users.last_name" },
                                 :rsort => nil })
   end
 
   it "should execute find with since parameter, with default settings" do
-    Record.expects(:find).times(2).with(:all, { :conditions => [ '(users.created_at >= cast(:since as datetime))',
-                                                                 { :since => '2008-02-26' } ] })
+    Record.expects(:find).times(2).with(:all, { :conditions => [ "(users.created_at >= cast(:since as datetime))",
+                                                                 { :since => "2008-02-26" } ] })
 
-    Record.find_queried(:all, { :since => '2008-02-26' },
-                              { :since => 'users.created_at' })
-    Record.find_queried(:all, { :since => '2008-02-26' },
-                              { :since => { :column => 'users.created_at' } })
+    Record.find_queried(:all, { :since => "2008-02-26" },
+                              { :since => "users.created_at" })
+    Record.find_queried(:all, { :since => "2008-02-26" },
+                              { :since => { :column => "users.created_at" } })
   end
 
   it "should execute find with since parameter, with custom settings" do
-    Record.expects(:find).times(3).with(:all, { :conditions => [ '(users.time >= cast(:since as time))',
-                                                                 { :since => '11:04' } ] })
+    Record.expects(:find).times(3).with(:all, { :conditions => [ "(users.time >= cast(:since as time))",
+                                                                 { :since => "11:04" } ] })
 
-    Record.find_queried(:all, { :since => '11:04' },
-                              { :since => { :column  => 'users.time',
-                                            :cast_as => 'time' } })
+    Record.find_queried(:all, { :since => "11:04" },
+                              { :since => { :column  => "users.time",
+                                            :cast_as => "time" } })
 
     org_settings = Record.searchable_record_settings.dup
-    Record.searchable_record_settings[:cast_since_as] = 'time'
+    Record.searchable_record_settings[:cast_since_as] = "time"
 
-    Record.find_queried(:all, { :since => '11:04' },
-                              { :since => 'users.time'})
+    Record.find_queried(:all, { :since => "11:04" },
+                              { :since => "users.time"})
 
-    Record.find_queried(:all, { :since => '11:04' },
-                              { :since => { :column  => 'users.time' } })
+    Record.find_queried(:all, { :since => "11:04" },
+                              { :since => { :column  => "users.time" } })
 
     Record.searchable_record_settings = org_settings
   end
 
   it "should execute find with until parameter, with default settings" do
-    Record.expects(:find).times(2).with(:all, { :conditions => [ '(users.created_at <= cast(:until as datetime))',
-                                                                 { :until => '2008-04-28' } ] })
+    Record.expects(:find).times(2).with(:all, { :conditions => [ "(users.created_at <= cast(:until as datetime))",
+                                                                 { :until => "2008-04-28" } ] })
 
-    Record.find_queried(:all, { :until => '2008-04-28' },
-                              { :until => 'users.created_at' })
-    Record.find_queried(:all, { :until => '2008-04-28' },
-                              { :until => { :column => 'users.created_at' } })
+    Record.find_queried(:all, { :until => "2008-04-28" },
+                              { :until => "users.created_at" })
+    Record.find_queried(:all, { :until => "2008-04-28" },
+                              { :until => { :column => "users.created_at" } })
   end
 
   it "should execute find with until parameter, with custom settings" do
-    Record.expects(:find).times(3).with(:all, { :conditions => [ '(users.time <= cast(:until as time))',
-                                                                 { :until => '13:06' } ] })
+    Record.expects(:find).times(3).with(:all, { :conditions => [ "(users.time <= cast(:until as time))",
+                                                                 { :until => "13:06" } ] })
 
-    Record.find_queried(:all, { :until => '13:06' },
-                              { :until => { :column  => 'users.time',
-                                            :cast_as => 'time' } })
+    Record.find_queried(:all, { :until => "13:06" },
+                              { :until => { :column  => "users.time",
+                                            :cast_as => "time" } })
 
     org_settings = Record.searchable_record_settings.dup
-    Record.searchable_record_settings[:cast_until_as] = 'time'
+    Record.searchable_record_settings[:cast_until_as] = "time"
 
-    Record.find_queried(:all, { :until => '13:06' },
-                              { :until => 'users.time'})
+    Record.find_queried(:all, { :until => "13:06" },
+                              { :until => "users.time"})
 
-    Record.find_queried(:all, { :until => '13:06' },
-                              { :until => { :column  => 'users.time' } })
+    Record.find_queried(:all, { :until => "13:06" },
+                              { :until => { :column  => "users.time" } })
 
     Record.searchable_record_settings = org_settings
   end
 
   it "should execute find with pattern matching parameters" do
     Record.expects(:find).times(1).with(:all, :conditions => [ "(users.first_name like :name)",
-                                                               { :name => '%john%' } ])
+                                                               { :name => "%john%" } ])
 
-    Record.find_queried(:all, { :name     => 'john' },
-                              { :patterns => { :name => 'users.first_name'} })
+    Record.find_queried(:all, { :name     => "john" },
+                              { :patterns => { :name => "users.first_name"} })
   end
 
   it "should execute find with a pattern matching parameter, with default settings" do
     Record.expects(:find).times(1).with(:all, :conditions => [ "(sites.status like :status)",
-                                                               { :status => '%active%' } ])
+                                                               { :status => "%active%" } ])
 
-    Record.find_queried(:all, { :status   => 'active' },
-                              { :patterns => { :status => 'sites.status' } })
+    Record.find_queried(:all, { :status   => "active" },
+                              { :patterns => { :status => "sites.status" } })
   end
 
   it "should execute find with a pattern matching parameter, with custom settings" do
     Record.expects(:find).times(1).with(:all, :conditions => [ "(sites.domain like :domain)",
-                                                               { :domain => '%www.example.fi%' } ])
+                                                               { :domain => "%www.example.fi%" } ])
 
-    Record.find_queried(:all, { :domain   => 'www_example_fi' },
-                              { :patterns => { :domain => { :column    => 'sites.domain',
+    Record.find_queried(:all, { :domain   => "www_example_fi" },
+                              { :patterns => { :domain => { :column    => "sites.domain",
                                                             :converter => lambda { |val| "%#{val.gsub('_', '.')}%" } } } })
 
     Record.expects(:find).times(2).with(:all, :conditions => [ "(sites.domain regexp :domain)",
-                                                               { :domain => 'www.example.fi' } ])
+                                                               { :domain => "www.example.fi" } ])
 
-    Record.find_queried(:all, { :domain   => 'www_example_fi' },
-                              { :patterns => { :domain => { :column    => 'sites.domain',
-                                                            :converter => lambda { |val| val.gsub('_', '.') },
-                                                            :operator  => 'regexp' } } })
+    Record.find_queried(:all, { :domain   => "www_example_fi" },
+                              { :patterns => { :domain => { :column    => "sites.domain",
+                                                            :converter => lambda { |val| val.gsub("_", ".") },
+                                                            :operator  => "regexp" } } })
 
     org_settings = Record.searchable_record_settings.dup
-    Record.searchable_record_settings[:pattern_operator]  = 'regexp'
-    Record.searchable_record_settings[:pattern_converter] = lambda { |val| val.gsub('_', '.') }
+    Record.searchable_record_settings[:pattern_operator]  = "regexp"
+    Record.searchable_record_settings[:pattern_converter] = lambda { |val| val.gsub("_", ".") }
 
-    Record.find_queried(:all, { :domain   => 'www_example_fi' },
-                              { :patterns => { :domain => 'sites.domain' } })
+    Record.find_queried(:all, { :domain   => "www_example_fi" },
+                              { :patterns => { :domain => "sites.domain" } })
 
     Record.searchable_record_settings = org_settings
   end
@@ -222,40 +222,40 @@ describe SearchableRecord, "for finding queried records" do
   it "should execute find with multiple pattern matching parameters" do
     results = [
      { :conditions => [ "(sites.domain like :domain) and (sites.status like :status)",
-                      { :domain => '%www.another.example.fi%',
-                        :status => '%active%' } ]},
+                      { :domain => "%www.another.example.fi%",
+                        :status => "%active%" } ]},
      { :conditions => [ "(sites.status like :status) and (sites.domain like :domain)",
-                      { :domain => '%www.another.example.fi%',
-                        :status => '%active%' } ]}
+                      { :domain => "%www.another.example.fi%",
+                        :status => "%active%" } ]}
     ]
 
     Record.expects(:find).times(1).with(:all, any_of(equals(results[0]), equals(results[1])))
 
-    Record.find_queried(:all, { :domain   => 'www_another_example_fi',
-                                :status   => 'active' },
-                              { :patterns => { :domain => { :column    => 'sites.domain',
+    Record.find_queried(:all, { :domain   => "www_another_example_fi",
+                                :status   => "active" },
+                              { :patterns => { :domain => { :column    => "sites.domain",
                                                             :converter => lambda { |val| "%#{val.gsub('_', '.')}%" } },
-                                               :status => 'sites.status' } })
+                                               :status => "sites.status" } })
   end
 
   it "should preserve additional options" do
     Record.expects(:find).times(1).with(:all, :include => [ :affiliates ],
                                         :conditions => [ "(sites.flags = 'fo') and (sites.domain like :domain)",
-                                                         { :domain => '%www.still-works.com%' } ])
+                                                         { :domain => "%www.still-works.com%" } ])
 
-    Record.find_queried(:all, { :domain     => 'www_still-works_com' },
-                              { :patterns   => { :domain => { :column    => 'sites.domain',
+    Record.find_queried(:all, { :domain     => "www_still-works_com" },
+                              { :patterns   => { :domain => { :column    => "sites.domain",
                                                               :converter => lambda { |val| "%#{val.gsub('_', '.')}%" } } } },
                               { :conditions => "sites.flags = 'fo'",
                                 :include    => [ :affiliates ] })
 
     Record.expects(:find).times(1).with(:all, :include => [ :affiliates ],
                                         :conditions => [ "(sites.flags = 'fo') and (users.time <= cast(:until as time))",
-                                                         { :until => '13:06' } ])
+                                                         { :until => "13:06" } ])
 
-    Record.find_queried(:all, { :until      => '13:06' },
-                              { :until      => { :column  => 'users.time',
-                                                 :cast_as => 'time' } },
+    Record.find_queried(:all, { :until      => "13:06" },
+                              { :until      => { :column  => "users.time",
+                                                 :cast_as => "time" } },
                               { :conditions => "sites.flags = 'fo'",
                                 :include    => [ :affiliates ] })
   end
@@ -265,29 +265,29 @@ describe SearchableRecord, "for finding queried records" do
 
     Item.expects(:find).times(1).with(:all,
                                       :include => [ :owners ],
-                                      :order   => 'items.name desc',
+                                      :order   => "items.name desc",
                                       :offset  => 4,
                                       :limit   => 5,
                                       :conditions => [ "(items.flag = 'f') and (items.created_at <= cast(:until as datetime)) and (items.name like :name)",
-                                                       { :until => '2008-02-28', :name => '%foo.bar%' } ])
+                                                       { :until => "2008-02-28", :name => "%foo.bar%" } ])
 
     query_params = {
-      :offset => '4',
-      :limit  => '5',
-      :rsort  => 'name',
-      :until  => '2008-02-28',
-      :name   => 'foo_bar'
+      :offset => "4",
+      :limit  => "5",
+      :rsort  => "name",
+      :until  => "2008-02-28",
+      :name   => "foo_bar"
     }
 
     rules = {
       :limit    => nil,
       :offset   => nil,
-      :sort     => { 'name' => 'items.name', 'created' => 'items.created_at' },
+      :sort     => { "name" => "items.name", "created" => "items.created_at" },
       :rsort    => nil,
-      :since    => 'items.created_at',
-      :until    => 'items.created_at',
-      :patterns => { :type => 'items.type',
-                     :name => { :column    => 'items.name',
+      :since    => "items.created_at",
+      :until    => "items.created_at",
+      :patterns => { :type => "items.type",
+                     :name => { :column    => "items.name",
                                 :converter => lambda { |val| "%#{val.gsub('_', '.')}%" } } }
     }
 

data/spec/searchable_record_spec_helper.rb

@@ -1,7 +1,7 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(File.dirname(__FILE__) + "/../lib")
 
-require 'rubygems'
-require 'mocha'
+require "rubygems"
+require "mocha"
 
 Spec::Runner.configure do |config|
   config.mock_with :mocha

data/spec/util_spec.rb

@@ -1,29 +1,29 @@
-require File.join(File.dirname(__FILE__) + '/searchable_record_spec_helper')
-require 'active_support/core_ext/blank'
-require 'util'
+require File.join(File.dirname(__FILE__) + "/searchable_record_spec_helper")
+require "active_support/core_ext/blank"
+require "util"
 
 include SearchableRecord
 
 describe Util do
   it "should parse positive integers" do
-    Util.parse_positive_int('1').should == 1
-    Util.parse_positive_int('1sdfgsdf').should == 1
+    Util.parse_positive_int("1").should == 1
+    Util.parse_positive_int("1sdfgsdf").should == 1
     Util.parse_positive_int(nil).should be_nil
-    Util.parse_positive_int('0').should be_nil
-    Util.parse_positive_int('-1').should be_nil
-    Util.parse_positive_int('sdfgdfg').should be_nil
+    Util.parse_positive_int("0").should be_nil
+    Util.parse_positive_int("-1").should be_nil
+    Util.parse_positive_int("sdfgdfg").should be_nil
   end
 
   it "should prune and duplicate hashes" do
     str = "don't remove me"
 
-    Util.pruned_dup({ :excess => 'foobar', :preserve => str },  [ :preserve ]).should == { :preserve => str }
-    Util.pruned_dup({ :excess => 'foobar', 'preserve' => str }, [ :preserve ]).should == { :preserve => str }
+    Util.pruned_dup({ :excess => "foobar", :preserve => str },  [ :preserve ]).should == { :preserve => str }
+    Util.pruned_dup({ :excess => "foobar", "preserve" => str }, [ :preserve ]).should == { :preserve => str }
 
     # A contrived example of calling #to_a for the second argument.
-    Util.pruned_dup({:e => 'foobar', [ :p, str ] => str }, { :p => str }).should == { [:p, str ] => str }
+    Util.pruned_dup({:e => "foobar", [ :p, str ] => str }, { :p => str }).should == { [:p, str ] => str }
 
-    Util.pruned_dup({ :excess => 'foobar' }, [ :preserve ]).should == { }
+    Util.pruned_dup({ :excess => "foobar" }, [ :preserve ]).should == { }
     Util.pruned_dup({ }, [ ]).should == { }
     Util.pruned_dup({ }, [ :preserve ]).should == { }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: searchable_record
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Tuomas Kareinen
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-27 00:00:00 +03:00
+date: 2009-01-14 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -23,43 +23,51 @@ dependencies:
         version: "0"
     version: 
 - !ruby/object:Gem::Dependency 
-  name: hoe
+  name: echoe
   type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.7.0
+        version: "0"
     version: 
-description: "SearchableRecord is a small Ruby on Rails plugin that makes the parsing of query parameters from URLs easy for resources, allowing the requester to control the items (records) shown in the resource's representation.  The implementation is a helper module (a mixin) for ActiveRecord models. It is used by including SearchableRecord module in a model.  The mixin provides a class method, <tt>SearchableRecord#find_queried</tt>, to the class that includes it. The method is a front-end to ActiveRecord::Base#find: it parses query parameters against the given rules and calls <tt>find</tt> accordingly, returning the results of <tt>find</tt>."
+description: SearchableRecord is a small Ruby on Rails plugin that makes the parsing of query parameters from URLs easy for resources, allowing the requester to control the items (records) shown in the resource's representation.
 email: tkareine@gmail.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
-- History.txt
-- Manifest.txt
-- MIT-LICENSE.txt
-- README.txt
+- CHANGELOG.rdoc
+- lib/searchable_record/core.rb
+- lib/searchable_record/util.rb
+- lib/searchable_record/version.rb
+- lib/searchable_record.rb
+- README.rdoc
 files: 
-- History.txt
-- Manifest.txt
-- MIT-LICENSE.txt
-- Rakefile
-- README.txt
+- CHANGELOG.rdoc
+- lib/searchable_record/core.rb
+- lib/searchable_record/util.rb
+- lib/searchable_record/version.rb
 - lib/searchable_record.rb
-- lib/util.rb
-- spec/searchable_record_spec_helper.rb
+- Manifest
+- Rakefile
+- README.rdoc
 - spec/searchable_record_spec.rb
+- spec/searchable_record_spec_helper.rb
 - spec/util_spec.rb
+- searchable_record.gemspec
 has_rdoc: true
 homepage: http://searchable-rec.rubyforge.org
 post_install_message: 
 rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Searchable_record
 - --main
-- README.txt
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -72,12 +80,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
+      version: "1.2"
   version: 
 requirements: []
 
 rubyforge_project: searchable-rec
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: SearchableRecord is a small Ruby on Rails plugin that makes the parsing of query parameters from URLs easy for resources, allowing the requester to control the items (records) shown in the resource's representation.

data/History.txt

@@ -1,7 +0,0 @@
-=== 0.0.2 / 2008-08-26
-
-* Changed specs to use RSpec syntax instead of test/spec.
-
-=== 0.0.1 / 2008-03-03
-
-* First release.

data/MIT-LICENSE.txt

@@ -1,19 +0,0 @@
-Copyright (c) 2008 Tuomas Kareinen
-
-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/Manifest.txt

@@ -1,10 +0,0 @@
-History.txt
-Manifest.txt
-MIT-LICENSE.txt
-Rakefile
-README.txt
-lib/searchable_record.rb
-lib/util.rb
-spec/searchable_record_spec_helper.rb
-spec/searchable_record_spec.rb
-spec/util_spec.rb