activerecord-virtual_attributes 1.0.0

data/gemfiles/virtual_attributes_51.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.1.6"
+gem "sqlite3", "~> 1.3.6"
+gem "pg"
+gem "mysql2"
+
+gemspec path: "../"

data/gemfiles/virtual_attributes_52.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "activerecord", "~> 5.2.0"
+gem "sqlite3"
+gem "pg"
+gem "mysql2"
+
+gemspec path: "../"

data/init.rb

@@ -0,0 +1 @@
+require 'virtual_attributes'

data/lib/active_record-virtual_attributes.rb

@@ -0,0 +1 @@
+require "active_record/virtual_attributes"

data/lib/active_record/virtual_attributes.rb

@@ -0,0 +1,143 @@
+require "active_support/concern"
+require "active_record"
+
+require "active_record/virtual_attributes/virtual_includes"
+require "active_record/virtual_attributes/virtual_arel"
+require "active_record/virtual_attributes/virtual_delegates"
+
+module ActiveRecord
+  module VirtualAttributes
+    extend ActiveSupport::Concern
+    include ActiveRecord::VirtualAttributes::VirtualIncludes
+    include ActiveRecord::VirtualAttributes::VirtualArel
+    include ActiveRecord::VirtualAttributes::VirtualDelegates
+
+    module Type
+      # TODO: do we actually need symbol types?
+      class Symbol < ActiveRecord::Type::String
+        def type; :symbol; end
+      end
+
+      class StringSet < ActiveRecord::Type::Value
+        def type; :string_set; end
+      end
+
+      class NumericSet < ActiveRecord::Type::Value
+        def type; :numeric_set; end
+      end
+    end
+
+    ActiveRecord::Type.register(:numeric_set, Type::NumericSet)
+    ActiveRecord::Type.register(:string_set, Type::StringSet)
+    ActiveRecord::Type.register(:symbol, Type::Symbol)
+
+    included do
+      class_attribute :virtual_attributes_to_define, :instance_accessor => false
+      self.virtual_attributes_to_define = {}
+    end
+
+    module ClassMethods
+
+      #
+      # Definition
+      #
+
+      # Compatibility method: `virtual_attribute` is a more accurate name
+      def virtual_column(name, type_or_options, **options)
+        if type_or_options.kind_of?(Hash)
+          options = options.merge(type_or_options)
+          type = options.delete(:type)
+        else
+          type = type_or_options
+        end
+
+        virtual_attribute(name, type, **options)
+      end
+
+      def virtual_attribute(name, type, **options)
+        name = name.to_s
+        reload_schema_from_cache
+
+        self.virtual_attributes_to_define =
+          virtual_attributes_to_define.merge(name => [type, options])
+      end
+
+      #
+      # Introspection
+      #
+
+      def virtual_attribute?(name)
+        load_schema
+        has_attribute?(name) && (
+          !respond_to?(:column_for_attribute) ||
+          column_for_attribute(name).kind_of?(ActiveRecord::ConnectionAdapters::NullColumn)
+        )
+      end
+
+      def virtual_attribute_names
+        if respond_to?(:column_names)
+          attribute_names - column_names
+        else
+          attribute_names
+        end
+      end
+
+      def attributes_builder # :nodoc:
+        unless defined?(@attributes_builder) && @attributes_builder
+          defaults = _default_attributes.except(*(column_names - [primary_key]))
+          # change necessary for rails 5.0 and 5.1 - (changed/introduced in https://github.com/rails/rails/pull/31894)
+          defaults = defaults.except(*virtual_attribute_names)
+          # end change
+          @attributes_builder = ActiveRecord::AttributeSet::Builder.new(attribute_types, defaults)
+        end
+        @attributes_builder
+      end
+
+      private
+
+      def load_schema!
+        super
+
+        virtual_attributes_to_define.each do |name, (type, options)|
+          type = type.call if type.respond_to?(:call)
+          type = ActiveRecord::Type.lookup(type, **options.except(:uses, :arel)) if type.kind_of?(Symbol)
+
+          define_virtual_attribute(name, type, **options.slice(:uses, :arel))
+        end
+
+        virtual_delegates_to_define.each do |method_name, (method, options)|
+          define_virtual_delegate(method_name, method, options)
+        end
+      end
+
+      def define_virtual_attribute(name, cast_type, uses: nil, arel: nil)
+        attribute_types[name] = cast_type
+        define_virtual_include(name, uses) if uses
+        define_virtual_arel(name, arel) if arel
+      end
+    end
+  end
+end
+require "active_record/virtual_attributes/virtual_reflections"
+require "active_record/virtual_attributes/virtual_fields"
+
+#
+# Class extensions
+#
+
+# this patch is no longer necessary for 5.2
+if ActiveRecord.version.to_s < "5.2"
+require "active_record/attribute"
+module ActiveRecord
+  # This is a bug in rails 5.0 and 5.1, but it is made much worse by virtual attributes
+  class Attribute
+    def with_value_from_database(value)
+      # self.class.from_database(name, value, type)
+      initialized? ? self.class.from_database(name, value, type) : self
+    end
+  end
+end
+end
+
+require "active_record/virtual_attributes/virtual_total"
+require "active_record/virtual_attributes/arel_groups"

data/lib/active_record/virtual_attributes/arel_groups.rb

@@ -0,0 +1,14 @@
+# this is from https://github.com/rails/arel/pull/435
+# this allows sorting and where clauses to work with virtual_attribute columns
+if defined?(Arel::Nodes::Grouping)
+  module Arel
+    module Nodes
+      class Grouping
+        include Arel::Expressions
+        include Arel::AliasPredication
+        include Arel::OrderPredications
+        include Arel::Math
+      end
+    end
+  end
+end

data/lib/active_record/virtual_attributes/rspec.rb

@@ -0,0 +1 @@
+require "active_record/virtual_attributes/rspec/have_virtual_attribute"

data/lib/active_record/virtual_attributes/rspec/have_virtual_attribute.rb

@@ -0,0 +1,44 @@
+# TODO: expose this to classes that include this gem
+
+# legacy matcher
+RSpec::Matchers.define :have_virtual_column do |name, type|
+  match do |klass|
+    expect(klass.has_attribute?(name)).to be_truthy
+    expect(klass.virtual_attribute?(name)).to be_truthy
+    expect(klass.type_for_attribute(name).type).to eq(type)
+    klass.instance_methods.include?(name.to_sym)
+  end
+
+  failure_message do |klass|
+    "expected #{klass.name} to have virtual column #{name.inspect} with type #{type.inspect}"
+  end
+
+  failure_message_when_negated do |klass|
+    "expected #{klass.name} to not have virtual column #{name.inspect} with type #{type.inspect}"
+  end
+
+  description do
+    "expect the object to have the virtual column"
+  end
+end
+
+RSpec::Matchers.define :have_virtual_attribute do |name, type|
+  match do |klass|
+    expect(klass.has_attribute?(name)).to be_truthy
+    expect(klass.virtual_attribute?(name)).to be_truthy
+    expect(klass.type_for_attribute(name).type).to eq(type)
+    klass.instance_methods.include?(name.to_sym)
+  end
+
+  failure_message do |klass|
+    "expected #{klass.name} to have virtual column #{name.inspect} with type #{type.inspect}"
+  end
+
+  failure_message_when_negated do |klass|
+    "expected #{klass.name} to not have virtual column #{name.inspect} with type #{type.inspect}"
+  end
+
+  description do
+    "expect the object to have the virtual column"
+  end
+end

data/lib/active_record/virtual_attributes/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module VirtualAttributes
+    VERSION = "1.0.0"
+  end
+end

data/lib/active_record/virtual_attributes/virtual_arel.rb

@@ -0,0 +1,48 @@
+module ActiveRecord
+  module VirtualAttributes
+    # VirtualArel associates arel with an attribute
+    #
+    # Model.virtual_attribute :field, :string, :arel => -> (t) { t.grouping(t[:field2]) } }
+    # Model.select(:field)
+    #
+    # is equivalent to:
+    #
+    # Model.select(Model.arel_table.grouping(Model.arel_table[:field2]).as(:field))
+    # Model.attribute_supported_by_sql?(:field) # => true
+    module VirtualArel
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :_virtual_arel, :instance_accessor => false
+        self._virtual_arel = {}
+      end
+
+      module ClassMethods
+        def arel_attribute(column_name, arel_table = self.arel_table)
+          load_schema
+          if virtual_attribute?(column_name) && !attribute_alias?(column_name)
+            col = _virtual_arel[column_name.to_s]
+            col.call(arel_table) if col
+          else
+            super
+          end
+        end
+
+        # supported by sql if
+        # - it is an attribute alias
+        # - it is an attribute that is non virtual
+        # - it is an attribute that is virtual and has arel defined
+        def attribute_supported_by_sql?(name)
+          load_schema
+          try(:attribute_alias?, name) ||
+            (has_attribute?(name) && (!virtual_attribute?(name) || !!_virtual_arel[name.to_s]))
+        end
+        private
+
+        def define_virtual_arel(name, arel)
+          self._virtual_arel = _virtual_arel.merge(name => arel)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/virtual_attributes/virtual_delegates.rb

@@ -0,0 +1,276 @@
+module ActiveRecord
+  module VirtualAttributes
+    # VirtualDelegate is the same as delegate, but adds sql support, and a default when a value is not found
+    #
+    # Model.belongs_to :association
+    # Model.virtual_delegate :field1, :field2, to: :association
+    #
+    # Model.select(:field1) # now works
+    module VirtualDelegates
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :virtual_delegates_to_define, :instance_accessor => false
+        self.virtual_delegates_to_define = {}
+      end
+
+      module ClassMethods
+
+        #
+        # Definition
+        #
+
+        def virtual_delegate(*methods)
+          options = methods.extract_options!
+          unless (to = options[:to])
+            raise ArgumentError, 'Delegation needs an association. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter).'
+          end
+
+          to = to.to_s
+          if to.include?(".") && methods.size > 1
+            raise ArgumentError, 'Delegation only supports specifying a method name when defining a single virtual method'
+          end
+
+          if to.count(".") > 1
+            raise ArgumentError, 'Delegation needs a single association. Supply an option hash with a :to key with only 1 period (e.g. delegate :hello, to: "greeter.greeting")'
+          end
+
+          allow_nil = options[:allow_nil]
+          default = options[:default]
+
+          # put method entry per method name.
+          # This better supports reloading of the class and changing the definitions
+          methods.each do |method|
+            method_prefix = virtual_delegate_name_prefix(options[:prefix], to)
+            method_name = "#{method_prefix}#{method}"
+            if to.include?(".") # to => "target.method"
+              to, method = to.split(".")
+              options[:to] = to
+            end
+
+            define_delegate(method_name, method, :to => to, :allow_nil => allow_nil, :default => default)
+
+            self.virtual_delegates_to_define =
+              virtual_delegates_to_define.merge(method_name => [method, options])
+          end
+        end
+
+        private
+
+        # define virtual_attribute for delegates
+        #
+        # this is called at schema load time (and not at class definition time)
+        #
+        # @param  method_name [Symbol] name of the attribute on the source class to be defined
+        # @param  col [Symbol] name of the attribute on the associated class to be referenced
+        # @option options :to [Symbol] name of the association from the source class to be referenced
+        # @option options :arel [Proc] (optional and not common)
+        # @option options :uses [Array|Symbol|Hash] sql includes hash. (default: to)
+        def define_virtual_delegate(method_name, col, options)
+          unless (to = options[:to]) && (to_ref = reflection_with_virtual(to.to_s))
+            raise ArgumentError, 'Delegation needs an association. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter).'
+          end
+
+          col = col.to_s
+          type = to_ref.klass.type_for_attribute(col)
+          raise "unknown attribute #{to}##{col} referenced in #{name}" unless type
+          arel = virtual_delegate_arel(col, to_ref)
+          define_virtual_attribute(method_name, type, :uses => (options[:uses] || to), :arel => arel)
+        end
+
+        # see activesupport module/delegation.rb
+        def define_delegate(method_name, method, to: nil, allow_nil: nil, default: nil)
+          location = caller_locations(2, 1).first
+          file, line = location.path, location.lineno
+
+          # Attribute writer methods only accept one argument. Makes sure []=
+          # methods still accept two arguments.
+          definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
+          default = default ? " || #{default.inspect}" : nil
+          # The following generated method calls the target exactly once, storing
+          # the returned value in a dummy variable.
+          #
+          # Reason is twofold: On one hand doing less calls is in general better.
+          # On the other hand it could be that the target has side-effects,
+          # whereas conceptually, from the user point of view, the delegator should
+          # be doing one call.
+          if allow_nil
+            method_def = <<-METHOD
+              def #{method_name}(#{definition})
+                return self[:#{method_name}]#{default} if has_attribute?(:#{method_name})
+                _ = #{to}
+                if !_.nil? || nil.respond_to?(:#{method})
+                  _.#{method}(#{definition})
+                end#{default}
+              end
+            METHOD
+          else
+            exception = %(raise Module::DelegationError, "#{self}##{method_name} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+
+            method_def = <<-METHOD
+              def #{method_name}(#{definition})
+                return self[:#{method_name}]#{default} if has_attribute?(:#{method_name})
+                _ = #{to}
+                _.#{method}(#{definition})#{default}
+              rescue NoMethodError => e
+                if _.nil? && e.name == :#{method}
+                  #{exception}
+                else
+                  raise
+                end
+              end
+            METHOD
+          end
+          method_def = method_def.split("\n").map(&:strip).join(';')
+          module_eval(method_def, file, line)
+        end
+
+        def virtual_delegate_name_prefix(prefix, to)
+          "#{prefix == true ? to : prefix}_" if prefix
+        end
+
+        # @param col [String] attribute name
+        # @param to_ref [Association] association from source class to target association
+        # @return [Proc] lambda to return arel that selects the attribute in a sub-query
+        # @return [Nil] if the attribute (col) can not be represented in sql.
+        #
+        # To generate a proc, the following cases must happen:
+        #   - the column has sql (virtual_column with arel OR real sql attribute)
+        #   - the association has sql representation (a real association has sql)
+        #   - the association is to a single record (has_one or belongs_to)
+        #
+        #   See select_from_alias for examples
+
+        def virtual_delegate_arel(col, to_ref)
+          # ensure the column has sql and the association is reachable via sql
+          # There is currently no way to propagate sql over a virtual association
+          if to_ref.klass.arel_attribute(col) && reflect_on_association(to_ref.name)
+            if to_ref.macro == :has_one || to_ref.macro == :belongs_to
+              blk = ->(arel) { arel.limit = 1 } if to_ref.macro == :has_one
+              lambda do |t|
+                if ActiveRecord.version.to_s >= "5.1"
+                  join_keys = to_ref.join_keys
+                else
+                  join_keys = to_ref.join_keys(to_ref.klass)
+                end
+                src_model_id = arel_attribute(join_keys.foreign_key, t)
+                VirtualDelegates.select_from_alias(to_ref, col, join_keys.key, src_model_id, &blk)
+              end
+            end
+          end
+        end
+      end
+
+      # select_from_alias: helper method for virtual_delegate_arel to construct the sql
+      # see also virtual_delegate_arel
+      #
+      # @param to_ref [Association] association from source class to target association
+      # @param col [String] attribute name
+      # @param to_model_col_name [String]
+      # @param src_model_id [Arel::Attribute]
+      # @return [Arel::Node] Arel representing the sql for this join
+      #
+      # example
+      #
+      #   for the given belongs_to class definition:
+      #
+      #     class Vm
+      #       belongs_to :hosts #, :foreign_key => :host_id, :primary_key => :id
+      #       virtual_delegate :name, :to => :host, :prefix => true, :allow_nil => true
+      #     end
+      #
+      #   The virtual_delegate calls:
+      #
+      #     virtual_delegate_arel("name", Vm.reflection_with_virtual(:host))
+      #
+      #   which calls:
+      #
+      #     select_from_alias(Vm.reflection_with_virtual(:host), "name", "id", Vm.arel_table[:host_id])
+      #
+      #   which produces the sql:
+      #
+      #     SELECT to_model[col] from to_model where to_model[to_model_col_name] = src_model_table[:src_model_id]
+      #     (SELECT "hosts"."name" FROM "hosts" WHERE "hosts"."id" = "vms"."host_id")
+      #
+      #   ----
+      #
+      #   for the given has_one class definition
+      #
+      #     class Host
+      #       has_one :hardware
+      #       virtual_delegate :name, :to => :hardware, :prefix => true, :allow_nil => true
+      #     end
+      #
+      #   The virtual_delegate calls:
+      #
+      #     virtual_delegate_arel("name", Host.reflection_with_virtual(:hardware))
+      #
+      #   which at runtime will call select_from_alias:
+      #
+      #     select_from_alias(Host.reflection_with_virtual(:hardware), "name", "host_id", Host.arel_table[:id])
+      #
+      #   which produces the sql (ala arel):
+      #
+      #     #select to_model[col] from to_model where to_model[to_model_col_name] = src_model_table[:src_model_id]
+      #     (SELECT "hardwares"."name" FROM "hardwares" WHERE "hardwares"."host_id" = "hosts"."id")
+      #
+      #   ----
+      #
+      #   for the given self join class definition:
+      #
+      #     class Vm
+      #       belongs_to :src_template, :class => Vm
+      #       virtual_delegate :name, :to => :src_template, :prefix => true, :allow_nil => true
+      #     end
+      #
+      #   The virtual_delegate calls:
+      #
+      #     virtual_delegate_arel("name", Vm.reflection_with_virtual(:src_template))
+      #
+      #   which calls:
+      #
+      #     select_from_alias(Vm.reflection_with_virtual(:src_template), "name", "src_template_id", Vm.arel_table[:id])
+      #
+      #   which produces the sql:
+      #
+      #     #select to_model[col] from to_model where to_model[to_model_col_name] = src_model_table[:src_model_id]
+      #     (SELECT "vms_sub"."name" FROM "vms" AS "vms_ss" WHERE "vms_ss"."id" = "vms"."src_template_id")
+      #
+
+      def self.select_from_alias(to_ref, col, to_model_col_name, src_model_id)
+        query = if to_ref.scope
+                  to_ref.klass.instance_exec(nil, &to_ref.scope)
+                else
+                  to_ref.klass.all
+                end
+
+        to_table    = select_from_alias_table(to_ref.klass, src_model_id.relation)
+        to_model_id = to_ref.klass.arel_attribute(to_model_col_name, to_table)
+        to_column   = to_ref.klass.arel_attribute(col, to_table)
+        arel        = query.except(:select).select(to_column).arel
+                           .from(to_table)
+                           .where(to_model_id.eq(src_model_id))
+
+        yield arel if block_given?
+
+        Arel.sql("(#{arel.to_sql})")
+      end
+
+      # determine table reference to use for a sub query
+      #
+      # typically to_table is just the table used for the to_ref
+      # but if it is a self join, then it will also have an alias
+      def self.select_from_alias_table(to_klass, src_relation)
+        to_table = to_klass.arel_table
+        # if a self join, alias the second table to a different name
+        if to_table.table_name == src_relation.table_name
+          # use a dup to not modify the primary table in the model
+          to_table = to_table.dup
+          # use a table alias to not conflict with table name in the primary query
+          to_table.table_alias = "#{to_table.table_name}_sub"
+        end
+        to_table
+      end
+    end
+  end
+end