horza 0.3.9 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 05dec4f4ed4ea42ae1721a8b519496ec70f2a803
-  data.tar.gz: 3fbd9ab81b756c4e4666a5334d7dda52b44a6fca
+  metadata.gz: 85bbbb02cee6bd4f2fe40c56bd9c37d16307b22f
+  data.tar.gz: 0398edae9ed16b2bb8d13650b1869741e8213a2c
 SHA512:
-  metadata.gz: 3afecde1421ecf764dfb2b8ebe1a3f7450526632488fc052376e46c1f0f35d7b3fd8dec25f2465bd3a1db3f65dd3dbef2041064ef7f53c59f03e0f7d88b13179
-  data.tar.gz: 42e7183c12b8733dd2db997ebccb2df9741c3ef5e5dbf5b0f57c7ef01c1f33684b280698594e52ae5c53b57c41c14c30ad8831678474cf8d7e3b8ee958728640
+  metadata.gz: f890a99acceefb96521d07a8b0ef41a290438f4672f917bfefd68cc0085379de73dd050de8eff44b442bb0f91daa7e4a39f409893200bc2b2dd4d82dd4560347
+  data.tar.gz: 98f821f258db1e72ce67439eb7aff920098a5c941954cb5fc8192ff491b68a7b12bd8247ce3aee336db9c14ed405a22ccb17b8e96d25195f70f58e767820aa59

data/README.md

@@ -16,7 +16,8 @@ end
 **Get Adapter for your ORM Object**
 ```ruby
 # ActiveRecord Example
-user = Horza.adapt(User)
+# Don't worry, We don't actually call things horza_users in our codebase, this is just for emphasis
+horza_user = Horza.adapt(User)
 
 # Examples
 user.get(id) # Find by id - Return nil on fail
@@ -59,29 +60,48 @@ user.find_all(conditions: conditions, offset: 50)
 
 # Eager loading associations
 employer.association(target: :users, eager_load: true)
-```
-
-## Options
-
-**Base Options**
 
-Key | Type | Details
---- | ---- | -------
-`conditions` | Hash | Key value pairs for the query
-`order` | Hash | { `field` => `:asc`/`:desc` }
-`limit` | Integer | Number of records to return
-`offset` | Integer | Number of records to offset
-`id` | Integer | The id of the root object (associations only)
-`target` | Symbol | The target of the association - ie. employer.users would have a target of :users (associations only)
-`eager_load` | Boolean | Whether to eager_load the association (associations only)
-
-**Association Options**
-
-Key | Type | Details
---- | ---- | -------
-`id` | Integer | The id of the root object
-`target` | Symbol | The target of the association - ie. employer.users would have a target of :users
-`eager_load` | Boolean | Whether to eager_load the association
+# Joins are slightly more complex
+join_params = {
+  with: :employers,
+  on: { employer_id: :id }, # field for adapted model => field for join model
+  fields: {
+    users: [:first_name, :last_name, :email],
+    employers: [:company_name, :address, :phone],
+  },
+  conditions: {
+    users: { last_name: 'Turner'  },
+    employers: { company_name: 'Corporation ltd.' }
+  },
+  limit: 20,
+  offset: 5,
+}
+horza_user.join(join_params)
+
+# You can join on multiple fields by passing an array
+join_params = {
+  with: :employers,
+  on: [
+    { employer_id: :id }, # field for adapted model => field for join model
+    { email: :email }, # field for adapted model => field for join model
+  ]
+}
+horza_user.join(join_params)
+
+# You can also alias field names
+join_params = {
+  with: :employers,
+  on: [
+    { employer_id: :id }, # field for adapted model => field for join model
+    { email: :email }, # field for adapted model => field for join model
+  ],
+  fields: {
+    users: [:id, :last_name, :email],
+    employers: [{id: :employer_id}], # Fieldname in db => alias for output
+  },
+}
+horza_user.join(join_params)
+```
 
 ## Outputs
 
@@ -91,7 +111,7 @@ Collection entities behave like arrays.
 
 ```ruby
 # Singular Entity
-result = user.find_first(first_name: 'Blake')
+result = horza_user.find_first(first_name: 'Blake')
 
 result # => {"id"=>1, "first_name"=>"Blake", "last_name"=>"Turner", "employer_id"=>1}
 result.class.name # => "Horza::Entities::Single"
@@ -100,7 +120,7 @@ result.id # => 1
 result.id? # => true
 
 # Collection Entity
-result = user.find_all(last_name: 'Turner')
+result = horza_user.find_all(last_name: 'Turner')
 
 result.class.name # => "Horza::Entities::Collection"
 result.length # => 1

data/lib/horza.rb

@@ -2,7 +2,8 @@ require 'horza/adapters/class_methods'
 require 'horza/adapters/instance_methods'
 require 'horza/adapters/options'
 require 'horza/adapters/abstract_adapter'
-require 'horza/adapters/active_record'
+require 'horza/adapters/active_record/active_record'
+require 'horza/adapters/active_record/arel_join'
 require 'horza/core_extensions/string'
 require 'horza/entities/single'
 require 'horza/entities/collection'

data/lib/horza/adapters/abstract_adapter.rb

@@ -29,6 +29,10 @@ module Horza
         not_implemented_error
       end
 
+      def join(options = {})
+        not_implemented_error
+      end
+
       def create!(options = {})
         not_implemented_error
       end

data/lib/horza/adapters/{active_record.rb → active_record/active_record.rb}

@@ -32,6 +32,13 @@ module Horza
         run_and_convert_exceptions { entity_class(query(options)) }
       end
 
+      def join(options = {})
+        run_and_convert_exceptions do
+          sql = ArelJoin.sql(self.context, options)
+          entity_class(::ActiveRecord::Base.connection.exec_query(sql).to_a)
+        end
+      end
+
       def create!(options = {})
         run_and_convert_exceptions do
           record = @context.new(options)

data/lib/horza/adapters/active_record/arel_join.rb

@@ -0,0 +1,80 @@
+module Horza
+  module Adapters
+    class ArelJoin < Options
+
+      class << self
+        def sql(context, options)
+          new(context, options).query.to_sql
+        end
+      end
+
+      def initialize(context, options)
+        @options = options
+
+        @base_table_key = context.table_name.to_sym
+        @join_table_key = options[:with]
+
+        @base_table = Arel::Table.new(@base_table_key)
+        @join_table = Arel::Table.new(@join_table_key)
+      end
+
+      def query
+        join = @base_table.project(fields).join(@join_table).on(predicates)
+        join = join.where(where_clause(@base_table, @base_table_key)) if conditions_for_table?(@base_table_key)
+        join = join.where(where_clause(@join_table, @join_table_key)) if conditions_for_table?(@join_table_key)
+        join = join.take(@options[:limit]) if @options[:limit]
+        join = join.skip(@options[:offset]) if @options[:offset]
+        join
+      end
+
+      private
+
+      def fields
+        return [@base_table[:id], Arel.star] unless @options[:fields] && @options[:fields].present?
+
+        @options[:fields].map do |table, fields|
+          fields.map do |field|
+            case table
+            when @base_table_key
+              alias_field(@base_table, field)
+            when @join_table_key
+              alias_field(@join_table, field)
+            end
+          end
+        end
+      end
+
+      def alias_field(table, field)
+        return table[field.to_s] unless field.is_a?(Hash)
+        table[field.keys.first.to_s].as(field.values.first.to_s)
+      end
+
+      def predicates
+        @options[:on] = [@options[:on]] unless @options[:on].is_a?(Array)
+
+        predicate_list = @options[:on].map { |on| predicate(on) }.flatten
+        chain_with_method(predicate_list, :and)
+      end
+
+      def predicate(on)
+        on.map { |base_field, join_field| @base_table[base_field].eq(@join_table[join_field]) }
+      end
+
+      def conditions_for_table?(table_key)
+        @options[:conditions].present? && @options[:conditions][table_key].present?
+      end
+
+      def where_clause(table, table_key)
+        clauses = @options[:conditions][table_key].map { |key, value| table[key].eq(value) }
+        chain_with_method(clauses, :and)
+      end
+
+      def chain_with_method(statements, method)
+        statements.reduce(nil) do |chained, statement|
+          next statement if chained.nil?
+          chained.send(method, statement)
+        end
+      end
+    end
+  end
+end

data/lib/horza/entities/collection.rb

@@ -1,8 +1,8 @@
 module Horza
   module Entities
     class Collection
-      def initialize(collection)
-        @collection = collection
+      def initialize(collection, singular_entity = nil)
+        @collection, @singular_entity = collection, singular_entity
       end
 
       def [](index)
@@ -28,8 +28,8 @@ module Horza
       end
 
       def singular_entity(record)
-        adapter = Horza.adapter.new(record)
-        singular_entity_class(record).new(adapter.to_hash)
+        attributes = record.respond_to?(:to_hash) ? record.to_hash : Horza.adapter.new(record).to_hash
+        singular_entity_class(record).new(attributes)
       end
 
       # Collection classes have the form Horza::Entities::Users

data/spec/active_record_spec.rb

@@ -7,8 +7,8 @@ else
 
   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(:employers, force: true) {|t| t.string :name; t.string :boss_email }
+      create_table(:users, force: true) {|t| t.string :first_name; t.string :last_name; t.string :email; t.references :employer; }
       create_table(:customers, force: true) {|t| t.string :first_name; t.string :last_name; }
       create_table(:sports_cars, force: true) {|t| t.string :make; t.references :employer; }
       create_table(:dummy_models, force: true) {|t| t.string :key }
@@ -65,6 +65,8 @@ describe Horza do
   after do
     HorzaSpec::User.delete_all
     HorzaSpec::Employer.delete_all
+    HorzaSpec::Customer.delete_all
+    HorzaSpec::SportsCar.delete_all
   end
 
   context '#context_for_entity' do
@@ -515,6 +517,156 @@ describe Horza do
         end
       end
     end
+
+    context '#join' do
+      let(:simple) do
+        {
+          with: :employers,
+          on: { employer_id: :id } # field for adapted model => field for join model
+        }
+      end
+
+      let(:complex_predicate) do
+        {
+          with: :employers,
+          on: [
+            { employer_id: :id }, # field for adapted model => field for join model
+            { email: :boss_email }, # field for adapted model => field for join model
+          ],
+          fields: {
+            users: [:id, :email],
+            employers: [:boss_email]
+          }
+        }
+      end
+
+      let(:fields) do
+        {
+          fields: {
+            users: [:id, :first_name, :last_name],
+            employers: [{id: :employer_id}, :name]
+          }
+        }.merge(simple)
+      end
+
+      let(:conditions) do
+        {
+          conditions: {
+            users: { last_name: 'Turner'  },
+            employers: { name: 'Corporation ltd.' }
+          }
+        }.merge(fields)
+      end
+
+      context 'without conditions' do
+        context 'when one join record exists' do
+          let!(:employer) { HorzaSpec::Employer.create(name: 'Corporation ltd.', boss_email: 'boss@boss.com') }
+          let!(:user) { HorzaSpec::User.create(employer: employer, first_name: 'John', last_name: 'Turner', email: 'email@email.com') }
+
+          context 'without fields' do
+            it 'returns joined record' do
+              result = user_adapter.join(simple)
+              expect(result.length).to eq 1
+
+              expect(result.first.first_name).to eq user.first_name
+              expect(result.first.last_name).to eq user.last_name
+              expect(result.first.email).to eq user.email
+              expect(result.first.boss_email).to eq employer.boss_email
+              expect(result.first.name).to eq employer.name
+            end
+          end
+
+          context 'with fields' do
+            it 'returns joined record and the specified fields' do
+              result = user_adapter.join(fields)
+              expect(result.length).to eq 1
+
+              record = result.first
+
+              expect(record.id).to eq user.id
+              expect(record.first_name).to eq user.first_name
+              expect(record.last_name).to eq user.last_name
+              expect(record.name).to eq employer.name
+              expect(record.employer_id).to eq employer.id
+
+              expect(record.respond_to?(:email)).to be false
+            end
+          end
+
+          context 'complex predicate' do
+            let!(:match_user) { HorzaSpec::User.create(employer: employer, first_name: 'John', last_name: 'Turner', email: 'boss@boss.com') }
+            let!(:match_user2) { HorzaSpec::User.create(employer: employer, first_name: 'Helen', last_name: 'Jones', email: 'boss@boss.com') }
+            it 'returns joined records and the specified fields' do
+              result = user_adapter.join(complex_predicate)
+              expect(result.length).to eq 2
+
+              expect(result.first.id).to eq match_user.id
+              expect(result.first.email).to eq match_user.email
+              expect(result.first.boss_email).to eq employer.boss_email
+            end
+
+          end
+        end
+
+        context 'when no join record exists' do
+          let!(:employer) { HorzaSpec::Employer.create(name: 'Corporation ltd.') }
+          let!(:user) { HorzaSpec::User.create(employer_id: 9999, first_name: 'John', last_name: 'Turner', email: 'email@email.com') }
+
+          it 'returns an empty collection' do
+            result = user_adapter.join(simple)
+            expect(result.length).to eq 0
+          end
+        end
+
+        context 'when multiple join records exists' do
+          let!(:employer) { HorzaSpec::Employer.create(name: 'Corporation ltd.') }
+          let!(:user) { HorzaSpec::User.create(employer: employer, first_name: 'John', last_name: 'Turner', email: 'email@turner.com') }
+          let!(:user2) { HorzaSpec::User.create(employer: employer, first_name: 'Adam', last_name: 'Boots', email: 'email@boots.com') }
+          let!(:user3) { HorzaSpec::User.create(employer: employer, first_name: 'Tim', last_name: 'Socks', email: 'email@socks.com') }
+
+          it 'returns an empty collection' do
+            result = user_adapter.join(simple)
+            expect(result.length).to eq 3
+          end
+        end
+      end
+
+      context 'with conditions' do
+        let!(:employer) { HorzaSpec::Employer.create(name: 'Corporation ltd.') }
+        let!(:employer2) { HorzaSpec::Employer.create(name: 'BigBucks ltd.') }
+        let!(:user) { HorzaSpec::User.create(employer: employer, first_name: 'John', last_name: 'Turner', email: 'email@turner.com') }
+        let!(:user2) { HorzaSpec::User.create(employer: employer, first_name: 'Adam', last_name: 'Boots', email: 'email@boots.com') }
+        let!(:user3) { HorzaSpec::User.create(employer: employer2, first_name: 'Tim', last_name: 'Socks', email: 'email@socks.com') }
+
+        it 'returns only the joins that match the conditions' do
+          result = user_adapter.join(conditions)
+          expect(result.length).to eq 1
+          expect(result.first.id).to eq user.id
+        end
+      end
+
+      context 'limits/offset' do
+        let!(:employer) { HorzaSpec::Employer.create(name: 'Corporation ltd.') }
+        let!(:employer2) { HorzaSpec::Employer.create(name: 'BigBucks ltd.') }
+        let!(:user) { HorzaSpec::User.create(employer: employer, first_name: 'John', last_name: 'Turner', email: 'email@turner.com') }
+        let!(:user2) { HorzaSpec::User.create(employer: employer, first_name: 'Adam', last_name: 'Turner', email: 'email@boots.com') }
+        let!(:user3) { HorzaSpec::User.create(employer: employer2, first_name: 'Tim', last_name: 'Socks', email: 'email@socks.com') }
+
+        it 'limits the joins that match the conditions' do
+          params = conditions.merge(limit: 1)
+          result = user_adapter.join(params)
+          expect(result.length).to eq 1
+          expect(result.first.id).to eq user.id
+        end
+
+        it 'offsets the joins that match the conditions' do
+          params = conditions.merge(offset: 1)
+          result = user_adapter.join(params)
+          expect(result.length).to eq 1
+          expect(result.first.id).to eq user2.id
+        end
+      end
+    end
   end
 
   describe 'Entities' do

data/spec/horza_spec.rb

@@ -76,7 +76,7 @@ describe Horza::Adapters::Options do
         offset: 10,
         target: :sports_cars,
         via: [:employer],
-        eager_load: true
+        eager_load: true,
       }
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: horza
 version: !ruby/object:Gem::Version
-  version: 0.3.9
+  version: 0.4.0
 platform: ruby
 authors:
 - Blake Turner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-01 00:00:00.000000000 Z
+date: 2015-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -105,7 +105,8 @@ files:
 - README.md
 - lib/horza.rb
 - lib/horza/adapters/abstract_adapter.rb
-- lib/horza/adapters/active_record.rb
+- lib/horza/adapters/active_record/active_record.rb
+- lib/horza/adapters/active_record/arel_join.rb
 - lib/horza/adapters/class_methods.rb
 - lib/horza/adapters/instance_methods.rb
 - lib/horza/adapters/options.rb