rails_select_on_includes 0.5.2 → 0.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 63afc846674a71d9b60199a542ac6842ad09c134
-  data.tar.gz: f7c43c0cbfdae603b95c066f6e6575ad161b1e90
+  metadata.gz: 5f26d06137a196f73e828264c19083cbd2c40dd6
+  data.tar.gz: 5bc21a1aa9c61a595c87afcdd6d6d6e2e00a192f
 SHA512:
-  metadata.gz: 3e469be7fdc9d1b389a3a20647baf475dfe8f625f84ee560b4d9c348af5b87db06064402e3453fce553fbe8bc3675def092a4c93bf6211872aaf73d61611f8f4
-  data.tar.gz: c7cf417cc7771e2d9248e02092678e214d4012a6a003a67680e3ba29125898dd697c18f31ee5bee8d5288e6a6e6e829c9dbc4d434a3ab6033f505ad86d95b60e
+  metadata.gz: f2ca94a77cdac843e6b63b2ed5e1ab6158c6165dd4782d4fae5ec72bcce839c94dac1c8b552aec9624df2501e780d9a4b4a9a1f63e682155313ff50cb26e1707
+  data.tar.gz: f299a77e138a5dc2acaafa8f72d8b656e94894cfd5b7d13f17ea6d38e651c3f8bf0365cb19e302d73435f714aaaec35af4430ff4c808645241b75f9949e93dec

data/lib/rails_select_on_includes.rb

@@ -1,141 +1,272 @@
 require 'active_support/deprecation'
 require 'active_support/core_ext/string/filters'
 
-module ActiveRecord
-  module Associations
-    class JoinDependency # :nodoc:
-      class Aliases # :nodoc:
-        def initialize(tables)
-          @tables = tables
-          @alias_cache = tables.each_with_object({}) { |table,h|
-            h[table.node] = table.columns.each_with_object({}) { |column,i|
-              i[column.name] = column.alias
-            }
-          }
-          @name_and_alias_cache = tables.each_with_object({}) { |table,h|
-            h[table.node] = table.columns.map { |column|
-              [column.name, column.alias]
-            }
-            @base_class_node_aliases ||= h[table.node] if table.node.is_a?(ActiveRecord::Associations::JoinDependency::JoinBase)
-          }
-
-          @virtual_attributes_names = []
-        end
-        # valid formats are:
-        # 1 'table_name.column' or 'table_name.column as column_1' will be parsed! distinct on can be used also
-        # 2 {table_name: column} or { table_name: [column1, column2] }
-        # 3 table_name: 2
-        def update_aliases_to_select_values( select_values )
-          return if select_values.blank?
-          select_values.each do |sv|
-            # if sv is symbol that we assume that its a base table column and it will be aliased and added as usual
-            # all we need is some specials joins+select from related tables
-            if sv.is_a?(Hash)
-              flatten_hash_values(sv).each{|sub_sv| @base_class_node_aliases << [sub_sv, sub_sv]; @virtual_attributes_names << sub_sv }
-            elsif sv.is_a?(String)
-              # this is the case of long raw select
-              sv.split( ", " ).each do |sub_sv|
-                if sub_sv[/.+ as .+/i]
-                  selected_column = sub_sv[/ as .+/i][4..-1]
-                  @base_class_node_aliases << [selected_column, selected_column]
-                  @virtual_attributes_names << selected_column
-                elsif sub_sv[/.+\.[^\*]+/]
-                  selected_column = sub_sv[/\..+/][1..-1]
-                  @base_class_node_aliases << [selected_column, selected_column]
-                  @virtual_attributes_names << selected_column
-                end
-              end
-            end
+::ActiveRecord::Associations::JoinDependency::Aliases.class_eval do
+  def initialize(tables)
+    @tables = tables
+    @alias_cache = tables.each_with_object({}) { |table,h|
+      h[table.node] = table.columns.each_with_object({}) { |column,i|
+        i[column.name] = column.alias
+      }
+    }
+    @name_and_alias_cache = tables.each_with_object({}) { |table,h|
+      h[table.node] = table.columns.map { |column|
+        [column.name, column.alias]
+      }
+      @base_class_node_aliases ||= h[table.node] if table.node.is_a?(ActiveRecord::Associations::JoinDependency::JoinBase)
+    }
+
+    @virtual_attributes_names = []
+  end
+  # valid formats are:
+  # 1 'table_name.column' or 'table_name.column as column_1' will be parsed! distinct on can be used also
+  # 2 {table_name: column} or { table_name: [column1, column2] }
+  # 3 table_name: 2
+  def update_aliases_to_select_values( select_values )
+    return if select_values.blank?
+    select_values.each do |sv|
+      # if sv is symbol that we assume that its a base table column and it will be aliased and added as usual
+      # all we need is some specials joins+select from related tables
+      if sv.is_a?(Hash)
+        flatten_hash_values(sv).each{|sub_sv| @base_class_node_aliases << [sub_sv, sub_sv]; @virtual_attributes_names << sub_sv }
+      elsif sv.is_a?(String)
+        # this is the case of long raw select
+        sv.split( ", " ).each do |sub_sv|
+          if sub_sv[/.+ as .+/i]
+            selected_column = sub_sv[/ as .+/i][4..-1]
+            @base_class_node_aliases << [selected_column, selected_column]
+            @virtual_attributes_names << selected_column
+          elsif sub_sv[/.+\.[^\*]+/]
+            selected_column = sub_sv[/\..+/][1..-1]
+            @base_class_node_aliases << [selected_column, selected_column]
+            @virtual_attributes_names << selected_column
           end
         end
+      end
+    end
+  end
 
-        def slice_selected_attr_types( column_types )
-          column_types.slice( *@virtual_attributes_names )
-        end
+  def slice_selected_attr_types( column_types )
+    column_types.slice( *@virtual_attributes_names )
+  end
 
-        private
-        def flatten_hash_values( some_hash )
-          some_hash.values.map{ |value| value.is_a?(Hash) ? flatten_hash_values( value ) : value }.flatten
-        end
-      end
+  private
+  def flatten_hash_values( some_hash )
+    some_hash.values.map{ |value| value.is_a?(Hash) ? flatten_hash_values( value ) : value }.flatten
+  end
+end
 
-      class JoinPart
-        def instantiate(row, aliases, column_types = {}, &block)
-          base_klass.instantiate(extract_record(row, aliases), column_types, &block)
-        end
-      end
+::ActiveRecord::Associations::JoinDependency::JoinPart.class_eval do
+  def instantiate(row, aliases, column_types = {}, &block)
+    base_klass.instantiate(extract_record(row, aliases), column_types, &block)
+  end
+end
 
-      def instantiate(result_set, aliases)
-        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
-
-        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
-            # DISTINCTION PART > join_root.instantiate(row_hash, column_aliases, aliases.slice_selected_attr_types( result_set.column_types ) )
-            # PREVIOUS         > join_root.instantiate(row_hash, column_aliases )
-            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, aliases.slice_selected_attr_types( result_set.column_types ) )
-            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
-          }
-        end
-        parents.values
-      end
+::ActiveRecord::Associations::JoinDependency.class_eval do
+  def instantiate(result_set, aliases)
+  primary_key = aliases.column_alias(join_root, join_root.primary_key)
 
-    end
+  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
+
+  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
+      # DISTINCTION PART > join_root.instantiate(row_hash, column_aliases, aliases.slice_selected_attr_types( result_set.column_types ) )
+      # PREVIOUS         > join_root.instantiate(row_hash, column_aliases )
+      parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, aliases.slice_selected_attr_types( result_set.column_types ) )
+      construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+    }
   end
+  parents.values
+end
 end
 
-module ActiveRecord
-  module FinderMethods
-
-    def find_with_associations
-        # NOTE: the JoinDependency constructed here needs to know about
-        #       any joins already present in `self`, so pass them in
-        #
-        # failing to do so means that in cases like activerecord/test/cases/associations/inner_join_association_test.rb:136
-        # incorrect SQL is generated. In that case, the join dependency for
-        # SpecialCategorizations is constructed without knowledge of the
-        # preexisting join in joins_values to categorizations (by way of
-        # the `has_many :through` for categories).
-        #
-        join_dependency = construct_join_dependency(joins_values)
-
-        aliases  = join_dependency.aliases
-        relation = select aliases.columns
-        relation = apply_join_dependency(relation, join_dependency)
-
-        if block_given?
-          yield relation
-        else
-          if ActiveRecord::NullRelation === relation
-            []
-          else
-            arel = relation.arel
-            rows = connection.select_all(arel, 'SQL', relation.bound_attributes)
-            #1 DISTINCTION IS HERE:
-            # now we gently mokey-patching existing column aliases with select values
-            aliases.update_aliases_to_select_values(values[:select]) unless values[:select].blank?
-
-            join_dependency.instantiate(rows, aliases)
-          end
-        end
+
+::ActiveRecord::FinderMethods.class_eval do
+  def find_with_associations
+    # NOTE: the JoinDependency constructed here needs to know about
+    #       any joins already present in `self`, so pass them in
+    #
+    # failing to do so means that in cases like activerecord/test/cases/associations/inner_join_association_test.rb:136
+    # incorrect SQL is generated. In that case, the join dependency for
+    # SpecialCategorizations is constructed without knowledge of the
+    # preexisting join in joins_values to categorizations (by way of
+    # the `has_many :through` for categories).
+    #
+    join_dependency = construct_join_dependency(joins_values)
+
+    aliases  = join_dependency.aliases
+    relation = select aliases.columns
+    relation = apply_join_dependency(relation, join_dependency)
+
+    if block_given?
+      yield relation
+    else
+      if ActiveRecord::NullRelation === relation
+        []
+      else
+        arel = relation.arel
+        rows = connection.select_all(arel, 'SQL', relation.bound_attributes)
+        #1 DISTINCTION IS HERE:
+        # now we gently mokey-patching existing column aliases with select values
+        aliases.update_aliases_to_select_values(values[:select]) unless values[:select].blank?
+
+        join_dependency.instantiate(rows, aliases)
+      end
     end
   end
 end
 
+# module ActiveRecord
+#   module Associations
+#     class JoinDependency # :nodoc:
+#       # class Aliases # :nodoc:
+#       #   def initialize(tables)
+#       #     @tables = tables
+#       #     @alias_cache = tables.each_with_object({}) { |table,h|
+#       #       h[table.node] = table.columns.each_with_object({}) { |column,i|
+#       #         i[column.name] = column.alias
+#       #       }
+#       #     }
+#       #     @name_and_alias_cache = tables.each_with_object({}) { |table,h|
+#       #       h[table.node] = table.columns.map { |column|
+#       #         [column.name, column.alias]
+#       #       }
+#       #       @base_class_node_aliases ||= h[table.node] if table.node.is_a?(ActiveRecord::Associations::JoinDependency::JoinBase)
+#       #     }
+#       #
+#       #     @virtual_attributes_names = []
+#       #   end
+#       #   # valid formats are:
+#       #   # 1 'table_name.column' or 'table_name.column as column_1' will be parsed! distinct on can be used also
+#       #   # 2 {table_name: column} or { table_name: [column1, column2] }
+#       #   # 3 table_name: 2
+#       #   def update_aliases_to_select_values( select_values )
+#       #     return if select_values.blank?
+#       #     select_values.each do |sv|
+#       #       # if sv is symbol that we assume that its a base table column and it will be aliased and added as usual
+#       #       # all we need is some specials joins+select from related tables
+#       #       if sv.is_a?(Hash)
+#       #         flatten_hash_values(sv).each{|sub_sv| @base_class_node_aliases << [sub_sv, sub_sv]; @virtual_attributes_names << sub_sv }
+#       #       elsif sv.is_a?(String)
+#       #         # this is the case of long raw select
+#       #         sv.split( ", " ).each do |sub_sv|
+#       #           if sub_sv[/.+ as .+/i]
+#       #             selected_column = sub_sv[/ as .+/i][4..-1]
+#       #             @base_class_node_aliases << [selected_column, selected_column]
+#       #             @virtual_attributes_names << selected_column
+#       #           elsif sub_sv[/.+\.[^\*]+/]
+#       #             selected_column = sub_sv[/\..+/][1..-1]
+#       #             @base_class_node_aliases << [selected_column, selected_column]
+#       #             @virtual_attributes_names << selected_column
+#       #           end
+#       #         end
+#       #       end
+#       #     end
+#       #   end
+#       #
+#       #   def slice_selected_attr_types( column_types )
+#       #     column_types.slice( *@virtual_attributes_names )
+#       #   end
+#       #
+#       #   private
+#       #   def flatten_hash_values( some_hash )
+#       #     some_hash.values.map{ |value| value.is_a?(Hash) ? flatten_hash_values( value ) : value }.flatten
+#       #   end
+#       # end
+#
+#       # class JoinPart
+#       #   def instantiate(row, aliases, column_types = {}, &block)
+#       #     base_klass.instantiate(extract_record(row, aliases), column_types, &block)
+#       #   end
+#       # end
+#
+#       # def instantiate(result_set, aliases)
+#       #   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
+#       #
+#       #   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
+#       #       # DISTINCTION PART > join_root.instantiate(row_hash, column_aliases, aliases.slice_selected_attr_types( result_set.column_types ) )
+#       #       # PREVIOUS         > join_root.instantiate(row_hash, column_aliases )
+#       #       parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, aliases.slice_selected_attr_types( result_set.column_types ) )
+#       #       construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+#       #     }
+#       #   end
+#       #   parents.values
+#       # end
+#
+#     end
+#   end
+# end
+
+# module ActiveRecord
+#   module FinderMethods
+#
+#     # def find_with_associations
+#     #     # NOTE: the JoinDependency constructed here needs to know about
+#     #     #       any joins already present in `self`, so pass them in
+#     #     #
+#     #     # failing to do so means that in cases like activerecord/test/cases/associations/inner_join_association_test.rb:136
+#     #     # incorrect SQL is generated. In that case, the join dependency for
+#     #     # SpecialCategorizations is constructed without knowledge of the
+#     #     # preexisting join in joins_values to categorizations (by way of
+#     #     # the `has_many :through` for categories).
+#     #     #
+#     #     join_dependency = construct_join_dependency(joins_values)
+#     #
+#     #     aliases  = join_dependency.aliases
+#     #     relation = select aliases.columns
+#     #     relation = apply_join_dependency(relation, join_dependency)
+#     #
+#     #     if block_given?
+#     #       yield relation
+#     #     else
+#     #       if ActiveRecord::NullRelation === relation
+#     #         []
+#     #       else
+#     #         arel = relation.arel
+#     #         rows = connection.select_all(arel, 'SQL', relation.bound_attributes)
+#     #         #1 DISTINCTION IS HERE:
+#     #         # now we gently mokey-patching existing column aliases with select values
+#     #         aliases.update_aliases_to_select_values(values[:select]) unless values[:select].blank?
+#     #
+#     #         join_dependency.instantiate(rows, aliases)
+#     #       end
+#     #     end
+#     # end
+#   end
+# end
+

data/lib/rails_select_on_includes/version.rb

@@ -1,3 +1,3 @@
 module RailsSelectOnIncludes
-  VERSION = "0.5.2"
+  VERSION = "0.5.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails_select_on_includes
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors:
 - alekseyl
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-14 00:00:00.000000000 Z
+date: 2017-02-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord