challah 0.5.0 → 0.5.1

data/vendor/bundle/gems/arel-3.0.0/test/visitors/test_to_sql.rb

@@ -1,347 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    describe 'the to_sql visitor' do
-      before do
-        @visitor = ToSql.new Table.engine.connection
-        @table = Table.new(:users)
-        @attr = @table[:id]
-      end
-
-      it 'can define a dispatch method' do
-        visited = false
-        viz = Class.new(Arel::Visitors::Visitor) {
-          define_method(:hello) do |node|
-            visited = true
-          end
-
-          def dispatch
-            { Arel::Table => 'hello' }
-          end
-        }.new
-
-        viz.accept(@table)
-        assert visited, 'hello method was called'
-      end
-
-      it 'should not quote sql literals' do
-        node = @table[Arel.star]
-        sql = @visitor.accept node
-        sql.must_be_like '"users".*'
-      end
-
-      it 'should visit named functions' do
-        function = Nodes::NamedFunction.new('omg', [Arel.star])
-        assert_equal 'omg(*)', @visitor.accept(function)
-      end
-
-      it 'should chain predications on named functions' do
-        function = Nodes::NamedFunction.new('omg', [Arel.star])
-        sql = @visitor.accept(function.eq(2))
-        sql.must_be_like %{ omg(*) = 2 }
-      end
-
-      it 'works with lists' do
-        function = Nodes::NamedFunction.new('omg', [Arel.star, Arel.star])
-        assert_equal 'omg(*, *)', @visitor.accept(function)
-      end
-
-      describe 'equality' do
-        it 'should handle false' do
-          sql = @visitor.accept Nodes::Equality.new(false, false)
-          sql.must_be_like %{ 'f' = 'f' }
-        end
-
-        it 'should use the column to quote' do
-          table = Table.new(:users)
-          sql = @visitor.accept Nodes::Equality.new(table[:id], '1-fooo')
-          sql.must_be_like %{ "users"."id" = 1 }
-        end
-      end
-
-      it "should visit string subclass" do
-        @visitor.accept(Class.new(String).new(":'("))
-        @visitor.accept(Class.new(Class.new(String)).new(":'("))
-      end
-
-      it "should visit_Class" do
-        @visitor.accept(DateTime).must_equal "'DateTime'"
-      end
-
-      it "should escape LIMIT" do
-        sc = Arel::Nodes::SelectStatement.new
-        sc.limit = Arel::Nodes::Limit.new("omg")
-        assert_match(/LIMIT 'omg'/, @visitor.accept(sc))
-      end
-
-      it "should visit_DateTime" do
-        @visitor.accept DateTime.now
-      end
-
-      it "should visit_Float" do
-        @visitor.accept 2.14
-      end
-
-      it "should visit_Not" do
-        sql = @visitor.accept Nodes::Not.new(Arel.sql("foo"))
-        sql.must_be_like "NOT (foo)"
-      end
-
-      it "should apply Not to the whole expression" do
-        node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
-        sql = @visitor.accept Nodes::Not.new(node)
-        sql.must_be_like %{NOT ("users"."id" = 10 AND "users"."id" = 11)}
-      end
-
-      it "should visit_As" do
-        as = Nodes::As.new(Arel.sql("foo"), Arel.sql("bar"))
-        sql = @visitor.accept as
-        sql.must_be_like "foo AS bar"
-      end
-
-      it "should visit_Bignum" do
-        @visitor.accept 8787878092
-      end
-
-      it "should visit_Hash" do
-        @visitor.accept({:a => 1})
-      end
-
-      it "should visit_BigDecimal" do
-        @visitor.accept BigDecimal.new('2.14')
-      end
-
-      it "should visit_Date" do
-        @visitor.accept Date.today
-      end
-
-      it "should visit_NilClass" do
-        @visitor.accept(nil).must_be_like "NULL"
-      end
-
-      it "should visit_Arel_Nodes_And" do
-        node = Nodes::And.new [@attr.eq(10), @attr.eq(11)]
-        @visitor.accept(node).must_be_like %{
-          "users"."id" = 10 AND "users"."id" = 11
-        }
-      end
-
-      it "should visit_Arel_Nodes_Or" do
-        node = Nodes::Or.new @attr.eq(10), @attr.eq(11)
-        @visitor.accept(node).must_be_like %{
-          "users"."id" = 10 OR "users"."id" = 11
-        }
-      end
-
-      it "should visit visit_Arel_Attributes_Time" do
-        attr = Attributes::Time.new(@attr.relation, @attr.name)
-        @visitor.accept attr
-      end
-
-      it "should visit_TrueClass" do
-        test = Table.new(:users)[:bool].eq(true)
-        @visitor.accept(test).must_be_like %{ "users"."bool" = 't' }
-      end
-
-      describe "Nodes::Ordering" do
-        it "should know how to visit" do
-          node = @attr.desc
-          @visitor.accept(node).must_be_like %{
-            "users"."id" DESC
-          }
-        end
-      end
-
-      describe "Nodes::In" do
-        it "should know how to visit" do
-          node = @attr.in [1, 2, 3]
-          @visitor.accept(node).must_be_like %{
-            "users"."id" IN (1, 2, 3)
-          }
-        end
-
-        it "should turn empty right to NULL" do
-          node = @attr.in []
-          @visitor.accept(node).must_be_like %{
-            "users"."id" IN (NULL)
-          }
-        end
-
-        it 'can handle two dot ranges' do
-          node = @attr.in 1..3
-          @visitor.accept(node).must_be_like %{
-            "users"."id" BETWEEN 1 AND 3
-          }
-        end
-
-        it 'can handle three dot ranges' do
-          node = @attr.in 1...3
-          @visitor.accept(node).must_be_like %{
-            "users"."id" >= 1 AND "users"."id" < 3
-          }
-        end
-
-        it 'can handle subqueries' do
-          table = Table.new(:users)
-          subquery = table.project(:id).where(table[:name].eq('Aaron'))
-          node = @attr.in subquery
-          @visitor.accept(node).must_be_like %{
-            "users"."id" IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
-          }
-        end
-
-        it 'uses the same column for escaping values' do
-        @attr = Table.new(:users)[:name]
-          visitor = Class.new(ToSql) do
-            attr_accessor :expected
-
-            def quote value, column = nil
-              raise unless column == expected
-              super
-            end
-          end
-          in_node = Nodes::In.new @attr, %w{ a b c }
-          visitor = visitor.new(Table.engine.connection)
-          visitor.expected = Table.engine.connection.columns(:users).find { |x|
-            x.name == 'name'
-          }
-          visitor.accept(in_node).must_equal %("users"."name" IN ('a', 'b', 'c'))
-        end
-      end
-
-      describe "Nodes::InfixOperation" do
-        it "should handle Multiplication" do
-          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) * Arel::Attributes::Decimal.new(Table.new(:currency_rates), :rate)
-          @visitor.accept(node).must_equal %("products"."price" * "currency_rates"."rate")
-        end
-
-        it "should handle Division" do
-          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) / 5
-          @visitor.accept(node).must_equal %("products"."price" / 5)
-        end
-
-        it "should handle Addition" do
-          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) + 6
-          @visitor.accept(node).must_equal %(("products"."price" + 6))
-        end
-
-        it "should handle Subtraction" do
-          node = Arel::Attributes::Decimal.new(Table.new(:products), :price) - 7
-          @visitor.accept(node).must_equal %(("products"."price" - 7))
-        end
-
-        it "should handle arbitrary operators" do
-          node = Arel::Nodes::InfixOperation.new(
-            '||',
-            Arel::Attributes::String.new(Table.new(:products), :name),
-            Arel::Attributes::String.new(Table.new(:products), :name)
-          )
-          @visitor.accept(node).must_equal %("products"."name" || "products"."name")
-        end
-      end
-
-      describe "Nodes::NotIn" do
-        it "should know how to visit" do
-          node = @attr.not_in [1, 2, 3]
-          @visitor.accept(node).must_be_like %{
-            "users"."id" NOT IN (1, 2, 3)
-          }
-        end
-
-        it "should turn empty right to NULL" do
-          node = @attr.not_in []
-          @visitor.accept(node).must_be_like %{
-            "users"."id" NOT IN (NULL)
-          }
-        end
-
-        it 'can handle two dot ranges' do
-          node = @attr.not_in 1..3
-          @visitor.accept(node).must_be_like %{
-            "users"."id" < 1 OR "users"."id" > 3
-          }
-        end
-
-        it 'can handle three dot ranges' do
-          node = @attr.not_in 1...3
-          @visitor.accept(node).must_be_like %{
-            "users"."id" < 1 OR "users"."id" >= 3
-          }
-        end
-
-        it 'can handle subqueries' do
-          table = Table.new(:users)
-          subquery = table.project(:id).where(table[:name].eq('Aaron'))
-          node = @attr.not_in subquery
-          @visitor.accept(node).must_be_like %{
-            "users"."id" NOT IN (SELECT id FROM "users" WHERE "users"."name" = 'Aaron')
-          }
-        end
-
-        it 'uses the same column for escaping values' do
-        @attr = Table.new(:users)[:name]
-          visitor = Class.new(ToSql) do
-            attr_accessor :expected
-
-            def quote value, column = nil
-              raise unless column == expected
-              super
-            end
-          end
-          in_node = Nodes::NotIn.new @attr, %w{ a b c }
-          visitor = visitor.new(Table.engine.connection)
-          visitor.expected = Table.engine.connection.columns(:users).find { |x|
-            x.name == 'name'
-          }
-          visitor.accept(in_node).must_equal %("users"."name" NOT IN ('a', 'b', 'c'))
-        end
-      end
-
-      describe 'Equality' do
-        it "should escape strings" do
-          test = Table.new(:users)[:name].eq 'Aaron Patterson'
-          @visitor.accept(test).must_be_like %{
-            "users"."name" = 'Aaron Patterson'
-          }
-        end
-      end
-
-      describe 'Constants' do
-        it "should handle true" do
-          test = Table.new(:users).create_true
-          @visitor.accept(test).must_be_like %{
-            TRUE
-          }
-        end
-
-        it "should handle false" do
-          test = Table.new(:users).create_false
-          @visitor.accept(test).must_be_like %{
-            FALSE
-          }
-        end
-      end
-
-      describe 'TableAlias' do
-        it "should use the underlying table for checking columns" do
-          test = Table.new(:users).alias('zomgusers')[:id].eq '3'
-          @visitor.accept(test).must_be_like %{
-            "zomgusers"."id" = 3
-          }
-        end
-      end
-
-      describe 'distinct on' do
-        it 'raises not implemented error' do
-          core = Arel::Nodes::SelectCore.new
-          core.set_quantifier = Arel::Nodes::DistinctOn.new(Arel.sql('aaron'))
-
-          assert_raises(NotImplementedError) do
-            @visitor.accept(core)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/factory_girl-2.5.1/Appraisals

@@ -1,20 +0,0 @@
-appraise "2.1" do
-  gem "test-unit", "~> 2.3.0", :platforms => [:mri_19]
-  gem "activerecord", "~> 2.1"
-end
-
-appraise "2.3" do
-  gem "activerecord", "~> 2.3"
-end
-
-appraise "3.0" do
-  gem "activerecord", "~> 3.0"
-end
-
-appraise "3.1" do
-  gem "activerecord", "~> 3.1"
-end
-
-appraise "3.2" do
-  gem "activerecord", "~> 3.2"
-end

data/vendor/bundle/gems/factory_girl-2.5.1/Changelog

@@ -1,128 +0,0 @@
-2.5.1 (February 3, 2012)
-  Fix attribute evaluation when the attribute isn't defined in the factory but
-    is a private method on Object
-  Update rubygems on Travis before running tests
-  Fix spec name
-  Update GETTING_STARTED with correct usage of build_stubbed
-  Update README with more info on initialize_with
-  Honor :parent on factory over block nesting
-
-2.5.0 (January 20, 2012)
-  Revert 'Deprecate build_stubbed and attributes_for'
-  Implement initialize_with to allow overriding object instantiation
-  Ensure FG runs against Rails 3.2.0
-
-2.4.2 (January 18, 2012)
-  Fix inline traits' interaction with defaults on the factory
-
-2.4.1 (January 17, 2012)
-  Deprecate build_stubbed and attributes_for
-  Fix inline traits
-
-2.4.0 (January 13, 2012)
-  Refactor internals of Factory Girl to use anonymous class on which attributes
-    get defined
-  Explicitly require Ruby 1.8.7 or higher in gemspec
-  Fix documentation
-  Add Gemnasium status to documentation
-  Supplying a Class to a factory that overrides to_s no longer results in
-    getting the wrong Class constructed
-  Be more agnostic about ORMs when using columns in Factory Girl step
-    definitions
-  Test against Active Record 3.2.0.rc2
-  Update GETTING_STARTED to use Ruby syntax highlighting
-
-2.3.2 (November 26, 2011)
-  Move logic of where instance.save! is set to Definition
-  Fix method name from aliases_for? to alias_for?
-  Refactor internal attribute handling to use an anonymous class instead of
-    faking Ruby's variable resolution. This allows for more sane usage of
-    attributes without having to manage sorting priority because attributes
-    can turn themselves into procs, which are used with define_method on a
-    class so attributes work correctly all the time.
-
-2.3.1 (November 23, 2011)
-  Remove internally-used associate method from all the FactoryGirl::Proxy subclasses
-  Move around requiring of files
-  Consolidate errors into factory_girl.rb
-  Refactor AttributeList to deal with priority only when iterating over
-    attributes
-  Refactor internals of some of the Proxy subclasses
-  Ensure callbacks on traits are executed in the correct order
-
-2.3.0 (November 18, 2011)
-  Registries are named, resulting in better messages when factories, traits,
-    or sequences cannot be found
-  Fix incorrect tests
-  Internals refactoring introducing FactoryGirl::NullFactory,
-    FactoryGirl::Definition, and FactoryGirl::DeclarationList
-  Use ActiveSupport for Hash#except and its delegation capabilities
-  Fix usage of callbacks when added via implicit traits
-  Use Bundler tasks and clean up dependencies
-  Fix failing spec for big letters in factory name passed as symbol
-  Add ability for traits to be added dynamically when creating an instance via
-    build, create, build_stubbed, or attributes_for
-
-2.2.0 (October 14, 2011)
-  Clean up RSpec suite to not use 'should'
-  Use create_list in step definitions
-  Syntax methods that deal with ORM interaction (attributes_for, build, build_stubbed,
-    and create) now accept a block that yields the result. This results in a
-    more convenient way to interact with the result than using Object.tap.
-  Standardize deprecation warnings
-  Update transient attribute syntax to use blocks instead of calling ignore on
-    each attribute declaration
-  Parents can be defined after children because factories are evaluated when
-    they're used; this means breaking up factories across multiple files will
-    behave as expected
-  Large internal refactoring, including changing access modifiers for a
-    handful of methods for a more clearly defined API
-
-2.1.2 (September 23, 2011)
-  Bugfix: Vintage syntax fixed after bug introduced in 2.1.1
-  Introduce dependency on activesupport to remove code from Factory class
-
-2.1.1 (September 23, 2011) (yanked)
-  Bugfix: Parent object callbacks are run before child object callbacks
-  Declarations: allow overriding/modification of individual traits in child factories
-  Callbacks refactored to not be attributes
-  Updating documentation for formatting and clarity (incl. new specificity for cucumber)
-
-2.1.0 (September 02, 2011)
-  Bugfix: created_at now defined for stubbed models
-  Gemspec updated for use with Rails 3.1
-  Factories can now be modified post-definition (useful for overriding defaults from gems/plugins)
-  All factories can now be reloaded with Factory.reload
-  Add :method => build to factory associations to prevent saving of associated objects
-  Factories defined in {Rails.root}/factories are now loaded by default
-  Various documentation updates
-
-1.1.4 (November 28, 2008)
-  Factory.build now uses Factory.create for associations of the built object
-  Factory definitions are now detected in subdirectories, such as
-		factories/person_factory.rb (thanks to Josh Nichols)
-  Factory definitions are now loaded after the environment in a Rails project
-		(fixes some issues with dependencies being loaded too early) (thanks to
-		Josh Nichols)
-  Factory names ending in 's' no longer cause problems (thanks to Alex Sharp
-		and Josh Owens)
-
-1.1.3 (September 12, 2008)
-  Automatically pull in definitions from factories.rb, test/factories.rb, or
-	spec/factories.rb
-1.1.2 (July 30, 2008)
-  Improved error handling for invalid and undefined factories/attributes
-	Improved handling of strings vs symbols vs classes
-	Added a prettier syntax for handling associations
-  Updated documentation and fixed compatibility with Rails 2.1
-
-1.1.1 (June 23, 2008)
-  The attribute "name" no longer requires using #add_attribute
-
-1.1.0 (June 03, 2008)
-	Added support for dependent attributes
-	Fixed the attributes_for build strategy to not build associations
-  Added support for sequences
-
-1.0.0 (May 31, 2008)
-  First version