dbee 2.1.1 → 3.0.0

data/lib/dbee/schema_from_tree_based_model.rb

@@ -0,0 +1,47 @@
+# 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
+  # Converts a tree based model to a Schema. Note that this results in a
+  # different but compatible schema compared to the result of generating a
+  # Dbee::Schema by calling to_schema on a Dbee::Base class. This is
+  # because converting from a tree based model is a lossy.
+  class SchemaFromTreeBasedModel # :nodoc:
+    class << self
+      def convert(tree_model)
+        Schema.new(to_graph_based_models(tree_model))
+      end
+
+      private
+
+      def to_graph_based_models(tree_model, parent_model = nil, models_attrs_by_name = {})
+        models_attrs_by_name[tree_model.name] = {
+          name: tree_model.name,
+          table: tree_model.table,
+          partitioners: tree_model.partitioners,
+          relationships: {}
+        }
+
+        parent_model && add_relationship_to_parent_model(
+          tree_model, models_attrs_by_name[parent_model.name]
+        )
+
+        tree_model.models.each do |sub_model|
+          to_graph_based_models(sub_model, tree_model, models_attrs_by_name)
+        end
+
+        models_attrs_by_name
+      end
+
+      def add_relationship_to_parent_model(model, graph_model_attrs)
+        graph_model_attrs[:relationships][model.name] = { constraints: model.constraints }
+      end
+    end
+  end
+end

data/lib/dbee/util/make_keyed_by.rb

@@ -0,0 +1,50 @@
+# 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
+  module Util
+    # Provides a "make_keyed_by" method which extends the Hashable gem's
+    # concept of a "make" method.
+    module MakeKeyedBy # :nodoc:
+      # Given a hash of hashes or a hash of values of instances of this class,
+      # a hash is returned where all of the values are instances of this class
+      # and the keys are the string versions of the original hash.
+      #
+      # An ArgumentError is raised if the value's <tt>key_attrib</tt> is not
+      # equal to the top level hash key. This ensures that the
+      # <tt>key_attrib</tt> is the same in the incoming hash and the value.
+      #
+      # This is useful for cases where it makes sense in the configuration
+      # (YAML) specification to represent certain objects in a hash structure
+      # instead of a list.
+      def make_keyed_by(key_attrib, spec_hash)
+        # Once Ruby 2.5 support is dropped, this can just use the block form of
+        # #to_h.
+        spec_hash.map do |key, spec|
+          string_key = key.to_s
+          [string_key, make_value_checking_key_attib!(key_attrib, string_key, spec)]
+        end.to_h
+      end
+
+      private
+
+      def make_value_checking_key_attib!(key_attrib, key, spec)
+        if spec.is_a?(self)
+          if spec.send(key_attrib).to_s != key
+            err_msg = "expected a #{key_attrib} of '#{key}' but got '#{spec.send(key_attrib)}'"
+            raise ArgumentError, err_msg
+          end
+          spec
+        else
+          make((spec || {}).merge(key_attrib => key))
+        end
+      end
+    end
+  end
+end

data/lib/dbee/version.rb

@@ -8,5 +8,5 @@
 #
 
 module Dbee
-  VERSION = '2.1.1'
+  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

@@ -9,23 +9,28 @@
 
 require 'spec_helper'
 
-describe Dbee::ConstantResolver do
-  module A
-    class B; end
-    class E; end
-  end
-
+# rubocop:disable Lint/EmptyClass
+# These are intentionally empty to keep the tests focused.
+module A
   class B; end
 
-  module C
-    class D; end
-    class E; end
+  class E; end
+end
+
+class B; end
 
-    module F
-      class G; end
-    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

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