active_record-framing 0.1.0.pre.7 → 0.1.0.pre.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a84c35cce6f059189796de3ed8b120fdf0c078c2fa688bf0e70cd46f41f9ce2b
-  data.tar.gz: f5678727edd6b2ad75939bce7b8c434684970dc3773b1bf7742c1b4e2d4cdafc
+  metadata.gz: ab0c33dbeba1bf12e4f49d8e51fada71519e03993edc8a15821b88bbabc37061
+  data.tar.gz: 74750a483858cd179c5051db28d3bc272c9440bacf51fc8c50cc0f43c48806ba
 SHA512:
-  metadata.gz: 40d135da789de110cef85ad302cfb8db66d2ef6a826c48c14eea4d8a767f433dcd8469b6fe41b3ce8219ef73593b0d26edcf53aabf64275970618c829d349880
-  data.tar.gz: 4f80b40511c0d1b0e17e8aef18c05ef660724c2fc3fdb873e5682b0c974653cf98a0135bff61c1ffedee8d3bceeb0c429ed18f47d78c60f00aafa9fba1e49eb2
+  metadata.gz: ae7e047fefd79d7bb836b04b69bcc7378b6fae4057fbfe6299cf0ec3fd37904e9b9e034ebaf86107f628c8b2efb319946d00bbc4a4111a3fb7eff257db577300
+  data.tar.gz: 2b09eaecb22f6d66fe20b9215589f0f816f0538f53e5b8be833fd09c1e68e4f58e9168d74d81774de89f4ac0e8528bc95c1b781bb06d84a28b9f32ed180a85d5

data/lib/active_record/framing/core_extension.rb

@@ -18,6 +18,17 @@ module ActiveRecord
       subclass.extend ClassMethods
     end
 
+    def self.disable
+      @disabled = true
+      yield if block_given?
+    ensure
+      @disabled = false
+    end
+
+    def self.disabled?
+      @disabled == true
+    end
+
     module ClassMethods # :nodoc:
       def current_frame
         FrameRegistry.value_for(:current_frame, self)
@@ -62,25 +73,13 @@ module ActiveRecord
       # Obtains the value for a given +frame_type+ and +model+.
       def value_for(frame_type, model)
         raise_invalid_frame_type!(frame_type)
-        return @registry[frame_type][model.name]
+        return @registry[frame_type][model]# if skip_inherited_frame
       end
 
-      # def value_for(frame_type, model, skip_inherited_frame = false)
-      #   raise_invalid_frame_type!(frame_type)
-      #   return @registry[frame_type][model.name] if skip_inherited_frame
-      #   klass = model
-      #   base = model.base_class
-      #   while klass <= base
-      #     value = @registry[frame_type][klass.name]
-      #     return value if value
-      #     klass = klass.superclass
-      #   end
-      # end
-
       # Sets the +value+ for a given +frame_type+ and +model+.
       def set_value_for(frame_type, model, value)
         raise_invalid_frame_type!(frame_type)
-        @registry[frame_type][model.name] = value
+        @registry[frame_type][model] = value
       end
 
       private

data/lib/active_record/framing/default.rb

@@ -7,8 +7,13 @@ module ActiveRecord
 
       included do
         # Stores the default frame for the class.
-        class_attribute :default_frames, instance_writer: false, instance_predicate: false
-        class_attribute :default_frame_override, instance_writer: false, instance_predicate: false
+        class_attribute :default_frames,
+          instance_writer: false,
+          instance_predicate: false
+
+        class_attribute :default_frame_override,
+          instance_writer: false,
+          instance_predicate: false
 
         self.default_frames = []
         self.default_frame_override = nil
@@ -41,109 +46,106 @@ module ActiveRecord
           FrameRegistry.value_for(:ignore_default_frame, base_class)
         end
 
-        private
-
-          # Use this macro in your model to set a default frame for all operations on
-          # the model.
-          #
-          #   class Article < ActiveRecord::Base
-          #     default_frame { where(published: true) }
-          #   end
-          #
-          #   Article.all # => # Fires "WITH articles AS (SELECT * FROM articles WHERE published = true) SELECT * FROM articles"
-          #
-          # The #default_frame is not applied while updating/creating/building a record.
-          #
-          #   Article.new.published    # => nil
-          #   Article.create.published # => nil
-          #   Article.first.update(name: 'A Tale of Two Cities').published # => nil
-          #
-          # (You can also pass any object which responds to +call+ to the
-          # +default_frame+ macro, and it will be called when building the
-          # default frame.)
-          #
-          # If you use multiple #default_frame declarations in your model then
-          # they will be merged together:
-          #
-          #   class Article < ActiveRecord::Base
-          #     default_frame { where(published: true) }
-          #     default_frame { where(rating: 'G') }
-          #   end
-          #
-          #   Article.all # => WITH articles AS (SELECT * FROM articles WHERE published = true AND rating = 'G') SELECT * FROM articles
-          #
-          # This is also the case with inheritance and module includes where the
-          # parent or module defines a #default_frame and the child or including
-          # class defines a second one.
-          #
-          # If you need to do more complex things with a default frame, you can
-          # alternatively define it as a class method:
-          #
-          #   class Article < ActiveRecord::Base
-          #     def self.default_frame
-          #       # Should return a frame, you can call 'super' here etc.
-          #     end
-          #   end
-          def default_frame(frame = nil) # :doc:
-            frame = Proc.new if block_given?
-
-            if frame.is_a?(Relation) || !frame.respond_to?(:call)
-              raise ArgumentError,
-                "Support for calling #default_frame without a block is removed. For example instead " \
-                "of `default_frame where(color: 'red')`, please use " \
-                "`default_frame { where(color: 'red') }`. (Alternatively you can just redefine " \
-                "self.default_frame.)"
-            end
+        # 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
+          return if ignore_default_frame?
+          self.ignore_default_frame = true
+          yield
+        ensure
+          self.ignore_default_frame = false
+        end
 
-            self.default_frames += [frame]
-          end
+      private
 
-          def build_default_frame(base_rel = nil)
-            return if abstract_class?
+        def ignore_default_frame=(ignore)
+          FrameRegistry.set_value_for(:ignore_default_frame, base_class, ignore)
+        end
 
-            if default_frame_override.nil?
-              self.default_frame_override = !Base.is_a?(method(:default_frame).owner)
-            end
+        # Use this macro in your model to set a default frame for all operations on
+        # the model.
+        #
+        #   class Article < ActiveRecord::Base
+        #     default_frame { where(published: true) }
+        #   end
+        #
+        #   Article.all # => # Fires "WITH articles AS (SELECT * FROM articles WHERE published = true) SELECT * FROM articles"
+        #
+        # The #default_frame is not applied while updating/creating/building a record.
+        #
+        #   Article.new.published    # => nil
+        #   Article.create.published # => nil
+        #   Article.first.update(name: 'A Tale of Two Cities').published # => nil
+        #
+        # (You can also pass any object which responds to +call+ to the
+        # +default_frame+ macro, and it will be called when building the
+        # default frame.)
+        #
+        # If you use multiple #default_frame declarations in your model then
+        # they will be merged together:
+        #
+        #   class Article < ActiveRecord::Base
+        #     default_frame { where(published: true) }
+        #     default_frame { where(rating: 'G') }
+        #   end
+        #
+        #   Article.all # => WITH articles AS (SELECT * FROM articles WHERE published = true AND rating = 'G') SELECT * FROM articles
+        #
+        # This is also the case with inheritance and module includes where the
+        # parent or module defines a #default_frame and the child or including
+        # class defines a second one.
+        #
+        # If you need to do more complex things with a default frame, you can
+        # alternatively define it as a class method:
+        #
+        #   class Article < ActiveRecord::Base
+        #     def self.default_frame
+        #       # Should return a frame, you can call 'super' here etc.
+        #     end
+        #   end
+        def default_frame(frame = nil) # :doc:
+          frame = Proc.new if block_given?
+
+          if frame.is_a?(Relation) || !frame.respond_to?(:call)
+            raise ArgumentError,
+              "Support for calling #default_frame without a block is removed. For example instead " \
+              "of `default_frame where(color: 'red')`, please use " \
+              "`default_frame { where(color: 'red') }`. (Alternatively you can just redefine " \
+              "self.default_frame.)"
+          end
 
-            if default_frame_override
-              # The user has defined their own default frame method, so call that
-              evaluate_default_frame do
-                if frame = default_frame
-                  (base_rel ||= relation).frame!(frame)
-                end
-              end
-            elsif default_frames.any?
-              # cte_table = arel_table
-              cte_table = Arel::Table.new(table_name)
+          self.default_frames += [frame]
+        end
 
-              evaluate_default_frame do
-                # Create CTE here
+        def build_default_frame(base_rel = nil)
+          return if abstract_class?
 
-                cte_relation = default_frames.inject(relation) do |default_frame, frame|
-                  frame = frame.respond_to?(:to_proc) ? frame : frame.method(:call)
-                  default_frame.merge!(relation.instance_exec(&frame))
-                end
+          if default_frame_override.nil?
+            self.default_frame_override = !::ActiveRecord::Base.is_a?(method(:default_frame).owner)
+          end
 
-                base_rel ||= relation
-                base_rel.frame!(Arel::Nodes::As.new(Arel::Table.new(table_name), cte_relation.arel))# if cte_relation
+          if default_frame_override
+            # The user has defined their own default frame method, so call that
+            ignore_default_frame do
+              if (frame = default_frame)
+                (base_rel ||= relation).frame!(frame)
               end
             end
-          end
+          elsif default_frames.any?
+            ignore_default_frame do
+              cte_table = Arel::Table.new(table_name)
 
-          def ignore_default_frame=(ignore)
-            FrameRegistry.set_value_for(:ignore_default_frame, base_class, ignore)
-          end
+              cte_relation = default_frames.inject(relation) do |default_frame, frame|
+                frame = frame.respond_to?(:to_proc) ? frame : frame.method(:call)
+                default_frame.merge!(relation.instance_exec(&frame))
+              end
 
-          # 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 evaluate_default_frame
-            return if ignore_default_frame?
-            self.ignore_default_frame = true
-            yield
-          ensure
-            self.ignore_default_frame = false
+              base_rel ||= relation
+              base_rel.frame!(Arel::Nodes::As.new(cte_table, cte_relation.arel))# if cte_relation
+            end
           end
+        end
       end
     end
   end

data/lib/active_record/framing/named.rb

@@ -19,7 +19,7 @@ module ActiveRecord
       # {default_frame}[rdoc-ref:Framing::Default::ClassMethods#default_frame].
       def all
         rel = unframed_all
-        if current_frame = self.current_frame
+        if (current_frame = self.current_frame)
           if self == current_frame.klass
             current_frame.clone
           else
@@ -32,7 +32,7 @@ module ActiveRecord
 
       # def default_framed(frame = relation) # :nodoc:
       def default_framed(frame = nil) # :nodoc:
-        !ignore_default_frame? && build_default_frame(frame) || frame
+        !ignore_default_frame? && !ActiveRecord::Framing.disabled? && build_default_frame(frame) || frame
       end
 
       # Adds a class method for retrieving and querying objects.
@@ -149,7 +149,6 @@ module ActiveRecord
         the_frame = body.respond_to?(:to_proc) ? body : body.method(:call)
         cte_relation = relation.merge!(relation.instance_exec(&the_frame) || relation)
 
-        delegator = self.name.to_sym
         new_class = self.const_set constant, (Class.new(self) do |klass|
           klass.abstract_class = true
           klass.table_name = superclass.table_name

data/lib/active_record/framing/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Framing
-    VERSION = "0.1.0-7"
+    VERSION = "0.1.0-8"
   end
 end

data/lib/active_record/framing.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record-framing
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.7
+  version: 0.1.0.pre.8
 platform: ruby
 authors:
 - Dale Stevens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-26 00:00:00.000000000 Z
+date: 2019-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -148,6 +148,7 @@ 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/active_record_4_2.rb
 - lib/active_record/framing/compat/active_record_5_0.rb