activerecord-virtual_attributes 1.0.0

data/lib/active_record/virtual_attributes/virtual_fields.rb

@@ -0,0 +1,234 @@
+module ActiveRecord
+  module VirtualAttributes
+    module VirtualFields
+      extend ActiveSupport::Concern
+      include ActiveRecord::VirtualAttributes
+      include ActiveRecord::VirtualAttributes::VirtualReflections
+
+      module NonARModels
+        def dangerous_attribute_method?(_); false; end
+
+        def generated_association_methods; self; end
+
+        def add_autosave_association_callbacks(*_args); self; end
+
+        def belongs_to_required_by_default; false; end
+      end
+
+      included do
+        unless respond_to?(:dangerous_attribute_method?)
+          extend NonARModels
+        end
+      end
+
+      module ClassMethods
+        def virtual_fields_base?
+          !(superclass < VirtualFields)
+        end
+
+        def virtual_field?(name)
+          virtual_attribute?(name) || virtual_reflection?(name)
+        end
+
+        def remove_virtual_fields(associations)
+          case associations
+          when String, Symbol
+            virtual_field?(associations) ? nil : associations
+          when Array
+            associations.collect { |association| remove_virtual_fields(association) }.compact
+          when Hash
+            associations.each_with_object({}) do |(parent, child), h|
+              next if virtual_field?(parent)
+              reflection = reflect_on_association(parent.to_sym)
+              h[parent] = reflection.options[:polymorphic] ? nil : reflection.klass.remove_virtual_fields(child) if reflection
+            end
+          else
+            associations
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class Base
+    include ActiveRecord::VirtualAttributes::VirtualFields
+  end
+
+  module Associations
+    class Preloader
+      prepend Module.new {
+        def preloaders_for_one(association, records, scope)
+          klass_map = records.compact.group_by(&:class)
+
+          loaders = klass_map.keys.group_by { |klass| klass.virtual_includes(association) }.flat_map do |virtuals, klasses|
+            subset = klasses.flat_map { |klass| klass_map[klass] }
+            preload(subset, virtuals)
+          end
+
+          records_with_association = klass_map.select { |k, rs| k.reflect_on_association(association) }.flat_map { |k, rs| rs }
+          if records_with_association.any?
+            loaders.concat(super(association, records_with_association, scope))
+          end
+
+          loaders
+        end
+      }
+    end
+
+    # FIXME: Hopefully we can get this into Rails core so this is no longer
+    # required in our codebase, but the rule that are broken here are mostly
+    # due to the style of the Rails codebase conflicting with our own.
+    # Ignoring them to avoid noise in RuboCop, but allow us to keep the same
+    # syntax from the original codebase.
+    #
+    # rubocop:disable Style/BlockDelimiters, Layout/SpaceAfterComma, Style/HashSyntax
+    # rubocop:disable Layout/AlignHash, Metrics/AbcSize, Metrics/MethodLength
+    class JoinDependency
+      def instantiate(result_set, *_, &block)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+
+        seen = Hash.new { |i, object_id|
+          i[object_id] = Hash.new { |j, child_class|
+            j[child_class] = {}
+          }
+        }
+
+        model_cache = Hash.new { |h,klass| h[klass] = {} }
+        parents = model_cache[join_root]
+        column_aliases = aliases.column_aliases(join_root)
+
+        # New Code
+        #
+        # This monkey patches the ActiveRecord::Associations::JoinDependency to
+        # include columns into the main record that might have been added
+        # through a `select` clause.
+        #
+        # This can be seen with the following:
+        #
+        #   Vm.select(Vm.arel_table[Arel.star]).select(:some_vm_virtual_col)
+        #     .includes(:tags => {}).references(:tags => {})
+        #
+        # Which will produce a SQL SELECT statement kind of like this:
+        #
+        #   SELECT "vms".*,
+        #          (<virtual_attribute_arel>) AS some_vm_virtual_col,
+        #          "vms"."id"      AS t0_r0
+        #          "vms"."vendor"  AS t0_r1
+        #          "vms"."format"  AS t0_r1
+        #          "vms"."version" AS t0_r1
+        #          ...
+        #          "tags"."id"     AS t1_r0
+        #          "tags"."name"   AS t1_r1
+        #
+        # This is because rails is trying to reduce the number of queries
+        # needed to fetch all of the records in the include, so it grabs the
+        # columns for both of the tables together to do it.  Unfortuantely (or
+        # fortunately... depending on how you look at it), it does not remove
+        # any `.select` columns from the query that is run in the process, so
+        # that is brought along for the ride, but never used when this method
+        # instanciates the objects.
+        #
+        # The "New Code" here simply also instanciates any extra rows that
+        # might have been included in the select (virtual_columns) as well and
+        # brought back with the result set.
+        unless result_set.empty?
+          join_dep_keys         = aliases.columns.map(&:right)
+          join_root_aliases     = column_aliases.map(&:first)
+          additional_attributes = result_set.first.keys
+                                            .reject { |k| join_dep_keys.include?(k) }
+                                            .reject { |k| join_root_aliases.include?(k) }
+                                            .map    { |k| [k, k] }
+          column_aliases += additional_attributes
+        end
+        # End of New Code
+
+        message_bus = ActiveSupport::Notifications.instrumenter
+
+        payload = {
+          record_count: result_set.length,
+          class_name: join_root.base_klass.name
+        }
+
+        message_bus.instrument('instantiation.active_record', payload) do
+          result_set.each { |row_hash|
+            parent_key = primary_key ? row_hash[primary_key] : row_hash
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
+            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+          }
+        end
+
+        parents.values
+      end
+      # rubocop:enable Style/BlockDelimiters, Layout/SpaceAfterComma, Style/HashSyntax
+      # rubocop:enable Layout/AlignHash, Metrics/AbcSize, Metrics/MethodLength
+    end
+  end
+
+  class Relation
+    def without_virtual_includes
+      filtered_includes = includes_values && klass.remove_virtual_fields(includes_values)
+      if filtered_includes != includes_values
+        spawn.tap { |other| other.includes_values = filtered_includes }
+      else
+        self
+      end
+    end
+
+    include(Module.new {
+      # From ActiveRecord::FinderMethods
+      def find_with_associations
+        real = without_virtual_includes
+        return super if real.equal?(self)
+
+        if ActiveRecord.version.to_s >= "5.1"
+          recs, join_dep = real.find_with_associations { |relation, join_dependency| [relation, join_dependency] }
+        else
+          recs = real.find_with_associations
+        end
+        MiqPreloader.preload(recs, preload_values + includes_values) if includes_values
+
+        # when 5.0 support is dropped, assume a block given
+        if block_given?
+          yield recs, join_dep
+        end
+        recs
+      end
+
+      # From ActiveRecord::QueryMethods
+      def select(*fields)
+        return super if block_given? || fields.empty?
+        # support virtual attributes by adding an alias to the sql phrase for the column
+        # it does not add an as() if the column already has an as
+        # this code is based upon _select()
+        fields.flatten!
+        fields.map! do |field|
+          if virtual_attribute?(field) && (arel = klass.arel_attribute(field)) && arel.respond_to?(:as)
+            arel.as(field.to_s)
+          else
+            field
+          end
+        end
+        # end support virtual attributes
+        super
+      end
+
+      # From ActiveRecord::Calculations
+      def calculate(operation, attribute_name)
+        # work around 1 until https://github.com/rails/rails/pull/25304 gets merged
+        # This allows attribute_name to be a virtual_attribute
+        if (arel = klass.arel_attribute(attribute_name)) && virtual_attribute?(attribute_name)
+          attribute_name = arel
+        end
+        # end work around 1
+
+        # allow calculate to work when including a virtual attribute
+        real = without_virtual_includes
+        return super if real.equal?(self)
+
+        real.calculate(operation, attribute_name)
+      end
+    })
+  end
+end

data/lib/active_record/virtual_attributes/virtual_includes.rb

@@ -0,0 +1,33 @@
+module ActiveRecord
+  module VirtualAttributes
+    # VirtualIncludes associates an includes with an attribute
+    #
+    # Model.virtual_attribute :field, :string, :includes => :table
+    # Model.includes(:field)
+    #
+    # is equivalent to:
+    #
+    # Model.includes(:table)
+    module VirtualIncludes
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_virtual_includes, :instance_accessor => false
+        self._virtual_includes = {}
+      end
+
+      module ClassMethods
+        def virtual_includes(name)
+          load_schema
+          _virtual_includes[name.to_s]
+        end
+
+        private
+
+        def define_virtual_include(name, uses)
+          self._virtual_includes = _virtual_includes.merge(name => uses)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/virtual_attributes/virtual_reflections.rb

@@ -0,0 +1,114 @@
+module ActiveRecord
+  module VirtualAttributes
+    module VirtualReflections
+      extend ActiveSupport::Concern
+      include ActiveRecord::VirtualAttributes::VirtualIncludes
+
+      module ClassMethods
+
+        #
+        # Definition
+        #
+
+        def virtual_has_one(name, options = {})
+          uses = options.delete(:uses)
+          reflection = ActiveRecord::Associations::Builder::HasOne.build(self, name, nil, options)
+          add_virtual_reflection(reflection, name, uses, options)
+        end
+
+        def virtual_has_many(name, options = {})
+          define_method("#{name.to_s.singularize}_ids") do
+            records = send(name)
+            records.respond_to?(:ids) ? records.ids : records.collect(&:id)
+          end
+          uses = options.delete(:uses)
+          reflection = ActiveRecord::Associations::Builder::HasMany.build(self, name, nil, options)
+          add_virtual_reflection(reflection, name, uses, options)
+        end
+
+        def virtual_belongs_to(name, options = {})
+          uses = options.delete(:uses)
+          reflection = ActiveRecord::Associations::Builder::BelongsTo.build(self, name, nil, options)
+          add_virtual_reflection(reflection, name, uses, options)
+        end
+
+        def virtual_reflection?(name)
+          virtual_reflections.key?(name.to_sym)
+        end
+
+        def virtual_reflection(name)
+          virtual_reflections[name.to_sym]
+        end
+
+        #
+        # Introspection
+        #
+
+        def virtual_reflections
+          (virtual_fields_base? ? {} : superclass.virtual_reflections).merge(_virtual_reflections)
+        end
+
+        def reflections_with_virtual
+          reflections.symbolize_keys.merge(virtual_reflections)
+        end
+
+        def reflection_with_virtual(association)
+          virtual_reflection(association) || reflect_on_association(association)
+        end
+
+        def follow_associations(association_names)
+          association_names.inject(self) { |klass, name| klass.try!(:reflect_on_association, name).try!(:klass) }
+        end
+
+        def follow_associations_with_virtual(association_names)
+          association_names.inject(self) { |klass, name| klass.try!(:reflection_with_virtual, name).try!(:klass) }
+        end
+
+        # invalid associations return a nil
+        # real reflections are followed
+        # a virtual association will stop the traversal
+        # @returns [nil, Array<Relation>]
+        def collect_reflections(association_names)
+          klass = self
+          association_names.each_with_object([]) do |name, ret|
+            reflection = klass.reflect_on_association(name)
+            if reflection.nil?
+              if klass.reflection_with_virtual(name)
+                break(ret)
+              else
+                break
+              end
+            end
+            klass = reflection.klass
+            ret << reflection
+          end
+        end
+
+        def collect_reflections_with_virtual(association_names)
+          klass = self
+          association_names.collect do |name|
+            reflection = klass.reflection_with_virtual(name) || break
+            klass = reflection.klass
+            reflection
+          end
+        end
+
+        private
+
+        def add_virtual_reflection(reflection, name, uses, _options)
+          raise ArgumentError, "macro must be specified" unless reflection
+          reset_virtual_reflection_information
+          _virtual_reflections[name.to_sym] = reflection
+          define_virtual_include(name.to_s, uses)
+        end
+
+        def reset_virtual_reflection_information
+        end
+
+        def _virtual_reflections
+          @virtual_reflections ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/active_record/virtual_attributes/virtual_total.rb

@@ -0,0 +1,134 @@
+module VirtualAttributes
+  module VirtualTotal
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      private
+
+      # define an attribute to calculating the total of a child
+      def virtual_total(name, relation, options = {})
+        virtual_aggregate(name, relation, :size, nil, options)
+      end
+
+      # define an attribute to calculating the total of a child
+      #
+      #  example 1:
+      #
+      #    class ExtManagementSystem
+      #      has_many :vms
+      #      virtual_total :total_vms, :vms
+      #    end
+      #
+      #    generates:
+      #
+      #    def total_vms
+      #      vms.count
+      #    end
+      #
+      #    virtual_attribute :total_vms, :integer, :uses => :vms, :arel => ...
+      #
+      #   # arel == (SELECT COUNT(*) FROM vms where ems.id = vms.ems_id)
+      #
+      #  example 2:
+      #
+      #    class Hardware
+      #      has_many :disks
+      #      virtual_aggregate :allocated_disk_storage, :disks, :sum, :size
+      #    end
+      #
+      #    generates:
+      #
+      #    def allocated_disk_storage
+      #      if disks.loaded?
+      #        disks.blank? ? nil : disks.map { |t| t.size.to_i }.sum
+      #      else
+      #        disks.sum(:size) || 0
+      #      end
+      #    end
+      #
+      #    virtual_attribute :allocated_disk_storage, :integer, :uses => :disks, :arel => ...
+      #
+      #    # arel => (SELECT sum("disks"."size") where "hardware"."id" = "disks"."hardware_id")
+
+      def virtual_aggregate(name, relation, method_name = :sum, column = nil, options = {})
+        define_virtual_aggregate_method(name, relation, method_name, column)
+        reflection = reflect_on_association(relation)
+
+        if options.key?(:arel)
+          arel = options.dup.delete(:arel)
+          # if there is no relation to get to the arel, have to throw it away
+          arel = nil if !arel || !reflection
+        else
+          arel = virtual_aggregate_arel(reflection, method_name, column)
+        end
+
+        if arel
+          virtual_attribute name, :integer, :uses => options[:uses] || relation, :arel => arel
+        else
+          virtual_attribute name, :integer, **options
+        end
+      end
+
+      def define_virtual_aggregate_method(name, relation, method_name, column)
+        if method_name == :size
+          define_method(name) do
+            (attribute_present?(name) ? self[name] : nil) || send(relation).try(:size) || 0
+          end
+        else
+          define_method(name) do
+            (attribute_present?(name) ? self[name] : nil) ||
+              begin
+                rel = send(relation)
+                if rel.loaded?
+                  rel.blank? ? nil : (rel.map { |t| t.send(column).to_i } || 0).send(method_name)
+                else
+                  # aggregates are not smart enough to handle virtual attributes
+                  arel_column = rel.klass.arel_attribute(column)
+                  rel.try(method_name, arel_column) || 0
+                end
+              end
+          end
+        end
+      end
+
+      def virtual_aggregate_arel(reflection, method_name, column)
+        return unless reflection && reflection.macro == :has_many && !reflection.options[:through]
+        lambda do |t|
+          query = if reflection.scope
+                    reflection.klass.instance_exec(nil, &reflection.scope)
+                  else
+                    reflection.klass.all
+                  end
+
+          # ordering will probably screw up aggregations, so clear this out from
+          # any calls
+          #
+          # only clear this out if this isn't a `:size` call as well, since doing
+          # a COUNT(*) will allow any ORDER BY to still work properly.  This is
+          # to avoid any possible edge cases by clearing out the order clause.
+          query.order_values = [] if method_name != :size
+
+          foreign_table = reflection.klass.arel_table
+          # need db access for the keys, so delaying all this lookup until call time
+          if ActiveRecord.version.to_s >= "5.1"
+            join_keys = reflection.join_keys
+          else
+            join_keys = reflection.join_keys(reflection.klass)
+          end
+          query       = query.where(t[join_keys.foreign_key].eq(foreign_table[join_keys.key]))
+
+          arel_column = if method_name == :size
+                          Arel.star.count
+                        else
+                          reflection.klass.arel_attribute(column).send(method_name)
+                        end
+          query       = query.select(arel_column)
+
+          t.grouping(Arel::Nodes::SqlLiteral.new(query.to_sql))
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send(:include, VirtualAttributes::VirtualTotal)