dbee 2.0.2 → 3.0.0

data/lib/dbee/version.rb

@@ -8,5 +8,5 @@
 #
 
 module Dbee
-  VERSION = '2.0.2'
+  VERSION = '3.0.0'
 end

data/spec/dbee/base_spec.rb

@@ -11,52 +11,17 @@ require 'spec_helper'
 require 'fixtures/models'
 
 describe Dbee::Base do
-  describe '#to_model' do
-    it 'compiles correctly' do
-      model_name      = 'Theaters, Members, and Movies'
-      expected_config = yaml_fixture('models.yaml')[model_name]
+  describe '.to_schema' do
+    it 'passes the keychain and model to DslSchemaBuilder' do
+      key_chain = Dbee::KeyChain.new
 
-      expected_model = Dbee::Model.make(expected_config)
+      schema_builder_double = double(Dbee::DslSchemaBuilder)
+      expect(Dbee::DslSchemaBuilder).to receive(:new).with(Models::A, key_chain).and_return(
+        schema_builder_double
+      )
+      expect(schema_builder_double).to receive(:to_schema)
 
-      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::Theater.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)
+      Models::A.to_schema(key_chain)
     end
   end
 
@@ -72,32 +37,4 @@ describe Dbee::Base do
       expect(Models::E.inherited_table_name).to eq('table_set_to_e')
     end
   end
-
-  describe 'partitioners' do
-    it 'honors partitioners on a root model' do
-      model_name      = 'Partitioner Example 1'
-      expected_config = yaml_fixture('models.yaml')[model_name]
-      expected_model = Dbee::Model.make(expected_config)
-
-      key_paths = %w[id]
-      key_chain = Dbee::KeyChain.new(key_paths)
-
-      actual_model = PartitionerExamples::Dog.to_model(key_chain)
-
-      expect(actual_model).to eq(expected_model)
-    end
-
-    it 'honors partitioners on a child model' do
-      model_name      = 'Partitioner Example 2'
-      expected_config = yaml_fixture('models.yaml')[model_name]
-      expected_model = Dbee::Model.make(expected_config)
-
-      key_paths = %w[id dogs.id]
-      key_chain = Dbee::KeyChain.new(key_paths)
-
-      actual_model = PartitionerExamples::Owner.to_model(key_chain)
-
-      expect(actual_model).to eq(expected_model)
-    end
-  end
 end

data/spec/dbee/constant_resolver_spec.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.
+#
+
+require 'spec_helper'
+
+# rubocop:disable Lint/EmptyClass
+# These are intentionally empty to keep the tests focused.
+module A
+  class B; end
+
+  class E; end
+end
+
+class B; end
+
+module C
+  class D; end
+
+  class E; end
+
+  module F
+    class G; end
+  end
+end
+# rubocop:enable Lint/EmptyClass
+
+describe Dbee::ConstantResolver do
+  it 'resolves nested constant with the same as an ancestor constants sibling' do
+    expect(subject.constantize('A::B')).to eq(::A::B)
+  end
+
+  it 'resolves root constant' do
+    expect(subject.constantize('B')).to eq(::B)
+  end
+
+  it 'does not resolve constant in a different parent module' do
+    expect { subject.constantize('C::B') }.to raise_error(NameError)
+  end
+
+  it 'does not resolve constant in a different parent module' do
+    expect { subject.constantize('D') }.to raise_error(NameError)
+  end
+
+  it 'resolves same leaf constants specific to their parents' do
+    expect(subject.constantize('A::E')).to eq(::A::E)
+    expect(subject.constantize('C::E')).to eq(::C::E)
+  end
+
+  it 'does not resolve constant without its parent' do
+    expect { subject.constantize('F') }.to raise_error(NameError)
+  end
+end

data/spec/dbee/dsl_schema_builder_spec.rb

@@ -0,0 +1,106 @@
+# 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'
+require 'fixtures/models'
+
+describe Dbee::DslSchemaBuilder do
+  specify 'theaters example' do
+    model_name      = 'Theaters, Members, and Movies from DSL'
+    expected_config = yaml_fixture('models.yaml')[model_name]
+
+    expected_schema = Dbee::Schema.new(expected_config)
+
+    key_paths = %w[
+      members.a
+      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_schema = Models::Theater.to_schema(key_chain)
+    expect(actual_schema).to eq(expected_schema)
+  end
+
+  it 'honors key_chain to flatten cyclic references' do
+    model_name      = 'Cycle Example'
+    expected_config = yaml_fixture('models.yaml')[model_name]
+
+    expected_schema = Dbee::Schema.new(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_schema = Cycles::A.to_schema(key_chain)
+    expect(actual_schema).to eq(expected_schema)
+  end
+
+  describe 'partitioners' do
+    it 'honors partitioners on a root model' do
+      model_name      = 'Partitioner Example 1'
+      expected_config = yaml_fixture('models.yaml')[model_name]
+      expected_schema = Dbee::Schema.new(expected_config)
+
+      key_paths = %w[id]
+      key_chain = Dbee::KeyChain.new(key_paths)
+
+      actual_schema = PartitionerExamples::Dog.to_schema(key_chain)
+
+      expect(actual_schema).to eq(expected_schema)
+    end
+
+    it 'honors partitioners on a child model' do
+      model_name      = 'Partitioner Example 2'
+      expected_config = yaml_fixture('models.yaml')[model_name]
+      expected_schema = Dbee::Schema.new(expected_config)
+
+      key_paths = %w[id dogs.id]
+      key_chain = Dbee::KeyChain.new(key_paths)
+
+      actual_schema = PartitionerExamples::Owner.to_schema(key_chain)
+
+      expect(actual_schema).to eq(expected_schema)
+    end
+  end
+
+  context 'README examples' do
+    specify 'code-first and configuration-first models are equal' do
+      config        = yaml_fixture('models.yaml')['Readme']
+      config_schema = Dbee::Schema.new(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
+                                     ])
+
+      code_schema = ReadmeDataModels::Practice.to_schema(key_chain)
+
+      expect(config_schema).to eq(code_schema)
+    end
+  end
+end

data/spec/dbee/key_chain_spec.rb

@@ -78,4 +78,28 @@ describe Dbee::KeyChain do
       end
     end
   end
+
+  describe '#to_unique_ancestors collapses the KeyChain' do
+    let(:collapsed_key_chain) do
+      described_class.new([
+                            'z.b.c.d.any_column',
+                            'b.c.any_column',
+                            'any_column',
+                            '44.55.any_column'
+                          ])
+    end
+
+    specify 'the empty case' do
+      expect(described_class.new.to_unique_ancestors).to eq described_class.new
+    end
+
+    specify 'when there are no ancestors, one key path is returned' do
+      no_query_depth = described_class.new(%w[column1 column2 column3])
+      expect(no_query_depth.to_unique_ancestors).to eq described_class.new(['any_column'])
+    end
+
+    it 'returns a new KeyChain which has one KeyPath per ancestor' do
+      expect(subject.to_unique_ancestors).to eq collapsed_key_chain
+    end
+  end
 end

data/spec/dbee/model/constraints_spec.rb

@@ -9,14 +9,13 @@
 
 require 'spec_helper'
 
-describe Dbee::Model::Constraints do
-  CONSTRAINT_CONFIG = { name: :a }.freeze
-
-  CONSTRAINT_FACTORIES = {
-    Dbee::Model::Constraints::Reference => CONSTRAINT_CONFIG.merge(parent: :b, type: :reference),
-    Dbee::Model::Constraints::Static => CONSTRAINT_CONFIG.merge(value: :b, type: :static)
-  }.freeze
+CONSTRAINT_CONFIG = { name: :a }.freeze
+CONSTRAINT_FACTORIES = {
+  Dbee::Model::Constraints::Reference => CONSTRAINT_CONFIG.merge(parent: :b, type: :reference),
+  Dbee::Model::Constraints::Static => CONSTRAINT_CONFIG.merge(value: :b, type: :static)
+}.freeze
 
+describe Dbee::Model::Constraints do
   CONSTRAINT_FACTORIES.each_pair do |constant, config|
     it "should instantiate #{constant} objects" do
       expect(described_class.make(config)).to be_a(constant)

data/spec/dbee/model_spec.rb

@@ -55,77 +55,80 @@ describe Dbee::Model do
     end
   end
 
-  describe '#ancestors' do
-    let(:yaml_entities) { yaml_fixture('models.yaml') }
-
-    let(:entity_hash) { yaml_entities['Theaters, Members, and Movies'] }
-
-    subject { described_class.make(entity_hash) }
-
-    specify 'returns proper models' do
-      members = subject.models.first
-
-      expected_plan = {
-        %w[members] => members
+  describe '.make_keyed_by' do
+    it 'returns a hash of Models where the keys equal the names of the models' do
+      input = {
+        model1: nil,
+        model2: { table: :model2_table }
       }
-
-      plan = subject.ancestors!(%w[members])
-
-      expect(plan).to eq(expected_plan)
-    end
-
-    specify 'returns proper multi-level models' do
-      members       = subject.models.first
-      demos         = members.models.first
-      phone_numbers = demos.models.first
-
-      expected_plan = {
-        %w[members] => members,
-        %w[members demos] => demos,
-        %w[members demos phone_numbers] => phone_numbers
+      expected_result = {
+        'model1' => described_class.new(name: 'model1'),
+        'model2' => described_class.new(name: 'model2', table: 'model2_table')
       }
 
-      plan = subject.ancestors!(%w[members demos phone_numbers])
-
-      expect(plan).to eq(expected_plan)
+      expect(described_class.make_keyed_by(:name, input)).to eq expected_result
     end
-  end
-
-  describe 'equality' do
-    let(:config) { yaml_fixture('models.yaml')['Theaters, Members, and Movies'] }
 
-    subject { described_class.make(config) }
-
-    specify 'equality compares attributes' do
-      model1 = described_class.make(config)
-      model2 = described_class.make(config)
+    it 'accepts values of Dbee::Model instances' do
+      input = { model1: described_class.new(name: :model1) }
+      expected_result = { 'model1' => described_class.new(name: :model1) }
+      expect(described_class.make_keyed_by(:name, input)).to eq expected_result
+    end
 
-      expect(model1).to eq(model2)
-      expect(model1).to eql(model2)
+    it 'accepts values of Dbee::Model instances when the key attribute is a string' do
+      input = { 'model1' => described_class.new(name: 'model1') }
+      expected_result = { 'model1' => described_class.new(name: 'model1') }
+      expect(described_class.make_keyed_by(:name, input)).to eq expected_result
     end
 
-    it 'returns false unless comparing same object types' do
-      expect(subject).not_to eq(config)
-      expect(subject).not_to eq(nil)
+    it 'raises an error when the input hash key is not equal to the name of the model' do
+      input = { model1: described_class.new(name: :bogus) }
+      expect do
+        described_class.make_keyed_by(:name, input)
+      end.to raise_error ArgumentError, "expected a name of 'model1' but got 'bogus'"
     end
   end
 
-  context 'README examples' do
-    specify 'code-first and configuration-first models are equal' do
-      config        = yaml_fixture('models.yaml')['Readme']
-      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
-                                     ])
-
-      code_model = ReadmeDataModels::Practice.to_model(key_chain)
+  describe '#to_s' do
+    it 'is represented by the model name' do
+      expect(described_class.new(name: 'foo').to_s).to eq 'foo'
+    end
+  end
 
-      expect(config_model).to eq(code_model)
+  equality_cases = {
+    tree_based: yaml_fixture('models.yaml')['Theaters, Members, and Movies Tree Based'],
+    graph_based: yaml_fixture('models.yaml')['Theaters, Members, and Movies from DSL']['theater']
+  }
+  equality_cases[:graph_based].merge!(name: 'theaters')
+  equality_cases.each do |test_case, config|
+    describe "equality for #{test_case}" do
+      let(:model1) { described_class.make(config) }
+      let(:model2) { described_class.make(config) }
+
+      subject { described_class.make(config) }
+
+      specify 'equality compares attributes' do
+        expect(model1).to eq(model2)
+        expect(model1).to eql(model2)
+      end
+
+      it 'returns false unless comparing same object types' do
+        expect(subject).not_to eq(config)
+        expect(subject).not_to eq(nil)
+      end
+
+      describe 'hash codes' do
+        specify 'are equal when objects are equal' do
+          expect(model1).to eq(model2)
+          expect(model1.hash).to eq(model2.hash)
+        end
+
+        specify 'are not equal when objects are not equal' do
+          different_model = described_class.new(name: :oddball)
+          expect(model1).not_to eq(different_model)
+          expect(model1.hash).not_to eq(different_model.hash)
+        end
+      end
     end
   end
 end