restful_query 0.2.0 → 0.3.0

data/History.txt

@@ -1,3 +1,16 @@
+== 0.3.0 2009-08-10
+
+* Vast improvements/enhancements
+  * Added Sequel::Dataset extension: restful_query - works like the can_query named_scope
+  * Added IN and NOT IN to Condition operators - value can be split on delimiter option
+  * Changed the default behavior to storing conditions as an array of condition hashes
+  * Added ability to pass an array of :conditions to the parser, see tests for format.
+  * Added English/Human names to condition operators
+  * Added list of CONVERTABLE_VALUES which are prefixed w/ : and are converted to their true ruby counterparts (nil, null, true, etc)
+  * Added operators for IS and IS NOT
+  * Added neq/!= operator to conditions
+  * Added a clear_default_sort! action that deletes the default before switching
+
 == 0.2.0 2009-03-20
 
 * 1 major enhancement:

data/Manifest.txt

@@ -9,6 +9,7 @@ lib/restful_query/can_query.rb
 lib/restful_query/condition.rb
 lib/restful_query/parser.rb
 lib/restful_query/sort.rb
+lib/sequel/extensions/restful_query.rb
 rails/init.rb
 restful_query.gemspec
 tasks/restful_query_tasks.rake

data/README.rdoc

@@ -8,7 +8,44 @@ RestfulQuery provides a RESTful interface for easily and safely querying ActiveR
 
 == USAGE:
 
-Please see the project homepage for usage and more info:
+=== Rails/ActiveRecord:
+  
+  # as a gem, in environment.rb
+  config.gem 'restful_query'
+  
+or install the plugin.
+In your model:
+
+  class Post < ActiveRecord::Base
+    can_query
+  end
+
+In your controller:
+  
+  class PostsController < ApplicationController
+    # ...
+    def index
+      @posts = Post.restful_query(params[:query])
+    end
+    # ...
+  end
+
+Now you can query your model via the URL:
+
+  /posts?query[name][like]=jon&query[_sort]=created_at-desc
+
+=== Sequel
+
+Theres also a Sequel extension that works very similar to ActiveRecord::Base.can_query:
+
+  require 'sequel/extensions/restful_query'
+  
+  DB[:posts].restful_query({'name' => {'like' => 'jon'}, '_sort' => 'created_at-desc'})
+  <Sequel::SQLite::Dataset: "SELECT * FROM `posts` WHERE (name LIKE %jon%) ORDER BY `created_at` DESC">
+
+=== More!
+
+Please see the project homepage for detailed usage and info:
 
 http://code.quirkey.com/restful_query
 
@@ -24,6 +61,8 @@ or from github:
   
 To install as a rails plugin
   
+  ./script/plugin install git://github.com/quirkey/restful_query.git
+  
 == LICENSE:
 
 Free for use under the terms of the MIT License - see LICENSE for details

data/Rakefile

@@ -1,17 +1,18 @@
-%w[rubygems rake rake/clean fileutils newgem rubigen].each { |f| require f }
+%w[rubygems rake rake/clean hoe fileutils newgem rubigen].each { |f| require f }
 require File.dirname(__FILE__) + '/lib/restful_query'
 
 # Generate all the Rake tasks
 # Run 'rake -T' to see list of generated tasks (from gem root directory)
-$hoe = Hoe.new('restful_query', RestfulQuery::VERSION) do |p|
+$hoe = Hoe.spec('restful_query') do |p|
+  p.version = RestfulQuery::VERSION
   p.developer('Aaron Quint', 'aaron@quirkey.com')
   p.changes              = p.paragraphs_of("History.txt", 0..1).join("\n\n")
   p.rubyforge_name       = 'quirkey'
-  p.description = p.summary = 'Simple ActiveRecord queries from a RESTful and safe interface'
+  p.summary              = 'Simple ActiveRecord and Sequel queries from a RESTful and safe interface'
+  p.description          = %q{RestfulQuery provides a simple interface in front of a complex parser to parse specially formatted query hashes into complex SQL queries. It includes ActiveRecord and Sequel extensions.}
   p.url                  = 'http://code.quirkey.com/restful_query'
   p.extra_deps         = [
     ['activesupport','>= 2.2.0'],
-    ['activerecord','>= 2.2.0'],
     ['chronic','>= 0.2.3']
   ]
   p.extra_dev_deps = [

data/lib/restful_query/condition.rb

@@ -5,33 +5,51 @@ module RestfulQuery
     attr_reader :column, :value, :operator, :options
     
     OPERATOR_MAPPING = {
-      'lt'   => '<',
-      'gt'   => '>',
-      'gteq' => '>=',
-      'lteq' => '<=',
-      'eq'   => '=',
-      'like' => 'LIKE'
+      'lt'    => '<',
+      'gt'    => '>',
+      'gteq'  => '>=',
+      'lteq'  => '<=',
+      'eq'    => '=',
+      'neq'   => '!=',
+      'is'    => 'IS',
+      'not'   => 'IS NOT',
+      'like'  => 'LIKE',
+      'in'    => 'IN',
+      'notin' => 'NOT IN'
     }.freeze
-      
-    REVERSE_OPERATOR_MAPPING = {
-      '<'    => 'lt', 
-      '>'    => 'gt',  
-      '>='   => 'gteq',
-      '<='   => 'lteq',
-      '='    => 'eq',
-      'LIKE' => 'like'
+    
+    CONVERTABLE_VALUES = {
+      ':true'  => true,
+      ':false' => false,
+      ':nil'   => nil,
+      ':null'  => nil
+    }.freeze
+    
+    ENGLISH_OPERATOR_MAPPING = {
+      'Less than'                => 'lt',
+      'Greater than'             => 'gt',
+      'Less than or equal to'    => 'lteq',
+      'Greater than or equal to' => 'gteq',
+      'Equal to'                 => 'eq',
+      'Not equal to'             => 'neq',
+      'Is'                       => 'is',
+      'Is not'                   => 'not',
+      'Like'                     => 'like',
+      'In'                       => 'in',
+      'Not in'                   => 'notin'
     }.freeze
     
+    
     def initialize(column, value, operator = '=', options = {})
       @options = {}
-      @options = options if options.is_a?(Hash)
+      self.options  = options if options.is_a?(Hash)
       self.column   = column
-      self.value    = value
       self.operator = operator
+      self.value    = value
     end
     
     def map_operator(operator_to_look_up, reverse = false)
-      mapping = reverse ?  REVERSE_OPERATOR_MAPPING.dup : OPERATOR_MAPPING.dup
+      mapping = reverse ?  OPERATOR_MAPPING.dup.invert : OPERATOR_MAPPING.dup
       return operator_to_look_up if mapping.values.include?(operator_to_look_up)
       found = mapping[operator_to_look_up.to_s]
     end
@@ -49,26 +67,39 @@ module RestfulQuery
       @value = parse_value(value)
     end
     
+    def options=(options)
+      options.each {|k, v| @options[k.to_sym] = v }
+    end
+    
     def to_hash
       {column => {map_operator(operator, true) => value}}
     end
     
     def to_condition_array
-      parsed_value = if operator == 'LIKE' 
-          "%#{value}%"
-        elsif options[:integer]
-          value.to_i
-        else
-          value
-        end
-      ["#{column} #{operator} ?", parsed_value]
+      ["#{column} #{operator} #{placeholder}", value]
+    end
+    
+    def placeholder
+      if ['IN', 'NOT IN'].include?(operator)
+        '(?)'
+      else
+        '?'
+      end
     end
     
     protected
     def parse_value(value)
-      if options[:chronic]
+      if operator == 'LIKE' 
+        "%#{value}%"
+      elsif ['IN', 'NOT IN'].include?(operator) && !value.is_a?(Array)
+        value.split(options[:delimiter] || ',')
+      elsif options[:integer]
+        value.to_i
+      elsif options[:chronic]
         Chronic.parse(value.to_s)
-      else 
+      elsif value =~ /^\:/ && CONVERTABLE_VALUES.has_key?(value)
+        CONVERTABLE_VALUES[value]
+      else
         value
       end
     end

data/lib/restful_query/parser.rb

@@ -1,16 +1,17 @@
 module RestfulQuery
   class Parser
-    attr_reader :query_hash, :exclude_columns, :integer_columns, :options
+    attr_reader :query, :exclude_columns, :integer_columns, :options
 
-    def initialize(query_hash, options = {})
+    def initialize(query, options = {})
       @options         = options || {}
       @exclude_columns = options[:exclude_columns] ? [options.delete(:exclude_columns)].flatten.collect {|c| c.to_s } : []
       @integer_columns = options[:integer_columns] ? [options.delete(:integer_columns)].flatten.collect {|c| c.to_s } : []
       @default_sort    = options[:default_sort] ? [Sort.parse(options[:default_sort])] : []
-      @query_hash      = (query_hash || {}).dup
-      @default_join    = @query_hash.delete(:join) || :and
+      @single_sort     = options[:single_sort] || false
+      @query           = (query || {}).dup
+      @default_join    = @query.delete(:join) || :and
       extract_sorts_from_conditions
-      map_hash_to_conditions
+      map_conditions
     end
 
     def conditions
@@ -39,9 +40,8 @@ module RestfulQuery
     end
     
     def to_query_hash
-      hash = @query_hash
-      hash['join'] = @default_join
-      hash['_sort'] = sorts.collect {|s| s.to_s }
+      hash = @query
+      hash['_sort'] = sorts.collect {|s| s.to_s } unless sorts.empty?
       hash
     end
         
@@ -87,6 +87,10 @@ module RestfulQuery
       end
       new_sort
     end
+    
+    def clear_default_sort!
+      @sorts.reject! {|s| s == @default_sort.first }
+    end
 
     protected
     def add_condition_for(column, condition)
@@ -107,26 +111,37 @@ module RestfulQuery
     end
     
     def extract_sorts_from_conditions
-      @sorts = self.class.sorts_from_hash(@query_hash.delete('_sort'))
+      @sorts = self.class.sorts_from_hash(@query.delete('_sort'))
       @sorts = @default_sort if @sorts.empty?
     end
 
-    def map_hash_to_conditions
-      @query_hash.each do |column, hash_conditions|
-        unless exclude_columns.include?(column.to_s)
-          condition_options = {}
-          condition_options[:chronic] = true if chronic_columns.include?(column.to_s)
-          condition_options[:integer] = true if integer_columns.include?(column.to_s)
+    def map_conditions
+      conditions = query.delete(:conditions) || query
+      if conditions.is_a?(Hash)
+        conditions_array = []
+        conditions.each do |column, hash_conditions|
           if hash_conditions.is_a?(Hash)
             hash_conditions.each do |operator, value|
-              add_condition_for(column, Condition.new(column, value, operator, condition_options))
+              conditions_array << {'column' => column, 'operator' => operator, 'value' => value}
             end
           else
-            add_condition_for(column, Condition.new(column, hash_conditions, '=', condition_options))
+            conditions_array << {'column' => column, 'value' => hash_conditions}
           end
         end
+        conditions = conditions_array
+      end
+      # with a normalized array of conditions
+      conditions.each do |condition|
+        column, operator, value = condition['column'], condition['operator'] || 'eq', condition['value']
+        unless exclude_columns.include?(column.to_s)
+          condition_options = {}
+          condition_options[:chronic] = true if chronic_columns.include?(column.to_s)
+          condition_options[:integer] = true if integer_columns.include?(column.to_s)
+          condition_options.merge!(condition['options'] || {})
+          add_condition_for(column, Condition.new(column, value, operator, condition_options))
+        end
       end
     end
-
+     
   end
 end

data/lib/restful_query/sort.rb

@@ -2,6 +2,8 @@ module RestfulQuery
   class InvalidDirection < Error; end
   
   class Sort
+    include Comparable
+    
     attr_reader :column, :direction
     
     DIRECTIONS = {
@@ -19,7 +21,7 @@ module RestfulQuery
       self.direction = direction
     end
     
-    def self.parse(sort_string, split_on = /-|\ /)
+    def self.parse(sort_string, split_on = /\-|\ /)
       return unless sort_string
       column, direction = sort_string.split(split_on)
       new(column, direction)
@@ -38,6 +40,11 @@ module RestfulQuery
       direction == 'ASC' ? 'DESC' : 'ASC'
     end
     
+    def ==(other)
+      return false unless other.is_a?(Sort)
+      column == other.column && direction == other.direction
+    end
+    
     # Makes a roundabout for directions nil -> desc -> asc -> nil
     def self.next_direction(current_direction)
       case current_direction.to_s.downcase

data/lib/restful_query.rb

@@ -11,12 +11,12 @@ rescue LoadError
 end
 
 module RestfulQuery
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
   
   class Error < RuntimeError; end
 end
 
 
-%w{condition sort parser can_query}.each do |lib|
+%w{condition sort parser}.each do |lib|
   require File.join("restful_query","#{lib}.rb")
 end

data/lib/sequel/extensions/restful_query.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'restful_query.rb')
+
+module RestfulQuery
+  class Sort
+    
+    def to_sequel
+      column.to_sym.send(direction.downcase)
+    end
+    
+  end
+end
+
+module Sequel
+  class Dataset
+        
+    def restful_query(query_hash, options = {})
+      parser = RestfulQuery::Parser.new(query_hash, options = {})
+      collection = self
+      collection = collection.filter(*parser.to_conditions_array) if parser.has_conditions?
+      collection = collection.order(*parser.sorts.collect {|s| s.to_sequel }) if parser.has_sort?
+      collection
+    end
+  end
+  
+end

data/rails/init.rb

@@ -1,3 +1,4 @@
 require File.join(File.dirname(__FILE__),'..','lib','restful_query.rb')
+require File.join(File.dirname(__FILE__),'..','lib','restful_query', 'can_query.rb')
 
 ActiveRecord::Base.send(:include, RestfulQuery::CanQuery)

data/restful_query.gemspec

@@ -2,49 +2,45 @@
 
 Gem::Specification.new do |s|
   s.name = %q{restful_query}
-  s.version = "0.2.0"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Aaron Quint"]
-  s.date = %q{2009-03-21}
-  s.description = %q{Simple ActiveRecord queries from a RESTful and safe interface}
+  s.date = %q{2009-08-10}
+  s.description = %q{RestfulQuery provides a simple interface in front of a complex parser to parse specially formatted query hashes into complex SQL queries. It includes ActiveRecord and Sequel extensions.}
   s.email = ["aaron@quirkey.com"]
-  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.rdoc"]
-  s.files = ["History.txt", "LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "init.rb", "lib/restful_query.rb", "lib/restful_query/can_query.rb", "lib/restful_query/condition.rb", "lib/restful_query/parser.rb", "lib/restful_query/sort.rb", "rails/init.rb", "restful_query.gemspec", "tasks/restful_query_tasks.rake", "test/test_helper.rb", "test/test_restful_query_can_query.rb", "test/test_restful_query_condition.rb", "test/test_restful_query_parser.rb", "test/test_restful_query_sort.rb"]
-  s.has_rdoc = true
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt"]
+  s.files = ["History.txt", "LICENSE", "Manifest.txt", "README.rdoc", "Rakefile", "init.rb", "lib/restful_query.rb", "lib/restful_query/can_query.rb", "lib/restful_query/condition.rb", "lib/restful_query/parser.rb", "lib/restful_query/sort.rb", "lib/sequel/extensions/restful_query.rb", "rails/init.rb", "restful_query.gemspec", "tasks/restful_query_tasks.rake", "test/test_helper.rb", "test/test_restful_query_can_query.rb", "test/test_restful_query_condition.rb", "test/test_restful_query_parser.rb", "test/test_restful_query_sort.rb"]
   s.homepage = %q{http://code.quirkey.com/restful_query}
-  s.rdoc_options = ["--main", "README.rdoc"]
+  s.rdoc_options = ["--main", "README.txt"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{quirkey}
-  s.rubygems_version = %q{1.3.1}
-  s.summary = %q{Simple ActiveRecord queries from a RESTful and safe interface}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Simple ActiveRecord and Sequel queries from a RESTful and safe interface}
   s.test_files = ["test/test_helper.rb", "test/test_restful_query_can_query.rb", "test/test_restful_query_condition.rb", "test/test_restful_query_parser.rb", "test/test_restful_query_sort.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 2
+    s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<activesupport>, [">= 2.2.0"])
-      s.add_runtime_dependency(%q<activerecord>, [">= 2.2.0"])
       s.add_runtime_dependency(%q<chronic>, [">= 0.2.3"])
-      s.add_development_dependency(%q<newgem>, [">= 1.2.3"])
+      s.add_development_dependency(%q<newgem>, [">= 1.5.2"])
       s.add_development_dependency(%q<Shoulda>, [">= 1.2.0"])
-      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+      s.add_development_dependency(%q<hoe>, [">= 2.3.3"])
     else
       s.add_dependency(%q<activesupport>, [">= 2.2.0"])
-      s.add_dependency(%q<activerecord>, [">= 2.2.0"])
       s.add_dependency(%q<chronic>, [">= 0.2.3"])
-      s.add_dependency(%q<newgem>, [">= 1.2.3"])
+      s.add_dependency(%q<newgem>, [">= 1.5.2"])
       s.add_dependency(%q<Shoulda>, [">= 1.2.0"])
-      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+      s.add_dependency(%q<hoe>, [">= 2.3.3"])
     end
   else
     s.add_dependency(%q<activesupport>, [">= 2.2.0"])
-    s.add_dependency(%q<activerecord>, [">= 2.2.0"])
     s.add_dependency(%q<chronic>, [">= 0.2.3"])
-    s.add_dependency(%q<newgem>, [">= 1.2.3"])
+    s.add_dependency(%q<newgem>, [">= 1.5.2"])
     s.add_dependency(%q<Shoulda>, [">= 1.2.0"])
-    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    s.add_dependency(%q<hoe>, [">= 2.3.3"])
   end
-end
+end

data/test/test_restful_query_condition.rb

@@ -59,6 +59,68 @@ class RestfulQueryConditionTest < Test::Unit::TestCase
           assert_equal(1.week.ago.to_s, @condition.value.to_s)
         end
       end
+      
+      context "with a value of ':nil'" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', ':nil')
+        end
+        
+        should "convert value to true nil" do
+          assert_equal(nil, @condition.value)
+        end
+      end
+      
+      context "with a value of ':true'" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', ':true')
+        end
+        
+        should "convert value to true true" do
+          assert_equal(true, @condition.value)
+        end
+      end
+      
+      context "with the IN operator" do
+        setup do
+          @condition = RestfulQuery::Condition.new('year', '1995,2005,2006', 'in')
+        end
+        
+        should "assign the operator" do
+          assert_equal 'IN', @condition.operator
+        end
+        
+        should "split values by the delimiter option" do
+          assert_equal ['1995', '2005', '2006'], @condition.value
+        end
+        
+        should "include parens in placeholder" do
+          assert_equal ["year IN (?)", ['1995', '2005', '2006']], @condition.to_condition_array
+        end
+        
+        context "when the value is already an array" do
+          setup do
+            @condition = RestfulQuery::Condition.new('year', ['1995', '2005', '2006'], 'in')
+          end
+          
+          should "not resplit the value" do
+            assert_equal ['1995', '2005', '2006'], @condition.value
+          end
+        end
+      end
+      
+      context "with the NOT IN operator" do
+        setup do
+          @condition = RestfulQuery::Condition.new('year', '1995|2005|2006', 'notin', :delimiter => '|')
+        end
+        
+        should "assign the operator" do
+          assert_equal 'NOT IN', @condition.operator
+        end
+        
+        should "split values by delimiter option" do
+          assert_equal ['1995', '2005', '2006'], @condition.value
+        end
+      end
     end
 
 

data/test/test_restful_query_parser.rb

@@ -19,7 +19,7 @@ class RestfulQueryParserTest < Test::Unit::TestCase
         end
 
         should "have a blank hash for query hash" do
-          assert_equal({}, @parser.query_hash)
+          assert_equal({}, @parser.to_query_hash)
         end
       end
 
@@ -33,7 +33,7 @@ class RestfulQueryParserTest < Test::Unit::TestCase
         end
 
         should "save hash to query_hash" do
-          assert_equal @base_query_hash, @parser.query_hash.to_hash
+          assert_equal @base_query_hash, @parser.to_query_hash
         end
 
         should "save each condition as a condition object" do
@@ -177,6 +177,37 @@ class RestfulQueryParserTest < Test::Unit::TestCase
         end
       end
     end
+    
+    context "from an array of conditions" do
+      setup do
+        @array_of_conditions = [
+          {'column' => 'created_at', 'operator' => 'gt', 'value' => '1 week ago'}, 
+          {'column' => 'created_at', 'operator' => 'lt', 'value' => '1 hour ago'}, 
+          {'column' => 'updated_at', 'operator' => 'lt', 'value' => '1 day ago'}, 
+          {'column' => 'title', 'operator' => 'eq', 'value' => 'Test'}, 
+          {'column' => 'other_time', 'operator' => 'gt', 'value' => 'oct 1'},
+          {'column'  => 'name', 'value' => 'Aaron'}
+        ]
+        @parser = RestfulQuery::Parser.new(:conditions => @array_of_conditions)
+      end
+      
+      should "return parser object" do
+        assert @parser.is_a?(RestfulQuery::Parser)
+      end
+
+      should "save each condition as a condition object" do
+        assert @parser.conditions.is_a?(Array)
+        assert_equal 6, @parser.conditions.length
+        assert @parser.conditions.first.is_a?(RestfulQuery::Condition)
+      end
+
+      should "save condition without operator with default operator" do
+        assert @parser.conditions_for(:name)
+        assert @parser.conditions_for(:name).first.is_a?(RestfulQuery::Condition)
+        assert_equal '=', @parser.conditions_for(:name).first.operator
+      end
+    
+    end
 
     context "a loaded parser" do
       setup do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: restful_query
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Aaron Quint
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-21 00:00:00 -04:00
+date: 2009-08-10 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -22,16 +22,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 2.2.0
     version: 
-- !ruby/object:Gem::Dependency 
-  name: activerecord
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 2.2.0
-    version: 
 - !ruby/object:Gem::Dependency 
   name: chronic
   type: :runtime
@@ -50,7 +40,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.2.3
+        version: 1.5.2
     version: 
 - !ruby/object:Gem::Dependency 
   name: Shoulda
@@ -70,9 +60,9 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.0
+        version: 2.3.3
     version: 
-description: Simple ActiveRecord queries from a RESTful and safe interface
+description: RestfulQuery provides a simple interface in front of a complex parser to parse specially formatted query hashes into complex SQL queries. It includes ActiveRecord and Sequel extensions.
 email: 
 - aaron@quirkey.com
 executables: []
@@ -82,7 +72,6 @@ extensions: []
 extra_rdoc_files: 
 - History.txt
 - Manifest.txt
-- README.rdoc
 files: 
 - History.txt
 - LICENSE
@@ -95,6 +84,7 @@ files:
 - lib/restful_query/condition.rb
 - lib/restful_query/parser.rb
 - lib/restful_query/sort.rb
+- lib/sequel/extensions/restful_query.rb
 - rails/init.rb
 - restful_query.gemspec
 - tasks/restful_query_tasks.rake
@@ -105,10 +95,12 @@ files:
 - test/test_restful_query_sort.rb
 has_rdoc: true
 homepage: http://code.quirkey.com/restful_query
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
-- README.rdoc
+- README.txt
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -126,10 +118,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: quirkey
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
-summary: Simple ActiveRecord queries from a RESTful and safe interface
+specification_version: 3
+summary: Simple ActiveRecord and Sequel queries from a RESTful and safe interface
 test_files: 
 - test/test_helper.rb
 - test/test_restful_query_can_query.rb