dbee 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bc7bf9701c14a96bfe5c83893637a1e10545e70f268c674851279d150b57bcc4
-  data.tar.gz: 1fbdb14e73fe98629a2cf41db0906b543eb33d16e044d5c8552916c76d4e9e8d
+  metadata.gz: 3e07996f0622fbf3eb19b8fa7bdd6ebfe963d3edc18745ccdf89f2a87f7a16dd
+  data.tar.gz: 0e25d666b9cd0a099741220caf423a670e832149bac26f27283c7a43987c14c5
 SHA512:
-  metadata.gz: 6ecaedc494e15776f1716de8891dd528fcbbbb76e44d6fe4d3056ab70674ede17f029f5316c171680c9265074624de8d78cf8856957fa5242371c26e41297089
-  data.tar.gz: e091625f6c6281673c48df689a1ec3ec692898799f9ef76d28991c90c519526bcd3c09d19d0cd1ce72a1df35bc98b5f81b46b01ec25934b4aa7ea86635549d1e
+  metadata.gz: 5290d4c90695c68b7d558c35cf4ca47cd24d60e50fc776ce2c4138a74d469e86bc9021d66a9645ddcb0e25924cad80d1dca239df610a1c01a41c02523159062e
+  data.tar.gz: b9023ad0e9a82db914a0c0c40b918fd52a87572718aadc31e82eb1ba96adbd7a8a50932d9d1968b72d73de9689f26d4ca71374e4a7c2fcba416fd5f4e992c696

data/CHANGELOG.md

@@ -1,8 +1,19 @@
+# 1.0.2 (August 26th, 2019)
+
+Fixes:
+
+* Dbee::Base subclasses can now support cycles to N-depth, where N is limited by the Query.  The recursion will go as far as the Query specifies it has to go.
+
+Additions:
+
+* Equals filter is now the default type when type is omitted.
+* model can now be a string so it can be lazy evaluated at run-time instead of at script evaluation time.
+
 # 1.0.1 (August 26th, 2019)
 
 Fixes:
 
-* Dbee::Base sub-classes can now declare self-referential associations.  Note that it will stop the hierarchy once the cycle is detected.
+* Dbee::Base subclasses can now declare self-referential associations.  Note that it will stop the hierarchy once the cycle is detected.
 
 Additions:
 

data/lib/dbee/base.rb

@@ -24,11 +24,23 @@ module Dbee
         self
       end
 
-      def to_model(name = nil, constraints = [], from = nil)
-        name  = derive_name(name)
-        key   = [name, constraints, from]
-
-        to_models[key] ||= Model.make(model_config(name, constraints, from))
+      # This method is cycle-resistant due to the fact that it is a requirement to send in a
+      # key_chain.  That means each model produced using to_model is specific to a set of desired
+      # fields.  Basically, you cannot derive a Model from a Base subclass without the context
+      # of a Query.  This is not true for configuration-first Model definitions because, in that
+      # case, cycles do not exist since the nature of the configuration is flat.
+      def to_model(key_chain, name = nil, constraints = [], path_parts = [])
+        derived_name  = derive_name(name)
+        key           = [key_chain, derived_name, constraints, path_parts]
+
+        to_models[key] ||= Model.make(
+          model_config(
+            key_chain,
+            derived_name,
+            constraints,
+            path_parts + [name]
+          )
+        )
       end
 
       def table_name
@@ -63,10 +75,10 @@ module Dbee
         subclasses.reverse
       end
 
-      def model_config(name, constraints, from)
+      def model_config(key_chain, name, constraints, path_parts)
         {
           constraints: constraints,
-          models: associations(from),
+          models: associations(key_chain, path_parts),
           name: name,
           table: derive_table
         }
@@ -82,15 +94,15 @@ module Dbee
         inherited_table.empty? ? inflected_name : inherited_table
       end
 
-      def associations(from)
+      def associations(key_chain, path_parts)
         inherited_associations_by_name.values
-                                      .reject { |c| c[:name].to_s == from.to_s }
+                                      .select { |c| key_chain.ancestor_path?(path_parts, c[:name]) }
                                       .each_with_object([]) do |config, memo|
-          model_klass             = config[:model]
+          model_constant          = constantize(config[:model])
           associated_constraints  = config[:constraints]
           name                    = config[:name]
 
-          memo << model_klass.to_model(name, associated_constraints, name)
+          memo << model_constant.to_model(key_chain, name, associated_constraints, path_parts)
         end
       end
 
@@ -106,6 +118,10 @@ module Dbee
             .tr('-', '_')
             .downcase
       end
+
+      def constantize(value)
+        value.is_a?(String) || value.is_a?(Symbol) ? Object.const_get(value) : value
+      end
     end
   end
 end

data/lib/dbee/key_chain.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require_relative 'key_path'
+
+module Dbee
+  # A KeyChain is a collection of KeyPath objects.  It knows how to deal with aggregate methods,
+  # such as equality of a set of KeyPath objects and finding an ancestor path in all the
+  # KeyPath objects' ancestor paths. You can pass in either KeyPath instances or strings,
+  # which will be coerced to KeyPath objects. Duplicates will also be removed.
+  class KeyChain
+    attr_reader :key_path_set, :ancestor_path_set
+
+    def initialize(key_paths = [])
+      @key_path_set       = key_paths.map { |k| KeyPath.get(k) }.to_set
+      @ancestor_path_set  = @key_path_set.map(&:ancestor_paths).flatten.to_set
+
+      freeze
+    end
+
+    def hash
+      key_path_set.hash
+    end
+
+    def ==(other)
+      key_path_set == other.key_path_set
+    end
+    alias eql? ==
+
+    def ancestor_path?(*parts)
+      path = parts.flatten.compact.join(KeyPath::SPLIT_CHAR)
+
+      ancestor_path_set.include?(path)
+    end
+  end
+end

data/lib/dbee/key_path.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+module Dbee
+  # This class represents a relative path from a model to a column.  For example:
+  # Say we have a model called "users" which is represented by a "users" table.
+  # The "users" table also has a one-to-many relationship with a "phone_numbers" table, which
+  # is modeled as a nested model under "users" as "phone_numbers".  Then, to get the column:
+  # "area_code", you would use: "phone_numbers.area_code".
+  # Say the column "name" is located on "users", you could use the key path: "name".
+  # This also works for deeper nested columns in the same fashion.
+  class KeyPath
+    extend Forwardable
+
+    class << self
+      def get(obj)
+        obj.is_a?(self.class) ? obj : new(obj)
+      end
+    end
+
+    SPLIT_CHAR = '.'
+
+    attr_reader :value, :ancestor_names, :column_name
+
+    def_delegators :value, :to_s
+
+    def initialize(value)
+      raise 'Value is required' if value.to_s.empty?
+
+      @value          = value.to_s
+      @ancestor_names = value.to_s.split(SPLIT_CHAR)
+      @column_name    = @ancestor_names.pop
+
+      freeze
+    end
+
+    def hash
+      value.hash
+    end
+
+    def ==(other)
+      other.to_s == to_s
+    end
+    alias eql? ==
+
+    def ancestor_paths
+      ancestor_names.each_with_object([]) do |ancestor, memo|
+        memo << [memo.last, ancestor].compact.join(SPLIT_CHAR)
+      end
+    end
+  end
+end

data/lib/dbee/model/constraints/base.rb

@@ -23,7 +23,7 @@ module Dbee
         end
 
         def <=>(other)
-          other.name <=> name
+          name <=> other.name
         end
 
         def hash

data/lib/dbee/model.rb

@@ -21,7 +21,7 @@ module Dbee
 
     class ModelNotFoundError < StandardError; end
 
-    attr_reader :constraints, :name
+    attr_reader :constraints, :name, :table
 
     def initialize(name:, constraints: [], models: [], table: '')
       raise ArgumentError, 'name is required' if name.to_s.empty?
@@ -29,7 +29,7 @@ module Dbee
       @name           = name.to_s
       @constraints    = Constraints.array(constraints)
       @models_by_name = name_hash(Model.array(models))
-      @table          = table.to_s
+      @table          = table.to_s.empty? ? @name : table.to_s
 
       freeze
     end
@@ -38,10 +38,6 @@ module Dbee
       array.map { |a| [a.name, a] }.to_h
     end
 
-    def table
-      @table.to_s.empty? ? name : @table
-    end
-
     def models
       models_by_name.values
     end
@@ -75,7 +71,7 @@ module Dbee
     alias eql? ==
 
     def <=>(other)
-      other.name <=> name
+      name <=> other.name
     end
 
     private

data/lib/dbee/query/field.rb

@@ -7,8 +7,6 @@
 # LICENSE file in the root directory of this source tree.
 #
 
-require_relative 'key_path'
-
 module Dbee
   class Query
     # This class is an abstraction of the SELECT part of a SQL statement.
@@ -36,6 +34,10 @@ module Dbee
         other.key_path == key_path && other.display == display
       end
       alias eql? ==
+
+      def <=>(other)
+        "#{key_path}#{display}" <=> "#{other.key_path}#{other.display}"
+      end
     end
   end
 end

data/lib/dbee/query/filters/base.rb

@@ -33,6 +33,10 @@ module Dbee
           other.key_path == key_path && other.value == value
         end
         alias eql? ==
+
+        def <=>(other)
+          "#{key_path}#{value}" <=> "#{other.key_path}#{other.value}"
+        end
       end
     end
   end

data/lib/dbee/query/filters.rb

@@ -25,6 +25,7 @@ module Dbee
     class Filters
       acts_as_hashable_factory
 
+      register '',                          Equals # Default if type is blank.
       register 'contains',                  Contains
       register 'equals',                    Equals
       register 'greater_than_or_equal_to',  GreaterThanOrEqualTo

data/lib/dbee/query/sorter.rb

@@ -7,8 +7,6 @@
 # LICENSE file in the root directory of this source tree.
 #
 
-require_relative 'key_path'
-
 module Dbee
   class Query
     # Abstract representation of the ORDER BY part of a SQL statement.
@@ -48,6 +46,10 @@ module Dbee
         other.key_path == key_path && other.direction == direction
       end
       alias eql? ==
+
+      def <=>(other)
+        "#{key_path}#{direction}" <=> "#{other.key_path}#{other.direction}"
+      end
     end
   end
 end

data/lib/dbee/query.rb

@@ -40,11 +40,21 @@ module Dbee
     end
 
     def ==(other)
-      other.fields == fields &&
-        other.filters == filters &&
+      other.fields.sort == fields.sort &&
+        other.filters.sort == filters.sort &&
         other.limit == limit &&
-        other.sorters == sorters
+        other.sorters.sort == sorters.sort
     end
     alias eql? ==
+
+    def key_chain
+      KeyChain.new(key_paths)
+    end
+
+    private
+
+    def key_paths
+      (fields.map(&:key_path) + filters.map(&:key_path) + sorters.map(&:key_path))
+    end
   end
 end

data/lib/dbee/version.rb

@@ -8,5 +8,5 @@
 #
 
 module Dbee
-  VERSION = '1.0.1'
+  VERSION = '1.0.2'
 end

data/lib/dbee.rb

@@ -11,6 +11,8 @@ require 'acts_as_hashable'
 require 'forwardable'
 
 require_relative 'dbee/base'
+require_relative 'dbee/key_chain'
+require_relative 'dbee/key_path'
 require_relative 'dbee/model'
 require_relative 'dbee/query'
 require_relative 'dbee/providers'
@@ -19,8 +21,13 @@ require_relative 'dbee/providers'
 module Dbee
   class << self
     def sql(model, query, provider)
-      model = model.is_a?(Hash) || model.is_a?(Model) ? Model.make(model) : model.to_model
       query = Query.make(query)
+      model =
+        if model.is_a?(Hash) || model.is_a?(Model)
+          Model.make(model)
+        else
+          model.to_model(query.key_chain)
+        end
 
       provider.sql(model, query)
     end

data/spec/dbee/base_spec.rb

@@ -11,13 +11,53 @@ require 'spec_helper'
 require 'fixtures/models'
 
 describe Dbee::Base do
-  it 'compiles to Model instance correctly' do
-    model_name      = 'Theaters, Members, and Movies'
-    expected_config = yaml_fixture('models.yaml')[model_name]
+  describe '#to_model' do
+    it 'compiles correctly' do
+      model_name      = 'Theaters, Members, and Movies'
+      expected_config = yaml_fixture('models.yaml')[model_name]
 
-    expected_model = Dbee::Model.make(expected_config)
+      expected_model = Dbee::Model.make(expected_config)
 
-    expect(Models::Theaters.to_model).to eq(expected_model)
+      key_paths = %w[
+        members.demos.phone_numbers.a
+        members.movies.b
+        members.favorite_comic_movies.c
+        members.favorite_mystery_movies.d
+        members.favorite_comedy_movies.e
+        parent_theater.members.demos.phone_numbers.f
+        parent_theater.members.movies.g
+        parent_theater.members.favorite_comic_movies.h
+        parent_theater.members.favorite_mystery_movies.i
+        parent_theater.members.favorite_comedy_movies.j
+      ]
+
+      key_chain = Dbee::KeyChain.new(key_paths)
+
+      actual_model = Models::Theaters.to_model(key_chain)
+
+      expect(actual_model).to eq(expected_model)
+    end
+
+    it 'honors key_chain to flatten cyclic references' do
+      model_name      = 'Cycle Example'
+      expected_config = yaml_fixture('models.yaml')[model_name]
+
+      expected_model = Dbee::Model.make(expected_config)
+
+      key_paths = %w[
+        b1.c.a.z
+        b1.d.a.y
+        b2.c.a.x
+        b2.d.a.w
+        b2.d.a.b1.c.z
+      ]
+
+      key_chain = Dbee::KeyChain.new(key_paths)
+
+      actual_model = Cycles::A.to_model(key_chain)
+
+      expect(actual_model).to eq(expected_model)
+    end
   end
 
   context 'inheritance' do

data/spec/dbee/key_chain_spec.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+#
+# Copyright (c) 2019-present, Blue Marble Payroll, LLC
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+require 'spec_helper'
+
+describe Dbee::KeyChain do
+  let(:key_paths) do
+    [
+      'z.b.c.d.e',
+      'b.c.s',
+      'a',
+      'b.c.s',
+      123,
+      Dbee::KeyPath.get('44.55.66'),
+      'a'
+    ]
+  end
+
+  let(:out_of_order_key_paths) do
+    [
+      Dbee::KeyPath.get('44.55.66'),
+      Dbee::KeyPath.get('44.55.66'),
+      Dbee::KeyPath.get('44.55.66'),
+      Dbee::KeyPath.get('b.c.s'),
+      Dbee::KeyPath.get(123),
+      Dbee::KeyPath.get('z.b.c.d.e'),
+      Dbee::KeyPath.get('44.55.66'),
+      Dbee::KeyPath.get('a')
+    ]
+  end
+
+  subject { described_class.new(key_paths) }
+
+  describe '#initialize' do
+    it 'sets key_path_set correctly' do
+      expect(subject.key_path_set).to eq(out_of_order_key_paths.to_set)
+    end
+
+    it 'sets ancestor_path_set correctly' do
+      expected = out_of_order_key_paths.map(&:ancestor_paths).flatten.to_set
+
+      expect(subject.ancestor_path_set).to eq(expected)
+    end
+  end
+
+  specify 'equality compares unique key_paths' do
+    chain1 = described_class.new(key_paths)
+    chain2 = described_class.new(out_of_order_key_paths)
+
+    expect(chain1).to eq(chain2)
+    expect(chain1).to eql(chain2)
+  end
+
+  specify '#hash compares unique key_path hashes' do
+    chain1 = described_class.new(key_paths)
+    chain2 = described_class.new(out_of_order_key_paths)
+
+    expect(chain1.hash).to eq(chain2.hash)
+    expect(chain1.hash).to eql(chain2.hash)
+  end
+
+  describe '#ancestor_path?' do
+    it 'returns true when passed in ancestor_path exists' do
+      %w[z z.b z.b.c z.b.c.d b b.c 44 44.55].each do |example|
+        expect(subject.ancestor_path?(example)).to be true
+      end
+    end
+
+    it 'returns false when passed in ancestor_path does not exist' do
+      %w[z.b.c.d.e matt nick sam.nick A Z].each do |example|
+        expect(subject.ancestor_path?(example)).to be false
+      end
+    end
+  end
+end

data/spec/dbee/{query/key_path_spec.rb → key_path_spec.rb}

@@ -9,7 +9,7 @@
 
 require 'spec_helper'
 
-describe Dbee::Query::KeyPath do
+describe Dbee::KeyPath do
   let(:key_path_string) { 'contacts.demographics.first' }
 
   subject { described_class.get(key_path_string) }
@@ -32,4 +32,16 @@ describe Dbee::Query::KeyPath do
     expect(subject).to eq(key_path_string)
     expect(subject).to eql(key_path_string)
   end
+
+  describe '#ancestor_paths' do
+    let(:key_path_string) { 'a.b.c.d.e' }
+
+    subject { described_class.get(key_path_string) }
+
+    it 'should include all left-inclusive paths' do
+      expected = %w[a a.b a.b.c a.b.c.d]
+
+      expect(subject.ancestor_paths).to eq(expected)
+    end
+  end
 end

data/spec/dbee/model_spec.rb

@@ -103,11 +103,20 @@ describe Dbee::Model do
 
   context 'README examples' do
     specify 'code-first and configuration-first models are equal' do
-      config = yaml_fixture('models.yaml')['Readme']
+      config        = yaml_fixture('models.yaml')['Readme']
+      config_model  = described_class.make(config)
 
-      config_model = described_class.make(config)
+      key_chain = Dbee::KeyChain.new(%w[
+                                       patients.a
+                                       patients.notes.b
+                                       patients.work_phone_number.c
+                                       patients.cell_phone_number.d
+                                       patients.fax_phone_number.e
+                                     ])
 
-      expect(config_model).to eq(ReadmeDataModels::Practices.to_model)
+      code_model = ReadmeDataModels::Practices.to_model(key_chain)
+
+      expect(config_model).to eq(code_model)
     end
   end
 end

data/spec/dbee/query_spec.rb

@@ -21,6 +21,10 @@ describe Dbee::Query do
         { key_path: :sort_me },
         { key_path: :sort_me_too, direction: :descending }
       ],
+      filters: [
+        { key_path: 'filter_me.a_little', value: 'something' },
+        { key_path: 'matt.nick.sam', value: 'something' }
+      ],
       limit: 125
     }
   end
@@ -41,6 +45,19 @@ describe Dbee::Query do
     end
   end
 
+  describe '#key_chain' do
+    it 'should include filter, sorter, and field key_paths' do
+      key_paths =
+        config[:fields].map { |f| f[:key_path].to_s } +
+        config[:filters].map { |f| f[:key_path].to_s } +
+        config[:sorters].map { |s| s[:key_path].to_s }
+
+      expected_key_chain = Dbee::KeyChain.new(key_paths)
+
+      expect(subject.key_chain).to eq(expected_key_chain)
+    end
+  end
+
   context 'README examples' do
     EXAMPLES = {
       'Get all practices' => {

data/spec/dbee_spec.rb

@@ -14,47 +14,58 @@ describe Dbee do
   describe '#sql' do
     let(:provider) { Dbee::Providers::NullProvider.new }
 
-    let(:query) { { fields: [{ key_path: :a }] } }
+    let(:model_hash) do
+      {
+        name: 'something'
+      }
+    end
 
-    it 'accepts a hash as a model and passes a Model instance to provider#sql' do
-      model = { name: 'something' }
+    let(:model) { Dbee::Model.make(model_hash) }
 
-      expect(provider).to receive(:sql).with(Dbee::Model.make(model), Dbee::Query.make(query))
+    let(:query_hash) do
+      {
+        fields: [
+          { key_path: :a }
+        ]
+      }
+    end
 
-      described_class.sql(model, query, provider)
+    let(:query) { Dbee::Query.make(query_hash) }
+
+    it 'accepts a hash as a model and passes a Model instance to provider#sql' do
+      expect(provider).to receive(:sql).with(model, query)
+
+      described_class.sql(model_hash, query, provider)
     end
 
     it 'accepts a Dbee::Model instance as a model and passes a Model instance to provider#sql' do
-      model = Dbee::Model.make(name: 'something')
-
-      expect(provider).to receive(:sql).with(Dbee::Model.make(model), Dbee::Query.make(query))
+      expect(provider).to receive(:sql).with(model, query)
 
       described_class.sql(model, query, provider)
     end
 
     it 'accepts a Dbee::Base constant as a model and passes a Model instance to provider#sql' do
-      model = Models::Theaters
+      model_constant = Models::Theaters
 
-      expect(provider).to receive(:sql).with(model.to_model, Dbee::Query.make(query))
+      expect(provider).to receive(:sql).with(model_constant.to_model(query.key_chain), query)
 
-      described_class.sql(model, query, provider)
+      described_class.sql(model_constant, query, provider)
     end
 
     it 'accepts a Dbee::Query instance as a query and passes a Query instance to provider#sql' do
-      model = Models::Theaters
-      query = Dbee::Query.make(query)
+      model = Models::Theaters.to_model(query.key_chain)
 
-      expect(provider).to receive(:sql).with(model.to_model, Dbee::Query.make(query))
+      expect(provider).to receive(:sql).with(model, query)
 
       described_class.sql(model, query, provider)
     end
 
     it 'accepts a hash as a query and passes a Query instance to provider#sql' do
-      model = Models::Theaters
+      model = Models::Theaters.to_model(query.key_chain)
 
-      expect(provider).to receive(:sql).with(model.to_model, Dbee::Query.make(query))
+      expect(provider).to receive(:sql).with(model, query)
 
-      described_class.sql(model, query, provider)
+      described_class.sql(model, query_hash, provider)
     end
   end
 end

data/spec/fixtures/models.rb

@@ -15,7 +15,7 @@ module Models
   end
 
   class Demographics < Dbee::Base
-    association :phone_numbers, model: PhoneNumbers,
+    association :phone_numbers, model: 'Models::PhoneNumbers',
                                 constraints: {
                                   name: :demographic_id,
                                   parent: :id
@@ -56,7 +56,7 @@ module Models
 
   class Theaters < TheatersBase
     association :parent_theater, model: self, constraints: [
-      { type: :reference, name: :parent_theater_id, parent: :id }
+      { type: :reference, name: :id, parent: :parent_theater_id }
     ]
   end
 
@@ -115,3 +115,27 @@ module ReadmeDataModels
     }
   end
 end
+
+module Cycles
+  class BaseA < Dbee::Base
+    association :b1, model: 'Cycles::B'
+  end
+
+  class A < BaseA
+    association :b2, model: 'Cycles::B'
+  end
+
+  class B < Dbee::Base
+    association :c, model: 'Cycles::C'
+
+    association :d, model: 'Cycles::D'
+  end
+
+  class C < Dbee::Base
+    association :a, model: 'Cycles::A'
+  end
+
+  class D < Dbee::Base
+    association :a, model: 'Cycles::A'
+  end
+end

data/spec/fixtures/models.yaml

@@ -60,8 +60,8 @@ Theaters, Members, and Movies:
       table: theaters
       constraints:
         - type: reference
-          name: parent_theater_id
-          parent: id
+          name: id
+          parent: parent_theater_id
       models:
         - name: members
           table: members
@@ -160,3 +160,29 @@ Readme:
             - type: static
               name: phone_number_type
               value: fax
+Cycle Example:
+  name: a
+  models:
+    - name: b1
+      table: b
+      models:
+        - name: c
+          models:
+            - name: a
+        - name: d
+          models:
+            - name: a
+    - name: b2
+      table: b
+      models:
+        - name: c
+          models:
+            - name: a
+        - name: d
+          models:
+            - name: a
+              models:
+                - name: b1
+                  table: b
+                  models:
+                    - name: c

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbee
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-26 00:00:00.000000000 Z
+date: 2019-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: acts_as_hashable
@@ -155,6 +155,8 @@ files:
 - dbee.gemspec
 - lib/dbee.rb
 - lib/dbee/base.rb
+- lib/dbee/key_chain.rb
+- lib/dbee/key_path.rb
 - lib/dbee/model.rb
 - lib/dbee/model/constraints.rb
 - lib/dbee/model/constraints/base.rb
@@ -176,10 +178,11 @@ files:
 - lib/dbee/query/filters/not_equals.rb
 - lib/dbee/query/filters/not_start_with.rb
 - lib/dbee/query/filters/starts_with.rb
-- lib/dbee/query/key_path.rb
 - lib/dbee/query/sorter.rb
 - lib/dbee/version.rb
 - spec/dbee/base_spec.rb
+- spec/dbee/key_chain_spec.rb
+- spec/dbee/key_path_spec.rb
 - spec/dbee/model/constraints/base_spec.rb
 - spec/dbee/model/constraints/reference_spec.rb
 - spec/dbee/model/constraints/static_spec.rb
@@ -189,7 +192,6 @@ files:
 - spec/dbee/query/field_spec.rb
 - spec/dbee/query/filters/base_spec.rb
 - spec/dbee/query/filters_spec.rb
-- spec/dbee/query/key_path_spec.rb
 - spec/dbee/query/sorter_spec.rb
 - spec/dbee/query_spec.rb
 - spec/dbee_spec.rb
@@ -221,6 +223,8 @@ specification_version: 4
 summary: Adhoc Reporting SQL Generator
 test_files:
 - spec/dbee/base_spec.rb
+- spec/dbee/key_chain_spec.rb
+- spec/dbee/key_path_spec.rb
 - spec/dbee/model/constraints/base_spec.rb
 - spec/dbee/model/constraints/reference_spec.rb
 - spec/dbee/model/constraints/static_spec.rb
@@ -230,7 +234,6 @@ test_files:
 - spec/dbee/query/field_spec.rb
 - spec/dbee/query/filters/base_spec.rb
 - spec/dbee/query/filters_spec.rb
-- spec/dbee/query/key_path_spec.rb
 - spec/dbee/query/sorter_spec.rb
 - spec/dbee/query_spec.rb
 - spec/dbee_spec.rb

data/lib/dbee/query/key_path.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-#
-# Copyright (c) 2019-present, Blue Marble Payroll, LLC
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-#
-
-module Dbee
-  class Query
-    # This class represents a relative path from a model to a column.  For example:
-    # Say we have a model called "users" which is represented by a "users" table.
-    # The "users" table also has a one-to-many relationship with a "phone_numbers" table, which
-    # is modeled as a nested model under "users" as "phone_numbers".  Then, to get the column:
-    # "area_code", you would use: "phone_numbers.area_code".
-    # Say the column "name" is located on "users", you could use the key path: "name".
-    # This also works for deeper nested columns in the same fashion.
-    class KeyPath
-      extend Forwardable
-
-      class << self
-        def get(obj)
-          obj.is_a?(self.class) ? obj : new(obj)
-        end
-      end
-
-      SPLIT_CHAR = '.'
-
-      private_constant :SPLIT_CHAR
-
-      attr_reader :value, :ancestor_names, :column_name
-
-      def_delegators :value, :to_s
-
-      def initialize(value)
-        raise 'Value is required' if value.to_s.empty?
-
-        @value          = value.to_s
-        @ancestor_names = value.to_s.split(SPLIT_CHAR)
-        @column_name    = @ancestor_names.pop
-
-        freeze
-      end
-
-      def hash
-        value.hash
-      end
-
-      def ==(other)
-        other.to_s == to_s
-      end
-      alias eql? ==
-    end
-  end
-end