active_record-framing 0.1.0.pre.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: db9fa84eb9a0af089cf82457843e6b46c05178f0dd3679253df766ba17755ec1
+  data.tar.gz: 37c02526ee91a9fbe029b9f4f740cac732738ddf9c18a189f7b6ba56a2614c10
+SHA512:
+  metadata.gz: 734a4dff29f64d57563c622088256f8e3f12d992d4f4943c8eec959e47bab3e0ce91cf4058691e7b7a391cc98a4d35b689ec95c5ac6d15d13bdd69c5cb99fa04
+  data.tar.gz: 3abe8e57cf9d98312ab3e651fe48964854a03bb68e1577755249ad0dd33ba4dee615246229acf5c299d4593e8ea44ede1115a309b1de721ea259b5e7a02145f4

data/CHANGELOG.md

@@ -0,0 +1,53 @@
+# DeletedAt
+
+## 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`)

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Dale Stevens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+[![License     ](https://img.shields.io/github/license/TwilightCoders/active_record-framing.svg)]()
+[![Version     ](https://img.shields.io/gem/v/active_record-framing.svg)](https://rubygems.org/gems/active_record-framing)
+[![Build Status](https://travis-ci.org/TwilightCoders/active_record-framing.svg)](https://travis-ci.org/TwilightCoders/active_record-framing)
+[![Maintenence ](https://api.codeclimate.com/v1/badges/762cdcd63990efa768b0/maintainability)](https://codeclimate.com/github/TwilightCoders/active_record-framing/maintainability)
+[![Coverage    ](https://codeclimate.com/github/TwilightCoders/active_record-framing/badges/coverage.svg)](https://codeclimate.com/github/TwilightCoders/active_record-framing/coverage)
+[![Dependencies](https://img.shields.io/librariesio/github/twilightcoders/active_record-framing.svg)](https://depfu.com/github/TwilightCoders/active_record-framing)
+
+# ActiveRecord::Framing
+
+Works similar to `scopes`. Rather than modifying the where clause of the `ActiveRecord::Relation`, it creates a common table expression (CTE) to be applied upon execution.
+
+Unlike scopes, they do not affect the values of attributes upon creation.
+
+## Requirements
+
+- Ruby 2.3+
+- ActiveRecord 4.2+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record-framing'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_record-framing
+
+## Usage
+
+Any `ActiveRecord::Base` descendant has access to two additional methods: `frame` and `default_frame`.
+
+```ruby
+class User < ActiveRecord::Base
+  default_frame { where(active: true) }
+  # ...
+end
+```
+Afterwards, `User.all.to_sql` yields
+```sql
+WITH "users" AS
+  (SELECT "users".* FROM "users" WHERE "users"."active" = true)
+SELECT "users".* FROM "users"
+```
+
+```ruby
+class Admin < User
+  default_frame('admins') { where(kind: 1) }
+  # ...
+end
+```
+
+Afterwards, `Admin.all.to_sql` yields
+```sql
+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.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/TwilightCoders/active_record-framing. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/active_record/framing/attribute_methods.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  module Framing
+    module AttributeMethods
+      extend ActiveSupport::Concern
+
+      BLACKLISTED_CLASS_CONSTS = %w(unframed)
+
+      module ClassMethods
+        # A class const is 'dangerous' if it is already defined by Active Record, but
+        # not by any ancestors. (So 'All' is not dangerous but 'Frameless' is.)
+        def dangerous_class_const?(const_name)
+          BLACKLISTED_CLASS_CONSTS.include?(const_name.to_s) || class_const_defined_within?(const_name, Base)
+        end
+
+        def class_const_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
+          klass.const_defined?(name) || superklass.const_defined?(name)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/framing/core_extension.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "active_support/per_thread_registry"
+
+module ActiveRecord
+  module Framing
+    extend ActiveSupport::Concern
+
+    included do
+      include Default
+      include Named
+      include AttributeMethods
+    end
+
+    module ClassMethods # :nodoc:
+      def current_frame
+        FrameRegistry.value_for(:current_frame, self)
+      end
+
+      def current_frame=(frame)
+        FrameRegistry.set_value_for(:current_frame, self, frame)
+      end
+    end
+
+    # This class stores the +:current_frame+ and +:ignore_default_frame+ values
+    # for different classes. The registry is stored as a thread local, which is
+    # accessed through +FrameRegistry.current+.
+    #
+    # This class allows you to store and get the frame values on different
+    # classes and different types of frames. For example, if you are attempting
+    # to get the current_frame for the +Board+ model, then you would use the
+    # following code:
+    #
+    #   registry = ActiveRecord::Framing::FrameRegistry
+    #   registry.set_value_for(:current_frame, Board, some_new_frame)
+    #
+    # Now when you run:
+    #
+    #   registry.value_for(:current_frame, Board)
+    #
+    # You will obtain whatever was defined in +some_new_frame+. The #value_for
+    # and #set_value_for methods are delegated to the current FrameRegistry
+    # object, so the above example code can also be called as:
+    #
+    #   ActiveRecord::Framing::FrameRegistry.set_value_for(:current_frame,
+    #       Board, some_new_frame)
+    class FrameRegistry # :nodoc:
+      extend ActiveSupport::PerThreadRegistry
+
+      VALID_SCOPE_TYPES = [:current_frame, :ignore_default_frame]
+
+      def initialize
+        @registry = Hash.new { |hash, key| hash[key] = {} }
+      end
+
+      # 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]
+      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
+      end
+
+      private
+
+        def raise_invalid_frame_type!(frame_type)
+          if !VALID_SCOPE_TYPES.include?(frame_type)
+            raise ArgumentError, "Invalid frame type '#{frame_type}' sent to the registry. Frame types must be included in VALID_SCOPE_TYPES"
+          end
+        end
+    end
+  end
+end

data/lib/active_record/framing/default.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Framing
+    module Default
+      extend ActiveSupport::Concern
+
+      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
+
+        self.default_frames = []
+        self.default_frame_override = nil
+      end
+
+      module ClassMethods
+        # Returns a frame for the model without the previously set frames.
+        #
+        #   class Post < ActiveRecord::Base
+        #     def self.default_frame
+        #       where(published: true)
+        #     end
+        #   end
+        #
+        #   Post.all                                  # Fires "WITH posts AS (SELECT * FROM posts WHERE published = true) SELECT * FROM posts"
+        #   Post.unframed.all                         # Fires "SELECT * FROM posts"
+        #   Post.where(published: false).unframed.all # Fires "SELECT * FROM posts"
+        #
+        # This method also accepts a block. All queries inside the block will
+        # not use the previously set frames.
+        #
+        #   Post.unframed {
+        #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
+        #   }
+        def unframed
+          block_given? ? relation.framing { yield } : relation
+        end
+
+        # Are there attributes associated with this frame?
+        def frame_attributes? # :nodoc:
+          super || default_frames.any? || respond_to?(:default_frame)
+        end
+
+        def before_remove_const #:nodoc:
+          self.current_frame = nil
+        end
+
+        def ignore_default_frame?
+          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
+
+            self.default_frames += [frame]
+          end
+
+          def build_default_frame(base_rel = nil)
+            return if abstract_class?
+
+            if default_frame_override.nil?
+              self.default_frame_override = !Base.is_a?(method(:default_frame).owner)
+            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).merge!(frame)
+              #   end
+              # end
+              warn "come back to me!"
+            elsif default_frames.any?
+              # cte_table = arel_table
+              cte_table = Arel::Table.new(table_name)
+
+              evaluate_default_frame do
+                # Create CTE here
+
+                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
+
+                base_rel ||= relation
+                base_rel.frame!(Arel::Nodes::As.new(Arel::Table.new(table_name), cte_relation.arel))# if cte_relation
+              end
+            end
+          end
+
+          def ignore_default_frame=(ignore)
+            FrameRegistry.set_value_for(:ignore_default_frame, base_class, ignore)
+          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
+          end
+      end
+    end
+  end
+end

data/lib/active_record/framing/named.rb

@@ -0,0 +1,239 @@
+require 'delegate'
+
+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
+          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
+
+        # 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}"
+
+          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
+
+            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)
+          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
+
+        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
+
+          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/query_methods.rb

@@ -0,0 +1,119 @@
+module ActiveRecord
+  module Framing
+    module QueryMethods
+
+      if ::ActiveRecord.version >= Gem::Version.new("5.1") # 5.1+
+        def frames_values
+          get_value(:frames)
+        end
+        def frames_values=(value)
+          set_value(:frames, value)
+        end
+        ::ActiveRecord::Relation::DEFAULT_VALUES[:frames] = ::ActiveRecord::Relation::FROZEN_EMPTY_HASH
+      elsif ::ActiveRecord.version >= Gem::Version.new("5.0") # 5.0+
+        def frames_values
+          @values[:frames] || ::ActiveRecord::Relation::FROZEN_EMPTY_HASH
+        end
+        def frames_values=(values)
+          assert_mutability!
+          @values[:frames] = values
+        end
+      elsif ::ActiveRecord.version >= Gem::Version.new("4.2") # 4.2+
+        def frames_values
+          @values[:frames] || {}
+        end
+        def frames_values=(values)
+          raise ImmutableRelation if @loaded
+          check_cached_relation
+          @values[:frames] = values
+        end
+      else
+        raise NotImplementedError, "ActiveRecord::Framing does not support Rails #{::ActiveRecord.version}"
+      end
+
+      def from!(value, subquery_name = nil) # :nodoc:
+        super.tap do |rel|
+          frames_values = frames_values.merge(value.frames_values) if value.is_a?(::ActiveRecord::Relation)
+        end
+      end
+
+      def frame(value)
+        spawn.frame!(value)
+      end
+
+      def frame!(value)
+        if key = frame_key(value)
+          self.frames_values = self.frames_values.merge(key => value)
+        end
+        self
+      end
+
+      # Removes an unwanted relation that is already defined on a chain of relations.
+      # This is useful when passing around chains of relations and would like to
+      # modify the relations without reconstructing the entire chain.
+      #
+      #   User.order('email DESC').unframe(:order) == User.all
+      #
+      # The method arguments are symbols which correspond to the names of the methods
+      # which should be unframed. The valid arguments are given in VALID_UNSCOPING_VALUES.
+      # The method can also be called with multiple arguments. For example:
+      #
+      #   User.order('email DESC').select('id').where(name: "John")
+      #       .unframe(:order, :select, :where) == User.all
+      #
+      # One can additionally pass a hash as an argument to unframe specific +:where+ values.
+      # This is done by passing a hash with a single key-value pair. The key should be
+      # +:where+ and the value should be the where value to unframe. For example:
+      #
+      #   User.where(name: "John", active: true).unframe(where: :name)
+      #       == User.where(active: true)
+      #
+      # This method is similar to #except, but unlike
+      # #except, it persists across merges:
+      #
+      #   User.order('email').merge(User.except(:order))
+      #       == User.order('email')
+      #
+      #   User.order('email').merge(User.unframe(:order))
+      #       == User.all
+      #
+      # This means it can be used in association definitions:
+      #
+      #   has_many :comments, -> { unframe(where: :trashed) }
+      #
+      # def unframe(*args)
+      #   check_if_method_has_arguments!(:unframe, args)
+      #   spawn.unframe!(*args)
+      # end
+
+      # def unframe!(*args) # :nodoc:
+      #   args.flatten!
+      #   self.unframe_values += args
+
+      #   args.each do |frame|
+      #     case frame
+      #     when Symbol
+      #       frame = :left_outer_joins if frame == :left_joins
+      #       if !VALID_UNSCOPING_VALUES.include?(frame)
+      #         raise ArgumentError, "Called unframe() with invalid unframing argument ':#{frame}'. Valid arguments are :#{VALID_UNSCOPING_VALUES.to_a.join(", :")}."
+      #       end
+      #       set_value(frame, DEFAULT_VALUES[frame])
+      #     when Hash
+      #       frame.each do |key, target_value|
+      #         if key != :where
+      #           raise ArgumentError, "Hash arguments in .unframe(*args) must have :where as the key."
+      #         end
+
+      #         target_values = Array(target_value).map(&:to_s)
+      #         self.where_clause = where_clause.except(*target_values)
+      #       end
+      #     else
+      #       raise ArgumentError, "Unrecognized framing: #{args.inspect}. Use .unframe(where: :attribute_name) or .unframe(:order), for example."
+      #     end
+      #   end
+
+      #   self
+      # end
+    end
+  end
+end

data/lib/active_record/framing/railtie.rb

@@ -0,0 +1,19 @@
+require 'rails/railtie'
+require 'active_record/framing/core_extension'
+require 'active_record/framing/query_methods'
+require 'active_record/framing/spawn_methods'
+require 'active_record/framing/attribute_methods'
+require 'active_record/framing/relation'
+
+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::Relation.prepend(ActiveRecord::Framing::Relation)
+        ::ActiveRecord::Relation.include(ActiveRecord::Framing::QueryMethods)
+        ::ActiveRecord::Relation.prepend(ActiveRecord::Framing::SpawnMethods)
+      end
+    end
+  end
+end

data/lib/active_record/framing/relation.rb

@@ -0,0 +1,162 @@
+module ActiveRecord
+  # = Active Record \Relation
+  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?
+            # alias_tracker.aliased_table_for(
+            #   reflection.table_name,
+            #   table_alias_for(reflection, parent, reflection != node.reflection),
+            #   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
+      end
+
+      # This is all very unfortunate (rails 4.2):
+      # 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:
+      #
+      # #<Arel::Nodes::InnerJoin:0x00007f974e6eb008
+      #  @left=
+      #   #<Arel::Table:0x00007f97508f42f8
+      #    @aliases=[],
+      #    @columns=nil,
+      #    @engine=ActiveRecord::Base,     <=== Problem, should be `User`
+      #    @name="users",
+      #    @primary_key=nil,
+      #    @table_alias=nil>,
+      # NOTE: In Rails 5.2 (at least) we could use the InnerJoin.left.type_caster
+      def build_frames(manager)
+        join_names = manager.join_sources.collect do |source|
+          source.left.name.to_s # TODO: Need to_s?
+        end
+
+        # scopes = klass.reflections.slice(*join_names).values.inject(Hash.new) do |collector, assoc|
+        # NOTE: We cannot early exclude associations because some associations are different from their table names
+        klass.reflect_on_all_associations.each do |assoc|
+          # collector.merge(assoc.klass.default_scopes) if join_names.include?(assoc.table_name)
+          # (collector[assoc.klass] ||= Set.new).merge(assoc.klass.default_scopes) if join_names.include?(assoc.table_name) && assoc.klass.default_scopes.any?
+          if join_names.include?(assoc.table_name) && assoc.klass.default_frames.any? && assoc_default_frame = assoc.klass.send(:build_default_frame)
+            merge!(assoc_default_frame)
+            # collector[assoc_default_frame.table_name] ||= assoc_default_frame
+          end
+
+          # collector
+        end
+      end
+
+      def frame_key(cte)
+        case cte
+        when ActiveRecord::Relation
+          cte.table.name
+        when Arel::Nodes::As
+          cte.left.name
+        when String
+          cte
+        else
+          nil
+        end
+      end
+
+      # def reframe(*args) # :nodoc:
+      #   args.compact!
+      #   args.flatten!
+      #   # binding.pry
+      #   self
+      # end
+
+      # def reframe!(*args) # :nodoc:
+      #   args.flatten!
+      #   self.unframe_values += args
+
+      #   args.each do |frame|
+      #     case frame
+      #     when Symbol
+      #       frame = :left_outer_joins if frame == :left_joins
+      #       if !VALID_UNSCOPING_VALUES.include?(frame)
+      #         raise ArgumentError, "Called unframe() with invalid unframing argument ':#{frame}'. Valid arguments are :#{VALID_UNSCOPING_VALUES.to_a.join(", :")}."
+      #       end
+      #       set_value(frame, DEFAULT_VALUES[frame])
+      #     when Hash
+      #       frame.each do |key, target_value|
+      #         if key != :where
+      #           raise ArgumentError, "Hash arguments in .unframe(*args) must have :where as the key."
+      #         end
+
+      #         target_values = Array(target_value).map(&:to_s)
+      #         self.where_clause = where_clause.except(*target_values)
+      #       end
+      #     else
+      #       raise ArgumentError, "Unrecognized framing: #{args.inspect}. Use .unframe(where: :attribute_name) or .unframe(:order), for example."
+      #     end
+      #   end
+
+      #   self
+      # end
+
+      # Frame all queries to the current frame.
+      #
+      #   Comment.where(post_id: 1).framing do
+      #     Comment.first
+      #   end
+      #   # => WITH "comments" AS (
+      #   # =>   SELECT "comments".* FROM "comments" WHERE "comments"."post_id" = 1
+      #   # => ) SELECT "comments".* FROM "comments" ORDER BY "comments"."id" ASC LIMIT 1
+      #
+      # Please check unframed if you want to remove all previous frames (including
+      # the default_frame) during the execution of a block.
+      def framing
+        previous, klass.current_frame = klass.current_frame, self unless @delegate_to_klass
+        yield
+      ensure
+        klass.current_frame = previous unless @delegate_to_klass
+      end
+
+      def scoping
+        framing { super }
+      end
+
+      # def _exec_frame(*args, &block) # :nodoc:
+      #   @delegate_to_klass = true
+      #   instance_exec(*args, &block) || self
+      # ensure
+      #   @delegate_to_klass = false
+      # end
+
+      # def frame_for_create
+      #   where_values_hash.merge!(create_with_value.stringify_keys)
+      # end
+
+      # def empty_frame? # :nodoc:
+      #   @values == klass.unframed.values
+      # end
+
+    end
+  end
+end

data/lib/active_record/framing/spawn_methods.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module Framing
+    module SpawnMethods
+
+      def merge!(other) # :nodoc:
+        super.tap do |rel|
+          rel.frames_values = rel.frames_values.merge(other.frames_values)
+        end
+      end
+
+    end
+  end
+end

data/lib/active_record/framing/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Framing
+    VERSION = "0.1.0-1"
+  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

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: active_record-framing
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre.1
+platform: ruby
+authors:
+- Dale Stevens
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6'
+- !ruby/object:Gem::Dependency
+  name: pg
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: Allows for larger level scoping (framing) that affect complicated queries
+  more holistically
+email:
+- dale@twilightcoders.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/active_record/framing.rb
+- lib/active_record/framing/attribute_methods.rb
+- lib/active_record/framing/core_extension.rb
+- lib/active_record/framing/default.rb
+- lib/active_record/framing/named.rb
+- lib/active_record/framing/query_methods.rb
+- lib/active_record/framing/railtie.rb
+- lib/active_record/framing/relation.rb
+- lib/active_record/framing/spawn_methods.rb
+- lib/active_record/framing/version.rb
+homepage: https://github.com/TwilightCoders/active_record-framing
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Provides larger level scopes (frames) through the use of common table expressions.
+test_files: []