restful_query 0.2.0

data/History.txt

@@ -0,0 +1,10 @@
+== 0.2.0 2009-03-20
+
+* 1 major enhancement:
+  * Now includes interface for sorting.
+  * Better documentation on the way.
+
+== 0.0.1 2009-01-11
+
+* 1 major enhancement:
+  * Initial release

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Aaron Quint, Quirkey NYC, LLC
+
+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

@@ -0,0 +1,19 @@
+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

data/README.rdoc

@@ -0,0 +1,29 @@
+= restful_query
+
+http://github.com/quirkey/restful_query
+
+== DESCRIPTION:
+
+RestfulQuery provides a RESTful interface for easily and safely querying ActiveRecord data. 
+
+== USAGE:
+
+Please see the project homepage for usage and more info:
+
+http://code.quirkey.com/restful_query
+
+== INSTALL:
+
+To install as a gem:
+
+  sudo gem install restful_query
+  
+or from github:
+
+  sudo gem install quirkey-restful_query -s http://gems.github.com
+  
+To install as a rails plugin
+  
+== LICENSE:
+
+Free for use under the terms of the MIT License - see LICENSE for details

data/Rakefile

@@ -0,0 +1,32 @@
+%w[rubygems rake rake/clean 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|
+  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.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 = [
+    ['newgem', ">= #{::Newgem::VERSION}"],
+    ['Shoulda', '>= 1.2.0']
+  ]
+  
+  p.clean_globs |= %w[**/.DS_Store tmp *.log]
+  path = (p.rubyforge_name == p.name) ? p.rubyforge_name : "\#{p.rubyforge_name}/\#{p.name}"
+  p.remote_rdoc_dir = File.join(path.gsub(/^#{p.rubyforge_name}\/?/,''), 'rdoc')
+  p.rsync_args = '-av --delete --ignore-errors'
+end
+
+require 'newgem/tasks' # load /tasks/*.rake
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# task :default => [:spec, :features]

data/init.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), 'rails', 'init.rb')

data/lib/restful_query/can_query.rb

@@ -0,0 +1,36 @@
+module RestfulQuery
+  module CanQuery
+   
+    def self.included(klass)
+      klass.extend MacroMethods
+    end
+
+    module MacroMethods
+      def can_query(options = {})
+        @include       = options.delete(:include) || []
+        @query_options = options
+        @can_query     = true
+        module_eval do
+          def self.restful_query_parser(query_hash, options = {})
+            RestfulQuery::Parser.new(query_hash, @query_options.merge(options))
+          end
+          
+          named_scope :restful_query, lambda {|query_hash| 
+            parser = self.restful_query_parser(query_hash)
+            query_hash = {}
+            query_hash[:conditions] = parser.to_conditions_array if parser.has_conditions?
+            query_hash[:include]    = @include if @include && !@include.empty?
+            query_hash[:order]      = parser.sort_sql if parser.has_sort?
+            logger.info 'Rest query:' + query_hash.inspect
+            query_hash
+          }
+        end
+      end
+      
+      def can_query?
+        @can_query
+      end
+    end
+    
+  end
+end

data/lib/restful_query/condition.rb

@@ -0,0 +1,77 @@
+module RestfulQuery
+  class InvalidOperator < Error; end;
+  
+  class Condition
+    attr_reader :column, :value, :operator, :options
+    
+    OPERATOR_MAPPING = {
+      'lt'   => '<',
+      'gt'   => '>',
+      'gteq' => '>=',
+      'lteq' => '<=',
+      'eq'   => '=',
+      'like' => 'LIKE'
+    }.freeze
+      
+    REVERSE_OPERATOR_MAPPING = {
+      '<'    => 'lt', 
+      '>'    => 'gt',  
+      '>='   => 'gteq',
+      '<='   => 'lteq',
+      '='    => 'eq',
+      'LIKE' => 'like'
+    }.freeze
+    
+    def initialize(column, value, operator = '=', options = {})
+      @options = {}
+      @options = options if options.is_a?(Hash)
+      self.column   = column
+      self.value    = value
+      self.operator = operator
+    end
+    
+    def map_operator(operator_to_look_up, reverse = false)
+      mapping = reverse ?  REVERSE_OPERATOR_MAPPING.dup : 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
+ 
+    def operator=(operator)
+      @operator = map_operator(operator)
+      raise(RestfulQuery::InvalidOperator, "#{@operator} is not a valid operator") unless @operator
+    end
+      
+    def column=(column)
+      @column = column.to_s
+    end
+    
+    def value=(value)
+      @value = parse_value(value)
+    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]
+    end
+    
+    protected
+    def parse_value(value)
+      if options[:chronic]
+        Chronic.parse(value.to_s)
+      else 
+        value
+      end
+    end
+    
+  end
+end

data/lib/restful_query/parser.rb

@@ -0,0 +1,132 @@
+module RestfulQuery
+  class Parser
+    attr_reader :query_hash, :exclude_columns, :integer_columns, :options
+
+    def initialize(query_hash, 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
+      extract_sorts_from_conditions
+      map_hash_to_conditions
+    end
+
+    def conditions
+      conditions_hash.values.flatten
+    end
+    
+    def has_conditions?
+      !conditions.empty?
+    end
+
+    def conditions_for(column)
+      conditions_hash[column.to_s]
+    end
+
+    def to_conditions_array(join = nil)
+      join ||= @default_join
+      join_string = (join == :or) ? ' OR ' : ' AND '
+      conditions_string = []
+      conditions_values = []
+      conditions.each do |c| 
+        ca = c.to_condition_array
+        conditions_string << ca[0]
+        conditions_values << ca[1]
+      end
+      conditions_values.unshift(conditions_string.join(join_string))
+    end
+    
+    def to_query_hash
+      hash = @query_hash
+      hash['join'] = @default_join
+      hash['_sort'] = sorts.collect {|s| s.to_s }
+      hash
+    end
+        
+    def self.sorts_from_hash(sorts)
+      sort_conditions = [sorts].flatten.compact
+      sort_conditions.collect {|c| Sort.parse(c) }
+    end
+    
+    def sort_sql
+      @sorts.collect {|s| s.to_sql }.join(', ')
+    end
+    
+    def has_sort?
+      !sorts.empty?
+    end
+    
+    def sorts
+      @sorts ||= []
+    end
+    
+    def sorted_columns
+      sorts.collect {|s| s.column }
+    end
+    
+    def sorted_by?(column)
+      sorted_columns.include?(column.to_s)
+    end
+    
+    def sort(column)
+      sorts.detect {|s| s && s.column == column.to_s }
+    end
+    
+    def set_sort(column, direction)
+      if new_sort = self.sort(column)
+        if direction.nil?
+          self.sorts.reject! {|s| s.column == column.to_s }
+        else
+          new_sort.direction = direction
+        end
+      else
+        new_sort = Sort.new(column, direction)
+        self.sorts << new_sort
+      end
+      new_sort
+    end
+
+    protected
+    def add_condition_for(column, condition)
+      conditions_hash[column.to_s] ||= []
+      conditions_hash[column.to_s] << condition
+    end
+
+    def conditions_hash
+      @conditions_hash ||= {}
+    end
+
+    def chronic_columns
+      if chronic = options[:chronic]
+        chronic.is_a?(Array) ? chronic.collect {|c| c.to_s } : ['created_at', 'updated_at']
+      else
+        []
+      end
+    end
+    
+    def extract_sorts_from_conditions
+      @sorts = self.class.sorts_from_hash(@query_hash.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)
+          if hash_conditions.is_a?(Hash)
+            hash_conditions.each do |operator, value|
+              add_condition_for(column, Condition.new(column, value, operator, condition_options))
+            end
+          else
+            add_condition_for(column, Condition.new(column, hash_conditions, '=', condition_options))
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/restful_query/sort.rb

@@ -0,0 +1,65 @@
+module RestfulQuery
+  class InvalidDirection < Error; end
+  
+  class Sort
+    attr_reader :column, :direction
+    
+    DIRECTIONS = {
+      'up' => 'ASC',
+      'asc' => 'ASC',
+      'ASC' => 'ASC',
+      'down' => 'DESC',
+      'desc' => 'DESC',
+      'DESC' => 'DESC'
+    }.freeze
+    
+    
+    def initialize(column, direction)
+      self.column    = column
+      self.direction = direction
+    end
+    
+    def self.parse(sort_string, split_on = /-|\ /)
+      return unless sort_string
+      column, direction = sort_string.split(split_on)
+      new(column, direction)
+    end
+    
+    def column=(column)
+      @column = column.to_s
+    end
+    
+    def direction=(direction)
+      @direction = DIRECTIONS[direction.to_s]
+      raise(InvalidDirection, "'#{direction}' is not a valid order direction") unless @direction
+    end
+    
+    def reverse_direction
+      direction == 'ASC' ? 'DESC' : 'ASC'
+    end
+    
+    # Makes a roundabout for directions nil -> desc -> asc -> nil
+    def self.next_direction(current_direction)
+      case current_direction.to_s.downcase
+      when 'desc'
+        'asc'
+      when 'asc'
+        nil
+      else
+        'desc'
+      end
+    end
+    
+    def next_direction
+      self.class.next_direction(direction)
+    end
+    
+    def to_s(join = '-')
+      "#{column}#{join}#{direction.downcase}"
+    end
+            
+    def to_sql
+      "#{column} #{direction}"
+    end
+  end
+end

data/lib/restful_query.rb

@@ -0,0 +1,22 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+begin
+  require 'chronic'
+  unless defined?(ActiveSupport)
+    require 'active_support'
+  end
+rescue LoadError
+  warn 'In order to use the time parsing functionalities you must install the Chronic gem: sudo gem install chronic'
+end
+
+module RestfulQuery
+  VERSION = '0.2.0'
+  
+  class Error < RuntimeError; end
+end
+
+
+%w{condition sort parser can_query}.each do |lib|
+  require File.join("restful_query","#{lib}.rb")
+end

data/rails/init.rb

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

data/restful_query.gemspec

@@ -0,0 +1,50 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{restful_query}
+  s.version = "0.2.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.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.homepage = %q{http://code.quirkey.com/restful_query}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  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.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
+
+    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<Shoulda>, [">= 1.2.0"])
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    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<Shoulda>, [">= 1.2.0"])
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    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<Shoulda>, [">= 1.2.0"])
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/tasks/restful_query_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :restful_query do
+#   # Task goes here
+# end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+
+require File.join(File.dirname(__FILE__), '..', 'lib','restful_query.rb')
+
+
+unless defined?(ActiveRecord)
+  module ActiveRecord
+    class Base
+      class << self
+        attr_accessor :pluralize_table_names
+
+        def protected_attributes
+          []
+        end
+        
+        def named_scope(name, options = {})
+        end
+      end
+      self.pluralize_table_names = true
+      
+      include RestfulQuery::CanQuery
+    end
+  end
+end
+
+class ClassWithQuery < ActiveRecord::Base
+  can_query
+end
+
+class ClassWithoutQuery < ActiveRecord::Base
+  
+end

data/test/test_restful_query_can_query.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestRestfulQueryCanQuery < Test::Unit::TestCase
+
+  context "CanQuery" do
+    context "A class with the can_query macro" do
+      should "can_query?" do
+        assert ClassWithQuery.can_query?
+      end
+    end
+    
+    context "A class without the can_query macro" do
+      should "not can_query?" do
+        assert !ClassWithoutQuery.can_query?
+      end
+    end
+    
+  end
+
+end

data/test/test_restful_query_condition.rb

@@ -0,0 +1,112 @@
+require 'test_helper'
+
+class RestfulQueryConditionTest < Test::Unit::TestCase
+
+  context "Condition" do
+
+    context "initializing" do
+      context "with column, value, operator" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', '1 week ago', '>')
+        end
+
+        should "save column" do
+          assert_equal 'created_at', @condition.column
+        end
+
+        should "save value" do
+          assert_equal '1 week ago', @condition.value
+        end
+
+        should "save operator as string" do
+          assert_equal '>', @condition.operator
+        end
+
+      end
+
+      context "with no operator" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', '1 week ago')
+        end
+
+        should "assume =" do
+          assert_equal '=', @condition.operator
+        end
+
+      end
+
+      context "with an operator as a string" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', '1 week ago', 'gteq')
+        end
+
+        should "translate string to operator" do
+          assert_equal '>=', @condition.operator
+        end
+
+      end
+
+      context "with chronic => true" do
+        setup do
+          @condition = RestfulQuery::Condition.new('created_at', '1 week ago', 'gteq', :chronic => true)
+        end
+
+        should "save option to options" do
+          assert @condition.options[:chronic]
+        end
+
+        should "parse value with chronic" do
+          assert_equal(1.week.ago.to_s, @condition.value.to_s)
+        end
+      end
+    end
+
+
+    context "a Condition" do
+      setup do
+        @condition = RestfulQuery::Condition.new('title', 'Bossman', 'lt')
+      end
+      
+      context "with operator = like to condition array" do
+        setup do
+          @condition = RestfulQuery::Condition.new('title', 'Bossman', 'like')
+          @to_condition_array = @condition.to_condition_array
+        end
+        
+        should "wrap value with %" do
+          assert_equal "%Bossman%", @to_condition_array[1]
+        end
+        
+        should "translate operator to LIKE" do
+          assert_equal("title LIKE ?", @to_condition_array[0])
+        end
+        
+      end
+      
+      context "to_condition_array" do
+        setup do
+          @to_condition = @condition.to_condition_array
+        end
+
+        should "return array" do
+          assert @to_condition.is_a?(Array)
+        end
+
+        should "have conditional string first" do
+          assert_equal 'title < ?', @to_condition[0]
+        end
+
+        should "have value as [1]" do
+          assert_equal @condition.value, @to_condition[1]
+        end
+      end
+    
+      context "to_hash" do
+        should "return hash like params" do
+          assert_equal({'title' => {'lt' => 'Bossman'}}, @condition.to_hash)
+        end
+      end
+    end
+  end
+
+end

data/test/test_restful_query_parser.rb

@@ -0,0 +1,392 @@
+require 'test_helper'
+
+class RestfulQueryParserTest < Test::Unit::TestCase
+
+  context "Parser" do
+    setup do
+      @base_query_hash = {'created_at' => {'gt' => '1 week ago', 'lt' => '1 hour ago'}, 'updated_at' => {'lt' => '1 day ago'}, 'title' => {'eq' => 'Test'}, 'other_time' => {'gt' => 'oct 1'}, 'name' => 'Aaron'}
+    end
+
+    context "from_hash" do
+
+      context "without hash" do
+        setup do
+          @parser = RestfulQuery::Parser.new(nil)
+        end
+
+        should "return Parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "have a blank hash for query hash" do
+          assert_equal({}, @parser.query_hash)
+        end
+      end
+
+      context "with a hash of columns and operations" do
+        setup do
+          new_parser_from_hash
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "save hash to query_hash" do
+          assert_equal @base_query_hash, @parser.query_hash.to_hash
+        end
+
+        should "save each condition as a condition object" do
+          assert @parser.conditions.is_a?(Array)
+          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 "with exclude columns" do
+        setup do
+          new_parser_from_hash({}, :exclude_columns => [:other_time,'name'])
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "exclude columns from conditions" do
+          assert @parser.conditions_for('created_at')
+          assert_nil @parser.conditions_for('other_time')
+          assert_nil @parser.conditions_for(:name)
+        end
+
+      end
+
+      context "with chronic => true" do
+        setup do
+          new_parser_from_hash({}, :chronic => true)
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "parse created at and updated with chronic" do
+          assert_equal Chronic.parse('1 week ago').to_s, @parser.conditions_for(:created_at).first.value.to_s
+          assert_equal Chronic.parse('1 day ago').to_s, @parser.conditions_for(:updated_at).first.value.to_s
+        end
+
+      end
+
+      context "with chronic => []" do
+        setup do
+          new_parser_from_hash({}, :chronic => [:other_time])
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "parse selected attributes in array with chronic" do
+          assert_equal Chronic.parse('oct 1').to_s, @parser.conditions_for(:other_time).first.value.to_s
+        end
+
+        should "not parse created at/updated at if not specified" do
+          assert_not_equal Chronic.parse('1 week ago').to_s, @parser.conditions_for(:created_at).first.value.to_s
+          assert_not_equal Chronic.parse('1 day ago').to_s, @parser.conditions_for(:updated_at).first.value.to_s
+        end
+      end
+
+      context "with sort as a single string" do
+        setup do
+          new_parser_from_hash({'_sort' => 'created_at-up'})
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "parse sort string" do
+          @sort = @parser.sorts.first 
+          assert @sort.is_a?(RestfulQuery::Sort)
+          assert_equal 'ASC', @sort.direction
+          assert_equal 'created_at', @sort.column
+        end
+
+        should "add sort to sorts" do
+          assert @parser.sorts
+          assert_equal 1, @parser.sorts.length
+        end
+
+      end
+
+      context "with sort as an array of strings" do
+        setup do
+          new_parser_from_hash({'_sort' => ['created_at-up','title-desc']})
+        end
+
+        should "return parser object" do
+          assert @parser.is_a?(RestfulQuery::Parser)
+        end
+
+        should "add sorts to sorts" do
+          assert @parser.sorts
+          assert_equal 2, @parser.sorts.length
+          @parser.sorts.each do |sort|
+            assert sort.is_a?(RestfulQuery::Sort)
+          end
+        end
+
+      end
+      
+      context "with a default_sort" do
+        context "with no sorts defined in the query hash" do
+          setup do
+            new_parser_from_hash({}, {:default_sort => 'created_at DESC'})
+          end
+          
+          should "return parser object" do
+            assert @parser.is_a?(RestfulQuery::Parser)
+          end
+        
+          should "have default sort in sorts" do
+            assert @parser.sorts
+            assert_equal 1, @parser.sorts.length
+            assert_equal 'created_at DESC', @parser.sort_sql
+          end
+        end
+        
+        context "with sorts defined in the query hash" do
+          setup do
+            new_parser_from_hash({'_sort' => 'created_at-up'})
+          end
+
+          should "return parser object" do
+            assert @parser.is_a?(RestfulQuery::Parser)
+          end
+          
+          should "have query hash sorts in sorts and not default sort" do
+            assert @parser.sorts
+            assert_equal 1, @parser.sorts.length
+            assert_equal 'created_at ASC', @parser.sort_sql
+          end
+        end
+      end
+    end
+
+    context "a loaded parser" do
+      setup do
+        new_parser_from_hash
+      end
+
+      context "conditions" do
+        setup do
+          @conditions = @parser.conditions
+        end
+
+        should "return array of all conditions objects" do
+          assert @conditions.is_a?(Array)
+          @conditions.each do |condition|
+            assert condition.is_a?(RestfulQuery::Condition)
+          end
+        end
+
+        should "include conditions for every attribute" do
+          assert_equal @base_query_hash.keys.length + 1, @conditions.length
+        end
+      end
+
+      context "conditions_for" do
+        should "return nil for columns without conditions" do
+          assert_nil @parser.conditions_for(:blah)
+        end
+
+        should "return array of conditions for column that exists" do
+          @conditions = @parser.conditions_for(:created_at)
+          assert @conditions.is_a?(Array)
+          @conditions.each do |condition|
+            assert condition.is_a?(RestfulQuery::Condition)
+            assert_equal 'created_at', condition.column
+          end
+        end
+
+      end
+
+      context "to conditions array" do
+        setup do
+          @conditions = @parser.to_conditions_array
+        end
+
+        should "return array" do
+          assert @conditions.is_a?(Array)
+        end
+
+        should "first element should be a condition string" do
+          assert @conditions[0].is_a?(String)
+        end
+
+        should "include operators for all querys" do
+          assert_match(/(([a-z_]) (\<|\>|\=|\<\=|\>\=) \? AND)+/,@conditions[0])
+        end
+
+        should "join query hash with AND" do
+          assert_match(/AND/,@conditions[0])
+        end
+
+        should "include values for each conditions" do
+          assert_equal @base_query_hash.keys.length + 2, @conditions.length
+        end
+
+      end
+
+      context "to conditions with :or" do
+        setup do
+          @conditions = @parser.to_conditions_array(:or)
+        end
+
+        should "join query hash with OR" do
+          assert_match(/(([a-z_]) (\<|\>|\=|\<\=|\>\=) \? OR)+/,@conditions[0])
+        end
+      end
+      
+      context "to_query_hash" do
+        context "with no altering" do
+          setup do
+            @query_hash = @parser.to_query_hash
+          end
+          
+          should "return hash" do
+            assert @query_hash.is_a?(Hash)
+          end
+      
+          should "return initial query hash" do
+            assert_equal({'gt' => '1 week ago', 'lt' => '1 hour ago'}, @query_hash['created_at'])
+          end
+        end
+        
+        context "with altered sorts" do
+          setup do
+            @parser.set_sort('title', 'up')
+            @parser.set_sort('created_at', 'down')
+            @query_hash = @parser.to_query_hash
+          end
+          
+          should "include unaltered sort conditions" do
+            assert_equal({'gt' => '1 week ago', 'lt' => '1 hour ago'}, @query_hash['created_at'])
+          end
+          
+          should "include altered sorts" do
+            assert_equal(['title-asc','created_at-desc'], @query_hash['_sort'])
+          end
+        end
+      end
+      
+      context "sorts" do
+        setup do
+          new_parser_from_hash({'_sort' => ['title-down', 'updated_at-asc']})
+          @sorts = @parser.sorts 
+        end
+        
+        should "return an array of sort objects" do
+          assert @sorts
+          assert_equal 2, @sorts.length
+          @sorts.each do |sort|
+            assert sort.is_a?(RestfulQuery::Sort)
+          end
+        end
+        
+        context "sorted_columns" do
+          should "return an array of columns" do
+            @sorted_columns = @parser.sorted_columns
+            assert @sorted_columns.is_a?(Array)
+            assert @sorted_columns.include?('title')
+          end
+        end
+        
+        context "sorted_by?" do
+          should "return true if column is sorted" do
+            assert @parser.sorted_by?('title')
+          end
+          
+          should "return false if column is not sorted" do
+            assert !@parser.sorted_by?('created_at')
+          end
+        end
+        
+        context "sort()" do
+          should "return Sort object if column is sorted" do
+            sort = @parser.sort('title')
+            assert sort.is_a?(RestfulQuery::Sort)
+            assert_equal 'title', sort.column
+          end
+          
+          should "return nil if col" do
+            assert_nil @parser.sort('created_at')
+          end
+        end
+        
+        context "set_sort" do
+          context "with an existing sort" do            
+            setup do
+              @parser.set_sort('title','up')
+            end
+            
+            should "not add new sort" do
+              assert_equal 2, @parser.sorts.length
+            end
+            
+            should "update sort direction" do
+              assert_equal 'ASC', @parser.sort('title').direction
+            end
+          end
+          
+          context "with direction: nil" do
+            setup do
+              @parser.set_sort('title', nil)
+            end
+            
+            should "remove sort" do
+              assert_equal 1, @parser.sorts.length
+              assert !@parser.sorted_by?('title')
+            end
+          end
+          
+          context "with a new sort" do
+            setup do
+              @parser.set_sort('name', 'down')
+            end
+            
+            should "add sort to sorts" do
+              assert_equal 3, @parser.sorts.length
+            end
+            
+            should "set sort direction" do
+              assert_equal 'DESC', @parser.sort('name').direction
+            end
+          end
+          
+        end
+        
+      end
+      
+
+      context "sort_sql" do
+        should "join order with ," do
+          new_parser_from_hash({'_sort' => ['title-down', 'updated_at-asc']})
+          assert_equal 'title DESC, updated_at ASC', @parser.sort_sql
+        end
+      end
+
+    end
+
+  end
+
+  protected
+  def new_parser_from_hash(params = {}, options = {})
+    @parser = RestfulQuery::Parser.new(@base_query_hash.merge(params), options)
+  end
+end

data/test/test_restful_query_sort.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+class RestfulQuerySortTest < Test::Unit::TestCase
+
+  context "Sort" do
+    context "initializing" do
+      context "with valid column and direction" do
+        setup do
+          @sort = RestfulQuery::Sort.new(:attribute, 'up')
+        end
+        
+        should "save column name as string" do
+          assert_equal 'attribute', @sort.column
+        end
+        
+        should "interpret direction" do
+          assert_equal 'ASC', @sort.direction
+        end
+      end
+      
+      context "with an invalid direction" do
+        should "raise error" do
+          assert_raise(RestfulQuery::InvalidDirection) do
+            RestfulQuery::Sort.new('column', 'blarg')
+          end
+        end
+      end
+      
+    end
+    
+    context "parse" do
+      context "with a query hash like condition" do
+      setup do
+        @sort = RestfulQuery::Sort.parse('long_name_attribute-down')
+      end
+      
+      should "return sort object" do
+        assert @sort.is_a?(RestfulQuery::Sort)
+      end
+      
+      should "set column and direction" do
+        assert_equal 'long_name_attribute', @sort.column
+        assert_equal 'DESC', @sort.direction
+      end
+      end
+      
+      context "with a standard SQL like condition" do
+        setup do
+          @sort = RestfulQuery::Sort.parse('long_name_attribute DESC')
+        end
+
+        should "return sort object" do
+          assert @sort.is_a?(RestfulQuery::Sort)
+        end
+
+        should "set column and direction" do
+          assert_equal 'long_name_attribute', @sort.column
+          assert_equal 'DESC', @sort.direction
+        end
+      end
+    end
+    
+    context "to_sql" do
+      should "join the column and attribute" do
+        @sort = RestfulQuery::Sort.new(:attribute, 'down')
+        assert_equal 'attribute DESC', @sort.to_sql
+      end
+    end
+    
+  end
+  
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification 
+name: restful_query
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Aaron Quint
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-21 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  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: 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
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: newgem
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: Shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: Simple ActiveRecord queries from a RESTful and safe interface
+email: 
+- aaron@quirkey.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+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
+has_rdoc: true
+homepage: http://code.quirkey.com/restful_query
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: quirkey
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Simple ActiveRecord queries from a RESTful and safe interface
+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