sample_models 1.2.6 → 2.0.0

data/vendor/ar_query/lib/ar_query.rb

@@ -1,146 +0,0 @@
-class ARQuery
-  attr_reader :joins
-  
-  def initialize(simple_values={})
-    @simple_values = simple_values
-    @base_condition = Condition.new self
-    @joins = UniqueArray.new simple_values[:joins]
-  end
-
-  def method_missing(sym, *args)
-    if sym == :total_entries=
-      @simple_values[:total_entries] = args.first
-    elsif [:has_conditions?, :boolean_join=].include?(sym)
-      @base_condition.send(sym, *args)
-    else
-      super
-    end
-  end
-  
-  def add_condition(&block)
-    if @base_condition.has_conditions?
-      @base_condition.add_condition do |nested|
-        block.call nested
-      end
-    else
-      block.call @base_condition
-    end
-  end
-  
-  def condition_bind_vars
-    @base_condition.bind_vars
-  end
-  
-  def condition_bind_vars=(arg)
-    @base_condition.bind_vars = arg
-  end
-  
-  def condition_sqls
-    @base_condition.sqls
-  end
-  
-  def conditions
-    @base_condition
-  end
-  
-  def to_hash
-    hash = @simple_values.dup
-    hash[:conditions] = @base_condition.to_conditions if has_conditions?
-    joins = @joins
-    if includes = @simple_values[:include]
-      if includes.is_a?(Array)
-        joins = joins.reject { |join|
-          includes.any? { |inc| inc.to_sym == join.to_sym }
-        }
-      else
-        joins = joins.reject { |join| includes.to_sym == join.to_sym }
-      end
-    end
-    hash[:joins] = joins unless joins.empty?
-    hash
-  end
-  
-  class Condition
-    attr_accessor :bind_vars, :boolean_join
-    attr_reader :ar_query, :sqls
-    
-    def initialize(ar_query)
-      @ar_query = ar_query
-      @bind_vars = []
-      @sqls = SQLs.new
-      @boolean_join = :and
-      @children = []
-    end
-    
-    def []=(attr, value)
-      @sqls << "#{attr} = ?"
-      @bind_vars << value
-    end
-    
-    def add_condition(&block)
-      if has_conditions?
-        @children << Condition.new(@ar_query)
-        yield @children.last
-      else
-        yield self
-      end
-    end
-  
-    def has_conditions?
-      !@sqls.empty?
-    end
-    
-    def to_conditions
-      join_str = @boolean_join == :and ? ' AND ' : ' OR '
-      binds = @bind_vars.dup || []
-      condition_sql_fragments = @sqls.map { |c_sql| "(#{c_sql})" }
-      @children.each do |child|
-        sub_conditions = child.to_conditions
-        if sub_conditions
-          if sub_conditions.is_a?(Array)
-            sql = sub_conditions.first
-            sub_binds = sub_conditions[1..-1]
-            condition_sql_fragments << "(#{sql})"
-            binds.concat sub_binds
-          else
-            condition_sql_fragments << "(#{sub_conditions})"
-          end
-        end
-      end
-      condition_sql = condition_sql_fragments.join(join_str)
-      if binds.empty?
-        condition_sql unless condition_sql == ''
-      else
-        [ condition_sql, *binds ]
-      end
-    end
-  
-    class SQLs < Array
-      def <<(elt)
-        if elt.is_a?(String)
-          super
-        else
-          raise(
-            ArgumentError,
-            "Tried appending #{elt.inspect} to ARQuery::Condition::SQLs: Only strings are allowed"
-          )
-        end
-      end
-    end
-  end
-  
-  class UniqueArray < Array
-    def initialize(values)
-      super()
-      if values
-        values = [values] unless values.is_a?(Array)
-        values.each do |value| self << value; end
-      end
-    end
-    
-    def <<(value)
-      super
-      uniq!
-    end
-  end
-end

data/vendor/ar_query/spec/ar_query_spec.rb

@@ -1,318 +0,0 @@
-require File.dirname(__FILE__) + '/../lib/ar_query'
-
-describe ARQuery do
-  describe '#initialize with no values' do
-    before :all do
-      ar_query = ARQuery.new
-      @hash = ar_query.to_hash
-    end
-    
-    it 'should not have conditions' do
-      @hash[:conditions].should be_nil
-    end
-    
-    it 'should not have joins' do
-      @hash[:joins].should be_nil
-    end
-    
-    it 'should not let you assign like a hash' do
-      lambda {
-        @ar_query[:conditions] = "foo = 'bar'"
-      }.should raise_error(NoMethodError)
-      lambda {
-        @ar_query[:joins] = "foo = 'bar'"
-      }.should raise_error(NoMethodError)
-    end
-  end
-  
-  describe '#initialize with values' do
-    before :all do
-      @ar_query = ARQuery.new(:order => 'id desc', :limit => 25)
-      @hash = @ar_query.to_hash
-    end
-    
-    it 'should have those values in the hash' do
-      @hash[:order].should == 'id desc'
-      @hash[:limit].should == 25
-    end
-    
-    it 'should not have other values in the hash' do
-      @hash[:conditions].should be_nil
-    end
-  end
-  
-  describe "#condition_sqls <<" do
-    before :all do
-      @ar_query = ARQuery.new
-      @ar_query.condition_sqls << "fname is not null"
-      @ar_query.condition_sqls << "lname is not null"
-    end
-    
-    it 'should join the conditions with an AND' do
-      @ar_query.to_hash[:conditions].should ==
-          "(fname is not null) AND (lname is not null)"
-    end
-    
-    it "should prevent you from appending nil" do
-      lambda { @ar_query.condition_sqls << nil }.should raise_error(
-        ArgumentError,
-        "Tried appending nil to ARQuery::Condition::SQLs: Only strings are allowed"
-      )
-    end
-    
-    it "should prevent you from appending a value besides a string" do
-      lambda { @ar_query.condition_sqls << 55 }.should raise_error(
-        ArgumentError,
-        "Tried appending 55 to ARQuery::Condition::SQLs: Only strings are allowed"
-      )
-    end
-  end
-  
-  describe '#condition_sqls << with OR as the boolean join' do
-    before :all do
-      @ar_query = ARQuery.new
-      @ar_query.boolean_join = :or
-      @ar_query.condition_sqls << "fname is not null"
-      @ar_query.condition_sqls << "lname is not null"
-    end
-    
-    it 'should join the conditions with an OR' do
-      @ar_query.to_hash[:conditions].should ==
-          "(fname is not null) OR (lname is not null)"
-    end
-  end
-  
-  describe '#conditions hash usage << with OR as the boolean join' do
-    before :all do
-      @ar_query = ARQuery.new
-      @ar_query.boolean_join = :or
-      @ar_query.conditions[:fname] = 'John'
-      @ar_query.conditions[:lname] = 'Doe'
-    end
-    
-    it 'should join the conditions with an OR' do
-      @ar_query.to_hash[:conditions].should == [
-        "(fname = ?) OR (lname = ?)", 'John', 'Doe'
-      ]
-    end
-  end
-
-  describe '[:conditions]' do
-    describe 'with bind vars' do
-      before :all do
-        @ar_query = ARQuery.new
-        @ar_query.condition_sqls << "fname = ?"
-        @ar_query.condition_sqls << "lname = ?"
-      end
-      
-      describe 'using appends' do
-        before :all do
-          @ar_query.condition_bind_vars << 'Francis'
-          @ar_query.condition_bind_vars << 'Hwang'
-        end
-        
-        it 'should put the bind_vars at the end of the conditions array' do
-          @ar_query.to_hash[:conditions].should ==
-            [ "(fname = ?) AND (lname = ?)", 'Francis', 'Hwang' ]
-        end
-      end
-      
-      describe 'using assignment' do
-        before :all do
-          @ar_query.condition_bind_vars = %w( Francis Hwang )
-        end
-        
-        it 'should put the bind_vars at the end of the conditions array' do
-          @ar_query.to_hash[:conditions].should ==
-            [ "(fname = ?) AND (lname = ?)", 'Francis', 'Hwang' ]
-        end
-      end
-    end
-    
-    describe 'with hash setters' do
-      before :all do
-        @ar_query = ARQuery.new
-        @ar_query.conditions[:fname] = 'John'
-        @ar_query.conditions[:lname] = 'Doe'
-      end
-      
-      it 'should return conditions as an array with bind vars' do
-        @ar_query.to_hash[:conditions].should == [
-          "(fname = ?) AND (lname = ?)", 'John', 'Doe'
-        ]
-      end
-    end
-    
-    describe 'with a combination of hash setters and bind vars' do
-      before :all do
-        @ar_query = ARQuery.new
-        @ar_query.conditions[:fname] = 'John'
-        @ar_query.condition_sqls << "lname = ?"
-        @ar_query.condition_bind_vars << 'Doe'
-      end
-      
-      it 'should return conditions as an array with bind vars' do
-        @ar_query.to_hash[:conditions].should == [
-          "(fname = ?) AND (lname = ?)", 'John', 'Doe'
-        ]
-      end
-    end
-  end
-  
-  describe 'with a nested condition' do
-    before :all do
-      @ar_query = ARQuery.new
-      @ar_query.condition_sqls << "fname = ?"
-      @ar_query.condition_bind_vars << 'Francis'
-      @ar_query.add_condition do |cond|
-        cond.boolean_join = :or
-        cond.sqls << 'lname = ?'
-        cond.sqls << 'lname = ?'
-        cond.bind_vars << 'Hwang'
-        cond.bind_vars << 'Bacon'
-        cond.ar_query.should == @ar_query
-      end
-    end
-    
-    it 'should generate nested conditions in SQL' do
-      @ar_query.to_hash[:conditions].should == [
-        "(fname = ?) AND ((lname = ?) OR (lname = ?))",
-        'Francis', 'Hwang', 'Bacon'
-      ]
-    end
-  end
-  
-  describe 'with a nested condition using hash setters' do
-    before :all do
-      @ar_query = ARQuery.new
-      @ar_query.condition_sqls << "fname = ?"
-      @ar_query.condition_bind_vars << 'Francis'
-      @ar_query.add_condition do |cond|
-        cond.boolean_join = :or
-        cond[:lname] = 'Hwang'
-        cond[:city] = 'Brooklyn'
-        cond.ar_query.should == @ar_query
-      end
-    end
-    
-    it 'should generate nested conditions in SQL' do
-      @ar_query.to_hash[:conditions].should == [
-        "(fname = ?) AND ((lname = ?) OR (city = ?))",
-        'Francis', 'Hwang', 'Brooklyn'
-      ]
-    end
-  end
-  
-  describe "when using the nested condition syntax even though the query isn't nested" do
-    before :all do
-      @ar_query = ARQuery.new
-      @ar_query.add_condition do |cond|
-        cond.boolean_join = :or
-        cond.sqls << "fname = ?"
-        cond.bind_vars << 'Chunky'
-      end
-    end
-    
-    it 'should generate the non-nested condition in SQL' do
-      @ar_query.to_hash[:conditions].should == ["(fname = ?)", 'Chunky']
-    end
-  end
-  
-  describe 'when nesting the nested condition unnecessarily' do
-    before :all do
-      @ar_query = ARQuery.new
-      @ar_query.add_condition do |cond|
-        cond.add_condition do |subcond|
-          subcond.boolean_join = :or
-          subcond.sqls << "fname = ?"
-          subcond.bind_vars << 'Chunky'
-        end
-      end
-    end
-    
-    it 'should generate the non-nested condition in SQL' do
-      @ar_query.to_hash[:conditions].should == ["(fname = ?)", 'Chunky']
-    end
-  end
-  
-  describe 'when calling an empty #add_condition after already adding to condition_sqls' do
-    before :all do
-      @ar_query = ARQuery.new
-      @ar_query.condition_sqls << "published = true"
-      @ar_query.add_condition do |cond|
-      end
-    end
-    
-    it 'should not append anything to the condition' do
-      @ar_query.to_hash[:conditions].should == '(published = true)'
-    end
-  end
-  
-  describe '#joins <<' do
-    describe 'when there are no joins to start' do
-      before :all do
-        @ar_query = ARQuery.new
-        @ar_query.joins << :user
-      end
-      
-      it 'should result in an array of 1 join' do
-        @ar_query.to_hash[:joins].should == [:user]
-      end
-    end
-    
-    describe 'when it was initialized with one join' do
-      before :all do
-        @ar_query = ARQuery.new :joins => :user
-        @ar_query.joins << :tags
-      end
-      
-      it 'should result in an array of 2 joins' do
-        @ar_query.to_hash[:joins].should == [:user, :tags]
-      end
-    end
-    
-    describe 'when there are already two joins' do
-      before :all do
-        @ar_query = ARQuery.new :joins => [:user, :tags]
-        @ar_query.joins << :images
-      end
-      
-      it 'should result in 3 joins' do
-        @ar_query.to_hash[:joins].should == [:user, :tags, :images]
-      end
-    end
-    
-    describe 'when a duplicate join is being appended' do
-      before :all do
-        @ar_query = ARQuery.new :joins => [:user, :tags]
-        @ar_query.joins << :user
-      end
-
-      it 'should not keep the array of joins unique' do
-        @ar_query.to_hash[:joins].should == [:user, :tags]
-      end
-    end
-    
-    describe 'when the same association has already been :included' do
-      before :all do
-        @ar_query = ARQuery.new :include => 'user'
-        @ar_query.joins << :user
-      end
-      
-      it 'should not include the association in the join' do
-        @ar_query.to_hash[:joins].should be_nil
-      end
-    end
-  end
-  
-  describe '#total_entries =' do
-    before :all do
-      @ar_query = ARQuery.new
-      @ar_query.total_entries = 25
-    end
-    
-    it 'should set [:total_entries]' do
-      @ar_query.to_hash[:total_entries].should == 25
-    end
-  end
-end

data/vendor/ar_query/uninstall.rb

@@ -1 +0,0 @@
-# Uninstall hook code here