twilson63-sinatra-squirrel 0.1.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 twilson63
+
+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.rdoc

@@ -0,0 +1,9 @@
+= sinatra-squirrel
+
+Port of the Thought Bots Squirrel Search to Sinatra
+  
+Trying to get the release to build the gem
+
+== Copyright
+
+Copyright (c) 2009 twilson63. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "sinatra-squirrel"
+    gem.summary = %Q{Port of Thought Bot Squirrel to Sinatra}
+    gem.email = "tom@jackrussellsoftware.com"
+    gem.homepage = "http://github.com/twilson63/sinatra-squirrel"
+    gem.authors = ["twilson63"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sinatra-squirrel #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 2

data/lib/sinatra/extensions.rb

@@ -0,0 +1,36 @@
+class Hash
+  def merge_tree other
+    self.dup.merge_tree! other
+  end
+  
+  def merge_tree! other
+    other.each do |key, value|
+      if self[key].is_a?(Hash) && value.is_a?(Hash)
+        self[key] = self[key].merge_tree(value)
+      else
+        self[key] = value
+      end
+    end
+    self
+  end
+end
+
+module ActiveRecord #:nodoc: all
+  module Associations
+    module ClassMethods
+      class JoinDependency
+        class JoinAssociation
+          def ancestry #:doc
+            [ parent.ancestry, reflection.name ].flatten.compact
+          end
+        end
+        class JoinBase
+          def ancestry
+            nil
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/sinatra/paginator.rb

@@ -0,0 +1,81 @@
+module Squirrel
+  # The WillPagination module emulates the results that the will_paginate plugin returns
+  # from its #paginate methods. When it is used to extend a result set from Squirrel, it
+  # automtically pulls the result from the pagination that Squirrel performs. The methods
+  # added to that result set make it duck-equivalent to the WillPaginate::Collection
+  # class.
+  module WillPagination
+    def self.extended base
+      base.current_page  = base.pages.current || 1
+      base.per_page      = base.pages.per_page
+      base.total_entries = base.pages.total_results
+    end
+
+    attr_accessor :current_page, :per_page, :total_entries
+
+    # Returns the current_page + 1, or nil if there are no more.
+    def next_page
+      current_page < page_count ? (current_page + 1) : nil
+    end
+
+    # Returns the offset of the current page that is suitable for inserting into SQL.
+    def offset
+      (current_page - 1) * per_page
+    end
+
+    # Returns true if the current_page is greater than the total number of pages.
+    # Useful in case someone manually modifies the URL to put their own page number in.
+    def out_of_bounds?
+      current_page > page_count
+    end
+
+    # The number of pages in the result set.
+    def page_count
+      pages.last
+    end
+
+    alias_method :total_pages, :page_count
+
+    # Returns the current_page - 1, or nil if this is the first page.
+    def previous_page
+      current_page > 1 ? (current_page - 1) : nil
+    end
+
+    # Sets the number of pages and entries.
+    def total_entries= total
+      @total_entries = total.to_i
+      @total_pages   = (@total_entries / per_page.to_f).ceil
+    end
+  end
+
+  # The Page class holds information about the current page of results.
+  class Page
+    attr_reader :offset, :limit, :page, :per_page
+    def initialize(offset, limit, page, per_page)
+      @offset, @limit, @page, @per_page = offset, limit, page, per_page
+    end
+  end
+
+  # A Paginator object is what gets inserted into the result set and is returned by
+  # the #pages method of the result set. Contains offets and limits for all pages.
+  class Paginator < Array
+    attr_reader :total_results, :per_page, :current, :next, :previous, :first, :last, :current_range
+    def initialize opts={}
+      @total_results = opts[:count].to_i
+      @limit         = opts[:limit].to_i
+      @offset        = opts[:offset].to_i
+
+      @per_page      = @limit
+      @current       = (@offset / @limit) + 1
+      @first         = 1
+      @last          = ((@total_results-1) / @limit) + 1
+      @next          = @current + 1 if @current < @last
+      @previous      = @current - 1 if @current > 1
+      @current_range = ((@offset+1)..([@offset+@limit, @total_results].min))
+
+      (@first..@last).each do |page|
+        self[page-1] = Page.new((page-1) * @per_page, @per_page, page, @per_page)
+      end
+    end
+  end
+end

data/lib/sinatra/squirrel.rb

@@ -0,0 +1,537 @@
+
+require File.dirname(__FILE__) + '/paginator.rb'
+
+# Squirrel is a library for making querying the database using ActiveRecord cleaner, easier
+# to read, and less prone to user error. It does this by allowing AR::Base#find to take a block,
+# which is run to build the conditions and includes required to execute the query.
+module Squirrel
+  # When included in AR::Base, it chains the #find method to allow for block execution.
+  module Hook
+    def find_with_squirrel *args, &blk
+      args ||= [:all]
+      if blk || (args.last.is_a?(Hash) && args.last.has_key?(:paginate))
+        query = Query.new(self, &blk)
+        query.execute(*args)
+      else
+        find_without_squirrel(*args)
+      end
+    end
+
+    def scoped_with_squirrel *args, &blk
+      if blk
+        query = Query.new(self, &blk)
+        self.scoped(query.to_find_parameters)
+      else
+        scoped_without_squirrel(*args)
+      end
+    end
+
+    def self.included base
+      if ! base.instance_methods.include?('find_without_squirrel') &&
+           base.instance_methods.include?('find')
+        base.class_eval do
+          alias_method :find_without_squirrel, :find
+          alias_method :find, :find_with_squirrel
+        end
+      end
+      if ! base.instance_methods.include?('scoped_without_squirrel') &&
+           base.instance_methods.include?('scoped')
+        base.class_eval do
+          alias_method :scoped_without_squirrel, :scoped
+          alias_method :scoped, :scoped_with_squirrel
+        end
+      end
+    end
+  end
+
+  module NamedScopeHook
+    def scoped *args, &blk
+      args = blk ? [Query.new(self, &blk).to_find_parameters] : args
+      scopes[:scoped].call(self, *args)
+    end
+  end
+
+  # The Query is what contains the query and is what handles execution and pagination of the
+  # result set.
+  class Query
+    attr_reader :conditions, :model
+
+    # Creates a Query specific to the given model (which is a class that descends from AR::Base)
+    # and a block that will be run to find the conditions for the #find call.
+    def initialize model, &blk
+      @model      = model
+      @joins      = nil
+      @binding    = blk && blk.binding
+      @conditions = ConditionGroup.new(@model, "AND", @binding, &blk)
+      @conditions.assign_joins( join_dependency )
+    end
+    
+    # Builds the dependencies needed to find what AR plans to call the tables in the query
+    # by finding and sending what would be passed in as the +include+ parameter to #find.
+    # This is a necessary step because what AR calls tables deeply nested might not be
+    # completely obvious.)
+    def join_dependency
+      jd = ::ActiveRecord::Associations::ClassMethods::JoinDependency
+      @join_dependency ||= jd.new model, 
+                                  @conditions.to_find_include, 
+                                  nil
+    end
+
+    # Runs the block which builds the conditions. If requested, paginates the result_set.
+    # If the first parameter to #find is :query (instead of :all or :first), then the query
+    # object itself is returned. Useful for debugging, but not much else.
+    def execute *args
+      if args.first == :query
+        self
+      else
+        opts = args.last.is_a?(Hash) ? args.last : {}
+        results = []
+        pagination = opts.delete(:paginate) || {}
+        model.send(:with_scope, :find => opts) do
+          @conditions.paginate(pagination) unless pagination.empty?
+          results = model.find args[0], to_find_parameters
+          if @conditions.paginate?
+            paginate_result_set results, to_find_parameters
+          end
+        end
+        results
+      end
+    end
+
+    def to_find_parameters
+      find_parameters = {}
+      find_parameters[:conditions] = to_find_conditions unless to_find_conditions.blank?
+      find_parameters[:include   ] = to_find_include    unless to_find_include.blank?
+      find_parameters[:order     ] = to_find_order      unless to_find_order.blank?
+      find_parameters[:limit     ] = to_find_limit      unless to_find_limit.blank?
+      find_parameters[:offset    ] = to_find_offset     unless to_find_offset.blank?
+      find_parameters
+    end
+
+    # Delegates the to_find_conditions call to the root ConditionGroup
+    def to_find_conditions
+      @conditions.to_find_conditions
+    end
+
+    # Delegates the to_find_include call to the root ConditionGroup
+    def to_find_include
+      @conditions.to_find_include
+    end
+
+    # Delegates the to_find_order call to the root ConditionGroup
+    def to_find_order
+      @conditions.to_find_order
+    end
+
+    # Delegates the to_find_limit call to the root ConditionGroup
+    def to_find_limit
+      @conditions.to_find_limit
+    end
+
+    # Delegates the to_find_offset call to the root ConditionGroup
+    def to_find_offset
+      @conditions.to_find_offset
+    end
+
+    # Used by #execute to paginates the result set if 
+    # pagination was requested. In this case, it adds +pages+ and +total_results+ accessors
+    # to the result set. See Paginator for more details.
+    def paginate_result_set set, conditions
+      limit  = conditions.delete(:limit)
+      offset = conditions.delete(:offset)
+
+      class << set
+        attr_reader :pages
+        attr_reader :total_results
+      end
+
+      total_results = model.count(conditions)
+      set.instance_variable_set("@pages", 
+                                Paginator.new( :count => total_results, 
+                                               :limit => limit, 
+                                               :offset => offset) )
+      set.instance_variable_set("@total_results", total_results)
+      set.extend( Squirrel::WillPagination )
+    end
+    
+    # ConditionGroups are groups of Conditions, oddly enough. They most closely map to models
+    # in your schema, but they also handle the grouping jobs for the #any and #all blocks.
+    class ConditionGroup
+      attr_accessor :model, :logical_join, :binding, :reflection, :path
+
+      # Creates a ConditionGroup by passing in the following arguments:
+      # * model: The AR subclass that defines what columns and associations will be accessible
+      #   in the given block.
+      # * logical_join: A string containing the join that will be used when concatenating the 
+      #   conditions together. The root level ConditionGroup created by Query defaults the 
+      #   join to be "AND", but the #any and #all methods will create specific ConditionGroups
+      #   using "OR" and "AND" as their join, respectively.
+      # * binding: The +binding+ of the block passed to the original #find. Will be used to
+      #   +eval+ what +self+ would be. This is necessary for using methods like +params+ and 
+      #   +session+ in your controllers.
+      # * path: The "path" taken through the models to arrive at this model. For example, if
+      #   your User class has_many Posts which has_many Comments each of which belongs_to User,
+      #   the path to the second User would be [:posts, :comments, :user]
+      # * reflection: The association used to get to this block. If nil, then no new association
+      #   was traversed, which means we're in an #any or #all grouping block.
+      # * blk: The block to be executed.
+      #
+      # This method defines a number of methods to be available inside the block, one for each
+      # of the columns and associations in the specified model. Note that you CANNOT use
+      # user-defined methods on your model inside Squirrel queries. They don't have any meaning
+      # in the context of a database query.
+      def initialize model, logical_join, binding, path = nil, reflection = nil, &blk
+        @model            = model
+        @logical_join     = logical_join
+        @conditions       = []
+        @condition_blocks = []
+        @reflection       = reflection
+        @path             = [ path, reflection ].compact.flatten
+        @binding          = binding
+        @order            = []
+        @negative         = false
+        @paginator        = false
+        @block            = blk
+
+        existing_methods = self.class.instance_methods(false)
+        (model.column_names - existing_methods).each do |col|
+          (class << self; self; end).class_eval do
+            define_method(col.to_s.intern) do
+              column(col)
+            end
+          end
+        end
+        (model.reflections.keys - existing_methods).each do |assn|
+          (class << self; self; end).class_eval do
+            define_method(assn.to_s.intern) do
+              association(assn)
+            end
+          end
+        end
+
+        execute_block
+      end
+
+      # Creates a Condition and queues it for inclusion. When calling a method defined
+      # during the creation of the ConditionGroup object is the same as calling column(:column_name).
+      # This is useful if you need to access a column that happens to coincide with the name of
+      # an already-defined method (e.g. anything returned by instance_methods(false) for the
+      # given model).
+      def column name
+        @conditions << Condition.new(name)
+        @conditions.last
+      end
+
+      # Similar to #column, this will create an association even if you can't use the normal
+      # method version.
+      def association name, &blk
+        name = name.to_s.intern
+        ref = @model.reflect_on_association(name)
+        @condition_blocks << ConditionGroup.new(ref.klass, logical_join, binding, path, ref.name, &blk)
+        @condition_blocks.last
+      end
+
+      # Creates a ConditionGroup that has the logical_join set to "OR".
+      def any &blk
+        @condition_blocks << ConditionGroup.new(model, "OR", binding, path, &blk)
+        @condition_blocks.last
+      end
+
+      # Creates a ConditionGroup that has the logical_join set to "AND".
+      def all &blk
+        @condition_blocks << ConditionGroup.new(model, "AND", binding, path, &blk)
+        @condition_blocks.last
+      end
+      
+      # Sets the arguments for the :order parameter. Arguments can be columns (i.e. Conditions)
+      # or they can be strings (for "RANDOM()", etc.). If a Condition is used, and the column is
+      # negated using #not or #desc, then the resulting specification in the ORDER clause will 
+      # be ordered descending. That is, "order_by name.desc" will become "ORDER name DESC"
+      def order_by *columns
+        @order += [columns].flatten
+      end
+      
+      # Flags the result set to be paginated according to the :page and :per_page parameters
+      # to this method.
+      def paginate opts = {}
+        @paginator = true
+        page     = (opts[:page]     || 1).to_i
+        per_page = (opts[:per_page] || 20).to_i
+        page     = 1 if page < 1
+        limit( per_page, ( page - 1 ) * per_page )
+      end
+      
+      # Similar to #paginate, but does not flag the result set for pagination. Takes a limit
+      # and an offset (by default the offset is 0).
+      def limit lim, off = nil
+        @limit  = ( lim || @limit ).to_i
+        @offset = ( off || @offset ).to_i
+      end
+      
+      # Returns true if this ConditionGroup or any of its subgroups have been flagged for pagination.
+      def paginate?
+        @paginator || @condition_blocks.any?(&:paginate?)
+      end
+      
+      # Negates the condition. Essentially prefixes the condition with NOT in the final query.
+      def -@
+        @negative = !@negative
+        self
+      end
+
+      alias_method :desc, :-@
+
+      # Negates the condition. Also works to negate ConditionGroup blocks in a more straightforward
+      # manner, like so:
+      #   any.not do
+      #     id == 1
+      #     name == "Joe"
+      #   end
+      # 
+      #   # => "NOT( id = 1 OR name = 'Joe')"
+      def not &blk
+        @negative = !@negative
+        if blk
+          @block = blk
+          execute_block
+        end
+      end
+
+      # Takes the JoinDependency object and filters it down through the ConditionGroups
+      # to make sure each one knows the aliases necessary to refer to each table by its
+      # correct name.
+      def assign_joins join_dependency, ancestries = nil
+        ancestries ||= join_dependency.join_associations.map{|ja| ja.ancestry }
+        unless @conditions.empty?
+          my_association = unless @path.blank?
+                             join_dependency.join_associations[ancestries.index(@path)]
+                           else 
+                             join_dependency.join_base
+                           end
+          @conditions.each do |column|
+            column.assign_join(my_association)
+          end
+        end
+        @condition_blocks.each do |association|
+          association.assign_joins(join_dependency, ancestries)
+        end
+      end
+
+      # Generates the parameter for :include for this ConditionGroup and all its subgroups.
+      def to_find_include
+        @condition_blocks.inject({}) do |inc, cb|
+          if cb.reflection.nil?
+            inc.merge_tree(cb.to_find_include)
+          else
+            inc[cb.reflection] ||= {}
+            inc[cb.reflection] = inc[cb.reflection].merge_tree(cb.to_find_include)
+            inc
+          end
+        end
+      end
+      
+      # Generates the :order parameter for this ConditionGroup. Because this does not reference
+      # subgroups it should only be used from the outermost block (which is probably where it makes
+      # the most sense to reference it, but it's worth mentioning)
+      def to_find_order
+        if @order.blank?
+          nil
+        else
+          @order.collect do |col| 
+            col.respond_to?(:full_name) ? (col.full_name + (col.negative? ? " DESC" : "")) : col 
+          end.join(", ")
+        end
+      end
+
+      # Generates the :conditions parameter for this ConditionGroup and all subgroups. It
+      # generates them in ["sql", params] format because of the requirements of LIKE, etc.
+      def to_find_conditions
+        segments = conditions.collect{|c| c.to_find_conditions }.compact
+        return nil if segments.length == 0
+        cond = "(" + segments.collect{|s| s.first }.join(" #{logical_join} ") + ")"
+        cond = "NOT #{cond}" if negative?
+        
+        values = segments.inject([]){|all, now| all + now[1..-1] }
+        [ cond, *values ]
+      end
+
+      # Generates the :limit parameter.
+      def to_find_limit
+        @limit
+      end
+
+      # Generates the :offset parameter.
+      def to_find_offset
+        @offset
+      end
+
+      # Returns all the conditions, which is the union of the Conditions and ConditionGroups
+      # that belong to this ConditionGroup.
+      def conditions
+        @conditions + @condition_blocks
+      end
+      
+      # Returns true if this block has been negated using #not, #desc, or #-
+      def negative?
+        @negative
+      end
+
+      # This is a bit of a hack, due to how Squirrel is built. It can be used to fetch
+      # instance variables from the location where the call to #find was made. For example,
+      # if called from within your model and you happened to have an instance variable called
+      # "@foo", you can access it by calling
+      #   instance "@foo"
+      # from within your Squirrel query.
+      def instance instance_var
+        s = eval("self", binding)
+        if s
+          s.instance_variable_get(instance_var)
+        end
+      end
+
+      private
+
+      def execute_block #:nodoc:
+        instance_eval &@block if @block
+      end
+
+      def method_missing meth, *args #:nodoc:
+        m = eval <<-end_eval, binding
+          begin
+            method(:#{meth})
+          rescue NameError
+            nil
+          end
+        end_eval
+        if m
+          m.call(*args)
+        else
+          super(meth, *args)
+        end
+      end
+
+    end
+
+    # Handles comparisons in the query. This class is analagous to the columns in the database.
+    # When comparing the Condition to a value, the operators are used as follows:
+    # * ==, === : Straight-up Equals. Can also be used as the "IN" operator if the operand is an Array.
+    #   Additionally, when the oprand is +nil+, the comparison is correctly generates as "IS NULL"."
+    # * =~ : The LIKE and REGEXP operators. If the operand is a String, it will generate a LIKE
+    #   comparison. If it is a Regexp, the REGEXP operator will be used. NOTE: MySQL regular expressions
+    #   are NOT the same as Ruby regular expressions. Also NOTE: No wildcards are inserted into the LIKE
+    #   comparison, so you may add them where you wish.
+    # * <=> : Performs a BETWEEN comparison, as long as the operand responds to both #first and #last,
+    #   which both Ranges and Arrays do.
+    # * > : A simple greater-than comparison.
+    # * >= : Greater-than or equal-to.
+    # * < : A simple less-than comparison.
+    # * <= : Less-than or equal-to.
+    # * contains? : Like =~, except automatically surrounds the operand in %s, which =~ does not do.
+    # * nil? : Works exactly like "column == nil", but in a nicer syntax, which is what Squirrel is all about.
+    class Condition
+      attr_reader :name, :operator, :operand
+
+      # Creates and Condition with the given name.
+      def initialize name
+        @name = name
+        @sql = nil
+        @negative = false
+      end
+
+      [ :==, :===, :=~, :<=>, :<=, :<, :>, :>= ].each do |op|
+        define_method(op) do |val|
+          @operator = op
+          @operand = val
+          self
+        end
+      end
+
+      def contains? val #:nodoc:
+        @operator = :contains
+        @operand = val
+        self
+      end
+
+      def nil? #:nodoc:
+        @operator = :==
+        @operand = nil
+        self
+      end
+      
+      def -@ #:nodoc:
+        @negative = !@negative
+        self
+      end
+
+      alias_method :not, :-@
+      alias_method :desc, :-@
+
+      # Returns true if this Condition has been negated, which means it will be prefixed with "NOT"
+      def negative?
+        @negative
+      end
+      
+      # Gets the name of the table that this Condition refers to by taking it out of the
+      # association object.
+      def assign_join association = nil
+        @table_alias = association ? "#{association.aliased_table_name}." : ""
+      end
+  
+      # Returns the full name of the column, including any assigned table alias.
+      def full_name
+        "#{@table_alias}#{name}"
+      end
+
+      # Generates the :condition parameter for this Condition, in ["sql", args] format.]
+      def to_find_conditions(join_association = {})
+        return nil if operator.nil?
+        
+        op, arg_format, values = operator, "?", [operand]
+        op, arg_format, values = case operator
+        when :<=>        then    [ "BETWEEN", "? AND ?",   [ operand.first, operand.last ] ]
+        when :=~         then
+          case operand
+          when String    then    [ "LIKE",    arg_format,  values ]
+          when Regexp    then    [ "REGEXP",  arg_format,  values.map(&:source) ]
+          end
+        when :==, :===   then
+          case operand
+          when Array     then    [ "IN",      "(?)",             values ]
+          when Range     then    [ "IN",      "(?)",             values ]
+          when Condition then    [ "=",       operand.full_name, [] ] 
+          when nil       then    [ "IS",      "NULL",            [] ]
+          else                   [ "=",       arg_format,        values ]
+          end
+        when :contains   then    [ "LIKE",    arg_format,        values.map{|v| "%#{v}%" } ]
+        else
+          case operand
+          when Condition then    [ op,        oprand.full_name,  [] ] 
+          else                   [ op,        arg_format,        values ]
+          end
+        end		
+        sql = "#{full_name} #{op} #{arg_format}"
+        sql = "NOT (#{sql})" if @negative
+        [ sql, *values ]
+      end
+
+    end
+  end
+end
+
+class << ActiveRecord::Base
+  include Squirrel::Hook
+end
+
+if defined?(ActiveRecord::NamedScope::Scope)
+  class ActiveRecord::NamedScope::Scope
+    include Squirrel::NamedScopeHook
+  end
+end
+
+[ ActiveRecord::Associations::HasManyAssociation,
+  ActiveRecord::Associations::HasAndBelongsToManyAssociation,
+  ActiveRecord::Associations::HasManyThroughAssociation
+  ].each do |association_class|
+    association_class.send(:include, Squirrel::Hook)
+  end
+  

data/sinatra-squirrel.gemspec

@@ -0,0 +1,48 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sinatra-squirrel}
+  s.version = "0.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["twilson63"]
+  s.date = %q{2009-06-17}
+  s.email = %q{tom@jackrussellsoftware.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "lib/sinatra/extensions.rb",
+     "lib/sinatra/paginator.rb",
+     "lib/sinatra/squirrel.rb",
+     "sinatra-squirrel.gemspec",
+     "test/sinatra-squirrel_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/twilson63/sinatra-squirrel}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Port of Thought Bot Squirrel to Sinatra}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/sinatra-squirrel_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/sinatra-squirrel_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class SinatraSquirrelTest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'sinatra-squirrel'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: twilson63-sinatra-squirrel
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- twilson63
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-17 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: tom@jackrussellsoftware.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/sinatra/extensions.rb
+- lib/sinatra/paginator.rb
+- lib/sinatra/squirrel.rb
+- sinatra-squirrel.gemspec
+- test/sinatra-squirrel_test.rb
+- test/test_helper.rb
+has_rdoc: false
+homepage: http://github.com/twilson63/sinatra-squirrel
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Port of Thought Bot Squirrel to Sinatra
+test_files: 
+- test/test_helper.rb
+- test/sinatra-squirrel_test.rb