dbee 1.2.1 → 2.0.0.pre.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e099b2ff5d651a4bc97562314e0216e07afa778cc7b99cc775a2461f744ab3a
-  data.tar.gz: 3d9ea4d091416484bdd5186caf02f9fec23e6d15d91fb9528965c9eff07f9669
+  metadata.gz: ccd40ea06b62b782bc525c069d38b01fc4c486b42507dd8f70e915ba197f01b6
+  data.tar.gz: a2f2fac76927357e5187d922c3da1ffd8e102430a878f8dedbec3aeb654ad0be
 SHA512:
-  metadata.gz: 7a31b7129beab7271692bc7ff3534ce53977d80a017d5fee250e13fa1f5c586d51cd867c39e72aa646265287b2ae152a5b8d824bdd849459fedfb67f6b240ae6
-  data.tar.gz: 5d0149dedb9a61efc00df03e37e454bfb53755a7ecdb8f8440751779e352b30e2f1f910a97f60df7bbbd3cd7f8111dbf2af1d2b93635a2dfc255e735cd3e2ebc
+  metadata.gz: ea4bfb0f14b33d70b7704ba8006189d5d725f90cf7de89d321d7147ab75c7b068644dd4d483b2aa7c1ee187080ae438096d05856b4c9d2b46265b5548a481d4a
+  data.tar.gz: ee4ecf4505be3b1911662de5553a3b38606af539a0bfadbc243fb2d38bf6d11310945bf2664d10795c97d0e6a82bc49262ae9550c0c7a867b25a4c1d9f3a4503

data/CHANGELOG.md

@@ -1,55 +1,71 @@
+# 2.0.0 (September 3rd, 2019)
+
+### Additions:
+
+* New DSL method for declaring child associations: `child`.
+* New DSL method for declaring parent associations: `parent`.
+* Added global inflection using Dry::Inflector, can be overridden using Dbee.inflector = Dry::Inflector.new # or some other instance.
+
+### Breaking changes:
+
+Inflection was introduced with this release and hence changes some of the default naming inference behavior:
+
+* Table name is now inferred to be the pluralized and de-modulized class name (unless explicitly declared.)
+* Top level root model name is inferred to be the underscored and de-modulized class name.
+* Model is now inferred to be the relative, singular, and camelized association name (unless explicitly declared.)
+
 # 1.2.1 (September 1st, 2019)
 
-Fixes:
+### Fixes:
 
 * Dbee::Base table name should default to the most-parent table name (if none are explicitly defined.)  Overriding still takes most child sub-class precedence.
 
 # 1.2.0 (August 29th, 2019)
 
-Additions:
+### Additions:
 
 * Added partitioners to a model specification.  A Partitioner is essentially a way of explicitly specifying that a data model must meet a specific equality for a column.
 
-Changes:
+### Changes:
 
 * Model#ancestors renamed to Model#ancestors!
 * Model#ancestor now returns a hash where the key is an array of strings and not just a pre-concatenated string.
 
 # 1.1.0 (August 28th, 2019)
 
-Additions:
+### Additions:
 
 * Added better equality and sort methods for Ruby objects (added class type checks where needed.)
 
-Changes:
+### Changes:
 
 * Removed Sorter in favor of Sorter subclasses.
 * Duplicate filters and sorters will be ignored in a Query.
 
 # 1.0.3 (August 27th, 2019)
 
-Additions:
+### Additions:
 
 * Added 'parent' keyword for static constraints.  This makes it possible to have a static constraint apply to a parent and not just a child relationship.
 
 # 1.0.2 (August 26th, 2019)
 
-Fixes:
+### 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:
+### 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:
+### Fixes:
 
 * Dbee::Base subclasses can now declare self-referential associations.  Note that it will stop the hierarchy once the cycle is detected.
 
-Additions:
+### Additions:
 
 * Static constraint is now the default type when type is omitted.
 

data/README.md

@@ -80,58 +80,116 @@ There are two ways to model this schema using Dbee:
 1. code-first
 2. configuration-first
 
-#### Code-First Data Modeling
+#### Code-First Data Modeling (With Inflection)
 
 Code-first data modeling involves creating sub-classes of Dbee::Base that describes the tables and associations.  We could model the above example as:
 
 ````ruby
 module ReadmeDataModels
-  class PhoneNumbers < Dbee::Base
+  class PhoneNumber < Dbee::Base
     table :phones
+
+    parent :patient
+  end
+
+  class Note < Dbee::Base
+    parent :patient
+  end
+
+  class Patient < Dbee::Base
+    child :notes
+
+    child :work_phone_number, model: 'ReadmeDataModels::PhoneNumber',
+                              static: { name: :phone_number_type, value: 'work' }
+
+    child :cell_phone_number, model: 'ReadmeDataModels::PhoneNumber',
+                              static: { name: :phone_number_type, value: 'cell' }
+
+    child :fax_phone_number,  model: 'ReadmeDataModels::PhoneNumber',
+                              static: { name: :phone_number_type, value: 'fax' }
+  end
+
+  class Practice < Dbee::Base
+    child :patients
+  end
+end
+````
+
+The two DSL methods: parent/child are very similar to ActiveRecord's belongs_to/has_many, respectively.  Options for these methods are:
+
+* **model**: class constant, string, or symbol to use as associated data model.  If omitted, the model name will be the relative, singular, and camelized version of the association name.
+* **foreign_key**: name of the key on the child table.  If omitted for child then it will resolve as singular, underscored, de-modulized class name suffixed with '\_id'.  If omitted for parent it will resolve to 'id'.
+* **primary_key**: name of the key on the parent table.  If omitted for child then it will resolve as 'id'.  If omitted for parent then it will resolve as the singular, underscored, de-modulized name of the relationship suffixed with '\_id'
+
+##### Customizing Inflection Rules
+
+Inflection is provided via the (Dry::Inflector gem)[https://github.com/dry-rb/dry-inflector].  There are options to add custom grammar rules which you can then pass into Dbee.  For example:
+
+````ruby
+Dbee.inflector = Dry::Inflector.new do |inflections|
+  inflections.plural      'virus',   'viruses' # specify a rule for #pluralize
+  inflections.singular    'thieves', 'thief'   # specify a rule for #singularize
+  inflections.uncountable 'dry-inflector'      # add an exception for an uncountable word
+end
+````
+
+#### Code-First Data Modeling (Without Inflection)
+
+You can use the raw `association` method you wish to fully control the entire referencing configuration.
+
+````ruby
+module ReadmeDataModels
+  class PhoneNumber < Dbee::Base
+    table :phones
+
+    association :patient, model: 'ReadmeDataModels::Patient', constraints: {
+      type: :reference, name: :patient_id, parent: :id
+    }
   end
 
-  class Notes < Dbee::Base
+  class Note < Dbee::Base
+    association :patient, model: 'ReadmeDataModels::Patient', constraints: {
+      type: :reference, name: :patient_id, parent: :id
+    }
   end
 
-  class Patients < Dbee::Base
-    association :notes, model: Notes, constraints: {
+  class Patient < Dbee::Base
+    association :notes, model: 'ReadmeDataModels::Note', constraints: {
       type: :reference, name: :patient_id, parent: :id
     }
 
-    association :work_phone_number, model: PhoneNumbers, constraints: [
+    association :work_phone_number, model: 'ReadmeDataModels::PhoneNumber', constraints: [
       { type: :reference, name: :patient_id, parent: :id },
       { type: :static, name: :phone_number_type, value: 'work' }
     ]
 
-    association :cell_phone_number, model: PhoneNumbers, constraints: [
+    association :cell_phone_number, model: 'ReadmeDataModels::PhoneNumber', constraints: [
       { type: :reference, name: :patient_id, parent: :id },
       { type: :static, name: :phone_number_type, value: 'cell' }
     ]
 
-    association :fax_phone_number, model: PhoneNumbers, constraints: [
+    association :fax_phone_number, model: 'ReadmeDataModels::PhoneNumber', constraints: [
       { type: :reference, name: :patient_id, parent: :id },
       { type: :static, name: :phone_number_type, value: 'fax' }
     ]
   end
 
-  class Practices < Dbee::Base
-    association :patients, model: Patients, constraints: {
+  class Practice < Dbee::Base
+    association :patients, model: Patient, constraints: {
       type: :reference, name: :practice_id, parent: :id
     }
   end
 end
-
 ````
 
-**Note:** the 'table' directive is optional, and if omitted, the classes name will be turned into snake_case and used.  In the above example you can see we wanted the class name of PhoneNumbers but the table is actually 'phones'
-
+The two code-first examples above should be technically equivalent.
 
 #### Configuration-First Data Modeling
 
 You can choose to alternatively describe your data model using configuration.  The YAML below is equivalent to the Ruby sub-classes above:
 
 ````yaml
-name: practices
+name: practice
 models:
   - name: patients
     constraints:
@@ -182,15 +240,14 @@ You can leverage the model partitioners for hard-coding partitioning by column=v
 ##### Code-first:
 
 ````ruby
-class Dogs < Dbee::Base
-  table 'animals'
+class Animal < Dbee::Base
+end
 
+class Dog < Animal
   partitioner :type, 'Dog'
 end
 
-class Cats < Dbee::Base
-  table 'animals'
-
+class Cat < Animal
   partitioner :type, 'Cat'
 end
 ````
@@ -199,14 +256,14 @@ end
 
 ````yaml
 Dogs:
-  name: dogs
+  name: dog
   table: animals
   partitioners:
     - name: type
       value: Dog
 
 Cats:
-  name: cats
+  name: cat
   table: animals
   partitioners:
     - name: type
@@ -309,10 +366,9 @@ Here are some sample executions based off the preceding examples:
 ##### Code-First Execution
 
 ````ruby
-require 'dbee'
 require 'dbee/providers/active_record_provider'
 
-class Practices < Dbee::Base; end
+class Practice < Dbee::Base; end
 
 provider = Dbee::Providers::ActiveRecordProvider.new
 
@@ -324,19 +380,18 @@ query = {
   ]
 }
 
-sql = Dbee.sql(Practices, query, provider)
+sql = Dbee.sql(Practice, query, provider)
 ````
 
 ##### Configuration-First Execution
 
 ````ruby
-require 'dbee'
 require 'dbee/providers/active_record_provider'
 
 provider = Dbee::Providers::ActiveRecordProvider.new
 
 model = {
-  name: :practices
+  name: :practice
 }
 
 query = {

data/dbee.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 2.4.6'
 
   s.add_dependency('acts_as_hashable', '~>1', '>=1.1.0')
+  s.add_dependency('dry-inflector', '~>0')
 
   s.add_development_dependency('guard-rspec', '~>4.7')
   s.add_development_dependency('pry', '~>0')

data/lib/dbee/base.rb

@@ -7,38 +7,28 @@
 # LICENSE file in the root directory of this source tree.
 #
 
-require_relative 'dsl/inflectable'
+require_relative 'dsl/association'
+require_relative 'dsl/association_builder'
+require_relative 'dsl/methods'
 require_relative 'dsl/reflectable'
 
 module Dbee
   # Instead of using the configuration-first approach, you could use this super class for
   # Model declaration.
   class Base
-    extend Dsl::Inflectable
     extend Dsl::Reflectable
+    extend Dsl::Methods
 
     BASE_CLASS_CONSTANT = Dbee::Base
 
     class << self
-      def partitioner(name, value)
-        partitioners << { name: name, value: value }
-      end
-
-      def table(name)
-        tap { @table_name = name.to_s }
-      end
-
-      def association(name, opts = {})
-        tap { associations_by_name[name.to_s] = opts.merge(name: name) }
-      end
-
       # 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  = name.to_s.empty? ? tableize(self.name) : name.to_s
+        derived_name  = name.to_s.empty? ? inflected_class_name(self.name) : name.to_s
         key           = [key_chain, derived_name, constraints, path_parts]
 
         to_models[key] ||= Model.make(
@@ -51,25 +41,9 @@ module Dbee
         )
       end
 
-      def table_name
-        @table_name || ''
-      end
-
-      def associations_by_name
-        @associations_by_name ||= {}
-      end
-
-      def partitioners
-        @partitioners ||= []
-      end
-
-      def table_name?
-        !table_name.empty?
-      end
-
       def inherited_table_name
         subclasses(BASE_CLASS_CONSTANT).find(&:table_name?)&.table_name ||
-          tableize(reversed_subclasses(BASE_CLASS_CONSTANT).first.name)
+          inflected_table_name(reversed_subclasses(BASE_CLASS_CONSTANT).first.name)
       end
 
       def inherited_associations
@@ -97,16 +71,14 @@ module Dbee
       end
 
       def associations(key_chain, path_parts)
-        inherited_associations.select { |c| key_chain.ancestor_path?(path_parts, c[:name]) }
-                              .each_with_object([]) do |config, memo|
-          model_constant          = constantize(config[:model])
-          associated_constraints  = config[:constraints]
-          name                    = config[:name]
+        inherited_associations.select { |c| key_chain.ancestor_path?(path_parts, c.name) }
+                              .map do |association|
+          model_constant = association.model_constant
 
-          memo << model_constant.to_model(
+          model_constant.to_model(
             key_chain,
-            name,
-            associated_constraints,
+            association.name,
+            association.constraints,
             path_parts
           )
         end
@@ -115,6 +87,14 @@ module Dbee
       def to_models
         @to_models ||= {}
       end
+
+      def inflected_table_name(name)
+        inflector.pluralize(inflector.underscore(inflector.demodulize(name)))
+      end
+
+      def inflected_class_name(name)
+        inflector.underscore(inflector.demodulize(name))
+      end
     end
   end
 end

data/lib/dbee/dsl/association.rb

@@ -0,0 +1,53 @@
+# 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 Dsl
+    # The main logic that can take input from model association declaration and turn it into
+    # usable information.
+    class Association
+      attr_reader :on_class_name, :inflector, :name, :opts
+
+      def initialize(on_class_name, inflector, name, opts = {})
+        raise ArgumentError, 'on_class_name is required'  if on_class_name.to_s.empty?
+        raise ArgumentError, 'inflector is required'      unless inflector
+        raise ArgumentError, 'name is required'           if name.to_s.empty?
+
+        @on_class_name  = on_class_name
+        @inflector      = inflector
+        @name           = name.to_s
+        @opts           = opts || {}
+
+        freeze
+      end
+
+      def model_constant
+        constantize(class_name)
+      end
+
+      def constraints
+        opts[:constraints] || []
+      end
+
+      private
+
+      def class_name
+        opts[:model] || relative_class_name
+      end
+
+      def relative_class_name
+        (on_class_name.split('::')[0...-1] + [inflector.classify(name)]).join('::')
+      end
+
+      def constantize(value)
+        value.is_a?(String) || value.is_a?(Symbol) ? Object.const_get(value) : value
+      end
+    end
+  end
+end

data/lib/dbee/dsl/association_builder.rb

@@ -0,0 +1,65 @@
+# 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 Dsl
+    # This is really syntactic sugar built on top of Association.  It can handle two main
+    # use-cases when declaring associations:
+    # - parent: create an association to a parent model (foreign key is on immediate table)
+    # - child: create an association to a child model (foreign key is on child table)
+    class AssociationBuilder
+      attr_reader :inflector
+
+      def initialize(inflector)
+        raise ArgumentError, 'inflector is required' unless inflector
+
+        @inflector = inflector
+
+        freeze
+      end
+
+      def parent_association(on_class_name, name, opts = {})
+        reference_constraint = {
+          name: opts[:foreign_key] || :id,
+          parent: opts[:primary_key] || inflector.foreign_key(name)
+        }
+
+        association(on_class_name, name, opts, reference_constraint)
+      end
+
+      def child_association(on_class_name, name, opts = {})
+        reference_constraint = {
+          name: opts[:foreign_key] || inflector.foreign_key(on_class_name),
+          parent: opts[:primary_key] || :id
+        }
+
+        association(on_class_name, name, opts, reference_constraint)
+      end
+
+      private
+
+      def association(on_class_name, name, opts, reference_constraint)
+        association_opts = {
+          model: opts[:model],
+          constraints: [reference_constraint] + make_constraints(opts)
+        }
+
+        Association.new(on_class_name, inflector, name, association_opts)
+      end
+
+      def make_constraints(opts = {})
+        array(opts[:constraints]) + array(opts[:static]).map { |c| c.merge(type: :static) }
+      end
+
+      def array(value)
+        value.is_a?(Hash) ? [value] : Array(value)
+      end
+    end
+  end
+end

data/lib/dbee/dsl/methods.rb

@@ -0,0 +1,74 @@
+# 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 Dsl
+    # This mixin contains all the reader/writers for model meta-data declared through the DSL.
+    module Methods
+      def partitioner(name, value)
+        partitioners << { name: name, value: value }
+      end
+
+      def table(name)
+        tap { @table_name = name.to_s }
+      end
+
+      def parent(name, opts = {})
+        association = association_builder.parent_association(self.name, name, opts)
+
+        association(name, association)
+      end
+
+      def child(name, opts = {})
+        association = association_builder.child_association(self.name, name, opts)
+
+        association(name, association)
+      end
+
+      def association(name, opts = {})
+        value =
+          if opts.is_a?(Dsl::Association)
+            opts
+          else
+            Dsl::Association.new(self.name, inflector, name, opts)
+          end
+
+        tap do
+          associations_by_name[name.to_s] = value
+        end
+      end
+
+      def table_name
+        @table_name || ''
+      end
+
+      def associations_by_name
+        @associations_by_name ||= {}
+      end
+
+      def partitioners
+        @partitioners ||= []
+      end
+
+      def table_name?
+        !table_name.empty?
+      end
+
+      private
+
+      def inflector
+        Dbee.inflector
+      end
+
+      def association_builder
+        @association_builder ||= Dsl::AssociationBuilder.new(inflector)
+      end
+    end
+  end
+end

data/lib/dbee/version.rb

@@ -8,5 +8,5 @@
 #
 
 module Dbee
-  VERSION = '1.2.1'
+  VERSION = '2.0.0-alpha'
 end

data/lib/dbee.rb

@@ -8,6 +8,7 @@
 #
 
 require 'acts_as_hashable'
+require 'dry/inflector'
 require 'forwardable'
 
 require_relative 'dbee/base'
@@ -20,6 +21,15 @@ require_relative 'dbee/providers'
 # Top-level namespace that provides the main public API.
 module Dbee
   class << self
+    # Use this to override the built in Dry::Inflector instance.
+    # This is useful is you have your own grammar/overrides you need to load.
+    # See the referenced gem here: https://github.com/dry-rb/dry-inflector
+    attr_writer :inflector
+
+    def inflector
+      @inflector ||= Dry::Inflector.new
+    end
+
     def sql(model, query, provider)
       query = Query.make(query)
       model =

data/spec/dbee/base_spec.rb

@@ -33,7 +33,7 @@ describe Dbee::Base do
 
       key_chain = Dbee::KeyChain.new(key_paths)
 
-      actual_model = Models::Theaters.to_model(key_chain)
+      actual_model = Models::Theater.to_model(key_chain)
 
       expect(actual_model).to eq(expected_model)
     end
@@ -82,7 +82,7 @@ describe Dbee::Base do
       key_paths = %w[id]
       key_chain = Dbee::KeyChain.new(key_paths)
 
-      actual_model = PartitionerExamples::Dogs.to_model(key_chain)
+      actual_model = PartitionerExamples::Dog.to_model(key_chain)
 
       expect(actual_model).to eq(expected_model)
     end
@@ -95,7 +95,7 @@ describe Dbee::Base do
       key_paths = %w[id dogs.id]
       key_chain = Dbee::KeyChain.new(key_paths)
 
-      actual_model = PartitionerExamples::Owners.to_model(key_chain)
+      actual_model = PartitionerExamples::Owner.to_model(key_chain)
 
       expect(actual_model).to eq(expected_model)
     end

data/spec/dbee/model_spec.rb

@@ -123,7 +123,7 @@ describe Dbee::Model do
                                        patients.fax_phone_number.e
                                      ])
 
-      code_model = ReadmeDataModels::Practices.to_model(key_chain)
+      code_model = ReadmeDataModels::Practice.to_model(key_chain)
 
       expect(config_model).to eq(code_model)
     end

data/spec/dbee_spec.rb

@@ -45,7 +45,7 @@ describe Dbee do
     end
 
     it 'accepts a Dbee::Base constant as a model and passes a Model instance to provider#sql' do
-      model_constant = Models::Theaters
+      model_constant = Models::Theater
 
       expect(provider).to receive(:sql).with(model_constant.to_model(query.key_chain), query)
 
@@ -53,7 +53,7 @@ describe Dbee do
     end
 
     it 'accepts a Dbee::Query instance as a query and passes a Query instance to provider#sql' do
-      model = Models::Theaters.to_model(query.key_chain)
+      model = Models::Theater.to_model(query.key_chain)
 
       expect(provider).to receive(:sql).with(model, query)
 
@@ -61,7 +61,7 @@ describe Dbee do
     end
 
     it 'accepts a hash as a query and passes a Query instance to provider#sql' do
-      model = Models::Theaters.to_model(query.key_chain)
+      model = Models::Theater.to_model(query.key_chain)
 
       expect(provider).to receive(:sql).with(model, query)
 

data/spec/fixtures/models.rb

@@ -8,60 +8,44 @@
 #
 
 module Models
-  class Movies < Dbee::Base
-  end
+  class Movie < Dbee::Base; end
 
-  class PhoneNumbers < Dbee::Base
-  end
+  class PhoneNumber < Dbee::Base; end
 
-  class Demographics < Dbee::Base
-    association :phone_numbers, model: 'Models::PhoneNumbers',
-                                constraints: {
-                                  name: :demographic_id,
-                                  parent: :id
-                                }
+  class Demographic < Dbee::Base
+    child :phone_numbers
   end
 
-  class MembersBase < Dbee::Base
-    table 'members'
+  class MemberBase < Dbee::Base
+    child :demos, model: 'Models::Demographic', foreign_key: :member_id
 
-    association :demos, model: Demographics,
-                        constraints: { type: :reference, name: :member_id, parent: :id }
-
-    association :movies, model: Movies,
-                         constraints: { name: :member_id, parent: :id }
+    child :movies, foreign_key: :member_id
   end
 
-  class Members < MembersBase
-    association :favorite_comic_movies, model: Movies, constraints: [
-      { type: :reference, name: :member_id, parent: :id },
-      { type: :static, name: :genre, value: 'comic' }
-    ]
+  class Member < MemberBase
+    table 'members'
+
+    child :favorite_comic_movies, model: Movie, static: { name: :genre, value: 'comic' }
 
-    association :favorite_mystery_movies, model: Movies, constraints: [
-      { type: :reference, name: :member_id, parent: :id },
+    child :favorite_mystery_movies, model: Movie, constraints: [
       { type: :static, name: :genre, value: 'mystery' }
     ]
 
-    association :favorite_comedy_movies, model: Movies, constraints: [
-      { type: :reference, name: :member_id, parent: :id },
-      { type: :static, name: :genre, value: 'comedy' }
-    ]
+    child :favorite_comedy_movies, model: Movie, constraints: {
+      type: :static, name: :genre, value: 'comedy'
+    }
   end
 
-  class TheatersBase < Dbee::Base
-    association :members, model: Members, constraints: [
-      { type: :reference, name: :tid, parent: :id },
+  class TheaterBase < Dbee::Base
+    child :members, foreign_key: :tid, constraints: [
       { type: :reference, name: :partition, parent: :partition }
     ]
   end
 
-  class Theaters < TheatersBase
+  class Theater < TheaterBase
     table 'theaters'
 
-    association :parent_theater, model: self, constraints: [
-      { type: :reference, name: :id, parent: :parent_theater_id }
-    ]
+    parent :parent_theater, model: self
   end
 
   class A < Dbee::Base
@@ -72,8 +56,7 @@ module Models
     table 'table_set_to_b'
   end
 
-  class C < A
-  end
+  class C < A; end
 
   class D < A
     table ''
@@ -85,36 +68,30 @@ module Models
 end
 
 module ReadmeDataModels
-  class PhoneNumbers < Dbee::Base
+  class PhoneNumber < Dbee::Base
     table :phones
   end
 
-  class Notes < Dbee::Base
-  end
+  class Note < Dbee::Base; end
 
-  class Patients < Dbee::Base
-    association :notes, model: Notes, constraints: {
-      type: :reference, name: :patient_id, parent: :id
-    }
+  class Patient < Dbee::Base
+    child :notes
 
-    association :work_phone_number, model: PhoneNumbers, constraints: [
-      { type: :reference, name: :patient_id, parent: :id },
-      { type: :static, name: :phone_number_type, value: 'work' }
-    ]
+    child :work_phone_number, model: PhoneNumber, static: {
+      name: :phone_number_type, value: 'work'
+    }
 
-    association :cell_phone_number, model: PhoneNumbers, constraints: [
-      { type: :reference, name: :patient_id, parent: :id },
+    child :cell_phone_number, model: PhoneNumber, constraints: [
       { type: :static, name: :phone_number_type, value: 'cell' }
     ]
 
-    association :fax_phone_number, model: PhoneNumbers, constraints: [
-      { type: :reference, name: :patient_id, parent: :id },
+    child :fax_phone_number, model: PhoneNumber, constraints: [
       { type: :static, name: :phone_number_type, value: 'fax' }
     ]
   end
 
-  class Practices < Dbee::Base
-    association :patients, model: Patients, constraints: {
+  class Practice < Dbee::Base
+    association :patients, constraints: {
       type: :reference, name: :practice_id, parent: :id
     }
   end
@@ -126,36 +103,35 @@ module Cycles
   end
 
   class A < BaseA
+    table :as
+
     association :b2, model: 'Cycles::B'
   end
 
   class B < Dbee::Base
-    association :c, model: 'Cycles::C'
+    association :c
 
-    association :d, model: 'Cycles::D'
+    association :d
   end
 
   class C < Dbee::Base
-    association :a, model: 'Cycles::A'
+    association :a
   end
 
   class D < Dbee::Base
-    association :a, model: 'Cycles::A'
+    association :a
   end
 end
 
 # Examples of Rails Single Table Inheritance.
 module PartitionerExamples
-  class Owners < Dbee::Base
-    association :dogs, model: 'PartitionerExamples::Dogs', constraints: {
-      name: :owner_id, parent: :id
-    }
+  class Owner < Dbee::Base
+    child :dogs
   end
 
-  class Animals < Dbee::Base
-  end
+  class Animal < Dbee::Base; end
 
-  class Dogs < Animals
+  class Dog < Animal
     partitioner :type, 'Dog'
 
     partitioner :deleted, false

data/spec/fixtures/models.yaml

@@ -1,5 +1,5 @@
 Theaters, Members, and Movies:
-  name: theaters
+  name: theater
   table: theaters
   models:
     - name: members
@@ -120,7 +120,8 @@ Theaters, Members, and Movies:
                   name: genre
                   value: comedy
 Readme:
-  name: practices
+  name: practice
+  table: practices
   models:
     - name: patients
       constraints:
@@ -162,38 +163,43 @@ Readme:
               value: fax
 Cycle Example:
   name: a
-  table: base_a
+  table: as
   models:
     - name: b1
-      table: b
+      table: bs
       models:
         - name: c
+          table: cs
           models:
             - name: a
-              table: base_a
+              table: as
         - name: d
+          table: ds
           models:
             - name: a
-              table: base_a
+              table: as
     - name: b2
-      table: b
+      table: bs
       models:
         - name: c
+          table: cs
           models:
             - name: a
-              table: base_a
+              table: as
         - name: d
+          table: ds
           models:
             - name: a
-              table: base_a
+              table: as
               models:
                 - name: b1
-                  table: b
+                  table: bs
                   models:
                     - name: c
+                      table: cs
 
 Partitioner Example 1:
-  name: dogs
+  name: dog
   table: animals
   partitioners:
     - name: type
@@ -202,7 +208,8 @@ Partitioner Example 1:
       value: false
 
 Partitioner Example 2:
-  name: owners
+  name: owner
+  table: owners
   models:
     - name: dogs
       table: animals

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dbee
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 2.0.0.pre.alpha
 platform: ruby
 authors:
 - Matthew Ruggio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-02 00:00:00.000000000 Z
+date: 2019-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: acts_as_hashable
@@ -30,6 +30,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -155,7 +169,9 @@ files:
 - dbee.gemspec
 - lib/dbee.rb
 - lib/dbee/base.rb
-- lib/dbee/dsl/inflectable.rb
+- lib/dbee/dsl/association.rb
+- lib/dbee/dsl/association_builder.rb
+- lib/dbee/dsl/methods.rb
 - lib/dbee/dsl/reflectable.rb
 - lib/dbee/key_chain.rb
 - lib/dbee/key_path.rb
@@ -221,9 +237,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.4.6
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
 signing_key: 

data/lib/dbee/dsl/inflectable.rb

@@ -1,28 +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
-  module Dsl
-    # Provides methods for dealing with naming grammar.
-    module Inflectable
-      def constantize(value)
-        value.is_a?(String) || value.is_a?(Symbol) ? Object.const_get(value) : value
-      end
-
-      def tableize(value)
-        value.split('::')
-             .last
-             .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-             .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-             .tr('-', '_')
-             .downcase
-      end
-    end
-  end
-end