Convert specs to RSpec 2.99.1 syntax with Transpec

This conversion is done by Transpec 2.3.6 with the following command:
    transpec -b true,false

* 406 conversions
    from: obj.should
      to: expect(obj).to

* 245 conversions
    from: == expected
      to: eq(expected)

* 38 conversions
    from: be_true
      to: be true

* 34 conversions
    from: be_false
      to: be false

* 31 conversions
    from: obj.should_not
      to: expect(obj).not_to

* 11 conversions
    from: obj.stub(:message)
      to: allow(obj).to receive(:message)

* 9 conversions
    from: lambda { }.should
      to: expect { }.to

* 4 conversions
    from: lambda { }.should_not
      to: expect { }.not_to

* 2 conversions
    from: pending
      to: skip

* 1 conversion
    from: =~ /pattern/
      to: match(/pattern/)

* 1 conversion
    from: =~ [1, 2]
      to: match_array([1, 2])

* 1 conversion
    from: before { example }
      to: before { |example| example }

* 1 conversion
    from: obj.should_not_receive(:message)
      to: expect(obj).not_to receive(:message)

For more details: https://github.com/yujinakayama/transpec#supported-conversions
Rubocop
Simplify use of attr_accessor

Removing some metaprogramming that can be done much more simply.
Add specs to test `select` on `Octopus::ScopeProxy`

These tests should fail. The fix is in the next commit.

The error messages should indicate that `Kernel#select` is being called
improperly:

http://www.ruby-doc.org/core-2.1.2/Kernel.html#method-i-select
Fix failing calls to `select` on `Octopus::RelationProxy`

`Kernel#select` was called instead of `method_missing`

This fix allows `Octopus::RelationProxy` objects via `Octopus::ScopeProxy
to query for specific fields.

When an `Octopus::RelationProxy` is created via an `Octopus::ScopeProxy`
in the context of a query like `User.where()`, it loses the ability to call
`ActiveRecord::QueryMethods#select` via the proxy.

This is because when the `Ocotpus::RelationProxy` tries to call `select`
it incorrectly finds `Kernel#select`.

The solution was to simply add a `select` method on `Octopus::RelationProxy`
to manually dispatch to `method_missing`

See:
 * http://guides.rubyonrails.org/active_record_querying.html#selecting-specific-fields
 * http://api.rubyonrails.org/classes/ActiveRecord/QueryMethods.html
 * http://www.ruby-doc.org/core-2.1.2/Kernel.html#method-i-select
Isolate Rails4 only tests
Merge pull request #261 from emorikawa/fix-select

FIX: Selecting specific fields was broken for all `RelationProxy`s
Add specs to test Array#select form of ScopeProxy#select

These tests should fail. The fix is in the next commit.

This should raise:

    ArgumentError: Call this with at least one field

This is because the block is not being passed through.
Fix to allow Array#select form on RelationProxy#select

When `select` is called on an `Octopus::RelationProxy` it is supposed to
delegate to `ActiveRecord::QueryMethods#select`. The ActiveRecord version
takes an optional block, which makes the method behave like
`Array#select`

The block is now passed through and passes the test
Merge pull request #262 from emorikawa/fix-select-block

FIX: Let `Octopus::RelationProxy#select` takes a block so it can be used just like `Array#select`.
Merge pull request #258 from JackDanger/simpler-attr_accessor

Simplify use of attr_accessor
Merge branch 'master' of https://github.com/tamird/octopus into tamird-master
Merge branch 'tamird-master'
We cant run Rubocop on spec (yet)
Octopus 0.8.3
Run RuboCop in travis
Merge pull request #263 from tamird/master

Run RuboCop in travis
Allow indifferent access for url-based config

ConnectionPool.new is expecting to be able to access the config with
symbolized keys. Prior to this fix, this was causing any connection pool
settings to be ignored.

Most adapters avoid this issue by calling symbolize_keys before
attempting to connect, so the connection still works.
Merge pull request #274 from erykwalder/pool-config

Allow indifferent access for url-based config
Update Rubocop