horza 0.0.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3b297b82ecba5dd4f72a6974c8018d2895f80dbc
-  data.tar.gz: c2403238d237160290cd7c68a37cda4f106b78b9
+  metadata.gz: aa0c514a09b3c9cc5c381187de5123e83d6bbc20
+  data.tar.gz: d6fb63bc973ed1cca3b703d8eceb5390163a5a0e
 SHA512:
-  metadata.gz: 5b6cabd74b00d0d5954bd030d2854f1ed30feabb540dbdb4f53b46b79485f5b02cddc8f266b9230884de78b37fd241af2c59370ea278b7aa6d6db4714b6bffdb
-  data.tar.gz: 2a0fbb2d13b0e524642c66ddf7a37a0fb00b94f67c13d0f54621a159e779b4b235feabd910cb7b4c9082f661b3d2ebc54d11f61f4676efafa52b7985252d0d3b
+  metadata.gz: d59d0f2c0ab53696247e2144f34541a3a60074731e1431cea21ea73d3da6beab250a2cd0a57f55a52f75d695e0d49ccc3d22c8f570d0c9d86787e87073203371
+  data.tar.gz: 8970bb56079f409f998e36a5d97192d5cec75f04a0ee05ac87611def55a51458b4c92b1c0901e64c25a746249f8b16dfb72777150e145e6f03db49676428349b

data/README.md

@@ -1,333 +1,73 @@
-# Get
+# Horza
 
-Dynamically generate classes to encapsulate common database queries in Rails.
+Horza is a library for decoupling your application from the ORM you have implemented.
 
-## Why is this necessary?
+## Inputs
 
-#### Problem 1: Encapsulation
-
-ORMs like ActiveRecord make querying the database incredible easy, but with power comes responsibility, and there's a lot of irresponsible code out there.
-
-Consider:
-
-```ruby
-User.where(name: 'blake').order('updated_at DESC').limit(2)
-```
-
-This query is easy to read, and it works. Unfortunately, anything that uses it is tough to test, and any other implementation has to repeat this same cumbersome method chain.
-Sure, you can wrap it in a method:
+Horza uses ORM-specific adapters to decouple Ruby apps from their ORMS.
 
+**Configure Adapter**
 ```ruby
-def find_two_blakes
-  User.where(name: 'blake').order('updated_at DESC').limit(2)
+Horza.configure do |config|
+  config.adapter = :active_record
 end
 ```
 
-But where does it live? Scope methods on models are (IMHO) hideous, so maybe a Helper? A Service? A private method in a class that I inherit from? The options aren't great.
-
-#### Problem 2: Associations
-
-ORMs like ActiveRecord also makes querying associations incredible easy. Consider:
-
-```html+ruby
-<div>
-  <ul>
-    <% current_user.employer.sportscars.each do |car| %>
-      <li><%= car.cost %></li>
-    <% end >
-  </ul>
-</div>
-```
-
-The above is a great example of query pollution in the view layer. It's quick-to-build, tough-to-test, and very common in Rails.
-A spec for a view like this would need to either create/stub each of the records with the proper associations, or stub the entire method chain.
-
-If you move the query to the controller, it's a bit better:
-
-```ruby
-# controller
-def index
-  @employer = current_user.employer
-  @sportscars = @employer.sportscars
-end
-```
-
-```html+ruby
-#view
-<div>
-  <ul>
-    <% @sportscars.each do |car| %>
-      <li><%= car.cost %></li>
-    <% end >
-  </ul>
-</div>
-```
-
-But that's just lipstick on a pig. We've simply shifted the testing burden to the controller; the dependencies and mocking complexity remain the same.
-
-#### Problem 3: Self-Documenting code
-
-Consider:
-
-```ruby
-User.where(last_name: 'Turner').order('id DESC').limit(1)
-```
-
-Most programmers familiar with Rails will be able to understand the above immediately, but only because they've written similar chains a hundred times.
-
-## Solution
-
-The Get library tries to solve the above problems by dynamically generating classes that perform common database queries.
-Get identifies four themes in common queries:
-
-- **Singular**: Queries that expect a single record in response
-- **Plural**: Queries that expect a collection of records in response
-- **Query**: Query is performed on the given model
-- **Association**: Query traverses the associations of the given model and returns a different model
-
-These themes are not mutually exclusive; **Query** and **Association** can be either **Singular** or **Plural**.
-
-## Usage
-
-#### Singular Queries - Return a single record
-
-With field being queried in the class name
-```ruby
-Get::UserById.run(123)
-```
-
-Fail loudly
+**Get Adapter for your ORM Object**
 ```ruby
-Get::UserById.run!(123)
-```
+# ActiveRecord Example
+user = User.create(user_params)
+horza_user = Horza.adapter.new(user)
 
-Slightly more flexible model:
-```ruby
-Get::UserBy.run(id: 123, employer_id: 88)
+# Examples
+horza_user.get(id) # Find by id - Return nil on fail
+horza_user.get!(id) # Find by id - Error on fail
+horza_user.find_first(params) # Find 1 user - Orders by id desc by default - Return nil on fail
+horza_user.find_first!(params) # Find 1 user - Orders by id desc by default - Error nil on fail
+horza_user.find_all(params) # Find all users that match parameters
+horza_user.ancestors(target: :employer, via: []) # Traverse relations
 ```
 
-#### Plural Queries - Return a collection of records
+## Outputs
 
-_Note the plurality of 'Users'_
-```ruby
-Get::UsersByLastName.run('Turner')
-```
-
-#### Associations
-
-Associations use 'From', and are sugar for the chains we so often write in rails.
+Horza queries return very dumb vanilla entities instead of ORM response objects.
+Singular entities are simply hashes that allow both hash and dot notation, and binary helpers.
+Collection entities behave like arrays.
 
-_You can pass either an entity or an id, the only requirement is that it responds to #id_
-
-Parent relationship (user.employer):
 ```ruby
-Get::EmployerFromUser.run(user)
-```
+# Singular Entity
+result = horza_user.find_first(first_name: 'Blake') # => {"id"=>1, "first_name"=>"Blake", "last_name"=>"Turner", "employer_id"=>nil}
+result.class.name # => "Horza::Entities::Single"
 
-Child relationship (employer.users):
-```ruby
-Get::UsersFromEmployer.run(employer_id)
-```
-
-Complex relationship (user.employer.sportscars)
-```ruby
-Get::SportscarsFromUser.run(user, via: :employer)
-```
-
-Keep the plurality of associations in mind. If an Employer has many Users, UsersFromEmployer works,
-but UserFromEmployer will throw `Get::Errors::InvalidAncestry`.
-
-## Entities
-
-Ironically, one of the "features" of Get is its removal of the ability to query associations from the query response object.
-This choice was made to combat query pollution throughout the app, particularly in the view layer.
+result['id'] # => 1
+result.id # => 1
+result.id? # => true
 
-To achieve this, Get returns **entities** instead of ORM  objects (`ActiveRecord::Base`, etc.).
-These entity classes are generated at runtime with names appropriate to their contents.
-You can also register your own entities in the Get config.
+# Collection Entity
+result = horza_user.find_all(last_name: 'Turner')
+result.class.name # => "Horza::Entities::Collection"
 
-```ruby
->> result = Get::UserById.run(user.id)
->> result.class.name
->> "Get::Entities::GetUser"
+result.length # => 1
+result.size # => 1
+result.empty? # => false
+result.present? # => true
+result.first # => {"id"=>1, "first_name"=>"Blake", "last_name"=>"Turner", "employer_id"=>nil}
+result.last # => {"id"=>1, "first_name"=>"Blake", "last_name"=>"Turner", "employer_id"=>nil}
+result[0] # => {"id"=>1, "first_name"=>"Blake", "last_name"=>"Turner", "employer_id"=>nil}
 ```
 
-Individual entities will have all attributes accessible via dot notation and hash notation, but attempts to get associations will fail.
-Collections have all of the common enumerator methods: `first`, `last`, `each`, and `[]`.
-
-Dynamically generated Get::Entities are prefixed with `Get` to avoid colliding with your ORM objects.
-
-## Testing
-
-A big motivation for this library is to make testing database queries easier.
-Get accomplishes this by making class-level mocking/stubbing very easy.
-
-Consider:
-
-```ruby
-# sportscars_controller.rb
-
-# ActiveRecord
-def index
-  @sportscars = current_user.employer.sportscars
-end
-
-# Get
-def index
-  @sportscars = Get::SportscarsFromUser.run(current_user, via: employer)
-end
-```
+## Custom Entities
 
-The above methods do the exact same thing. Cool, let's test them:
+You can define your own entities by making them subclasses of [Horza entities](https://github.com/onfido/horza/tree/master/lib/horza/entities). Just make sure they have the same class name as your ORM classes. Horza will automatically detect custom entities and use them for output.
 
 ```ruby
-# sportscars_controller.rb
-describe SportscarsController, type: :controller do
-  context '#index' do
-    context 'ActiveRecord' do
-      let(:user) { FactoryGirl.build_stubbed(:user, employer: employer) }
-      let(:employer) { FactoryGirl.build_stubbed(:employer) }
-      let(:sportscars) { 3.times { FactoryGirl.build_stubbed(:sportscars) } }
-
-      before do
-        employer.sportscars << sportscars
-        sign_in(user)
-        get :index
-      end
-
-      it 'assigns sportscars' do
-        expect(assigns(:sportscars)).to eq(sportscars)
-      end
-    end
-
-    context 'Get' do
-      let(:user) { FactoryGirl.build_stubbed(:user, employer: employer) }
-      let(:sportscars) { 3.times { FactoryGirl.build_stubbed(:sportscars) } }
-
-      before do
-        allow(Get::SportscarsFromUser).to receive(:run).and_return(sportscars)
-        sign_in(user)
-        get :index
-      end
-
-      it 'assigns sportscars' do
-        expect(assigns(:sportscars)).to eq(sportscars)
-      end
-    end
+module CustomEntities
+  # Collection Entity
+  class Users < Horza::Entities::Collection
   end
-end
-```
-
-By encapsulating the query in a class, we're able to stub it at the class level, which eliminates then need to create any dependencies.
-This will speed up tests (a little), but more importantly it makes them easier to read and write.
-
-## Config
-
-**Define your adapter**
 
-_config/initializers/ask.rb_
-```ruby
-Get.configure { |config| config.adapter = :active_record }
-```
-
-**Configure custom entities**
-
-The code below will cause Get classes that begin with _Users_ (ie. `UsersByLastName`) to return a MyCustomEntity instead of the default `Get::Entities::User`.
-
-_config/initializers/ask.rb_
-```ruby
-class MyCustomEntity < Get::Entities::Collection
- def east_london_length
-   "#{length}, bruv"
- end
-end
-
-Get.config do |config|
- config.register_entity(:users_by_last_name, MyCustomEntity)
+  # Singular Entity
+  class User < Horza::Entities::Single
+  end
 end
 ```
-
-You can reset the config at any time using `Get.reset`.
-
-## Adapters
-
-Get currently works with ActiveRecord.
-
-## Benchmarking
-
-Get requests generally run < 1ms slower than ActiveRecord requests.
-
-```
-GETTING BY ID, SAMPLE_SIZE: 400
-
-
->>> ActiveRecord
-                                     user     system      total        real
-Clients::User.find               0.170000   0.020000   0.190000 (  0.224373)
-Clients::User.find_by_id         0.240000   0.010000   0.250000 (  0.342278)
-
->>> Get
-                                     user     system      total        real
-Get::UserById                    0.300000   0.020000   0.320000 (  0.402454)
-Get::UserBy                      0.260000   0.010000   0.270000 (  0.350982)
-
-
-GETTING SINGLE RECORD BY LAST NAME, SAMPLE_SIZE: 400
-
-
->>> ActiveRecord
-                                     user     system      total        real
-Clients::User.where              0.190000   0.020000   0.210000 (  0.292516)
-Clients::User.find_by_last_name  0.180000   0.010000   0.190000 (  0.270033)
-
->>> Get
-                                     user     system      total        real
-Get::UserByLastName              0.240000   0.010000   0.250000 (  0.337908)
-Get::UserBy                      0.310000   0.020000   0.330000 (  0.415142)
-
-
-GETTING MULTIPLE RECORDS BY LAST NAME, SAMPLE_SIZE: 400
-
-
->>> ActiveRecord
-                                     user     system      total        real
-Clients::User.where              0.020000   0.000000   0.020000 (  0.012604)
-
->>> Get
-                                     user     system      total        real
-Get::UsersByLastName             0.100000   0.000000   0.100000 (  0.105822)
-Get::UsersBy                     0.100000   0.010000   0.110000 (  0.106406)
-
-
-GETTING PARENT FROM CHILD, SAMPLE_SIZE: 400
-
-
->>> ActiveRecord
-                                     user     system      total        real
-Clients::User.find(:id).employer  0.440000   0.030000   0.470000 (  0.580800)
-
->>> Get
-                                     user     system      total        real
-Get::EmployerFromUser            0.500000   0.020000   0.520000 (  0.643316)
-
-
-GETTING CHILDREN FROM PARENT, SAMPLE_SIZE: 400
-
-
->>> ActiveRecord
-                                     user     system      total        real
-Clients::Employer.find[:id].users  0.160000   0.020000   0.180000 (  0.218710)
-
->>> Get
-                                     user     system      total        real
-Get::UsersFromEmployer           0.230000   0.010000   0.240000 (  0.293037)
-
-
-STATS
-
-AVERAGE DIFF FOR BY ID: 0.000233s
-AVERAGE DIFF FOR BY LAST NAME: 0.000238s
-AVERAGE DIFF FOR BY LAST NAME (MULTIPLE): 0.000234s
-AVERAGE DIFF FOR PARENT FROM CHILD: 0.000156s
-AVERAGE DIFF FOR CHILDREN FROM PARENT: -0.000186s
-```

data/lib/horza.rb

@@ -10,4 +10,10 @@ require 'active_support/inflector'
 
 module Horza
   extend Configuration
+
+  class << self
+    def descendants_map(klass)
+      klass.descendants.reduce({}) { |hash, (klass)| hash.merge(klass.name.split('::').last.underscore.to_sym => klass) }
+    end
+  end
 end

data/lib/horza/adapters/abstract_adapter.rb

@@ -19,25 +19,27 @@ module Horza
         def not_implemented_error
           raise ::Horza::Errors::MethodNotImplemented, 'You must implement this method in your adapter.'
         end
-
-        def descendants
-          descendants = []
-          ObjectSpace.each_object(singleton_class) do |k|
-            descendants.unshift k unless k == self
-          end
-          descendants
-        end
       end
 
       def initialize(context)
         @context = context
       end
 
+      def get(options = {})
+        get!(options = {})
+      rescue *self.class.expected_errors
+      end
+
       def get!(options = {})
         not_implemented_error
       end
 
       def find_first(options = {})
+        find_first!(options = {})
+      rescue *self.class.expected_errors
+      end
+
+      def find_first!(options = {})
         not_implemented_error
       end
 
@@ -57,11 +59,20 @@ module Horza
         not_implemented_error
       end
 
+      def entity_class(res = @context)
+        collection?(res) ? ::Horza::Entities.collection_entity_for(entity_symbol).new(res) : ::Horza::Entities.single_entity_for(entity_symbol).new(res)
+      end
+
       private
 
       def not_implemented_error
         self.class.not_implemented_error
       end
+
+      def entity_symbol
+        klass = @context.name.split('::').last
+        collection? ? klass.pluralize.symbolize : klass.symbolize
+      end
     end
   end
 end

data/lib/horza/adapters/active_record.rb

@@ -1,6 +1,8 @@
 module Horza
   module Adapters
     class ActiveRecord < AbstractAdapter
+      INVALID_ANCESTRY_MSG = 'Invalid relation. Ensure that the plurality of your associations is correct.'
+
       class << self
         def expected_errors
           [::ActiveRecord::RecordNotFound]
@@ -11,37 +13,52 @@ module Horza
         end
 
         def entity_context_map
-          @map ||= ::ActiveRecord::Base.descendants.reduce({}) { |hash, (klass)| hash.merge(klass.name.split('::').last.underscore.to_sym => klass) }
+          @map ||= ::Horza.descendants_map(::ActiveRecord::Base)
         end
       end
 
-      def get!(options = {})
-        @context = @context.find(options[:id])
+      def get!(id)
+        entity_class(@context.find(id).attributes)
       end
 
-      def find_first(options = {})
-        @context = find_all(options).limit(1).first!
+      def find_first!(options = {})
+        entity_class(base_query(options).first!.attributes)
       end
 
       def find_all(options = {})
-        @context = @context.where(options[:conditions]).order('ID DESC')
+        entity_class(base_query(options))
       end
 
       def ancestors(options = {})
-        get!(options)
-        walk_family_tree(options)
-        rescue NoMethodError
-          raise ::Horza::Errors::InvalidAncestry.new('Invalid relation. Ensure that the plurality of your associations is correct.')
+        result = walk_family_tree(@context.find(options[:id]), options)
+
+        return nil unless result
+
+        collection?(result) ? entity_class(result) : entity_class(result.attributes)
       end
 
       def to_hash
+        raise ::Horza::Errors::CannotGetHashFromCollection.new if collection?
+        raise ::Horza::Errors::QueryNotYetPerformed.new unless @context.respond_to?(:attributes)
         @context.attributes
       end
 
       private
 
-      def walk_family_tree(options)
-        options[:via].push(options[:result_key]).each { |relation| @context = @context.send(relation) }
+      def base_query(options)
+        @context.where(options).order('ID DESC')
+      end
+
+      def collection?(subject = @context)
+        subject.is_a?(::ActiveRecord::Relation) || subject.is_a?(Array)
+      end
+
+      def walk_family_tree(object, options)
+        via = options[:via] || []
+        via.push(options[:target]).reduce(object) do |object, relation|
+          raise ::Horza::Errors::InvalidAncestry.new(INVALID_ANCESTRY_MSG) unless object.respond_to? relation
+          object.send(relation)
+        end
       end
     end
   end

data/lib/horza/configuration.rb

@@ -1,7 +1,7 @@
 module Horza
   module Configuration
     String.send(:include, ::Horza::CoreExtensions::String)
-    
+
     def configuration
       @configuration ||= Config.new
     end
@@ -21,7 +21,16 @@ module Horza
     end
 
     def adapter_map
-      @adapter_map ||= ::Horza::Adapters::AbstractAdapter.descendants.reduce({}) { |hash, (klass)| hash.merge(klass.name.split('::').last.underscore.to_sym => klass) }
+      @adapter_map ||= generate_map
+    end
+
+    private
+
+    def generate_map
+      ::Horza::Adapters::AbstractAdapter.descendants.reduce({}) do |hash, (klass)|
+        return hash unless klass.name
+        hash.merge(klass.name.split('::').last.underscore.to_sym => klass)
+      end
     end
   end
 

data/lib/horza/entities.rb

@@ -1,9 +1,20 @@
 module Horza
   module Entities
     class << self
-      def const_missing(name)
-        parent_klass = name.to_s.plural? ? Horza::Entities::Collection : Horza::Entities::Single
-        Horza::Entities.const_set(name, Class.new(parent_klass))
+      def single_entity_for(entity_symbol)
+        single_entities[entity_symbol] || ::Horza::Entities::Single
+      end
+
+      def single_entities
+        @singles ||= ::Horza.descendants_map(::Horza::Entities::Single)
+      end
+
+      def collection_entity_for(entity_symbol)
+        collection_entities[entity_symbol] || ::Horza::Entities::Collection
+      end
+
+      def collection_entities
+        @singles ||= ::Horza.descendants_map(::Horza::Entities::Collection)
       end
     end
   end

data/lib/horza/entities/collection.rb

@@ -26,15 +26,14 @@ module Horza
       end
 
       def singular_entity(record)
-        singular_entity_class.new(Horza.adapter.new(record).to_hash)
+        adapter = Horza.adapter.new(record)
+        singular_entity_class(record).new(adapter.to_hash)
       end
 
-      # Collection classes have the form Horza::Entities::TypesMapper
-      # Single output requires the form Horza::Entities::TypeMapper
-      def singular_entity_class
-        @singular_entity ||= Kernel.const_get(self.class.name.deconstantize).const_get(self.class.name.demodulize.singularize)
-      rescue NameError
-        @singular_entity = ::Horza::Entities::Single
+      # Collection classes have the form Horza::Entities::Users
+      # Single output requires the form Horza::Entities::User
+      def singular_entity_class(record)
+        @singular_entity ||= ::Horza::Entities::single_entity_for(record.class.name.split('::').last.symbolize)
       end
     end
   end

data/lib/horza/errors.rb

@@ -8,5 +8,11 @@ module Horza
 
     class InvalidAncestry < StandardError
     end
+
+    class QueryNotYetPerformed < StandardError
+    end
+
+    class CannotGetHashFromCollection < StandardError
+    end
   end
 end

data/spec/active_record_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+
+if !defined?(ActiveRecord::Base)
+  puts "** require 'active_record' to run the specs in #{__FILE__}"
+else
+  ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+  ActiveRecord::Migration.suppress_messages do
+    ActiveRecord::Schema.define(:version => 0) do
+      create_table(:employers, force: true) {|t| t.string :name }
+      create_table(:users, force: true) {|t| t.string :first_name; t.string :last_name; t.references :employer; }
+      create_table(:sports_cars, force: true) {|t| t.string :make; t.references :employer; }
+      create_table(:dummy_models, force: true) {|t| t.string :key }
+      create_table(:other_dummy_models, force: true) {|t| t.string :key }
+    end
+  end
+
+  module HorzaSpec
+    class Employer < ActiveRecord::Base
+      has_many :users
+      has_many :sports_cars
+    end
+
+    class User < ActiveRecord::Base
+      belongs_to :employer
+    end
+
+    class SportsCar < ActiveRecord::Base
+      belongs_to :employer
+    end
+
+    class DummyModel < ActiveRecord::Base
+      belongs_to :employer
+    end
+
+    class OtherDummyModel < ActiveRecord::Base
+      belongs_to :employer
+    end
+  end
+end
+
+describe Horza do
+  let(:last_name) { 'Turner' }
+  let(:adapter) { :active_record }
+  let(:user_adapter) { Horza.adapter.new(HorzaSpec::User) }
+  let(:employer_adapter) { Horza.adapter.new(HorzaSpec::Employer) }
+  let(:sports_car_adapter) { Horza.adapter.new(HorzaSpec::SportsCar) }
+
+  # Reset base config with each iteration
+  before { Horza.configure { |config| config.adapter = adapter } }
+  after do
+    HorzaSpec::User.delete_all
+    HorzaSpec::Employer.delete_all
+  end
+
+  describe '#adapter' do
+    let(:user) { HorzaSpec::User.create }
+
+    describe '#get!' do
+      context 'when user exists' do
+        it 'returns Single entity' do
+          expect(user_adapter.get!(user.id).is_a? Horza::Entities::Single).to be true
+        end
+      end
+
+      context 'when user exists' do
+        it 'returns user' do
+          expect(user_adapter.get!(user.id).to_h).to eq user.attributes
+        end
+      end
+
+      context 'when user does not exist' do
+        it 'throws error' do
+          expect { user_adapter.get!(999) }.to raise_error ActiveRecord::RecordNotFound
+        end
+      end
+    end
+
+    describe '#get' do
+      context 'when user does not exist' do
+        it 'returns nil' do
+          expect(user_adapter.get(999)).to be nil
+        end
+      end
+    end
+
+    describe '#find_first!' do
+      context 'when users exist' do
+        before do
+          3.times { HorzaSpec::User.create(last_name: last_name) }
+          2.times { HorzaSpec::User.create(last_name: 'OTHER') }
+        end
+        it 'returns single Entity' do
+          expect(user_adapter.find_first(last_name: last_name).is_a? Horza::Entities::Single).to be true
+        end
+
+        it 'returns user' do
+          expect(user_adapter.find_first!(last_name: last_name).to_h).to eq HorzaSpec::User.where(last_name: last_name).order('id DESC').first.attributes
+        end
+      end
+
+      context 'when user does not exist' do
+        it 'throws error' do
+          expect { user_adapter.find_first!(last_name: last_name) }.to raise_error ActiveRecord::RecordNotFound
+        end
+      end
+    end
+
+    describe '#find_first' do
+      context 'when user does not exist' do
+        it 'returns nil' do
+          expect(user_adapter.find_first(last_name: last_name)).to be nil
+        end
+      end
+    end
+
+    describe '#find_all' do
+      context 'when users exist' do
+        before do
+          3.times { HorzaSpec::User.create(last_name: last_name) }
+          2.times { HorzaSpec::User.create(last_name: 'OTHER') }
+        end
+        it 'returns user' do
+          expect(user_adapter.find_all(last_name: last_name).length).to eq 3
+        end
+      end
+
+      context 'when user does not exist' do
+        it 'throws error' do
+          expect(user_adapter.find_all(last_name: last_name).empty?).to be true
+        end
+      end
+    end
+
+    context '#ancestors' do
+      context 'direct relation' do
+        let(:employer) { HorzaSpec::Employer.create }
+        let!(:user1) { HorzaSpec::User.create(employer: employer) }
+        let!(:user2) { HorzaSpec::User.create(employer: employer) }
+
+        context 'parent' do
+          it 'returns parent' do
+            expect(user_adapter.ancestors(id: user1.id, target: :employer).to_h).to eq employer.attributes
+          end
+        end
+
+        context 'children' do
+          it 'returns children' do
+            result = employer_adapter.ancestors(id: employer.id, target: :users)
+            expect(result.length).to eq 2
+            expect(result.first.is_a? Horza::Entities::Single).to be true
+            expect(result.first.to_hash).to eq HorzaSpec::User.order('id DESC').last.attributes
+          end
+        end
+
+        context 'invalid ancestry' do
+          it 'throws error' do
+            expect { employer_adapter.ancestors(id: employer.id, target: :user) }.to raise_error Horza::Errors::InvalidAncestry
+          end
+        end
+
+        context 'valid ancestry with no saved childred' do
+          let(:employer2) { HorzaSpec::Employer.create }
+          it 'returns empty collection error' do
+            expect(employer_adapter.ancestors(id: employer2.id, target: :users).empty?).to be true
+          end
+        end
+
+        context 'valid ancestry with no saved parent' do
+          let(:user2) { HorzaSpec::User.create }
+          it 'returns nil' do
+            expect(user_adapter.ancestors(id: user2.id, target: :employer)).to be nil
+          end
+        end
+      end
+
+      context 'using via' do
+        let(:employer) { HorzaSpec::Employer.create }
+        let(:user) { HorzaSpec::User.create(employer: employer) }
+        let(:sportscar) { HorzaSpec::SportsCar.create(employer: employer) }
+
+        before do
+          employer.sports_cars << sportscar
+        end
+
+        it 'returns the correct ancestor' do
+          expect(user_adapter.ancestors(id: user.id, target: :sports_cars, via: [:employer]).first).to eq sportscar.attributes
+        end
+      end
+    end
+  end
+
+  describe 'Entities' do
+    describe 'Collection' do
+      context '#singular_entity_class' do
+        context 'when singular entity class does not exist' do
+        let(:dummy_model) { HorzaSpec::DummyModel.create }
+
+          module TestNamespace
+            class DummyModels < Horza::Entities::Collection
+            end
+          end
+
+          it 'returns Horza::Collection::Single' do
+            expect(TestNamespace::DummyModels.new([]).send(:singular_entity_class, dummy_model)).to eq Horza::Entities::Single
+          end
+        end
+
+        context 'when singular entity class exists' do
+          let(:other_dummy_model) { HorzaSpec::OtherDummyModel.create }
+
+          module TestNamespace
+            class OtherDummyModels < Horza::Entities::Collection
+            end
+
+            class OtherDummyModel < Horza::Entities::Single
+            end
+          end
+
+          it 'returns the existing singular class' do
+            expect(TestNamespace::OtherDummyModels.new([]).send(:singular_entity_class, other_dummy_model)).to eq TestNamespace::OtherDummyModel
+          end
+        end
+      end
+    end
+  end
+end

data/spec/horza_spec.rb

@@ -3,6 +3,8 @@ require 'spec_helper'
 describe Horza do
   context '#adapter' do
     context 'when adapter is not configured' do
+      before { Horza.reset }
+      after { Horza.reset }
       it 'throws error' do
         expect { Horza.adapter }.to raise_error(Horza::Errors::AdapterNotConfigured)
       end
@@ -16,41 +18,4 @@ describe Horza do
       end
     end
   end
-
-  describe 'Entities' do
-    context '#const_missing' do
-      it 'dynamically defines classes' do
-        expect { Horza::Entities.const_get('NewClass') }.to_not raise_error
-      end
-    end
-
-    describe 'Collection' do
-      context '#singular_entity_class' do
-        context 'when singular entity class does not exist' do
-          module TestNamespace
-            class GetUsers < Horza::Entities::Collection
-            end
-          end
-
-          it 'returns Horza::Collection::Single' do
-            expect(TestNamespace::GetUsers.new([]).send(:singular_entity_class)).to eq Horza::Entities::Single
-          end
-        end
-
-        context 'when singular entity class exists' do
-          module TestNamespace
-            class GetEmployers < Horza::Entities::Collection
-            end
-
-            class GetEmployer < Horza::Entities::Single
-            end
-          end
-
-          it 'returns the existing singular class' do
-            expect(TestNamespace::GetEmployers.new([]).send(:singular_entity_class)).to eq TestNamespace::GetEmployer
-          end
-        end
-      end
-    end
-  end
 end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'byebug'
 require 'rspec'
+require 'active_record'
 require 'bundler/setup'
 Bundler.setup
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: horza
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Blake Turner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-22 00:00:00.000000000 Z
+date: 2015-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -66,6 +66,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.15
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Horza is a shapeshifter that provides common inputs and outputs for your
   ORM
 email: mail@blakewilliamturner.com
@@ -84,6 +112,7 @@ files:
 - lib/horza/entities/collection.rb
 - lib/horza/entities/single.rb
 - lib/horza/errors.rb
+- spec/active_record_spec.rb
 - spec/horza_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/onfido/horza
@@ -111,6 +140,7 @@ signing_key:
 specification_version: 4
 summary: Keep your app ORM-agnostic
 test_files:
+- spec/active_record_spec.rb
 - spec/horza_spec.rb
 - spec/spec_helper.rb
 has_rdoc: