dbee 2.0.2 → 3.0.0

data/dbee.gemspec

@@ -15,20 +15,31 @@ Gem::Specification.new do |s|
   s.email       = ['mruggio@bluemarblepayroll.com']
   s.files       = `git ls-files`.split("\n")
   s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.bindir      = 'exe'
+  s.executables = []
   s.homepage    = 'https://github.com/bluemarblepayroll/dbee'
   s.license     = 'MIT'
+  s.metadata    = {
+    'bug_tracker_uri' => 'https://github.com/bluemarblepayroll/dbee/issues',
+    'changelog_uri' => 'https://github.com/bluemarblepayroll/dbee/blob/master/CHANGELOG.md',
+    'documentation_uri' => 'https://www.rubydoc.info/gems/dbee',
+    'homepage_uri' => s.homepage,
+    'source_code_uri' => s.homepage
+  }
 
-  s.required_ruby_version = '>= 2.3.8'
+  s.required_ruby_version = '>= 2.5'
 
-  s.add_dependency('acts_as_hashable', '~>1', '>=1.1.0')
+  s.add_dependency('acts_as_hashable', '~>1', '>=1.2.0')
   s.add_dependency('dry-inflector', '~>0')
 
   s.add_development_dependency('guard-rspec', '~>4.7')
   s.add_development_dependency('pry', '~>0')
+  s.add_development_dependency('pry-byebug')
   s.add_development_dependency('rake', '~> 13')
   s.add_development_dependency('rspec')
-  s.add_development_dependency('rubocop', '~>0.76.0')
-  s.add_development_dependency('simplecov', '~>0.17.0')
-  s.add_development_dependency('simplecov-console', '~>0.5.0')
+  s.add_development_dependency('rubocop', '~> 1')
+  s.add_development_dependency('rubocop-rake')
+  s.add_development_dependency('rubocop-rspec')
+  s.add_development_dependency('simplecov', '~>0.19.0')
+  s.add_development_dependency('simplecov-console', '~>0.7.0')
 end

data/lib/dbee.rb

@@ -12,11 +12,16 @@ require 'dry/inflector'
 require 'forwardable'
 
 require_relative 'dbee/base'
+require_relative 'dbee/constant_resolver'
+require_relative 'dbee/dsl_schema_builder'
 require_relative 'dbee/key_chain'
 require_relative 'dbee/key_path'
 require_relative 'dbee/model'
-require_relative 'dbee/query'
 require_relative 'dbee/providers'
+require_relative 'dbee/query'
+require_relative 'dbee/schema'
+require_relative 'dbee/schema_creator'
+require_relative 'dbee/schema_from_tree_based_model'
 
 # Top-level namespace that provides the main public API.
 module Dbee
@@ -30,16 +35,11 @@ module Dbee
       @inflector ||= Dry::Inflector.new
     end
 
-    def sql(model, query, provider)
-      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
+    def sql(schema_or_model, query_input, provider)
+      raise ArgumentError, 'a provider is required' unless provider
 
-      provider.sql(model, query)
+      schema_compat = SchemaCreator.new(schema_or_model, query_input)
+      provider.sql(schema_compat.schema, schema_compat.query)
     end
   end
 end

data/lib/dbee/base.rb

@@ -7,8 +7,8 @@
 # LICENSE file in the root directory of this source tree.
 #
 
-require_relative 'dsl/association'
 require_relative 'dsl/association_builder'
+require_relative 'dsl/association'
 require_relative 'dsl/methods'
 require_relative 'dsl/reflectable'
 
@@ -22,23 +22,9 @@ module Dbee
     BASE_CLASS_CONSTANT = Dbee::Base
 
     class << self
-      # 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? ? inflected_class_name(self.name) : name.to_s
-        key           = [key_chain, derived_name, constraints, path_parts]
-
-        to_models[key] ||= Model.make(
-          model_config(
-            key_chain,
-            derived_name,
-            constraints,
-            path_parts + [name]
-          )
-        )
+      # Returns the smallest needed Dbee::Schema for the provided key_chain.
+      def to_schema(key_chain)
+        DslSchemaBuilder.new(self, key_chain).to_schema
       end
 
       def inherited_table_name
@@ -58,43 +44,15 @@ module Dbee
         end
       end
 
-      private
-
-      def model_config(key_chain, name, constraints, path_parts)
-        {
-          constraints: constraints,
-          models: associations(key_chain, path_parts),
-          name: name,
-          partitioners: inherited_partitioners,
-          table: inherited_table_name
-        }
-      end
-
-      def associations(key_chain, path_parts)
-        inherited_associations.select { |c| key_chain.ancestor_path?(path_parts, c.name) }
-                              .map do |association|
-          model_constant = association.model_constant
-
-          model_constant.to_model(
-            key_chain,
-            association.name,
-            association.constraints,
-            path_parts
-          )
-        end
+      def inflected_class_name
+        inflector.underscore(inflector.demodulize(name))
       end
 
-      def to_models
-        @to_models ||= {}
-      end
+      private
 
       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/constant_resolver.rb

@@ -0,0 +1,34 @@
+# 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 is responsible for turning strings and symbols into constants.
+  # It does not deal with inflection, simply just constant resolution.
+  class ConstantResolver
+    # Only use Module constant resolution if a string or symbol was passed in.
+    # Any other type is defined as an acceptable constant and is simply returned.
+    def constantize(value)
+      value.is_a?(String) || value.is_a?(Symbol) ? object_constant(value) : value
+    end
+
+    private
+
+    # If the constant has been loaded, we can safely use it through const_get.
+    # If the constant has not been loaded, we need to defer to const_missing to resolve it.
+    # If we blindly call const_get, it may return false positives for namespaced constants
+    # or anything nested.
+    def object_constant(value)
+      if Object.const_defined?(value, false)
+        Object.const_get(value, false)
+      else
+        Object.const_missing(value)
+      end
+    end
+  end
+end

data/lib/dbee/dsl/association.rb

@@ -19,16 +19,17 @@ module Dbee
         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 || {}
+        @on_class_name     = on_class_name
+        @inflector         = inflector
+        @name              = name.to_s
+        @opts              = opts || {}
+        @constant_resolver = ConstantResolver.new
 
         freeze
       end
 
       def model_constant
-        constantize(class_name)
+        constant_resolver.constantize(class_name)
       end
 
       def constraints
@@ -37,6 +38,8 @@ module Dbee
 
       private
 
+      attr_reader :constant_resolver
+
       def class_name
         opts[:model] || relative_class_name
       end
@@ -47,20 +50,6 @@ module Dbee
       def relative_class_name
         (on_class_name.split('::')[0...-1] + [inflector.classify(name)]).join('::')
       end
-
-      # Only use Module constant resolution if a string or symbol was passed in.
-      # Any other type is defined as an acceptable constant and is simply returned.
-      def constantize(value)
-        value.is_a?(String) || value.is_a?(Symbol) ? object_constant(value) : value
-      end
-
-      # If the constant has been loaded, we can safely use it through const_get.
-      # If the constant has not been loaded, we need to defer to const_missing to resolve it.
-      # If we blindly call const_get, it may return false positives for namespaced constants
-      # or anything nested.
-      def object_constant(value)
-        Object.const_defined?(value) ? Object.const_get(value) : Object.const_missing(value)
-      end
     end
   end
 end

data/lib/dbee/dsl_schema_builder.rb

@@ -0,0 +1,86 @@
+# 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
+  # Builds a Dbee::Schema given a Dbee::Base (DSL) model. Note that this class
+  # does not exist in the "Dsl" module as it is not used for defining the DSL
+  # itself.
+  class DslSchemaBuilder # :nodoc:
+    attr_reader :dsl_model, :key_chain
+
+    def initialize(dsl_model, key_chain)
+      @dsl_model = dsl_model || ArgumentError('dsl_model is required')
+      @key_chain = key_chain || ArgumentError('key_chain is required')
+
+      freeze
+    end
+
+    def to_schema
+      schema_spec = { dsl_model.inflected_class_name => model_config(dsl_model) }
+
+      ancestor_paths(key_chain).each do |key_path|
+        start_model = dsl_model
+
+        key_path.ancestor_names.each do |association_name|
+          start_model = append_model_and_relationship(schema_spec, start_model, association_name)
+        end
+      end
+
+      Schema.new(schema_spec)
+    end
+
+    private
+
+    def model_config(dsl_model) #:nodoc:
+      {
+        name: dsl_model.inflected_class_name,
+        partitioners: dsl_model.inherited_partitioners,
+        table: dsl_model.inherited_table_name,
+        relationships: {}
+      }
+    end
+
+    def append_model_and_relationship(schema_spec, base_model, association_name)
+      association = find_association!(base_model, association_name)
+      target_model = association.model_constant
+
+      schema_spec[target_model.inflected_class_name] ||= model_config(target_model)
+
+      schema_spec[base_model.inflected_class_name][:relationships][association.name] = {
+        constraints: association.constraints,
+        model: relationship_model_name(association, target_model)
+      }
+
+      target_model
+    end
+
+    # Returns a unique list of ancestor paths from a key_chain. Omits any
+    # fields on the base model.
+    def ancestor_paths(key_chain)
+      key_chain.to_unique_ancestors.key_path_set.select do |key_path|
+        key_path.ancestor_names.any?
+      end
+    end
+
+    def find_association!(base_model, association_name)
+      base_model.inherited_associations.find { |assoc| assoc.name == association_name } \
+        ||
+        raise(
+          ArgumentError,
+          "no association #{association_name} exists on model #{base_model.name}"
+        )
+    end
+
+    def relationship_model_name(association, target_model)
+      return nil if association.name == target_model.inflected_class_name
+
+      target_model.inflected_class_name
+    end
+  end
+end

data/lib/dbee/key_chain.rb

@@ -38,5 +38,16 @@ module Dbee
 
       ancestor_path_set.include?(path)
     end
+
+    # Returns a unique set of ancestors by considering all column names to be the same.
+    def to_unique_ancestors # :nodoc:
+      normalized_paths = key_path_set.map do |kp|
+        KeyPath.new((kp.ancestor_names + COLUMN_PLACEHOLDER).join(KeyPath::SPLIT_CHAR))
+      end
+      self.class.new(normalized_paths.uniq)
+    end
+
+    COLUMN_PLACEHOLDER = ['any_column'].freeze
+    private_constant :COLUMN_PLACEHOLDER
   end
 end

data/lib/dbee/model.rb

@@ -9,65 +9,53 @@
 
 require_relative 'model/constraints'
 require_relative 'model/partitioner'
+require_relative 'model/relationships'
+require_relative 'util/make_keyed_by'
 
 module Dbee
   # In DB terms, a Model is usually a table, but it does not have to be.  You can also re-model
   # your DB schema using Dbee::Models.
   class Model
-    extend Forwardable
     acts_as_hashable
+    extend Dbee::Util::MakeKeyedBy
+    extend Forwardable
 
     class ModelNotFoundError < StandardError; end
 
-    attr_reader :constraints, :filters, :name, :partitioners, :table
+    attr_reader :constraints, :filters, :name, :partitioners, :relationships, :table
 
     def_delegator :models_by_name,  :values,  :models
     def_delegator :models,          :sort,    :sorted_models
     def_delegator :constraints,     :sort,    :sorted_constraints
     def_delegator :partitioners,    :sort,    :sorted_partitioners
 
-    def initialize(name:, constraints: [], models: [], partitioners: [], table: '')
-      raise ArgumentError, 'name is required' if name.to_s.empty?
-
-      @name           = name.to_s
-      @constraints    = Constraints.array(constraints).uniq
+    def initialize(
+      name:,
+      constraints: [], # Exists here for tree based model backward compatibility.
+      relationships: [],
+      models: [],      # Exists here for tree based model backward compatibility.
+      partitioners: [],
+      table: ''
+    )
+      @name           = name
+      @constraints    = Constraints.array(constraints || []).uniq
+      @relationships  = Relationships.make_keyed_by(:name, relationships)
       @models_by_name = name_hash(Model.array(models))
       @partitioners   = Partitioner.array(partitioners).uniq
       @table          = table.to_s.empty? ? @name : table.to_s
 
+      ensure_input_is_valid
+
       freeze
     end
 
-    # This recursive method will walk a path of model names (parts) and return back a
-    # flattened hash instead of a nested object structure.
-    # The hash key will be an array of strings (model names) and the value will be the
-    # identified model.
-    def ancestors!(parts = [], visited_parts = [], found = {})
-      return found if Array(parts).empty?
-
-      # Take the first entry in parts
-      model_name = parts.first.to_s
-
-      # Ensure we have it registered as a child, or raise error
-      model = assert_model(model_name, visited_parts)
-
-      # Push onto visited list
-      visited_parts += [model_name]
-
-      # Add found model to flattened structure
-      found[visited_parts] = model
-
-      # Recursively call for next parts in the chain
-      model.ancestors!(parts[1..-1], visited_parts, found)
+    def relationship_for_name(relationship_name)
+      relationships[relationship_name]
     end
 
     def ==(other)
       other.instance_of?(self.class) &&
-        other.name == name &&
-        other.table == table &&
-        other.sorted_constraints == sorted_constraints &&
-        other.sorted_partitioners == sorted_partitioners &&
-        other.sorted_models == sorted_models
+        other.name == name && other.table == table && children_are_equal(other)
     end
     alias eql? ==
 
@@ -75,17 +63,41 @@ module Dbee
       name <=> other.name
     end
 
+    def hash
+      [
+        name.hash,
+        table.hash,
+        relationships.hash,
+        sorted_constraints.hash,
+        sorted_partitioners.hash,
+        sorted_models.hash
+      ].hash
+    end
+
+    def to_s
+      name
+    end
+
     private
 
     attr_reader :models_by_name
 
-    def assert_model(model_name, visited_parts)
-      models_by_name[model_name] ||
-        raise(ModelNotFoundError, "Missing: #{model_name}, after: #{visited_parts}")
-    end
-
     def name_hash(array)
       array.map { |a| [a.name, a] }.to_h
     end
+
+    def children_are_equal(other)
+      other.relationships == relationships &&
+        other.sorted_constraints == sorted_constraints &&
+        other.sorted_partitioners == sorted_partitioners &&
+        other.sorted_models == sorted_models
+    end
+
+    def ensure_input_is_valid
+      raise ArgumentError, 'name is required' if name.to_s.empty?
+
+      constraints&.any? && relationships&.any? && \
+        raise(ArgumentError, 'constraints and relationships are mutually exclusive')
+    end
   end
 end