panda_query 0.3.0

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2008 Christian Herschel Stevenson, Persapient Systems
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,153 @@
+= PANDA Query
+
+The PANDA Query library provides a generic query object, which is basically an
+immutable hash whose _where_ clause is represented as a boolean/comparison
+expression AST, or *PANDA* (<b>P</b>ainlessly <b>A</b>llocated _via_ "<b>N</b>ative
+<b>D</b>SL" <b>A</b>ST).
+
+The Goal of PANDA is to make it possible to build _where_ style expression ASTs
+'painlessly' on the fly (in a single line of code) that are highly readable, with
+code that closely resembles the expression being built. This is accomplished
+with a kind of internal (or '_native_') DSL implemented in pure ruby via method
+calls on Panda objects.
+
+PANDA is basically a variation of the Parser-less Interpreter/Internal DSL patterns
+as described in Russ Olsen's {Design Patterns in Ruby}[http://designpatternsinruby.com].
+
+== The Panda AST
+
+In order to fully grasp the painlessness of building a PANDA, it would first be
+wise to see the _painful_ example first.
+
+In the following example I build a PANDA node by node the hard way in order to
+provide a little insight on the relatively simple anatomy of a Panda tree. The
+statement I build here would be the SQL <em>where clause</em> equivalent to
+"<tt>first_name = 'Milton' AND last_name = 'Waddams' OR handle LIKE '%milwad%'
+</tt>".
+
+  require 'panda/expressions'
+
+  s1 = Panda::Subject.new :first_name
+  c1 = Panda::Comparison.new s1, :==, 'Milton'
+  s2 = Panda::Subject.new :last_name
+  c2 = Panda::Comparison.new s2, :==, 'Waddams'
+  b1 = Panda::Boolean.new c1, :'&', c2
+
+  s3 = Panda::Subject.new :handle
+  c3 = Panda::Comparison.new s3, :like, '%milwad%'
+
+  root = Panda::Boolean.new b1, :'|', c3
+
+To get a better look at what was just built, we can execute the following code:
+
+  require 'panda/expressers/tree_expresser'
+
+  puts Panda::Expressers::TreeExpresser.express(root) # puts the following..
+  :|
+  |----:&
+  |    |----:==
+  |    |    |----:first_name
+  |    |    |
+  |    |    `----"Milton"
+  |    |
+  |    `----:==
+  |         |----:last_name
+  |         |
+  |         `----"Waddams"
+  |
+  `----:like
+       |----:handle
+       |
+       `----"%milwad%"
+
+
+Obviously we would never resort to building ASTs in this manner in the real world
+as we would normally opt for a builder of some sort (or aquire one from a parser).
+In fact, the PANDA method can be thought of as a sort of hybrid
+builder/parser-less/internal DSL solution to painless AST allocation.
+
+Here is the same AST allocated PANDA style:
+
+  # version 1
+  ast = Panda.build {|s| (s.first_name == 'Milton') & (s.last_name == 'Waddams') | (s.handle.like '%milwad%') }
+
+Lets see that again in slow motion.
+
+  # version 2
+  ast = Panda.build {|s| s.first_name.is('Milton').and(s.last_name.is('Waddams')).or(s.handle.like('%milwad%')) }
+
+Version 2 is identical to version 1 except that I have substituted each call to
+an overloaded operator with its named (non-operator) alias (except for _like_
+which has no operator version). Although it is not exactly the most elegant
+looking line of code, version 2 does expose a bit of the DSL magic behind
+version 1.
+
+== The Query Object
+
+As mentioned at the beginning, the Panda::Query class is really little more than
+an immutable hash of query elements, or _clauses_, with the <tt>:where</tt>
+element being the resulting AST from a Panda expression, which is passed as a
+block to the constructor. Instead of being a feature-packed solution to one or
+another specific domain, Panda::Query is better thought of as a flexible,
+free-form base class upon which one can define their more specific query object
+needs (for instance, you may not be dealing with SQL at all).
+
+=== Examples
+
+  require 'panda_query'
+
+  q = Panda::Query.new :select => :*, :from => :leet_haxors do |lh|
+    (lh.handle =~ /^[Mm]atz/) | (lh.lisps.is true)
+  end
+
+  q.query_elements -> [:where, :from, :select]
+  q.select         -> :*
+  q.from           -> :leet_haxors
+  q.where          -> (handle =~ /^[Mm]atz/ | lisps == true)
+
+Notice that I am accessing the query elements as method calls rather than using
+the [] operator. This allows me to override the behavior of certain elements
+if need be, although I can also call [] on a query if I really want to. A good
+example of this is Panda::Query's +order+ method which always returns an array.
+
+  # continued from above..
+
+  q[:order]                        -> nil
+  q.order                          -> []
+
+  q2 = q.merge :order => :last_name
+
+  q2[:order]                       -> :last_name
+  q2.order                         -> [:last_name]
+
+  q3 = q2.merge :order => [:last_name, :first_name]
+
+  q3.order                         -> [:last_name, :first_name]
+
+IN addition to _theoretically_ being a good query object base class, Panda::Query
+could also serve as a nice front-end api mechanism for some other querying
+back-end interface, or for a system that uses PANDA Query as its native query
+representation internally (PANDA Query was originally developed for the latter
+case).
+
+In the following example I demonstrate this idea using a hypothetical object
+persistence tool with a Panda::Query based querying api.
+
+  # Lets find all the employees who are in desperate need of a raise
+
+  emps = Employee.find(:all, :order => :date_hired, :desc => true) {|e| (e.rate <= MIN_WAGE) | (e.cubicle.not nil) }
+
+
+== Installation
+
+  % sudo gem install panda-query
+
+== License[link://files/LICENSE.html]
+
+Copyright (c) 2008 Christian Herschel Stevenson, Persapient Systems. Released
+under the same license[link://files/LICENSE.html] as Ruby.
+
+== Support
+
+For more information, contact mailto:stevenson@persapient.com. This documentation
+can be found online at http://api.persapient.com/panda_query

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rake'
+require 'rake/rdoctask'
+
+desc 'Default: Generate documentation.'
+task :default => :rdoc
+
+desc 'Generate documentation for PANDA Query.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'PANDA Query'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README', 'LICENSE', 'lib/**/*.rb')
+end

data/lib/panda/build.rb

@@ -0,0 +1,51 @@
+module Panda
+
+  class SubjectGenerator
+
+    # Returns a new Subject whose _name_ attribute is set to _sub_name_.
+    #
+    #   sg = Panda::SubjectGenerator.new
+    #   sg[:foo]  -> #<Panda::Subject:0x8260acc @name=:foo>
+    #   sg['bar'] -> #<Panda::Subject:0x825f398 @name="bar">
+    #
+    def [](sub_name)
+      Subject.new sub_name
+    end
+
+    private
+
+    # Returns a new Subject whose _name_ attribute is set to the missing
+    # method's name.
+    #
+    #   sg = Panda::SubjectGenerator.new
+    #   sg.foo -> #<Panda::Subject:0x8260acc @name=:foo>
+    #   sg.bar -> #<Panda::Subject:0x825f398 @name=:bar>
+    #
+    def method_missing(method, *args) # :doc:
+      Subject.new method
+    end
+
+  end
+
+
+  # Returns the result of the given block, which is passed a new SubjectGenerator
+  # object. If the given block does not return a Panda expression AST then a
+  # Panda::SyntaxError exception is raised.
+  #
+  #   ast = Panda.build { |s| (s.name == 'FooHoney') | (s.booty.like 'whoa!') }
+  #   puts ast
+  #   puts ast.inspect
+  #
+  # _produces_:
+  #
+  #   #<Panda::Boolean:0x8255ca8>
+  #   (name == "FooHoney" | booty like "whoa!")
+  #
+  def self.build
+    unless Panda::Node === ast = yield(SubjectGenerator.new)
+      raise SyntaxError, "Invalid PANDA expression: \"#{ast}\". Are you using the != operator, perhaps?"
+    end
+    return ast
+  end
+
+end

data/lib/panda/core_ext/hash.rb

@@ -0,0 +1,7 @@
+class Hash
+
+  def merged_with(other, &block)
+    (other || {}).merge self, &block
+  end
+
+end

data/lib/panda/expressers/base.rb

@@ -0,0 +1,30 @@
+module Panda
+  module Expressers
+
+
+    class Base
+
+      def self.express(*args)
+        new.express *args
+      end
+
+
+      def express(expression)
+        write_node str = '', expression
+        str
+      end
+
+
+      def write_node(stream, node)
+        case node
+          when Boolean: write_boolean(stream, node)
+          when Comparison: write_comparison(stream, node)
+          else raise ArgumentError, "Bad node"
+        end
+      end
+
+    end
+
+
+  end
+end

data/lib/panda/expressers/examples/active_record_expresser.rb

@@ -0,0 +1,20 @@
+module Panda::Expressers
+
+  class ActiveRecordExpresser < SqlExpresser # :nodoc:
+
+    def express(expression)
+      @objects = []
+      [ super ] + @objects
+    end
+
+
+    private
+
+    def write_comparison(stream, node)
+      stream << "#{node.subject.name} #{@@operators[node.operator]} ?"
+      @objects << node.object
+    end
+
+  end
+
+end

data/lib/panda/expressers/examples/sql_expresser.rb

@@ -0,0 +1,33 @@
+module Panda
+  module Expressers
+
+
+    class SqlExpresser < Base # :nodoc:
+
+      @@operators = Hash.new { |h,k| k.to_s.upcase }.merge(
+        :'&' => 'AND',
+        :'|' => 'OR',
+        :== => '=',
+        :not => '!='
+      )
+
+      private
+
+      def write_boolean(stream, node)
+        stream << '('
+        write_node stream, node.left
+        stream << " #{@@operators[node.operator]} "
+        write_node stream, node.right
+        stream << ')'
+      end
+
+
+      def write_comparison(stream, node)
+        stream << "#{node.subject.name} #{@@operators[node.operator]} '#{node.object}'"
+      end
+
+    end
+
+
+  end
+end

data/lib/panda/expressers/inspector.rb

@@ -0,0 +1,27 @@
+require 'panda/expressers/base'
+
+module Panda
+  module Expressers
+
+
+    class Inspector < Base
+      private
+
+      def write_boolean(stream, node)
+        stream << '('
+        write_node stream, node.left
+        stream << " #{node.operator} "
+        write_node stream, node.right
+        stream << ')'
+      end
+
+
+      def write_comparison(stream, node)
+        stream << "#{node.subject.name} #{node.operator} #{node.object.inspect}"
+      end
+
+    end
+
+
+  end
+end

data/lib/panda/expressers/tree_expresser.rb

@@ -0,0 +1,46 @@
+require 'panda/expressers/base'
+
+module Panda
+  module Expressers
+
+
+    class TreeExpresser < Base
+
+      def express(expression)
+        @indent_stk = ["\n"]
+        super
+      end
+
+
+      private
+
+      def indent
+        @indent_stk.join ''
+      end
+
+
+      def write_boolean(stream, node)
+        stream << ":#{node.operator}" << indent << '|----'
+        @indent_stk.push '|    '
+        write_node stream, node.left
+        @indent_stk.pop
+        stream << indent << '|' << indent << '`----'
+        @indent_stk.push '     '
+        write_node stream, node.right
+        @indent_stk.pop
+      end
+
+
+      def write_comparison(stream, node)
+        stream << ":#{node.operator}"
+        stream << indent << '|----'
+        stream << "#{node.subject.name.inspect}"
+        stream << indent << '|' << indent << '`----'
+        stream << "#{node.object.inspect}"
+      end
+
+    end
+
+
+  end
+end

data/lib/panda/expressions.rb

@@ -0,0 +1,205 @@
+require 'panda/expressers/inspector'
+
+
+module Panda
+
+  class SyntaxError < ::SyntaxError
+  end
+
+
+  # === The base class for all Panda tree nodes (except for the object of a comparison).
+  #
+  class Node
+
+    # Defines instance methods on the invoking class for each operator of
+    # _klass_. Each defined method returns a new instance of _klass_ with the
+    # invoking instance as the left operand, the method name as the operator,
+    # and the _object_ argument as the right operand. If the method's operator
+    # has a 'wordy' alias, the method is aliased by that name.
+    def self.define_operator_builders_for(klass)
+      klass.operators.each do |operator, op_name|
+        define_method operator do |object|
+          klass.new(self, operator, object)
+        end
+        alias_method(op_name, operator) if op_name
+      end
+    end
+
+  end
+
+
+  # === The base class for binary Panda expression nodes.
+  #
+  # Expression objects have an operator (as a symbol) and left & right operands.
+  # Expression classes define a hash of possible operators where the key is the
+  # operator and the value is a 'wordy' alias for the operator which can be +nil+.
+  #
+  # There is currently no unary expression class because I have not yet figured
+  # out a way to implement one in a way that would be useful with this library
+  # (for now you'll just have to apply a bit of Demorgan to get around the absence
+  # of a unary negation operator).
+  #
+  class Expression < Node
+    @@inspector = Expressers::Inspector
+
+    attr_reader :operator, :left, :right
+
+
+    # Accepts a _left_ operand, an _operator_ as a symbol, and a _right_ operand.
+    # If _operator_ is not one of the possible operators of the invoking Epression
+    # class then a Panda::SyntaxError exception is raised.
+    def initialize(left, operator, right)
+      unless has_operator? operator
+        raise SyntaxError, "bad operator :#{operator} for #{self.class}"
+      end
+      @left, @operator, @right = left, operator, right
+    end
+
+
+    # Returns the receiver class's hash of possible operators where the key is
+    # the operator and the value is the 'wordy' alias name of the operator, or
+    # +nil+.
+    def self.operators
+      @operators
+    end
+
+
+    # Returns +true+ if the class uses the given operator.
+    def self.has_operator?(op)
+      @operators.has_key? op
+    end
+
+
+    # Returns the wordy alias of the operator or +nil+ if it does not have one
+    # or if the receiver class does not use the given operator.
+    def self.operator_alias_for(op)
+      @operators[op.to_sym]
+    end
+
+
+    # Sets the default expresser class for all Panda AST node's +inspect+ method.
+    # If +nil+ is passed then ruby's default +inspect+ method is used instead.
+    def self.inspector=(inspector)
+      @@inspector = inspector
+    end
+
+
+    # Returns +true+ if the receiver's class uses the given operator.
+    def has_operator?(op)
+      self.class.has_operator? op
+    end
+
+
+    # Returns the wordy alias name of the receiver's operator or +nil+ if it
+    # does not have one.
+    def operator_alias
+      self.class.operator_alias_for @operator
+    end
+
+
+    # Overwrites +inspect+ to use the +express+ class method of the expresser
+    # class assigned to <tt>@@inspector</tt> if one exists.
+    #
+    # The default expresser is Panda::Expressers::Inspector.
+    def inspect
+      @@inspector && @@inspector.express(self) || super
+    end
+  end
+
+
+  # === The binary boolean expression node class.
+  #
+  # The possible operators are:
+  # * :& (and)
+  # * :| (or)
+  #
+  # [NOTE:]
+  #   The binary operators are used here because you cannot yet overload ruby's
+  #   && and || operators <em>(at least in 1.8)</em>.
+  #
+  class Boolean < Expression
+    @operators = { :'&' => :and, :'|' => :or }.freeze
+
+    define_operator_builders_for self
+
+
+    # Same precondition as Panda::Expression plus a Panda::SyntaxError is raised
+    # if _left_ or _right_ is not an instance of Panda::Expression.
+    def initialize(left, operator, right)
+      unless left.kind_of?(Expression) && right.kind_of?(Expression)
+        raise SyntaxError, "Bad operand for #{self.class}: (#{left.inspect}) #{operator} (#{right.inspect})"
+      end
+      super
+    end
+
+  end
+
+
+  # === The binary comparison expression node class.
+  #
+  # Comparison expressions consist of a Panda::Subject object as the left operand
+  # <em>(the 'subject' of a comparison)</em> and any type of object as the right
+  # operand <em>(the 'object' of a comparison)</em>.
+  #
+  # The possible operators are:
+  # * :== (is)
+  # * :not
+  # * :< (less_than)
+  # * :<= (less_than_or_equal_to)
+  # * :> (greater_than)
+  # * :>= (greater_than_or_equal_to)
+  # * :=~ (matches_regexp)
+  # * :like
+  # * :ilike
+  #
+  # [NOTE:]
+  #   It is not possible in ruby 1.8 to overload the != operator so you'll
+  #   have to call it by name (:not) :P.
+  #
+  class Comparison < Expression
+    @operators = {
+      :== => :is,
+      :not => nil,
+      :< => :less_than,
+      :> => :greater_than,
+      :<= => :less_than_or_equal_to,
+      :>= => :greater_than_or_equal_to,
+      :=~ => :matches_regexp,
+      :like => nil,
+      :ilike => nil
+    }.freeze
+
+    define_operator_builders_for Boolean
+
+
+    # Same precondition as Panda::Expression plus a Panda::SyntaxError is raised
+    # if _subject_ is not an instance of Panda::Subject.
+    def initialize(subject, operator, object)
+      unless subject.kind_of?(Subject)
+        raise SyntaxError, "Bad subject for #{self.class}: expected an instance of Panda::Subject but got #{subject.inspect}"
+      end
+      super
+    end
+
+    alias subject left
+    alias object right
+
+  end
+
+
+  # === The comparison subject node class.
+  #
+  # Subject nodes represent the 'subject' <em>(left operand)</em> of a Comparison
+  # object. Subjects are nothing more than thin wrappers around any object that
+  # represents the name of a comparison subject (typically a Symbol or String)
+  # that have Comparison operator builder methods.
+  class Subject < Node
+    attr_reader :name
+    define_operator_builders_for Comparison
+
+    def initialize(name)
+      @name = name
+    end
+  end
+
+end

data/lib/panda/query.rb

@@ -0,0 +1,96 @@
+require 'panda/expressions'
+require 'panda/build'
+
+
+module Panda
+
+  InvalidQuery = Class.new(ArgumentError)
+
+
+  class Query
+
+    def initialize(args = {}, &block)
+      @query = (args || {}).to_hash
+      @query[panda_element] = Panda.build(&block) if block_given?
+    end
+
+
+    def panda_element
+      :where
+    end
+
+
+    def to_hash
+      @query.dup
+    end
+
+
+    def query_elements
+      @query.keys
+    end
+
+
+    def [](element)
+      @query[element]
+    end
+
+
+    def order
+      @order ||= [ @query[:order] || [] ].flatten
+    end
+
+
+    def descends_on?(order_attr)
+      assert_ordered_by(order_attr) && (@descenders || load_descenders)[order_attr]
+    end
+
+
+    def ascends_on?(order_attr)
+      !descends_on? order_attr
+    end
+
+
+    def merge(query = {}, &block)
+      self.class.new @query.merge(query || {}), &block
+    end
+
+
+    def merged_with(other = {}, &block)
+      self.class.new(other, &block).merge(@query)
+    end
+
+
+    private
+
+    def method_missing(method, *args)
+      args.empty? ? @query[method] : super
+    end
+
+
+    def assert_ordered_by(attr, exception = ArgumentError)
+      return true if order.include?(attr)
+      raise exception, "query is not ordered by #{attr}"
+    end
+
+
+    def load_descenders
+      case desc = @query[:desc]
+        when NilClass, FalseClass: @descenders = Hash.new(false)
+        when TrueClass: @descenders = Hash.new(true)
+      else
+        @descenders = Hash.new(false)
+        [ desc ].flatten.each do |dsc|
+          case dsc
+            when Integer: @descenders[order[dsc] || raise(InvalidQuery, "query order does not include index #{dsc}")] = true
+            when Symbol: assert_ordered_by(dsc, InvalidQuery) && @descenders[dsc] = true
+            else raise InvalidQuery, "don't know how to descend on #{dsc.class} object"
+          end
+        end
+      end
+      @descenders
+    end
+
+  end
+
+
+end

data/lib/panda_query.rb

@@ -0,0 +1,3 @@
+require 'panda/core_ext/hash'
+require 'panda/expressers/tree_expresser'
+require 'panda/query'

data/test/panda/build_case.rb

@@ -0,0 +1,30 @@
+$:.unshift "#{File.dirname(__FILE__)}/../../lib"
+
+require 'panda/expressions'
+require 'panda/build'
+require 'test/unit'
+
+
+class Panda::BuildTest < Test::Unit::TestCase
+
+  def test_root_oopsee
+    assert_raise Panda::SyntaxError do
+      Panda.build { |p| p.bud != nil }
+    end
+  end
+
+
+  def test_non_root_oopsee
+    assert_raise Panda::SyntaxError do
+      Panda.build { |p| (p.bud != nil) & (p.beer > 12) }
+    end
+  end
+
+
+  def test_straight_abuse
+    assert_raise Panda::SyntaxError do
+      Panda.build { |p| "HI! I don't have a @$%!'n clue what I'm doing!" }
+    end
+  end
+
+end

data/test/panda/expressions/boolean_case.rb

@@ -0,0 +1,42 @@
+$:.unshift "#{File.dirname(__FILE__)}/../../../lib"
+
+require 'panda/expressions'
+require 'test/unit'
+
+
+class Panda::BooleanTest < Test::Unit::TestCase
+  B = Panda::Boolean
+  B.inspector = nil
+
+  class E < Panda::Expression
+    @operators = { :xor => nil }
+  end
+
+
+  def test_class_operators
+    assert B.instance_methods.include?('&')
+    assert B.instance_methods.include?('|')
+    assert B.instance_methods.include?('and')
+    assert B.instance_methods.include?('or')
+    assert B.has_operator?(:'&')
+    assert B.has_operator?(:'|')
+    assert_same :and, B.operator_alias_for(:'&')
+    assert_same :or, B.operator_alias_for(:'|')
+  end
+
+
+  def test_initialize
+    left, right = E.new(:a, :xor, :b), E.new(:x, :xor, :y)
+    bool = B.new left, :'&', right
+    assert_same left, bool.left
+    assert_same right, bool.right
+    assert_same :'&', bool.operator
+
+    assert_raise(Panda::SyntaxError) { B.new :not_exp, :'&', right }
+    assert_raise(Panda::SyntaxError) { B.new left, :'&', :not_exp }
+    assert_raise(Panda::SyntaxError) { B.new :not_exp, :'&', :not_exp }
+    assert_raise(Panda::SyntaxError) { B.new left, :not_op, right }
+    assert_raise(Panda::SyntaxError) { B.new :not_exp, :not_op, :not_exp }
+  end
+
+end

data/test/panda/expressions/comparison_case.rb

@@ -0,0 +1,49 @@
+$:.unshift "#{File.dirname(__FILE__)}/../../../lib"
+
+require 'panda/expressions'
+require 'test/unit'
+
+
+class Panda::ComparisonTest < Test::Unit::TestCase
+  C = Panda::Comparison
+  S = Panda::Subject
+
+
+  def test_class_operators
+    {
+      :== => :is,
+      :not => nil,
+      :< => :less_than,
+      :> => :greater_than,
+      :<= => :less_than_or_equal_to,
+      :>= => :greater_than_or_equal_to,
+      :=~ => :matches_regexp,
+      :like => nil,
+      :ilike => nil
+    }.each do |op, name|
+      assert C.has_operator?(op)
+      assert_same name, C.operator_alias_for(op)
+    end
+    assert C.instance_methods.include?('&')
+    assert C.instance_methods.include?('|')
+    assert C.instance_methods.include?('and')
+    assert C.instance_methods.include?('or')
+  end
+
+
+  def test_initialize
+    sub = S.new(:ass)
+    comp = C.new sub, :like, 'whoa!'
+    assert_same sub, comp.subject
+    assert_same comp.subject, comp.left
+    assert_equal 'whoa!', comp.object
+    assert_same comp.object, comp.right
+    assert_same :like, comp.operator
+
+    assert_raise(Panda::SyntaxError) { C.new :not_sub, :==, Object.new }
+    assert_raise(Panda::SyntaxError) { C.new sub, :not_op, Object.new }
+    assert_raise(Panda::SyntaxError) { C.new :not_sub, :not_op, Object.new }
+    assert_nothing_raised { C.new sub, :not, nil }
+  end
+
+end

data/test/panda/expressions/expression_case.rb

@@ -0,0 +1,63 @@
+$:.unshift "#{File.dirname(__FILE__)}/../../../lib"
+
+require 'panda/expressions'
+require 'test/unit'
+
+
+class Panda::ExpressionTest < Test::Unit::TestCase
+
+  class Foo < Panda::Expression
+    @operators = { :'|' => :bar, :do => nil }.freeze
+    define_operator_builders_for self
+  end
+
+
+  def test_class_define_operator_builders_for
+    assert Foo.instance_methods.include?('|')
+    assert Foo.instance_methods.include?('bar')
+    assert Foo.instance_methods.include?('do')
+  end
+
+
+  def test_class_operators
+    assert_equal({ :'|' => :bar, :do => nil }, Foo.operators)
+  end
+
+
+  def test_class_has_operator?
+    assert Foo.has_operator?(:'|')
+    assert Foo.has_operator?(:do)
+    assert !Foo.has_operator?(:phoo)
+  end
+
+
+  def test_class_operator_alias_for
+    assert_same :bar, Foo.operator_alias_for(:'|')
+    assert_nil Foo.operator_alias_for(:do)
+    assert_nil Foo.operator_alias_for(:phoo)
+  end
+
+
+  def test_initialize
+    foo = Foo.new :left, :'|', :right
+    assert_same :left, foo.left
+    assert_same :'|', foo.operator
+    assert_same :right, foo.right
+    assert_raise(Panda::SyntaxError) { Foo.new 7, :==, 7 }
+  end
+
+
+  def test_has_operator?
+    foo = Foo.new :left, :'|', :right
+    assert foo.has_operator?(:'|')
+    assert foo.has_operator?(:do)
+    assert !foo.has_operator?(:phoo)
+  end
+
+
+  def test_operator_alias
+    assert_same :bar, Foo.new(:left, :'|', :right).operator_alias
+    assert_nil Foo.new(:left, :do, :right).operator_alias
+  end
+
+end

data/test/panda/expressions/subject_case.rb

@@ -0,0 +1,35 @@
+$:.unshift "#{File.dirname(__FILE__)}/../../../lib"
+
+require 'panda/expressions'
+require 'test/unit'
+
+
+class Panda::SubjectTest < Test::Unit::TestCase
+  S = Panda::Subject
+
+
+  def test_class_operators
+    {
+      :== => :is,
+      :not => nil,
+      :< => :less_than,
+      :> => :greater_than,
+      :<= => :less_than_or_equal_to,
+      :>= => :greater_than_or_equal_to,
+      :=~ => :matches_regexp,
+      :like => nil,
+      :ilike => nil
+    }.each do |op, name|
+      assert S.instance_methods.include?(op.to_s)
+      assert name.nil? || S.instance_methods.include?(name.to_s)
+    end
+  end
+
+
+  def test_initialize
+    sub = S.new(:bob)
+    assert_same :bob, sub.name
+  end
+
+end
+

data/test/panda/expressions_suite.rb

@@ -0,0 +1,7 @@
+$:.unshift "#{File.dirname(__FILE__)}/expressions"
+
+require 'test/unit'
+require 'expression_case'
+require 'boolean_case'
+require 'comparison_case'
+require 'subject_case'

data/test/panda/query_case.rb

@@ -0,0 +1,155 @@
+$:.unshift "#{File.dirname(__FILE__)}/../../lib"
+
+require 'panda/query'
+require 'test/unit'
+
+
+class Panda::QueryTest < Test::Unit::TestCase
+
+  Q = Panda::Query
+
+  class Fq < Panda::Query
+    def panda_element
+      :filter
+    end
+  end
+
+
+  def test_initialize
+    q = Q.new(:where => Panda.build { |o| (o.mark == 7) & (o.explodes.not true) }) { |o| o.mark >= 7 }
+    assert_kind_of Panda::Comparison, q.where
+    q2 = Q.new q
+    assert_equal q.instance_variable_get(:@query), q2.instance_variable_get(:@query)
+    assert_not_same q.instance_variable_get(:@query), q2.instance_variable_get(:@query)
+    assert_equal({}, Q.new(nil).to_hash)
+  end
+
+
+  def test_panda_element_overide
+    fq = Fq.new { |o| (o.mark == 7) & (o.explodes.not true) }
+    assert_nil fq.where
+    assert_kind_of Panda::Boolean, fq.filter
+  end
+
+
+  def test_to_hash
+    q = Q.new :key => :value
+    assert_equal q.instance_variable_get(:@query), q.to_hash
+    assert_not_same q.instance_variable_get(:@query), q.to_hash
+  end
+
+
+  def test_query_elements
+    q = Q.new(:limit => 7, :offset => 666) {|o| o.exists.not true }
+    assert [:limit, :offset, :where].all? {|e| q.query_elements.include? e }
+    assert_equal 3, q.query_elements.size
+    assert Q.new.query_elements.empty?
+  end
+
+
+  def test_index_op
+    assert_same :bob, Q.new(:order => :bob)[:order]
+  end
+
+
+  def test_order
+    assert_equal [:obsolete], Q.new(:order => :obsolete).order
+    assert_equal [:first, :last], Q.new(:order => [:first, :last]).order
+  end
+
+
+  def test_ascends_on_descends_on
+    assert_descenders Q.new(:order => [:x, :y, :z])
+
+    assert_descenders Q.new(:order => [:x, :y, :z], :desc => false)
+    assert_descenders Q.new(:order => [:x, :y, :z], :desc => true), :x => true, :y => true, :z => true
+
+    assert_descenders Q.new(:order => [:x, :y, :z], :desc => :x), :x => true
+    assert_descenders Q.new(:order => [:x, :y, :z], :desc => 2), :z => true
+
+    assert_descenders Q.new(:order => [:x, :y, :z], :desc => [:y, :z]), :y => true, :z => true
+    assert_descenders Q.new(:order => [:x, :y, :z], :desc => [0, 1]), :x => true, :y => true
+    assert_descenders Q.new(:order => [:x, :y, :z], :desc => [0, :y, 2]), :x => true, :y => true, :z => true
+
+    assert_raise(ArgumentError) { Q.new(:order => :x).descends_on?(:y) }
+    assert_raise(ArgumentError) { Q.new(:order => :x).ascends_on?(:y) }
+
+    assert_raise(Panda::InvalidQuery) { Q.new(:order => [:x, :y], :desc => :z).descends_on?(:x) }
+    assert_raise(Panda::InvalidQuery) { Q.new(:order => [:x, :y], :desc => :z).ascends_on?(:x) }
+
+    assert_raise(Panda::InvalidQuery) { Q.new(:order => [:x, :y], :desc => 7).descends_on?(:x) }
+    assert_raise(Panda::InvalidQuery) { Q.new(:order => [:x, :y], :desc => 7).ascends_on?(:x) }
+
+    assert_raise(Panda::InvalidQuery) { Q.new(:order => [:x, :y], :desc => {}).descends_on?(:x) }
+    assert_raise(Panda::InvalidQuery) { Q.new(:order => [:x, :y], :desc => 1.21).ascends_on?(:x) }
+
+    assert_nothing_raised { Q.new(:order => [:x, :y], :desc => :z) }
+    assert_nothing_raised { Q.new(:order => [:x, :y], :desc => 7) }
+  end
+
+
+  def test_merge
+    q1 = Q.new(:order => :x) { |o| o.x.not 666 }
+    q2 = q1.merge(:limit => 7) { |o| (o.x <= 665) & (o.x >= 667) }
+    assert_kind_of Panda::Query, q2
+    assert_same 7, q2[:limit]
+    assert_kind_of Panda::Boolean, q2[:where]
+
+    q3 = q1.merge q2
+    assert_kind_of Panda::Query, q3
+    assert_equal q2.to_hash, q3.to_hash
+
+    q3 = q1.merge(q2) { |oh| oh.why.not nil }
+    assert_kind_of Panda::Query, q3
+    assert_not_same q2[:where], q3[:where]
+
+    q4 = nil
+    assert_nothing_raised { q4 = q3.merge nil }
+    assert_kind_of Panda::Query, q4
+    assert_equal q3.to_hash, q4.to_hash
+
+    assert Q.new(:order => [:x, :y, :z], :desc => true).merge(:order => [:i, :j, :k]).descends_on?(:k)
+    assert Q.new(:order => [:x, :y, :z], :desc => 0).merge(:order => [:y, :z]).descends_on?(:y)
+    assert_raise(Panda::InvalidQuery) { Q.new(:order => [:x, :y, :z], :desc => :x).merge(:order => [:y, :z]).descends_on?(:y) }
+  end
+
+
+  def test_merged_with
+    q1 = Q.new(:order => :x) { |o| o.x.not 666 }
+    q2 = q1.merged_with(:limit => 7) { |o| (o.x <= 665) & (o.x >= 667) }
+    assert_kind_of Panda::Query, q2
+    assert_same 7, q2[:limit]
+    assert_kind_of Panda::Comparison, q2[:where]
+
+    q3 = q1.merged_with q2
+    assert_kind_of Panda::Query, q3
+    assert_equal q2.to_hash, q3.to_hash
+
+    q3 = q1.merged_with(q2) { |oh| oh.why.not nil }
+    assert_kind_of Panda::Query, q3
+    assert_same q2[:where], q3[:where]
+
+    q4 = nil
+    assert_nothing_raised { q4 = q3.merged_with nil }
+    assert_kind_of Panda::Query, q4
+    assert_equal q3.to_hash, q4.to_hash
+
+    assert Q.new(:desc => true).merged_with(:order => [:i, :j, :k]).descends_on?(:k)
+    assert Q.new(:desc => 0).merged_with(:order => [:y, :z]).descends_on?(:y)
+    assert_raise(Panda::InvalidQuery) { Q.new(:desc => :x).merged_with(:order => [:y, :z]).descends_on?(:y) }
+  end
+
+
+  private
+
+  def assert_descenders(q, descends = {})
+    q.order.each do |elem|
+      if descends[elem]
+        assert q.descends_on?(elem) && !q.ascends_on?(elem)
+      else
+        assert q.ascends_on?(elem) && !q.descends_on?(elem)
+      end
+    end
+  end
+
+end

data/test/panda_suite.rb

@@ -0,0 +1,6 @@
+$:.unshift "#{File.dirname(__FILE__)}/panda"
+
+require 'test/unit'
+require 'expressions_suite'
+require 'build_case'
+require 'query_case'

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: panda_query
+version: !ruby/object:Gem::Version 
+  version: 0.3.0
+platform: ruby
+authors: 
+- Hersch Stevenson (xian)
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-30 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: stevenson@persapient.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- README
+- LICENSE
+- Rakefile
+- lib/panda/core_ext/hash.rb
+- lib/panda/expressers/examples/sql_expresser.rb
+- lib/panda/expressers/examples/active_record_expresser.rb
+- lib/panda/expressers/tree_expresser.rb
+- lib/panda/expressers/inspector.rb
+- lib/panda/expressers/base.rb
+- lib/panda/build.rb
+- lib/panda/expressions.rb
+- lib/panda/query.rb
+- lib/panda_query.rb
+- test/panda/expressions/comparison_case.rb
+- test/panda/expressions/boolean_case.rb
+- test/panda/expressions/expression_case.rb
+- test/panda/expressions/subject_case.rb
+- test/panda/query_case.rb
+- test/panda/expressions_suite.rb
+- test/panda/build_case.rb
+- test/panda_suite.rb
+has_rdoc: true
+homepage: http://api.persapient.com/panda_query
+post_install_message: 
+rdoc_options: []
+
+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: panda-query
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: A small library for building generic query objects.
+test_files: 
+- test/panda_suite.rb