active_record-framing 0.1.0.pre.1 → 0.1.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db9fa84eb9a0af089cf82457843e6b46c05178f0dd3679253df766ba17755ec1
-  data.tar.gz: 37c02526ee91a9fbe029b9f4f740cac732738ddf9c18a189f7b6ba56a2614c10
+  metadata.gz: 8dd6c0a413bc426a0a22dee85cb7077ffb21c47fb77e5cf411a47478961002d1
+  data.tar.gz: 5c7b93bcd554161bf4020f5f3d3cec8882d31ec0b9da86ef26b72b08f70d146d
 SHA512:
-  metadata.gz: 734a4dff29f64d57563c622088256f8e3f12d992d4f4943c8eec959e47bab3e0ce91cf4058691e7b7a391cc98a4d35b689ec95c5ac6d15d13bdd69c5cb99fa04
-  data.tar.gz: 3abe8e57cf9d98312ab3e651fe48964854a03bb68e1577755249ad0dd33ba4dee615246229acf5c299d4593e8ea44ede1115a309b1de721ea259b5e7a02145f4
+  metadata.gz: 04f3c99ff11c241b3a0915d06e4c32cf171bd31b18314ac23f7c2536ad8d35aefaac73bdcfe4cbb4c6476a04db3bfcf03fdbde902865ea8dc761671d9894efed
+  data.tar.gz: b19fcf8ef79262680551b65f0dffe47d5c0cb2b1216d5c7c149dd7d7037067f3b5785dd87d2aa6d5ce0dc8d749d440f0864a6c4360b7bf1d30273475d42f0ebb

data/CHANGELOG.md

@@ -1,53 +1,4 @@
-# DeletedAt
+# ActiveRecord::Framing
 
-## 0.5.0 _(June 25, 2018)_
-- Removed use of invasive views in preference of sub-selects
-- Dropped support for Ruby 2.0, 2.1, 2.2
-- Dropped support for Rails 4.1
-- Default `active_record-framing` options using `Proc`
-
-## 0.4.0 _(Never Released)_
-- Specs for Rails 4.0-5.1
-  - Uses `combustion` gem for cleaner and more comprehensive testing
-- Added badges to ReadMe
-- Using `:prepend` to leverage ancestry chain
-- Add logger for internal use
-- DRYd up init code
-- Removed partially supported features
-- Added DSL in migrations/schema for adding `active_record-framing` timestamps to tables
-
-## 0.3.0 _(May 10, 2017)_
-- Add specs
-- Clean up dependencies
-- Auto-init models after installing views
-- Remove chained `create` methods
-
-## 0.2.6 _(April 06, 2017)_
-- Add warning when no DB connection present
-
-## 0.2.5 _(March 28, 2017)_
-- Extract injections to `.load` method
-
-## 0.2.4 _(February 03, 2017)_
-- Use `becomes` to mask `::All` etc classes
-
-## 0.2.3 _(February 03, 2017)_
-- Chain `create!` method to work properly
-
-## 0.2.2 _(February 03, 2017)_
-- Chain `create` method to work properly
-
-## 0.2.1 _(February 03, 2017)_
-- More reliable table name handling
-- Changed API for installing views (e.g. `destroy_deleted_view`, `uninstall_deleted_view`)
-
-## 0.1.1 _(January 31, 2017)_
-- Added instructions to readme
-- Fixes stack-too-deep edge-case (by moving to `:include` over `:prepend`)
-
-## 0.1.0 _(January 30, 2017)_
-- Renames primary table to `model_name/all`
-- Creates views for each model using `active_record-framing`
-  - `model_name/deleted`
-  - `model_name/present`
-- Classes created to read from views (`::All`, `::Present`, `::Deleted`)
+## 0.1.0 _(May 08, 2019)_
+- Initial Release

data/README.md

@@ -62,22 +62,6 @@ WITH "admins" AS
   (SELECT "users".* )
 ```
 
-If you're starting with a brand-new table, the existing `timestamps` DSL has been extended to accept `deleted_at: true` as an option, for convenience. Or you can do it seperately as shown above.
-
-```ruby
-class CreatCommentsTable < ActiveRecord::Migration
-
-  def change
-    create_table :comments do |t|
-      # ...
-      #  to the `timestamps` DSL
-      t.timestamps null: false, deleted_at: true
-    end
-  end
-
-end
-```
-
 ## Development
 
 After checking out the repo, run `bundle` to install dependencies. Then, run `bundle exec rspec` to run the tests.

data/lib/active_record/framing/core_extension.rb

@@ -4,12 +4,16 @@ require "active_support/per_thread_registry"
 
 module ActiveRecord
   module Framing
-    extend ActiveSupport::Concern
 
-    included do
-      include Default
-      include Named
-      include AttributeMethods
+    def self.prepended(subclass)
+      subclass.class_eval do
+        singleton_class.alias_method :unframed_all, :all
+      end
+
+      subclass.include Default
+      subclass.extend Named
+      subclass.include AttributeMethods
+      subclass.extend ClassMethods
     end
 
     module ClassMethods # :nodoc:

data/lib/active_record/framing/default.rb

@@ -34,7 +34,7 @@ module ActiveRecord
         #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
         #   }
         def unframed
-          block_given? ? relation.framing { yield } : relation
+          block_given? ? unframed_all.framing { yield } : unframed_all
         end
 
         # Are there attributes associated with this frame?
@@ -116,12 +116,11 @@ module ActiveRecord
 
             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).merge!(frame)
-              #   end
-              # end
-              warn "come back to me!"
+              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)

data/lib/active_record/framing/named.rb

@@ -4,236 +4,188 @@ module ActiveRecord
   # = Active Record \Named \Frames
   module Framing
     module Named
-      extend ActiveSupport::Concern
 
-      module ClassMethods
-        # Returns an ActiveRecord::Relation frame object.
-        #
-        #   posts = Post.all
-        #   posts.size # Fires "select count(*) from  posts" and returns the count
-        #   posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects
-        #
-        #   fruits = Fruit.all
-        #   fruits = fruits.where(color: 'red') if options[:red_only]
-        #   fruits = fruits.limit(10) if limited?
-        #
-        # You can define a frame that applies to all finders using
-        # {default_frame}[rdoc-ref:Framing::Default::ClassMethods#default_frame].
-        # def all
-        #   super.tap do |rel|
-        #     if frame = framed_all
-        #       rel.with(frame)
-        #     end
-        #   end
-        # end
-
-        # alias this method?, framed_all
-        # def all
-        #   # if current_scope
-        #   #   current_scope.clone
-        #   # else
-        #   #   default_scoped
-        #   # end
-        #   if current_frame
-        #     puts "#{name} has a current_frame: #{current_frame.to_sql}"
-        #     super.frame(current_frame.clone)
-        #   else
-        #     puts "#{name} is using a default_frame: #{default_framed.to_sql}" if default_framed
-        #     super.frame(default_framed)
-        #   end
-        # end
-
-        def all
-          framed_all(super)
-        end
-
-        def framed_all(rel)
-          if current_frame = self.current_frame
-            if self == current_frame.klass
-              current_frame.clone
-            else
-              rel.merge!(current_frame)
-            end
+      # Returns an ActiveRecord::Relation frame object.
+      #
+      #   posts = Post.all
+      #   posts.size # Fires "select count(*) from  posts" and returns the count
+      #   posts.each {|p| puts p.name } # Fires "select * from posts" and loads post objects
+      #
+      #   fruits = Fruit.all
+      #   fruits = fruits.where(color: 'red') if options[:red_only]
+      #   fruits = fruits.limit(10) if limited?
+      #
+      # You can define a frame that applies to all finders using
+      # {default_frame}[rdoc-ref:Framing::Default::ClassMethods#default_frame].
+      def all
+        rel = unframed_all
+        if current_frame = self.current_frame
+          if self == current_frame.klass
+            current_frame.clone
           else
-            default_framed(rel)
+            rel.merge!(current_frame)
           end
+        else
+          default_framed(rel)
         end
+      end
 
-        def const_missing(const_name)
-          registered_frames[const_name]&.call() || super
-        end
-
-        def registered_frames
-          @registered_frames ||= {}
-        end
-
-        def frame_for_association(frame = relation) # :nodoc:
-          current_frame = self.current_frame
-
-          if current_frame && current_frame.empty_frame?
-            frame
-          else
-            default_framed(frame)
-          end
-        end
+      # def default_framed(frame = relation) # :nodoc:
+      def default_framed(frame = nil) # :nodoc:
+        !ignore_default_frame? && build_default_frame(frame) || frame
+      end
 
-        # def default_framed(frame = relation) # :nodoc:
-        def default_framed(frame = nil) # :nodoc:
-          !ignore_default_frame? && build_default_frame(frame) || frame
+      # 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.
+      # If it returns +nil+ or +false+, an
+      # {all}[rdoc-ref:Framing::Named::ClassMethods#all] frame is returned instead.
+      #
+      # A \frame represents a narrowing of a database query, such as
+      # <tt>where(color: :red).select('shirts.*').includes(:washing_instructions)</tt>.
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     frame :red, -> { where(color: 'red') }
+      #     frame :dry_clean_only, -> { joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) }
+      #   end
+      #
+      # The above calls to #frame define class methods <tt>Shirt.red</tt> and
+      # <tt>Shirt::DryCleanOnly</tt>. <tt>Shirt::Red</tt>, in effect,
+      # represents the query <tt>Shirt.where(color: 'red')</tt>.
+      #
+      # You should always pass a callable object to the frames defined
+      # with #frame. This ensures that the frame is re-evaluated each
+      # time it is called.
+      #
+      # Note that this is simply 'syntactic sugar' for defining an actual
+      # class method:
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     def self.red
+      #       where(color: 'red')
+      #     end
+      #   end
+      #
+      # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by
+      # <tt>Shirt.red</tt> is not an Array but an ActiveRecord::Relation,
+      # which is composable with other frames; it resembles the association object
+      # constructed by a {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
+      # declaration. For instance, you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>,
+      # <tt>Shirt.red.where(size: 'small')</tt>. Also, just as with the
+      # association objects, named \frames act like an Array, implementing
+      # Enumerable; <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>,
+      # and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if
+      # <tt>Shirt.red</tt> really was an array.
+      #
+      # These named \frames are composable. For instance,
+      # <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are
+      # both red and dry clean only. Nested finds and calculations also work
+      # with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
+      # returns the number of garments for which these criteria obtain.
+      # Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
+      #
+      # All frames are available as class methods on the ActiveRecord::Base
+      # descendant upon which the \frames were defined. But they are also
+      # available to {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
+      # associations. If,
+      #
+      #   class Person < ActiveRecord::Base
+      #     has_many :shirts
+      #   end
+      #
+      # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of
+      # Elton's red, dry clean only shirts.
+      #
+      # \Named frames can also have extensions, just as with
+      # {has_many}[rdoc-ref:Associations::ClassMethods#has_many] declarations:
+      #
+      #   class Shirt < ActiveRecord::Base
+      #     frame :red, -> { where(color: 'red') } do
+      #       def dom_id
+      #         'red_shirts'
+      #       end
+      #     end
+      #   end
+      #
+      # Frames cannot be used while creating/building a record.
+      #
+      #   class Article < ActiveRecord::Base
+      #     frame :published, -> { where(published: true) }
+      #   end
+      #
+      #   Article.published.new.published    # => nil
+      #   Article.published.create.published # => nil
+      #
+      # \Class methods on your model are automatically available
+      # on frames. Assuming the following setup:
+      #
+      #   class Article < ActiveRecord::Base
+      #     frame :published, -> { where(published: true) }
+      #     frame :featured, -> { where(featured: true) }
+      #
+      #     def self.latest_article
+      #       order('published_at desc').first
+      #     end
+      #
+      #     def self.titles
+      #       pluck(:title)
+      #     end
+      #   end
+      #
+      # We are able to call the methods like this:
+      #
+      #   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."
         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.
-        # If it returns +nil+ or +false+, an
-        # {all}[rdoc-ref:Framing::Named::ClassMethods#all] frame is returned instead.
-        #
-        # A \frame represents a narrowing of a database query, such as
-        # <tt>where(color: :red).select('shirts.*').includes(:washing_instructions)</tt>.
-        #
-        #   class Shirt < ActiveRecord::Base
-        #     frame :red, -> { where(color: 'red') }
-        #     frame :dry_clean_only, -> { joins(:washing_instructions).where('washing_instructions.dry_clean_only = ?', true) }
-        #   end
-        #
-        # The above calls to #frame define class methods <tt>Shirt.red</tt> and
-        # <tt>Shirt::DryCleanOnly</tt>. <tt>Shirt::Red</tt>, in effect,
-        # represents the query <tt>Shirt.where(color: 'red')</tt>.
-        #
-        # You should always pass a callable object to the frames defined
-        # with #frame. This ensures that the frame is re-evaluated each
-        # time it is called.
-        #
-        # Note that this is simply 'syntactic sugar' for defining an actual
-        # class method:
-        #
-        #   class Shirt < ActiveRecord::Base
-        #     def self.red
-        #       where(color: 'red')
-        #     end
-        #   end
-        #
-        # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by
-        # <tt>Shirt.red</tt> is not an Array but an ActiveRecord::Relation,
-        # which is composable with other frames; it resembles the association object
-        # constructed by a {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
-        # declaration. For instance, you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>,
-        # <tt>Shirt.red.where(size: 'small')</tt>. Also, just as with the
-        # association objects, named \frames act like an Array, implementing
-        # Enumerable; <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>,
-        # and <tt>Shirt.red.inject(memo, &block)</tt> all behave as if
-        # <tt>Shirt.red</tt> really was an array.
-        #
-        # These named \frames are composable. For instance,
-        # <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are
-        # both red and dry clean only. Nested finds and calculations also work
-        # with these compositions: <tt>Shirt.red.dry_clean_only.count</tt>
-        # returns the number of garments for which these criteria obtain.
-        # Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
-        #
-        # All frames are available as class methods on the ActiveRecord::Base
-        # descendant upon which the \frames were defined. But they are also
-        # available to {has_many}[rdoc-ref:Associations::ClassMethods#has_many]
-        # associations. If,
-        #
-        #   class Person < ActiveRecord::Base
-        #     has_many :shirts
-        #   end
-        #
-        # then <tt>elton.shirts.red.dry_clean_only</tt> will return all of
-        # Elton's red, dry clean only shirts.
-        #
-        # \Named frames can also have extensions, just as with
-        # {has_many}[rdoc-ref:Associations::ClassMethods#has_many] declarations:
-        #
-        #   class Shirt < ActiveRecord::Base
-        #     frame :red, -> { where(color: 'red') } do
-        #       def dom_id
-        #         'red_shirts'
-        #       end
-        #     end
-        #   end
-        #
-        # Frames cannot be used while creating/building a record.
-        #
-        #   class Article < ActiveRecord::Base
-        #     frame :published, -> { where(published: true) }
-        #   end
-        #
-        #   Article.published.new.published    # => nil
-        #   Article.published.create.published # => nil
-        #
-        # \Class methods on your model are automatically available
-        # on frames. Assuming the following setup:
-        #
-        #   class Article < ActiveRecord::Base
-        #     frame :published, -> { where(published: true) }
-        #     frame :featured, -> { where(featured: true) }
-        #
-        #     def self.latest_article
-        #       order('published_at desc').first
-        #     end
-        #
-        #     def self.titles
-        #       pluck(:title)
-        #     end
-        #   end
-        #
-        # We are able to call the methods like this:
-        #
-        #   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."
-          end
-
-          constant = frame_name.to_s.classify.to_sym
-          arel_tn = "#{frame_name}/#{self.table_name}"
+        constant = frame_name.to_s.classify.to_sym
+        arel_tn = "#{frame_name}/#{self.table_name}"
 
-          the_frame = body.respond_to?(:to_proc) ? body : body.method(:call)
-          cte_relation = relation.merge!(relation.instance_exec(&the_frame) || relation)
+        the_frame = body.respond_to?(:to_proc) ? body : body.method(:call)
+        cte_relation = relation.merge!(relation.instance_exec(&the_frame) || relation)
 
-          # self.const_set constant, Class.new(DelegateClass(self)) do |klass|
-          delegator = self.name.to_sym
-          self.const_set(constant, self.dup).class_eval do |klass|
-            extend SingleForwardable
-            def_delegator delegator, :type_caster
-            def_delegator delegator, :table_name
+        # self.const_set constant, Class.new(DelegateClass(self)) do |klass|
+        delegator = self.name.to_sym
+        self.const_set(constant, self.dup).class_eval do |klass|
+        # self.const_set constant, Class.new do |klass|
+          extend SingleForwardable
+          def_delegators delegator, :type_caster, :table_name, :discriminate_class_for_record
 
-            klass.default_frames = []
+          klass.default_frames = []
 
-            @arel_table = klass.arel_table.dup.tap do |at|
-              at.name = arel_tn
-            end
-
-            klass.current_frame = build_frame(cte_relation, &block)
+          @arel_table = klass.arel_table.dup.tap do |at|
+            at.name = arel_tn
           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."
-          end
+          klass.current_frame = build_frame(cte_relation, &block)
+        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."
         end
 
-        def build_frame(frame, &block)
-          extension = Module.new(&block) if block
-          relation.frame!(Arel::Nodes::As.new(arel_table, frame.arel)).tap do |rel|
-            rel.extending!(extension) if extension
-          end
+      end
+
+      def build_frame(frame, &block)
+        extension = Module.new(&block) if block
+        relation.frame!(Arel::Nodes::As.new(arel_table, frame.arel)).tap do |rel|
+          rel.extending!(extension) if extension
         end
+      end
 
-        private
+      private
 
-          def valid_frame_name?(name)
-            if respond_to?(name, true) && logger
-              logger.warn "Creating frame :#{name}. " \
-                "Overwriting existing method #{self.name}.#{name}."
-            end
+        def valid_frame_name?(name)
+          if respond_to?(name, true) && logger
+            logger.warn "Creating frame :#{name}. " \
+              "Overwriting existing method #{self.name}.#{name}."
           end
-      end
+        end
     end
   end
 end

data/lib/active_record/framing/railtie.rb

@@ -9,7 +9,7 @@ module ActiveRecord::Framing
   class Railtie < Rails::Railtie
     initializer 'active_record-framing.load' do |_app|
       ActiveSupport.on_load(:active_record) do
-        ::ActiveRecord::Base.include(ActiveRecord::Framing)
+        ::ActiveRecord::Base.prepend(ActiveRecord::Framing)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Framing::Relation)
         ::ActiveRecord::Relation.include(ActiveRecord::Framing::QueryMethods)
         ::ActiveRecord::Relation.prepend(ActiveRecord::Framing::SpawnMethods)

data/lib/active_record/framing/relation.rb

@@ -3,20 +3,6 @@ module ActiveRecord
   module Framing
     module Relation
 
-      # def arel_without_frames
-      #   klass.ignore_default_frame
-      #   Thread.currently(:without_frames, true) do
-      #     @arel_without_frames ||= build_arel_without_frames
-      #   end
-      # end
-
-      # def build_arel_without_frames
-      #   @arel, old = nil, @arel
-      #   arel
-      # ensure
-      #   @arel = old
-      # end
-
       def build_arel(*)
         super.tap do |ar|
           unless ignore_default_frame?
@@ -26,11 +12,6 @@ module ActiveRecord
             #   reflection.klass.type_caster
             # )
             build_frames(ar)
-
-            frames_values.each do |k,v|
-              puts "#{k} => #{v.to_sql}"
-            end
-
             ar.with(*frames_values.values) if frames_values.any?
           end
         end

data/lib/active_record/framing/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record-framing
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.1
+  version: 0.1.0.pre.2
 platform: ruby
 authors:
 - Dale Stevens