active_record-framing 0.1.0.pre.9 → 0.1.0.pre.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c45ff57cff6a36c65d09cc5c6e33a8d394c0f35eb6097f64213e458d41d4509
-  data.tar.gz: 8bd322afcc0c2406367c43354baa15f60291063fce86a91c8bb24dfaeaefd5f2
+  metadata.gz: 3470c754f26d19c299b29aed737299fc49be9e8b32ae738b241bf4f857f15aae
+  data.tar.gz: 347bc600be62caca146be5062c6244d3d91c6425d12576b6dab0908d7f5e6716
 SHA512:
-  metadata.gz: ebfb3761c9c471e80b2b7e77d235f1b74c85dcbb185f470da6f6f8732489802ababfb31ee039680781afdfd5d353d7417e8e0e62e2408bc1010044a1c540cfeb
-  data.tar.gz: faba924aef8072dc5c98a7bfc6e67decbadab3bc7eaa75b162c9de4a4410716bb89513124c0a27df1d8dc0a55c88507aa3883b5c01207330d4528bf818f55e56
+  metadata.gz: 59105768fd8a95a7dc826ca0a8708f05fac62e060a4556703ea6721b4ed8b4dbde6273faafa5e808757499c35f8dcd2825a745e29a768612c408a3bc3760374c
+  data.tar.gz: db85b4f5bc35430dfa888402ad5e3a3973efa8f36a2182f3b1781a5f8efa772febb2ea10a26c820c97be477ad4318532f74ede6459c76ad50f2656543b93df55

data/lib/active_record/framing/compat.rb

@@ -0,0 +1,14 @@
+require 'active_record/framing/compat/arel'
+
+case ::ActiveRecord.version
+when Gem::Requirement.new('~> 4.2') # 4.2.x
+  require 'active_record/framing/compat/active_record_4_2'
+when Gem::Requirement.new('~> 5.0.0') # 5.0.x
+  require 'active_record/framing/compat/active_record_5_0'
+when Gem::Requirement.new('~> 5.0') # 5.1+
+  require 'active_record/framing/compat/active_record_5_1'
+when Gem::Requirement.new('~> 6.0.0') # 6.0.x
+  require 'active_record/framing/compat/active_record_6_0'
+else
+  raise NotImplementedError, "ActiveRecord::Framing does not support Rails #{::ActiveRecord.version}" unless ENV['EDGE_TESTING']
+end

data/lib/active_record/framing/compat/active_record_4_2.rb

@@ -1,13 +1,19 @@
-{
-  frames: {},
-  reframe: {}
-}.each do |value_name, default_value|
-  define_method("#{value_name}_values") do
-    @values[value_name] || default_value
-  end
-  define_method("#{value_name}_values=") do |values|
-    raise ImmutableRelation if @loaded
-    check_cached_relation
-    @values[value_name] = values
+module ActiveRecord
+  module Framing
+    module QueryMethods
+      {
+        frames: {},
+        reframe: {}
+      }.each do |value_name, default_value|
+        define_method("#{value_name}_values") do
+          @values[value_name] || default_value
+        end
+        define_method("#{value_name}_values=") do |values|
+          raise ImmutableRelation if @loaded
+          check_cached_relation
+          @values[value_name] = values
+        end
+      end
+    end
   end
 end

data/lib/active_record/framing/compat/active_record_5_0.rb

@@ -1,12 +1,19 @@
-{
-  frames: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH,
-  reframe: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH
-}.each do |value_name, default_value|
-  define_method("#{value_name}_values") do
-    @values[value_name] || default_value
-  end
-  define_method("#{value_name}_values=") do |values|
-    assert_mutability!
-    @values[value_name] = values
+module ActiveRecord
+  module Framing
+    module QueryMethods
+      {
+        frames: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH,
+        reframe: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH
+      }.each do |value_name, default_value|
+        define_method("#{value_name}_values") do
+          @values[value_name] || default_value
+        end
+        define_method("#{value_name}_values=") do |values|
+          assert_mutability!
+          @values[value_name] = values
+        end
+      end
+    end
   end
 end
+

data/lib/active_record/framing/compat/active_record_5_1.rb

@@ -1,12 +1,18 @@
-{
-  frames: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH,
-  reframe: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH
-}.each do |value_name, default_value|
-  define_method("#{value_name}_values") do
-    get_value(value_name)
+module ActiveRecord
+  module Framing
+    module QueryMethods
+      {
+        frames: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH,
+        reframe: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH
+      }.each do |value_name, default_value|
+        define_method("#{value_name}_values") do
+          get_value(value_name)
+        end
+        define_method("#{value_name}_values=") do |value|
+          set_value(value_name, value)
+        end
+        ::ActiveRecord::QueryMethods::DEFAULT_VALUES[value_name] = default_value
+      end
+    end
   end
-  define_method("#{value_name}_values=") do |value|
-    set_value(value_name, value)
-  end
-  ::ActiveRecord::QueryMethods::DEFAULT_VALUES[value_name] = default_value
 end

data/lib/active_record/framing/compat/active_record_6_0.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Framing
+    module QueryMethods
+      {
+        frames: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH,
+        reframe: ::ActiveRecord::QueryMethods::FROZEN_EMPTY_HASH
+      }.each do |value_name, default_value|
+        ::ActiveRecord::QueryMethods::DEFAULT_VALUES[value_name] = default_value
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{value_name}_values                                                 # def frames_values
+            default = ::ActiveRecord::QueryMethods::DEFAULT_VALUES[:#{value_name}] #   default = DEFAULT_VALUES[:frames]
+            @values.fetch(:#{value_name}, default)                                 #   @values.fetch(:frames, default)
+          end                                                                      # end
+
+          def #{value_name}_values=(value)     # def frames_values=(value)
+            assert_mutability!                 #   assert_mutability!
+            @values[:#{value_name}] = value    #   @values[:frames] = value
+          end                                  # end
+        CODE
+      end
+    end
+  end
+end

data/lib/active_record/framing/compat/arel.rb

@@ -0,0 +1,24 @@
+case Gem::Version.new(Arel::VERSION)
+when Gem::Requirement.new('>= 7.0')
+  Arel::Table.class_eval do
+    def engine
+      type_caster.send(:types)
+    end
+
+    def engine=(value)
+      @type_caster = value.type_caster
+    end
+  end
+
+  Arel::Nodes::TableAlias.class_eval do
+    def engine
+      left.send(:type_caster)
+    end
+  end
+else
+  Arel::Table.class_eval do
+    def engine=(value)
+      @engine = value
+    end
+  end
+end

data/lib/active_record/framing/core_extension.rb

@@ -10,6 +10,8 @@ module ActiveRecord
     def self.prepended(subclass)
       subclass.singleton_class.class_eval do
         alias_method :unframed_all, :all
+        # NOTE: not for 4.2
+        alias_method :unframed_scope_for_association, :scope_for_association if subclass.respond_to?(:scope_for_association)
 
         # Subclasses need to be able to call its parent's
         protected :relation
@@ -32,6 +34,13 @@ module ActiveRecord
       @disabled == true
     end
 
+    class Foo
+
+      def self.whatever
+        @whatever
+      end
+    end
+
     module ClassMethods # :nodoc:
       def current_frame
         FrameRegistry.value_for(:current_frame, self)
@@ -40,6 +49,16 @@ module ActiveRecord
       def current_frame=(frame)
         FrameRegistry.set_value_for(:current_frame, self, frame)
       end
+
+      def const_missing(const_name)
+        case const_name
+        when *frames.keys
+          columns
+          frames[const_name].call
+        else
+          super
+        end
+      end
     end
 
     # This class stores the +:current_frame+ and +:ignore_default_frame+ values

data/lib/active_record/framing/default.rb

@@ -49,7 +49,7 @@ module ActiveRecord
         # The ignore_default_frame flag is used to prevent an infinite recursion
         # situation where a default frame references a frame which has a default
         # frame which references a frame...
-        def ignore_default_frame
+        def evaluate_default_frame
           return if ignore_default_frame?
           self.ignore_default_frame = true
           yield
@@ -57,6 +57,13 @@ module ActiveRecord
           self.ignore_default_frame = false
         end
 
+        def default_arel_table
+          @default_arel_table ||= arel_table.dup.tap do |at|
+            at.name = sovereign_table_name
+          end
+          # @default_arel_table ||= arel_table.alias(sovereign_table_name)
+        end
+
       protected
 
         def build_frame(frames, arel_table, base_rel = nil, &block)
@@ -68,6 +75,7 @@ module ActiveRecord
           end
 
           relation.frame!(Arel::Nodes::As.new(arel_table, cte_relation.arel)).tap do |rel|
+            rel.table = arel_table
             extension = Module.new(&block) if block_given?
             rel.extending!(extension) if extension
           end
@@ -120,7 +128,7 @@ module ActiveRecord
         #       # Should return a frame, you can call 'super' here etc.
         #     end
         #   end
-        def default_frame(frame = nil) # :doc:
+        def default_frame(frame_name = nil, frame: nil) # :doc:
           frame = Proc.new if block_given?
 
           if frame.is_a?(Relation) || !frame.respond_to?(:call)
@@ -131,9 +139,31 @@ module ActiveRecord
               "self.default_frame.)"
           end
 
+          # TODO: Include default_scopes?
+          # frame(:unframed)
+
+          # default_arel_table.tap do |at|
+          #   at.name = frame_name
+          # end if frame_name
+
           self.default_frames += [frame]
         end
 
+        def sovereign_table_name
+          # TODO: Use compute_table_name to disambiguate between users and admins
+          if superclass < ::ActiveRecord::Base && table_name == superclass.table_name
+            begin
+              orig, superclass.abstract_class = superclass.abstract_class, true
+              # return compute_table_name
+              return table_name
+            ensure
+              superclass.abstract_class = orig
+            end
+          end
+          # compute_table_name
+          table_name
+        end
+
         def build_default_frame(base_rel = nil)
           return if abstract_class?
 
@@ -143,14 +173,15 @@ module ActiveRecord
 
           if default_frame_override
             # The user has defined their own default frame method, so call that
-            ignore_default_frame do
+            evaluate_default_frame do
               if (frame = default_frame)
                 (base_rel ||= relation).frame!(frame)
               end
             end
           elsif default_frames.any?
-            ignore_default_frame do
-              cte_table = Arel::Table.new(table_name)
+            evaluate_default_frame do
+              # cte_table = Arel::Table.new(table_name)
+              cte_table = default_arel_table
               build_frame(default_frames, cte_table, base_rel || relation)
             end
           end

data/lib/active_record/framing/join_dependency.rb

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module Framing
+    module JoinDependency
+      def table_aliases_for(parent, node)
+        super.tap do |list|
+          list.zip(node.reflection.chain).each do |aliaz, reflection|
+            engine = @join_root.base_klass.reframe_values.fetch(reflection.name) { reflection }.klass
+            fix_table_engine(aliaz, engine)
+          end
+        end
+      end
+
+      def fix_table_engine(table, engine)
+        case table
+        when ::Arel::Nodes::TableAlias
+          table.left.engine = engine # if table.left.engine == ::ActiveRecord::Base
+          table.left.name = engine.table_name
+        else
+          table.engine = engine # if table.engine == ::ActiveRecord::Base
+          table.name = engine.table_name
+        end
+        # binding.pry if table.name == "users"
+      end
+    end
+  end
+end

data/lib/active_record/framing/model_proxy.rb

@@ -0,0 +1,53 @@
+module ActiveRecord
+  module Framing
+    class ModelProxy < SimpleDelegator
+
+      def initialize(klass, table)
+        @table = table
+        super(klass)
+      end
+
+      def unscoped
+        __getobj__.unscoped.tap do |rel|
+          rel.instance_variable_set(:@table, @table)
+        end
+      end
+
+      # NOTE: Arel 8.x / Rails 5.1 compatibility
+      # Method exists on AR::Model, but default value for table
+      # is scoped incorrectly without this proxy override
+      def arel_attribute(column_name, table = arel_table)
+        super
+      end
+
+      def table=(value)
+        @table = value
+      end
+
+      def table_name
+        @table.name
+      end
+
+      def reframe_values
+        @reframe_values ||= {}
+      end
+
+      def reframe_values=(value)
+        @reframe_values = value
+      end
+
+      def send(*args)
+        __getobj__.send(*args)
+      end
+
+      def arel_table
+        @table
+      end
+
+      # Might not need this
+      def is_a?(obj)
+        __getobj__.is_a?(obj)
+      end
+    end
+  end
+end

data/lib/active_record/framing/named.rb

@@ -18,23 +18,34 @@ module ActiveRecord
       # You can define a frame that applies to all finders using
       # {default_frame}[rdoc-ref:Framing::Default::ClassMethods#default_frame].
       def all
-        if (current_frame = self.current_frame)
-          if self == current_frame.klass
-            current_frame.clone
-          else
-            unframed_all.merge!(current_frame)
-          end
-        else
-          # default_framed.merge!(unframed_all)
-          unframed_all.merge!(default_framed)
-        end
+        unframed_all.merge(current_frame || default_framed)
+      end
+
+      # def all
+      #   current_frame = self.current_frame
+
+      #   if current_frame
+      #     if self == current_frame.klass
+      #       current_frame.clone
+      #     else
+      #       unframed_all.merge!(current_frame)
+      #     end
+      #   else
+      #     default_framed
+      #   end
+      # end
+
+      def scope_for_association(scope = relation) # :nodoc:
+        unframed_scope_for_association(scope).merge(current_frame || default_framed)
       end
 
-      # def default_framed(frame = relation) # :nodoc:
-      def default_framed(frame = relation) # :nodoc:
-        !ignore_default_frame? && !ActiveRecord::Framing.disabled? && build_default_frame(frame) || frame
+      def default_framed(my_frame = relation)
+        build_default_frame(my_frame) || my_frame
       end
 
+      def frames
+        @frames ||= {}
+      end
       # Adds a class method for retrieving and querying objects.
       # The method is intended to return an ActiveRecord::Relation
       # object, which is composable with other frames.
@@ -136,50 +147,39 @@ module ActiveRecord
       #
       #   Article.published.featured.latest_article
       #   Article.featured.titles
-      def frame(frame_name, body, &block)
-        unless body.respond_to?(:call)
-          raise ArgumentError, "The frame body needs to be callable."
+      def frame(frame_name, body = nil, &block)
+        constant = frame_name.to_s.classify.to_sym
+
+        if !body.respond_to?(:call)
+          # raise ArgumentError, "The frame body needs to be callable."
+          warn "You've assigned a frame (#{frame_name}) with no callable block." unless
+            AttributeMethods::BLACKLISTED_CLASS_CONSTS.include?(frame_name)
+        elsif dangerous_class_const?(constant)
+          raise ArgumentError, "You tried to define a frame named \"#{constant}\" " \
+            "on the model \"#{self.constant}\", but Active Record already defined " \
+            "a class method with the same name."
         end
 
-        constant = frame_name.to_s.classify.to_sym
         valid_frame_name?(constant)
 
         arel_tn = "#{frame_name}/#{self.table_name}"
 
-        new_class = self.const_set constant, (Class.new(self) do |klass|
-          klass.abstract_class = true
-          klass.table_name = superclass.table_name
-
-          def klass.discriminate_class_for_record(record)
-            superclass.send(:discriminate_class_for_record, record)
-          end
-
-          klass.default_frames = [body]
-
-          @current_frame_extension = block
-
-          def klass.current_frame
-            build_frame(default_frames, arel_table, superclass.relation, &@current_frame_extension)
-          end
-
-          @arel_table = superclass.arel_table.dup.tap do |at|
-            at.name = arel_tn
-          end
-
-        end)
-
-        if dangerous_class_const?(constant)
-          raise ArgumentError, "You tried to define a frame named \"#{constant}\" " \
-            "on the model \"#{self.constant}\", but Active Record already defined " \
-            "a class method with the same name."
+        at = arel_table.clone.tap do |a_t|
+          a_t.name = arel_tn
         end
+        # at = Arel::Table.new(arel_tn, arel_table.engine)
+        # at = Arel::Table.new(arel_tn, self)
 
+        frames[constant] = Proc.new do
+          build_frame([body].compact, at, relation, &block)
+        end
       end
 
       private
 
         def valid_frame_name?(name)
-          if const_defined?(name) && logger
+          # if const_defined?(name) && logger
+          if frames.key?(name) && logger
             logger.warn "Creating frame :#{name}. " \
               "Overwriting existing const #{self.name}::#{name}."
           end

data/lib/active_record/framing/query_methods.rb

@@ -4,29 +4,10 @@ module ActiveRecord
   module Framing
     module QueryMethods
 
-      if ::ActiveRecord.version >= Gem::Version.new("5.1") # 5.1+
-        require 'active_record/framing/compat/active_record_5_1'
-      elsif ::ActiveRecord.version >= Gem::Version.new("5.0") # 5.0+
-        require 'active_record/framing/compat/active_record_5_0'
-      elsif ::ActiveRecord.version >= Gem::Version.new("4.2") # 4.2+
-        require 'active_record/framing/compat/active_record_4_2'
-      else
-        raise NotImplementedError, "ActiveRecord::Framing does not support Rails #{::ActiveRecord.version}"
+      def frame(value)
+        spawn.frame!(value)
       end
 
-      # def from!(value, subquery_name = nil) # :nodoc:
-      #   super.tap do |rel|
-      #     if value.is_a?(::ActiveRecord::Relation) && value.frames_values.any?
-      #       self.frames_values = self.frames_values.merge(value.frames_values)
-      #       value.frames_values.clear
-      #     end
-      #   end
-      # end
-
-      # def frame(value)
-      #   spawn.frame!(value)
-      # end
-
       def frame!(value)
         value = value.all if (value.is_a?(Class) && value < ::ActiveRecord::Base)
 
@@ -39,6 +20,8 @@ module ActiveRecord
             {value.left.name => value}
           when String
             {arel_table.name => value}
+          when Hash
+            value
           else
             {}
           end

data/lib/active_record/framing/railtie.rb

@@ -4,15 +4,21 @@ require 'active_record/framing/query_methods'
 require 'active_record/framing/spawn_methods'
 require 'active_record/framing/attribute_methods'
 require 'active_record/framing/relation'
+require 'active_record/framing/join_dependency'
+require 'active_record/framing/reflection'
+require 'active_record/framing/compat'
 
 module ActiveRecord::Framing
   class Railtie < Rails::Railtie
     initializer 'active_record-framing.load' do |_app|
       ActiveSupport.on_load(:active_record) do
         ::ActiveRecord::Base.prepend(ActiveRecord::Framing)
+
         ::ActiveRecord::Relation.prepend(ActiveRecord::Framing::Relation)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Framing::QueryMethods)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Framing::SpawnMethods)
+        ::ActiveRecord::Associations::JoinDependency.prepend(ActiveRecord::Framing::JoinDependency)
+
       end
     end
   end

data/lib/active_record/framing/reflection.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  module Framing
+    module Reflection
+
+      def self.prepended(subclass)
+        class << subclass
+          prepend ClassMethods
+        end
+      end
+
+      module ClassMethods
+
+        def add_reflection(ar, name, reflection)
+          super.tap do |reflections|
+            #
+            # puts "foo"
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module Framing
+    module MacroReflection
+
+      def self.prepended(subclass)
+        class << subclass
+          attr_reader :frame
+        end
+      end
+
+    end
+  end
+end

data/lib/active_record/framing/relation.rb

@@ -1,9 +1,18 @@
+require 'active_record/framing/model_proxy'
+
 module ActiveRecord
   # = Active Record \Relation
   module Framing
     module Relation
 
+      def initialize(*args)
+        super.tap do |something|
+          @klass = ModelProxy.new(@klass, arel_table) unless @klass.class == ModelProxy
+        end
+      end
+
       def build_arel(*)
+        @klass.reframe_values = reframe_values
         super.tap do |ar|
           unless ignore_default_frame?
             build_frames(ar)
@@ -12,8 +21,30 @@ module ActiveRecord
         end
       end
 
+      # Prevents a scope from re-including the default_scope
+      # e.g. User::All.all.to_sql yielding
+      # WITH "all/users" AS (SELECT "users".* FROM "users"), "users" AS (SELECT "users".* FROM "users" WHERE "users"."kind" = 1) SELECT "all/users".* FROM "all/users"
+      # vs.
+      # WITH "all/users" AS (SELECT "users".* FROM "users") SELECT "all/users".* FROM "all/users"
+      def all
+        spawn
+      end
+
+      def table=(value)
+        @table = value
+        @klass.table = value
+      end
+
+      def aggregate_column(column_name)
+        framing { super }
+      end
+
+      def build_joins(*)
+        framing { super }
+      end
+
       # This is all very unfortunate (rails 4.2):
-      # ActiveRecord, in it's infinite wisdom, has decided
+      # ActiveRecord—in it's infinite wisdom—has decided
       # to create JoinDependency objects with arel_tables using a
       # generic engine (ActiveRecord::Base) as opposed to that of
       # the driving class. For example:
@@ -33,7 +64,7 @@ module ActiveRecord
         # TODO: cache known associations, (renable warning)
         assocs = klass.reflect_on_all_associations.inject(Hash.new) do |assocs, assoc|
           begin
-            assocs[assoc.table_name] = assoc
+            assocs[assoc.name] = assoc
           rescue NameError => e
             # warn <<~WARN.chomp
             #   ActiveRecord::Framing was trying to inspect the association #{assoc.name}
@@ -47,19 +78,28 @@ module ActiveRecord
 
         manager.join_sources.each do |join_source|
           next unless join_source&.left&.respond_to?(:name)
-          if (assoc = assocs[join_source.left.name])
-            source = reframe_values.fetch(assoc.name) { assoc.klass }
+          table = join_source.left
+          if (join_class = derive_engine(table, assocs))
+            frame!(join_class)
+          end
+        end
 
-            join_source.left.name = source.arel_table.name
-            if source < ::ActiveRecord::Base
-              merge!(source.all)
-            elsif source < ::ActiveRecord::Relation
-              merge!(source)
-            end
+        reframe_values.each do |assoc_name, relation|
+          relation.frames_values.values.each do |value|
+            original = frames_values.delete(value.left.engine.table_name)
+            frame!(value)
           end
         end
       end
 
+      def derive_engine(table, associations)
+        if table.engine == ::ActiveRecord::Base
+          associations[table.name]
+        else
+          table.engine
+        end
+      end
+
       # Frame all queries to the current frame.
       #
       #   Comment.where(post_id: 1).framing do

data/lib/active_record/framing/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Framing
-    VERSION = "0.1.0-9"
+    VERSION = "0.1.0-10"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record-framing
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.9
+  version: 0.1.0.pre.10
 platform: ruby
 authors:
 - Dale Stevens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-13 00:00:00.000000000 Z
+date: 2019-12-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -17,6 +17,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -24,6 +27,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +142,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Allows for larger level scoping (framing) that affect complicated queries
   more holistically
 email:
@@ -148,16 +168,21 @@ files:
 - LICENSE
 - README.md
 - lib/active_record-framing.rb
-- lib/active_record/framing.rb
 - lib/active_record/framing/attribute_methods.rb
+- lib/active_record/framing/compat.rb
 - lib/active_record/framing/compat/active_record_4_2.rb
 - lib/active_record/framing/compat/active_record_5_0.rb
 - lib/active_record/framing/compat/active_record_5_1.rb
+- lib/active_record/framing/compat/active_record_6_0.rb
+- lib/active_record/framing/compat/arel.rb
 - lib/active_record/framing/core_extension.rb
 - lib/active_record/framing/default.rb
+- lib/active_record/framing/join_dependency.rb
+- lib/active_record/framing/model_proxy.rb
 - lib/active_record/framing/named.rb
 - lib/active_record/framing/query_methods.rb
 - lib/active_record/framing/railtie.rb
+- lib/active_record/framing/reflection.rb
 - lib/active_record/framing/relation.rb
 - lib/active_record/framing/spawn_methods.rb
 - lib/active_record/framing/version.rb
@@ -181,7 +206,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: Provides larger level scopes (frames) through the use of common table expressions.

data/lib/active_record/framing.rb

@@ -1,3 +0,0 @@
-require 'active_record/framing/default'
-require 'active_record/framing/named'
-require 'active_record/framing/railtie' if defined?(Rails::Railtie)