challah 0.6.1 → 0.6.2

data/vendor/bundle/gems/arel-3.0.0/test/test_table.rb

@@ -1,184 +0,0 @@
-require 'helper'
-
-module Arel
-  describe Table do
-    before do
-      @relation = Table.new(:users)
-    end
-
-    it 'should create join nodes' do
-      join = @relation.create_string_join 'foo'
-      assert_kind_of Arel::Nodes::StringJoin, join
-      assert_equal 'foo', join.left
-    end
-
-    it 'should create join nodes' do
-      join = @relation.create_join 'foo', 'bar'
-      assert_kind_of Arel::Nodes::InnerJoin, join
-      assert_equal 'foo', join.left
-      assert_equal 'bar', join.right
-    end
-
-    it 'should create join nodes with a klass' do
-      join = @relation.create_join 'foo', 'bar', Arel::Nodes::OuterJoin
-      assert_kind_of Arel::Nodes::OuterJoin, join
-      assert_equal 'foo', join.left
-      assert_equal 'bar', join.right
-    end
-
-    it 'should return an insert manager' do
-      im = @relation.compile_insert 'VALUES(NULL)'
-      assert_kind_of Arel::InsertManager, im
-      assert_equal 'INSERT INTO NULL VALUES(NULL)', im.to_sql
-    end
-
-    it 'should return IM from insert_manager' do
-      im = @relation.insert_manager
-      assert_kind_of Arel::InsertManager, im
-      assert_equal im.engine, @relation.engine
-    end
-
-    describe 'skip' do
-      it 'should add an offset' do
-        sm = @relation.skip 2
-        sm.to_sql.must_be_like "SELECT FROM \"users\" OFFSET 2"
-      end
-    end
-
-    describe 'select_manager' do
-      it 'should return an empty select manager' do
-        sm = @relation.select_manager
-        sm.to_sql.must_be_like 'SELECT'
-      end
-    end
-
-    describe 'having' do
-      it 'adds a having clause' do
-        mgr = @relation.having @relation[:id].eq(10)
-        mgr.to_sql.must_be_like %{
-         SELECT FROM "users" HAVING "users"."id" = 10
-        }
-      end
-    end
-
-    describe 'backwards compat' do
-      describe 'join' do
-        it 'noops on nil' do
-          mgr = @relation.join nil
-
-          mgr.to_sql.must_be_like %{ SELECT FROM "users" }
-        end
-
-        it 'takes a second argument for join type' do
-          right     = @relation.alias
-          predicate = @relation[:id].eq(right[:id])
-          mgr = @relation.join(right, Nodes::OuterJoin).on(predicate)
-
-          mgr.to_sql.must_be_like %{
-           SELECT FROM "users"
-             LEFT OUTER JOIN "users" "users_2"
-               ON "users"."id" = "users_2"."id"
-          }
-        end
-      end
-    end
-
-    describe 'group' do
-      it 'should create a group' do
-        manager = @relation.group @relation[:id]
-        manager.to_sql.must_be_like %{
-          SELECT FROM "users" GROUP BY "users"."id"
-        }
-      end
-    end
-
-    describe 'alias' do
-      it 'should create a node that proxies to a table' do
-        @relation.aliases.must_equal []
-
-        node = @relation.alias
-        @relation.aliases.must_equal [node]
-        node.name.must_equal 'users_2'
-        node[:id].relation.must_equal node
-      end
-    end
-
-    describe 'new' do
-      it 'should accept an engine' do
-        rel = Table.new :users, 'foo'
-        rel.engine.must_equal 'foo'
-      end
-
-      it 'should accept a hash' do
-        rel = Table.new :users, :engine => 'foo'
-        rel.engine.must_equal 'foo'
-      end
-
-      it 'ignores as if it equals name' do
-        rel = Table.new :users, :as => 'users'
-        rel.table_alias.must_be_nil
-      end
-    end
-
-    describe 'order' do
-      it "should take an order" do
-        manager = @relation.order "foo"
-        manager.to_sql.must_be_like %{ SELECT FROM "users" ORDER BY foo }
-      end
-    end
-
-    describe 'take' do
-      it "should add a limit" do
-        manager = @relation.take 1
-        manager.project SqlLiteral.new '*'
-        manager.to_sql.must_be_like %{ SELECT * FROM "users" LIMIT 1 }
-      end
-    end
-
-    describe 'project' do
-      it 'can project' do
-        manager = @relation.project SqlLiteral.new '*'
-        manager.to_sql.must_be_like %{ SELECT * FROM "users" }
-      end
-
-      it 'takes multiple parameters' do
-        manager = @relation.project SqlLiteral.new('*'), SqlLiteral.new('*')
-        manager.to_sql.must_be_like %{ SELECT *, * FROM "users" }
-      end
-    end
-
-    describe 'where' do
-      it "returns a tree manager" do
-        manager = @relation.where @relation[:id].eq 1
-        manager.project @relation[:id]
-        manager.must_be_kind_of TreeManager
-        manager.to_sql.must_be_like %{
-          SELECT "users"."id"
-          FROM "users"
-          WHERE "users"."id" = 1
-        }
-      end
-    end
-
-    it "should have a name" do
-      @relation.name.must_equal 'users'
-    end
-
-    it "should have a table name" do
-      @relation.table_name.must_equal 'users'
-    end
-
-    it "should have an engine" do
-      @relation.engine.must_equal Table.engine
-    end
-
-    describe '[]' do
-      describe 'when given a Symbol' do
-        it "manufactures an attribute if the symbol names an attribute within the relation" do
-          column = @relation[:id]
-          column.name.must_equal :id
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/arel-3.0.0/test/test_update_manager.rb

@@ -1,115 +0,0 @@
-require 'helper'
-
-module Arel
-  describe 'update manager' do
-    describe 'new' do
-      it 'takes an engine' do
-        Arel::UpdateManager.new Table.engine
-      end
-    end
-
-    it 'handles limit properly' do
-      table = Table.new(:users)
-      um = Arel::UpdateManager.new Table.engine
-      um.take 10
-      um.table table
-      um.set [[table[:name], nil]]
-      assert_match(/LIMIT 10/, um.to_sql)
-    end
-
-    describe 'set' do
-      it "updates with null" do
-        table = Table.new(:users)
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.set [[table[:name], nil]]
-        um.to_sql.must_be_like %{ UPDATE "users" SET "name" =  NULL }
-      end
-
-      it 'takes a string' do
-        table = Table.new(:users)
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.set Nodes::SqlLiteral.new "foo = bar"
-        um.to_sql.must_be_like %{ UPDATE "users" SET foo = bar }
-      end
-
-      it 'takes a list of lists' do
-        table = Table.new(:users)
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.set [[table[:id], 1], [table[:name], 'hello']]
-        um.to_sql.must_be_like %{
-          UPDATE "users" SET "id" = 1, "name" =  'hello'
-        }
-      end
-
-      it 'chains' do
-        table = Table.new(:users)
-        um = Arel::UpdateManager.new Table.engine
-        um.set([[table[:id], 1], [table[:name], 'hello']]).must_equal um
-      end
-    end
-
-    describe 'table' do
-      it 'generates an update statement' do
-        um = Arel::UpdateManager.new Table.engine
-        um.table Table.new(:users)
-        um.to_sql.must_be_like %{ UPDATE "users" }
-      end
-
-      it 'chains' do
-        um = Arel::UpdateManager.new Table.engine
-        um.table(Table.new(:users)).must_equal um
-      end
-
-      it 'generates an update statement with joins' do
-        um = Arel::UpdateManager.new Table.engine
-
-        table = Table.new(:users)
-        join_source = Arel::Nodes::JoinSource.new(
-          table,
-          [table.create_join(Table.new(:posts))]
-        )
-
-        um.table join_source
-        um.to_sql.must_be_like %{ UPDATE "users" INNER JOIN "posts" }
-      end
-    end
-
-    describe 'where' do
-      it 'generates a where clause' do
-        table = Table.new :users
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.where table[:id].eq(1)
-        um.to_sql.must_be_like %{
-          UPDATE "users" WHERE "users"."id" = 1
-        }
-      end
-
-      it 'chains' do
-        table = Table.new :users
-        um = Arel::UpdateManager.new Table.engine
-        um.table table
-        um.where(table[:id].eq(1)).must_equal um
-      end
-    end
-
-    describe 'key' do
-      before do
-        @table = Table.new :users
-        @um = Arel::UpdateManager.new Table.engine
-        @um.key = @table[:foo]
-      end
-
-      it 'can be set' do
-        @um.ast.key.must_equal @table[:foo]
-      end
-
-      it 'can be accessed' do
-        @um.key.must_equal @table[:foo]
-      end
-    end
-  end
-end

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

@@ -1,230 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    class TestDepthFirst < MiniTest::Unit::TestCase
-      Collector = Struct.new(:calls) do
-        def call object
-          calls << object
-        end
-      end
-
-      def setup
-        @collector = Collector.new []
-        @visitor = Visitors::DepthFirst.new @collector
-      end
-
-      def test_raises_with_object
-        assert_raises(TypeError) do
-          @visitor.accept(Object.new)
-        end
-      end
-
-
-      # unary ops
-      [
-        Arel::Nodes::Not,
-        Arel::Nodes::Group,
-        Arel::Nodes::On,
-        Arel::Nodes::Grouping,
-        Arel::Nodes::Offset,
-        Arel::Nodes::Ordering,
-        Arel::Nodes::Having,
-        Arel::Nodes::StringJoin,
-        Arel::Nodes::UnqualifiedColumn,
-        Arel::Nodes::Top,
-        Arel::Nodes::Limit,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          op = klass.new(:a)
-          @visitor.accept op
-          assert_equal [:a, op], @collector.calls
-        end
-      end
-
-      # functions
-      [
-        Arel::Nodes::Exists,
-        Arel::Nodes::Avg,
-        Arel::Nodes::Min,
-        Arel::Nodes::Max,
-        Arel::Nodes::Sum,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          func = klass.new(:a, "b")
-          @visitor.accept func
-          assert_equal [:a, "b", false, func], @collector.calls
-        end
-      end
-
-      def test_named_function
-        func = Arel::Nodes::NamedFunction.new(:a, :b, "c")
-        @visitor.accept func
-        assert_equal [:a, :b, false, "c", func], @collector.calls
-      end
-
-      def test_lock
-        lock = Nodes::Lock.new true
-        @visitor.accept lock
-        assert_equal [lock], @collector.calls
-      end
-
-      def test_count
-        count = Nodes::Count.new :a, :b, "c"
-        @visitor.accept count
-        assert_equal [:a, "c", :b, count], @collector.calls
-      end
-
-      def test_inner_join
-        join = Nodes::InnerJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      def test_outer_join
-        join = Nodes::OuterJoin.new :a, :b
-        @visitor.accept join
-        assert_equal [:a, :b, join], @collector.calls
-      end
-
-      [
-        Arel::Nodes::Assignment,
-        Arel::Nodes::Between,
-        Arel::Nodes::DoesNotMatch,
-        Arel::Nodes::Equality,
-        Arel::Nodes::GreaterThan,
-        Arel::Nodes::GreaterThanOrEqual,
-        Arel::Nodes::In,
-        Arel::Nodes::LessThan,
-        Arel::Nodes::LessThanOrEqual,
-        Arel::Nodes::Matches,
-        Arel::Nodes::NotEqual,
-        Arel::Nodes::NotIn,
-        Arel::Nodes::Or,
-        Arel::Nodes::TableAlias,
-        Arel::Nodes::Values,
-        Arel::Nodes::As,
-        Arel::Nodes::DeleteStatement,
-        Arel::Nodes::JoinSource,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new(:a, :b)
-          @visitor.accept binary
-          assert_equal [:a, :b, binary], @collector.calls
-        end
-      end
-
-      # N-ary
-      [
-        Arel::Nodes::And,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new([:a, :b, :c])
-          @visitor.accept binary
-          assert_equal [:a, :b, :c, binary], @collector.calls
-        end
-      end
-
-      [
-        Arel::Attributes::Integer,
-        Arel::Attributes::Float,
-        Arel::Attributes::String,
-        Arel::Attributes::Time,
-        Arel::Attributes::Boolean,
-        Arel::Attributes::Attribute
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new(:a, :b)
-          @visitor.accept binary
-          assert_equal [:a, :b, binary], @collector.calls
-        end
-      end
-
-      def test_table
-        relation = Arel::Table.new(:users)
-        @visitor.accept relation
-        assert_equal ['users', relation], @collector.calls
-      end
-
-      def test_array
-        node = Nodes::Or.new(:a, :b)
-        list = [node]
-        @visitor.accept list
-        assert_equal [:a, :b, node, list], @collector.calls
-      end
-
-      def test_hash
-        node = Nodes::Or.new(:a, :b)
-        hash = { node => node }
-        @visitor.accept hash
-        assert_equal [:a, :b, node, :a, :b, node, hash], @collector.calls
-      end
-
-      def test_update_statement
-        stmt = Nodes::UpdateStatement.new
-        stmt.relation = :a
-        stmt.values << :b
-        stmt.wheres << :c
-        stmt.orders << :d
-        stmt.limit = :e
-
-        @visitor.accept stmt
-        assert_equal [:a, :b, stmt.values, :c, stmt.wheres, :d, stmt.orders,
-          :e, stmt], @collector.calls
-      end
-
-      def test_select_core
-        core = Nodes::SelectCore.new
-        core.projections << :a
-        core.froms = :b
-        core.wheres << :c
-        core.groups << :d
-        core.having = :e
-
-        @visitor.accept core
-        assert_equal [
-          :a, core.projections,
-          :b, [],
-          core.source,
-          :c, core.wheres,
-          :d, core.groups,
-          :e,
-          core], @collector.calls
-      end
-
-      def test_select_statement
-        ss = Nodes::SelectStatement.new
-        ss.cores.replace [:a]
-        ss.orders << :b
-        ss.limit = :c
-        ss.lock = :d
-        ss.offset = :e
-
-        @visitor.accept ss
-        assert_equal [
-          :a, ss.cores,
-          :b, ss.orders,
-          :c,
-          :d,
-          :e,
-          ss], @collector.calls
-      end
-
-      def test_insert_statement
-        stmt = Nodes::InsertStatement.new
-        stmt.relation = :a
-        stmt.columns << :b
-        stmt.values = :c
-
-        @visitor.accept stmt
-        assert_equal [:a, :b, stmt.columns, :c, stmt], @collector.calls
-      end
-
-      def test_node
-        node = Nodes::Node.new
-        @visitor.accept node
-        assert_equal [node], @collector.calls
-      end
-    end
-  end
-end

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

@@ -1,76 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    class TestDot < MiniTest::Unit::TestCase
-      def setup
-        @visitor = Visitors::Dot.new
-      end
-
-      # functions
-      [
-        Nodes::Sum,
-        Nodes::Exists,
-        Nodes::Max,
-        Nodes::Min,
-        Nodes::Avg,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          op = klass.new(:a, "z")
-          @visitor.accept op
-        end
-      end
-
-      def test_named_function
-        func = Nodes::NamedFunction.new 'omg', 'omg'
-        @visitor.accept func
-      end
-
-      # unary ops
-      [
-        Arel::Nodes::Not,
-        Arel::Nodes::Group,
-        Arel::Nodes::On,
-        Arel::Nodes::Grouping,
-        Arel::Nodes::Offset,
-        Arel::Nodes::Ordering,
-        Arel::Nodes::Having,
-        Arel::Nodes::UnqualifiedColumn,
-        Arel::Nodes::Top,
-        Arel::Nodes::Limit,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          op = klass.new(:a)
-          @visitor.accept op
-        end
-      end
-
-      # binary ops
-      [
-        Arel::Nodes::Assignment,
-        Arel::Nodes::Between,
-        Arel::Nodes::DoesNotMatch,
-        Arel::Nodes::Equality,
-        Arel::Nodes::GreaterThan,
-        Arel::Nodes::GreaterThanOrEqual,
-        Arel::Nodes::In,
-        Arel::Nodes::LessThan,
-        Arel::Nodes::LessThanOrEqual,
-        Arel::Nodes::Matches,
-        Arel::Nodes::NotEqual,
-        Arel::Nodes::NotIn,
-        Arel::Nodes::Or,
-        Arel::Nodes::TableAlias,
-        Arel::Nodes::Values,
-        Arel::Nodes::As,
-        Arel::Nodes::DeleteStatement,
-        Arel::Nodes::JoinSource,
-      ].each do |klass|
-        define_method("test_#{klass.name.gsub('::', '_')}") do
-          binary = klass.new(:a, :b)
-          @visitor.accept binary
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    describe 'the ibm_db visitor' do
-      before do
-        @visitor = IBM_DB.new Table.engine.connection
-      end
-
-      it 'uses FETCH FIRST n ROWS to limit results' do
-        stmt = Nodes::SelectStatement.new
-        stmt.limit = Nodes::Limit.new(1)
-        sql = @visitor.accept(stmt)
-        sql.must_be_like "SELECT FETCH FIRST 1 ROWS ONLY"
-      end
-
-      it 'uses FETCH FIRST n ROWS in updates with a limit' do
-        stmt = Nodes::UpdateStatement.new
-        stmt.limit = Nodes::Limit.new(1)
-        stmt.key = 'id'
-        sql = @visitor.accept(stmt)
-        sql.must_be_like "UPDATE NULL WHERE 'id' IN (SELECT 'id' FETCH FIRST 1 ROWS ONLY)"
-      end
-
-    end
-  end
-end

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

@@ -1,42 +0,0 @@
-require 'helper'
-
-module Arel
-  module Visitors
-    describe 'the informix visitor' do
-      before do
-        @visitor = Informix.new Table.engine.connection
-      end
-
-      it 'uses LIMIT n to limit results' do
-        stmt = Nodes::SelectStatement.new
-        stmt.limit = Nodes::Limit.new(1)
-        sql = @visitor.accept(stmt)
-        sql.must_be_like "SELECT LIMIT 1"
-      end
-
-      it 'uses LIMIT n in updates with a limit' do
-        stmt = Nodes::UpdateStatement.new
-        stmt.limit = Nodes::Limit.new(1)
-        stmt.key = 'id'
-        sql = @visitor.accept(stmt)
-        sql.must_be_like "UPDATE NULL WHERE 'id' IN (SELECT LIMIT 1 'id')"
-      end
-
-      it 'uses SKIP n to jump results' do
-        stmt = Nodes::SelectStatement.new
-        stmt.offset = Nodes::Offset.new(10)
-        sql = @visitor.accept(stmt)
-        sql.must_be_like "SELECT SKIP 10"
-      end
-
-      it 'uses SKIP before LIMIT' do
-        stmt = Nodes::SelectStatement.new
-        stmt.limit = Nodes::Limit.new(1)
-        stmt.offset = Nodes::Offset.new(1)
-        sql = @visitor.accept(stmt)
-        sql.must_be_like "SELECT SKIP 1 LIMIT 1"
-      end
-
-    end
-  end
-end